Added plane

assets/scenes/test_rpg_scene.json

@@ -9,6 +9,10 @@
     "npc": {
       "type": "prefab",
       "path": "prefabs/npc.json"
+    },
+    "rosatext": {
+      "type": "texture",
+      "path": "rosa.texture"
     }
   },
 
@@ -21,6 +25,26 @@
       }
     },
 
+    "plane": {
+      "position": [ 0, 0, 0 ],
+      "components": {
+        "mesh": {
+          "type": "PlaneMesh",
+          "size": [ 512, 512 ],
+          "cells": [ 16, 16 ],
+          "uv": [ 0, 0, 0.33, 0.25 ]
+        },
+        "renderer": {
+          "type": "MeshRenderer"
+        },
+        "mat": {
+          "type": "SimpleTexturedMaterial",
+          "color": "green",
+          "texture": "rosatext"
+        }
+      }
+    },
+
     "rosa": {
       "prefab": "rosa",
       "position": [ 0, 0, 0 ],

src/dawn/component/display/mesh/CMakeLists.txt

@@ -8,4 +8,5 @@ target_sources(${DAWN_TARGET_NAME}
     MeshComponent.cpp
     CubeMeshComponent.cpp
     QuadMeshComponent.cpp
+    PlaneMeshComponent.cpp
 )

src/dawn/component/display/mesh/PlaneMeshComponent.cpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PlaneMeshComponent.hpp"
+#include "display/mesh/PlaneMesh.hpp"
+#include "util/JSON.hpp"
+
+using namespace Dawn;
+
+void PlaneMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
+  if(ctx->data.contains("columns")) {
+    columns = ctx->data["columns"];
+    assertTrue(columns > 0, "Columns must be greater than 0.");
+  } else {
+    columns = 10;
+  }
+
+  if(ctx->data.contains("rows")) {
+    rows = ctx->data["rows"];
+    assertTrue(rows > 0, "Rows must be greater than 0.");
+  } else {
+    rows = columns;
+  }
+
+  if(ctx->data.contains("cells")) {
+    assertTrue(
+      ctx->data["cells"].type() == json::value_t::array,
+      "Cells must be an array."
+    );
+    assertTrue(
+      ctx->data["cells"].size() == 2,
+      "Cells must be an array of 2 integers."
+    );
+    columns = ctx->data["cells"][0];
+    rows = ctx->data["cells"][1];
+    assertTrue(columns > 0, "Columns must be greater than 0.");
+    assertTrue(rows > 0, "Rows must be greater than 0.");
+  }
+
+  if(ctx->data.contains("planeSize")) {
+    planeSize = JSON::vec2(ctx->data["planeSize"]);
+    assertTrue(planeSize.x > 0.0f, "Plane size x must be greater than 0.");
+    assertTrue(planeSize.y > 0.0f, "Plane size y must be greater than 0.");
+  } else if(ctx->data.contains("size")) {
+    planeSize = JSON::vec2(ctx->data["size"]);
+    assertTrue(planeSize.x > 0.0f, "Size x must be greater than 0.");
+    assertTrue(planeSize.y > 0.0f, "Size y must be greater than 0.");
+  } else {
+    planeSize = glm::vec2(10.0f, 10.0f);
+  }
+
+  if(ctx->data.contains("uv")) {
+    uv = JSON::vec4(ctx->data["uv"]);
+  } else {
+    uv = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
+  }
+}
+
+void PlaneMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
+  PlaneMesh::buffer(
+    mesh,
+    planeSize,
+    columns, rows,
+    uv
+  );
+}

src/dawn/component/display/mesh/PlaneMeshComponent.hpp

@@ -0,0 +1,23 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "MeshComponent.hpp"
+
+namespace Dawn {
+  class PlaneMeshComponent final : public MeshComponent {
+    protected:
+      int32_t columns;
+      int32_t rows;
+      glm::vec2 planeSize;
+      glm::vec4 uv;
+
+      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
+      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
+
+    public:
+
+  };
+}

src/dawn/display/mesh/CMakeLists.txt

@@ -9,4 +9,5 @@ target_sources(${DAWN_TARGET_NAME}
     CubeMesh.cpp
     QuadMesh.cpp
     SphereMesh.cpp
+    PlaneMesh.cpp
 )

src/dawn/display/mesh/PlaneMesh.cpp

@@ -4,6 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "PlaneMesh.hpp"
+#include "assert/assert.hpp"
 
 using namespace Dawn;
 
@@ -11,49 +12,53 @@ void PlaneMesh::buffer(
   const std::shared_ptr<Mesh> mesh,
   const glm::vec2 planeSize,
   const int32_t columns,
-  const int32_t rows
+  const int32_t rows,
+  const glm::vec4 uv
 ) {
+  assertNotNull(mesh, "Mesh cannot be null.");
+  assertTrue(columns > 0, "Columns must be greater than 0.");
+  assertTrue(rows > 0, "Rows must be greater than 0.");
+
   const int32_t verticeCount = (columns+1)*(rows+1) * PLANE_VERTICE_PER_SEGMENT;
-  const int32_t indiceCount = columns * rows * PLANE_INDICE_PER_SEGMENT;
+  const int32_t indiceCount = (columns+1)*(rows+1) * PLANE_INDICE_PER_SEGMENT;
   mesh->createBuffers(verticeCount, indiceCount);
 
-  const float columnWidth = planeSize.x / columns;
-  const float rowHeight = planeSize.y / rows;
-
-  glm::vec3 vertices[verticeCount];
-  glm::vec2 uvs[verticeCount];
+  glm::vec3 positions[verticeCount];
+  glm::vec2 coordinates[verticeCount];
   int32_t indices[indiceCount];
+  const glm::vec2 offset(planeSize.x / 2.0f, planeSize.y / 2.0f);
+  const glm::vec2 step(planeSize.x / columns, planeSize.y / rows);
 
-  int32_t verticeIndex = 0;
-  int32_t indiceIndex = 0;
-  for (int32_t row = 0; row <= rows; row++) {
-    for (int32_t column = 0; column <= columns; column++) {
-      const float x = column * columnWidth;
-      const float y = row * rowHeight;
+  for (int32_t y = 0; y <= rows; ++y) {
+    for (int32_t x = 0; x <= columns; ++x) {
+      const int32_t verticeStart = (y * (columns + 1) + x) * PLANE_VERTICE_PER_SEGMENT;
+      const int32_t indiceStart = (y * (columns + 1) + x) * PLANE_INDICE_PER_SEGMENT;
 
-      vertices[verticeIndex] = glm::vec3(x, 0.0f, y);
-      uvs[verticeIndex] = glm::vec2((float)column / columns, (float)row / rows);
-      verticeIndex++;
+      const float_t xPos = step.x * x - offset.x;
+      const float_t yPos = step.y * y - offset.y;
+
+      positions[verticeStart + 0] = glm::vec3(xPos, yPos, 0.0f);
+      positions[verticeStart + 1] = glm::vec3(xPos + step.x, yPos, 0.0f);
+      positions[verticeStart + 2] = glm::vec3(xPos, yPos + step.y, 0.0f);
+      positions[verticeStart + 3] = glm::vec3(xPos + step.x, yPos + step.y, 0.0f);
+
+      coordinates[verticeStart + 0] = glm::vec2(uv.x, uv.y);
+      coordinates[verticeStart + 1] = glm::vec2(uv.z, uv.y);
+      coordinates[verticeStart + 2] = glm::vec2(uv.x, uv.w);
+      coordinates[verticeStart + 3] = glm::vec2(uv.z, uv.w);
+
+      indices[indiceStart + 0] = verticeStart + 0;
+      indices[indiceStart + 1] = verticeStart + 2;
+      indices[indiceStart + 2] = verticeStart + 1;
+
+      indices[indiceStart + 3] = verticeStart + 1;
+      indices[indiceStart + 4] = verticeStart + 2;
+      indices[indiceStart + 5] = verticeStart + 3;
     }
   }
 
-  for (int32_t row = 0; row < rows; row++) {
-    for (int32_t column = 0; column < columns; column++) {
-      const int32_t topLeft = (row * (columns + 1)) + column;
-      const int32_t topRight = topLeft + 1;
-      const int32_t bottomLeft = topLeft + (columns + 1);
-      const int32_t bottomRight = bottomLeft + 1;
 
-      indices[indiceIndex++] = topLeft;
-      indices[indiceIndex++] = bottomLeft;
-      indices[indiceIndex++] = topRight;
-      indices[indiceIndex++] = topRight;
-      indices[indiceIndex++] = bottomLeft;
-      indices[indiceIndex++] = bottomRight;
-    }
-  }
-
-  mesh->bufferPositions(0, vertices, verticeCount);
-  mesh->bufferCoordinates(0, uvs, verticeCount);
+  mesh->bufferPositions(0, positions, verticeCount);
+  mesh->bufferCoordinates(0, coordinates, verticeCount);
   mesh->bufferIndices(0, indices, indiceCount);
 }

src/dawn/display/mesh/PlaneMesh.hpp

@@ -12,11 +12,21 @@
 namespace Dawn {
   class PlaneMesh {
     public:
+      /**
+       * Buffers a plane mesh into the provided mesh.
+       * 
+       * @param mesh The mesh to buffer the plane into.
+       * @param planeSize The size of the plane.
+       * @param columns The number of columns.
+       * @param rows The number of rows.
+       * @param uv The UV coordinates of the plane.
+       */
       static void buffer(
         const std::shared_ptr<Mesh> mesh,
         const glm::vec2 planeSize,
         const int32_t columns,
-        const int32_t rows
+        const int32_t rows,
+        const glm::vec4 uv = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f)
       );
   };
 }

src/dawn/game/IGame.cpp

@@ -15,6 +15,7 @@
 #include "component/display/MeshRenderer.hpp"
 #include "component/display/mesh/CubeMeshComponent.hpp"
 #include "component/display/mesh/QuadMeshComponent.hpp"
+#include "component/display/mesh/PlaneMeshComponent.hpp"
 
 #ifdef DAWN_ENABLE_PHYSICS
 #endif
@@ -29,6 +30,8 @@ IGame::IGame() {
   SceneComponentRegistry::reg<CubeMeshComponent>("CubeMesh");
   SceneComponentRegistry::reg<QuadMeshComponent>("QuadMeshComponent");
   SceneComponentRegistry::reg<QuadMeshComponent>("QuadMesh");
+  SceneComponentRegistry::reg<PlaneMeshComponent>("PlaneMeshComponent");
+  SceneComponentRegistry::reg<PlaneMeshComponent>("PlaneMesh");
 }
 
 void IGame::init() {

src/dawn/util/JSON.cpp

@@ -8,6 +8,24 @@
 
 using namespace Dawn;
 
+glm::vec2 JSON::vec2(const json &j) {
+  if(j.type() == json::value_t::array) {
+    assertTrue(j.size() == 2, "Invalid size for vec2");
+    return glm::vec2(j[0].get<float_t>(), j[1].get<float_t>());
+  } else if(j.type() == json::value_t::object) {
+    assertTrue(j.contains("x"), "Missing x in vec2");
+    assertTrue(j.contains("y"), "Missing y in vec2");
+    
+    return glm::vec2(
+      j["x"].get<float_t>(),
+      j["y"].get<float_t>()
+    );
+  }
+
+  assertUnreachable("Invalid JSON type for vec2");
+  return glm::vec2(0.0f);
+}
+
 glm::vec3 JSON::vec3(const json &j) {
   if(j.type() == json::value_t::array) {
     assertTrue(j.size() == 3, "Invalid size for vec3");

src/dawn/util/JSON.hpp

@@ -10,6 +10,14 @@
 namespace Dawn {
   class JSON final {
     public:
+      /**
+       * Parses the given JSON string as a vec2.
+       * 
+       * @param j JSON obj to parse.
+       * @return Parsed vec2.
+       */
+      static glm::vec2 vec2(const json &j);
+
       /**
        * Parses the given JSON string as a vec3.
        *