UI Hello World

src/dawn/CMakeLists.txt

@@ -18,4 +18,5 @@ target_include_directories(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(asset)
 add_subdirectory(display)
-add_subdirectory(scene)
+add_subdirectory(scene)
+add_subdirectory(ui)

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
+  );
 }

src/dawn/scene/Scene.cpp

@@ -35,5 +35,4 @@ std::shared_ptr<SceneItem> Scene::createSceneItem() {
 }
 
 Scene::~Scene() {
-  std::cout << "What the dick" << std::endl;
 }

src/dawn/scene/SceneItem.hpp

@@ -71,6 +71,42 @@ namespace Dawn {
         }
         return nullptr;
       }
+
+      /**
+       * Finds a (direct) child of this component that has a matching component.
+       * 
+       * @tparam T Component to find child of.
+       * @return Pointer to the child, or nullptr if not found.
+       */
+      template<class T>
+      std::shared_ptr<T> findChild() {
+        auto it = this->transform.children.begin();
+        while(it != this->transform.children.end()) {
+          auto child = (*it)->item.getComponent<T>();
+          if(child != nullptr) return child;
+          ++it;
+        }
+        return nullptr;
+      }
+
+      /**
+       * Finds all (direct) children of this component that match the queried
+       * component.
+       * 
+       * @tparam T Component to find children for.
+       * @return Array of pointers to matching children.
+       */
+      template<class T>
+      std::vector<std::shared_ptr<T>> findChildren() {
+        auto it = this->transform.children.begin();
+        std::vector<std::shared_ptr<T>> children;
+        while(it != this->transform.children.end()) {
+          auto child = (*it)->item.getComponent<T>();
+          if(child != nullptr) children.push_back(child);
+          ++it;
+        }
+        return children;
+      }
       
       /**
        * Destroy this SceneItem.

src/dawn/scene/components/CMakeLists.txt

@@ -4,4 +4,5 @@
 # https://opensource.org/licenses/MIT
 
 # Subdirs
-add_subdirectory(display)
+add_subdirectory(display)
+add_subdirectory(ui)

src/dawn/scene/components/ui/CMakeLists.txt

@@ -0,0 +1,10 @@
+# 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
+    UICanvas.cpp
+)

src/dawn/scene/components/ui/UICanvas.cpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UICanvas.hpp"
+#include "scene/Scene.hpp"
+#include "ui/UIComponent.hpp"
+#include "game/DawnGame.hpp"
+
+using namespace Dawn;
+
+std::shared_ptr<UICanvas> UICanvas::createCanvas(std::shared_ptr<Scene> scene) {
+  auto item = scene->createSceneItem();
+  return item->addComponent<UICanvas>();
+}
+
+UICanvas::UICanvas(SceneItem &item) : SceneItemComponent(item) {
+
+}
+
+float_t UICanvas::getWidth() {
+  return this->getGame().renderManager.getBackBuffer().getWidth();
+}
+
+float_t UICanvas::getHeight() {
+  return this->getGame().renderManager.getBackBuffer().getHeight();
+}
+
+void UICanvas::start() {
+
+}

src/dawn/scene/components/ui/UICanvas.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+
+namespace Dawn {
+  enum UIDrawType {
+    UI_DRAW_TYPE_WORLD_ABSOLUTE,
+    UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE,
+    UI_DRAW_TYPE_CAMERA_OVERLAY
+  };
+
+  class UIComponent;
+
+  class UICanvas : public SceneItemComponent {
+    public:
+      static std::shared_ptr<UICanvas> createCanvas(
+        std::shared_ptr<Scene> scene
+      );
+
+      //
+      std::vector<std::shared_ptr<UIComponent>> children;
+      UIDrawType drawType = UI_DRAW_TYPE_WORLD_CAMERA_RELATIVE;
+
+      UICanvas(SceneItem &item);
+
+      template<class T>
+      std::shared_ptr<T> addElement() {
+        auto item = std::make_shared<T>(*this);
+        this->children.push_back(item);
+        return item;
+      }
+
+      float_t getWidth();
+      float_t getHeight();
+
+      void start() override;
+  };
+}

src/dawn/ui/CMakeLists.txt

@@ -0,0 +1,11 @@
+# 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
+    UIComponent.cpp
+    UISprite.cpp
+)

src/dawn/ui/UIComponent.cpp

@@ -0,0 +1,119 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "UIComponent.hpp"
+
+using namespace Dawn;
+
+UIComponent::UIComponent(UICanvas &canvas) :
+  canvas(canvas)
+{
+}
+
+void UIComponent::updatePositions() {
+  // X Alignment
+  if(this->alignX == UI_COMPONENT_ALIGN_STRETCH) {
+    if(this->parent == nullptr) {
+      this->width = this->canvas.getWidth();
+    } else {
+      this->width = this->parent->getWidth();
+    }
+    this->relativeX = this->alignment[0];
+    this->width -= (this->alignment[0] + this->alignment[2]);
+  } else {
+    this->relativeX = this->alignment[0];
+    this->width = this->alignment[2];
+  }
+
+  // Y Alignment
+  if(this->alignY == UI_COMPONENT_ALIGN_STRETCH) {
+    if(this->parent == nullptr) {
+      this->height = this->canvas.getHeight();
+    } else {
+      this->height = this->parent->getHeight();
+    }
+    this->relativeY = this->alignment[1];
+    this->height -= (this->alignment[1] + this->alignment[3]);
+  } else {
+    this->relativeY = this->alignment[1];
+    this->height = this->alignment[3];
+  }
+
+  // Update children
+  auto it = this->children.begin();
+  while(it != this->children.end()) {
+    (*it)->updatePositions();
+    ++it;
+  }
+}
+
+float_t UIComponent::getWidth() {
+  return this->width;
+}
+
+float_t UIComponent::getHeight() {
+  return this->height;
+}
+
+float_t UIComponent::getRelativeX() {
+  return this->relativeX;
+}
+
+float_t UIComponent::getRelativeY() {
+  return this->relativeY;
+}
+
+void UIComponent::setTransform(
+  UIComponentAlign xAlign,
+  UIComponentAlign yAlign,
+  glm::vec4 alignment,
+  float_t z
+) {
+  this->alignX = xAlign;
+  this->alignY = yAlign;
+  this->alignment = alignment;
+  this->z = z;
+  this->updatePositions();
+}
+
+void UIComponent::draw(UIShader &uiShader, glm::mat4 parentTransform) {
+  // Calculate self transform matrix
+  glm::mat4 selfTransform = parentTransform * glm::translate(
+    glm::mat4(1.0f), glm::vec3(this->relativeX, this->relativeY, this->z)
+  );
+
+  // Draw Self
+  this->drawSelf(uiShader, selfTransform);
+
+  // Render children
+  auto it = this->children.begin();
+  while(it != this->children.end()) {
+    (*it)->draw(uiShader, selfTransform);
+    ++it;
+  }
+}
+
+void UIComponent::addChild(std::shared_ptr<UIComponent> child) {
+  if(child->parent == this) return;
+  if(child->parent != nullptr) child->parent->removeChild(child);
+  this->children.push_back(child);
+  child->parent = this;
+}
+
+void UIComponent::removeChild(std::shared_ptr<UIComponent> child) {
+  if(child->parent != this) throw "Invalid child";
+  auto it = this->children.begin();
+  while(it != this->children.end()) {
+    if(it->get() == child.get()) {
+      this->children.erase(it);
+      break;
+    }
+    ++it;
+  }
+}
+
+UIComponent::~UIComponent() {
+  
+}

src/dawn/ui/UIComponent.hpp

@@ -0,0 +1,75 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/components/ui/UICanvas.hpp"
+#include "scene/Scene.hpp"
+#include "display/Color.hpp"
+#include "display/shader/UIShader.hpp"
+
+namespace Dawn {
+  enum UIComponentAlign {
+    UI_COMPONENT_ALIGN_START,
+    UI_COMPONENT_ALIGN_MIDDLE,
+    UI_COMPONENT_ALIGN_END,
+    UI_COMPONENT_ALIGN_STRETCH
+  };
+  
+  class UIComponent {
+    protected:
+      // Calculated (and cached) values
+      float_t width = 1;
+      float_t height = 1;
+      float_t relativeX = 0;
+      float_t relativeY = 0;
+
+      // Setting values
+      UIComponentAlign alignX = UI_COMPONENT_ALIGN_START;
+      UIComponentAlign alignY = UI_COMPONENT_ALIGN_START;
+      glm::vec4 alignment = glm::vec4(0, 0, 1, 1);
+      float_t z = 0;
+      std::vector<std::shared_ptr<UIComponent>> children;
+      UIComponent *parent = nullptr;
+      
+      // I currently don't support rotation or scale. Not because I can't but
+      // because it's basically un-necessary. Unity does support rotation but
+      // it doesn't affect how the alignment side of things work (similar to how
+      // CSS would handle things) When I need to support these I will add the 
+      // code but right now it's not necessary
+
+      /**
+       * Updates the cached/stored values based on the setting internal values.
+       * You should watchdog this if you intend to do something when values are 
+       * updated, e.g. if you need to resize a quad, or something.
+       */
+      virtual void updatePositions();
+
+    public:
+      UICanvas &canvas;
+
+      UIComponent(UICanvas &canvas);
+
+      float_t getWidth();
+      float_t getHeight();
+      float_t getRelativeX();
+      float_t getRelativeY();
+      
+      void setTransform(
+        UIComponentAlign xAlign,
+        UIComponentAlign yAlign,
+        glm::vec4 alignment,
+        float_t z
+      );
+
+      // virtual void update() = 0;
+      void draw(UIShader &uiShader, glm::mat4 parentTransform);
+      virtual void drawSelf(UIShader &uiShader, glm::mat4 selfTransform) = 0;
+
+      void addChild(std::shared_ptr<UIComponent> chidl);
+      void removeChild(std::shared_ptr<UIComponent> child);
+      
+      virtual ~UIComponent();
+  };
+}

src/dawn/ui/UISprite.cpp

@@ -0,0 +1,34 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License. 
+// https://opensource.org/licenses/MIT
+
+#include "UISprite.hpp"
+
+using namespace Dawn;
+
+UISprite::UISprite(UICanvas &canvas) : UIComponent(canvas) {
+  this->mesh.createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+}
+
+void UISprite::updatePositions() {
+  UIComponent::updatePositions();
+
+  std::cout << "Updating" << std::endl;
+
+  QuadMesh::bufferQuadMesh(
+    this->mesh,
+    glm::vec2(0, 0), glm::vec2(0, 0),
+    glm::vec2(this->width, this->height), glm::vec2(1, 1),
+    0, 0
+  );
+}
+
+void UISprite::drawSelf(UIShader &uiShader, glm::mat4 selfTransform) {
+  uiShader.setUITexture(nullptr);
+  uiShader.setUIModel(selfTransform);
+  uiShader.setUIModel(glm::mat4(1.0f));
+  uiShader.setUIColor(COLOR_WHITE);
+
+  this->mesh.draw(MESH_DRAW_MODE_TRIANGLES, 0, -1);
+}

src/dawn/ui/UISprite.hpp

@@ -0,0 +1,23 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "UIComponent.hpp"
+#include "display/mesh/QuadMesh.hpp"
+
+namespace Dawn {
+  class UISprite : public UIComponent {
+    protected:
+      void updatePositions() override;
+
+    public:
+      Mesh mesh;
+
+      UISprite(UICanvas &canvas);
+      
+      // void update() override;
+      void drawSelf(UIShader &uiShader, glm::mat4 selfTransform) override;
+  };
+}

src/dawn/util/flag.hpp

@@ -7,5 +7,9 @@
 #include "dawnlibs.hpp"
 
 typedef uint_fast8_t flag8_t;
+typedef uint_fast16_t flag16_t;
+typedef uint_fast32_t flag32_t;
+
+typedef flag32_t flag_t;
 
 #define FLAG_DEFINE(n) (1 << n)

src/dawnopengl/display/RenderManager.cpp

@@ -16,17 +16,18 @@ RenderManager::RenderManager(DawnGame &game) :
 {
   this->standardRenderPipeline=std::make_shared<StandardRenderPipeline>(*this);
   this->simpleShader = std::make_shared<SimpleTexturedShader>();
+  this->uiShader = std::make_shared<UIShader>();
 }
 
 void RenderManager::init() {
   this->standardRenderPipeline->init();
   this->simpleShader->compile();
+  this->uiShader->compile();
 
-  // Setup the alpha blend function.
-  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  glEnable(GL_BLEND);
+
+  // Prepare the initial values
   glEnable(GL_TEXTURE_2D);
-  glEnable(GL_DEPTH_TEST);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glDepthMask(GL_TRUE);
   glDepthFunc(GL_LESS);
 }
@@ -43,6 +44,26 @@ std::shared_ptr<Shader> RenderManager::getDefaultShader() {
   return this->simpleShader;
 }
 
+std::shared_ptr<UIShader> RenderManager::getUIShader() {
+  return this->uiShader;
+}
+
+void RenderManager::setRenderFlags(renderflag_t flags) {
+  this->renderFlags = flags;
+  
+  if((flags & RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST) == 0) {
+    glDisable(GL_DEPTH_TEST);
+  } else {
+    glEnable(GL_DEPTH_TEST);
+  }
+
+  if((flags & RENDER_MANAGER_RENDER_FLAG_BLEND) == 0) {
+    glDisable(GL_BLEND);
+  } else {
+    glEnable(GL_BLEND);
+  }
+}
+
 void RenderManager::update() {
   this->getRenderPipeline().render();
 }

src/dawnopengl/display/RenderManager.hpp

@@ -18,6 +18,7 @@ namespace Dawn {
     public:
       BackBufferRenderTarget backBuffer;
       std::shared_ptr<SimpleTexturedShader> simpleShader;
+      std::shared_ptr<UIShader> uiShader;
 
       /**
        * Construct a new RenderManager for a game instance.
@@ -27,6 +28,8 @@ namespace Dawn {
       RenderTarget & getBackBuffer() override;
       RenderPipeline & getRenderPipeline() override;
       std::shared_ptr<Shader> getDefaultShader() override;
+      std::shared_ptr<UIShader> getUIShader() override;
+      void setRenderFlags(renderflag_t renderFlags) override;
       void init() override;
       void update() override;
       

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -9,7 +9,7 @@
 
 namespace Dawn {
   class SimpleTexturedShader : public Shader {
-    private:
+    public:
       shaderparameter_t paramProjection;
       shaderparameter_t paramView;
       shaderparameter_t paramModel;
@@ -17,7 +17,6 @@ namespace Dawn {
       shaderparameter_t paramTexture;
       shaderparameter_t paramHasTexture;
 
-    public:
       std::map<shaderparameter_t, enum ShaderParameterType>
       getParameters() override {
         std::map<shaderparameter_t, enum ShaderParameterType> ps;

src/dawnopengl/display/shader/UIShader.hpp

@@ -0,0 +1,119 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/Shader.hpp"
+#include "scene/components/Components.hpp"
+
+namespace Dawn {
+  class UIShader : public Shader {
+    public:
+      shaderparameter_t paramProjection;
+      shaderparameter_t paramView;
+      shaderparameter_t paramModel;
+      shaderparameter_t paramColor;
+      shaderparameter_t paramTexture;
+      shaderparameter_t paramHasTexture;
+
+      std::map<shaderparameter_t, enum ShaderParameterType>
+      getParameters() override {
+        std::map<shaderparameter_t, enum ShaderParameterType> ps;
+
+        ps[this->paramColor] = SHADER_PARAMETER_TYPE_COLOR;
+        ps[this->paramHasTexture] = SHADER_PARAMETER_TYPE_BOOLEAN;
+        ps[this->paramTexture] = SHADER_PARAMETER_TYPE_TEXTURE;
+
+        return ps;
+      }
+      
+      void setDefaultParameters(Material &material) override {
+        material.colorValues[this->paramColor] = COLOR_WHITE;
+      }
+
+      void setGlobalParameters(glm::mat4 proj, glm::mat4 view) override {
+        this->setMatrix(this->paramProjection, proj);
+        this->setMatrix(this->paramView, view);
+      }
+
+      void setMeshParameters(glm::mat4 transform) override {
+        this->setMatrix(this->paramModel, transform);
+      }
+
+      void bindTexture(
+        shaderparameter_t param,
+        std::shared_ptr<Texture> texture
+      ) override {
+        if(texture == nullptr) {
+          this->setBoolean(this->paramHasTexture, false);
+        } else {
+          this->setBoolean(this->paramHasTexture, true);
+          this->setTextureSlot(param, 0x00);
+          texture->bind(0x00);
+        }
+      }
+
+      void compile() override {
+        this->compileShader(
+          // Vertex Shader
+          "#version 330 core\n"
+          "layout (location = 0) in vec3 aPos;\n"
+          "layout (location = 1) in vec2 aTexCoord;\n"
+
+          "uniform mat4 u_Proj;\n"
+          "uniform mat4 u_View;\n"
+          "uniform mat4 u_Model;\n"
+
+          "out vec2 o_TextCoord;\n"
+          "void main() {\n"
+            "gl_Position = u_Proj * u_View * u_Model * vec4(aPos, 1.0);\n"
+            "o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
+          "}",
+
+          // Fragment Shader
+          "#version 330 core\n"
+          "out vec4 o_Color;\n"
+          "in vec2 o_TextCoord;\n"
+          "uniform vec4 u_Color;\n"
+          "uniform sampler2D u_Text;\n"
+          "uniform bool u_HasTexture;\n"
+
+          "void main() {\n"
+            "if(u_HasTexture) {\n"
+              "o_Color = texture(u_Text, o_TextCoord) * u_Color;\n"
+            "} else {\n"
+              "o_Color = u_Color;"
+            "}\n"
+          "}\n"
+        );
+
+        this->paramProjection = this->getParameterByName("u_Proj");
+        this->paramView = this->getParameterByName("u_View");
+        this->paramModel = this->getParameterByName("u_Model");
+        this->paramColor = this->getParameterByName("u_Color");
+        this->paramTexture = this->getParameterByName("u_Text");
+        this->paramHasTexture = this->getParameterByName("u_HasTexture");
+
+        this->setBoolean(this->paramHasTexture, false);
+      }
+
+
+      void setUICamera(glm::mat4 view, glm::mat4 projection) {
+        this->setMatrix(this->paramView, view);
+        this->setMatrix(this->paramProjection, projection);
+      }
+
+      void setUIModel(glm::mat4 model) {
+        this->setMatrix(this->paramModel, model);
+      }
+
+      void setUITexture(std::shared_ptr<Texture> texture) {
+        this->bindTexture(this->paramTexture, texture);
+      }
+
+      void setUIColor(struct Color color) {
+        this->setColor(this->paramColor, color);
+      }
+  };
+}

src/dawnpokergame/game/DawnPokerGame.cpp

@@ -7,22 +7,6 @@
 
 using namespace Dawn;
 
-std::shared_ptr<SceneItem> cubeCreate(std::shared_ptr<Scene> scene) {
-  auto cubeObject = scene->createSceneItem();
-  auto cubeMeshRenderer = cubeObject->addComponent<MeshRenderer>();
-  auto cubeMaterial = cubeObject->addComponent<Material>();
-  cubeMeshRenderer->mesh = std::make_shared<Mesh>();
-  cubeMeshRenderer->mesh->createBuffers(CUBE_VERTICE_COUNT, CUBE_INDICE_COUNT);
-  CubeMesh::buffer( 
-    *cubeMeshRenderer->mesh,
-    glm::vec3(-0.5f, -0.5f, -0.5f), glm::vec3(1, 1, 1),
-    0, 0
-  );
-  return cubeObject;
-}
-
-std::shared_ptr<SceneItem> cubeParent;
-
 DawnGame::DawnGame(DawnHost &host) :
   host(host),
   renderManager(*this)
@@ -39,12 +23,14 @@ int32_t DawnGame::init() {
   auto camera = cameraObject->addComponent<Camera>();
   camera->transform.lookAt(glm::vec3(5, 5, 5), glm::vec3(0, 0, 0));
   
-  cubeParent = cubeCreate(this->scene);
-  auto cubeChild = cubeCreate(this->scene);
-  cubeChild->getComponent<Material>()->colorValues[cubeChild->getComponent<Material>()->getShader()->getParameterByName("u_Color")] = COLOR_MAGENTA;
-  cubeChild->transform.setParent(&cubeParent->transform);
-  cubeChild->transform.setLocalPosition(glm::vec3(1, 0, 0));
-  cubeParent->transform.setLocalPosition(glm::vec3(-0.5f, 0, 0));
+  auto canvas = UICanvas::createCanvas(this->scene);
+  auto test = canvas->addElement<UISprite>();
+  test->setTransform(
+    UI_COMPONENT_ALIGN_START,
+    UI_COMPONENT_ALIGN_START,
+    glm::vec4(0, 0, 32, 32),
+    0
+  );
 
   return DAWN_GAME_INIT_RESULT_SUCCESS;
 }
@@ -54,8 +40,6 @@ int32_t DawnGame::update(float_t delta) {
 
   if(this->scene != nullptr) this->scene->update();
   
-  cubeParent->transform.setLocalPosition(cubeParent->transform.getLocalPosition() + glm::vec3(-delta, 0, 0));
-
   this->renderManager.update();
 
   return DAWN_GAME_UPDATE_RESULT_SUCCESS;

src/dawnpokergame/game/DawnPokerGame.hpp

@@ -6,7 +6,4 @@
 #pragma once
 #include "game/DawnGame.hpp"
 #include "scene/components/Components.hpp"
-#include "display/mesh/QuadMesh.hpp"
-#include "display/mesh/TriangleMesh.hpp"
-#include "display/mesh/CubeMesh.hpp"
-#include "asset/assets/TextureAsset.hpp"
+#include "ui/UISprite.hpp"