// при помощи текстур пакера создаем атлас
private void BakeTexture()
  {
    newTexture = new Texture2D(8, 8, TextureFormat.ETC_RGB4, false);
    var Rects = newTexture.PackTextures(textures.ToArray(), 0, 2048, false);
    for (int i = 0; i < Rects.Length; i++)
    {
      AtlasTextures[i].rect = Rects[i];
    }
    newTexture.Apply();
  }
// меняем текстурные координаты меша при помощи данных из текстур пакера
private void BakeMesh(Mesh meshInstance, int meshId)
  {
    tempMeshes.Add(new Mesh());
    var newMesh = tempMeshes[meshId];
    newMesh.vertices = meshInstance.vertices;
    newMesh.normals = meshInstance.normals;
    //код для объектов с подкраской при помощи vertex color
    if (meshInstance.colors != null && meshInstance.colors.Length != 0)
    {
      newMesh.colors = meshInstance.colors;
    }
    for (int i = 0; i < newMesh.subMeshCount; i++)
    {
      newMesh.SetIndices(meshInstance.GetIndices(i), meshInstance.GetTopology(i), i);
      newMesh.SetTriangles(meshInstance.GetTriangles(i), i);
    }
    var rect = AtlasTextures[meshId].rect;
    Vector2 ofst = new Vector2(rect.xMin, rect.yMin);
    Vector2 scl = new Vector2(rect.width, rect.height);
    Vector2[] newUv = new Vector2[meshInstance.uv.Length];
    for (int i = 0; i < meshInstance.uv.Length; i++)
    {
      Vector2 uv = meshInstance.uv[i];
      newUv[i] = Vector2.Scale(uv, scl) + ofst;
    }
    newMesh.uv = newUv;
    if (meshInstance.uv2 != null && meshInstance.uv2.Length != 0)
    {
    newMesh.uv2 = meshInstance.uv2;
    }
    tempMeshes[meshId] = newMesh;
  }

private Vector3[] verts; // список вертексов аллоцируем один раз и дальше просто перезаполняем
        private Vector2[] uv; // координаты развертки также аллоцируем единожды
// decimator служит для определения разрешения меша
        private void UpdateMesh(int X, int Y, ref MeshInstance TerrainMeshPart, bool isEdge = false, MeshPosition meshPosition = MeshPosition.Center, int decimator = 1)
        {
            int lowMeshIndex = ArrayToLinear(X, Y, terrainData.gridWidth);
            TerrainMeshPart.meshRenderer.enabled = true;
            TerrainMeshPart.LowMesh = lowMesh[lowMeshIndex];
            bool FirstTimeMeshCreated = (TerrainMeshPart.mesh == null || TerrainMeshPart.mesh.vertexCount == 0); // проверяем новый меш или перезаполняем список вертексов и UV-координат
            if (TerrainMeshPart.LowMesh != null)
            {
                TerrainMeshPart.LowMesh.enabled = false;
                TerrainMeshPart.meshRenderer.sharedMaterial = TerrainMeshPart.usePreviewMaterial ? terrainData.previewTerrainMaterial : terrainData.materials[lowMeshIndex];
                TerrainMeshPart.trans.position = TerrainMeshPart.LowMesh.transform.position;
            }
            int meshResolution = terrainData.maxMeshResolution / decimator + 1;
            int partWidth = (terrainData.width -1) / terrainData.gridWidth;
            float partSize = terrainData.realSize / terrainData.gridWidth;
            int xCoord;
            int yCoord;
            float height;
            bool isTop = meshPosition == MeshPosition.Top || meshPosition == MeshPosition.TopLeft || meshPosition == MeshPosition.TopRight;
            bool isBot = meshPosition == MeshPosition.Bot || meshPosition == MeshPosition.BotLeft || meshPosition == MeshPosition.BotRight;
            bool isLeft = meshPosition == MeshPosition.Left || meshPosition == MeshPosition.TopLeft || meshPosition == MeshPosition.BotLeft;
            bool isRight = meshPosition == MeshPosition.Right || meshPosition == MeshPosition.TopRight || meshPosition == MeshPosition.BotRight; // чтобы избежать дырок на стыках лоу и хай меша, определяем с каких граней чанка нужно дополнительно обработать позиции четных вертексов
            float ReadHeightStep = (float)partWidth / terrainData.maxMeshResolution * decimator;
            int intReadHeightStep = Mathf.RoundToInt(ReadHeightStep);
            float VertexStep = terrainData.realSize / (float)terrainData.gridWidth / terrainData.maxMeshResolution * decimator;
            float xVertexPos = 0;
            float yVertexPos = 0;
            int ReadCoordinateForX = 0;
            int ReadCoordinateForY = 0;
            float fromByteToFloat = 1f / 255;
            float finalHeightMultiplyer = terrainData.MaxHeight * fromByteToFloat;
            for (int x = 0; x < meshResolution; x++)
            {
                for (int y = 0; y < meshResolution; y++)
                {
                    int offsetX = partWidth * X;
                    int offsetY = partWidth * Y;
                    if (isEdge && (x & 1) != 0 && ((y == 0 && isBot) || (y == meshResolution - 1 && isTop)))
                    {
                        xCoord = offsetX + (x - 1) * intReadHeightStep;
                        ReadCoordinateForX = offsetX + (x + 1) * intReadHeightStep;
                        yCoord = offsetY + y * intReadHeightStep;
                        byte heightT = heights[ArrayToLinear(ReadCoordinateForX, yCoord, terrainData.minitex.width)];
                        height = 0.5f * (heights[ArrayToLinear(xCoord, yCoord, terrainData.minitex.width)] + heightT);
                    }
                    else if (isEdge && (y & 1) != 0 && ((x == 0 && isLeft) || (x == meshResolution - 1 && isRight)))
                    {
                        xCoord = offsetX + x * intReadHeightStep;
                        ReadCoordinateForY = offsetY + (y + 1) * intReadHeightStep;
                        yCoord = offsetY + (y - 1) * intReadHeightStep;
                        byte heightT = heights[ArrayToLinear(xCoord, ReadCoordinateForY, terrainData.minitex.width)];
                        height = 0.5f * (heights[ArrayToLinear(xCoord, yCoord, terrainData.minitex.width)] + heightT);
                    }
                    else
                    {
                        xCoord = offsetX + x * intReadHeightStep;
                        yCoord = offsetY + y * intReadHeightStep;
                        int index = ArrayToLinear(xCoord, yCoord, terrainData.minitex.width);
                        height = heights[index];
                    }
                    int arrPos = ArrayToLinear(x, y, meshResolution);
                    xVertexPos = x * VertexStep;
                    yVertexPos = y * VertexStep;
                    verts[arrPos] = new Vector3(xVertexPos, height * finalHeightMultiplyer, yVertexPos);
                    uv[arrPos] = new Vector2((partSize * X + xVertexPos) / terrainData.realSize, (partSize * Y + yVertexPos) / terrainData.realSize);
                    if (FirstTimeMeshCreated)//check if triangles already created
                    {
                        if (x < meshResolution - 1 && y < meshResolution - 1)
                        {
                            indicesList.Add(arrPos);
                            indicesList.Add(ArrayToLinear(x, y + 1, meshResolution));
                            indicesList.Add(ArrayToLinear(x + 1, y + 1, meshResolution));
                            indicesList.Add(arrPos);
                            indicesList.Add(ArrayToLinear(x + 1, y + 1, meshResolution));
                            indicesList.Add(ArrayToLinear(x + 1, y, meshResolution));
                        }
                    }
                }
            }
            TerrainMeshPart.mesh.vertices = verts;
            TerrainMeshPart.mesh.uv = uv;
            if (!FirstTimeMeshCreated) return;
            float volume = terrainData.realSize / terrainData.gridWidth;
            var BoundsSize = new Vector3(volume, terrainData.MaxHeight, volume);
            TerrainMeshPart.mesh.bounds = new Bounds(BoundsSize / 2, BoundsSize);
            TerrainMeshPart.mesh.SetIndices(indicesList.ToArray(), MeshTopology.Triangles, 0);
        }

float DistanceToRelativeHeight(float distance, float lodHeight)
    {
        var halfAngle = Mathf.Tan(Mathf.Deg2Rad * defaultFov * 0.5f);
        var relativeHeight = lodHeight * 0.5f / (distance * halfAngle);
        return relativeHeight;
    }

public void PlaceObjects(int x, int y)
  {
    newChunks = FillListOfAjacentChunks(x,y);
    // неиспользуемыми считаются чанки, которых нет в списке newChunks
    ClearUnusedChunks();
    for (int i = 0; i < newChunks.Count; i++)
    {
      var newChunkId = newChunks[i];
      // если чанк есть в списке currentChunks, то объекты на нем уже расставлены
      // и расставлять их заново не нужно
      if (newChunkId != -1 && !currentChunks.Contains(newChunkId))
      {
        UpdateChunk(newChunkId);
      }
    }
    for (int i = 0; i < newChunks.Count; i++)
    {
      var newChunkId = newChunks[i];
      currentChunks[i] = newChunkId;
    }
  }
// тут мы используем сериализуемые Dictionary для хранения списка списков
  #region MyDictionaryOfPoolObjects
  [System.Serializable]
  public class MyDictionaryOfPoolObjects : SerializableDictionary<string, PoolObjListHolder> { }
  [System.Serializable]
  public class PoolObjListHolder
  {
    public List<PoolObj> entityList;
  }
  #endregion
void UpdateChunk(int chunkID)
  {
    Chunk chunk = chunks[chunkID];
    for (int i = 0; i < chunk.objectsInChunk.Count; i++)
    {
      string key = chunk.objectsInChunk[i];
      List<PoolObj> _pool = pool.dictionary[key].entityList;
      int _placedObjectsCount = poolUseCounter.dictionary[key];
      List<Vector3> poses = chunk.positions.dictionary[key].entityList;
      List<Quaternion> rotations = chunk.rotations.dictionary[key].entityList;
        // учитываем количество свободных объектов
        // из количества объектов в пуле вычитаем число уже используемых
        // а также вычитаем количество которое предстоит расставить
      int delta = _pool.Count - _placedObjectsCount - poses.Count;
        // если объектов нужно больше, чем лежит в пуле, то создаем еще
      if (delta < 0)
      {
        ExpandPool(_pool, Mathf.Abs(delta) + 1);
      }
        // так как мы не знаем наверняка, какие объекты уже используются, а какие возвращены в пул, то пройдемся по всем начиная с первого
      int counter = 0;
      for (int j = 0; j < poses.Count; j++)
      {
        var poolObj = _pool[counter];
        counter++;
        // если объект уже на карте, то пропускаем его
        if (poolObj.isPlaced)
        {
          j--;
          continue;
        }
        _placedObjectsCount++;
        poolObj.currentChunk = chunkID;
        poolObj.isPlaced = true;
        poolObj.obj.position = poses[j];
        poolObj.obj.rotation = rotations[j];
      }
      poolUseCounter.dictionary[key] = _placedObjectsCount;
    }
  }

List<int> MaxUniqueObjectInstancesCount = new List<int>();
  for (int i = 0; i < UniqueObjectNames.Count; i++)
    {
      if (isDebug)
      {
        Debug.Log("Prefab name : " + UniqueObjectNames[i]);
      }
    MaxUniqueObjectInstancesCount.Add(0);
    for (int x = 0; x < Grid; x++)
    {
      for (int y = 0; y < Grid; y++)
      {
        var maxCountOfObjectsForChunk = CalculateMaxObjectsInThisAndAdjacentChunks(x, y, UniqueObjectNames[i]);
        if (isDebug && maxCountOfObjectsForChunk > 0)
        {
          Debug.Log(string.Format("Chunk: ({0},{1}) Count : {2}", x, y, maxCountOfObjectsForChunk));
        }
        if (maxCountOfObjectsForChunk > MaxUniqueObjectInstancesCount[i])
        {          MaxUniqueObjectInstancesCount[i] = maxCountOfObjectsForChunk;
        }
      }
    }
  }

[ContextMenu("(Debug)Find chunks triangles density")]
    void CheckVertexCount()
    {
        PlaceAllObjects();
        Dictionary<string, int> chunkTrianglesCount = new Dictionary<string, int>();
        var worldObjects = FindObjectsOfType<LODGroup>();
        for (int i = 0; i < worldObjects.Length; i++)
        {
            int trianglesCount = 0;
            var chunkId = chunks[GetCurrentChunkId(worldObjects[i].transform.position)].id.ToString();
            if (chunkTrianglesCount.ContainsKey(chunkId)) trianglesCount = chunkTrianglesCount[chunkId];
            else chunkTrianglesCount.Add(chunkId, 0);
            if (worldObjects[i].GetLODs()[0].renderers != null)
            {
                var count = 0;
                foreach (Renderer r in worldObjects[i].GetLODs()[0].renderers)
                {
                    if (r)
                    {
                        MeshFilter meshFilter = r.GetComponent<MeshFilter>();
                        if (meshFilter && meshFilter.sharedMesh != null)
                        {
                            count += meshFilter.sharedMesh.triangles.Length;
                        }
                    }
                }
                trianglesCount += count;
                // логируем количество треугольников в объектах
                Debug.Log(chunkId + " Object Name: " + worldObjects[i].name + " Triangles Count: " + count);
            }
            chunkTrianglesCount[chunkId] = trianglesCount;
        }
        for (int i = 0; i < chunks.Length; i++)
        {
            var chunkId = chunks[i].id.ToString();
            if (chunkTrianglesCount.ContainsKey(chunkId))
                Debug.Log("Chunk: " + chunkId + " Triangles count: " + chunkTrianglesCount[chunkId]);
        }
        RemoveAllObjectsToPool();
    }

Shader "Optimized/FallBack/DiffuseTopDownShaded"
{
    Properties
    {
        _MainTex("Texture", 2D) = "white" {}
        _ShadowTex("Shadow Texture", 2D) = "white" {}
        _Scale("Scale", Float) = 1
        _OffsetX("Offset X", Float) = 1
        _OffsetY("Offset Y", Float) = 1
    }
        SubShader
    {
        Tags{ "RenderType" = "Opaque" "Queue" = "Geometry"  "IgnoreProjector" = "True" }
        ZWrite On
        ZTest Less
        LOD 200
        Cull Back
        Lighting Off
        Pass
    {
        CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "UnityCG.cginc"
    struct v2f
    {
        float2 uv : TEXCOORD0;
        fixed2 projectedUV : TEXCOORD2;
        UNITY_FOG_COORDS(1)
        float4 vertex : SV_POSITION;
    };
    sampler2D _MainTex;
    sampler2D _ShadowTex;
    float4 _MainTex_ST;
    fixed _Scale;
    fixed _OffsetX;
    fixed _OffsetY;
    v2f vert(appdata_full v)
    {
        v2f o;
        o.vertex = UnityObjectToClipPos(v.vertex);
        o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
        fixed4 vertPose = mul(unity_ObjectToWorld, v.vertex);
        o.projectedUV = vertPose.xz + fixed2(_OffsetX, _OffsetY);
        o.projectedUV = o.uvs / _Scale;
        UNITY_TRANSFER_FOG(o,o.vertex);
        return o;
    }
    fixed4 frag(v2f i) : SV_Target
    {
        fixed4 col = tex2D(_MainTex, i.uv);
        fixed4 col2 = tex2D(_ShadowTex, i.projectedUV) * col;
        UNITY_APPLY_FOG(i.fogCoord, col2);
        return col2;
    }
        ENDCG
    }
    }
}