Started work on rendering chunks around a player

Author: Andthehand

Minecraft-Clone/CMakeLists.txt

@@ -5,7 +5,7 @@ project(Minecraft-Clone)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
-add_executable(Minecraft-Clone "src/MinecraftAPP.cpp" "src/MinecraftLayer.h" "src/MinecraftLayer.cpp" "src/Chunk.h" "src/Chunk.cpp" "src/Block.cpp" "src/ChunkRenderer.h" "src/ChunkRenderer.cpp")
+add_executable(Minecraft-Clone "src/MinecraftAPP.cpp" "src/MinecraftLayer.h" "src/MinecraftLayer.cpp" "src/Chunk.h" "src/Chunk.cpp" "src/Block.cpp" "src/ChunkRenderer.h" "src/ChunkRenderer.cpp" "src/ChunkManager.h" "src/ChunkManager.cpp" "src/GameCamera.h")
 
 include_directories(Minecraft-Clone PRIVATE
   ${CMAKE_SOURCE_DIR}/RealEngine/src

Minecraft-Clone/assets/shaders/basic.shader

@@ -13,6 +13,7 @@ layout(binding = 1, std430) readonly buffer ssbo1 {
 layout(binding = 0) uniform Camera {
 	mat4 u_ViewProjection;
     vec3 eye_position;
+    ivec3 eye_position_int;
 };
 
 out VS_OUT {
@@ -67,7 +68,7 @@ void main() {
   vs_out.normal = normalLookup[face];
   vs_out.color = colorLookup[(quadData2&255u) - 1];
 
-  vec3 vertexPos = iVertexPos;
+  vec3 vertexPos = iVertexPos - eye_position_int;
   vertexPos[wDir] += 0.0007 * flipLookup[face] * (wMod * 2 - 1);
   vertexPos[hDir] += 0.0007 * (hMod * 2 - 1);
 
@@ -88,6 +89,7 @@ in VS_OUT {
 layout(binding = 0) uniform Camera {
 	mat4 u_ViewProjection;
     vec3 eye_position;
+    ivec3 eye_position_int;
 };
 
 const vec3 diffuse_color = vec3(0.15, 0.15, 0.15);

Minecraft-Clone/src/Chunk.cpp

@@ -18,7 +18,22 @@ namespace RealEngine {
     }
 
 	Chunk::Chunk(const glm::ivec3& chunkOffset) 
-        : m_ChunkOffset(chunkOffset) { }
+        : m_ChunkOffset(chunkOffset) {
+        m_MeshData.opaqueMask = new uint64_t[CS_P2]{ 0 };
+        m_MeshData.faceMasks = new uint64_t[CS_2 * 6]{ 0 };
+        m_MeshData.forwardMerged = new uint8_t[CS_2]{ 0 };
+        m_MeshData.rightMerged = new uint8_t[CS]{ 0 };
+        m_MeshData.vertices = new std::vector<uint64_t>(10000);
+        m_MeshData.maxVertices = 10000;
+    }
+
+    Chunk::~Chunk() {
+		delete[] m_MeshData.opaqueMask;
+		delete[] m_MeshData.faceMasks;
+		delete[] m_MeshData.forwardMerged;
+		delete[] m_MeshData.rightMerged;
+		delete m_MeshData.vertices;
+    }
 
     constexpr uint64_t P_MASK = ~(1ull << 63 | 1);
 
@@ -43,17 +58,9 @@ namespace RealEngine {
         return (type << 32) | (h << 24) | (w << 18) | (z << 12) | (y << 6) | x;
     }
 
-    MeshData Chunk::Generate() {
+    MeshData& Chunk::Reuse() {
         RE_PROFILE_FUNCTION();
 
-        MeshData meshData;
-        meshData.opaqueMask = new uint64_t[CS_P2]{ 0 };
-        meshData.faceMasks = new uint64_t[CS_2 * 6]{ 0 };
-        meshData.forwardMerged = new uint8_t[CS_2]{ 0 };
-        meshData.rightMerged = new uint8_t[CS]{ 0 };
-        meshData.vertices = new std::vector<uint64_t>(10000);
-        meshData.maxVertices = 10000;
-
         //for (uint16_t y = 0; y < CS; y++) {
         //    for (uint8_t x = 0; x < CS; x++) {
         //        for (uint8_t z = 0; z < CS; z++) {
@@ -78,34 +85,34 @@ namespace RealEngine {
                 for (int z = 1; z < CS_P; z++) {
                     if (x % 2 == 0 && y % 2 == 0 && z % 2 == 0) {
                         m_Blocks[z + (x * CS_P) + (y * CS_P2)] = 1;
-                        meshData.opaqueMask[(y * CS_P) + x] |= 1ull << z;
+                        m_MeshData.opaqueMask[(y * CS_P) + x] |= 1ull << z;
 
                         m_Blocks[z + (x * CS_P) + (y * CS_P2)] = 2;
-                        meshData.opaqueMask[((y - 1) * CS_P) + (x - 1)] |= 1ull << z;
+                        m_MeshData.opaqueMask[((y - 1) * CS_P) + (x - 1)] |= 1ull << z;
 
                         m_Blocks[z + (x * CS_P) + (y * CS_P2)] = 3;
-                        meshData.opaqueMask[(y * CS_P) + (x - 1)] |= 1ull << (z - 1);
+                        m_MeshData.opaqueMask[(y * CS_P) + (x - 1)] |= 1ull << (z - 1);
 
                         m_Blocks[z + (x * CS_P) + (y * CS_P2)] = 4;
-                        meshData.opaqueMask[((y - 1) * CS_P) + x] |= 1ull << (z - 1);
+                        m_MeshData.opaqueMask[((y - 1) * CS_P) + x] |= 1ull << (z - 1);
                     }
                 }
             }
         }
 
-        GenerateMesh(meshData);
-		return meshData;
+        GenerateMesh();
+		return m_MeshData;
     }
 
-    void Chunk::GenerateMesh(MeshData& meshData) {
+    void Chunk::GenerateMesh() {
         RE_PROFILE_FUNCTION();
 
-        meshData.vertexCount = 0;
+        m_MeshData.vertexCount = 0;
         int vertexI = 0;
 
-        uint64_t* opaqueMask = meshData.opaqueMask;
-        uint64_t* faceMasks = meshData.faceMasks;
-        uint8_t* forwardMerged = meshData.forwardMerged;
+        uint64_t* opaqueMask = m_MeshData.opaqueMask;
+        uint64_t* faceMasks = m_MeshData.faceMasks;
+        uint8_t* forwardMerged = m_MeshData.forwardMerged;
 
         // Hidden face culling
         for (int a = 1; a < CS_P - 1; a++) {
@@ -192,17 +199,17 @@ namespace RealEngine {
 							    break;
                         }
 
-                        insertQuad(*meshData.vertices, quad, vertexI, meshData.maxVertices);
+                        insertQuad(*m_MeshData.vertices, quad, vertexI, m_MeshData.maxVertices);
                     }
                 }
             }
 
             const int faceVertexLength = vertexI - faceVertexBegin;
-            meshData.faceVertexBegin[face] = faceVertexBegin;
-            meshData.faceVertexLength[face] = faceVertexLength;
+            m_MeshData.faceVertexBegin[face] = faceVertexBegin;
+            m_MeshData.faceVertexLength[face] = faceVertexLength;
         }
 
-        uint8_t* rightMerged = meshData.rightMerged;
+        uint8_t* rightMerged = m_MeshData.rightMerged;
 
         // Greedy meshing faces 4-5
         for (uint8_t face = 4; face < 6; face++) {
@@ -259,16 +266,16 @@ namespace RealEngine {
 
                         const uint64_t quad = getQuad(meshLeft + (face == 4 ? meshWidth : 0), meshFront, meshUp, meshWidth, meshLength, type);
 
-                        insertQuad(*meshData.vertices, quad, vertexI, meshData.maxVertices);
+                        insertQuad(*m_MeshData.vertices, quad, vertexI, m_MeshData.maxVertices);
                     }
                 }
             }
 
             const int faceVertexLength = vertexI - faceVertexBegin;
-            meshData.faceVertexBegin[face] = faceVertexBegin;
-            meshData.faceVertexLength[face] = faceVertexLength;
+            m_MeshData.faceVertexBegin[face] = faceVertexBegin;
+            m_MeshData.faceVertexLength[face] = faceVertexLength;
         }
 
-        meshData.vertexCount = vertexI + 1;
+        m_MeshData.vertexCount = vertexI + 1;
     }
 }

Minecraft-Clone/src/Chunk.h

@@ -5,11 +5,9 @@
 
 #include "Block.h"
 
-#define CHUNK_SIZE_WIDTH 62
+static constexpr int CS = 62;
 
-static constexpr int CS = CHUNK_SIZE_WIDTH;
-
-static constexpr int CS_P = CHUNK_SIZE_WIDTH + 2;
+static constexpr int CS_P = CS + 2;
 static constexpr int CS_2 = CS * CS;
 static constexpr int CS_P2 = CS_P * CS_P;
 static constexpr int CS_P3 = CS_P * CS_P * CS_P;
@@ -29,16 +27,20 @@ namespace RealEngine {
 
 	class Chunk {
 	public:
+		Chunk() = delete;
 		Chunk(const glm::ivec3& chunkOffset);
-		~Chunk() = default;
+		~Chunk();
 
-		MeshData Generate();
+		Chunk(const Chunk&) = delete;
+		Chunk& operator= (const Chunk&) = delete;
 
-		void GenerateMesh(MeshData& meshData);
+		MeshData& Reuse();
+		void GenerateMesh();
 
 		glm::ivec3& GetChunkOffset() { return m_ChunkOffset; }
 	private:
 		BlockType m_Blocks[CS_P * CS_P * CS_P];
+		MeshData m_MeshData;
 
 		glm::ivec3 m_ChunkOffset;
 	};

Minecraft-Clone/src/ChunkManager.cpp

@@ -0,0 +1,82 @@
+#include "ChunkManager.h"
+
+#include "RealEngine.h"
+
+namespace RealEngine {
+	ChunkManager::ChunkManager() {
+		RE_PROFILE_FUNCTION();
+		m_Shader = Shader::Create("assets/shaders/basic.shader");
+		
+		m_ChunkRenderer.init();
+
+		auto circleFunction = [](float x) {
+			return sqrt(RenderDistance * RenderDistance - x * x);
+		};
+	
+		for (float x = 0.5; x < RenderDistance; x += 1.0f) {
+			uint8_t yChunkCnt = (uint8_t)std::roundf(circleFunction(x));
+
+			//Right side of circle
+			for (int i = -yChunkCnt; i < yChunkCnt; i++) {
+				glm::ivec3 chunkOffset = { (int)(x - 0.5f), 0, -i };
+				Scope<Chunk> chunk = CreateScope<Chunk>(chunkOffset);
+
+				MeshData meshData = chunk->Reuse();
+
+				ChunkRenderData renderData;
+				for (uint32_t j = 0; j < renderData.faceDrawCommands.size(); j++) {
+					if (meshData.faceVertexLength[j]) {
+						uint32_t baseInstance = (j << 24) | (chunkOffset.z << 16) | (chunkOffset.y << 8) | chunkOffset.x;
+
+						auto drawCommand = m_ChunkRenderer.getDrawCommand(meshData.faceVertexLength[j], baseInstance);
+
+						renderData.faceDrawCommands[j] = drawCommand;
+
+						m_ChunkRenderer.buffer(*drawCommand, meshData.vertices->data() + meshData.faceVertexBegin[j]);
+					}
+				}
+
+				m_Chunks.push_back({ std::move(chunk), renderData });
+			}
+
+			//Left side of circle
+			for (int i = -yChunkCnt; i < yChunkCnt; i++) {
+				glm::ivec3 chunkOffset = { -(int)(x + 0.5f), 0, i };
+				Scope<Chunk> chunk = CreateScope<Chunk>(chunkOffset);
+
+				MeshData meshData = chunk->Reuse();
+
+				ChunkRenderData renderData;
+				for (uint32_t j = 0; j < renderData.faceDrawCommands.size(); j++) {
+					if (meshData.faceVertexLength[j]) {
+						uint32_t baseInstance = (j << 24) | (chunkOffset.z << 16) | (chunkOffset.y << 8) | chunkOffset.x;
+
+						auto drawCommand = m_ChunkRenderer.getDrawCommand(meshData.faceVertexLength[j], baseInstance);
+
+						renderData.faceDrawCommands[j] = drawCommand;
+
+						m_ChunkRenderer.buffer(*drawCommand, meshData.vertices->data() + meshData.faceVertexBegin[j]);
+					}
+				}
+
+				m_Chunks.push_back({ std::move(chunk), renderData });
+			}
+		}
+	}
+
+	void ChunkManager::Update() {
+		// TODO: Implement
+	}
+
+	void ChunkManager::Render() {
+		for (const auto& chunk : m_Chunks) {
+			for (int i = 0; i < chunk.ChunkRenderData.faceDrawCommands.size(); i++) {
+				if (chunk.ChunkRenderData.faceDrawCommands[i]) {
+					m_ChunkRenderer.addDrawCommand(*chunk.ChunkRenderData.faceDrawCommands[i]);
+				}
+			}
+		}
+
+		m_ChunkRenderer.render(m_Shader);
+	}
+}

Minecraft-Clone/src/ChunkManager.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Chunk.h"
+#include "ChunkRenderer.h"
+
+#include "RealEngine.h"
+
+#define RenderDistance 1
+
+namespace RealEngine {
+	struct ChunkRenderData {
+		std::array<DrawElementsIndirectCommand*, 6> faceDrawCommands = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+	};
+
+	struct ChunkData {
+		Scope<Chunk> Chunk;
+		ChunkRenderData ChunkRenderData;
+	};
+
+	class ChunkManager {
+	public:
+		ChunkManager();
+		~ChunkManager() = default;
+
+		void Update();
+		void Render();
+	private:
+		Ref<Shader> m_Shader;
+
+		std::vector<ChunkData> m_Chunks;
+
+		ChunkRenderer m_ChunkRenderer;
+	};
+}