Added basic debug lines

cmake/CMakeLists.txt

@@ -3,5 +3,13 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+# Defines
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(DAWN_DEBUG_BUILD true CACHE INTERNAL ${DAWN_CACHE_TARGET})
+else()
+  set(DAWN_DEBUG_BUILD false CACHE INTERNAL ${DAWN_CACHE_TARGET})
+endif()
+
+# Includes
 add_subdirectory(hosts)
 add_subdirectory(targets)

src/dawn/CMakeLists.txt

@@ -39,3 +39,10 @@ add_subdirectory(ui)
 if(DAWN_VISUAL_NOVEL)
   add_subdirectory(visualnovel)
 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(
+    item.mesh->draw(item.drawMode, item.start, item.count);
-      MESH_DRAW_MODE_TRIANGLES,
-      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

@@ -5,12 +5,13 @@
 
 #pragma once
 #include "display/shader/ShaderProgram.hpp"
-#include "scene/components/display/MeshRenderer.hpp"
+#include "display/mesh/Mesh.hpp"
-#include "scene/components/display/Camera.hpp"
 #include "display/_RenderManager.hpp"
 
 namespace Dawn {
   class Material;
+  class MeshRenderer;
+  class Camera;
 
   struct ShaderPassItem {
     ShaderProgram *shaderProgram = nullptr;
@@ -21,6 +22,7 @@ namespace Dawn {
     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;

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

@@ -13,3 +13,7 @@ target_sources(${DAWN_TARGET_NAME}
 
 # 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;
@@ -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
+    );
+  };
+}

src/dawnopengl/display/mesh/Mesh.hpp

@@ -13,7 +13,8 @@ typedef int32_t meshindice_t;
 
 namespace Dawn {
   enum MeshDrawMode {
-    MESH_DRAW_MODE_TRIANGLES = GL_TRIANGLES
+    MESH_DRAW_MODE_TRIANGLES = GL_TRIANGLES,
+    MESH_DRAW_MODE_LINES = GL_LINES
   };
 
   class Mesh {

src/dawnopengl/display/shader/SimpleTexturedShader.cpp

@@ -4,6 +4,8 @@
 // https://opensource.org/licenses/MIT
 
 #include "SimpleTexturedShader.hpp"
+#include "scene/components/display/MeshRenderer.hpp"
+#include "scene/components/display/Camera.hpp"
 
 using namespace Dawn;
 

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -10,10 +10,9 @@
 
 namespace Dawn {
   class SimpleTexturedShader : public Shader {
-    protected:
+    public:
       SimpleTexturedShaderProgram program;
 
-    public:
       void compile() override;
 
       std::vector<struct ShaderPassItem> getPassItems(

src/dawntictactoe/scenes/TicTacToeScene.hpp

@@ -17,8 +17,9 @@ namespace Dawn {
 
       void stage() override {
         camera = Camera::create(this);
-        camera->transform->lookAt(glm::vec3(0, 0, 5), glm::vec3(0, 0, 0));
+        // camera->transform->lookAt(glm::vec3(0, 0, 5), glm::vec3(0, 0, 0));
-        camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
+        // camera->type = CAMERA_TYPE_ORTHONOGRAPHIC;
+        camera->transform->lookAt(glm::vec3(1, 2, 3), glm::vec3(0, 0, 0));
 
         float_t s = 2.0f;
         camera->orthoTop = -s;
@@ -43,6 +44,12 @@ namespace Dawn {
             // tile->ticTacToe->setState(i % 2 == 0 ? TIC_TAC_TOE_CROSS : TIC_TAC_TOE_NOUGHT);
           }
         }
+
+        this->debugCube((struct SceneDebugCube){
+          .min = glm::vec3(-0.5f, -0.5f, -0.5f),
+          .max = glm::vec3(0.5f, 0.5f, 0.5f),
+          COLOR_BLUE
+        });
       }
       
       std::vector<Asset*> getRequiredAssets() override {