Added basic debug lines

src/dawn/CMakeLists.txt

@@ -38,4 +38,11 @@ add_subdirectory(ui)
 
 if(DAWN_VISUAL_NOVEL)
   add_subdirectory(visualnovel)
-endif()
+endif()
+
+# Definitions
+target_compile_definitions(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${DAWN_SHARED_DEFINITIONS}
+    DAWN_DEBUG_BUILD=${DAWN_DEBUG_BUILD}
+)

src/dawn/display/RenderPipeline.cpp

@@ -6,6 +6,10 @@
 #include "RenderPipeline.hpp"
 #include "game/DawnGame.hpp"
 
+#if DAWN_DEBUG_BUILD
+  #include "scene/debug/SceneDebugLine.hpp"
+#endif
+
 using namespace Dawn;
 
 RenderPipeline::RenderPipeline(RenderManager *renderManager) {
@@ -159,6 +163,27 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
     ++itCanvas;
   }
 
+  // Debug Lines
+  #if DAWN_DEBUG_BUILD
+    Mesh lineMesh;
+    int32_t lineIndex = 0;
+    lineMesh.createBuffers(
+      scene->debugLines.size() * SCENE_DEBUG_LINE_VERTICE_COUNT,
+      scene->debugLines.size() * SCENE_DEBUG_LINE_INDICE_COUNT
+    );
+    auto itDebugLine = scene->debugLines.begin();
+    while(itDebugLine != scene->debugLines.end()) {
+      auto item = itDebugLine->createShaderItem(
+        &lineMesh,
+        &lineIndex,
+        camera,
+        &this->renderManager->simpleShader
+      );
+      shaderPassItems.push_back(item);
+      ++itDebugLine;
+    }
+  #endif
+
   // Now we've queued everything, let's sort the rendering queue by the priority
   std::sort(
     shaderPassItems.begin(),
@@ -246,11 +271,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
     this->renderManager->setRenderFlags(item.renderFlags);
 
     // Thank god that's done, now just draw the damn mesh.
-    item.mesh->draw(
-      MESH_DRAW_MODE_TRIANGLES,
-      item.start,
-      item.count
-    );
+    item.mesh->draw(item.drawMode, item.start, item.count);
     ++itPassItem;
   }
 }

src/dawn/display/RenderPipeline.hpp

@@ -11,6 +11,7 @@
 #include "scene/components/scene/SubSceneController.hpp"
 #include "ui/UIComponent.hpp"
 
+
 namespace Dawn {
   class RenderManager;
 

src/dawn/display/shader/Shader.hpp

@@ -1,62 +1,64 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "display/shader/ShaderProgram.hpp"
-#include "scene/components/display/MeshRenderer.hpp"
-#include "scene/components/display/Camera.hpp"
-#include "display/_RenderManager.hpp"
-
-namespace Dawn {
-  class Material;
-
-  struct ShaderPassItem {
-    ShaderProgram *shaderProgram = nullptr;
-    int32_t priority = 0;
-
-    Mesh *mesh;
-    int32_t start = 0;
-    int32_t count = -1;
-    float_t w = 0;
-    renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
-    
-    // Parameters
-    std::map<shaderparameter_t, struct Color> colorValues;
-    std::map<shaderparameter_t, bool_t> boolValues;
-    std::map<shaderparameter_t, glm::mat4> matrixValues;
-    std::map<shaderparameter_t, glm::vec3> vec3Values;
-    std::map<shaderparameter_t, textureslot_t> textureValues;
-    std::map<shaderparameter_t, float_t> floatValues;
-
-    // Textures
-    std::map<textureslot_t, Texture*> textureSlots;
-  };
-
-  class Shader {
-    public:
-      int_fast16_t renderId = 0;
-
-      /**
-       * Compile all programs for this shader. This amy not remain forever as I
-       * may decide to allow shaders to share programs somehow. For now though
-       * this is clean enough.
-       */
-      virtual void compile() = 0;
-
-      /**
-       * Returns the list of pass items to render for the given scene item.
-       * 
-       * @param mesh Mesh Renderer for the scene item.
-       * @param material Material for the scene item.
-       * @param camera Camera for the scene.
-       * @return List of passes to render.
-       */
-      virtual std::vector<struct ShaderPassItem> getPassItems(
-        Mesh *mesh,
-        Material *material,
-        Camera *camera
-      ) = 0;
-  };
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/ShaderProgram.hpp"
+#include "display/mesh/Mesh.hpp"
+#include "display/_RenderManager.hpp"
+
+namespace Dawn {
+  class Material;
+  class MeshRenderer;
+  class Camera;
+
+  struct ShaderPassItem {
+    ShaderProgram *shaderProgram = nullptr;
+    int32_t priority = 0;
+
+    Mesh *mesh;
+    int32_t start = 0;
+    int32_t count = -1;
+    float_t w = 0;
+    renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
+    enum MeshDrawMode drawMode = MESH_DRAW_MODE_TRIANGLES;
+    
+    // Parameters
+    std::map<shaderparameter_t, struct Color> colorValues;
+    std::map<shaderparameter_t, bool_t> boolValues;
+    std::map<shaderparameter_t, glm::mat4> matrixValues;
+    std::map<shaderparameter_t, glm::vec3> vec3Values;
+    std::map<shaderparameter_t, textureslot_t> textureValues;
+    std::map<shaderparameter_t, float_t> floatValues;
+
+    // Textures
+    std::map<textureslot_t, Texture*> textureSlots;
+  };
+
+  class Shader {
+    public:
+      int_fast16_t renderId = 0;
+
+      /**
+       * Compile all programs for this shader. This amy not remain forever as I
+       * may decide to allow shaders to share programs somehow. For now though
+       * this is clean enough.
+       */
+      virtual void compile() = 0;
+
+      /**
+       * Returns the list of pass items to render for the given scene item.
+       * 
+       * @param mesh Mesh Renderer for the scene item.
+       * @param material Material for the scene item.
+       * @param camera Camera for the scene.
+       * @return List of passes to render.
+       */
+      virtual std::vector<struct ShaderPassItem> getPassItems(
+        Mesh *mesh,
+        Material *material,
+        Camera *camera
+      ) = 0;
+  };
 }

src/dawn/prefabs/SimpleSpinningCubePrefab.hpp

@@ -31,7 +31,7 @@ namespace Dawn {
         void prefabInit(AssetManager *man) override {
           auto meshRenderer = this->addComponent<MeshRenderer>();
           meshHost = this->addComponent<MeshHost>();
-          // auto spinning = this->addComponent<ExampleSpin>();
+          auto spinning = this->addComponent<ExampleSpin>();
           material = this->addComponent<SimpleTexturedMaterial>();
 
           meshHost->mesh.createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);

src/dawn/scene/CMakeLists.txt

@@ -1,15 +1,19 @@
-# Copyright (c) 2022 Dominic Masters
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
-
-# Sources
-target_sources(${DAWN_TARGET_NAME}
-  PRIVATE
-    Scene.cpp
-    SceneItem.cpp
-    SceneItemComponent.cpp
-)
-
-# Subdirs
-add_subdirectory(components)
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    Scene.cpp
+    SceneItem.cpp
+    SceneItemComponent.cpp
+)
+
+# Subdirs
+add_subdirectory(components)
+
+if(DAWN_DEBUG_BUILD)
+  add_subdirectory(debug)
+endif()

src/dawn/scene/Scene.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "event/Event.hpp"
 #include "asset/Asset.hpp"
+#include "scene/debug/SceneDebugLine.hpp"
 
 namespace Dawn {
   class DawnGame;
@@ -23,7 +24,7 @@ namespace Dawn {
       sceneitemid_t nextId;
       std::map<sceneitemid_t, SceneItem*> items;
       std::map<sceneitemid_t, SceneItem*> itemsNotInitialized;
-
+    
     public:
       DawnGame *game;
       Event<> eventSceneUpdate;
@@ -130,6 +131,13 @@ namespace Dawn {
         return components;
       }
 
+      // Scene debugging functions
+      #if DAWN_DEBUG_BUILD
+        std::vector<struct SceneDebugLine> debugLines;
+        void debugLine(struct SceneDebugLine line);
+        void debugCube(struct SceneDebugCube cube);
+      #endif
+
       /**
        * Destroys a previously initialized Scene.
        */

src/dawn/scene/debug/CMakeLists.txt

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

src/dawn/scene/debug/SceneDebugLine.cpp

@@ -0,0 +1,100 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneDebugLine.hpp"
+#include "display/shader/SimpleTexturedShader.hpp"
+#include "scene/components/display/Camera.hpp"
+#include "scene/Scene.hpp"
+
+using namespace Dawn;
+
+struct ShaderPassItem SceneDebugLine::createShaderItem(
+  Mesh *mesh,
+  int32_t *lineIndex,
+  Camera *camera,
+  SimpleTexturedShader *shader
+) {
+  struct ShaderPassItem item;
+  item.priority = SCENE_DEBUG_LINE_PRIORITY;
+
+  item.shaderProgram = &shader->program;
+  item.colorValues[shader->program.paramColor] = this->color;
+  item.matrixValues[shader->program.paramModel] = this->translation;
+  item.matrixValues[shader->program.paramView] = camera->transform->getWorldTransform();
+  item.matrixValues[shader->program.paramProjection] = camera->projection;
+  item.boolValues[shader->program.paramHasTexture] = false;
+
+  item.renderFlags = 0x00;
+
+  auto i = *lineIndex;
+  item.mesh = mesh;
+  item.drawMode = MESH_DRAW_MODE_LINES;
+  item.start = i * SCENE_DEBUG_LINE_INDICE_COUNT;
+  item.count = SCENE_DEBUG_LINE_INDICE_COUNT;
+
+  glm::vec3 positions[SCENE_DEBUG_LINE_VERTICE_COUNT] = { this->v0, this->v1 };
+  mesh->bufferPositions(
+    i * SCENE_DEBUG_LINE_VERTICE_COUNT,
+    positions,
+    SCENE_DEBUG_LINE_VERTICE_COUNT
+  );
+
+  meshindice_t indices[SCENE_DEBUG_LINE_INDICE_COUNT] = {
+    i * SCENE_DEBUG_LINE_VERTICE_COUNT,
+    (i*SCENE_DEBUG_LINE_VERTICE_COUNT) + 1
+  };
+  mesh->bufferIndices(
+    i * SCENE_DEBUG_LINE_INDICE_COUNT,
+    indices,
+    SCENE_DEBUG_LINE_INDICE_COUNT
+  );
+  
+  (*lineIndex)++;
+  return item;
+}
+
+// Scene Implementations (done here to keep things cleaner in scene)
+void Scene::debugLine(struct SceneDebugLine line) {
+  this->debugLines.push_back(line);
+}
+
+void Scene::debugCube(struct SceneDebugCube cube) {
+  auto min = cube.min;
+  auto max = cube.max;
+
+  struct SceneDebugLine line;
+  line.color = cube.color;
+  line.translation = cube.translation;
+
+  // Bottom Face
+  line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(max.x, min.y, min.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(min.x, min.y, max.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(max.x, min.y, min.z), line.v1 = glm::vec3(max.x, min.y, max.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(min.x, min.y, max.z), line.v1 = glm::vec3(max.x, min.y, max.z);
+  this->debugLine(line);
+
+  // Top Face
+  line.v0 = glm::vec3(min.x, max.y, min.z), line.v1 = glm::vec3(max.x, max.y, min.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(min.x, max.y, min.z), line.v1 = glm::vec3(min.x, max.y, max.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(max.x, max.y, min.z), line.v1 = glm::vec3(max.x, max.y, max.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(min.x, max.y, max.z), line.v1 = glm::vec3(max.x, max.y, max.z);
+  this->debugLine(line);
+
+  // Rails
+  line.v0 = glm::vec3(min.x, min.y, min.z), line.v1 = glm::vec3(min.x, max.y, min.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(max.x, min.y, min.z), line.v1 = glm::vec3(max.x, max.y, min.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(min.x, min.y, max.z), line.v1 = glm::vec3(min.x, max.y, max.z);
+  this->debugLine(line);
+  line.v0 = glm::vec3(max.x, min.y, max.z), line.v1 = glm::vec3(max.x, max.y, max.z);
+  this->debugLine(line);
+}

src/dawn/scene/debug/SceneDebugLine.hpp

@@ -0,0 +1,48 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/Color.hpp"
+#include "display/mesh/Mesh.hpp"
+#include "display/shader/Shader.hpp"
+
+#define SCENE_DEBUG_LINE_VERTICE_COUNT 2
+#define SCENE_DEBUG_LINE_INDICE_COUNT 2
+#define SCENE_DEBUG_LINE_PRIORITY 100
+
+namespace Dawn {
+  class SimpleTexturedShader;
+  class Camera;
+
+  struct SceneDebugCube {
+    glm::vec3 min;
+    glm::vec3 max;
+    struct Color color = COLOR_RED;
+    glm::mat4 translation = glm::mat4(1.0f);
+  };
+
+  struct SceneDebugLine {
+    glm::vec3 v0 = glm::vec3(0, 0, 0);
+    glm::vec3 v1 = glm::vec3(1, 1, 1);
+    struct Color color = COLOR_RED;
+    glm::mat4 translation = glm::mat4(1.0f);
+
+    /**
+     * Creates a renderable shader item for this debug line.
+     * 
+     * @param mesh Mesh that this debug line will buffer its indices in to
+     * @param lineIndex Currently iterated line index.
+     * @param camera Camera for this line index to set the shader params for.
+     * @param shader Shader that the params will be set for.
+     * @return The queueable shader pass item.
+     */
+    struct ShaderPassItem createShaderItem(
+      Mesh *mesh,
+      int32_t *lineIndex,
+      Camera *camera,
+      SimpleTexturedShader *shader
+    );
+  };
+}