map mat

assets/scenes/test_rpg_scene.json

@@ -38,9 +38,11 @@
           "type": "MeshRenderer"
         },
         "mat": {
-          "type": "SimpleTexturedMaterial",
+          "type": "MapMaterial",
-          "color": "green",
           "texture": "rosatext"
+        },
+        "map": {
+          "type": "RPGMap"
         }
       }
     },

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

@@ -17,7 +17,7 @@ void MeshComponent::buffer() {
 }
 
 void MeshComponent::invalidate() {
-  if(valid) return;
+  if(!valid) return;
   valid = false;
   events.push_back(getScene()->onNextFrame.listen([this]() {
     this->buffer();

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

@@ -10,7 +10,7 @@
 namespace Dawn {
   class MeshComponent : public SceneComponent {
     private:
-      bool_t valid = true;
+      bool_t valid = false;
 
       /**
        * Buffers the mesh.

src/dawnrpg/CMakeLists.txt

@@ -11,6 +11,7 @@ target_include_directories(${DAWN_TARGET_NAME}
 
 # Subdirs
 add_subdirectory(component)
+add_subdirectory(display)
 add_subdirectory(game)
 add_subdirectory(rpg)
 

src/dawnrpg/component/CMakeLists.txt

@@ -7,4 +7,8 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     RPGEntity.cpp
     RPGPlayer.cpp
-)
+    RPGMap.cpp
+)
+
+# Subdirs
+add_subdirectory(display)

src/dawnrpg/component/RPGMap.cpp

@@ -9,10 +9,10 @@ using namespace Dawn;
 
 void RPGMap::onInit() {
   auto mesh = getItem()->getComponent<PlaneMeshComponent>();
-  
 }
 
 void RPGMap::onDispose() {
+  
 }
 
 void RPGMap::load(std::shared_ptr<SceneLoadContext> ctx) {

src/dawnrpg/component/display/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+add_subdirectory(material)

src/dawnrpg/component/display/material/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
+    MapMaterial.cpp
+)

src/dawnrpg/component/display/material/MapMaterial.cpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "MapMaterial.hpp"
+#include "util/JSON.hpp"
+#include "asset/loader/TextureLoader.hpp"
+
+using namespace Dawn;
+
+void MapMaterial::load(std::shared_ptr<SceneLoadContext> ctx) {
+  if(ctx->data.contains("color")) {
+    this->setColor(JSON::color(ctx->data["color"]));
+  }
+
+  if(ctx->data.contains("texture")) {
+    auto asset = ctx->getAsset<TextureLoader>(
+      ctx->data["texture"].get<std::string>()
+    );
+    this->setTexture(asset->getTexture());
+  }
+}
+
+struct Color MapMaterial::getColor() {
+  return this->data.color;
+}
+
+std::shared_ptr<Texture> MapMaterial::getTexture() {
+  return this->texture;
+}
+
+void MapMaterial::setTexture(
+  const std::shared_ptr<Texture> texture
+) {
+  this->texture = texture;
+}
+
+void MapMaterial::setColor(const struct Color color) {
+  this->data.color = color;
+}
+
+std::vector<std::shared_ptr<IRenderPass>> MapMaterial::getPasses(
+  struct RenderPassContext &ctx
+) {
+  this->data.model = this->getItem()->getWorldTransform();
+  this->data.projection = ctx.camera->getProjection();
+  this->data.view = ctx.camera->getItem()->getWorldTransform();
+  auto textures = std::unordered_map<
+    shadertexturebinding_t, std::shared_ptr<Texture>
+  >();
+  
+  if(this->texture) {
+    this->data.hasTexture = true;
+    this->data.texture = 0;
+    textures[this->data.texture] = this->texture;
+  } else {
+    this->data.hasTexture = false;
+  }
+
+  return {
+    createRenderPass<MapShader, struct MapShaderData>(
+      *this,
+      data,
+      textures
+    )
+  };
+}

src/dawnrpg/component/display/material/MapMaterial.hpp

@@ -0,0 +1,50 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "component/display/material/Material.hpp"
+#include "display/shader/MapShader.hpp"
+#include "display/Texture.hpp"
+
+namespace Dawn {
+  class MapMaterial : public Material {
+    private:
+      struct MapShaderData data;
+      std::shared_ptr<Texture> texture;
+
+    public:
+      void load(std::shared_ptr<SceneLoadContext> ctx) override;
+      
+      /**
+       * Returns the color of this material.
+       */
+      struct Color getColor();
+
+      /**
+       * Returns the texture of this material.
+       * 
+       * @return The texture of this material.
+       */
+      std::shared_ptr<Texture> getTexture();
+
+      /**
+       * Sets the texture of this material.
+       * 
+       * @param texture The texture to set.
+       */
+      void setTexture(const std::shared_ptr<Texture> texture);
+
+      /**
+       * Sets the color of this material.
+       * 
+       * @param color The color to set.
+       */
+      void setColor(const struct Color color);
+
+      std::vector<std::shared_ptr<IRenderPass>> getPasses(
+        struct RenderPassContext &ctx
+      ) override;
+  };
+}

src/dawnrpg/display/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+add_subdirectory(shader)

src/dawnrpg/display/shader/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
+    MapShader.cpp
+)

src/dawnrpg/display/shader/MapShader.cpp

@@ -0,0 +1,104 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "display/shader/MapShader.hpp"
+
+using namespace Dawn;
+
+void MapShader::getStages(
+  const enum ShaderOpenGLVariant variant,
+  const struct MapShaderData *rel,
+  std::vector<std::shared_ptr<ShaderStage>> &stages,
+  std::vector<struct ShaderParameter> &parameters,
+  std::vector<struct IShaderStructure> &structures
+) {
+  // Stages
+  std::shared_ptr<ShaderStage> vertex;
+  std::shared_ptr<ShaderStage> fragment;
+
+  switch(variant) {
+    case ShaderOpenGLVariant::GLSL_330_CORE:
+      vertex = std::make_shared<ShaderStage>(
+        ShaderStageType::VERTEX,R"(
+          #version 330 core
+          layout (location = 0) in vec3 aPos;
+          layout (location = 1) in vec2 aTexCoord;
+          uniform mat4 u_Projection;
+          uniform mat4 u_View;
+          uniform mat4 u_Model;
+          out vec2 o_TextCoord;
+          void main() {
+            gl_Position = u_Projection * u_View * u_Model * vec4(aPos, 1.0);
+            o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);
+          }
+        )"
+      );
+      
+      fragment = std::make_shared<ShaderStage>(
+        ShaderStageType::FRAGMENT,R"(
+          #version 330 core
+          in vec2 o_TextCoord;
+          out vec4 o_Color;
+          uniform vec4 u_Color;
+          uniform bool u_HasTexture;
+          uniform sampler2D u_Texture;
+          void main() {
+            if(u_HasTexture) {
+              o_Color = texture(u_Texture, o_TextCoord);
+            } else {
+              o_Color = u_Color;
+            }
+
+            if(o_Color.a == 0) discard;
+          }
+        )"
+      );
+      break;
+
+    default:
+      assertUnreachable("Unsupported ShaderOpenGLVariant");
+  }
+
+  // Add stages
+  stages.push_back(vertex);
+  stages.push_back(fragment);
+
+  // Parameters
+  parameters.push_back(ShaderParameter(
+    "u_Projection",
+    &rel->projection,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_View",
+    &rel->view,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_Model",
+    &rel->model,
+    ShaderParameterType::MAT4
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_Color",
+    &rel->color,
+    ShaderParameterType::COLOR
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_HasTexture",
+    &rel->hasTexture,
+    ShaderParameterType::BOOLEAN
+  ));
+
+  parameters.push_back(ShaderParameter(
+    "u_Texture",
+    &rel->texture,
+    ShaderParameterType::TEXTURE
+  ));
+}

src/dawnrpg/display/shader/MapShader.hpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/Shader.hpp"
+
+namespace Dawn {
+  struct MapShaderData {
+    glm::mat4 projection;
+    glm::mat4 view;
+    glm::mat4 model;
+    struct Color color = COLOR_WHITE;
+    bool hasTexture = false;
+    shadertexturebinding_t texture = 0;
+  };
+
+  class MapShader : public Shader<MapShaderData> {
+    protected:
+      void getStages(
+        const enum ShaderOpenGLVariant variant,
+        const struct MapShaderData *rel,
+        std::vector<std::shared_ptr<ShaderStage>> &stages,
+        std::vector<struct ShaderParameter> &parameters,
+        std::vector<struct IShaderStructure> &structures
+      ) override;
+  };
+}

src/dawnrpg/game/Game.cpp

@@ -6,14 +6,18 @@
 #include "Game.hpp"
 #include "component/SceneComponentRegistry.hpp"
 
+#include "component/display/material/MapMaterial.hpp"
 #include "component/RPGEntity.hpp"
 #include "component/RPGPlayer.hpp"
+#include "component/RPGMap.hpp"
 
 using namespace Dawn;
 
 Game::Game() : IGame() {
   SceneComponentRegistry::reg<RPGEntity>("RPGEntity");
   SceneComponentRegistry::reg<RPGPlayer>("RPGPlayer");
+  SceneComponentRegistry::reg<RPGMap>("RPGMap");
+  SceneComponentRegistry::reg<MapMaterial>("MapMaterial");
 }
 
 std::string Game::getInitialScene() {