Troispoils/map3drendering
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Troispoils:main
Branches Tags
Troispoils:main
Troispoils:WPF-Render2D
Troispoils:Save-Double-Vertex
Troispoils:New-Map-System
..
compare: Troispoils:New-Map-System
Branches Tags
Troispoils:WPF-Render2D
Troispoils:Save-Double-Vertex
Troispoils:New-Map-System
Troispoils:main

4 commits
main ... New-Map-Sy

Author SHA1 Message Date
Troispoils
7c7dddde5e Test not positif 2024-03-03 19:07:02 +01:00
Troispoils
443b3a319d better system for texture terrain. 2024-03-01 21:56:18 +01:00
Troispoils
3aa6b5bc83 Update Window.cs 2024-03-01 16:15:05 +01:00
Troispoils
4ea0101cf6 Update loc of Vertex. 2024-03-01 15:03:45 +01:00
18 changed files with 420 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

67
LandblockExtraction/AtlasMaker/TerrainAtlasManager.cs
View file

@ -1,23 +1,26 @@
using AC2RE.Definitions; using AC2RE.Definitions;
using ImageMagick; using ImageMagick;
using LandblockExtraction.DatEngine; using LandblockExtraction.DatEngine;
using LandblockExtraction.Tools;
using System.Numerics; using System.Numerics;
namespace LandblockExtraction.AtlasMaker; namespace LandblockExtraction.AtlasMaker;
public class TerrainAtlasManager { public class TerrainAtlasManager {
private readonly string PATHTERRAINIMG = @".\terrains";
private PortalEngine portalEngine; private PortalEngine portalEngine;
private Dictionary<int, DataId> mapTerrain;
public Dictionary<int, Vector2> textureCoord; public Dictionary<int, Vector2> textureCoord;
public Dictionary<int, MagickImage> terrainTexture; public Dictionary<int, MagickImage> terrainTexture;
public Dictionary<int, Terrain> terrains; public Dictionary<int, Terrain> terrains;
public TerrainAtlasManager(PortalEngine portalEngine) { public TerrainAtlasManager(PortalEngine portalEngine) {
this.portalEngine = portalEngine; this.portalEngine = portalEngine;
mapTerrain = new();
textureCoord = new Dictionary<int, Vector2>(); textureCoord = new Dictionary<int, Vector2>();
terrainTexture = new Dictionary<int, MagickImage>(); terrainTexture = new Dictionary<int, MagickImage>();
terrains = new Dictionary<int, Terrain>(); terrains = new Dictionary<int, Terrain>();
testGenerateList(); InitialiseTerrainDic();
GenerateTerrain();
} }
public void ExtractTexture() { public void ExtractTexture() {
using (var atlasBuilder = new AtlasBuilder(portalEngine)) { using (var atlasBuilder = new AtlasBuilder(portalEngine)) {
@ -37,38 +40,56 @@ public class TerrainAtlasManager {
} }
} }
} }
/*private Terrain GenerateSubTerrain(int index, List<CSurfaceDesc.MaterialGroup> materialGroups) { private void GenerateTerrain() {
Terrain tmpTerrain = new Terrain(index); foreach(var terrain in portalEngine.cTerrainDesc.terrains) {
foreach(var material in materialGroups) { Terrain tmpTer = new((int)terrain.terrainIndex);
int indexTer = GetIndexBySurface(material.s) foreach(var surface in portalEngine.cSurfaceDesc.surfaces) {
SubTerrain subTerrain = new(ma) 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() { private void testGenerateList() {
foreach (var terrain in portalEngine.cTerrainDesc.terrains) {
foreach (var surfaces in portalEngine.cSurfaceDesc.surfaces) { foreach (var surfaces in portalEngine.cSurfaceDesc.surfaces) {
Console.WriteLine($"{surfaces.surfIndex} :"); if (surfaces.surfIndex != terrain.surfaceInfo) continue;
foreach (var surface in surfaces.terrainMaterials) { 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($"\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);
} }
private void InitialiseTerrainDic() {
foreach(var img in terrainTexture) {
var path = Path.Combine(PATHTERRAINIMG, img.Key.ToString());
img.Value.Write(path + ".jpg");
}
}
private int? GetIndexBySurface(uint surfaceIndex) {
foreach(var terrain in portalEngine.cTerrainDesc.terrains) { foreach(var terrain in portalEngine.cTerrainDesc.terrains) {
if (terrain.surfaceInfo == surfaceIndex) foreach (var surface in portalEngine.cSurfaceDesc.surfaces) {
return (int)terrain.terrainIndex; if (terrain.surfaceInfo == surface.surfIndex) {
var id = surface.terrainMaterials.First().baseMaterials.First().materialDid;
mapTerrain.Add((int)terrain.terrainIndex, id);
break;
} }
return null; }
}
}
private int GetIndex(DataId id) {
foreach(var mat in mapTerrain) {
if(mat.Value.id == id.id) return mat.Key;
}
return 0;
} }
public void GenerateUV() { public void GenerateUV() {
int count = (int)Math.Ceiling(Math.Sqrt(textureCoord.Count)); int count = (int)Math.Ceiling(Math.Sqrt(textureCoord.Count));

10
LandblockExtraction/AtlasMaker/TerrainInfo/SubTerrain.cs
View file

@ -1,13 +1,19 @@
namespace LandblockExtraction.AtlasMaker; using System.Numerics;
namespace LandblockExtraction.AtlasMaker;
public class SubTerrain { public class SubTerrain {
public int terrainIndex { get; set; } public int terrainIndex { get; set; }
public float minPitch { get; set; } public float minPitch { get; set; }
public float maxPitch { 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.terrainIndex = terrainIndex;
this.minPitch = minPitch; this.minPitch = minPitch;
this.maxPitch = maxPitch; this.maxPitch = maxPitch;
this.Color = color;
this.farColor = farcolor;
} }
public bool MatchesPitch(float pitch) { public bool MatchesPitch(float pitch) {
return pitch >= minPitch && pitch <= maxPitch; return pitch >= minPitch && pitch <= maxPitch;

6
LandblockExtraction/AtlasMaker/TerrainInfo/Terrain.cs
View file

@ -11,12 +11,12 @@ public class Terrain {
subTerrains.Add(sousTerrain); subTerrains.Add(sousTerrain);
} }
public int DetermineSubTerrain(float pitch) { public SubTerrain DetermineSubTerrain(float pitch) {
foreach (var terrain in subTerrains) { foreach (var terrain in subTerrains) {
if (terrain.MatchesPitch(pitch)) { if (terrain.MatchesPitch(pitch)) {
return terrain.terrainIndex; return terrain;
} }
} }
return terrainIndex; return subTerrains.First();
} }
} }

2
LandblockExtraction/AtlasMaker/TexturesImage.cs
View file

@ -40,7 +40,7 @@ public class TexturesImage {
if (!portalEngine.datReader.contains(img)) continue; if (!portalEngine.datReader.contains(img)) continue;
using (var data = portalEngine.datReader.getFileReader(img)) { using (var data = portalEngine.datReader.getFileReader(img)) {
var image = new RenderSurface(data); var image = new RenderSurface(data);
if (image.width != 256) continue; if (image.width != 64) continue;
var dataImg = DDSHeader.Generate(image); var dataImg = DDSHeader.Generate(image);
using (MagickImage realImg = new MagickImage(dataImg)) { using (MagickImage realImg = new MagickImage(dataImg)) {
magickImage = new(realImg); magickImage = new(realImg);

183
LandblockExtraction/LandBlockExtractor/LandBlockExtrator.cs
View file

@ -15,14 +15,15 @@ namespace LandblockExtraction.LandBlockExtractor {
private readonly int BlockSize = 17; private readonly int BlockSize = 17;
private readonly int cellSize = 8; private readonly int cellSize = 8;
private int[] indiceBase;
public LandBlockExtrator(PortalEngine portalEngine, CellEngine cellEngine) { public LandBlockExtrator(PortalEngine portalEngine, CellEngine cellEngine) {
this.portalEngine = portalEngine; this.portalEngine = portalEngine;
this.cellEngine = cellEngine; this.cellEngine = cellEngine;
terrainAtlasManager = new TerrainAtlasManager(portalEngine); terrainAtlasManager = new TerrainAtlasManager(portalEngine);
terrainAtlasManager.ExtractTexture();
terrainAtlasManager.GenerateUV(); indiceBase = GenerateBasicIndices();
terrainAtlasManager.SaveAllTerrain();
} }
public BlockStruct? GetBlock(int landX, int landY) { public BlockStruct? GetBlock(int landX, int landY) {
@ -39,77 +40,19 @@ namespace LandblockExtraction.LandBlockExtractor {
for (int x = 0; x < BlockSize; x++) { for (int x = 0; x < BlockSize; x++) {
var indice = y * BlockSize + x; var indice = y * BlockSize + x;
blockStruct.verticesStruct.position[indice] = GenerateVertexPosition(landX, landY, x, y, blockData.heights[indice]); blockStruct.verticesStruct.position[indice] = GenerateVertexPosition(landX, landY, x, y, blockData.heights[indice]);
blockStruct.verticesStruct.color[indice] = GenerateVertexColor(blockData.cellInfos[indice]); blockStruct.indices = indiceBase;
blockStruct.verticesStruct.farcolor[indice] = GenerateVertexFarColor(blockData.cellInfos[indice]); //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.terraintype[indice] = GenerateVertexTerrainType(blockData.cellInfos[indice]);
blockStruct.verticesStruct.texturecoord[indice] = GenerateUVForSubTile(x, y); }
blockStruct.indices = GenerateBasicIndices(); }
} GenerateBasicNormalandRighTexture(blockStruct);
} DoubleEdgeVertices(blockStruct);
//blockStruct.verticesStruct.texturecoord = GenerateBasicUVTest(blockStruct);
blockStruct.verticesStruct.normal = GenerateBasicNormal(blockStruct);
//DoubleEdgeVertices(blockStruct);
Dictionary<int, int> testTerr = new Dictionary<int, int>();
foreach (var test in blockStruct.verticesStruct.terraintype) {
var type = (int)test.X;
if (testTerr.ContainsKey(type)) {
testTerr[type]++;
} else {
testTerr.Add(type, 1);
}
}
return blockStruct; return blockStruct;
} }
private void GenerateBasicNormalandRighTexture(BlockStruct 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
for (int i = 0; i < blockStruct.indices.Length; i += 6) { for (int i = 0; i < blockStruct.indices.Length; i += 6) {
int index1 = blockStruct.indices[i]; int index1 = blockStruct.indices[i];
int index2 = blockStruct.indices[i + 1]; int index2 = blockStruct.indices[i + 1];
@ -121,26 +64,28 @@ namespace LandblockExtraction.LandBlockExtractor {
Vector3 vertex3 = blockStruct.verticesStruct.position[index3]; Vector3 vertex3 = blockStruct.verticesStruct.position[index3];
Vector3 vertex4 = blockStruct.verticesStruct.position[index4]; 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); var normal = MathOperations.CalculateQuadNormal(vertex1, vertex2, vertex3, vertex4);
// Ajoute la normale du triangle aux normales des sommets du triangle var test = MathOperations.CalculateInclination(normal);
normals[index1] += normal;
normals[index2] += normal; var sub1 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index1].X].DetermineSubTerrain(test);
normals[index3] += normal; var sub2 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index2].X].DetermineSubTerrain(test);
normals[index4] += normal; var sub3 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index3].X].DetermineSubTerrain(test);
var sub4 = terrainAtlasManager.terrains[(int)blockStruct.verticesStruct.terraintype[index4].X].DetermineSubTerrain(test);
InitColorFarColorTerrain(index1, normal, sub1, blockStruct);
InitColorFarColorTerrain(index2, normal, sub2, blockStruct);
InitColorFarColorTerrain(index3, normal, sub3, blockStruct);
InitColorFarColorTerrain(index4, normal, sub4, blockStruct);
}
} }
// Normalise toutes les normales de sommets pour qu'elles soient de longueur unitaire private void InitColorFarColorTerrain(int index, Vector3 normal, SubTerrain terrain, BlockStruct blockStruct) {
for (int i = 0; i < normals.Length; i++) { blockStruct.verticesStruct.terraintype[index].X = terrain.terrainIndex;
normals[i] = Vector3.Normalize(normals[i]); blockStruct.verticesStruct.color[index] = terrain.Color;
blockStruct.verticesStruct.farcolor[index] = terrain.farColor;
blockStruct.verticesStruct.normal[index] = normal;
} }
return normals;
}
private int[] GenerateBasicIndices() { private int[] GenerateBasicIndices() {
List<int> indices = new List<int>(); List<int> indices = new List<int>();
@ -171,10 +116,9 @@ namespace LandblockExtraction.LandBlockExtractor {
private Vector3 GenerateVertexPosition(int landx, int landy, int x, int y, byte height) { private Vector3 GenerateVertexPosition(int landx, int landy, int x, int y, byte height) {
int tmpx = (landx * BlockSize + y) * cellSize; int tmpx = (landx * BlockSize + y) * cellSize;
int tmpy = (BlockSize * NumberLandBlocks * cellSize) - ((landy * BlockSize + x) * cellSize) - 1; int tmpy = (BlockSize * NumberLandBlocks * cellSize) - ((landy * BlockSize + x) * cellSize) - 1;
var newX = (tmpx - (NumberLandBlocks * BlockSize * cellSize / 2)); 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)); 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);
return new Vector3(newX, portalEngine.landScapeDefs.landHeightTable[height], newY);
} }
private Vector4 GenerateVertexColor(uint cellInfo) { private Vector4 GenerateVertexColor(uint cellInfo) {
var terrain = MathOperations.GetTerrainInCellInfo(cellInfo); var terrain = MathOperations.GetTerrainInCellInfo(cellInfo);
@ -217,7 +161,6 @@ namespace LandblockExtraction.LandBlockExtractor {
List<Vector4> newFarColors = new List<Vector4>(); List<Vector4> newFarColors = new List<Vector4>();
List<Vector2> newTexCoord = new List<Vector2>(); List<Vector2> newTexCoord = new List<Vector2>();
List<Vector4> newTerrainTypes = new List<Vector4>(); List<Vector4> newTerrainTypes = new List<Vector4>();
List<float> newRealTerrainType = new List<float>();
int originalVertexCount = blockStruct.verticesStruct.position.Length; int originalVertexCount = blockStruct.verticesStruct.position.Length;
int originalIndicesCount = blockStruct.indices.Length; int originalIndicesCount = blockStruct.indices.Length;
@ -230,69 +173,49 @@ namespace LandblockExtraction.LandBlockExtractor {
var two = blockStruct.indices[i + 1]; var two = blockStruct.indices[i + 1];
var three = blockStruct.indices[i + 2]; var three = blockStruct.indices[i + 2];
var foor = blockStruct.indices[i + 5]; 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]); newPositions.Add(blockStruct.verticesStruct.position[one]);
newColors.Add(blockStruct.verticesStruct.color[one]); newColors.Add(blockStruct.verticesStruct.color[one]);
newFarColors.Add(blockStruct.verticesStruct.farcolor[one]); newFarColors.Add(blockStruct.verticesStruct.farcolor[one]);
newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, newNormals.Add(blockStruct.verticesStruct.normal[one]);
blockStruct.verticesStruct.terraintype[two].X, newTerrainTypes.Add(terrainType);
blockStruct.verticesStruct.terraintype[three].X,
blockStruct.verticesStruct.terraintype[foor].X));
newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[one].X);
/*newPositions.Add(blockStruct.verticesStruct.position[two]); newPositions.Add(blockStruct.verticesStruct.position[two]);
newColors.Add(blockStruct.verticesStruct.color[two]); newColors.Add(blockStruct.verticesStruct.color[two]);
newFarColors.Add(blockStruct.verticesStruct.farcolor[two]); newFarColors.Add(blockStruct.verticesStruct.farcolor[two]);
newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, newNormals.Add(blockStruct.verticesStruct.normal[two]);
blockStruct.verticesStruct.terraintype[two].X, newTerrainTypes.Add(terrainType);
blockStruct.verticesStruct.terraintype[three].X,
blockStruct.verticesStruct.terraintype[foor].X));
newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[two].X);
newPositions.Add(blockStruct.verticesStruct.position[three]); newPositions.Add(blockStruct.verticesStruct.position[three]);
newColors.Add(blockStruct.verticesStruct.color[three]); newColors.Add(blockStruct.verticesStruct.color[three]);
newFarColors.Add(blockStruct.verticesStruct.farcolor[three]); newFarColors.Add(blockStruct.verticesStruct.farcolor[three]);
newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, newNormals.Add(blockStruct.verticesStruct.normal[three]);
blockStruct.verticesStruct.terraintype[two].X, newTerrainTypes.Add(terrainType);
blockStruct.verticesStruct.terraintype[three].X,
blockStruct.verticesStruct.terraintype[foor].X));
newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[three].X);
newPositions.Add(blockStruct.verticesStruct.position[foor]); newPositions.Add(blockStruct.verticesStruct.position[foor]);
newColors.Add(blockStruct.verticesStruct.color[foor]); newColors.Add(blockStruct.verticesStruct.color[foor]);
newFarColors.Add(blockStruct.verticesStruct.farcolor[foor]); newFarColors.Add(blockStruct.verticesStruct.farcolor[foor]);
newTerrainTypes.Add(new Vector4(blockStruct.verticesStruct.terraintype[one].X, newNormals.Add(blockStruct.verticesStruct.normal[foor]);
blockStruct.verticesStruct.terraintype[two].X, newTerrainTypes.Add(terrainType);
blockStruct.verticesStruct.terraintype[three].X,
blockStruct.verticesStruct.terraintype[foor].X));
newRealTerrainType.Add(blockStruct.verticesStruct.terraintype[foor].X);
newTexCoord.Add(new(0, 0)); newTexCoord.Add(new(0, 0));
newTexCoord.Add(new(0, 1)); newTexCoord.Add(new(0, 1));
newTexCoord.Add(new(1, 0)); newTexCoord.Add(new(1, 0));
newTexCoord.Add(new(1, 1));*/ 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);
} }
// 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.position = newPositions.ToArray();
blockStruct.verticesStruct.normal = newNormals.ToArray(); blockStruct.verticesStruct.normal = newNormals.ToArray();
blockStruct.verticesStruct.color = newColors.ToArray(); blockStruct.verticesStruct.color = newColors.ToArray();
blockStruct.verticesStruct.farcolor = newFarColors.ToArray(); blockStruct.verticesStruct.farcolor = newFarColors.ToArray();
blockStruct.verticesStruct.texturecoord = newTexCoord.ToArray(); blockStruct.verticesStruct.texturecoord = newTexCoord.ToArray();
blockStruct.verticesStruct.terraintype = newTerrainTypes.ToArray(); blockStruct.verticesStruct.terraintype = newTerrainTypes.ToArray();
blockStruct.verticesStruct.realtype = newRealTerrainType.ToArray();
blockStruct.indices = GenerateNewsIndices(newPositions.Count); blockStruct.indices = GenerateNewsIndices(newPositions.Count);
} }
@ -300,12 +223,12 @@ namespace LandblockExtraction.LandBlockExtractor {
private int[] GenerateNewsIndices(int count) { private int[] GenerateNewsIndices(int count) {
List<int> indices = new List<int>(); List<int> indices = new List<int>();
for (int i = 0; i < count; i = i + 4) { for (int i = 0; i < count; i = i + 4) {
indices.Add(i); indices.Add(i); //A
indices.Add(i + 1); indices.Add(i + 1); //B
indices.Add(i + 2); indices.Add(i + 2); //C
indices.Add(i + 2); indices.Add(i + 2); //C
indices.Add(i + 1); indices.Add(i + 1); //B
indices.Add(i + 3); indices.Add(i + 3); //D
} }
return indices.ToArray(); return indices.ToArray();

7
LandblockExtraction/LandBlockExtractor/Utilities/VerticesStruct.cs
View file

@ -8,7 +8,6 @@ namespace LandblockExtraction.LandBlockExtractor {
public Vector4[] farcolor { get; set; } public Vector4[] farcolor { get; set; }
public Vector2[] texturecoord { get; set; } public Vector2[] texturecoord { get; set; }
public Vector4[] terraintype { get; set; } public Vector4[] terraintype { get; set; }
public float[] realtype { get; set; }
public VerticesStruct(int blockSize) { public VerticesStruct(int blockSize) {
position = new Vector3[blockSize * blockSize]; position = new Vector3[blockSize * blockSize];
@ -17,13 +16,12 @@ namespace LandblockExtraction.LandBlockExtractor {
farcolor = new Vector4[blockSize * blockSize]; farcolor = new Vector4[blockSize * blockSize];
texturecoord = new Vector2[blockSize * blockSize]; texturecoord = new Vector2[blockSize * blockSize];
terraintype = new Vector4[blockSize * blockSize]; terraintype = new Vector4[blockSize * blockSize];
realtype = new float[blockSize * blockSize];
} }
public float[] Vertices() { public float[] Vertices() {
int length = position.Length; int length = position.Length;
float[] vertices = new float[length * 21]; // 3 pour position, 4 pour color, et 4 pour farcolor float[] vertices = new float[length * 20];
for (int i = 0, vi = 0; i < length; i++, vi += 21) { for (int i = 0, vi = 0; i < length; i++, vi += 20) {
vertices[vi] = position[i].X; vertices[vi] = position[i].X;
vertices[vi + 1] = position[i].Y; vertices[vi + 1] = position[i].Y;
vertices[vi + 2] = position[i].Z; vertices[vi + 2] = position[i].Z;
@ -44,7 +42,6 @@ namespace LandblockExtraction.LandBlockExtractor {
vertices[vi + 17] = terraintype[i].Y; vertices[vi + 17] = terraintype[i].Y;
vertices[vi + 18] = terraintype[i].Z; vertices[vi + 18] = terraintype[i].Z;
vertices[vi + 19] = terraintype[i].W; vertices[vi + 19] = terraintype[i].W;
vertices[vi + 20] = realtype[i];
} }
return vertices; return vertices;
} }

15
LandblockExtraction/Tools/MathOperations.cs
View file

@ -41,5 +41,20 @@ namespace LandblockExtraction.Tools {
Vector3 averageNormal = (normal1 + normal2) / 2; Vector3 averageNormal = (normal1 + normal2) / 2;
return Vector3.Normalize(averageNormal); 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
}
} }
} }

12
LandblockExtraction/WorldMap/VertexInfo/VertexMap.cs Normal file
View file

@ -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;
}

165
LandblockExtraction/WorldMap/WorldMap.cs Normal file
View file

@ -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<float> verticesList = new List<float>();
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<int> indices = new List<int>();
// 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<int> indices = new List<int>();
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);
}
}

2
Map3DRendering/Common/Camera.cs
View file

@ -83,7 +83,7 @@ namespace Map3DRendering.Common {
// Get the projection matrix using the same method we have used up until this point // Get the projection matrix using the same method we have used up until this point
public Matrix4 GetProjectionMatrix() { 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. // This function is going to update the direction vertices using some of the math learned in the web tutorials.

17
Map3DRendering/Common/Shader.cs
View file

@ -1,11 +1,7 @@
using System; using OpenTK.Graphics.OpenGL4;
using System.IO;
using System.Text;
using System.Collections.Generic;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Mathematics; using OpenTK.Mathematics;
namespace Map3DRendering { namespace Map3DRendering.Common {
// A simple class meant to help create shaders. // A simple class meant to help create shaders.
public class Shader { public class Shader {
public readonly int Handle; public readonly int Handle;
@ -167,9 +163,18 @@ namespace Map3DRendering {
/// </summary> /// </summary>
/// <param name="name">The name of the uniform</param> /// <param name="name">The name of the uniform</param>
/// <param name="data">The data to set</param> /// <param name="data">The data to set</param>
public void SetVector2(string name, Vector2 data) {
GL.UseProgram(Handle);
GL.Uniform2(_uniformLocations[name], data);
}
public void SetVector3(string name, Vector3 data) { public void SetVector3(string name, Vector3 data) {
GL.UseProgram(Handle); GL.UseProgram(Handle);
GL.Uniform3(_uniformLocations[name], data); GL.Uniform3(_uniformLocations[name], data);
} }
public void SetVector4(string name, Vector4 data) {
GL.UseProgram(Handle);
GL.Uniform4(_uniformLocations[name], data);
}
} }
} }

13
Map3DRendering/Common/Texture.cs
View file

@ -1,11 +1,7 @@
using OpenTK.Graphics.OpenGL4; using OpenTK.Graphics.OpenGL4;
using System.Drawing;
using System.Drawing.Imaging;
using PixelFormat = OpenTK.Graphics.OpenGL4.PixelFormat;
using StbImageSharp; using StbImageSharp;
using System.IO;
namespace Map3DRendering { namespace Map3DRendering.Common {
// A helper class, much like Shader, meant to simplify loading textures. // A helper class, much like Shader, meant to simplify loading textures.
public class Texture { public class Texture {
public readonly int Handle; public readonly int Handle;
@ -105,6 +101,7 @@ namespace Map3DRendering {
return new Texture(handle); return new Texture(handle);
} }
public Texture(int glHandle) { public Texture(int glHandle) {
Handle = glHandle; Handle = glHandle;
} }
@ -121,5 +118,11 @@ namespace Map3DRendering {
GL.ActiveTexture(unit); GL.ActiveTexture(unit);
GL.BindTexture(TextureTarget.Texture2DArray, Handle); GL.BindTexture(TextureTarget.Texture2DArray, Handle);
} }
public void Assign(int shader, int i) {
int location = GL.GetUniformLocation(shader, "textures[" + i.ToString() + "]");
GL.Uniform1(location, i);
}
} }
} }

6
Map3DRendering/MapRender.cs
View file

@ -70,7 +70,7 @@ namespace Map3DRendering {
} }
} }
private void InitializeBlock(int x, int y, BlockStruct block, Shader _shader) { 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)... // 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. // Utilisez le code de votre méthode OnLoad originale pour configurer le VAO, VBO et EBO.
int tempVertexArray = GL.GenVertexArray(); int tempVertexArray = GL.GenVertexArray();
@ -112,10 +112,6 @@ namespace Map3DRendering {
var terraintypeLocation = _shader.GetAttribLocation("aTexType"); var terraintypeLocation = _shader.GetAttribLocation("aTexType");
GL.EnableVertexAttribArray(terraintypeLocation); GL.EnableVertexAttribArray(terraintypeLocation);
GL.VertexAttribPointer(terraintypeLocation, 4, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 16 * sizeof(float)); 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) { public void Render(Shader shader) {
for (int y = startY; y <= endY; y++) { for (int y = startY; y <= endY; y++) {

1
Map3DRendering/Program.cs
View file

@ -8,6 +8,7 @@ namespace Map3DRendering {
var nativeWindowSettings = new NativeWindowSettings() { var nativeWindowSettings = new NativeWindowSettings() {
ClientSize = new Vector2i(800, 600), ClientSize = new Vector2i(800, 600),
Title = "LearnOpenTK - Map AC2", Title = "LearnOpenTK - Map AC2",
Vsync = VSyncMode.On,
// This is needed to run on macos // This is needed to run on macos
Flags = ContextFlags.ForwardCompatible, Flags = ContextFlags.ForwardCompatible,
}; };

23
Map3DRendering/Shaders/shader.frag
View file

@ -2,33 +2,38 @@
out vec4 outputColor; out vec4 outputColor;
uniform sampler2DArray texture0;
uniform vec3 viewPos; uniform vec3 viewPos;
uniform vec3 lightPos; uniform vec3 lightPos;
uniform vec3 lightColor; uniform vec3 lightColor;
uniform sampler2DArray texture0;
in vec4 Color;
in vec4 FarColor; in vec4 FarColor;
in vec3 Normal; in vec3 Normal;
in vec3 FragPos; in vec3 FragPos;
in vec2 TexCoord; in vec2 TexCoord;
in vec4 TexType; in vec4 TexType;
in float RealType;
void main() 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); vec3 norm = normalize(Normal);
vec4 finalColor = color0; //mix(color0, color1, norm.y);
vec3 lightDir = normalize(lightPos - FragPos); vec3 lightDir = normalize(lightPos - FragPos);
float diff = max(dot(norm, lightDir), 0.0); float diff = max(dot(norm, lightDir), 0.0);
vec3 diffuse = diff * lightColor; 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 distance = length(viewPos - FragPos);
float interpolationFactor = clamp(distance / 1000.0, 0.0, 1.0); float interpolationFactor = clamp(distance / 1000.0, 0.0, 1.0);

3
Map3DRendering/Shaders/shader.vert
View file

@ -5,7 +5,6 @@ layout (location = 2) in vec4 aColor;
layout (location = 3) in vec4 aColorFar; layout (location = 3) in vec4 aColorFar;
layout (location = 4) in vec2 aTexCoord; layout (location = 4) in vec2 aTexCoord;
layout (location = 5) in vec4 aTexType; layout (location = 5) in vec4 aTexType;
layout (location = 6) in float aRealTexType;
uniform mat4 model; uniform mat4 model;
uniform mat4 view; uniform mat4 view;
@ -17,7 +16,6 @@ out vec4 Color;
out vec4 FarColor; out vec4 FarColor;
out vec2 TexCoord; out vec2 TexCoord;
out vec4 TexType; out vec4 TexType;
out float RealType;
void main() void main()
{ {
@ -28,5 +26,4 @@ void main()
FarColor = aColorFar; FarColor = aColorFar;
TexCoord = aTexCoord; TexCoord = aTexCoord;
TexType = aTexType; TexType = aTexType;
RealType = aRealTexType;
} }

24
Map3DRendering/Window.cs
View file

@ -10,7 +10,7 @@ namespace Map3DRendering {
private readonly Vector3 _lightPos = new Vector3(0x10, 0, 0x10); private readonly Vector3 _lightPos = new Vector3(0x10, 0, 0x10);
private MapRender mapRender; private WorldMapRender mapRender;
private AxesGizmo axesGizmo; private AxesGizmo axesGizmo;
private Shader _shader; private Shader _shader;
@ -33,7 +33,7 @@ namespace Map3DRendering {
public Window(GameWindowSettings gameWindowSettings, NativeWindowSettings nativeWindowSettings) public Window(GameWindowSettings gameWindowSettings, NativeWindowSettings nativeWindowSettings)
: base(gameWindowSettings, nativeWindowSettings) { : base(gameWindowSettings, nativeWindowSettings) {
mapRender = new MapRender(); mapRender = new WorldMapRender();
GL.GetInteger(GetPName.MaxTextureImageUnits, out maxTextures); GL.GetInteger(GetPName.MaxTextureImageUnits, out maxTextures);
} }
@ -55,20 +55,16 @@ namespace Map3DRendering {
mapRender.OnLoad(_shader); mapRender.OnLoad(_shader);
var file = Directory.EnumerateFiles(@"./terrains"); var file = Directory.EnumerateFiles(@"./terrains");
_texture = Texture.LoadFromArray(file.ToArray()); _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); _texture.UseArray(TextureUnit.Texture0);
axesGizmo = new AxesGizmo(); axesGizmo = new AxesGizmo();
_camera = new Camera(Vector3.UnitY * 300, Size.X / (float)Size.Y); _camera = new Camera(Vector3.UnitY * 300, Size.X / (float)Size.Y);
_camera.Fov = 60; _camera.Fov = 60;
//CursorState = CursorState.Grabbed; //CursorState = CursorState.Grabbed;
//GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
//GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
_lightPosVec = Vector3.UnitY * 1000; _lightPosVec = Vector3.UnitY * 1000;
} }
@ -79,22 +75,20 @@ namespace Map3DRendering {
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
_texture.UseArray(TextureUnit.Texture0);
_shader.Use(); _shader.Use();
_texture.UseArray(TextureUnit.Texture0);
_shader.SetMatrix4("view", _camera.GetViewMatrix()); _shader.SetMatrix4("view", _camera.GetViewMatrix());
_shader.SetMatrix4("projection", _camera.GetProjectionMatrix()); _shader.SetMatrix4("projection", _camera.GetProjectionMatrix());
//_shader.SetVector3("objectColor", new Vector3(0.5f, 0.5f, 0.5f)); //_shader.SetVector3("objectColor", new Vector3(0.5f, 0.5f, 0.5f));
_shader.SetVector3("lightColor", new Vector3(1.0f, 1.0f, 1.0f)); _shader.SetVector3("lightColor", new Vector3(1.0f, 1.0f, 1.0f));
_shader.SetVector3("lightPos", _lightPosVec); _shader.SetVector3("lightPos", _camera.Position);
//_shader.SetVector3("viewPos", _camera.Position);
GL.LineWidth(5.0f); GL.LineWidth(5.0f);
_shader.SetVector3("viewPos", _camera.Position); _shader.SetVector3("viewPos", _camera.Position);
mapRender.UpdateBlocks(_camera.Position, _shader); //mapRender.UpdateBlocks(_camera.Position, _shader);
mapRender.Render(_shader); mapRender.Render(_shader);
axesGizmo.Render(Size.X, Size.Y, _camera); axesGizmo.Render(Size.X, Size.Y, _camera);
@ -149,10 +143,10 @@ namespace Map3DRendering {
_camera.Position += _camera.Right * cameraSpeed * (float)e.Time; // Right _camera.Position += _camera.Right * cameraSpeed * (float)e.Time; // Right
} }
if (input.IsKeyDown(Keys.Space)) { 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)) { 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 // Get the mouse state

67
Map3DRendering/WorldMapRender.cs Normal file
View file

@ -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);
}
}