Оптимизация рендеринга в Unity: Сортировка миллиона спрайтов

// Традиционный подход
foreach (var sprite in hugeAmountOfSprites) {
    // Выполнение сортировки перед рендерингом
    // Каждый спрайт проходит через весь конвейер рендеринга
}

// Стандартный способ управления Z-порядком в Unity
spriteRenderer.sortingOrder = 10;
spriteRenderer.sortingLayerName = "Foreground";

// Базовое использование DrawMeshInstancedIndirect
Graphics.DrawMeshInstancedIndirect(
    mesh,         // Базовая геометрия (обычно квад для спрайта)
    submeshIndex, // Индекс подмеша
    material,     // Материал с инстансинговым шейдером
    bounds,       // Границы всех инстансов для отсечения невидимых
    argsBuffer    // ComputeBuffer с параметрами инстансинга
);

// Оптимизация с использованием индексированных UV
// Буфер с доступными UV-координатами (устанавливается один раз)
uvBuffer = new ComputeBuffer(uvCoordinates.Length, 16); // float4
uvBuffer.SetData(uvCoordinates);
 
// Индексный буфер (уникален для каждого спрайта)
uvIndexBuffer = new ComputeBuffer(spriteCount, sizeof(int));
uvIndexBuffer.SetData(uvIndices);

// Фрагмент vertex shader для правильной сортировки спрайтов
float3 worldPosition = translationAndRot.xyz;
// Используем Y-координату для Z (для сортировки)
worldPosition.z = position.y;

// В стандартных шейдерах этот фрагмент требует полной обработки,
// даже если пиксель будет перекрыт другим объектом
fixed4 frag(v2f i) : SV_Target {
    fixed4 col = tex2D(_MainTex, i.uv) * i.color;
    // Дополнительные вычисления...
    return col;
}

// Сортировка большого массива спрайтов с помощью NativeArray.Sort
NativeArray<SpriteData> spriteArray = new NativeArray<SpriteData>(sprites.Length, Allocator.TempJob);
// Заполнение данными...
 
// Создание и запуск сортировочного джоба
var sortJob = new SortJob<SpriteData, SpriteComparer> {
    Data = spriteArray,
    Comparer = new SpriteComparer()
};
sortJob.Schedule().Complete();

// Пример оптимизации с использованием индексированных UV
// Создаем буфер с доступными UV-координатами
const int uvCount = UV_X_ELEMENTS * UV_Y_ELEMENTS;
float4[] uvs = new float4[uvCount];
// Заполняем буфер координатами из атласа
for (int u = 0; u < UV_X_ELEMENTS; u++) {
    for (int v = 0; v < UV_Y_ELEMENTS; v++) {
        int index = v * UV_X_ELEMENTS + u;
        uvs[index] = new float4(0.25f, 0.25f, u * 0.25f, v * 0.25f);
    }
}
 
// Создаем индексный буфер для спрайтов
int[] uvIndices = new int[spriteCount]; 
for (int i = 0; i < spriteCount; i++) {
    // Выбор подходящего индекса для спрайта
    uvIndices[i] = GetSpriteUvIndex(sprites[i]);
}

// Фрагмент vertex shader для работы с индексированными UV
int uvIndex = uvIndexBuffer[instanceID];
float4 uv = uvBuffer[uvIndex];
// xy - размеры, zw - смещение в атласе
o.uv = v.texcoord * uv.xy + uv.zw;

// Пример раздельного обновления статических и динамических данных
// Буферы для статических объектов (настраиваются один раз)
staticPositionBuffer = new ComputeBuffer(staticCount, 16);
staticPositionBuffer.SetData(staticPositions);
 
// Буферы для динамических объектов (обновляются каждый кадр)
dynamicPositionBuffer = new ComputeBuffer(dynamicCount, 16);
 
void Update() {
    // Обновляем только изменившиеся данные
    UpdateDynamicObjectPositions(dynamicPositions);
    dynamicPositionBuffer.SetData(dynamicPositions);
    
    // Отрисовка статических и динамических объектов по отдельности
    Graphics.DrawMeshInstancedIndirect(mesh, 0, material, bounds, staticArgsBuffer);
    Graphics.DrawMeshInstancedIndirect(mesh, 0, material, bounds, dynamicArgsBuffer);
}

// Пример использования double buffering
const int BUFFER_COUNT = 2;
ComputeBuffer[] positionBuffers = new ComputeBuffer[BUFFER_COUNT];
int currentBufferIndex = 0;
 
void Update() {
    // Переключаемся между буферами
    currentBufferIndex = (currentBufferIndex + 1) % BUFFER_COUNT;
    
    // Обновляем текущий буфер
    positionBuffers[currentBufferIndex].SetData(positions);
    
    // Устанавливаем текущий буфер для шейдера и отрисовываем
    material.SetBuffer("positionBuffer", positionBuffers[currentBufferIndex]);
    Graphics.DrawMeshInstancedIndirect(mesh, 0, material, bounds, argsBuffer);
}

// Шейдер для непрозрачных объектов
ZWrite On
// ...
 
// Шейдер для прозрачных объектов
ZWrite Off
ZTest LEqual
Blend SrcAlpha OneMinusSrcAlpha

// Фрагмент shader с использованием alpha clipping
fixed4 frag(v2f i) : SV_Target {
    fixed4 col = tex2D(_MainTex, i.uv) * i.color;
    // Отбрасываем пиксели с низкой прозрачностью
    clip(col.a - _AlphaClipThreshold);
    return col;
}

// Стандартный подход в Unity, который не работает с DrawMeshInstancedIndirect
SpriteRenderer spriteRenderer = GetComponent<SpriteRenderer>();
spriteRenderer.sortingLayerName = "Characters";
spriteRenderer.sortingOrder = 5;

// При использовании инстансинга каждое изменение требует обновления буфера
for (int i = 0; i < changedSprites.Count; i++) {
    int index = changedSprites[i].index;
    transformData[index] = new Vector4(
        changedSprites[i].position.x,
        changedSprites[i].position.y,
        changedSprites[i].position.z,
        changedSprites[i].rotation
    );
}
transformBuffer.SetData(transformData); // Потенциально дорогая операция

Профилирование 100 000 спрайтов (SpriteRenderer):
Renderer.LateUpdate: ~250 мс
Camera.Render: ~350 мс
Общее время кадра: ~620 мс (~1.6 FPS)

Профилирование 100 000 спрайтов (DrawMeshInstancedIndirect):
Обновление буферов: ~5-10 мс
Camera.Render: ~20-30 мс
Общее время кадра: ~40-50 мс (20-25 FPS)

Профилирование 1 000 000 спрайтов (DrawMeshInstancedIndirect):
Обновление буферов: ~40-50 мс
Camera.Render: ~35-45 мс
Общее время кадра: ~80-100 мс (10-12 FPS)

// Упрощенная модель сортировки в Unity (концептуально)
void SortSprites(List<SpriteRenderer> sprites) {
    // Группировка по материалам O(n)
    Dictionary<Material, List<SpriteRenderer>> materialGroups = GroupByMaterial(sprites);
    
    // Сортировка внутри каждой группы O(m * n log n), где m - количество групп
    foreach (var group in materialGroups.Values) {
        group.Sort((a, b) => {
            if (a.sortingLayerID != b.sortingLayerID)
                return a.sortingLayerID.CompareTo(b.sortingLayerID);
            return a.sortingOrder.CompareTo(b.sortingOrder);
        });
    }
    
    // Подготовка данных для рендеринга O(n)
    PrepareRenderData(materialGroups);
}

// Типичный код обновления порядка сортировки на основе Y-позиции
void Update() {
    foreach (var character in characters) {
        // Позиция в мире
        Vector3 position = character.transform.position;
        // Обновление порядка сортировки на основе позиции Y
        character.spriteRenderer.sortingOrder = Mathf.RoundToInt(-position.y * 100);
    }
    // Unity интернально проводит пересортировку всех спрайтов
}

// Обновление порядка сортировки в инстансинговом подходе
void Update() {
    for (int i = 0; i < characters.Length; i++) {
        // Позиция в мире
        Vector3 position = characters[i].position;
        // Z равен Y для автоматической сортировки
        transformData[i] = new Vector4(position.x, position.y, position.y, characters[i].rotation);
    }
    // Обновление буфера на GPU
    transformBuffer.SetData(transformData);
}

// Пример частичного обновления буфера
void UpdateTransformBuffer(List<ModifiedSprite> modifiedSprites) {
    foreach (var sprite in modifiedSprites) {
        int index = sprite.index;
        transformData[index] = sprite.NewTransformData;
    }
    
    // Если изменений мало, можем обновить только часть буфера
    if (modifiedSprites.Count < transformData.Length / 10) {
        foreach (var sprite in modifiedSprites) {
            transformBuffer.SetData(transformData, sprite.index, sprite.index, 1);
        }
    } else {
        // Если изменений много, обновляем весь буфер за раз
        transformBuffer.SetData(transformData);
    }
}

// Концептуальная структура системы рендеринга в SimAirport
struct RenderGroup {
    ComputeBuffer transformBuffer;
    ComputeBuffer colorBuffer;
    ComputeBuffer uvIndexBuffer;
    // Дополнительные буферы...
    
    Material material;
    Mesh mesh;
    
    void UpdateBuffers(List<Entity> entities) {
        // Обновление только изменившихся данных
    }
    
    void Render() {
        Graphics.DrawMeshInstancedIndirect(mesh, 0, material, 
                                        bounds, argsBuffer);
    }
}

// Некорректная реализация в шейдере
position.z = -position.y; // Ошибка!

// Корректная реализация в шейдере
position.z = position.y; // Объекты вверху экрана (с меньшим Y) будут отрисованы первыми

// Фрагмент шейдера для отладки
float3 debugColor = float3(
    fmod(instanceID * 0.0174532925, 1.0),
    fmod(instanceID * 0.0105, 1.0),
    fmod(instanceID * 0.0253, 1.0)
);
o.color = float4(debugColor, 1.0);

// Пример тестовой реализации с драгабельными спрайтами
public class SpriteDragTest : MonoBehaviour {
    public Transform[] spriteTransforms;
    
    void Update() {
        // Обновление позиций в буфере
        for (int i = 0; i < spriteTransforms.Length; i++) {
            Vector3 position = spriteTransforms[i].position;
            transformData[i] = new Vector4(position.x, position.y, position.y, rotation);
        }
        
        // Обновление буфера и отрисовка
        transformBuffer.SetData(transformData);
        Graphics.DrawMeshInstancedIndirect(...);
    }
}

// Fragment of instanced sprite shader
Shader "Instanced/SpriteRendererIndexedUv" {
    Properties {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
    }
    
    SubShader {
        Tags{
            "Queue"="AlphaTest"
            "IgnoreProjector"="True"
            "RenderType"="TransparentCutout"
        }
        Cull Back
        Lighting Off
        ZWrite On
        AlphaTest Greater 0
        Blend SrcAlpha OneMinusSrcAlpha
        
        Pass {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 4.5
            
            #include "UnityCG.cginc"
            
            sampler2D _MainTex;
            fixed _Cutoff;
            
            // xyz - position, w - rotation
            StructuredBuffer<float4> translationAndRotationBuffer;
            StructuredBuffer<float> scaleBuffer;
            StructuredBuffer<float4> colorsBuffer;
            
            // UV management - optimized approach
            StructuredBuffer<float4> uvBuffer;
            StructuredBuffer<int> uvIndexBuffer;
            
            struct v2f {
                float4 pos : SV_POSITION;
                float2 uv: TEXCOORD0;
                fixed4 color : COLOR0;
            };
            
            float4x4 rotationZMatrix(float zRotRadians){
                float c = cos(zRotRadians);
                float s = sin(zRotRadians);
                float4x4 ZMatrix = 
                    float4x4( 
                        c,  s, 0,  0,
                        -s, c, 0,  0,
                        0,  0, 1,  0,
                        0,  0, 0,  1);
                return ZMatrix;
            }
            
            v2f vert(appdata_full v, uint instanceID : SV_InstanceID) {
                float4 translationAndRot = translationAndRotationBuffer[instanceID];
                int uvIndex = uvIndexBuffer[instanceID];
                float4 uv = uvBuffer[uvIndex];
                
                // Rotate the vertex
                v.vertex = mul(v.vertex - float4(0.5, 0.5, 0,0), rotationZMatrix(translationAndRot.w));
                
                // Scale it
                float scale = scaleBuffer[instanceID];
                float3 worldPosition = translationAndRot.xyz + (v.vertex.xyz * scale);
                
                v2f o;
                o.pos = UnityObjectToClipPos(float4(worldPosition, 1.0f));
                
                // XY - dimension, ZW - offset in texture
                o.uv = v.texcoord * uv.xy + uv.zw;
                
                o.color = colorsBuffer[instanceID];
                return o;
            }
            
            fixed4 frag(v2f i) : SV_Target {
                fixed4 col = tex2D(_MainTex, i.uv) * i.color;
                clip(col.a - _Cutoff);
                col.rgb *= col.a;
                return col;
            }
            
            ENDCG
        }
    }
}

public class ComputeBufferSpritesRenderer : MonoBehaviour {
    [SerializeField]
    private Camera referenceCamera;
    
    [SerializeField]
    private Material material;
    
    [SerializeField]
    private float spriteScale = 0.3f;
    
    [SerializeField]
    private int count = 1000000; // Количество спрайтов
    
    private Mesh mesh;
    private ComputeBuffer translationAndRotationBuffer;
    private ComputeBuffer scaleBuffer;
    private ComputeBuffer colorBuffer;
    private ComputeBuffer uvBuffer;
    private ComputeBuffer uvIndexBuffer;
    private ComputeBuffer argsBuffer;
    
    private uint[] args;
    
    private const int UV_X_ELEMENTS = 4;
    private const int UV_Y_ELEMENTS = 4;
    
    private void Awake() {
        // Отключаем VSync для тестирования максимальной производительности
        QualitySettings.vSyncCount = 0;
        Application.targetFrameRate = -1;
        
        // Создаем простой квад для спрайта
        this.mesh = CreateQuadMesh(1.0f);
        
        // Подготавливаем UV-координаты
        const int uvCount = UV_X_ELEMENTS * UV_Y_ELEMENTS;
        float4[] uvs = new float4[uvCount];
        for (int u = 0; u < UV_X_ELEMENTS; u++) {
            for (int v = 0; v < UV_Y_ELEMENTS; v++) {
                int index = v * UV_X_ELEMENTS + u;
                uvs[index] = new float4(0.25f, 0.25f, u * 0.25f, v * 0.25f);
            }
        }
        
        // Создаем и заполняем UV буфер
        this.uvBuffer = new ComputeBuffer(uvs.Length, 16);
        this.uvBuffer.SetData(uvs);
        int uvBufferId = Shader.PropertyToID("uvBuffer");
        this.material.SetBuffer(uvBufferId, this.uvBuffer);
        
        // Подготавливаем данные для спрайтов
        float4[] translationAndRotations = new float4[this.count];
        float[] scales = new float[this.count];
        float4[] colors = new float4[this.count];
        int[] uvIndices = new int[this.count]; 
        
        float screenRatio = (float)Screen.width / Screen.height;
        float orthoSize = this.referenceCamera.orthographicSize;
        float maxX = orthoSize * screenRatio;
        
        // Заполняем случайными значениями для демонстрации
        for (int i = 0; i < this.count; ++i) {
            float y = UnityEngine.Random.Range(-orthoSize, orthoSize);
            float x = UnityEngine.Random.Range(-maxX, maxX);
            float z = y; // Используем Y для Z, чтобы обеспечить правильную сортировку
            float rotation = UnityEngine.Random.Range(0, Mathf.PI * 2);
            
            translationAndRotations[i] = new float4(x, y, z, rotation);
            scales[i] = this.spriteScale;
            uvIndices[i] = UnityEngine.Random.Range(0, uvCount);
            
            float r = UnityEngine.Random.Range(0f, 1.0f);
            float g = UnityEngine.Random.Range(0f, 1.0f);
            float b = UnityEngine.Random.Range(0f, 1.0f);
            colors[i] = new float4(r, g, b, 1.0f);
        }
        
        // Создаем и заполняем буферы данных
        this.translationAndRotationBuffer = new ComputeBuffer(this.count, 16);
        this.translationAndRotationBuffer.SetData(translationAndRotations);
        this.material.SetBuffer("translationAndRotationBuffer", this.translationAndRotationBuffer);
        
        this.scaleBuffer = new ComputeBuffer(this.count, sizeof(float));
        this.scaleBuffer.SetData(scales);
        this.material.SetBuffer("scaleBuffer", this.scaleBuffer);
        
        this.uvIndexBuffer = new ComputeBuffer(this.count, sizeof(int));
        this.uvIndexBuffer.SetData(uvIndices);
        this.material.SetBuffer("uvIndexBuffer", this.uvIndexBuffer);
        
        this.colorBuffer = new ComputeBuffer(this.count, 16);
        this.colorBuffer.SetData(colors);
        this.material.SetBuffer("colorsBuffer", this.colorBuffer);
        
        // Настраиваем аргументы для DrawMeshInstancedIndirect
        this.args = new uint[] {
            6, // индексов на один спрайт (2 треугольника)
            (uint)this.count, // количество инстансов
            0, 0, 0 // unused
        };
        this.argsBuffer = new ComputeBuffer(1, this.args.Length * sizeof(uint), ComputeBufferType.IndirectArguments);
        this.argsBuffer.SetData(this.args);
    }
    
    private static readonly Bounds BOUNDS = new Bounds(Vector3.zero, Vector3.one * 1000);
    
    private void Update() {
        // Отрисовка всех спрайтов одним вызовом
        Graphics.DrawMeshInstancedIndirect(
            this.mesh, 0, this.material, BOUNDS, this.argsBuffer);
    }
    
    private void OnDestroy() {
        // Освобождаем ресурсы
        if (translationAndRotationBuffer != null) translationAndRotationBuffer.Release();
        if (scaleBuffer != null) scaleBuffer.Release();
        if (colorBuffer != null) colorBuffer.Release();
        if (uvBuffer != null) uvBuffer.Release();
        if (uvIndexBuffer != null) uvIndexBuffer.Release();
        if (argsBuffer != null) argsBuffer.Release();
    }
}

// Добавьте эти переменные в класс
private List<int> modifiedIndices = new List<int>(1000);
private float4[] translationAndRotations;
private SpriteController[] controllers;
 
// При инициализации создайте контроллеры для спрайтов
void InitDynamicSprites() {
    controllers = new SpriteController[count];
    for (int i = 0; i < count; i++) {
        controllers[i] = new SpriteController(i, this);
    }
}
 
// Обновление позиций только изменившихся спрайтов
void UpdateTransforms() {
    // Очистка списка изменений
    modifiedIndices.Clear();
    
    // Обновление контроллеров (движение логики и т.д.)
    for (int i = 0; i < controllers.Length; i++) {
        if (controllers[i].Update()) {
            // Спрайт изменился, добавляем в список
            modifiedIndices.Add(i);
        }
    }
    
    // Если изменилось мало спрайтов, обновляем их частично
    if (modifiedIndices.Count < count / 10) {
        foreach (int index in modifiedIndices) {
            // Обновляем буфер только для измененных спрайтов
            translationAndRotationBuffer.SetData(
                new[] { translationAndRotations[index] }, 
                0, index, 1);
        }
    } else {
        // Слишком много изменений, обновляем весь буфер
        translationAndRotationBuffer.SetData(translationAndRotations);
    }
}
 
// Класс контроллера для отдельного спрайта
class SpriteController {
    private int index;
    private ComputeBufferSpritesRenderer parent;
    private Vector3 position;
    private float rotation;
    private bool dirty = false;
    
    public SpriteController(int index, ComputeBufferSpritesRenderer parent) {
        this.index = index;
        this.parent = parent;
    }
    
    public bool Update() {
        // Реализация логики движения
        bool wasModified = dirty;
        dirty = false;
        return wasModified;
    }
    
    public void SetPosition(Vector3 newPos) {
        if (position != newPos) {
            position = newPos;
            // Обновляем данные в массиве родителя
            parent.translationAndRotations[index] = 
                new float4(position.x, position.y, position.y, rotation);
            dirty = true;
        }
    }
    
    public void SetRotation(float newRot) {
        if (rotation != newRot) {
            rotation = newRot;
            parent.translationAndRotations[index].w = rotation;
            dirty = true;
        }
    }
}

// Улучшенный менеджер UV-координат
class UVAtlasManager {
    private readonly Dictionary<string, int> uvIndices = new Dictionary<string, int>();
    private readonly List<float4> uvCoordinates = new List<float4>();
    private ComputeBuffer uvBuffer;
    
    public void Initialize(Material material) {
        // Создаем и заполняем буфер
        uvBuffer = new ComputeBuffer(uvCoordinates.Count, 16);
        uvBuffer.SetData(uvCoordinates.ToArray());
        material.SetBuffer("uvBuffer", uvBuffer);
    }
    
    public int RegisterUV(string textureName, Rect uvRect) {
        string key = $"{textureName}_{uvRect.x}_{uvRect.y}_{uvRect.width}_{uvRect.height}";
        
        if (uvIndices.TryGetValue(key, out int index)) {
            return index;
        }
        
        // Новые UV координаты
        float4 uvData = new float4(uvRect.width, uvRect.height, uvRect.x, uvRect.y);
        int newIndex = uvCoordinates.Count;
        uvCoordinates.Add(uvData);
        uvIndices[key] = newIndex;
        
        return newIndex;
    }
    
    public void UpdateBuffer() {
        uvBuffer.SetData(uvCoordinates.ToArray());
    }
    
    public void Release() {
        if (uvBuffer != null) uvBuffer.Release();
    }
}

// Дополненный фрагментный шейдер с расширенной функциональностью
fixed4 frag(v2f i) : SV_Target {
    fixed4 col = tex2D(_MainTex, i.uv) * i.color;
    
    // Alpha clipping для производительности
    clip(col.a - _Cutoff);
    
    // Normal mapping если требуется
    #ifdef NORMAL_MAPPING
        fixed3 normal = UnpackNormal(tex2D(_BumpMap, i.uv));
        // Применение нормалей для освещения
    #endif
    
    // Параллакс для эффекта глубины
    #ifdef PARALLAX
        float height = tex2D(_HeightMap, i.uv).r;
        float2 parallaxOffset = ParallaxOffset(height, _Parallax, i.viewDir);
        i.uv += parallaxOffset;
        // Повторно сэмплируем текстуру с новыми координатами
        col = tex2D(_MainTex, i.uv) * i.color;
    #endif
    
    // Премножение альфы для правильного смешивания
    col.rgb *= col.a;
    
    return col;
}

// Упаковка позиции и вращения в меньшее количество байт
struct CompressedTransform {
    // Позиция в диапазоне [-2048, 2048] с шагом ~0.0625
    // 12 бит на компоненту x, y, z = 36 бит
    private uint packedPosition;
    
    // Вращение [0, 2π] с шагом ~0.0061 радиан
    // 10 бит на вращение
    private ushort packedRotation;
    
    public void Set(Vector3 position, float rotation) {
        // Сжимаем позицию
        int x = Mathf.Clamp(Mathf.RoundToInt(position.x * 16), -2048, 2047);
        int y = Mathf.Clamp(Mathf.RoundToInt(position.y * 16), -2048, 2047);
        int z = Mathf.Clamp(Mathf.RoundToInt(position.z * 16), -2048, 2047);
        
        packedPosition = ((uint)(x & 0xFFF) << 24) | 
                         ((uint)(y & 0xFFF) << 12) | 
                         ((uint)(z & 0xFFF));
        
        // Сжимаем вращение
        int rot = Mathf.RoundToInt((rotation % (Mathf.PI * 2)) * 1024 / (Mathf.PI * 2));
        packedRotation = (ushort)(rot & 0x3FF);
    }
    
    public Vector4 GetUnpacked() {
        float x = ((int)((packedPosition >> 24) & 0xFFF)) / 16f;
        float y = ((int)((packedPosition >> 12) & 0xFFF)) / 16f;
        float z = ((int)(packedPosition & 0xFFF)) / 16f;
        float rotation = (packedRotation & 0x3FF) * (Mathf.PI * 2) / 1024f;
        
        return new Vector4(x, y, z, rotation);
    }
}

// Распаковка сжатых данных в шейдере
float4 UnpackTransform(uint packedPos, uint packedRot) {
    float x = ((int)((packedPos >> 24) & 0xFFF)) / 16.0;
    float y = ((int)((packedPos >> 12) & 0xFFF)) / 16.0;
    float z = ((int)(packedPos & 0xFFF)) / 16.0;
    float rotation = (packedRot & 0x3FF) * (3.14159265359 * 2.0) / 1024.0;
    
    return float4(x, y, z, rotation);
}

// Гибридный подход к сортировке
public class HybridSpriteRenderer : MonoBehaviour {
    // Группы спрайтов по Z-слоям
    private Dictionary<int, SpriteRenderGroup> renderGroups = new Dictionary<int, SpriteRenderGroup>();
    
    // Добавление спрайта в подходящую группу
    public void AddSprite(SpriteData sprite, int zLayer) {
        if (!renderGroups.TryGetValue(zLayer, out var group)) {
            group = new SpriteRenderGroup(material, mesh);
            renderGroups[zLayer] = group;
        }
        group.AddSprite(sprite);
    }
    
    // Отрисовка всех групп
    public void Render() {
        // Отрисовка от дальних к ближним слоям
        foreach (var layer in renderGroups.Keys.OrderBy(k => k)) {
            renderGroups[layer].Render();
        }
    }
}
 
// Группа спрайтов с общим Z-слоем
public class SpriteRenderGroup {
    private ComputeBuffer transformBuffer;
    private ComputeBuffer colorBuffer;
    private ComputeBuffer uvIndexBuffer;
    private Material material;
    private Mesh mesh;
    
    // Внутри каждой группы GPU выполняет сортировку по Y-координате
    public void AddSprite(SpriteData sprite) {
        // Добавление спрайта в буферы
        int index = sprites.Count;
        transformData[index] = new Vector4(
            sprite.position.x, 
            sprite.position.y, 
            sprite.position.y, // Y -> Z для сортировки
            sprite.rotation
        );
        // Заполнение других буферов...
        
        sprites.Add(sprite);
    }
    
    public void Render() {
        // Обновляем буферы если нужно
        if (isDirty) {
            UpdateBuffers();
        }
        
        // Один DrawCall для всей группы
        Graphics.DrawMeshInstancedIndirect(mesh, 0, material, 
            bounds, argsBuffer);
    }
}

// Оптимизация для смешанных сцен
public class OptimizedSpriteManager {
    // Статические объекты (редко или никогда не меняются)
    private SpriteRenderGroup staticSpritesGroup;
    
    // Динамические объекты (часто меняют позицию/вращение)
    private SpriteRenderGroup dynamicSpritesGroup;
    
    // Временные объекты (эффекты, снаряды и т.д.)
    private SpriteRenderGroup temporarySpritesGroup;
 
    public void Update() {
        // Статическая группа обновляется редко
        if (staticSpritesGroup.HasChanges()) {
            staticSpritesGroup.UpdateBuffers();
        }
        
        // Динамическая группа обновляется каждый кадр
        dynamicSpritesGroup.UpdatePositionsOnly();
        
        // Временная группа полностью перестраивается каждый кадр
        temporarySpritesGroup.RebuildCompletely();
        
        // Отрисовка всех групп в нужном порядке
        staticSpritesGroup.Render();
        dynamicSpritesGroup.Render();
        temporarySpritesGroup.Render();
    }
}

// Пулинг спрайтов для предотвращения выделений памяти
public class SpritePool {
    private Queue<SpriteData> pool = new Queue<SpriteData>();
    private int activeCount = 0;
    
    // Получение спрайта из пула
    public SpriteData GetSprite() {
        SpriteData sprite;
        
        if (pool.Count > 0) {
            sprite = pool.Dequeue();
        } else {
            sprite = new SpriteData();
        }
        
        activeCount++;
        return sprite;
    }
    
    // Возврат спрайта в пул
    public void ReturnSprite(SpriteData sprite) {
        pool.Enqueue(sprite);
        activeCount--;
    }
    
    // Создание преаллоцированного пула
    public static SpritePool CreatePreallocated(int capacity) {
        SpritePool pool = new SpritePool();
        for (int i = 0; i < capacity; i++) {
            pool.pool.Enqueue(new SpriteData());
        }
        return pool;
    }
}

// Управление буферами с возможностью динамического изменения размера
public class DynamicComputeBufferPool<T> where T : struct {
    private ComputeBuffer currentBuffer;
    private int currentCapacity;
    private int elementSize;
    
    public DynamicComputeBufferPool(int initialCapacity, int elementSize) {
        this.currentCapacity = initialCapacity;
        this.elementSize = elementSize;
        this.currentBuffer = new ComputeBuffer(initialCapacity, elementSize);
    }
    
    // Получение буфера подходящего размера
    public ComputeBuffer GetBuffer(int requiredCapacity) {
        if (requiredCapacity <= currentCapacity) {
            return currentBuffer;
        }
        
        // Размер недостаточен, создаем новый буфер
        if (currentBuffer != null) {
            currentBuffer.Release();
        }
        
        // Округляем до ближайшей степени двойки для избежания частого пересоздания
        int newCapacity = 1;
        while (newCapacity < requiredCapacity) newCapacity *= 2;
        
        currentCapacity = newCapacity;
        currentBuffer = new ComputeBuffer(newCapacity, elementSize);
        
        return currentBuffer;
    }
    
    public void Release() {
        if (currentBuffer != null) {
            currentBuffer.Release();
            currentBuffer = null;
        }
    }
}

// Асинхронное обновление буферов
public class AsyncBufferUpdater {
    private NativeArray<Vector4> transformData;
    private ComputeBuffer transformBuffer;
    private List<TransformUpdateJob> pendingJobs = new List<TransformUpdateJob>();
    
    // Структура для Job System
    private struct TransformUpdateJob : IJob {
        public NativeArray<Vector4> transformData;
        public int startIndex;
        public int count;
        [ReadOnly]
        public NativeArray<Vector3> positions;
        [ReadOnly]
        public NativeArray<float> rotations;
        
        public void Execute() {
            for (int i = 0; i < count; i++) {
                int index = startIndex + i;
                Vector3 pos = positions[i];
                transformData[index] = new Vector4(
                    pos.x, pos.y, pos.y, rotations[i]
                );
            }
        }
    }
    
    // Планирование обновления группы спрайтов
    public JobHandle ScheduleUpdate(
        int startIndex, NativeArray<Vector3> positions, 
        NativeArray<float> rotations) {
        
        var job = new TransformUpdateJob {
            transformData = transformData,
            startIndex = startIndex,
            count = positions.Length,
            positions = positions,
            rotations = rotations
        };
        
        JobHandle handle = job.Schedule();
        pendingJobs.Add(job);
        
        return handle;
    }
    
    // Применение всех изменений к буферу
    public void ApplyUpdates() {
        JobHandle.CompleteAll(pendingJobs.Select(j => j.handle).ToArray());
        transformBuffer.SetData(transformData);
        pendingJobs.Clear();
    }
}

// Упрощенная реализация квадродерева для 2D-спрайтов
public class QuadTree<T> {
    private Rect bounds;
    private int maxDepth;
    private int maxObjectsPerNode;
    private QuadTree<T>[] children;
    private List<QuadTreeObject> objects = new List<QuadTreeObject>();
    
    // Структура для хранения объекта и его AABB
    private struct QuadTreeObject {
        public T Object;
        public Rect Bounds;
    }
    
    // Добавление объекта в дерево
    public void Insert(T obj, Rect objBounds) {
        if (children != null) {
            // Определяем квадрант для вставки
            int index = GetQuadrant(objBounds);
            if (index != -1) {
                children[index].Insert(obj, objBounds);
                return;
            }
        }
        
        objects.Add(new QuadTreeObject { Object = obj, Bounds = objBounds });
        
        // Проверка необходимости разделения
        if (objects.Count > maxObjectsPerNode && currentDepth < maxDepth) {
            Split();
        }
    }
    
    // Получение всех объектов в пределах заданной области
    public List<T> Query(Rect queryBounds) {
        List<T> result = new List<T>();
        Query(queryBounds, result);
        return result;
    }
    
    // Выполнение запроса
    private void Query(Rect queryBounds, List<T> result) {
        if (!bounds.Overlaps(queryBounds)) return;
        
        // Добавляем объекты текущего узла
        foreach (var obj in objects) {
            if (obj.Bounds.Overlaps(queryBounds)) {
                result.Add(obj.Object);
            }
        }
        
        // Проверяем дочерние узлы
        if (children != null) {
            for (int i = 0; i < children.Length; i++) {
                children[i].Query(queryBounds, result);
            }
        }
    }
}

// Использование квадродерева для рендеринга
public class SpatialRendererManager {
    private QuadTree<SpriteData> spriteQuadTree;
    private Camera viewCamera;
    
    public void Update() {
        // Получаем границы видимой области
        Rect visibleBounds = GetVisibleWorldBounds(viewCamera);
        
        // Получаем только видимые спрайты
        List<SpriteData> visibleSprites = spriteQuadTree.Query(visibleBounds);
        
        // Группируем по слоям и приоритету
        Dictionary<int, List<SpriteData>> layeredSprites = 
            GroupByLayers(visibleSprites);
        
        // Рендерим только видимые спрайты
        foreach (var layer in layeredSprites.Keys.OrderBy(k => k)) {
            RenderSpriteGroup(layeredSprites[layer]);
        }
    }
    
    private void RenderSpriteGroup(List<SpriteData> sprites) {
        // Обновляем буферы только для видимых спрайтов
        UpdateBuffersForSprites(sprites);
        
        // Отрисовка одним DrawCall
        Graphics.DrawMeshInstancedIndirect(...);
    }
}

// Оптимизированное вращение в шейдере
// Вместо динамического вычисления используем предвычисленную таблицу
uniform float4x4 _RotationMatrices[16]; // 16 предвычисленных матриц для углов 0-360° с шагом 22.5°
 
v2f vert(appdata_full v, uint instanceID : SV_InstanceID) {
    float4 instanceData = transformBuffer[instanceID];
    
    // Получаем индекс ближайшей предвычисленной матрицы
    int rotIndex = round(instanceData.w * 15 / (2 * 3.14159265359));
    rotIndex = rotIndex & 15; // Маска для 16 вариантов
    
    // Применяем предвычисленную матрицу
    v.vertex = mul(_RotationMatrices[rotIndex], v.vertex - float4(0.5, 0.5, 0, 0));
    
    // ...остальная часть шейдера...
}

void PrepareRotationMatrices() {
    Matrix4x4[] rotationMatrices = new Matrix4x4[16];
    for (int i = 0; i < 16; i++) {
        float angle = i * (2 * Mathf.PI / 16);
        rotationMatrices[i] = Matrix4x4.Rotate(Quaternion.Euler(0, 0, angle * Mathf.Rad2Deg));
    }
    material.SetMatrixArray("_RotationMatrices", rotationMatrices);
}