Optimized Unity Scroll List

A high-performance, pooling-based scroll list system for Unity that efficiently renders 1000+ items in a ScrollView with minimal draw calls and smooth 60+ FPS scrolling, even on low-end devices.

Features

• 🚀 Virtual Scrolling / Object Pooling — only the visible items (plus a small buffer) are instantiated at any time, regardless of the total list size
• 📉 Drastically Reduced Draw Calls — keeps the batch count low by recycling a fixed pool of GameObjects instead of creating one per item
• 📐 Responsive Layout — automatically adapts to screen/viewport size changes
• ↔️ Horizontal & Vertical Support — works with both scroll directions
• 🔔 Lifecycle Callbacks — OnItemShow / OnItemHide actions and UnityEvents let you update item data cleanly
• 🧩 ScriptableObject Architecture — decoupled data (ScriptableVariable<T>) and event (EventSO) system for clean, inspector-driven communication

---

Project Structure

Assets/
├── Prefabs/                        # UI prefabs (inventory item, panels)
├── Resources/
│   ├── Data/                       # ScriptableObject assets
│   │   ├── SelectedItem.asset      # IntSO — currently selected item index
│   │   ├── SelectedData.asset      # InventoryItemsDataSO — full item array
│   │   ├── CurrentSprite.asset     # SpriteSO — current item sprite
│   │   └── events/                 # EventSO assets (data ready, item selected)
│   └── Sprites/
├── Scenes/
│   └── Main.unity                  # Main demo scene
└── Scripts/
    ├── OptmizedList/
    │   ├── ListOptmizer.cs         # Core virtual-scroll / pooling engine
    │   └── OptmizedListItem.cs     # Per-item show/hide UnityEvent hooks
    ├── MonoBehaviours/
    │   ├── InventoryManager.cs     # Loads JSON, generates item data
    │   ├── InventoryHandler.cs     # Connects manager → ListOptmizer
    │   ├── InventoryItem.cs        # Individual item UI logic
    │   ├── InventoryInfoPanel.cs   # Info panel (name, description, stat)
    │   ├── InventoryItemImage.cs   # Info panel sprite display
    │   └── AspectRatioFitterImageAdjuster.cs
    └── scriptableSystem/
        ├── ScriptableVariable.cs   # Generic ScriptableObject data container
        ├── IntSO.cs / SpriteSO.cs / InventoryItemsDataSO.cs
        ├── EventSO.cs              # ScriptableObject-based event bus
        └── EventSOListener.cs      # MonoBehaviour subscriber for EventSO

---

Requirements

• Unity 2020.3 LTS or later (the project uses UGui, TextMesh Pro)
• TextMesh Pro package (included via Packages/manifest.json)

---

Getting Started

1. Open the Project

1. Clone or download this repository.
2. Open Unity Hub and click Add → select the repository root folder.
3. Open the project with a compatible Unity version.

2. Open the Demo Scene

Navigate to Assets/Scenes/Main.unity and open it. Press Play to see the optimized scroll list in action with 1000+ inventory items.

---

How to Use ListOptmizer in Your Own Scene

Step 1 — Set Up the ScrollRect

1. Create a ScrollRect GameObject in your Canvas (e.g., via GameObject → UI → Scroll View).
2. Add the ListOptmizer component to that same ScrollRect GameObject.
   • It requires a ScrollRect component on the same object (enforced by [RequireComponent]).

Step 2 — Assign the Item Template

1. Create (or use an existing) item prefab — this is the GameObject that will be cloned and recycled to display each row.
2. In the ListOptmizer Inspector, assign your prefab to the Item Template field.
   • The template is hidden at runtime; ListOptmizer activates/deactivates it as needed.

Tip: Make sure the item prefab has a fixed size in the scroll direction so ListOptmizer can calculate how many items fit in the viewport.

Step 3 — Call PopulateList from Code

// Example: populate with 1000 items
[SerializeField] private ListOptmizer listOptmizer;

void Start()
{
    listOptmizer.PopulateList(
        itemsNumber: 1000,
        OnItemShow: (index, gameObject) =>
        {
            // Called every time an item becomes visible.
            // Update the item's UI here using `index`.
            var item = gameObject.GetComponent<MyItemComponent>();
            item.SetData(myDataArray[index]);
        },
        OnItemHide: (index, gameObject) =>
        {
            // Optional: called when an item scrolls out of view.
        }
    );
}

Parameter	Type	Description
itemsNumber	int	Total number of items in the list
OnItemShow	Action<int, GameObject>	Callback fired when an item becomes visible; receives the item's data index and its GameObject
OnItemHide	Action<int, GameObject>	(Optional) Callback fired when an item scrolls out of view

Step 4 — (Optional) Use OptmizedListItem for Inspector-Wired Events

If you prefer wiring callbacks in the Inspector instead of code, add the OptmizedListItem component to your item prefab and connect the OnShow / OnHide UnityEvents:

Item Prefab
└── OptmizedListItem (component)
    ├── OnShow (UnityEvent<int>)  → MyItemComponent.SetData
    └── OnHide (UnityEvent<int>)  → (optional cleanup)

OnShow receives the item's data index as its int argument.

Step 5 — Iterate Over Visible Items

At any point you can iterate over the currently visible pool:

listOptmizer.ForEachVisible((index, gameObject) =>
{
    // e.g., refresh highlight state after a selection change
    gameObject.GetComponent<MyItemComponent>().SetSelected(index == selectedIndex);
});

---

How It Works Internally

ListOptmizer implements a virtual scrolling strategy:

┌──────────────────────── ScrollRect Content ────────────────────────────┐
│  [rearFiller]   ← empty RectTransform that simulates hidden items above │
│  [Item Pool 0]                                                           │
│  [Item Pool 1]  ← only ~(viewport / itemHeight) + 2 items exist         │
│  [Item Pool 2]                                                           │
│      ...                                                                 │
│  [frontFiller]  ← empty RectTransform that simulates hidden items below  │
└──────────────────────────────────────────────────────────────────────────┘

1. On PopulateList — calculates how many items fit in the viewport, instantiates exactly that many GameObjects (plus 2), and creates invisible rearFiller / frontFiller RectTransforms.
2. On scroll — OnScrollValueChanged calculates the new startIndex/endIndex, resizes the fillers to represent the hidden items, and recycles items that have scrolled off one edge by moving them to the opposite edge and invoking the OnItemShow callback with the new index.
3. On viewport resize — OnRectTransformDimensionsChange recalculates all measures and rebuilds the pool to fit the new size.

---

ScriptableObject Architecture

The demo uses a lightweight, asset-based architecture to keep components decoupled:

Data Containers (ScriptableVariable<T>)

Store shared state as Unity assets. Any MonoBehaviour can read/write them without direct references to other MonoBehaviours.

Asset	Type	Purpose
SelectedItem	IntSO	Index of the currently selected inventory item
SelectedData	InventoryItemsDataSO	Array of all InventoryItemData structs
CurrentSprite	SpriteSO	Sprite of the currently selected item

Event Bus (EventSO / EventSOListener)

EventSO is a ScriptableObject that acts as a named event channel. Any component can call Raise() on it; any EventSOListener subscribed to it will fire its configured callback.

// Raise programmatically
[SerializeField] private EventSO onItemSelected;
onItemSelected.Raise();

// Or press the "Raise" button in the Inspector during Play mode (EventSOEditor)

EventSOListener subscribes/unsubscribes automatically via OnEnable / OnDisable, so it is safe to use on pooled objects.

---

Inventory Demo — Key Components

Component	GameObject	Role
InventoryManager	Manager	Parses item JSON, populates InventoryItemsDataSO, raises OnDataIsReady
InventoryHandler	Handler	Listens for OnDataIsReady, calls ListOptmizer.PopulateList
InventoryItem	Item Prefab	Updates icon/name UI; raises OnItemSelected when clicked
InventoryInfoPanel	InfoPanel	Listens for OnItemSelected, shows name / description / stat
InventoryItemImage	InfoPanel	Listens for OnItemSelected, shows item sprite

Data flow on startup

InventoryManager.Start()
  └─ Generates InventoryItemData[] from JSON
  └─ Raises OnDataIsReady
        └─ InventoryHandler.OnDataIsReady()
              └─ ListOptmizer.PopulateList(count, OnItemShow → InventoryItem.SetData)
                    └─ Builds visible pool, fires OnItemShow for each visible item
        └─ InventoryInfoPanel.OnDataReady()  ← displays item[0] on startup

Data flow on item click

InventoryItem.OnClick()
  └─ selectedItemIndex.Value = index   (writes IntSO)
  └─ Raises OnItemSelected
        └─ InventoryInfoPanel.OnItemSelected() → updates text
        └─ InventoryItemImage.OnItemSelected() → updates sprite
        └─ InventoryItem.OnItemClicked()       → refreshes highlight (all visible items)

---

Performance Notes

Scenario	Without optimization	With ListOptmizer
1000 items	~1000 UI GameObjects	~12–16 UI GameObjects
Draw call batches	Very high (scales with item count)	Low (scales with viewport size only)
Memory	O(n)	O(viewport)
FPS (low-end device)	<30 FPS while scrolling	60+ FPS

---

License

This project is provided as an open-source reference implementation. Feel free to use and adapt it in your own Unity projects.