Example of Rendering UI done.

src/dawn/component/ui/UICanvas.cpp

@@ -12,52 +12,66 @@
 using namespace Dawn;
 
 void UICanvas::onInit() {
+  mesh = std::make_shared<Mesh>();
+  mesh->createBuffers(
+    QUAD_VERTICE_COUNT * UI_SHADER_QUAD_COUNT,
+    QUAD_INDICE_COUNT * UI_SHADER_QUAD_COUNT
+  );
 
+  for(int32_t i = 0; i < UI_SHADER_QUAD_COUNT; i++) {
+    QuadMesh::bufferWithIndex(
+      mesh,
+      glm::vec4(0, 0, 1, 1),
+      glm::vec4(0, 0, 1, 1),
+      i * QUAD_VERTICE_COUNT,
+      i * QUAD_INDICE_COUNT,
+      i * QUAD_VERTICE_COUNT
+    );
+  }
 }
 
 void UICanvas::onDispose() {
-
+  mesh = nullptr;
 }
 
 std::vector<std::shared_ptr<IRenderPass>> UICanvas::getPasses(
   struct RenderPassContext &ctx
 ) {
   std::vector<std::shared_ptr<IRenderPass>> passes;
-
+  std::unordered_map<shadertexturebinding_t, std::shared_ptr<Texture>> textures;
-  auto selfTransform = this->getItem()->getWorldTransform();
-
-  auto mesh = std::make_shared<Mesh>();
-  mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
-  QuadMesh::buffer(mesh, glm::vec4(0, 0, 32, 32), glm::vec4(0, 0, 1, 1), 0, 0);
   UIShaderData data = {
     .projection = ctx.camera->getProjection(),
     .view = ctx.camera->getItem()->getWorldTransform(),
-    .model = selfTransform
+    .model = this->getItem()->getWorldTransform()
   };
   
-  data.test.first = COLOR_RED;
+  size_t quadCount = 0;
-  data.test.random = glm::vec3(0, 1, 0);
-  data.test.second = COLOR_BLUE;
-
-  auto pass = createRenderPass<UIShader, UIShaderData>(
-    std::ref(*this),
-    data,
-    std::unordered_map<shadertexturebinding_t, std::shared_ptr<Texture>>(),
-    mesh,
-    MeshDrawMode::TRIANGLES,
-    0, -1
-  );
-  passes.push_back(pass);
-
   auto itComponents = components.begin();
   while(itComponents != components.end()) {
     auto component = *itComponents;
 
     // Get this components' quads.
-    auto quads = component->getQuads(selfTransform);
+    auto quads = component->getQuads(glm::mat4(1.0));
-    
+    for(auto quad : quads) {
+      data.quads[quadCount++] = quad;
+      assertTrue(quadCount <= UI_SHADER_QUAD_COUNT, "Too many UI quads!");
+    }
     ++itComponents;
   }
 
+  // No render passes if no quads.
+  if(quadCount == 0) return passes;
+
+  auto pass = createRenderPass<UIShader, UIShaderData>(
+    std::ref(*this),
+    data,
+    textures,
+    mesh,
+    MeshDrawMode::TRIANGLES,
+    0, quadCount * QUAD_INDICE_COUNT
+  );
+  passes.push_back(pass);
+
+
   return passes;
 }

src/dawn/component/ui/UICanvas.hpp

@@ -14,6 +14,8 @@ namespace Dawn {
     public IRenderableComponent
   {
     protected:
+      std::shared_ptr<Mesh> mesh;
+
       virtual void onInit() override;
       virtual void onDispose() override;
 

src/dawn/display/mesh/QuadMesh.cpp

@@ -12,13 +12,46 @@ void QuadMesh::buffer(
   const glm::vec4 positions,
   const glm::vec4 coordinates,
   const int32_t verticeStart,
-  const int32_t indiceStart
+  const int32_t indiceStart,
+  const float_t depth
 ) {
   glm::vec3 vertices[QUAD_VERTICE_COUNT] = {
-    glm::vec3(positions.x, positions.y, 0),
+    glm::vec3(positions.x, positions.y, depth),
-    glm::vec3(positions.z, positions.y, 0),
+    glm::vec3(positions.z, positions.y, depth),
-    glm::vec3(positions.x, positions.w, 0),
+    glm::vec3(positions.x, positions.w, depth),
-    glm::vec3(positions.z, positions.w, 0)
+    glm::vec3(positions.z, positions.w, depth)
+  };
+
+  glm::vec2 coords[QUAD_VERTICE_COUNT] = {
+    glm::vec2(coordinates.x, coordinates.y),
+    glm::vec2(coordinates.z, coordinates.y),
+    glm::vec2(coordinates.x, coordinates.w),
+    glm::vec2(coordinates.z, coordinates.w)
+  };
+
+  int32_t indices[QUAD_INDICE_COUNT] = {
+    verticeStart, verticeStart + 1, verticeStart + 3,
+    verticeStart, verticeStart + 2, verticeStart + 3
+  };
+
+  mesh->bufferPositions(verticeStart, vertices, QUAD_VERTICE_COUNT);
+  mesh->bufferCoordinates(verticeStart, coords, QUAD_VERTICE_COUNT);
+  mesh->bufferIndices(indiceStart, indices, QUAD_INDICE_COUNT);
+}
+
+void QuadMesh::bufferWithIndex(
+  const std::shared_ptr<Mesh> mesh,
+  const glm::vec4 positions,
+  const glm::vec4 coordinates,
+  const int32_t verticeStart,
+  const int32_t indiceStart,
+  const int32_t indexOffset
+) {
+  glm::vec3 vertices[QUAD_VERTICE_COUNT] = {
+    glm::vec3(positions.x, positions.y, indexOffset),
+    glm::vec3(positions.z, positions.y, indexOffset + 1),
+    glm::vec3(positions.x, positions.w, indexOffset + 2),
+    glm::vec3(positions.z, positions.w, indexOffset + 3)
   };
 
   glm::vec2 coords[QUAD_VERTICE_COUNT] = {

src/dawn/display/mesh/QuadMesh.hpp

@@ -20,13 +20,36 @@ namespace Dawn {
        * @param coordinates The coordinates of the vertices.
        * @param verticeStart The starting index of the vertices.
        * @param indiceStart The starting index of the indices.
+       * @param depth The depth of the vertices (Z coordinate).
        */
       static void buffer(
         const std::shared_ptr<Mesh> mesh,
         const glm::vec4 positions,
         const glm::vec4 coordinates,
         const int32_t verticeStart,
-        const int32_t indiceStart
+        const int32_t indiceStart,
+        const float_t depth = 0.0f
+      );
+
+      /**
+       * Buffers quad mesh vertices and indices into the given mesh. This will
+       * store the index of the vertice in the Z component, allowing you to find
+       * which vertex ID you are rendering in your shader.
+       * 
+       * @param mesh The mesh to buffer into.
+       * @param positions The positions of the vertices.
+       * @param coordinates The coordinates of the vertices.
+       * @param verticeStart The starting index of the vertices.
+       * @param indiceStart The starting index of the indices.
+       * @param indexOffset The offset to add to the index of each vertex.
+       */
+      static void bufferWithIndex(
+        const std::shared_ptr<Mesh> mesh,
+        const glm::vec4 positions,
+        const glm::vec4 coordinates,
+        const int32_t verticeStart,
+        const int32_t indiceStart,
+        const int32_t indexOffset = 0
       );
   };
 }

src/dawn/ui/UIComponent.cpp

@@ -11,20 +11,20 @@ std::vector<std::shared_ptr<UIComponent>> UIComponent::getChildren() {
   return {};
 }
 
-std::vector<struct UIQuad> UIComponent::getQuads(
+std::vector<struct UIShaderQuad> UIComponent::getQuads(
   const glm::mat4 parent
 ) {
   // Get self transform
   glm::mat4 transform = glm::translate(
-    glm::mat4(1.0f), glm::vec3(position, 0.0f)
+    glm::mat4(1.0f),
+    glm::vec3(position, 0.0f)
   );
 
   // Add parent transform
   transform = parent * transform;
 
   // Get self quads and insert new transform.
-  std::vector<struct UIQuad> quads;
+  std::vector<struct UIShaderQuad> quads = this->getSelfQuads(transform);
-  auto selfQuads = this->getSelfQuads(transform);
 
   // Get children
   auto children = getChildren();

src/dawn/ui/UIComponent.hpp

@@ -5,20 +5,20 @@
 
 #pragma once
 #include "ui/UIAlign.hpp"
-#include "ui/UIQuad.hpp"
+#include "display/shader/UIShader.hpp"
 
 namespace Dawn {
   class UICanvas;
 
   class UIComponent {
     protected:
-      virtual std::vector<struct UIQuad> getSelfQuads(
+      virtual std::vector<struct UIShaderQuad> getSelfQuads(
         const glm::mat4 transform
       ) = 0;
 
       virtual std::vector<std::shared_ptr<UIComponent>> getChildren();
 
-      std::vector<struct UIQuad> getQuads(
+      std::vector<struct UIShaderQuad> getQuads(
         const glm::mat4 parent
       );
 

src/dawn/ui/UIQuad.hpp

@@ -1,34 +0,0 @@
-// 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/Texture.hpp"
-
-namespace Dawn {
-  struct UIQuad {
-    glm::mat4 transform;
-    glm::vec4 quad;
-    glm::vec4 uv;
-    struct Color color;
-    std::shared_ptr<Texture> texture;
-
-    UIQuad(
-      const glm::mat4 transform,
-      const glm::vec4 quad,
-      const glm::vec4 uv,
-      const struct Color color,
-      const std::shared_ptr<Texture> texture
-    ) :
-      transform(transform),
-      quad(quad),
-      uv(uv),
-      color(color),
-      texture(texture)
-    {
-
-    }
-  };
-}

src/dawn/ui/UIRectangle.cpp

@@ -7,18 +7,15 @@
 
 using namespace Dawn;
 
-std::vector<struct UIQuad> UIRectangle::getSelfQuads(
+std::vector<struct UIShaderQuad> UIRectangle::getSelfQuads(
   const glm::mat4 transform
 ) {
-  std::vector<struct UIQuad> quads;
+  std::vector<struct UIShaderQuad> quads;
-  
+  quads.push_back({
-  quads.push_back(UIQuad(
     transform,
     glm::vec4(0, 0, size.x, size.y),
     uv,
-    color,
+    color
-    texture
+  });
-  ));
-
   return quads;
 }

src/dawn/ui/UIRectangle.hpp

@@ -9,7 +9,7 @@
 namespace Dawn {
   class UIRectangle final : public UIComponent {
     protected:
-      std::vector<struct UIQuad> getSelfQuads(
+      std::vector<struct UIShaderQuad> getSelfQuads(
         const glm::mat4 transform
       ) override;
 

src/dawn/util/Macro.hpp

@@ -0,0 +1,11 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+
+#define MACRO_STRINGIFY_RAW(x) #x
+#define MACRO_STRINGIFY(x) MACRO_STRINGIFY_RAW(x)
+
+#define MACRO_JOIN(x, y) x ## y

src/dawnhelloworld/scene/HelloWorldScene.cpp

@@ -53,5 +53,11 @@ void Dawn::helloWorldScene(Scene &s) {
   auto uiCanvas = uiCanvasItem->addComponent<UICanvas>();
 
   auto rect = std::make_shared<UIRectangle>();
+  rect->position = { -32, -32 };
   uiCanvas->components.push_back(rect);
+
+  auto rect2 = std::make_shared<UIRectangle>();
+  rect2->color = COLOR_MAGENTA;
+  rect2->position = { 10, 10 };
+  uiCanvas->components.push_back(rect2);
 }

src/dawnopengl/display/shader/Shader.hpp

@@ -208,7 +208,7 @@ namespace Dawn {
               assertNoGLError();
               glBufferData(
                 GL_UNIFORM_BUFFER,
-                structure.size,
+                structure.size * structure.count,
                 (void*)((size_t)&this->data + (size_t)structure.offset),
                 GL_STATIC_DRAW
               );

src/dawnopengl/display/shader/ShaderStructure.hpp

@@ -16,7 +16,7 @@ namespace Dawn {
     size_t offset;
     enum ShaderOpenGLStructureType structureType;
     size_t size;
-    // size_t count;
+    size_t count;
     std::vector<struct ShaderParameter> parameters;
     GLint location = -1;
     GLuint buffer = -1;
@@ -46,12 +46,14 @@ namespace Dawn {
         const enum ShaderOpenGLStructureType structureType,
         std::function<
           void(const T&, std::vector<struct ShaderParameter>&)
-        > getParameters
+        > getParameters,
+        size_t count = 1
       ) {
         this->structureName = structureName;
         this->offset = (size_t)offset;
         this->structureType = structureType;
         this->size = sizeof(T);
+        this->count = count;
         this->parameters = std::vector<struct ShaderParameter>();
 
         T dummy;

src/dawnopengl/display/shader/UIShader.cpp

@@ -4,6 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "display/shader/UIShader.hpp"
+#include "util/Macro.hpp"
 
 using namespace Dawn;
 
@@ -28,10 +29,50 @@ void UIShader::getStages(
         "uniform mat4 u_Projection;\n"
         "uniform mat4 u_View;\n"
         "uniform mat4 u_Model;\n"
+        "struct UIShaderQuad {\n"
+          "mat4 transform;\n"
+          "vec4 quad;\n"
+          "vec4 uv;\n"
+          "vec4 color;\n"
+        "};\n"
+        "layout (std140) uniform ub_Quad {\n"
+          "UIShaderQuad quads[" MACRO_STRINGIFY(UI_SHADER_QUAD_COUNT) "];\n"
+        "};\n"
         "out vec2 o_TextCoord;\n"
+        "out vec4 v_Color;\n"
         "void main() {\n"
-          "gl_Position = u_Projection * u_View * u_Model * vec4(aPos, 1.0);\n"
+          "vec4 pos;\n"
-          "o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
+          "vec2 coord;\n"
+          "int index = int(aPos.z);\n"
+          "int quadIndex = index / 4;\n"
+          "int vertexIndex = index % 4;\n"
+          "struct UIShaderQuad quad = quads[quadIndex];\n"
+          "if(vertexIndex == 0) {\n"
+            "pos.x = quad.quad.x;\n"
+            "pos.y = quad.quad.y;\n"
+            "coord.x = quad.uv.x;\n"
+            "coord.y = quad.uv.y;\n"
+          "} else if(vertexIndex == 1) {\n"
+            "pos.x = quad.quad.z;\n"
+            "pos.y = quad.quad.y;\n"
+            "coord.x = quad.uv.z;\n"
+            "coord.y = quad.uv.y;\n"
+          "} else if(vertexIndex == 2) {\n"
+            "pos.y = quad.quad.w;\n"
+            "pos.x = quad.quad.x;\n"
+            "coord.x = quad.uv.x;\n"
+            "coord.y = quad.uv.w;\n"
+          "} else if(vertexIndex == 3) {\n"
+            "pos.x = quad.quad.z;\n"
+            "pos.y = quad.quad.w;\n"
+            "coord.x = quad.uv.z;\n"
+            "coord.y = quad.uv.w;\n"
+          "}\n"
+          "pos.z = 0;\n"
+          "pos.w = 1;\n"
+          "gl_Position = u_Projection * u_View * u_Model * quad.transform * pos;\n"
+          "o_TextCoord = coord;\n"
+          "v_Color = quad.color;\n"
         "}"
       );
       
@@ -39,14 +80,10 @@ void UIShader::getStages(
         ShaderStageType::FRAGMENT,
         "#version 330 core\n"
         "in vec2 o_TextCoord;\n"
-        "layout (std140) uniform ub_Color {\n"
+        "in vec4 v_Color;\n"
-          "vec4 first;\n"
-          "vec3 random;\n"
-          "vec4 second;\n"
-        "};\n"
         "out vec4 o_Color;\n"
         "void main() {\n"
-          "o_Color = second;\n"
+          "o_Color = v_Color;\n"
         "}\n"
       );
       break;
@@ -78,28 +115,35 @@ void UIShader::getStages(
     ShaderParameterType::MAT4
   ));
   
-  structures.push_back(ShaderStructure<struct TestStruct>(
+  structures.push_back(ShaderStructure<struct UIShaderQuad>(
-    "ub_Color",
+    "ub_Quad",
-    &rel->test,
+    &rel->quads,
     ShaderOpenGLStructureType::STD140,
-    [&](const struct TestStruct &rel, std::vector<struct ShaderParameter> &parameters) {
+    [&](const struct UIShaderQuad &rel, std::vector<struct ShaderParameter> &parameters) {
       parameters.push_back(ShaderParameter(
-        "first",
+        "u_Transform",
-        &rel.first,
+        &rel.transform,
-        ShaderParameterType::COLOR
+        ShaderParameterType::MAT4
       ));
 
       parameters.push_back(ShaderParameter(
-        "random",
+        "u_Quad",
-        &rel.random,
+        &rel.quad,
-        ShaderParameterType::VEC3
+        ShaderParameterType::VEC4
       ));
 
       parameters.push_back(ShaderParameter(
-        "second",
+        "u_UV",
-        &rel.second,
+        &rel.uv,
+        ShaderParameterType::VEC4
+      ));
+
+      parameters.push_back(ShaderParameter(
+        "u_Color",
+        &rel.color,
         ShaderParameterType::COLOR
       ));
-    }
+    },
+    2
   ));
 }

src/dawnopengl/display/shader/UIShader.hpp

@@ -7,18 +7,20 @@
 #include "display/shader/Shader.hpp"
 
 namespace Dawn {
-  struct TestStruct {
+  #define UI_SHADER_QUAD_COUNT 32
-    struct Color first;
+
-    glm::vec3 random;
+  struct UIShaderQuad {
-    float_t padded;
+    glm::mat4 transform;
-    struct Color second;
+    glm::vec4 quad;
+    glm::vec4 uv;
+    struct Color color;
   };
   
   struct UIShaderData {
     glm::mat4 projection;
     glm::mat4 view;
     glm::mat4 model;
-    struct TestStruct test;
+    struct UIShaderQuad quads[UI_SHADER_QUAD_COUNT];
   };
 
   class UIShader : public Shader<UIShaderData> {