diff --git a/LandblockExtraction/AtlasMaker/TerrainAtlasManager.cs b/LandblockExtraction/AtlasMaker/TerrainAtlasManager.cs index cf211c2..b0c1149 100644 --- a/LandblockExtraction/AtlasMaker/TerrainAtlasManager.cs +++ b/LandblockExtraction/AtlasMaker/TerrainAtlasManager.cs @@ -1,23 +1,26 @@ using AC2RE.Definitions; using ImageMagick; using LandblockExtraction.DatEngine; +using LandblockExtraction.Tools; using System.Numerics; namespace LandblockExtraction.AtlasMaker; public class TerrainAtlasManager { - private readonly string PATHTERRAINIMG = @".\terrains"; private PortalEngine portalEngine; + private Dictionary mapTerrain; public Dictionary textureCoord; public Dictionary terrainTexture; public Dictionary terrains; public TerrainAtlasManager(PortalEngine portalEngine) { this.portalEngine = portalEngine; + mapTerrain = new(); textureCoord = new Dictionary(); terrainTexture = new Dictionary(); terrains = new Dictionary(); - testGenerateList(); + InitialiseTerrainDic(); + GenerateTerrain(); } public void ExtractTexture() { using (var atlasBuilder = new AtlasBuilder(portalEngine)) { @@ -37,38 +40,56 @@ public class TerrainAtlasManager { } } } - /*private Terrain GenerateSubTerrain(int index, List materialGroups) { - Terrain tmpTerrain = new Terrain(index); - foreach(var material in materialGroups) { - int indexTer = GetIndexBySurface(material.s) - SubTerrain subTerrain = new(ma) + private void GenerateTerrain() { + foreach(var terrain in portalEngine.cTerrainDesc.terrains) { + Terrain tmpTer = new((int)terrain.terrainIndex); + foreach(var surface in portalEngine.cSurfaceDesc.surfaces) { + if(terrain.surfaceInfo == surface.surfIndex) { + foreach(var mat in surface.terrainMaterials) { + tmpTer.AddSubTerrain(new(GetIndex(mat.baseMaterials.First().materialDid), + mat.minPitch, + mat.maxPitch, + MathOperations.RGBAColorToVector4(mat.vertexColor.First().vertexColor), + MathOperations.RGBAColorToVector4(mat.vertexColor.First().farVertexColor))); + } + } + } + terrains.Add((int)terrain.terrainIndex, tmpTer); + Console.WriteLine("Init: " + terrain.terrainIndex); } - }*/ - private void testGenerateList() { - foreach(var surfaces in portalEngine.cSurfaceDesc.surfaces) { - Console.WriteLine($"{surfaces.surfIndex} :"); - foreach( var surface in surfaces.terrainMaterials) { - Console.WriteLine($"\t[{surface.minPitch} < {surface.maxPitch}]({surface.baseMaterials.First().materialDid}) - Vec3: {surface.vertexColor.First().vertexColor}"); + } + private void testGenerateList() { + foreach (var terrain in portalEngine.cTerrainDesc.terrains) { + foreach (var surfaces in portalEngine.cSurfaceDesc.surfaces) { + if (surfaces.surfIndex != terrain.surfaceInfo) continue; + foreach (var surface in surfaces.terrainMaterials) { + + uint test = 0; + //foreach(var m in map) { if (m.Key == surface.baseMaterials.First().materialDid) test = m.Value; } + + Console.Write($"({test})[{terrain.terrainName}]{surfaces.surfIndex} :"); + Console.WriteLine($"\t[{surface.minPitch} < {surface.maxPitch}]({surface.baseMaterials.First().materialDid}) - Vec3: {surface.vertexColor.First().vertexColor}"); + } + Console.WriteLine("--------"); } } } - public void SaveAllTerrain() { - if (!Directory.Exists(PATHTERRAINIMG)) { - Directory.CreateDirectory(PATHTERRAINIMG); - } - - foreach(var img in terrainTexture) { - var path = Path.Combine(PATHTERRAINIMG, img.Key.ToString()); - - img.Value.Write(path + ".jpg"); + private void InitialiseTerrainDic() { + foreach(var terrain in portalEngine.cTerrainDesc.terrains) { + foreach (var surface in portalEngine.cSurfaceDesc.surfaces) { + if (terrain.surfaceInfo == surface.surfIndex) { + var id = surface.terrainMaterials.First().baseMaterials.First().materialDid; + mapTerrain.Add((int)terrain.terrainIndex, id); + break; + } + } } } - private int? GetIndexBySurface(uint surfaceIndex) { - foreach(var terrain in portalEngine.cTerrainDesc.terrains) { - if (terrain.surfaceInfo == surfaceIndex) - return (int)terrain.terrainIndex; + private int GetIndex(DataId id) { + foreach(var mat in mapTerrain) { + if(mat.Value.id == id.id) return mat.Key; } - return null; + return 0; } public void GenerateUV() { int count = (int)Math.Ceiling(Math.Sqrt(textureCoord.Count)); diff --git a/LandblockExtraction/AtlasMaker/TerrainInfo/SubTerrain.cs b/LandblockExtraction/AtlasMaker/TerrainInfo/SubTerrain.cs index 65c5457..55dd4f9 100644 --- a/LandblockExtraction/AtlasMaker/TerrainInfo/SubTerrain.cs +++ b/LandblockExtraction/AtlasMaker/TerrainInfo/SubTerrain.cs @@ -1,13 +1,19 @@ -namespace LandblockExtraction.AtlasMaker; +using System.Numerics; + +namespace LandblockExtraction.AtlasMaker; public class SubTerrain { public int terrainIndex { get; set; } public float minPitch { get; set; } public float maxPitch { get; set; } - public SubTerrain(int terrainIndex, float minPitch, float maxPitch) { + public Vector4 Color { get; set; } + public Vector4 farColor { get; set; } + public SubTerrain(int terrainIndex, float minPitch, float maxPitch, Vector4 color, Vector4 farcolor) { this.terrainIndex = terrainIndex; this.minPitch = minPitch; this.maxPitch = maxPitch; + this.Color = color; + this.farColor = farcolor; } public bool MatchesPitch(float pitch) { return pitch >= minPitch && pitch <= maxPitch; diff --git a/LandblockExtraction/AtlasMaker/TerrainInfo/Terrain.cs b/LandblockExtraction/AtlasMaker/TerrainInfo/Terrain.cs index 8e6c097..5f5fc19 100644 --- a/LandblockExtraction/AtlasMaker/TerrainInfo/Terrain.cs +++ b/LandblockExtraction/AtlasMaker/TerrainInfo/Terrain.cs @@ -11,12 +11,12 @@ public class Terrain { subTerrains.Add(sousTerrain); } - public int DetermineSubTerrain(float pitch) { + public SubTerrain DetermineSubTerrain(float pitch) { foreach (var terrain in subTerrains) { if (terrain.MatchesPitch(pitch)) { - return terrain.terrainIndex; + return terrain; } } - return terrainIndex; + return subTerrains.First(); } } diff --git a/LandblockExtraction/AtlasMaker/TexturesImage.cs b/LandblockExtraction/AtlasMaker/TexturesImage.cs index cea78c1..18ca924 100644 --- a/LandblockExtraction/AtlasMaker/TexturesImage.cs +++ b/LandblockExtraction/AtlasMaker/TexturesImage.cs @@ -40,7 +40,7 @@ public class TexturesImage { if (!portalEngine.datReader.contains(img)) continue; using (var data = portalEngine.datReader.getFileReader(img)) { var image = new RenderSurface(data); - if (image.width != 256) continue; + if (image.width != 64) continue; var dataImg = DDSHeader.Generate(image); using (MagickImage realImg = new MagickImage(dataImg)) { magickImage = new(realImg); diff --git a/LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs b/LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs index a9f41a5..fa33ee7 100644 --- a/LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs +++ b/LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs @@ -15,14 +15,15 @@ namespace LandblockExtraction.LandBlockExtractor { private readonly int BlockSize = 17; private readonly int cellSize = 8; + private int[] indiceBase; + public LandBlockExtrator(PortalEngine portalEngine, CellEngine cellEngine) { this.portalEngine = portalEngine; this.cellEngine = cellEngine; terrainAtlasManager = new TerrainAtlasManager(portalEngine); - terrainAtlasManager.ExtractTexture(); - terrainAtlasManager.GenerateUV(); - terrainAtlasManager.SaveAllTerrain(); + + indiceBase = GenerateBasicIndices(); } public BlockStruct? GetBlock(int landX, int landY) { @@ -39,77 +40,19 @@ namespace LandblockExtraction.LandBlockExtractor { for (int x = 0; x < BlockSize; x++) { var indice = y * 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.indices = indiceBase; + //blockStruct.verticesStruct.color[indice] = GenerateVertexColor(blockData.cellInfos[indice]); + //blockStruct.verticesStruct.farcolor[indice] = GenerateVertexFarColor(blockData.cellInfos[indice]); blockStruct.verticesStruct.terraintype[indice] = GenerateVertexTerrainType(blockData.cellInfos[indice]); - blockStruct.verticesStruct.texturecoord[indice] = GenerateUVForSubTile(x, y); - blockStruct.indices = GenerateBasicIndices(); - } } - //blockStruct.verticesStruct.texturecoord = GenerateBasicUVTest(blockStruct); - blockStruct.verticesStruct.normal = GenerateBasicNormal(blockStruct); - //DoubleEdgeVertices(blockStruct); - Dictionary testTerr = new Dictionary(); - foreach (var test in blockStruct.verticesStruct.terraintype) { - var type = (int)test.X; - if (testTerr.ContainsKey(type)) { - testTerr[type]++; - } else { - testTerr.Add(type, 1); - } - } + GenerateBasicNormalandRighTexture(blockStruct); + DoubleEdgeVertices(blockStruct); return blockStruct; } - - private Vector2 GenerateBasicUV(int x, int y) { - float u = (float)x / (BlockSize - 1) * 8; - float v = (float)y / (BlockSize - 1) * 8; - - return new Vector2(u, v); - } - private Vector2 GenerateUVForSubTile(int x, int y) { - // Taille d'une "mini-tuile" en termes de coordonnées UV - float miniTileSize = 1f / BlockSize - 1; // Comme la sous-grille est 5x5 - - // Calcul des coordonnées UV basées sur la position (x, y) dans la sous-grille - float u = x * miniTileSize; - float v = y * miniTileSize; - - return new Vector2(u, v); - } - private Vector2[] GenerateBasicUVTest(BlockStruct blockStruct) { - Vector2[] uvs = new Vector2[blockStruct.verticesStruct.position.Length]; - - for (int i = 0; i < uvs.Length; i++) { - uvs[i] = new Vector2(0, 0); - } - - for (int i = 0; i < blockStruct.indices.Length; i += 6) { - int index1 = blockStruct.indices[i]; - int index2 = blockStruct.indices[i + 1]; - int index3 = blockStruct.indices[i + 2]; - int index4 = blockStruct.indices[i + 5]; - - uvs[index1] = new(0, 0); - uvs[index2] = new(0, 1); - uvs[index3] = new(1, 0); - uvs[index4] = new(1, 1); - } - - return uvs; - } - private Vector3[] GenerateBasicNormal(BlockStruct blockStruct) { - Vector3[] normals = new Vector3[blockStruct.verticesStruct.position.Length]; - - // Initialise tous les vecteurs normaux à zéro - for (int i = 0; i < normals.Length; i++) { - normals[i] = new Vector3(0, 0, 0); - } - - // Parcourt tous les indices et calcule les normales pour chaque triangle + private void GenerateBasicNormalandRighTexture(BlockStruct blockStruct) { for (int i = 0; i < blockStruct.indices.Length; i += 6) { int index1 = blockStruct.indices[i]; int index2 = blockStruct.indices[i + 1]; @@ -121,27 +64,29 @@ namespace LandblockExtraction.LandBlockExtractor { Vector3 vertex3 = blockStruct.verticesStruct.position[index3]; Vector3 vertex4 = blockStruct.verticesStruct.position[index4]; - // Calcule la normale du triangle - /*Vector3 edge1 = vertex2 - vertex1; - Vector3 edge2 = vertex3 - vertex1; - Vector3 normal = Vector3.Cross(edge1, edge2); - normal = Vector3.Normalize(normal);*/ var normal = MathOperations.CalculateQuadNormal(vertex1, vertex2, vertex3, vertex4); - // Ajoute la normale du triangle aux normales des sommets du triangle - normals[index1] += normal; - normals[index2] += normal; - normals[index3] += normal; - normals[index4] += normal; - } + var test = MathOperations.CalculateInclination(normal); - // Normalise toutes les normales de sommets pour qu'elles soient de longueur unitaire - for (int i = 0; i < normals.Length; i++) { - normals[i] = Vector3.Normalize(normals[i]); - } + var sub1 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index1].X].DetermineSubTerrain(test); + var sub2 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index2].X].DetermineSubTerrain(test); + var sub3 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index3].X].DetermineSubTerrain(test); + var sub4 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index4].X].DetermineSubTerrain(test); - return normals; + InitColorFarColorTerrain(index1, normal, sub1, blockStruct); + InitColorFarColorTerrain(index2, normal, sub2, blockStruct); + InitColorFarColorTerrain(index3, normal, sub3, blockStruct); + InitColorFarColorTerrain(index4, normal, sub4, blockStruct); + } } + private void InitColorFarColorTerrain(int index, Vector3 normal, SubTerrain terrain, BlockStruct blockStruct) { + blockStruct.verticesStruct.terraintype[index].X = terrain.terrainIndex; + blockStruct.verticesStruct.color[index] = terrain.Color; + blockStruct.verticesStruct.farcolor[index] = terrain.farColor; + blockStruct.verticesStruct.normal[index] = normal; + } + + private int[] GenerateBasicIndices() { List indices = new List(); @@ -171,10 +116,9 @@ namespace LandblockExtraction.LandBlockExtractor { 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); + var newX = (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2)) - landx * cellSize;// (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2)); + var newY = (tmpy - ((NumberLandBlocks * BlockSize * cellSize) - (NumberLandBlocks * BlockSize * cellSize / 2) - 1)) + landy * cellSize; //(tmpy - ((NumberLandBlocks * BlockSize * cellSize) - (NumberLandBlocks * BlockSize * cellSize / 2) - 1)); + return new Vector3(newX + 1020, portalEngine.landScapeDefs.landHeightTable[height], newY - 1020); } private Vector4 GenerateVertexColor(uint cellInfo) { var terrain = MathOperations.GetTerrainInCellInfo(cellInfo); @@ -217,7 +161,6 @@ namespace LandblockExtraction.LandBlockExtractor { List newFarColors = new List(); List newTexCoord = new List(); List newTerrainTypes = new List(); - List newRealTerrainType = new List(); int originalVertexCount = blockStruct.verticesStruct.position.Length; int originalIndicesCount = blockStruct.indices.Length; @@ -230,69 +173,49 @@ namespace LandblockExtraction.LandBlockExtractor { var two = blockStruct.indices[i + 1]; var three = blockStruct.indices[i + 2]; var foor = blockStruct.indices[i + 5]; + Vector4 terrainType = new Vector4(blockStruct.verticesStruct.terraintype[one].X, + blockStruct.verticesStruct.terraintype[two].X, + blockStruct.verticesStruct.terraintype[three].X, + blockStruct.verticesStruct.terraintype[foor].X); + newPositions.Add(blockStruct.verticesStruct.position[one]); newColors.Add(blockStruct.verticesStruct.color[one]); newFarColors.Add(blockStruct.verticesStruct.farcolor[one]); - newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, - blockStruct.verticesStruct.terraintype[two].X, - blockStruct.verticesStruct.terraintype[three].X, - blockStruct.verticesStruct.terraintype[foor].X)); - newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[one].X); + newNormals.Add(blockStruct.verticesStruct.normal[one]); + newTerrainTypes.Add(terrainType); - /*newPositions.Add(blockStruct.verticesStruct.position[two]); + newPositions.Add(blockStruct.verticesStruct.position[two]); newColors.Add(blockStruct.verticesStruct.color[two]); newFarColors.Add(blockStruct.verticesStruct.farcolor[two]); - newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, - blockStruct.verticesStruct.terraintype[two].X, - blockStruct.verticesStruct.terraintype[three].X, - blockStruct.verticesStruct.terraintype[foor].X)); - newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[two].X); + newNormals.Add(blockStruct.verticesStruct.normal[two]); + newTerrainTypes.Add(terrainType); newPositions.Add(blockStruct.verticesStruct.position[three]); newColors.Add(blockStruct.verticesStruct.color[three]); newFarColors.Add(blockStruct.verticesStruct.farcolor[three]); - newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, - blockStruct.verticesStruct.terraintype[two].X, - blockStruct.verticesStruct.terraintype[three].X, - blockStruct.verticesStruct.terraintype[foor].X)); - newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[three].X); + newNormals.Add(blockStruct.verticesStruct.normal[three]); + newTerrainTypes.Add(terrainType); newPositions.Add(blockStruct.verticesStruct.position[foor]); newColors.Add(blockStruct.verticesStruct.color[foor]); newFarColors.Add(blockStruct.verticesStruct.farcolor[foor]); - newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, - blockStruct.verticesStruct.terraintype[two].X, - blockStruct.verticesStruct.terraintype[three].X, - blockStruct.verticesStruct.terraintype[foor].X)); - newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[foor].X); + newNormals.Add(blockStruct.verticesStruct.normal[foor]); + newTerrainTypes.Add(terrainType); newTexCoord.Add(new(0, 0)); newTexCoord.Add(new(0, 1)); newTexCoord.Add(new(1, 0)); - newTexCoord.Add(new(1, 1));*/ - - var normal = MathOperations.CalculateQuadNormal(blockStruct.verticesStruct.position[one], - blockStruct.verticesStruct.position[two], - blockStruct.verticesStruct.position[three], - blockStruct.verticesStruct.position[foor]); - - newNormals.Add(normal); - //newNormals.Add(normal); - //newNormals.Add(normal); - //newNormals.Add(normal); + newTexCoord.Add(new(1, 1)); } - // Ajouter les nouveaux sommets à la structure BlockStruct (étape 2) - // Vous devez également mettre à jour les indices dans blockStruct.indices blockStruct.verticesStruct.position = newPositions.ToArray(); blockStruct.verticesStruct.normal = newNormals.ToArray(); blockStruct.verticesStruct.color = newColors.ToArray(); blockStruct.verticesStruct.farcolor = newFarColors.ToArray(); blockStruct.verticesStruct.texturecoord = newTexCoord.ToArray(); blockStruct.verticesStruct.terraintype = newTerrainTypes.ToArray(); - blockStruct.verticesStruct.realtype = newRealTerrainType.ToArray(); blockStruct.indices = GenerateNewsIndices(newPositions.Count); } @@ -300,12 +223,12 @@ namespace LandblockExtraction.LandBlockExtractor { private int[] GenerateNewsIndices(int count) { List indices = new List(); for (int i = 0; i < count; i = i + 4) { - indices.Add(i); - indices.Add(i + 1); - indices.Add(i + 2); - indices.Add(i + 2); - indices.Add(i + 1); - indices.Add(i + 3); + indices.Add(i); //A + indices.Add(i + 1); //B + indices.Add(i + 2); //C + indices.Add(i + 2); //C + indices.Add(i + 1); //B + indices.Add(i + 3); //D } return indices.ToArray(); diff --git a/LandblockExtraction/LandBlockExtractor/Utilities/VerticesStruct.cs b/LandblockExtraction/LandBlockExtractor/Utilities/VerticesStruct.cs index 938ab64..342de34 100644 --- a/LandblockExtraction/LandBlockExtractor/Utilities/VerticesStruct.cs +++ b/LandblockExtraction/LandBlockExtractor/Utilities/VerticesStruct.cs @@ -8,7 +8,6 @@ namespace LandblockExtraction.LandBlockExtractor { public Vector4[] farcolor { get; set; } public Vector2[] texturecoord { get; set; } public Vector4[] terraintype { get; set; } - public float[] realtype { get; set; } public VerticesStruct(int blockSize) { position = new Vector3[blockSize * blockSize]; @@ -17,13 +16,12 @@ namespace LandblockExtraction.LandBlockExtractor { farcolor = new Vector4[blockSize * blockSize]; texturecoord = new Vector2[blockSize * blockSize]; terraintype = new Vector4[blockSize * blockSize]; - realtype = new float[blockSize * blockSize]; } public float[] Vertices() { int length = position.Length; - float[] vertices = new float[length * 21]; // 3 pour position, 4 pour color, et 4 pour farcolor - for (int i = 0, vi = 0; i < length; i++, vi += 21) { + float[] vertices = new float[length * 20]; + for (int i = 0, vi = 0; i < length; i++, vi += 20) { vertices[vi] = position[i].X; vertices[vi + 1] = position[i].Y; vertices[vi + 2] = position[i].Z; @@ -44,7 +42,6 @@ namespace LandblockExtraction.LandBlockExtractor { vertices[vi + 17] = terraintype[i].Y; vertices[vi + 18] = terraintype[i].Z; vertices[vi + 19] = terraintype[i].W; - vertices[vi + 20] = realtype[i]; } return vertices; } diff --git a/LandblockExtraction/Tools/MathOperations.cs b/LandblockExtraction/Tools/MathOperations.cs index 71f5064..374a04c 100644 --- a/LandblockExtraction/Tools/MathOperations.cs +++ b/LandblockExtraction/Tools/MathOperations.cs @@ -41,5 +41,20 @@ namespace LandblockExtraction.Tools { Vector3 averageNormal = (normal1 + normal2) / 2; return Vector3.Normalize(averageNormal); } + public static float CalculateInclination(Vector3 normal) { + Vector3 up = new Vector3(0, 0, 1); // Vecteur vertical de référence + + normal = Vector3.Normalize(normal); // Normaliser la normale + + float dotProduct = Vector3.Dot(normal, up); // Produit scalaire entre la normale et le vecteur vertical + + // Calculer le cosinus de l'angle + float cosTheta = dotProduct; + + // Calculer le sinus de l'angle à partir du cosinus + float sinTheta = (float)Math.Sqrt(1 - cosTheta * cosTheta); + + return sinTheta; // Retourner l'angle d'inclinaison variant de 0 à 1 + } } } diff --git a/LandblockExtraction/WorldMap/VertexInfo/VertexMap.cs b/LandblockExtraction/WorldMap/VertexInfo/VertexMap.cs new file mode 100644 index 0000000..327a47b --- /dev/null +++ b/LandblockExtraction/WorldMap/VertexInfo/VertexMap.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using System.Text; +using System.Threading.Tasks; + +namespace LandblockExtraction.WorldMap; +public struct VertexMap { + public Vector3 Position; + public Vector4 Color; +} diff --git a/LandblockExtraction/WorldMap/WorldMap.cs b/LandblockExtraction/WorldMap/WorldMap.cs new file mode 100644 index 0000000..0b868f9 --- /dev/null +++ b/LandblockExtraction/WorldMap/WorldMap.cs @@ -0,0 +1,165 @@ +using AC2RE.Definitions; +using LandblockExtraction.AtlasMaker; +using LandblockExtraction.DatEngine; +using LandblockExtraction.Tools; +using System.Numerics; + +namespace LandblockExtraction.WorldMap; +public class WorldMap { + private readonly int NumberLandBlocks = 254; + private readonly int BlockSize = 17; + private readonly int cellSize = 8; + + private PortalEngine portalEngine; + private CellEngine cellEngine; + private TerrainAtlasManager terrainAtlasManager; + + private VertexMap[,] vertexMaps; + + public WorldMap(PortalEngine portalEngine, CellEngine cellEngine) { + this.portalEngine = portalEngine; + this.cellEngine = cellEngine; + + terrainAtlasManager = new TerrainAtlasManager(portalEngine); + + int globalSize = NumberLandBlocks * (BlockSize - 1); + vertexMaps = new VertexMap[globalSize, globalSize]; + } + private void InitializeBaseMap() { + for (int landY = 0; landY <= NumberLandBlocks; landY++) { + for (int landX = 0; landX <= NumberLandBlocks; landX++) { + InitializeCellMap(landY, landX); + } + } + } + public void LoadRegion(int start, int end) { + for (int landY = start; landY <= end; landY++) { + for (int landX = start; landX <= end; landX++) { + InitializeCellMap(landY, landX); + } + } + } + private void InitializeCellMap(int landx, int landy) { + CellId landBlockId = new CellId((byte)landx, (byte)landy, 0xFF, 0xFF); + var landBlock = cellEngine.GetLandBlockData(landBlockId.id); + + for (int y = 0; y < BlockSize; y++) { + for (int x = 0; x < BlockSize; x++) { + float height = 0; + Vector4 color = Vector4.Zero; + + // Calculer les indices globaux en prenant en compte la position du land + int indiceX = landx * (BlockSize - 1) + y; + int indiceY = landy * (BlockSize - 1) + x; + + if (landBlock != null) { + height = GetHeightInLandBlock(landBlock, x, y); + color = GetColorVertex(landBlock, x, y); + } + + // Vérifier si les indices ne dépassent pas la taille globale de la grille + if (indiceX < NumberLandBlocks * (BlockSize - 1) && indiceY < NumberLandBlocks * (BlockSize - 1)) { + vertexMaps[indiceX, indiceY] = new VertexMap() { + Position = GenerateVertexPosition(landx, landy, x, y, height), + Color = color + }; + } + } + } + } + + private float GetHeightInLandBlock(CLandBlockData block, int x, int y) { + var indice = y * BlockSize + x; + return block.heights[indice]; + } + private Vector4 GetColorVertex(CLandBlockData block, int x, int y) { + var indice = y * BlockSize + x; + var terrain = MathOperations.GetTerrainInCellInfo(block.cellInfos[indice]); + return terrainAtlasManager.terrains[(int)terrain].subTerrains.First().Color; + } + public float[] GetAllVertices() { + List verticesList = new List(); + + int rowLength = NumberLandBlocks * (BlockSize - 1); + for (int y = 0; y < rowLength; y++) { + for (int x = 0; x < rowLength; x++) { + + // Ajouter la position du vertex à la liste + verticesList.Add(vertexMaps[x, y].Position.X); + verticesList.Add(vertexMaps[x, y].Position.Y); + verticesList.Add(vertexMaps[x, y].Position.Z); + + // Ajouter la couleur si nécessaire + verticesList.Add(vertexMaps[x, y].Color.X); + verticesList.Add(vertexMaps[x, y].Color.Y); + verticesList.Add(vertexMaps[x, y].Color.Z); + verticesList.Add(vertexMaps[x, y].Color.W); + } + } + + return verticesList.ToArray(); + } + public int[] GenerateRegionIndices(int start, int end) { + List indices = new List(); + + // Calcul de la longueur de la ligne pour la région spécifiée + int rowLength = (end - start) * (BlockSize - 1); + + // Parcours de chaque "cellule" de la grille pour la région spécifiée + for (int y = 0; y < rowLength; y++) { + for (int x = 0; x < rowLength; x++) { + int baseX = start * (BlockSize - 1); + int baseY = start * (BlockSize - 1); + + int topLeft = (y + baseY) * (NumberLandBlocks * (BlockSize - 1)) + (x + baseX); + int topRight = topLeft + 1; + int bottomLeft = topLeft + (NumberLandBlocks * (BlockSize - 1)); + int bottomRight = bottomLeft + 1; + + indices.Add(topLeft); + indices.Add(bottomLeft); + indices.Add(bottomRight); + + indices.Add(bottomLeft); + indices.Add(bottomRight); + indices.Add(topRight); + } + } + + return indices.ToArray(); + } + public int[] GenerateIndices() { + List indices = new List(); + + int rowLength = NumberLandBlocks * (BlockSize - 1); + + // Parcourir chaque "cellule" de la grille, sauf la dernière colonne et la dernière ligne + for (int y = 0; y < rowLength - 1; y++) { + for (int x = 0; x < rowLength - 1; x++) { + // Calculer les indices des 4 sommets du carré courant + int topLeft = y * rowLength + x; + int topRight = topLeft + 1; + int bottomLeft = topLeft + rowLength; + int bottomRight = bottomLeft + 1; + + // Ajouter les indices pour former les deux triangles + indices.Add(topLeft); + indices.Add(bottomLeft); + indices.Add(bottomRight); + + indices.Add(bottomLeft); + indices.Add(bottomRight); + indices.Add(topRight); + } + } + + return indices.ToArray(); + } + private Vector3 GenerateVertexPosition(int landx, int landy, int x, int y, float height) { + int tmpx = (landx * BlockSize + y) * cellSize; + int tmpy = (BlockSize * NumberLandBlocks * cellSize) - ((landy * BlockSize + x) * cellSize) - 1; + var newX = (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2)) - landx * cellSize;// (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2)); + var newY = (tmpy - ((NumberLandBlocks * BlockSize * cellSize) - (NumberLandBlocks * BlockSize * cellSize / 2) - 1)) + landy * cellSize; //(tmpy - ((NumberLandBlocks * BlockSize * cellSize) - (NumberLandBlocks * BlockSize * cellSize / 2) - 1)); + return new Vector3(newX + 1020, height, newY - 1020); + } +} diff --git a/Map3DRendering/Common/Camera.cs b/Map3DRendering/Common/Camera.cs index 8ab50aa..6084f37 100644 --- a/Map3DRendering/Common/Camera.cs +++ b/Map3DRendering/Common/Camera.cs @@ -83,7 +83,7 @@ namespace Map3DRendering.Common { // Get the projection matrix using the same method we have used up until this point public Matrix4 GetProjectionMatrix() { - return Matrix4.CreatePerspectiveFieldOfView(_fov, AspectRatio, 0.01f, 1000f); + return Matrix4.CreatePerspectiveFieldOfView(_fov, AspectRatio, 0.01f, 5000f); } // This function is going to update the direction vertices using some of the math learned in the web tutorials. diff --git a/Map3DRendering/Common/Shader.cs b/Map3DRendering/Common/Shader.cs index dd7900a..d16e150 100644 --- a/Map3DRendering/Common/Shader.cs +++ b/Map3DRendering/Common/Shader.cs @@ -1,11 +1,7 @@ -using System; -using System.IO; -using System.Text; -using System.Collections.Generic; -using OpenTK.Graphics.OpenGL4; +using OpenTK.Graphics.OpenGL4; using OpenTK.Mathematics; -namespace Map3DRendering { +namespace Map3DRendering.Common { // A simple class meant to help create shaders. public class Shader { public readonly int Handle; @@ -167,9 +163,18 @@ namespace Map3DRendering { /// /// The name of the uniform /// The data to set + public void SetVector2(string name, Vector2 data) { + GL.UseProgram(Handle); + GL.Uniform2(_uniformLocations[name], data); + } public void SetVector3(string name, Vector3 data) { GL.UseProgram(Handle); GL.Uniform3(_uniformLocations[name], data); } + + public void SetVector4(string name, Vector4 data) { + GL.UseProgram(Handle); + GL.Uniform4(_uniformLocations[name], data); + } } -} \ No newline at end of file +} diff --git a/Map3DRendering/Common/Texture.cs b/Map3DRendering/Common/Texture.cs index 96e397c..7a52e63 100644 --- a/Map3DRendering/Common/Texture.cs +++ b/Map3DRendering/Common/Texture.cs @@ -1,11 +1,7 @@ using OpenTK.Graphics.OpenGL4; -using System.Drawing; -using System.Drawing.Imaging; -using PixelFormat = OpenTK.Graphics.OpenGL4.PixelFormat; using StbImageSharp; -using System.IO; -namespace Map3DRendering { +namespace Map3DRendering.Common { // A helper class, much like Shader, meant to simplify loading textures. public class Texture { public readonly int Handle; @@ -105,6 +101,7 @@ namespace Map3DRendering { return new Texture(handle); } + public Texture(int glHandle) { Handle = glHandle; } @@ -121,5 +118,11 @@ namespace Map3DRendering { GL.ActiveTexture(unit); GL.BindTexture(TextureTarget.Texture2DArray, Handle); } + + + public void Assign(int shader, int i) { + int location = GL.GetUniformLocation(shader, "textures[" + i.ToString() + "]"); + GL.Uniform1(location, i); + } } -} \ No newline at end of file +} diff --git a/Map3DRendering/MapRender.cs b/Map3DRendering/MapRender.cs index 769fd34..1434eaf 100644 --- a/Map3DRendering/MapRender.cs +++ b/Map3DRendering/MapRender.cs @@ -70,7 +70,7 @@ namespace Map3DRendering { } } private void InitializeBlock(int x, int y, BlockStruct block, Shader _shader) { - int lenghPacket = 21; + int lenghPacket = 20; // Initialisez le VAO, VBO et EBO pour le bloc à (x, y)... // Utilisez le code de votre méthode OnLoad originale pour configurer le VAO, VBO et EBO. int tempVertexArray = GL.GenVertexArray(); @@ -112,10 +112,6 @@ namespace Map3DRendering { var terraintypeLocation = _shader.GetAttribLocation("aTexType"); GL.EnableVertexAttribArray(terraintypeLocation); GL.VertexAttribPointer(terraintypeLocation, 4, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 16 * sizeof(float)); - - var realterraintypeLocation = _shader.GetAttribLocation("aRealTexType"); - GL.EnableVertexAttribArray(realterraintypeLocation); - GL.VertexAttribPointer(realterraintypeLocation, 1, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 20 * sizeof(float)); } public void Render(Shader shader) { for (int y = startY; y <= endY; y++) { diff --git a/Map3DRendering/Program.cs b/Map3DRendering/Program.cs index 88992d4..8ab14ec 100644 --- a/Map3DRendering/Program.cs +++ b/Map3DRendering/Program.cs @@ -8,6 +8,7 @@ namespace Map3DRendering { var nativeWindowSettings = new NativeWindowSettings() { ClientSize = new Vector2i(800, 600), Title = "LearnOpenTK - Map AC2", + Vsync = VSyncMode.On, // This is needed to run on macos Flags = ContextFlags.ForwardCompatible, }; diff --git a/Map3DRendering/Shaders/shader.frag b/Map3DRendering/Shaders/shader.frag index a559a77..3ee40c0 100644 --- a/Map3DRendering/Shaders/shader.frag +++ b/Map3DRendering/Shaders/shader.frag @@ -2,33 +2,38 @@ out vec4 outputColor; -uniform sampler2DArray texture0; - uniform vec3 viewPos; uniform vec3 lightPos; uniform vec3 lightColor; +uniform sampler2DArray texture0; -in vec4 Color; in vec4 FarColor; in vec3 Normal; in vec3 FragPos; in vec2 TexCoord; in vec4 TexType; -in float RealType; void main() { - vec4 color0 = texture(texture0, vec3(TexCoord, TexType.x)); + vec4 blendedColor[4]; + for (int i = 0; i < 4; i++) { + float type = TexType[i]; + blendedColor[i] = texture(texture0, vec3(TexCoord, type)); + } + + float weightX = TexCoord.x; + float weightY = TexCoord.y; + + vec4 mix1 = mix(blendedColor[0], blendedColor[2], weightX); + vec4 mix2 = mix(blendedColor[1], blendedColor[3], weightX); + vec4 finalColor = mix(mix1, mix2, weightY); vec3 norm = normalize(Normal); - - vec4 finalColor = color0; //mix(color0, color1, norm.y); - vec3 lightDir = normalize(lightPos - FragPos); float diff = max(dot(norm, lightDir), 0.0); vec3 diffuse = diff * lightColor; - vec4 litColor = vec4(diffuse, 1.0) * finalColor * Color; + vec4 litColor = vec4(diffuse, 1.0) * finalColor; float distance = length(viewPos - FragPos); float interpolationFactor = clamp(distance / 1000.0, 0.0, 1.0); diff --git a/Map3DRendering/Shaders/shader.vert b/Map3DRendering/Shaders/shader.vert index 7f31960..084f70a 100644 --- a/Map3DRendering/Shaders/shader.vert +++ b/Map3DRendering/Shaders/shader.vert @@ -5,7 +5,6 @@ layout (location = 2) in vec4 aColor; layout (location = 3) in vec4 aColorFar; layout (location = 4) in vec2 aTexCoord; layout (location = 5) in vec4 aTexType; -layout (location = 6) in float aRealTexType; uniform mat4 model; uniform mat4 view; @@ -17,7 +16,6 @@ out vec4 Color; out vec4 FarColor; out vec2 TexCoord; out vec4 TexType; -out float RealType; void main() { @@ -28,5 +26,4 @@ void main() FarColor = aColorFar; TexCoord = aTexCoord; TexType = aTexType; - RealType = aRealTexType; } \ No newline at end of file diff --git a/Map3DRendering/Window.cs b/Map3DRendering/Window.cs index 8958671..8d5b2ea 100644 --- a/Map3DRendering/Window.cs +++ b/Map3DRendering/Window.cs @@ -10,7 +10,7 @@ namespace Map3DRendering { private readonly Vector3 _lightPos = new Vector3(0x10, 0, 0x10); - private MapRender mapRender; + private WorldMapRender mapRender; private AxesGizmo axesGizmo; private Shader _shader; @@ -33,7 +33,7 @@ namespace Map3DRendering { public Window(GameWindowSettings gameWindowSettings, NativeWindowSettings nativeWindowSettings) : base(gameWindowSettings, nativeWindowSettings) { - mapRender = new MapRender(); + mapRender = new WorldMapRender(); GL.GetInteger(GetPName.MaxTextureImageUnits, out maxTextures); } @@ -55,20 +55,16 @@ namespace Map3DRendering { mapRender.OnLoad(_shader); var file = Directory.EnumerateFiles(@"./terrains"); - _texture = Texture.LoadFromArray(file.ToArray()); - // Texture units are explained in Texture.cs, at the Use function. - // First texture goes in texture unit 0. _texture.UseArray(TextureUnit.Texture0); - axesGizmo = new AxesGizmo(); _camera = new Camera(Vector3.UnitY * 300, Size.X / (float)Size.Y); _camera.Fov = 60; //CursorState = CursorState.Grabbed; - //GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); - //GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); + GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); + GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); _lightPosVec = Vector3.UnitY * 1000; } @@ -79,22 +75,20 @@ namespace Map3DRendering { GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); - _texture.UseArray(TextureUnit.Texture0); _shader.Use(); + _texture.UseArray(TextureUnit.Texture0); _shader.SetMatrix4("view", _camera.GetViewMatrix()); _shader.SetMatrix4("projection", _camera.GetProjectionMatrix()); //_shader.SetVector3("objectColor", new Vector3(0.5f, 0.5f, 0.5f)); _shader.SetVector3("lightColor", new Vector3(1.0f, 1.0f, 1.0f)); - _shader.SetVector3("lightPos", _lightPosVec); - - //_shader.SetVector3("viewPos", _camera.Position); + _shader.SetVector3("lightPos", _camera.Position); GL.LineWidth(5.0f); _shader.SetVector3("viewPos", _camera.Position); - mapRender.UpdateBlocks(_camera.Position, _shader); + //mapRender.UpdateBlocks(_camera.Position, _shader); mapRender.Render(_shader); axesGizmo.Render(Size.X, Size.Y, _camera); @@ -149,10 +143,10 @@ namespace Map3DRendering { _camera.Position += _camera.Right * cameraSpeed * (float)e.Time; // Right } if (input.IsKeyDown(Keys.Space)) { - _camera.Position += _camera.Up * cameraSpeed * (float)e.Time; // Up + _camera.Position += Vector3.UnitY * cameraSpeed * (float)e.Time; // Up } if (input.IsKeyDown(Keys.LeftShift)) { - _camera.Position -= _camera.Up * cameraSpeed * (float)e.Time; // Down + _camera.Position -= Vector3.UnitY * cameraSpeed * (float)e.Time; // Down } // Get the mouse state diff --git a/Map3DRendering/WorldMapRender.cs b/Map3DRendering/WorldMapRender.cs new file mode 100644 index 0000000..ce92ee1 --- /dev/null +++ b/Map3DRendering/WorldMapRender.cs @@ -0,0 +1,67 @@ +using LandblockExtraction.DatEngine; +using LandblockExtraction.WorldMap; +using Map3DRendering.Common; +using OpenTK.Graphics.OpenGL4; +using OpenTK.Mathematics; + + +namespace Map3DRendering; +public class WorldMapRender { + private PortalEngine portalEngine; + private CellEngine cellEngine; + private WorldMap worldMap; + + public int _vertexArrayObject; + public int _vertexBufferObject; + public int _elementBufferObject; + + public int indicesLength; + + public WorldMapRender() { + portalEngine = new PortalEngine(); + cellEngine = new CellEngine(); + + worldMap = new WorldMap(portalEngine, cellEngine); + worldMap.LoadRegion(0x5F, 0x9F); + } + public void OnLoad(Shader _shader) { + InitializeMap(_shader); + } + private void InitializeMap(Shader _shader) { + int lenghPacket = 7; + var vertices = worldMap.GetAllVertices(); + var indices = worldMap.GenerateRegionIndices(0x5F, 0x9F); + indicesLength = indices.Length; + // Initialisez le VAO, VBO et EBO pour le bloc à (x, y)... + // Utilisez le code de votre méthode OnLoad originale pour configurer le VAO, VBO et EBO. + int tempVertexArray = GL.GenVertexArray(); + GL.BindVertexArray(tempVertexArray); + _vertexArrayObject = tempVertexArray; + + int tmpVertexBuffer = GL.GenBuffer(); + GL.BindBuffer(BufferTarget.ArrayBuffer, tmpVertexBuffer); + GL.BufferData(BufferTarget.ArrayBuffer, vertices.Length * sizeof(float), vertices, BufferUsageHint.StaticDraw); + _vertexBufferObject = tmpVertexBuffer; + + GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 0); + + int tmpElementBuffer = GL.GenBuffer(); + GL.BindBuffer(BufferTarget.ElementArrayBuffer, tmpElementBuffer); + GL.BufferData(BufferTarget.ElementArrayBuffer, indices.Length * sizeof(int), indices, BufferUsageHint.StaticDraw); + _elementBufferObject = tmpElementBuffer; + + var vertexLocation = _shader.GetAttribLocation("aPos"); + GL.EnableVertexAttribArray(vertexLocation); + GL.VertexAttribPointer(vertexLocation, 3, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 0); + + var colorLocation = _shader.GetAttribLocation("aColor"); + GL.EnableVertexAttribArray(colorLocation); + GL.VertexAttribPointer(colorLocation, 4, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 6 * sizeof(float)); + } + public void Render(Shader shader) { + var model = Matrix4.Identity;//CreateTranslation(x * BlockSize, 0, y * BlockSize); // Ajustez selon votre système de coordonnées + shader.SetMatrix4("model", model); + GL.BindVertexArray(_vertexArrayObject); + GL.DrawElements(PrimitiveType.Triangles, indicesLength, DrawElementsType.UnsignedInt, 0); + } +}