Improve mesh components

assets/maps/testmap.json

@@ -0,0 +1,8 @@
+{
+  "name": "Test Map",
+  "layers": [
+    {
+
+    }
+  ]
+}

assets/prefabs/npc.json

@@ -9,6 +9,9 @@
   },
 
   "components": {
+    "mesh": {
+      "type": "QuadMesh"
+    },
     "material": {
       "type": "SimpleTexturedMaterial",
       "texture": "rosa"

assets/prefabs/rosa.json

@@ -9,6 +9,9 @@
   },
 
   "components": {
+    "mesh": {
+      "type": "QuadMesh"
+    },
     "material": {
       "type": "SimpleTexturedMaterial",
       "texture": "rosa"

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

@@ -5,5 +5,7 @@
 
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
+    MeshComponent.cpp
     CubeMeshComponent.cpp
+    QuadMeshComponent.cpp
 )

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

@@ -5,26 +5,24 @@
 
 #include "CubeMeshComponent.hpp"
 #include "display/mesh/CubeMesh.hpp"
-#include "component/display/MeshRenderer.hpp"
+#include "util/JSON.hpp"
 
 using namespace Dawn;
 
-void CubeMeshComponent::onInit() {
+void CubeMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
-  if(!mesh) mesh = std::make_shared<Mesh>();
   mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
   CubeMesh::buffer(
-    mesh, glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(1.0f, 1.0f, 1.0f), 0, 0
+    mesh,
+    -(size/2.0f),
+    size,
+    0, 0
   );
-
-  auto renderer = getItem()->getComponent<MeshRenderer>();
-  if(renderer) renderer->mesh = mesh;
 }
 
-void CubeMeshComponent::onDispose() {
+void CubeMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
-  mesh = nullptr;
+  if(ctx->data.contains("size")) {
-}
+    this->size = JSON::vec3(ctx->data["size"]);
-
+  } else {
-void CubeMeshComponent::load(std::shared_ptr<SceneLoadContext> ctx) {
+    this->size = glm::vec3(1.0f, 1.0f, 1.0f);
-  SceneComponent::load(ctx);
+  }
-  if(!mesh) mesh = std::make_shared<Mesh>();
 }

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

@@ -4,16 +4,14 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "scene/SceneItem.hpp"
+#include "MeshComponent.hpp"
-#include "display/mesh/Mesh.hpp"
 
 namespace Dawn {
-  class CubeMeshComponent final : public SceneComponent {
+  class CubeMeshComponent final : public MeshComponent {
-    public:
+    protected:
-      std::shared_ptr<Mesh> mesh;
+      glm::vec3 size;
 
-      void onInit() override;
+      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
-      void onDispose() override;
+      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
-      void load(std::shared_ptr<SceneLoadContext> ctx) override;
   };
 }

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

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "MeshComponent.hpp"
+#include "component/display/MeshRenderer.hpp"
+
+using namespace Dawn;
+
+void MeshComponent::buffer() {
+  if(!mesh) mesh = std::make_shared<Mesh>();
+  this->meshBuffer(mesh);
+}
+
+void MeshComponent::onInit() {
+  this->buffer();
+
+  auto renderer = getItem()->getComponent<MeshRenderer>();
+  if(renderer) renderer->mesh = mesh;
+}
+
+void MeshComponent::onDispose() {
+  mesh = nullptr;
+}
+
+void MeshComponent::load(std::shared_ptr<SceneLoadContext> ctx) {
+  SceneComponent::load(ctx);
+  if(this->mesh == nullptr) this->mesh = std::make_shared<Mesh>();
+  this->meshLoad(ctx);
+}

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

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItem.hpp"
+#include "display/mesh/Mesh.hpp"
+
+namespace Dawn {
+  class MeshComponent : public SceneComponent {
+    protected:
+      /**
+       * Called when the mesh should be loaded.
+       * 
+       * @param ctx Context to load the mesh from.
+       */
+      virtual void meshLoad(std::shared_ptr<SceneLoadContext> ctx) = 0;
+
+      /**
+       * Called when the mesh should be buffered.
+       * 
+       * @param mesh Mesh to buffer.
+       */
+      virtual void meshBuffer(std::shared_ptr<Mesh> mesh) = 0;
+
+      /**
+       * Buffers the mesh.
+       */
+      void buffer();
+
+    public:
+      std::shared_ptr<Mesh> mesh;
+
+      void onInit() override;
+      void onDispose() override;
+      void load(std::shared_ptr<SceneLoadContext> ctx) override;
+  };
+}

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

@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "QuadMeshComponent.hpp"
+#include "display/mesh/QuadMesh.hpp"
+#include "util/JSON.hpp"
+
+using namespace Dawn;
+
+void QuadMeshComponent::meshBuffer(std::shared_ptr<Mesh> mesh) {
+  mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+  QuadMesh::buffer(
+    mesh,
+    this->positions,
+    this->uvs,
+    0, 0
+  );
+}
+
+void QuadMeshComponent::meshLoad(std::shared_ptr<SceneLoadContext> ctx) {
+  if(ctx->data.contains("positions")) {
+    this->positions = JSON::vec4(ctx->data["positions"]);
+  } else {
+    this->positions = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
+  }
+
+  if(ctx->data.contains("uvs")) {
+    this->uvs = JSON::vec4(ctx->data["uvs"]);
+  } else {
+    this->uvs = glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
+  }
+}
+
+void QuadMeshComponent::setPositions(const glm::vec4 &positions) {
+  this->positions = positions;
+  this->buffer();
+}
+
+void QuadMeshComponent::setUVs(const glm::vec4 &uvs) {
+  this->uvs = uvs;
+  this->buffer();
+}

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

@@ -0,0 +1,33 @@
+// 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 QuadMeshComponent final : public MeshComponent {
+    protected:
+      glm::vec4 positions;
+      glm::vec4 uvs;
+    
+      void meshLoad(std::shared_ptr<SceneLoadContext> ctx) override;
+      void meshBuffer(std::shared_ptr<Mesh> mesh) override;
+
+    public:
+      /**
+       * Sets the positions of the quad.
+       * 
+       * @param positions The positions of the quad.
+       */
+      void setPositions(const glm::vec4 &positions);
+
+      /**
+       * Sets the UVs of the quad.
+       * 
+       * @param uvs The UVs of the quad.
+       */
+      void setUVs(const glm::vec4 &uvs);
+  };
+}

src/dawn/display/mesh/PlaneMesh.cpp

@@ -0,0 +1,59 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "PlaneMesh.hpp"
+
+using namespace Dawn;
+
+void PlaneMesh::buffer(
+  const std::shared_ptr<Mesh> mesh,
+  const glm::vec2 planeSize,
+  const int32_t columns,
+  const int32_t rows
+) {
+  const int32_t verticeCount = (columns + 1) * (rows + 1) * PLANE_VERTICE_PER_SEGMENT;
+  const int32_t indiceCount = columns * rows * 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];
+  int32_t indices[indiceCount];
+
+  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;
+
+      vertices[verticeIndex] = glm::vec3(x, 0.0f, y);
+      uvs[verticeIndex] = glm::vec2((float)column / columns, (float)row / rows);
+      verticeIndex++;
+    }
+  }
+
+  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->bufferIndices(0, indices, indiceCount);
+}

src/dawn/display/mesh/PlaneMesh.hpp

@@ -0,0 +1,22 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/mesh/Mesh.hpp"
+
+#define PLANE_VERTICE_PER_SEGMENT 4
+#define PLANE_INDICE_PER_SEGMENT 6
+
+namespace Dawn {
+  class PlaneMesh {
+    public:
+      static void buffer(
+        const std::shared_ptr<Mesh> mesh,
+        const glm::vec2 planeSize,
+        const int32_t columns,
+        const int32_t rows
+      );
+  };
+}

src/dawn/game/IGame.cpp

@@ -14,6 +14,7 @@
 #include "component/display/material/SimpleTexturedMaterial.hpp"
 #include "component/display/MeshRenderer.hpp"
 #include "component/display/mesh/CubeMeshComponent.hpp"
+#include "component/display/mesh/QuadMeshComponent.hpp"
 
 #ifdef DAWN_ENABLE_PHYSICS
 #endif
@@ -26,6 +27,8 @@ IGame::IGame() {
   SceneComponentRegistry::reg<MeshRenderer>("MeshRenderer");
   SceneComponentRegistry::reg<CubeMeshComponent>("CubeMeshComponent");
   SceneComponentRegistry::reg<CubeMeshComponent>("CubeMesh");
+  SceneComponentRegistry::reg<QuadMeshComponent>("QuadMeshComponent");
+  SceneComponentRegistry::reg<QuadMeshComponent>("QuadMesh");
 }
 
 void IGame::init() {

src/dawn/game/IGame.hpp

@@ -23,7 +23,7 @@ namespace Dawn {
     INITIALIZED = FLAG(1),
   };
 
-  class IGame : public std::enable_shared_from_this<IGame> {
+  class IGame : public std::enable_shared_from_this<Game> {
     private:
       std::shared_ptr<Scene> currentScene = nullptr;
       std::shared_ptr<Scene> nextFrameScene = nullptr;

src/dawn/util/JSON.cpp

@@ -10,6 +10,7 @@ using namespace Dawn;
 
 glm::vec3 JSON::vec3(const json &j) {
   if(j.type() == json::value_t::array) {
+    assertTrue(j.size() == 3, "Invalid size for vec3");
     return glm::vec3(j[0].get<float_t>(), j[1].get<float_t>(), j[2].get<float_t>());
   } else if(j.type() == json::value_t::object) {
     assertTrue(j.contains("x"), "Missing x in vec3");
@@ -27,6 +28,33 @@ glm::vec3 JSON::vec3(const json &j) {
   return glm::vec3(0.0f);
 }
 
+glm::vec4 JSON::vec4(const json &j) {
+  if(j.type() == json::value_t::array) {
+    assertTrue(j.size() == 4, "Invalid size for vec4");
+    return glm::vec4(
+      j[0].get<float_t>(),
+      j[1].get<float_t>(),
+      j[2].get<float_t>(),
+      j[3].get<float_t>()
+    );
+  } else if(j.type() == json::value_t::object) {
+    assertTrue(j.contains("x"), "Missing x in vec4");
+    assertTrue(j.contains("y"), "Missing y in vec4");
+    assertTrue(j.contains("z"), "Missing z in vec4");
+    assertTrue(j.contains("w"), "Missing w in vec4");
+
+    return glm::vec4(
+      j["x"].get<float_t>(),
+      j["y"].get<float_t>(),
+      j["z"].get<float_t>(),
+      j["w"].get<float_t>()
+    );
+  }
+
+  assertUnreachable("Invalid JSON type for vec4");
+  return glm::vec4(0.0f);
+}
+
 struct Color JSON::color(const json &j) {
   if(j.type() == json::value_t::array) {
     return {

src/dawn/util/JSON.hpp

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

src/dawnrpg/CMakeLists.txt

@@ -12,6 +12,7 @@ target_include_directories(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(component)
 add_subdirectory(game)
+add_subdirectory(rpg)
 
 # Assets
 tool_texture(rosa rosa.png)

src/dawnrpg/component/RPGEntity.cpp

@@ -5,7 +5,7 @@
 
 #include "RPGEntity.hpp"
 #include "scene/Scene.hpp"
-#include "display/mesh/QuadMesh.hpp"
+#include "component/display/mesh/QuadMeshComponent.hpp"
 #include "asset/loader/TextureLoader.hpp"
 #include "display/tileset/TilesetGrid.hpp"
 
@@ -15,22 +15,12 @@ void RPGEntity::onInit() {
   const glm::vec2 size = { RPG_ENTITY_SIZE, RPG_ENTITY_SIZE };
   const glm::vec2 position = -size;
 
-  mesh = std::make_shared<Mesh>();
+  auto mesh = getItem()->getComponent<QuadMeshComponent>();
-  mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+  mesh->setPositions(glm::vec4(position.x, position.y, size.x, size.y));
-  QuadMesh::buffer(
-    mesh,
-    glm::vec4(position.x, position.y, size.x, size.y),
-    glm::vec4(0, 1.0f, 1, 0.75f),
-    0, 0, 0
-  );
-
-  getItem()->getComponent<MeshRenderer>()->mesh = mesh;
-
   updateSprite();
 }
 
 void RPGEntity::onDispose() {
-  mesh = nullptr;
 }
 
 enum RPGEntityDirection RPGEntity::getFacingDirection() {
@@ -74,6 +64,7 @@ void RPGEntity::updateSprite() {
 
   // Convert row/col to UV coordinates.
   glm::vec4 tile = tileset.getTile(col, row);
-  tile = glm::vec4(tile.x, tile.w, tile.z, tile.y);// swap Y axis.
+  tile = glm::vec4(tile.x, tile.w, tile.z, tile.y);
-  QuadMesh::bufferCoordinates(mesh, tile, 0);
+  auto mesh = getItem()->getComponent<QuadMeshComponent>();
+  mesh->setUVs(tile);
 }

src/dawnrpg/component/RPGEntity.hpp

@@ -20,8 +20,6 @@ namespace Dawn {
     private:
 
     protected:
-      std::shared_ptr<Mesh> mesh;
-
       enum RPGEntityDirection facingDirection = RPGEntityDirection::SOUTH;
 
       void updateSprite();

src/dawnrpg/game/Game.cpp

@@ -21,7 +21,8 @@ std::string Game::getInitialScene() {
 }
 
 void Game::initManagers() {
-
+  this->rpgManager = std::make_shared<RPGManager>();
+  this->rpgManager->init(shared_from_this());
 }
 
 Game::~Game() {

src/dawnrpg/game/Game.hpp

@@ -5,14 +5,19 @@
 
 #pragma once
 #include "game/IGame.hpp"
+#include "rpg/RPGManager.hpp"
 
 namespace Dawn {
-  class Game : public IGame {
+  class Game :
+    public IGame
+  {
     protected:
       std::string getInitialScene() override;
       void initManagers() override;
 
     public:
+      std::shared_ptr<RPGManager> rpgManager;
+
       Game();
       ~Game();
   };

src/dawnrpg/rpg/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    RPGManager.cpp
+)

src/dawnrpg/rpg/RPGManager.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "RPGManager.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+void RPGManager::init(const std::shared_ptr<Game> &game) {
+  this->game = game; 
+}
+
+std::shared_ptr<Game> RPGManager::getGame() {
+  auto l = this->game.lock();
+  assertNotNull(l, "Game is null?");
+  return l;
+}

src/dawnrpg/rpg/RPGManager.hpp

@@ -0,0 +1,21 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+namespace Dawn {
+  class Game;
+  
+  class RPGManager {
+    private:
+      std::weak_ptr<Game> game;
+
+    public:
+      void init(const std::shared_ptr<Game> &game);
+
+      std::shared_ptr<Game> getGame();
+  };
+}