map3drendering/LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs

using AC2RE.Definitions;
using LandblockExtraction.AtlasMaker;
using LandblockExtraction.DatEngine;
using LandblockExtraction.Tools;
using System.Dynamic;
using System.Numerics;

namespace LandblockExtraction.LandBlockExtractor {
    public class LandBlockExtrator {
        private PortalEngine portalEngine;
        private CellEngine cellEngine;
        private TerrainAtlasManager terrainAtlasManager;

        private readonly int NumberLandBlocks = 255;
        private readonly int BlockSize = 17;
        private readonly int cellSize = 8;

        public LandBlockExtrator(PortalEngine portalEngine, CellEngine cellEngine) {
            this.portalEngine = portalEngine;
            this.cellEngine = cellEngine;

            terrainAtlasManager = new TerrainAtlasManager(portalEngine);
            terrainAtlasManager.ExtractTexture();
            terrainAtlasManager.GenerateAtlas();
            terrainAtlasManager.GenerateUV();
        }

        public BlockStruct? GetBlock(int landX, int landY) {
                    CellId landBlockId = new CellId((byte)landX, (byte)landY, 0xFF, 0xFF);
                    var landBlock = cellEngine.GetLandBlockData(landBlockId.id);
                    if (landBlock == null) return null;

                    return GenerateBlockStructByData(landBlock, landX, landY);
        }

        public BlockStruct GenerateBlockStructByData(CLandBlockData blockData, int landX, int landY) {
            BlockStruct blockStruct = new BlockStruct();
            for (int y = 0; y < BlockStruct.BlockSize; y++) {
                for (int x = 0; x < BlockStruct.BlockSize; x++) {
                    var indice = y * BlockStruct.BlockSize + x;
                    blockStruct.verticesStruct.position[indice] = GenerateVertexPosition(landX, landY, x, y, blockData.heights[indice]);
                    blockStruct.verticesStruct.color[indice] = GenerateVertexColor(blockData.cellInfos[indice]);
                    blockStruct.verticesStruct.farcolor[indice] = GenerateVertexFarColor(blockData.cellInfos[indice]);
                    blockStruct.GenerateIndices();
                    //blockStruct.GenerateUVByIndices();
                    GenerateVertexTextureCoord(blockData, blockStruct);
                }
            }

            return blockStruct;
        }

        private void GenerateVertexTextureCoord(CLandBlockData blockData, BlockStruct blockStruct) {
            List<Vector3> vertices = new List<Vector3>(); // Liste pour stocker les positions des sommets dupliqués
            List<Vector4> colors = new List<Vector4>();
            List<Vector4> farcolors = new List<Vector4>();
            List<Vector2> uvs = new List<Vector2>(); // Liste pour stocker les coordonnées UV
            List<int> indices = new List<int>(); // Liste pour stocker les nouveaux indices

            for (int y = 0; y < blockStruct.indices.Length; y = y + 6) {
                    // Créez 4 sommets 
                vertices.Add(blockStruct.verticesStruct.position[blockStruct.indices[y]]);
                vertices.Add(blockStruct.verticesStruct.position[blockStruct.indices[y + 1]]);
                vertices.Add(blockStruct.verticesStruct.position[blockStruct.indices[y + 2]]);
                vertices.Add(blockStruct.verticesStruct.position[blockStruct.indices[y + 5]]);

                // Créez 4 color
                colors.Add(blockStruct.verticesStruct.color[blockStruct.indices[y]]);
                colors.Add(blockStruct.verticesStruct.color[blockStruct.indices[y + 1]]);
                colors.Add(blockStruct.verticesStruct.color[blockStruct.indices[y + 2]]);
                colors.Add(blockStruct.verticesStruct.color[blockStruct.indices[y + 5]]);

                // Créez 4 farcolor
                farcolors.Add(blockStruct.verticesStruct.farcolor[blockStruct.indices[y]]);
                farcolors.Add(blockStruct.verticesStruct.farcolor[blockStruct.indices[y + 1]]);
                farcolors.Add(blockStruct.verticesStruct.farcolor[blockStruct.indices[y + 2]]);
                farcolors.Add(blockStruct.verticesStruct.farcolor[blockStruct.indices[y + 5]]);

                // Assignez les coordonnées UV à chaque sommet
                uvs.Add(new Vector2(0, 0)); // Coin inférieur gauche
                uvs.Add(new Vector2(1, 0)); // Coin inférieur droit
                uvs.Add(new Vector2(0, 1)); // Coin supérieur gauche
                uvs.Add(new Vector2(1, 1)); // Coin supérieur droit

                // Créez les indices pour les deux triangles du quad
                int baseIndex = (y / 6) * 4; // Calculez l'index de base pour ce quad
                indices.Add(baseIndex);
                indices.Add(baseIndex + 1);
                indices.Add(baseIndex + 2);

                indices.Add(baseIndex + 2);
                indices.Add(baseIndex + 1);
                indices.Add(baseIndex + 3);
            }

            // Mettez à jour le BlockStruct avec les nouvelles listes de sommets, UVs, et indices
            Console.WriteLine(indices.Count);
            blockStruct.verticesStruct.position = vertices.ToArray();
            blockStruct.verticesStruct.color = colors.ToArray();
            blockStruct.verticesStruct.farcolor = farcolors.ToArray();
            blockStruct.verticesStruct.texturecoord = uvs.ToArray();
            blockStruct.indices = indices.ToArray();
        }
        private Vector3 GenerateVertexPosition(int landx, int landy, int x, int y, byte height) {
            int tmpx = (landx * BlockSize + y) * cellSize;
            int tmpy = (BlockSize * NumberLandBlocks * cellSize) - ((landy * BlockSize + x) * cellSize) - 1;
            var newX = (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2));
            var newY = (tmpy - ((NumberLandBlocks * BlockSize * cellSize) - (NumberLandBlocks * BlockSize * cellSize / 2) - 1));

            return new Vector3(newX, portalEngine.landScapeDefs.landHeightTable[height], newY);
        }
        private Vector4 GenerateVertexColor(uint cellInfo) {
            var terrain = MathOperations.GetTerrainInCellInfo(cellInfo);

            foreach (var terrainType in portalEngine.cTerrainDesc.terrains) {
                if (terrainType.terrainIndex == terrain) {
                    foreach (var surfaceIndex in portalEngine.cSurfaceDesc.surfaces) {
                        if (surfaceIndex.surfIndex == terrainType.surfaceInfo) {
                            var color = surfaceIndex.terrainMaterials.First().vertexColor.First().vertexColor;
                            return MathOperations.RGBAColorToVector4(color);
                        }
                    }
                }
            }

            return Vector4.One;
        }
        private Vector4 GenerateVertexFarColor(uint cellInfo) {
            var terrain = MathOperations.GetTerrainInCellInfo(cellInfo);

            foreach (var terrainType in portalEngine.cTerrainDesc.terrains) {
                if (terrainType.terrainIndex == terrain) {
                    foreach (var surfaceIndex in portalEngine.cSurfaceDesc.surfaces) {
                        if (surfaceIndex.surfIndex == terrainType.surfaceInfo) {
                            var color = surfaceIndex.terrainMaterials.First().vertexColor.First().farVertexColor;
                            return MathOperations.RGBAColorToVector4(color);
                        }
                    }
                }
            }

            return Vector4.One;
        }
    }
}