UI Hello World

src/dawn/display/RenderPipeline.cpp

@@ -5,6 +5,7 @@
 
 #include "RenderPipeline.hpp"
 #include "game/DawnGame.hpp"
+#include "display/mesh/QuadMesh.hpp"
 
 using namespace Dawn;
 
@@ -44,6 +45,14 @@ void RenderPipeline::renderScene(Scene &scene) {
   // Now render the backbuffer camera.
   if(backBufferCamera == nullptr) return;
   this->renderSceneCamera(scene, *backBufferCamera);
+
+  // Now we try and render UI components
+  auto uiCanvasList = scene.findComponents<UICanvas>();
+  auto itCanvas = uiCanvasList.begin();
+  while(itCanvas != uiCanvasList.end()) {
+    this->renderUI(scene, *backBufferCamera, **itCanvas);
+    ++itCanvas;
+  }
 }
 
 void RenderPipeline::renderSceneCamera(Scene &scene, Camera &camera) {
@@ -53,6 +62,10 @@ void RenderPipeline::renderSceneCamera(Scene &scene, Camera &camera) {
     RENDER_TARGET_CLEAR_FLAG_DEPTH |
     RENDER_TARGET_CLEAR_FLAG_COLOR
   );
+  this->renderManager.setRenderFlags(
+    RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST |
+    RENDER_MANAGER_RENDER_FLAG_BLEND
+  );
 
   auto meshes = scene.findComponents<MeshRenderer>();
   auto it = meshes.begin();
@@ -77,6 +90,51 @@ void RenderPipeline::renderSceneCamera(Scene &scene, Camera &camera) {
   }
 }
 
+void RenderPipeline::renderUI(
+  Scene &scene,
+  Camera &camera,
+  UICanvas &canvas
+) {
+  // Get the 
+  RenderTarget *renderTarget;
+
+  glm::mat4 transform;
+  glm::mat4 projection;
+  switch(canvas.drawType) {
+    case UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE:
+      transform = glm::mat4(1.0f);
+      projection = glm::ortho(0.0f, canvas.getWidth(), canvas.getHeight(), 0.0f);
+      renderTarget = &camera.getRenderTarget();
+      break;
+    default:
+      throw "UI Draw modes are not yet supported.";
+  }
+  
+  // Clear / Bind / Update the render target.
+  renderTarget->bind();
+  renderTarget->clear(
+    RENDER_TARGET_CLEAR_FLAG_DEPTH |
+    RENDER_TARGET_CLEAR_FLAG_COLOR
+  );
+  this->renderManager.setRenderFlags(
+    RENDER_MANAGER_RENDER_FLAG_BLEND |
+    RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST
+  );
+
+  // Prepare the UI Shader
+  auto shader = this->renderManager.getUIShader();
+  shader->bind();
+  shader->setUICamera(transform, projection);
+
+  // Render the children
+  glm::mat4 rootMatrix = canvas.transform.getWorldTransform();  
+  auto it = canvas.children.begin();
+  while(it != canvas.children.end()) {
+    (*it)->draw(*shader, rootMatrix);
+    ++it;
+  }
+}
+
 RenderPipeline::~RenderPipeline() {
 
 }

src/dawn/display/RenderPipeline.hpp

@@ -8,6 +8,8 @@
 #include "display/RenderManager.hpp"
 #include "scene/Scene.hpp"
 #include "scene/components/Components.hpp"
+#include "scene/components/ui/UICanvas.hpp"
+#include "ui/UIComponent.hpp"
 
 namespace Dawn {
   class RenderPipeline {
@@ -49,6 +51,19 @@ namespace Dawn {
        */
       virtual void renderSceneCamera(Scene &scene, Camera &camera);
 
+      /**
+       * Renders a UI Canvas to the back buffer.
+       * 
+       * @param scene Scene for the UI canvas.
+       * @param camera Main backbuffer camera for the canvas.
+       * @param canvas Canvas to render.
+       */
+      virtual void renderUI(
+        Scene &scene,
+        Camera &camera,
+        UICanvas &canvas
+      );
+
       /**
        * Cleanup a render pipeline that has been initialized.
        */

src/dawn/display/Transform.cpp

@@ -79,7 +79,7 @@ void Transform::setLocalPosition(glm::vec3 position) {
 }
 
 glm::vec3 Transform::getLocalScale() {
-  return this->scale;
+  return this->localScale;
 }
 
 void Transform::setLocalScale(glm::vec3 scale) {
@@ -140,6 +140,9 @@ void Transform::setParent(Transform *parent) {
 
   this->parent = parent;
   if(parent != nullptr) parent->children.push_back(this);
+
+  this->updateLocalTransformFromWorldTransform();
+  this->updateChildrenTransforms();
 }
 
 Transform * Transform::getParent() {
@@ -148,6 +151,7 @@ Transform * Transform::getParent() {
 
 Transform::~Transform() {
   this->setParent(nullptr);
+
   auto it = this->parent->children.begin();
   while(it != this->parent->children.end()) {
     (*it)->setParent(nullptr);

src/dawn/display/Transform.hpp

@@ -21,9 +21,9 @@ namespace Dawn {
       glm::mat4 transformLocal;
       glm::mat4 transformWorld;
 
-      glm::vec3 position;
-      glm::vec3 scale;
-      glm::quat rotation;
+      // glm::vec3 position;
+      // glm::vec3 scale;
+      // glm::quat rotation;
 
       // Heirarchy
       Transform *parent = nullptr;

src/dawn/display/_RenderManager.hpp

@@ -6,12 +6,22 @@
 #pragma once
 #include "RenderTarget.hpp"
 #include "display/shader/Shader.hpp"
+#include "display/shader/UIShader.hpp"
+#include "util/flag.hpp"
+
+#define RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST FLAG_DEFINE(0)
+#define RENDER_MANAGER_RENDER_FLAG_BLEND FLAG_DEFINE(1)
+
+typedef flag_t renderflag_t;
 
 namespace Dawn {
   class DawnGame;
   class RenderPipeline;
 
   class IRenderManager {
+    protected:
+      renderflag_t renderFlags = 0;
+
     public:
       DawnGame &game;
       std::shared_ptr<RenderPipeline> renderPipeline;
@@ -47,6 +57,20 @@ namespace Dawn {
        */
       virtual std::shared_ptr<Shader> getDefaultShader() = 0;
 
+      /**
+       * Returns the UI Shader used by the game's UI engine.
+       * 
+       * @return Pointer to the UI Shader.
+       */
+      virtual std::shared_ptr<UIShader> getUIShader() = 0;
+      
+      /**
+       * Sets the render flags for the render manager to use.
+       * 
+       * @param renderFlags Render flags to use.
+       */
+      virtual void setRenderFlags(renderflag_t renderFlags) = 0;
+
       /**
        * Initialize / Start the Render Manager.
        * 

src/dawn/display/mesh/QuadMesh.cpp

@@ -35,4 +35,15 @@ void QuadMesh::bufferQuadMeshWithZ(
       verticeStart + 1, verticeStart + 2, verticeStart + 3
     }}
   );
+}
+
+void QuadMesh::bufferQuadMesh(
+  Mesh &mesh,
+  glm::vec2 xy0, glm::vec2 uv0,
+  glm::vec2 xy1, glm::vec2 uv1,
+  int32_t verticeStart, int32_t indiceStart
+) {
+  QuadMesh::bufferQuadMeshWithZ(
+    mesh, xy0, uv0, xy1, uv1, 0, verticeStart, indiceStart
+  );
 }