Batch Transform и Batch Gizmo Drawing API в Unity

Transform.TransformPoints
Transform.TransformVectors
Transform.TransformDirections
Transform.InverseTransformPoints
Transform.InverseTransformVectors
Transform.InverseTransformDirections

public void TransformPoints(Span<Vector3> points);

public void TransformPoints(ReadOnlySpan<Vector3> inPoints, Span<Vector3> outPoints);

// Создаём массив точек в локальных координатах
Vector3[] localPoints = new Vector3[1000];
// Заполняем массив какими-то данными...
 
// Создаём массив для результата
Vector3[] worldPoints = new Vector3[1000];
 
// Преобразуем все точки за один вызов
transform.TransformPoints(localPoints, worldPoints);
 
// Теперь worldPoints содержит все точки в мировых координатах

// Пример использования BatchTransform внутри Job System
public struct TransformPointsJob : IJobParallelFor
{
    public TransformAccess transform;
    public NativeArray<Vector3> inputPoints;
    public NativeArray<Vector3> outputPoints;
    
    public void Execute(int index)
    {
        // Обрабатываем часть данных с помощью BatchTransform
        int batchSize = 1000;
        int startIndex = index * batchSize;
        
        if (startIndex < inputPoints.Length)
        {
            int count = Math.Min(batchSize, inputPoints.Length - startIndex);
            transform.TransformPoints(
                inputPoints.GetSubArray(startIndex, count),
                outputPoints.GetSubArray(startIndex, count));
        }
    }
}

public class TransformationsVisualizer : MonoBehaviour
{
    private readonly Vector3[] _points = {
        Vector3.zero,
        Vector3.right,
        Vector3.zero,
        Vector3.up,
        Vector3.zero,
        new Vector3(1f, 1f, 0f)
    };
    
    private readonly Vector3[] _transformedPoints = new Vector3[6];
    private readonly Vector3[] _transformedVectors = new Vector3[6];
    private readonly Vector3[] _transformedDirections = new Vector3[6];
    
    private void OnDrawGizmosSelected()
    {
        // Трансформируем одни и те же данные разными способами
        transform.TransformPoints(_points, _transformedPoints);
        transform.TransformVectors(_points, _transformedVectors);
        transform.TransformDirections(_points, _transformedDirections);
        
        // Отображаем исходные данные
        Gizmos.color = Color.blue;
        Gizmos.DrawLineList(_points);
        
        // Отображаем точки - учитывают позицию, вращение и масштаб
        Gizmos.color = Color.green;
        Gizmos.DrawLineList(_transformedPoints);
        
        // Отображаем векторы - учитывают вращение и масштаб
        Gizmos.color = Color.red;
        Gizmos.DrawLineList(_transformedVectors);
        
        // Отображаем направления - учитывают только вращение
        Gizmos.color = Color.yellow;
        Gizmos.DrawLineList(_transformedDirections);
    }
}

// Единожды создаём буферы
private Vector3[] _localPoints = new Vector3[MAX_POINTS];
private Vector3[] _worldPoints = new Vector3[MAX_POINTS];
 
private void Update()
{
    // Заполняем _localPoints новыми данными...
    
    // Используем существующие буферы
    transform.TransformPoints(_localPoints, _worldPoints);
    
    // Используем _worldPoints...
}

public class Vector3ArrayPool
{
    private readonly Dictionary<int, Stack<Vector3[]>> _pools = new Dictionary<int, Stack<Vector3[]>>();
    
    public Vector3[] Get(int size)
    {
        if (!_pools.TryGetValue(size, out var pool))
        {
            pool = new Stack<Vector3[]>();
            _pools[size] = pool;
        }
        
        return pool.Count > 0 ? pool.Pop() : new Vector3[size];
    }
    
    public void Return(Vector3[] array)
    {
        if (array == null) return;
        
        if (!_pools.TryGetValue(array.Length, out var pool))
        {
            pool = new Stack<Vector3[]>();
            _pools[array.Length] = pool;
        }
        
        pool.Push(array);
    }
}

Vector3[] hugeArray = new Vector3[10000];
 
// Трансформируем только часть массива
var span = new Span<Vector3>(hugeArray, 100, 500);
transform.TransformPoints(span);

using Unity.Collections;
using Unity.Jobs;
using UnityEngine;
using UnityEngine.Jobs;
 
public class ParallelTransformer : MonoBehaviour
{
    [SerializeField] private Transform[] _targets;
    private Vector3[] _sourcePoints;
    private Vector3[] _transformedPoints;
    
    private void ProcessPointsInParallel()
    {
        // Подготавливаем данные
        int pointsPerTarget = 1000;
        int totalPoints = _targets.Length * pointsPerTarget;
        
        if (_sourcePoints == null || _sourcePoints.Length != totalPoints)
        {
            _sourcePoints = new Vector3[totalPoints];
            _transformedPoints = new Vector3[totalPoints];
            
            // Заполняем массив исходных точек...
        }
        
        // Создаём нативные массивы для использования в job
        var nativeSourcePoints = new NativeArray<Vector3>(_sourcePoints, Allocator.TempJob);
        var nativeTransformedPoints = new NativeArray<Vector3>(_transformedPoints, Allocator.TempJob);
        
        // Создаём TransformAccessArray для безопасного доступа к трансформациям из job
        var transforms = new TransformAccessArray(_targets);
        
        // Создаём и запускаем job
        var job = new TransformPointsJob
        {
            PointsPerTarget = pointsPerTarget,
            SourcePoints = nativeSourcePoints,
            TransformedPoints = nativeTransformedPoints
        };
        
        // Запускаем job и ждём её завершения
        JobHandle handle = job.Schedule(transforms);
        handle.Complete();
        
        // Копируем результаты обратно
        nativeTransformedPoints.CopyTo(_transformedPoints);
        
        // Освобождаем нативные ресурсы
        nativeSourcePoints.Dispose();
        nativeTransformedPoints.Dispose();
        transforms.Dispose();
    }
}
 
// Определение структуры job
public struct TransformPointsJob : IJobParallelForTransform
{
    public int PointsPerTarget;
    public NativeArray<Vector3> SourcePoints;
    [WriteOnly] public NativeArray<Vector3> TransformedPoints;
    
    public void Execute(int index, TransformAccess transform)
    {
        int startIndex = index * PointsPerTarget;
        
        // Создаём временные спаны для BatchTransform
        var sourceSpan = SourcePoints.Slice(startIndex, PointsPerTarget);
        var targetSpan = TransformedPoints.Slice(startIndex, PointsPerTarget);
        
        // Выполняем BatchTransform
        transform.TransformPoints(sourceSpan, targetSpan);
    }
}

public class ProceduralWavySurface : MonoBehaviour
{
    [SerializeField] private int _resolution = 100;
    [SerializeField] private float _waveAmplitude = 0.5f;
    [SerializeField] private float _waveFrequency = 2f;
    
    private MeshFilter _meshFilter;
    private Vector3[] _localVertices;
    private Vector3[] _worldVertices;
    
    private void Start()
    {
        _meshFilter = GetComponent<MeshFilter>();
        if (_meshFilter == null)
        {
            _meshFilter = gameObject.AddComponent<MeshFilter>();
            gameObject.AddComponent<MeshRenderer>();
        }
        
        GenerateMesh();
    }
    
    private void Update()
    {
        // Обновляем вершины меша в соответствии со временем
        UpdateMeshVertices(Time.time);
    }
    
    private void GenerateMesh()
    {
        int vertexCount = _resolution * _resolution;
        
        // Создаём новый меш
        Mesh mesh = new Mesh();
        mesh.name = "WavySurface";
        
        // Инициализируем массивы
        _localVertices = new Vector3[vertexCount];
        _worldVertices = new Vector3[vertexCount];
        
        // Заполняем массив вершин
        float step = 1f / (_resolution - 1);
        for (int z = 0; z < _resolution; z++)
        {
            for (int x = 0; x < _resolution; x++)
            {
                int index = z * _resolution + x;
                float posX = x * step - 0.5f;
                float posZ = z * step - 0.5f;
                
                _localVertices[index] = new Vector3(posX, 0, posZ);
            }
        }
        
        // Создаём индексы для треугольников
        int[] triangles = new int[(_resolution - 1) * (_resolution - 1) * 6];
        int triangleIndex = 0;
        
        for (int z = 0; z < _resolution - 1; z++)
        {
            for (int x = 0; x < _resolution - 1; x++)
            {
                int vertexIndex = z * _resolution + x;
                
                triangles[triangleIndex++] = vertexIndex;
                triangles[triangleIndex++] = vertexIndex + _resolution + 1;
                triangles[triangleIndex++] = vertexIndex + _resolution;
                
                triangles[triangleIndex++] = vertexIndex;
                triangles[triangleIndex++] = vertexIndex + 1;
                triangles[triangleIndex++] = vertexIndex + _resolution + 1;
            }
        }
        
        // Заполняем меш данными
        mesh.vertices = _localVertices;
        mesh.triangles = triangles;
        
        // Обновляем нормали и uv-координаты
        mesh.RecalculateNormals();
        mesh.RecalculateBounds();
        
        // Применяем меш
        _meshFilter.mesh = mesh;
        
        // Инициализируем первую волну
        UpdateMeshVertices(0);
    }
    
    private void UpdateMeshVertices(float time)
    {
        // Создаём волны в локальном пространстве
        for (int i = 0; i < _localVertices.Length; i++)
        {
            Vector3 vertex = _localVertices[i];
            float dist = Mathf.Sqrt(vertex.x * vertex.x + vertex.z * vertex.z);
            float offset = dist * _waveFrequency + time;
            vertex.y = Mathf.Sin(offset) * _waveAmplitude;
            _localVertices[i] = vertex;
        }
        
        // Применяем изменения к мешу
        _meshFilter.mesh.vertices = _localVertices;
        _meshFilter.mesh.RecalculateNormals();
    }
    
    // Метод для получения вершин в мировом пространстве
    public Vector3[] GetWorldVertices()
    {
        transform.TransformPoints(_localVertices, _worldVertices);
        return _worldVertices;
    }
}

// Неоптимизированный подход - последовательные вызовы
for (int i = 0; i < 10000; i++)
{
    worldPoints[i] = myTransform.TransformPoint(localPoints[i]);
}
 
// Оптимизированный подход - единый вызов с векторизацией
myTransform.TransformPoints(localPoints, worldPoints);

using System.Diagnostics;
using Unity.Mathematics;
using UnityEngine;
using Debug = UnityEngine.Debug;
 
public class TransformationBenchmark : MonoBehaviour
{
    [SerializeField] private int pointCount = 1_000_000;
    private Vector3[] points;
    private Vector3[] results1;
    private Vector3[] results2;
    
    private void Start()
    {
        // Инициализация тестовых данных
        points = new Vector3[pointCount];
        results1 = new Vector3[pointCount];
        results2 = new Vector3[pointCount];
        
        // Заполняем случайными значениями
        for (int i = 0; i < pointCount; i++)
        {
            points[i] = new Vector3(
                UnityEngine.Random.Range(-10f, 10f),
                UnityEngine.Random.Range(-10f, 10f),
                UnityEngine.Random.Range(-10f, 10f)
            );
        }
        
        // Запускаем тесты
        RunBenchmark();
    }
    
    private void RunBenchmark()
    {
        // Традиционный подход
        Stopwatch sw1 = new Stopwatch();
        sw1.Start();
        
        for (int i = 0; i < pointCount; i++)
        {
            results1[i] = transform.TransformPoint(points[i]);
        }
        
        sw1.Stop();
        long traditionalTime = sw1.ElapsedMilliseconds;
        
        // Пакетный подход
        Stopwatch sw2 = new Stopwatch();
        sw2.Start();
        
        transform.TransformPoints(points, results2);
        
        sw2.Stop();
        long batchTime = sw2.ElapsedMilliseconds;
        
        // Проверка корректности результатов
        bool resultsMatch = true;
        float maxDifference = 0f;
        
        for (int i = 0; i < pointCount; i++)
        {
            float diff = Vector3.Distance(results1[i], results2[i]);
            maxDifference = Mathf.Max(maxDifference, diff);
            
            if (diff > 0.0001f)
            {
                resultsMatch = false;
                break;
            }
        }
        
        // Вывод результатов
        Debug.Log($"Традиционный подход: {traditionalTime} мс");
        Debug.Log($"Пакетный подход: {batchTime} мс");
        Debug.Log($"Ускорение: {(float)traditionalTime / batchTime:F2}x");
        Debug.Log($"Результаты совпадают: {resultsMatch}, максимальная разница: {maxDifference}");
    }
}

private void ProcessPoints(Vector3[] localPoints, Vector3[] worldPoints)
{
#if UNITY_ANDROID || UNITY_IOS
    // На мобильных устройствах может быть эффективнее обрабатывать 
    // данные меньшими порциями для лучшего кэширования
    const int batchSize = 1000;
    for (int i = 0; i < localPoints.Length; i += batchSize)
    {
        int count = Mathf.Min(batchSize, localPoints.Length - i);
        transform.TransformPoints(
            new Span<Vector3>(localPoints, i, count),
            new Span<Vector3>(worldPoints, i, count));
    }
#else
    // На ПК и консолях можно обрабатывать все данные за один проход
    transform.TransformPoints(localPoints, worldPoints);
#endif
}

Gizmos.DrawLineList(ReadOnlySpan<Vector3> points)
Gizmos.DrawLineStrip(ReadOnlySpan<Vector3> points, bool closed)

private readonly Vector3[] _gridPoints = new Vector3[100]; // 50 линий
 
private void CreateGrid()
{
    int index = 0;
    // Создаём горизонтальные линии
    for (int i = 0; i < 5; i++)
    {
        float y = i - 2.0f; // от -2 до 2
        _gridPoints[index++] = new Vector3(-2, y, 0);
        _gridPoints[index++] = new Vector3(2, y, 0);
    }
    
    // Создаём вертикальные линии
    for (int i = 0; i < 5; i++)
    {
        float x = i - 2.0f; // от -2 до 2
        _gridPoints[index++] = new Vector3(x, -2, 0);
        _gridPoints[index++] = new Vector3(x, 2, 0);
    }
}
 
private void OnDrawGizmos()
{
    // Отрисовываем всю сетку одним вызовом
    Gizmos.color = Color.white;
    Gizmos.DrawLineList(_gridPoints);
}

private readonly Vector3[] _hexagonPoints = new Vector3[6];
 
private void CreateHexagon()
{
    float radius = 2.0f;
    
    for (int i = 0; i < 6; i++)
    {
        float angle = i * Mathf.PI * 2 / 6;
        _hexagonPoints[i] = new Vector3(Mathf.Cos(angle) * radius, Mathf.Sin(angle) * radius, 0);
    }
}
 
private void OnDrawGizmos()
{
    // Отрисовываем шестиугольник одним вызовом
    Gizmos.color = Color.green;
    Gizmos.DrawLineStrip(_hexagonPoints, true); // true = замкнутый контур
}

public class NavigationGraph : MonoBehaviour
{
    [SerializeField] private List<Transform> _nodes = new List<Transform>();
    [SerializeField] private float _connectionRadius = 5f;
    
    // Кэшированные массивы для отрисовки
    private List<Vector3> _connectionPoints = new List<Vector3>();
    private bool _connectionsNeedRebuild = true;
    
    // Обновляем кэш точек при изменении узлов
    private void OnValidate()
    {
        _connectionsNeedRebuild = true;
    }
    
    private void BuildConnections()
    {
        _connectionPoints.Clear();
        
        // Строим соединения между узлами
        for (int i = 0; i < _nodes.Count; i++)
        {
            if (_nodes[i] == null) continue;
            
            Vector3 nodePos = _nodes[i].position;
            
            for (int j = i + 1; j < _nodes.Count; j++)
            {
                if (_nodes[j] == null) continue;
                
                Vector3 otherPos = _nodes[j].position;
                
                // Если узлы достаточно близко, соединяем их
                if (Vector3.Distance(nodePos, otherPos) <= _connectionRadius)
                {
                    _connectionPoints.Add(nodePos);
                    _connectionPoints.Add(otherPos);
                }
            }
        }
        
        _connectionsNeedRebuild = false;
    }
    
    private void OnDrawGizmos()
    {
        // Отрисовываем узлы
        Gizmos.color = Color.blue;
        foreach (var node in _nodes)
        {
            if (node != null)
            {
                Gizmos.DrawSphere(node.position, 0.3f);
            }
        }
        
        // Строим соединения при необходимости
        if (_connectionsNeedRebuild)
        {
            BuildConnections();
        }
        
        // Отрисовываем соединения
        if (_connectionPoints.Count > 0)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawLineList(_connectionPoints.ToArray());
        }
    }
}

public class TerrainPathVisualizer : MonoBehaviour
{
    [SerializeField] private List<Vector3> _pathPoints = new List<Vector3>();
    [SerializeField] private float _maxDrawDistance = 100f;
    
    private void OnDrawGizmosSelected()
    {
        if (_pathPoints.Count < 2) return;
        
        // Получаем позицию камеры сцены
        Vector3 cameraPos = SceneView.lastActiveSceneView?.camera?.transform.position ?? Vector3.zero;
        float distanceToCamera = Vector3.Distance(transform.position, cameraPos);
        
        // Если слишком далеко, не отрисовываем детали
        if (distanceToCamera > _maxDrawDistance) return;
        
        // Определяем уровень детализации в зависимости от расстояния
        int stride = Mathf.Max(1, Mathf.FloorToInt(distanceToCamera / 10f));
        
        // Создаём подмножество точек для отрисовки
        List<Vector3> visiblePoints = new List<Vector3>();
        for (int i = 0; i < _pathPoints.Count; i += stride)
        {
            visiblePoints.Add(_pathPoints[i]);
        }
        
        // Добавляем последнюю точку, если её нет
        if (_pathPoints.Count > 0 && visiblePoints[visiblePoints.Count - 1] != _pathPoints[_pathPoints.Count - 1])
        {
            visiblePoints.Add(_pathPoints[_pathPoints.Count - 1]);
        }
        
        // Отрисовываем путь
        Gizmos.color = Color.red;
        Gizmos.DrawLineStrip(visiblePoints.ToArray(), false);
    }
}

public class GizmoPerformanceTest : MonoBehaviour
{
    [SerializeField] private int _lineCount = 10000;
    private Vector3[] _points;
    private bool _useBatchDrawing = false;
    private float _standardDrawTime;
    private float _batchDrawTime;
 
    private void OnValidate()
    {
        if (_points == null || _points.Length != _lineCount * 2)
        {
            GenerateRandomLines();
        }
    }
 
    private void GenerateRandomLines()
    {
        _points = new Vector3[_lineCount * 2];
        for (int i = 0; i < _lineCount; i++)
        {
            int baseIndex = i * 2;
            _points[baseIndex] = Random.insideUnitSphere * 5;
            _points[baseIndex + 1] = Random.insideUnitSphere * 5;
        }
    }
 
    private void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.cyan;
        
        // Замеряем время для традиционного подхода
        float startTime = Time.realtimeSinceStartup;
        
        if (!_useBatchDrawing)
        {
            for (int i = 0; i < _lineCount; i++)
            {
                int baseIndex = i * 2;
                Gizmos.DrawLine(_points[baseIndex], _points[baseIndex + 1]);
            }
            _standardDrawTime = Time.realtimeSinceStartup - startTime;
        }
        else
        {
            // Замеряем время для пакетного подхода
            Gizmos.DrawLineList(_points);
            _batchDrawTime = Time.realtimeSinceStartup - startTime;
        }
 
        // Отображаем результаты измерений
        GUI.color = Color.white;
        Handles.BeginGUI();
        GUILayout.Label($"Стандартный способ: {_standardDrawTime * 1000:F2} мс");
        GUILayout.Label($"Пакетный способ: {_batchDrawTime * 1000:F2} мс");
        if (_standardDrawTime > 0 && _batchDrawTime > 0)
        {
            GUILayout.Label($"Ускорение: {_standardDrawTime / _batchDrawTime:F2}x");
        }
        GUILayout.Toggle(_useBatchDrawing, "Использовать батчинг");
        if (GUILayout.Button("Переключить метод"))
        {
            _useBatchDrawing = !_useBatchDrawing;
        }
        Handles.EndGUI();
    }
}

public class CustomStyledGizmos : MonoBehaviour
{
    [SerializeField] private Color _lineColor = Color.magenta;
    [SerializeField] private float _lineWidth = 2f;
    private Vector3[] _starPoints;
 
    private void OnEnable()
    {
        // Создаём звезду из 10 вершин
        _starPoints = new Vector3[10];
        for (int i = 0; i < 10; i++)
        {
            float angle = i * Mathf.PI * 2 / 10;
            float radius = i % 2 == 0 ? 2f : 1f; // Чередуем внешний и внутренний радиусы
            _starPoints[i] = new Vector3(Mathf.Cos(angle) * radius, Mathf.Sin(angle) * radius, 0);
        }
    }
 
    private void OnDrawGizmos()
    {
        // Сохраняем текущую матрицу трансформации
        Matrix4x4 oldMatrix = Gizmos.matrix;
        Color oldColor = Gizmos.color;
        
        // Применяем нашу трансформацию
        Gizmos.matrix = transform.localToWorldMatrix;
        Gizmos.color = _lineColor;
        
        // Отрисовываем звезду с кастомным стилем
        Gizmos.DrawLineStrip(_starPoints, true);
        
        // Восстанавливаем исходные настройки
        Gizmos.matrix = oldMatrix;
        Gizmos.color = oldColor;
    }
 
    // Добавляем функцию для настройки толщины линий в редакторе
    #if UNITY_EDITOR
    [UnityEditor.DrawGizmo(UnityEditor.GizmoType.Selected | UnityEditor.GizmoType.NonSelected)]
    private static void DrawGizmoCustomWidth(CustomStyledGizmos script, UnityEditor.GizmoType gizmoType)
    {
        UnityEditor.Handles.color = script._lineColor;
        if (UnityEditor.SceneView.currentDrawingSceneView != null)
        {
            UnityEditor.Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
        }
        
        // Настраиваем толщину линий
        float oldWidth = UnityEditor.Handles.lineThickness;
        UnityEditor.Handles.lineThickness = script._lineWidth;
        
        // Можно добавить дополнительную кастомную отрисовку здесь
        
        // Восстанавливаем исходную толщину
        UnityEditor.Handles.lineThickness = oldWidth;
    }
    #endif
}

public class LargeDatasetVisualizer : MonoBehaviour
{
    [SerializeField] private int _totalPointCount = 1_000_000;
    [SerializeField] private int _chunkSize = 10000;
    
    private List<Vector3[]> _chunks = new List<Vector3[]>();
    private bool _dataGenerated = false;
 
    private void GenerateData()
    {
        // Создаём чанки для точек
        int chunkCount = Mathf.CeilToInt((float)_totalPointCount / _chunkSize);
        _chunks.Clear();
        
        for (int i = 0; i < chunkCount; i++)
        {
            int pointsInThisChunk = Mathf.Min(_chunkSize, _totalPointCount - i * _chunkSize);
            if (pointsInThisChunk <= 0) break;
            
            Vector3[] chunk = new Vector3[pointsInThisChunk * 2]; // *2 для пар точек (начало-конец линии)
            
            // Заполняем чанк случайными линиями
            for (int j = 0; j < pointsInThisChunk; j++)
            {
                Vector3 center = Random.insideUnitSphere * 50;
                Vector3 direction = Random.insideUnitSphere.normalized;
                
                chunk[j * 2] = center;
                chunk[j * 2 + 1] = center + direction * Random.Range(0.1f, 2f);
            }
            
            _chunks.Add(chunk);
        }
        
        _dataGenerated = true;
    }
 
    private void OnDrawGizmos()
    {
        if (!_dataGenerated)
        {
            GenerateData();
        }
        
        // Находим позицию камеры сцены для проверки видимости
        Vector3 cameraPos = Vector3.zero;
        float cameraDistance = 100f;
        
        #if UNITY_EDITOR
        if (UnityEditor.SceneView.lastActiveSceneView?.camera != null)
        {
            cameraPos = UnityEditor.SceneView.lastActiveSceneView.camera.transform.position;
            cameraDistance = UnityEditor.SceneView.lastActiveSceneView.camera.farClipPlane;
        }
        #endif
        
        // Отрисовываем только видимые чанки
        Gizmos.color = Color.yellow;
        foreach (var chunk in _chunks)
        {
            // Проверяем, находится ли чанк в поле зрения камеры
            // (это упрощенная проверка, в реальном проекте нужно использовать более точный алгоритм)
            Vector3 chunkCenter = chunk[0]; // Используем первую точку как приблизительный центр чанка
            if (Vector3.Distance(chunkCenter, cameraPos) > cameraDistance)
                continue;
                
            // Отрисовываем чанк
            Gizmos.DrawLineList(chunk);
        }
    }
    
    private void OnValidate()
    {
        if (_chunkSize <= 0) _chunkSize = 10000;
        if (_totalPointCount <= 0) _totalPointCount = 1000;
        _dataGenerated = false;
    }
}

public class CleanGizmoSystem : MonoBehaviour
{
    // Интерфейс для всех визуализируемых данных
    public interface IGizmoVisualizable
    {
        void PrepareGizmoData(List<Vector3> linePoints, List<Vector3> pointMarkers);
    }
    
    // Список объектов для визуализации
    [SerializeField] private List<MonoBehaviour> _visualizableObjects = new List<MonoBehaviour>();
    
    // Буферы для хранения геометрии Gizmo
    private List<Vector3> _linePoints = new List<Vector3>();
    private List<Vector3> _pointMarkers = new List<Vector3>();
    
    private void OnDrawGizmos()
    {
        // Очищаем буферы перед обновлением
        _linePoints.Clear();
        _pointMarkers.Clear();
        
        // Собираем данные со всех поддерживаемых объектов
        foreach (var obj in _visualizableObjects)
        {
            if (obj is IGizmoVisualizable visualizable)
            {
                visualizable.PrepareGizmoData(_linePoints, _pointMarkers);
            }
        }
        
        // Отрисовываем линии
        if (_linePoints.Count >= 2)
        {
            Gizmos.color = Color.green;
            Gizmos.DrawLineList(_linePoints.ToArray());
        }
        
        // Отрисовываем точки-маркеры
        Gizmos.color = Color.red;
        foreach (var point in _pointMarkers)
        {
            Gizmos.DrawSphere(point, 0.1f);
        }
    }
}

public class PhysicsDebugVisualizer : MonoBehaviour, CleanGizmoSystem.IGizmoVisualizable
{
    [SerializeField] private float _raycastDistance = 10f;
    [SerializeField] private LayerMask _raycastMask;
    [SerializeField] private int _rayCount = 36;
    
    // Реализация интерфейса для визуализации
    public void PrepareGizmoData(List<Vector3> linePoints, List<Vector3> pointMarkers)
    {
        // Выполняем круговые рейкасты и визуализируем их
        Vector3 origin = transform.position;
        
        for (int i = 0; i < _rayCount; i++)
        {
            float angle = i * 360f / _rayCount;
            Vector3 direction = Quaternion.Euler(0, angle, 0) * Vector3.forward;
            
            // Запускаем рейкаст
            if (Physics.Raycast(origin, direction, out RaycastHit hit, _raycastDistance, _raycastMask))
            {
                // Луч попал в объект - отрисовываем зелёную линию до точки попадания
                linePoints.Add(origin);
                linePoints.Add(hit.point);
                
                // Добавляем точку попадания как маркер
                pointMarkers.Add(hit.point);
            }
            else
            {
                // Луч не попал - отрисовываем красную линию на всю длину
                linePoints.Add(origin);
                linePoints.Add(origin + direction * _raycastDistance);
            }
        }
    }
}

#if UNITY_EDITOR
using UnityEditor;
 
public class InteractiveDebugTool : MonoBehaviour
{
    private Vector3[] _pathPoints = new Vector3[100];
    private bool _editMode = false;
    private int _selectedPointIndex = -1;
    
    private void OnDrawGizmos()
    {
        // Отрисовываем путь
        Gizmos.color = _editMode ? Color.yellow : Color.white;
        Gizmos.DrawLineStrip(_pathPoints, false);
        
        // В режиме редактирования отображаем точки для взаимодействия
        if (_editMode)
        {
            // Используем Handles для взаимодействия
            for (int i = 0; i < _pathPoints.Length; i++)
            {
                // Тут можно использовать интерактивные Handles
                // Но помните, что это выходит за рамки BatchGizmoAPI
            }
        }
    }
    
    [CustomEditor(typeof(InteractiveDebugTool))]
    public class InteractiveDebugToolEditor : Editor
    {
        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();
            
            InteractiveDebugTool tool = (InteractiveDebugTool)target;
            
            // Добавляем кнопку для включения режима редактирования
            tool._editMode = GUILayout.Toggle(tool._editMode, "Режим редактирования");
            
            if (GUILayout.Button("Генерировать случайный путь"))
            {
                // Логика генерации пути
            }
        }
    }
}
#endif

public class TraditionalArmyManager : MonoBehaviour
{
    [SerializeField] private List<Unit> _units = new List<Unit>();
    [SerializeField] private Transform _targetPosition;
    
    private void UpdateUnitPositions()
    {
        foreach (var unit in _units)
        {
            // Для каждого юнита вычисляем направление в локальные координаты
            Vector3 worldDirection = _targetPosition.position - unit.transform.position;
            Vector3 localDirection = unit.transform.InverseTransformDirection(worldDirection);
            
            // Обрабатываем локальное направление
            unit.SetMovementDirection(localDirection);
        }
    }
}

public class BatchArmyManager : MonoBehaviour
{
    [SerializeField] private List<Unit> _units = new List<Unit>();
    [SerializeField] private Transform _targetPosition;
    
    private Vector3[] _worldDirections;
    private Vector3[] _localDirections;
    
    private void Awake()
    {
        // Инициализируем буферы при создании объекта
        _worldDirections = new Vector3[_units.Count];
        _localDirections = new Vector3[_units.Count];
    }
    
    private void UpdateUnitPositions()
    {
        // Заполняем массив мировых направлений
        for (int i = 0; i < _units.Count; i++)
        {
            _worldDirections[i] = _targetPosition.position - _units[i].transform.position;
        }
        
        // Пакетно преобразуем все направления за один вызов
        for (int i = 0; i < _units.Count; i++)
        {
            _units[i].transform.InverseTransformDirections(_worldDirections, _localDirections);
            _units[i].SetMovementDirection(_localDirections[i]);
        }
    }
}

public class CityGenerator : MonoBehaviour
{
    [SerializeField] private BuildingPrototype[] _buildingPrototypes;
    [SerializeField] private int _gridSize = 20;
    private Vector3[] _buildingPositions;
    private Quaternion[] _buildingRotations;
    private List<GameObject> _generatedBuildings = new List<GameObject>();
    
    public void GenerateCity()
    {
        // Генерируем сетку позиций для зданий
        int buildingCount = _gridSize * _gridSize;
        _buildingPositions = new Vector3[buildingCount];
        _buildingRotations = new Quaternion[buildingCount];
        
        // Заполняем массивы позиций и поворотов
        for (int x = 0; x < _gridSize; x++)
        {
            for (int z = 0; z < _gridSize; z++)
            {
                int index = z * _gridSize + x;
                
                // Добавляем случайное смещение для естественности
                float offsetX = UnityEngine.Random.Range(-2f, 2f);
                float offsetZ = UnityEngine.Random.Range(-2f, 2f);
                
                _buildingPositions[index] = new Vector3(x * 10 + offsetX, 0, z * 10 + offsetZ);
                
                // Случайный поворот вокруг вертикальной оси
                float rotation = UnityEngine.Random.Range(0, 4) * 90f;
                _buildingRotations[index] = Quaternion.Euler(0, rotation, 0);
            }
        }
        
        // Создаём здания
        for (int i = 0; i < buildingCount; i++)
        {
            // Выбираем случайный прототип здания
            BuildingPrototype prototype = _buildingPrototypes[UnityEngine.Random.Range(0, _buildingPrototypes.Length)];
            
            // Создаём экземпляр
            GameObject building = Instantiate(prototype.prefab, _buildingPositions[i], _buildingRotations[i]);
            _generatedBuildings.Add(building);
        }
    }
    
    // Визуализируем план города перед генерацией
    private void OnDrawGizmosSelected()
    {
        if (_buildingPositions == null || _buildingPositions.Length == 0) return;
        
        // Используем Batch Gizmo для отрисовки контуров зданий
        Vector3[] outlinePoints = new Vector3[_buildingPositions.Length * 10]; // По 5 линий на здание, 2 точки на линию
        int pointIndex = 0;
        
        for (int i = 0; i < _buildingPositions.Length; i++)
        {
            Vector3 position = _buildingPositions[i];
            Quaternion rotation = _buildingRotations[i];
            
            // Создаём прямоугольник для здания (упрощённо)
            Vector3 halfSize = new Vector3(2, 0, 2);
            
            Vector3 frontLeft = position + rotation * new Vector3(-halfSize.x, 0, halfSize.z);
            Vector3 frontRight = position + rotation * new Vector3(halfSize.x, 0, halfSize.z);
            Vector3 backRight = position + rotation * new Vector3(halfSize.x, 0, -halfSize.z);
            Vector3 backLeft = position + rotation * new Vector3(-halfSize.x, 0, -halfSize.z);
            
            // Первая линия
            outlinePoints[pointIndex++] = frontLeft;
            outlinePoints[pointIndex++] = frontRight;
            
            // Вторая линия
            outlinePoints[pointIndex++] = frontRight;
            outlinePoints[pointIndex++] = backRight;
            
            // Третья линия
            outlinePoints[pointIndex++] = backRight;
            outlinePoints[pointIndex++] = backLeft;
            
            // Четвёртая линия
            outlinePoints[pointIndex++] = backLeft;
            outlinePoints[pointIndex++] = frontLeft;
            
            // Диагональ для визуального различия
            outlinePoints[pointIndex++] = frontLeft;
            outlinePoints[pointIndex++] = backRight;
        }
        
        Gizmos.color = Color.cyan;
        Gizmos.DrawLineList(outlinePoints);
    }
}
 
[System.Serializable]
public class BuildingPrototype
{
    public GameObject prefab;
    public float probability = 1f;
}

public class BatchPhysicsSystem : MonoBehaviour
{
    private List<Rigidbody> _activeRigidbodies = new List<Rigidbody>();
    private Vector3[] _positions;
    private Vector3[] _velocities;
    
    private void FixedUpdate()
    {
        int count = _activeRigidbodies.Count;
        
        // Инициализируем или изменяем размер массивов при необходимости
        if (_positions == null || _positions.Length != count)
        {
            _positions = new Vector3[count];
            _velocities = new Vector3[count];
        }
        
        // Собираем позиции и скорости всех объектов
        for (int i = 0; i < count; i++)
        {
            _positions[i] = _activeRigidbodies[i].position;
            _velocities[i] = _activeRigidbodies[i].velocity;
        }
        
        // Предсказываем новые позиции для оптимизации коллизий
        Vector3[] predictedPositions = new Vector3[count];
        for (int i = 0; i < count; i++)
        {
            predictedPositions[i] = _positions[i] + _velocities[i] * Time.fixedDeltaTime;
        }
        
        // Проверяем коллизии и обновляем физику
        ProcessCollisionsAndPhysics(predictedPositions);
    }
    
    private void ProcessCollisionsAndPhysics(Vector3[] predictedPositions)
    {
        // Здесь происходит обработка физики и коллизий
        // с использованием пакетных операций для оптимизации
    }
    
    public void RegisterRigidbody(Rigidbody rb)
    {
        if (!_activeRigidbodies.Contains(rb))
        {
            _activeRigidbodies.Add(rb);
        }
    }
    
    public void UnregisterRigidbody(Rigidbody rb)
    {
        _activeRigidbodies.Remove(rb);
    }
}

public class HeatmapVisualizer : MonoBehaviour
{
    [SerializeField] private int _resolution = 100;
    [SerializeField] private float _mapSize = 100f;
    [SerializeField] private float _maxHeight = 5f;
    
    private float[,] _heatmapData;
    private Vector3[] _heatmapMeshPoints;
    
    private void OnValidate()
    {
        GenerateRandomData();
        CalculateHeatmapMesh();
    }
    
    private void GenerateRandomData()
    {
        // В реальном проекте здесь были бы данные из аналитики или геймплея
        _heatmapData = new float[_resolution, _resolution];
        
        for (int x = 0; x < _resolution; x++)
        {
            for (int z = 0; z < _resolution; z++)
            {
                // Генерируем некоторые тестовые данные
                float centerDistance = Vector2.Distance(new Vector2(x, z), new Vector2(_resolution/2, _resolution/2));
                _heatmapData[x, z] = Mathf.Max(0, 1f - centerDistance / (_resolution/2)) * UnityEngine.Random.Range(0.5f, 1f);
            }
        }
    }
    
    private void CalculateHeatmapMesh()
    {
        // Подготавливаем точки для меша тепловой карты (упрощённо)
        int lineCount = _resolution * (_resolution - 1) * 2; // Горизонтальные и вертикальные линии
        _heatmapMeshPoints = new Vector3[lineCount * 2]; // 2 точки на линию
        
        int pointIndex = 0;
        float step = _mapSize / (_resolution - 1);
        
        // Создаём горизонтальные линии
        for (int z = 0; z < _resolution; z++)
        {
            for (int x = 0; x < _resolution - 1; x++)
            {
                float height1 = _heatmapData[x, z] * _maxHeight;
                float height2 = _heatmapData[x + 1, z] * _maxHeight;
                
                Vector3 point1 = new Vector3(x * step - _mapSize/2, height1, z * step - _mapSize/2);
                Vector3 point2 = new Vector3((x + 1) * step - _mapSize/2, height2, z * step - _mapSize/2);
                
                _heatmapMeshPoints[pointIndex++] = point1;
                _heatmapMeshPoints[pointIndex++] = point2;
            }
        }
        
        // Создаём вертикальные линии
        for (int x = 0; x < _resolution; x++)
        {
            for (int z = 0; z < _resolution - 1; z++)
            {
                float height1 = _heatmapData[x, z] * _maxHeight;
                float height2 = _heatmapData[x, z + 1] * _maxHeight;
                
                Vector3 point1 = new Vector3(x * step - _mapSize/2, height1, z * step - _mapSize/2);
                Vector3 point2 = new Vector3(x * step - _mapSize/2, height2, (z + 1) * step - _mapSize/2);
                
                _heatmapMeshPoints[pointIndex++] = point1;
                _heatmapMeshPoints[pointIndex++] = point2;
            }
        }
    }
    
    private void OnDrawGizmosSelected()
    {
        if (_heatmapMeshPoints == null) return;
        
        // Используем Batch Gizmo для отрисовки всего меша тепловой карты одним вызовом
        Gizmos.color = Color.green;
        Gizmos.DrawLineList(_heatmapMeshPoints);
    }
}

using Unity.Entities;
using Unity.Transforms;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;
 
public class BatchTransformBridge : MonoBehaviour
{
    private EntityManager _entityManager;
    private NativeArray<Vector3> _entityPositions;
    private TransformAccessArray _transformAccess;
    private Transform[] _linkedTransforms;
    
    void Start()
    {
        _entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
        // Инициализация компонентов...
    }
    
    public void SyncPositionsToGameObjects(EntityQuery query)
    {
        // Получаем позиции из ECS мира
        var positions = query.ToComponentDataArray<Translation>(Allocator.TempJob);
        
        // Пакетно применяем их к GameObject трансформациям
        JobHandle handle = new TransformPositionJob
        {
            Positions = positions
        }.Schedule(_transformAccess);
        
        handle.Complete();
        positions.Dispose();
    }
}