Повышаем производительность игры на Unity 6 с GPU Resident Drawer

// Пример кода для исключения определенных объектов из GPU Resident Drawer
// Применяется к объектам, которые должны управляться другими системами
[ExecuteInEditMode]
public class ExcludeFromGPUResident : MonoBehaviour
{
    void OnEnable()
    {
        if (gameObject.GetComponent<DisallowGPUDrivenRendering>() == null)
        {
            gameObject.AddComponent<DisallowGPUDrivenRendering>();
        }
    }
}

// Фрагмент кода для мониторинга реального использования VRAM (DirectX11)
#if UNITY_EDITOR
using UnityEngine;
using System.Runtime.InteropServices;
 
public class GPUMemoryMonitor : MonoBehaviour
{
    [DllImport("dxgi.dll")]
    static extern int CreateDXGIFactory1(ref System.Guid guid, out IntPtr factory);
 
    // ... остальной код для получения статистики ...
 
    void Update()
    {
        long availableMemory = GetAvailableVRAM();
        Debug.Log($"Реальная доступная видеопамять: {availableMemory / 1024 / 1024} МБ");
    }
}
#endif

// Фрагмент шейдера с исправлением проблем теней для GPU Resident Drawer
// ...
HLSLPROGRAM
// ...
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE 
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS
#pragma multi_compile _ _SHADOWS_SOFT
#pragma multi_compile_instancing
#pragma instancing_options procedural:ConfigureProcedural // Важно для работы с GPU Resident Drawer
 
// ...
ENDHLSL

// Утилита для проверки, использует ли объект GPU Resident Drawer
public static class GPUResidentDebugger
{
    public static bool IsUsingGPUResidentDrawer(GameObject obj)
    {
        // Проверяем базовые условия
        var renderer = obj.GetComponent<MeshRenderer>();
        if (renderer == null) return false;
        if (obj.GetComponent<DisallowGPUDrivenRendering>() != null) return false;
        
        // Проверяем другие условия...
        
        return true; // Вероятно использует GPU Resident Drawer
    }
}

// Упрощенная схема работы GPU Resident Drawer под капотом
// Unity генерирует такой код автоматически при включении технологии
 
// Создание буферов для данных на GPU
ComputeBuffer transformBuffer = new ComputeBuffer(objectCount, sizeof(float) * 16); 
ComputeBuffer propsBuffer = new ComputeBuffer(objectCount, sizeof(float) * 4);
 
// Заполнение буферов данными всех объектов сразу
transformBuffer.SetData(transforms);
propsBuffer.SetData(properties);
 
// Привязка буферов к шейдеру
material.SetBuffer("_TransformBuffer", transformBuffer);
material.SetBuffer("_PropsBuffer", propsBuffer);
 
// Одна команда рисования вместо тысяч
Graphics.DrawMeshInstancedIndirect(mesh, 0, material, bounds, argsBuffer);

// Пример реализации собственного механизма кластеризации объектов
// для более эффективной работы с GPU Resident Drawer
public class ObjectClusterOptimizer : MonoBehaviour
{
    [SerializeField] private float optimalDensity = 0.5f;
    [SerializeField] private float clusterSize = 10f;
    
    public void OptimizeObjectPlacement(List<GameObject> objects)
    {
        // Группируем объекты по областям пространства
        Dictionary<Vector3Int, List<GameObject>> clusters = new Dictionary<Vector3Int, List<GameObject>>();
        
        foreach (var obj in objects)
        {
            Vector3 pos = obj.transform.position;
            Vector3Int cellPos = new Vector3Int(
                Mathf.FloorToInt(pos.x / clusterSize),
                Mathf.FloorToInt(pos.y / clusterSize),
                Mathf.FloorToInt(pos.z / clusterSize)
            );
            
            if (!clusters.ContainsKey(cellPos))
                clusters[cellPos] = new List<GameObject>();
                
            clusters[cellPos].Add(obj);
        }
        
        // Оптимизируем слишком плотные кластеры
        foreach (var cluster in clusters)
        {
            if (cluster.Value.Count > optimalDensity * clusterSize * clusterSize * clusterSize)
            {
                OptimizeCluster(cluster.Value);
            }
        }
    }
    
    private void OptimizeCluster(List<GameObject> clusterObjects)
    {
        // Реализация оптимизации плотного кластера...
    }
}

// Класс для автоматического бенчмаркинга GPU Resident Drawer
public class GPUResidentBenchmark : MonoBehaviour
{
    [SerializeField] private bool enableGPUResident = true;
    [SerializeField] private bool enableOcclusionCulling = true;
    [SerializeField] private int warmupFrames = 100;
    [SerializeField] private int measuredFrames = 1000;
    
    private float[] cpuFrameTimes;
    private float[] gpuFrameTimes;
    private int frameCounter = 0;
    
    void Start()
    {
        cpuFrameTimes = new float[measuredFrames];
        gpuFrameTimes = new float[measuredFrames];
        
        // Настройка GPU Resident Drawer через рефлексию
        // (в реальной реализации используются более сложные методы)
        var urpAsset = GraphicsSettings.currentRenderPipeline;
        var property = urpAsset.GetType().GetProperty("gpuResidentDrawer");
        property?.SetValue(urpAsset, enableGPUResident ? 1 : 0);
    }
    
    void Update()
    {
        if (frameCounter >= warmupFrames && frameCounter < warmupFrames + measuredFrames)
        {
            int index = frameCounter - warmupFrames;
            cpuFrameTimes[index] = Time.unscaledDeltaTime * 1000f;
            // GPU время получается через Query в реальной реализации
        }
        frameCounter++;
    }
}

public static class GPUResidentHelper
{
    public static bool IsEligibleForGPUResident(GameObject obj)
    {
        MeshRenderer mr = obj.GetComponent<MeshRenderer>();
        if (mr == null) return false;
        
        // Проверяем материал на поддержку DOTS инстансинга
        if (mr.sharedMaterial != null && 
            !mr.sharedMaterial.shader.name.Contains("Universal Render Pipeline")) 
            return false;
        
        // Проверяем режим лайт-пробов
        if (mr.lightProbeUsage == UnityEngine.Rendering.LightProbeUsage.UseProxyVolume) 
            return false;
        
        // Проверяем наличие дисаблера
        if (obj.GetComponent<DisallowGPUDrivenRendering>() != null) 
            return false;
        
        return true;
    }
}

#if UNITY_EDITOR
[MenuItem("Tools/GPU Resident/Analyze Scene")]
public static void AnalyzeScene()
{
    MeshRenderer[] renderers = GameObject.FindObjectsOfType<MeshRenderer>();
    int eligible = 0;
    int notEligible = 0;
    
    foreach (var renderer in renderers)
    {
        if (GPUResidentHelper.IsEligibleForGPUResident(renderer.gameObject))
            eligible++;
        else
            notEligible++;
    }
    
    Debug.Log($"Анализ завершен. Подходят для GPU Resident: {eligible}, не подходят: {notEligible}");
}
#endif

public class GPUResidentObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject prefab;
    [SerializeField] private int poolSize = 100;
    
    private List<GameObject> pool = new List<GameObject>();
    private Queue<GameObject> availableObjects = new Queue<GameObject>();
    
    void Start()
    {
        // Предварительное создание пула объектов
        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = Instantiate(prefab, transform);
            obj.SetActive(false);
            pool.Add(obj);
            availableObjects.Enqueue(obj);
        }
    }
    
    public GameObject GetObject(Vector3 position, Quaternion rotation)
    {
        if (availableObjects.Count == 0)
        {
            Debug.LogWarning("Пул объектов исчерпан!");
            return null;
        }
        
        GameObject obj = availableObjects.Dequeue();
        obj.transform.position = position;
        obj.transform.rotation = rotation;
        obj.SetActive(true);
        
        return obj;
    }
    
    public void ReturnObject(GameObject obj)
    {
        obj.SetActive(false);
        availableObjects.Enqueue(obj);
    }
}

[RequireComponent(typeof(MeshRenderer))]
public class CustomLODController : MonoBehaviour
{
    [System.Serializable]
    public class LODLevel
    {
        public Mesh mesh;
        public float distance;
    }
    
    [SerializeField] private LODLevel[] lodLevels;
    [SerializeField] private float cullingDistance = 100f;
    
    private MeshFilter meshFilter;
    private float currentDistance;
    
    void Awake()
    {
        meshFilter = GetComponent<MeshFilter>();
    }
    
    void Update()
    {
        if (Camera.main == null) return;
        
        currentDistance = Vector3.Distance(transform.position, Camera.main.transform.position);
        
        // Полное отключение объекта при превышении дистанции каллинга
        if (currentDistance > cullingDistance)
        {
            gameObject.SetActive(false);
            return;
        }
        
        if (!gameObject.activeSelf)
            gameObject.SetActive(true);
            
        // Выбор подходящего LOD уровня
        for (int i = 0; i < lodLevels.Length; i++)
        {
            if (currentDistance <= lodLevels[i].distance || i == lodLevels.Length - 1)
            {
                if (meshFilter.sharedMesh != lodLevels[i].mesh)
                    meshFilter.sharedMesh = lodLevels[i].mesh;
                break;
            }
        }
    }
}

#if UNITY_EDITOR
using UnityEditor;
using System.Collections.Generic;
 
public static class MaterialOptimizer
{
    [MenuItem("Tools/GPU Resident/Optimize Materials")]
    public static void OptimizeMaterials()
    {
        Dictionary<string, Material> uniqueMaterials = new Dictionary<string, Material>();
        Dictionary<Material, List<Renderer>> materialUsage = new Dictionary<Material, List<Renderer>>();
        
        foreach (MeshRenderer renderer in GameObject.FindObjectsOfType<MeshRenderer>())
        {
            foreach (Material mat in renderer.sharedMaterials)
            {
                if (mat == null) continue;
                
                if (!materialUsage.ContainsKey(mat))
                    materialUsage[mat] = new List<Renderer>();
                    
                materialUsage[mat].Add(renderer);
            }
        }
        
        // Поиск похожих материалов для объединения
        List<Material> allMaterials = new List<Material>(materialUsage.Keys);
        for (int i = 0; i < allMaterials.Count; i++)
        {
            for (int j = i + 1; j < allMaterials.Count; j++)
            {
                if (AreMaterialsSimilar(allMaterials[i], allMaterials[j]))
                {
                    Debug.Log($"Материалы похожи: {allMaterials[i].name} и {allMaterials[j].name}");
                }
            }
        }
    }
    
    private static bool AreMaterialsSimilar(Material a, Material b)
    {
        // Проверка на одинаковый шейдер
        if (a.shader != b.shader) return false;
        
        // Проверка основных свойств
        // Реализация зависит от конкретных шейдеров в проекте
        return true; 
    }
}
#endif

[RequireComponent(typeof(MeshRenderer))]
public class TransparencyController : MonoBehaviour
{
    [SerializeField] private float distanceThreshold = 20f;
    [SerializeField] private Material opaqueVariant;
    [SerializeField] private Material transparentVariant;
    
    private MeshRenderer meshRenderer;
    private bool isUsingTransparent = false;
    
    void Awake()
    {
        meshRenderer = GetComponent<MeshRenderer>();
    }
    
    void Update()
    {
        if (Camera.main == null) return;
        
        float distance = Vector3.Distance(transform.position, Camera.main.transform.position);
        bool shouldBeTransparent = distance <= distanceThreshold;
        
        if (shouldBeTransparent != isUsingTransparent)
        {
            meshRenderer.material = shouldBeTransparent ? transparentVariant : opaqueVariant;
            isUsingTransparent = shouldBeTransparent;
            
            // Если объект стал непрозрачным, оптимизируем его для GPU Resident Drawer
            if (!isUsingTransparent && gameObject.GetComponent<DisallowGPUDrivenRendering>() != null)
            {
                Destroy(gameObject.GetComponent<DisallowGPUDrivenRendering>());
            }
            // Если объект стал прозрачным, исключаем из GPU Resident Drawer
            else if (isUsingTransparent && gameObject.GetComponent<DisallowGPUDrivenRendering>() == null)
            {
                gameObject.AddComponent<DisallowGPUDrivenRendering>();
            }
        }
    }
}

Shader "Custom/GPUResidentCompatible"
{
    Properties
    {
        _BaseMap ("Texture", 2D) = "white" {}
        _BaseColor ("Color", Color) = (1,1,1,1)
        // Другие свойства...
    }
    
    SubShader
    {
        Tags { "RenderType"="Opaque" "RenderPipeline"="UniversalPipeline" }
        
        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            // Эти директивы критичны для работы с GPU Resident Drawer
            #pragma multi_compile_instancing
            #pragma instancing_options procedural:ConfigureProcedural
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            
            // Наши свойства
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            
            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
            CBUFFER_END
            
            // Структура вершинных данных
            struct Attributes
            {
                float4 positionOS : POSITION;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            
            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            
            void ConfigureProcedural()
            {
                // Это будет заполнено автоматически GPU Resident Drawer
                // Не нужно реализовывать самостоятельно
            }
            
            Varyings vert(Attributes input)
            {
                Varyings output;
                
                // Важно для инстансинга
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                
                // Стандартное преобразование координат
                output.positionHCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                
                return output;
            }
            
            half4 frag(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                
                half4 color = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv) * _BaseColor;
                return color;
            }
            ENDHLSL
        }
    }
}

public class GPUResidentCompatibilityFixer : MonoBehaviour
{
    void Awake()
    {
        // Находим все системы частиц на сцене
        ParticleSystem[] particleSystems = FindObjectsOfType<ParticleSystem>();
        
        foreach (ParticleSystem ps in particleSystems)
        {
            ParticleSystemRenderer psr = ps.GetComponent<ParticleSystemRenderer>();
            
            // Если рендерер использует меш, исключаем его из GPU Resident Drawer
            if (psr.renderMode == ParticleSystemRenderMode.Mesh)
            {
                if (psr.gameObject.GetComponent<DisallowGPUDrivenRendering>() == null)
                {
                    psr.gameObject.AddComponent<DisallowGPUDrivenRendering>();
                    Debug.Log($"Исключена система частиц {ps.name} из GPU Resident Drawer");
                }
            }
        }
    }
}

// GPUResidentManager.cs - центральный менеджер системы
using UnityEngine;
using System.Collections.Generic;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
 
public class GPUResidentManager : MonoBehaviour
{
    [Header("Настройки производительности")]
    [SerializeField] private bool enableGPUResident = true;
    [SerializeField] private bool enableOcclusionCulling = true;
    [SerializeField] private int targetFPS = 60;
    [SerializeField] private float adaptationSpeed = 0.1f;
    
    [Header("Объекты для управления")]
    [SerializeField] private Transform worldRoot;
    [SerializeField] private int maxObjectsPerCell = 100;
    [SerializeField] private float cellSize = 50f;
    
    // Система управления качеством
    private float currentQualityLevel = 1.0f;
    private float smoothedFPS;
    
    // Пространственное разделение
    private Dictionary<Vector3Int, ObjectCell> cells = new Dictionary<Vector3Int, ObjectCell>();
    
    // Счетчики для профилирования
    private int totalObjectsCount;
    private int visibleObjectsCount;
    private int culledObjectsCount;
    
    void Awake()
    {
        // Принудительно устанавливаем GPU Resident Drawer
        SetGPUResident(enableGPUResident, enableOcclusionCulling);
        
        // Инициализация менеджера
        InitializeObjectCells();
    }
    
    void Update()
    {
        // Адаптивное качество на основе FPS
        UpdateAdaptiveQuality();
        
        // Обновление видимых ячеек
        UpdateVisibleCells();
    }
    
    private void InitializeObjectCells()
    {
        // Если корень мира не задан, используем текущий объект
        if (worldRoot == null)
            worldRoot = transform;
            
        // Получаем все рендереры в иерархии
        MeshRenderer[] renderers = worldRoot.GetComponentsInChildren<MeshRenderer>(true);
        totalObjectsCount = renderers.Length;
        
        // Распределяем по ячейкам пространства
        foreach (MeshRenderer renderer in renderers)
        {
            Vector3Int cellPos = WorldToCellPosition(renderer.transform.position);
            
            if (!cells.ContainsKey(cellPos))
            {
                cells[cellPos] = new ObjectCell(cellPos, cellSize);
            }
            
            cells[cellPos].AddObject(renderer.gameObject);
        }
        
        Debug.Log($"Инициализировано {totalObjectsCount} объектов в {cells.Count} ячейках");
    }
    
    private Vector3Int WorldToCellPosition(Vector3 worldPosition)
    {
        return new Vector3Int(
            Mathf.FloorToInt(worldPosition.x / cellSize),
            Mathf.FloorToInt(worldPosition.y / cellSize),
            Mathf.FloorToInt(worldPosition.z / cellSize)
        );
    }
    
    private void UpdateVisibleCells()
    {
        if (Camera.main == null) return;
        
        Vector3 cameraPos = Camera.main.transform.position;
        Vector3Int cameraCellPos = WorldToCellPosition(cameraPos);
        
        // Адаптивная дальность видимости на основе качества
        int viewDistance = Mathf.RoundToInt(3 * currentQualityLevel);
        
        visibleObjectsCount = 0;
        culledObjectsCount = 0;
        
        // Обновляем только ячейки в зоне видимости
        foreach (var cellPair in cells)
        {
            Vector3Int cellPos = cellPair.Key;
            ObjectCell cell = cellPair.Value;
            
            // Расстояние между ячейками (грубая метрика)
            int cellDist = Mathf.Abs(cellPos.x - cameraCellPos.x) + 
                          Mathf.Abs(cellPos.y - cameraCellPos.y) + 
                          Mathf.Abs(cellPos.z - cameraCellPos.z);
            
            bool isVisible = cellDist <= viewDistance;
            cell.SetVisibility(isVisible);
            
            if (isVisible)
                visibleObjectsCount += cell.ObjectCount;
            else
                culledObjectsCount += cell.ObjectCount;
        }
    }
    
    private void UpdateAdaptiveQuality()
    {
        // Обновляем сглаженный FPS
        float currentFPS = 1.0f / Time.deltaTime;
        smoothedFPS = Mathf.Lerp(smoothedFPS, currentFPS, Time.deltaTime * adaptationSpeed);
        
        // Адаптируем качество на основе FPS
        if (smoothedFPS < targetFPS * 0.8f)
        {
            // FPS ниже цели - уменьшаем качество
            currentQualityLevel = Mathf.Max(0.5f, currentQualityLevel - Time.deltaTime * adaptationSpeed);
        }
        else if (smoothedFPS > targetFPS * 0.95f && currentQualityLevel < 1.0f)
        {
            // FPS хороший - повышаем качество
            currentQualityLevel = Mathf.Min(1.0f, currentQualityLevel + Time.deltaTime * adaptationSpeed * 0.5f);
        }
    }
    
    // Настройка GPU Resident Drawer через рефлексию (костыль, но работает)
    private void SetGPUResident(bool enabled, bool occlusionCulling)
    {
        var urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
        if (urpAsset == null) return;
        
        // Используем рефлексию для установки приватных полей
        System.Type type = urpAsset.GetType();
        
        // Включаем/выключаем GPU Resident Drawer
        var gpuResidentField = type.GetField("m_GPUResidentDrawer", 
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
        
        if (gpuResidentField != null)
            gpuResidentField.SetValue(urpAsset, enabled ? 1 : 0);
            
        // Включаем/выключаем GPU Occlusion Culling
        var occlusionCullingField = type.GetField("m_GPUOcclusionCulling", 
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
            
        if (occlusionCullingField != null && enabled)
            occlusionCullingField.SetValue(urpAsset, occlusionCulling);
    }
    
    // Отображение статистики
    void OnGUI()
    {
        GUI.Label(new Rect(10, 10, 300, 30), $"GPU Resident: {enableGPUResident} | Occlusion: {enableOcclusionCulling}");
        GUI.Label(new Rect(10, 40, 300, 30), $"FPS: {Mathf.Round(smoothedFPS)} | Качество: {currentQualityLevel:F2}");
        GUI.Label(new Rect(10, 70, 300, 30), $"Объекты: {visibleObjectsCount}/{totalObjectsCount} (отсечено: {culledObjectsCount})");
    }
}

// ObjectCell.cs - ячейка для пространственного разделения объектов
using UnityEngine;
using System.Collections.Generic;
 
public class ObjectCell
{
    private Vector3Int position;
    private Vector3 worldCenter;
    private float size;
    private List<GameObject> objects = new List<GameObject>();
    private Bounds cellBounds;
    
    public int ObjectCount => objects.Count;
    
    public ObjectCell(Vector3Int pos, float cellSize)
    {
        position = pos;
        size = cellSize;
        
        // Вычисляем центр ячейки в мировых координатах
        worldCenter = new Vector3(
            (position.x + 0.5f) * size,
            (position.y + 0.5f) * size,
            (position.z + 0.5f) * size
        );
        
        // Создаем границы ячейки
        cellBounds = new Bounds(worldCenter, Vector3.one * size);
    }
    
    public void AddObject(GameObject obj)
    {
        objects.Add(obj);
    }
    
    public void SetVisibility(bool isVisible)
    {
        // Для оптимизации проверяем, не изменилось ли состояние
        if (objects.Count > 0 && objects[0].activeSelf != isVisible)
        {
            foreach (GameObject obj in objects)
            {
                obj.SetActive(isVisible);
            }
        }
    }
    
    public bool IsVisible(Camera camera)
    {
        // Быстрая проверка на видимость границ ячейки
        return GeometryUtility.TestPlanesAABB(GeometryUtility.CalculateFrustumPlanes(camera), cellBounds);
    }
}

// GPUResidentOptimizer.cs - компонент для оптимизации конкретного объекта
using UnityEngine;
 
[RequireComponent(typeof(MeshRenderer))]
public class GPUResidentOptimizer : MonoBehaviour
{
    [SerializeField] private bool forceDisableGPUResident = false;
    [SerializeField] private bool updateLODBasedOnPerformance = true;
    [SerializeField] private Mesh[] lodMeshes;
    [SerializeField] private float[] lodDistances = { 10f, 30f, 60f, 100f };
    
    private MeshRenderer meshRenderer;
    private MeshFilter meshFilter;
    private int currentLOD = 0;
    
    void Awake()
    {
        meshRenderer = GetComponent<MeshRenderer>();
        meshFilter = GetComponent<MeshFilter>();
        
        // Если требуется принудительно отключить GPU Resident
        if (forceDisableGPUResident && GetComponent<DisallowGPUDrivenRendering>() == null)
        {
            gameObject.AddComponent<DisallowGPUDrivenRendering>();
        }
    }
    
    void Update()
    {
        if (lodMeshes == null || lodMeshes.Length == 0) return;
        
        // Получаем глобальное качество из менеджера
        float qualityLevel = FindObjectOfType<GPUResidentManager>()?.GetQualityLevel() ?? 1.0f;
        
        if (Camera.main != null)
        {
            float distance = Vector3.Distance(transform.position, Camera.main.transform.position);
            
            // Если включено адаптивное LOD, корректируем дистанции на основе качества
            if (updateLODBasedOnPerformance)
            {
                distance /= qualityLevel;
            }
            
            // Определяем нужный LOD
            int targetLOD = lodMeshes.Length - 1; // По умолчанию самый низкий
            
            for (int i = 0; i < lodDistances.Length && i < lodMeshes.Length; i++)
            {
                if (distance <= lodDistances[i])
                {
                    targetLOD = i;
                    break;
                }
            }
            
            // Если нужно поменять LOD
            if (targetLOD != currentLOD && meshFilter != null)
            {
                meshFilter.mesh = lodMeshes[targetLOD];
                currentLOD = targetLOD;
            }
        }
    }
}

// GPUResidentAnalyzer.cs - инструмент для анализа производительности
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class GPUResidentAnalyzer : MonoBehaviour
{
    [SerializeField] private bool runOnStart = false;
    [SerializeField] private int warmupFrames = 100;
    [SerializeField] private int measuredFrames = 500;
    [SerializeField] private bool toggleGPUResidentDuringTest = true;
    
    private float[] fpsWithEnabled;
    private float[] fpsWithDisabled;
    private int frameCounter = 0;
    private bool isRunning = false;
    private bool originalGPUResidentState;
    
    void Start()
    {
        if (runOnStart)
            StartCoroutine(RunBenchmark());
    }
    
    public void RunTest()
    {
        StartCoroutine(RunBenchmark());
    }
    
    IEnumerator RunBenchmark()
    {
        if (isRunning) yield break;
        isRunning = true;
        
        GPUResidentManager manager = FindObjectOfType<GPUResidentManager>();
        if (manager == null)
        {
            Debug.LogError("Не найден GPUResidentManager");
            isRunning = false;
            yield break;
        }
        
        // Сохраняем оригинальное состояние
        originalGPUResidentState = manager.IsGPUResidentEnabled();
        
        // Тест с включенным GPU Resident
        fpsWithEnabled = new float[measuredFrames];
        manager.SetGPUResident(true);
        
        Debug.Log("Разогрев с GPU Resident...");
        yield return new WaitForSeconds(1); // Даем время на инициализацию
        
        for (frameCounter = 0; frameCounter < warmupFrames; frameCounter++)
            yield return null;
            
        Debug.Log("Сбор данных с GPU Resident...");
        
        for (frameCounter = 0; frameCounter < measuredFrames; frameCounter++)
        {
            fpsWithEnabled[frameCounter] = 1.0f / Time.deltaTime;
            yield return null;
        }
        
        // Если тест только с включенным режимом, пропускаем вторую часть
        if (!toggleGPUResidentDuringTest)
        {
            AnalyzeResults();
            manager.SetGPUResident(originalGPUResidentState);
            isRunning = false;
            yield break;
        }
        
        // Тест с выключенным GPU Resident
        fpsWithDisabled = new float[measuredFrames];
        manager.SetGPUResident(false);
        
        Debug.Log("Разогрев без GPU Resident...");
        yield return new WaitForSeconds(1);
        
        for (frameCounter = 0; frameCounter < warmupFrames; frameCounter++)
            yield return null;
            
        Debug.Log("Сбор данных без GPU Resident...");
        
        for (frameCounter = 0; frameCounter < measuredFrames; frameCounter++)
        {
            fpsWithDisabled[frameCounter] = 1.0f / Time.deltaTime;
            yield return null;
        }
        
        // Восстанавливаем оригинальное состояние
        manager.SetGPUResident(originalGPUResidentState);
        
        // Анализ результатов
        AnalyzeResults();
        
        isRunning = false;
    }
    
    private void AnalyzeResults()
    {
        if (fpsWithEnabled == null) return;
        
        float avgEnabledFPS = CalculateAverage(fpsWithEnabled);
        string result = $"Средний FPS с GPU Resident: {avgEnabledFPS:F1}";
        
        if (fpsWithDisabled != null)
        {
            float avgDisabledFPS = CalculateAverage(fpsWithDisabled);
            float improvement = (avgEnabledFPS / avgDisabledFPS - 1.0f) * 100f;
            
            result += $"\nСредний FPS без GPU Resident: {avgDisabledFPS:F1}";
            result += $"\nУлучшение: {improvement:F1}%";
        }
        
        Debug.Log(result);
    }
    
    private float CalculateAverage(float[] values)
    {
        float sum = 0;
        for (int i = 0; i < values.Length; i++)
            sum += values[i];
        return sum / values.Length;
    }
}

// GPUGeometryCache.cs - система кэширования геометрии на GPU
using UnityEngine;
using System.Collections.Generic;
 
public class GPUGeometryCache : MonoBehaviour
{
[SerializeField] private int maxCachedMeshes = 100;
[SerializeField] private bool preloadCommonMeshes = true;
 
private Dictionary<int, CachedMeshData> meshCache = new Dictionary<int, CachedMeshData>();
private Queue<int> lruQueue = new Queue<int>();
 
// Структура для хранения данных о закешированном меше
private class CachedMeshData
{
    public Mesh mesh;
    public int useCount;
    public float lastUseTime;
 
    public CachedMeshData(Mesh m)
    {
        mesh = m;
        useCount = 1;
        lastUseTime = Time.realtimeSinceStartup;
    }
}
 
void Start()
{
    if (preloadCommonMeshes)
        PreloadCommonMeshes();
}
 
private void PreloadCommonMeshes()
{
    // Предварительно кэшируем часто используемые примитивы
    CacheMesh(Resources.GetBuiltinResource<Mesh>("Cube.fbx"));
    CacheMesh(Resources.GetBuiltinResource<Mesh>("Sphere.fbx"));
    CacheMesh(Resources.GetBuiltinResource<Mesh>("Cylinder.fbx"));
    CacheMesh(Resources.GetBuiltinResource<Mesh>("Plane.fbx"));
    CacheMesh(Resources.GetBuiltinResource<Mesh>("Quad.fbx"));
}
 
public Mesh CacheMesh(Mesh originalMesh)
{
    int meshID = originalMesh.GetInstanceID();
    
    // Если меш уже в кэше, обновляем статистику и возвращаем его
    if (meshCache.TryGetValue(meshID, out CachedMeshData cachedData))
    {
        cachedData.useCount++;
        cachedData.lastUseTime = Time.realtimeSinceStartup;
        
        // Обновляем LRU очередь
        lruQueue.Enqueue(meshID);
        if (lruQueue.Count > maxCachedMeshes * 2)
            lruQueue.Dequeue(); // Удаляем старые записи из очереди
            
        return cachedData.mesh;
    }
    
    // Если кэш переполнен, удаляем наименее используемый меш
    if (meshCache.Count >= maxCachedMeshes)
    {
        EvictLeastUsedMesh();
    }
    
    // Создаем копию меша для кэширования
    // Это гарантирует, что даже если оригинал будет удален, 
    // у нас останется рабочая копия на GPU
    Mesh cachedMesh = Instantiate(originalMesh);
    
    // Важно для GPU Resident Drawer - делаем меш доступным для вычислений на GPU
    cachedMesh.MarkDynamic();
    
    // Загружаем меш в видеопамять
    cachedMesh.UploadMeshData(true);
    
    // Добавляем в кэш
    meshCache[meshID] = new CachedMeshData(cachedMesh);
    lruQueue.Enqueue(meshID);
    
    return cachedMesh;
}
 
private void EvictLeastUsedMesh()
{
    // Находим наименее используемый меш
    int leastUsedID = -1;
    float oldestTime = float.MaxValue;
    
    foreach (var pair in meshCache)
    {
        if (pair.Value.lastUseTime < oldestTime)
        {
            oldestTime = pair.Value.lastUseTime;
            leastUsedID = pair.Key;
        }
    }
    
    if (leastUsedID != -1)
    {
        // Удаляем меш из кэша
        Destroy(meshCache[leastUsedID].mesh);
        meshCache.Remove(leastUsedID);
    }
}
 
// Очистка ресурсов при уничтожении
void OnDestroy()
{
    foreach (var cachedData in meshCache.Values)
    {
        if (cachedData.mesh != null)
            Destroy(cachedData.mesh);
    }
    
    meshCache.Clear();
}
}

// MaterialBatchOptimizer.cs - оптимизатор материалов для GPU Resident Drawer
using UnityEngine;
using System.Collections.Generic;
 
public class MaterialBatchOptimizer : MonoBehaviour
{
[SerializeField] private bool combineSimilarMaterials = true;
[SerializeField] private float colorTolerance = 0.1f;
[SerializeField] private float textureTileToleranse = 0.1f;
 
private Dictionary<int, Material> optimizedMaterials = new Dictionary<int, Material>();
 
void Start()
{
    if (combineSimilarMaterials)
        OptimizeMaterials();
}
 
private void OptimizeMaterials()
{
    // Собираем все рендереры на сцене
    MeshRenderer[] renderers = FindObjectsOfType<MeshRenderer>();
    Debug.Log($"Найдено {renderers.Length} рендереров для оптимизации материалов");
    
    // Сначала собираем все используемые материалы
    HashSet<Material> uniqueMaterials = new HashSet<Material>();
    foreach (MeshRenderer renderer in renderers)
    {
        foreach (Material mat in renderer.sharedMaterials)
        {
            if (mat != null)
                uniqueMaterials.Add(mat);
        }
    }
    
    Debug.Log($"Найдено {uniqueMaterials.Count} уникальных материалов");
    
    // Создаем группы похожих материалов
    List<Material[]> similarGroups = GroupSimilarMaterials(uniqueMaterials);
    Debug.Log($"Сформировано {similarGroups.Count} групп похожих материалов");
    
    // Для каждой группы создаем один оптимизированный материал
    foreach (Material[] group in similarGroups)
    {
        if (group.Length <= 1) continue;
        
        // Создаем новый материал на основе первого в группе
        Material optimized = new Material(group[0]);
        optimized.name = $"Optimized_{group[0].name}_{group.Length}materials";
        
        // Регистрируем оптимизированный материал для каждого исходного
        foreach (Material original in group)
        {
            optimizedMaterials[original.GetInstanceID()] = optimized;
        }
    }
    
    // Применяем оптимизированные материалы ко всем рендерерам
    int replacedCount = 0;
    foreach (MeshRenderer renderer in renderers)
    {
        Material[] materials = renderer.sharedMaterials;
        bool needsUpdate = false;
        
        for (int i = 0; i < materials.Length; i++)
        {
            int matID = materials[i].GetInstanceID();
            if (optimizedMaterials.TryGetValue(matID, out Material optimized))
            {
                materials[i] = optimized;
                needsUpdate = true;
                replacedCount++;
            }
        }
        
        if (needsUpdate)
            renderer.sharedMaterials = materials;
    }
    
    Debug.Log($"Заменено {replacedCount} экземпляров материалов");
}