Testing textures and events

src/dawn/display/CMakeLists.txt

@@ -7,4 +7,7 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     RenderPipeline.cpp
-)
+)
+
+# Subdirs
+add_subdirectory(mesh)

src/dawn/display/RenderTarget.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include "util/flag.hpp"
 #include "display/Color.hpp"
+#include "event/Event.hpp"
 
 #define RENDER_TARGET_CLEAR_FLAG_COLOR FLAG_DEFINE(0)
 #define RENDER_TARGET_CLEAR_FLAG_DEPTH FLAG_DEFINE(1)
@@ -13,6 +14,8 @@
 namespace Dawn {
   class RenderTarget {
     public:
+      Event<RenderTarget &, float_t, float_t> eventRenderTargetResized;
+
       /**
        * Return the width of the render target.
        * 

src/dawn/display/_Texture.hpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/Color.hpp"
+
+namespace Dawn {
+  class ITexture {
+    public:
+      virtual int32_t getWidth() = 0;
+      virtual int32_t getHeight() = 0;
+      virtual void setSize(int32_t width, int32_t height) = 0;
+      virtual void fill(struct Color) = 0;
+      virtual bool_t isReady() = 0;
+      virtual void buffer(struct Color pixels[]) = 0;
+  };
+}

src/dawn/display/mesh/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
+    TriangleMesh.cpp
+    QuadMesh.cpp
+)

src/dawn/display/mesh/QuadMesh.cpp

@@ -0,0 +1,38 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "QuadMesh.hpp"
+
+using namespace Dawn;
+
+void QuadMesh::bufferQuadMeshWithZ(
+  Mesh &mesh,
+  glm::vec2 xy0, glm::vec2 uv0,
+  glm::vec2 xy1, glm::vec2 uv1,
+  float_t z, int32_t verticeStart, int32_t indiceStart
+) {
+  mesh.bufferPositions(
+    verticeStart, std::array<glm::vec3, QUAD_VERTICE_COUNT>{{
+      glm::vec3(xy0, z),
+      glm::vec3(xy1.x, xy0.y, z),
+      glm::vec3(xy0.x, xy1.y, z),
+      glm::vec3(xy1, z)
+    }}
+  );
+
+  mesh.bufferCoordinates(
+    verticeStart, std::array<glm::vec2, QUAD_VERTICE_COUNT>{{
+      uv0, glm::vec2(uv1.x, uv0.y),
+      glm::vec2(uv0.x, uv1.y), uv1
+    }}
+  );
+
+  mesh.bufferIndices(
+    indiceStart, std::array<meshindice_t, QUAD_INDICE_COUNT>{{
+      verticeStart, verticeStart + 1, verticeStart + 2,
+      verticeStart + 1, verticeStart + 2, verticeStart + 3
+    }}
+  );
+}

src/dawn/display/mesh/QuadMesh.hpp

@@ -0,0 +1,53 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/mesh/Mesh.hpp"
+
+#define QUAD_VERTICE_COUNT 4
+#define QUAD_INDICE_COUNT 6
+#define QUAD_INDICE_PER_QUAD 2
+
+namespace Dawn {
+  class QuadMesh {
+    public:
+      /**
+       * Buffers the vertices of a quad onto a primitive.
+       * 
+       * @param primitive The primitive to buffer to.
+       * @param xy0 The lower X and Y coordinate.
+       * @param uv0 The lower Xand Y texture coordinate.
+       * @param xy1 The higher X and Y coordinate.
+       * @param uv1 The higher X and Y texture coordinate.
+       * @param z The Z position of the coordinates.
+       * @param verticeStart Start vertice to buffer to.
+       * @param indiceStart Start indice to buffer to.
+       */
+      static void bufferQuadMeshWithZ(
+        Mesh &mesh,
+        glm::vec2 xy0, glm::vec2 uv0,
+        glm::vec2 xy1, glm::vec2 uv1,
+        float_t z, int32_t verticeStart, int32_t indiceStart
+      );
+
+      /**
+       * Buffers the vertices of a quad onto a primitive.
+       * 
+       * @param primitive The primitive to buffer to.
+       * @param xy0 The lower X and Y coordinate.
+       * @param uv0 The lower Xand Y texture coordinate.
+       * @param xy1 The higher X and Y coordinate.
+       * @param uv1 The higher X and Y texture coordinate.
+       * @param verticeStart Start vertice to buffer to.
+       * @param indiceStart Start indice to buffer to.
+       */
+      static void bufferQuadMesh(
+        Mesh &mesh,
+        glm::vec2 xy0, glm::vec2 uv0,
+        glm::vec2 xy1, glm::vec2 uv1,
+        int32_t verticeStart, int32_t indiceStart
+      );
+  };
+}

src/dawn/display/mesh/TriangleMesh.cpp

@@ -3,7 +3,6 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "display/mesh/Mesh.hpp"
 #include "display/mesh/TriangleMesh.hpp"
 
 using namespace Dawn;
@@ -11,9 +10,9 @@ using namespace Dawn;
 void TriangleMesh::createTriangleMesh(Mesh &mesh) {
   mesh.createBuffers(3, 3);
   mesh.bufferPositions(0, std::array<glm::vec3, 3>{{
-    glm::vec3(-1, 0, 0),
+    glm::vec3(-0.5f, -0.5f, 0),
-    glm::vec3(0, 1, 0),
+    glm::vec3(0.5f, -0.5f, 0),
-    glm::vec3(1, 0, 0)
+    glm::vec3(0, 0.5f, 0)
   }});
   mesh.bufferCoordinates(0, std::array<glm::vec2, 3>{{
     glm::vec2(0, 0),

src/dawn/display/shader/_Shader.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "display/Texture.hpp"
 
 namespace Dawn {
   class Material;
@@ -13,7 +13,8 @@ namespace Dawn {
     SHADER_PARAMETER_TYPE_MATRIX,
     SHADER_PARAMETER_TYPE_BOOLEAN,
     SHADER_PARAMETER_TYPE_COLOR,
-    SHADER_PARAMETER_TYPE_VECTOR3
+    SHADER_PARAMETER_TYPE_VECTOR3,
+    SHADER_PARAMETER_TYPE_TEXTURE
   };
 
   template<typename T>
@@ -93,5 +94,13 @@ namespace Dawn {
        * @param vector Vector to set.
        */
       virtual void setVector3(T parameter, glm::vec3 vector) = 0;
+
+      /**
+       * Attaches a texture to the currently bound shader.
+       * 
+       * @param parameter parameter to set the texture on to.
+       * @param texture Texture to bind to the parameter.
+       */
+      virtual void setTexture(T parameter, std::shared_ptr<Texture> texture)=0;
   };
 }

src/dawn/host/DawnHost.hpp

@@ -34,6 +34,7 @@ namespace Dawn {
   {
     public:
       std::unique_ptr<DawnHostData> data;
+      DawnGame *game;
 
       /**
        * Construct a new DawnHost. Hosts are set by the various dawn platform

src/dawn/scene/components/display/Camera.cpp

@@ -12,7 +12,9 @@ using namespace Dawn;
 Camera::Camera(SceneItem &item) :
   SceneItemComponent(item)
 {
-  this->updateProjection();
+  this->getRenderTarget().eventRenderTargetResized.addListener(
+    this, &Camera::onRenderTargetResize
+  );
 }
 
 void Camera::updateProjection() {
@@ -54,6 +56,18 @@ RenderTarget & Camera::getRenderTarget() {
   return *this->target;
 }
 
+void Camera::setRenderTarget(std::shared_ptr<RenderTarget> renderTarget) {
+  if(renderTarget == this->target) return;
+  this->getRenderTarget().eventRenderTargetResized.removeListener(
+    this, &Camera::onRenderTargetResize
+  );
+  this->target = renderTarget;
+  this->getRenderTarget().eventRenderTargetResized.addListener(
+    this, &Camera::onRenderTargetResize
+  );
+  this->updateProjection();
+}
+
 float_t Camera::getAspect() {
   RenderTarget &target = this->getRenderTarget();
   return target.getWidth() / target.getHeight();
@@ -61,4 +75,14 @@ float_t Camera::getAspect() {
 
 void Camera::start() {
   this->updateProjection();
+}
+
+void Camera::onRenderTargetResize(RenderTarget &target, float_t w, float_t h) {
+  this->updateProjection();
+}
+
+Camera::~Camera() {
+  this->getRenderTarget().eventRenderTargetResized.removeListener(
+    this, &Camera::onRenderTargetResize
+  );
 }

src/dawn/scene/components/display/Camera.hpp

@@ -14,9 +14,13 @@ namespace Dawn {
   };
 
   class Camera : public SceneItemComponent {
+    protected:
+      std::shared_ptr<RenderTarget> target = nullptr;
+
+      void onRenderTargetResize(RenderTarget &target, float_t w, float_t h);
+
     public:
       glm::mat4 projection;
-      std::shared_ptr<RenderTarget> target = nullptr;
 
       // Perspective
       enum CameraType type = CAMERA_TYPE_PERSPECTIVE;
@@ -55,6 +59,13 @@ namespace Dawn {
        */
       RenderTarget & getRenderTarget();
 
+      /**
+       * Updates the render target for the camera to use.
+       * 
+       * @param renderTarget Render target for this camera to draw to.
+       */
+      void setRenderTarget(std::shared_ptr<RenderTarget> renderTarget);
+
       /**
        * Returs the aspect ratio of the camera.
        * 
@@ -66,5 +77,10 @@ namespace Dawn {
        * Event triggered by the scene item when the item is added to the scene.
        */
       void start() override;
+
+      /**
+       * Disposes a previously initialized camera.
+       */
+      ~Camera();
   };
 }

src/dawn/scene/components/display/Material.cpp

@@ -46,6 +46,10 @@ void Material::setShaderParameters() {
       case SHADER_PARAMETER_TYPE_VECTOR3:
         this->shader->setVector3(it->first, this->vec3Values[it->first]);
         break;
+      
+      case SHADER_PARAMETER_TYPE_TEXTURE:
+        this->shader->setTexture(it->first, this->textureValues[it->first]);
+        break;
 
       default:
         throw "An unsupported or invalid shader parameter type was supplied.";

src/dawn/scene/components/display/Material.hpp

@@ -26,6 +26,7 @@ namespace Dawn {
       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, std::shared_ptr<Texture>> textureValues;
 
       /**
        * Material component constructor. 

src/dawn/util/memory.hpp

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2022 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawnlibs.hpp"
+
+/**
+ * Allocate some space in memory to use for your needs. Memory allocation may
+ * change how it functions later on to keep things nice and efficient. For now
+ * this is just an API forward for malloc.
+ * 
+ * @param size Size of the array you wish to buffer.
+ * @return Pointer to the space in memory to use.
+ */
+static inline void * memoryAllocate(const size_t size) {
+  return (void *)malloc(size);
+}
+
+/**
+ * Free some previously allocated memory space.
+ * @param pointer Pointer in memory to free.
+ */
+static inline void memoryFree(void *pointer) {
+  free(pointer);
+}
+
+/**
+ * Copies data from one buffer to another. Typically used for array operations.
+ * 
+ * @param source Source pointer.
+ * @param destination Destination buffer.
+ * @param size Size in bytes of data to copy.
+ */
+static inline void memoryCopy(
+  void *source,
+  void *destination,
+  size_t size
+) {
+  memcpy(destination, source, size);
+}
+
+/**
+ * Compares the data within two memory banks. Shorthand for memcpy.
+ * 
+ * @param left Left item to compare.
+ * @param right Right item to compare.
+ * @param size Count of bytes to compare.
+ * @return 0 for equal, <0 for left being greater, >0 for right being greater.
+ */
+static inline int32_t memoryCompare(
+  const void *left,
+  const void *right,
+  const size_t size
+) {
+  return memcmp(left, right, size);
+}
+
+/**
+ * Fill destination with a repeating set of bytes.
+ * 
+ * @param dest Destination pointer in memory.
+ * @param data Data byte to write.
+ * @param length How many times to write that byte.
+ */
+static inline void memorySet(
+  void *dest,
+  uint8_t data,
+  size_t length
+) {
+  memset(dest, data, length);
+}
+
+/**
+ * Reallocate a part of memory. Reallocation simply creates a new buffer that
+ * will take all of the existing contents and then free's the original buffer.
+ * 
+ * @param pointer Pointer to pointer in memory that you wish to re-allocate.
+ * @param currentSize Current size of the buffer that the pointer points to.
+ * @param newSize The new size of the buffer.
+ * @return The new size param you provided.
+ */
+static inline size_t memoryReallocate(
+  void **pointer,
+  size_t currentSize,
+  size_t newSize
+) {
+  // Create the new buffer
+  void *newBuffer = memoryAllocate(newSize);
+  memoryCopy(*pointer, newBuffer, currentSize);
+  memoryFree(*pointer);
+  *pointer = newBuffer;
+  return newSize;
+}

src/dawnglfw/host/DawnGLFWHost.cpp

@@ -12,12 +12,8 @@
 
 using namespace Dawn;
 
-GLFWwindow *window;
+// Static declaration of the host, needed due to GLFW events being C-like
-
+DawnHost *DAWN_HOST = nullptr;
-// GLFW Callbacks
-void glfwOnError(int error, const char* description) {
-  fputs(description, stderr);
-}
 
 // Host
 DawnHost::DawnHost() {
@@ -26,6 +22,10 @@ DawnHost::DawnHost() {
 }
 
 int32_t DawnHost::init(DawnGame &game) {
+  // Update values
+  this->game = &game;
+  DAWN_HOST = this;
+
   // Init GLFW
   if(!glfwInit()) return DAWN_GLFW_INIT_RESULT_INIT_FAILED;
 
@@ -35,18 +35,18 @@ int32_t DawnHost::init(DawnGame &game) {
   glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
   
   // Create Window
-  window = glfwCreateWindow(
+  this->data->window = glfwCreateWindow(
     DAWN_GLFW_WINDOW_WIDTH_DEFAULT,
     DAWN_GLFW_WINDOW_HEIGHT_DEFAULT,
     "Dawn", NULL, NULL
   );
-  if(window == nullptr) {
+  if(this->data->window == nullptr) {
     glfwTerminate();
     return DAWN_GLFW_INIT_RESULT_WINDOW_CREATE_FAILED;
   }
 
   // Load GLAD
-  glfwMakeContextCurrent(window);
+  glfwMakeContextCurrent(this->data->window);
   glfwSwapInterval(0);
   gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
 
@@ -59,6 +59,9 @@ int32_t DawnHost::init(DawnGame &game) {
     DAWN_GLFW_WINDOW_HEIGHT_DEFAULT
   );
 
+  // Set up event listeners
+  glfwSetWindowSizeCallback(this->data->window, &glfwOnResize);
+
   return DAWN_HOST_INIT_RESULT_SUCCESS;
 }
 
@@ -69,7 +72,7 @@ int32_t DawnHost::start(DawnGame &game) {
 
   // Main Render Loop 
   time = 0.0f;
-  while(!glfwWindowShouldClose(window)) {
+  while(!glfwWindowShouldClose(this->data->window)) {
     // Determine the delta.
     newTime = glfwGetTime();
     fDelta = (float_t)(newTime - time);
@@ -86,7 +89,7 @@ int32_t DawnHost::start(DawnGame &game) {
     }
     
     // Tick the engine.
-    glfwSwapBuffers(window);
+    glfwSwapBuffers(this->data->window);
     
     // Update events
     glfwPollEvents();
@@ -116,5 +119,24 @@ void DawnHost::unload(DawnGame &game) {
 }
 
 DawnHost::~DawnHost() {
+  DAWN_HOST = nullptr;
+}
 
+
+// GLFW Callbacks
+void glfwOnError(int error, const char* description) {
+  fputs(description, stderr);
+}
+
+void glfwOnResize(
+  GLFWwindow *window,
+  int32_t width,
+  int32_t height
+) {
+  if(DAWN_HOST == nullptr) return;
+  // TODO: I may throttle this, it calls for every frame the window's resized.
+  DAWN_HOST->game->renderManager.backBuffer.setSize(
+    (float_t)width,
+    (float_t)height
+  );
 }

src/dawnglfw/host/DawnGLFWHost.hpp

@@ -22,4 +22,8 @@ namespace Dawn {
     public:
       GLFWwindow *window;
   };
-}
+}
+
+// GLFW Callbacks
+void glfwOnError(int error, const char* description);
+void glfwOnResize(GLFWwindow *window, int32_t width, int32_t height);

src/dawnopengl/display/BackBufferRenderTarget.cpp

@@ -21,8 +21,11 @@ float_t BackBufferRenderTarget::getHeight() {
 }
 
 void BackBufferRenderTarget::setSize(float_t width, float_t height) {
+  if(this->width == width && this->height == height) return;
+
   this->width = width;
   this->height = height;
+  this->eventRenderTargetResized.invoke(*this, width, height);
 }
 
 void BackBufferRenderTarget::setClearColor(struct Color color) {

src/dawnopengl/display/CMakeLists.txt

@@ -9,6 +9,7 @@ target_sources(${DAWN_TARGET_NAME}
     RenderManager.cpp
     BackBufferRenderTarget.cpp
     StandardRenderPipeline.cpp
+    Texture.cpp
 )
 
 # Subdirs

src/dawnopengl/display/Texture.cpp

@@ -0,0 +1,76 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Texture.hpp"
+
+using namespace Dawn;
+
+void Texture::bind(textureslot_t slot) {
+  if(this->id == -1) throw "Texture has not been initialized, cannot bind.";
+  glActiveTexture(GL_TEXTURE0 + slot);
+  glBindTexture(GL_TEXTURE_2D, this->id);
+}
+
+int32_t Texture::getWidth() {
+  return this->width;
+}
+
+int32_t Texture::getHeight() {
+  return this->height;
+}
+
+void Texture::setSize(int32_t width, int32_t height) {
+  if(this->id != -1) glDeleteTextures(1, &this->id);
+
+  this->width = width;
+  this->height = height;
+
+  glGenTextures(1, &this->id);
+  if(this->id <= 0) throw "Texture generation failed!";
+  
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, this->id);
+
+  // Setup our preferred texture params, later this will be configurable.
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+  // Initialize the texture to blank
+  glTexImage2D(
+    GL_TEXTURE_2D, 0, GL_RGBA,
+    width, height,
+    0, GL_RGBA, GL_FLOAT, NULL
+  );
+}
+
+void Texture::fill(struct Color color) {
+  struct Color *pixels = (struct Color *)memoryAllocate(
+    sizeof(struct Color) * this->width * this->height
+  );
+
+  this->buffer(pixels);
+
+  memoryFree(pixels);
+}
+
+bool_t Texture::isReady() {
+  return this->id != -1;
+}
+      
+void Texture::buffer(struct Color pixels[]) {
+  glBindTexture(GL_TEXTURE_2D, this->id);
+
+  glTexImage2D(
+    GL_TEXTURE_2D, 0, GL_RGBA,
+    this->width, this->height,
+    0, GL_RGBA, GL_FLOAT, (void *)pixels
+  );
+}
+
+Texture::~Texture() {
+  if(this->id != -1) glDeleteTextures(1, &this->id);
+}

src/dawnopengl/display/Texture.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopengl.hpp"
+#include "display/_Texture.hpp"
+#include "util/memory.hpp"
+
+namespace Dawn {
+  typedef GLuint textureslot_t;
+
+  class Texture : public ITexture {
+    private:
+      int32_t width = -1;
+      int32_t height = -1;
+      GLuint id = -1;
+
+    public:
+      void bind(textureslot_t slot);
+
+      int32_t getWidth() override;
+      int32_t getHeight() override;
+      void setSize(int32_t width, int32_t height) override;
+      void fill(struct Color) override;
+      bool_t isReady() override;
+      void buffer(struct Color pixels[]) override;
+
+      ~Texture();
+  };
+}

src/dawnopengl/display/mesh/CMakeLists.txt

@@ -7,5 +7,4 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Mesh.cpp
-    TriangleMesh.cpp
 )

src/dawnopengl/display/mesh/Mesh.hpp

@@ -80,10 +80,15 @@ namespace Dawn {
         int32_t position,
         std::array<glm::vec2, N> coordinates
       ) {
+        auto offsetCoordinates = (
+          (sizeof(glm::vec3) * this->verticeCount) +
+          (sizeof(glm::vec2) * position)
+        );
+
         glBindBuffer(GL_ARRAY_BUFFER, this->vertexBuffer);
         glBufferSubData(
           GL_ARRAY_BUFFER,
-          sizeof(glm::vec2) * position,
+          offsetCoordinates,
           sizeof(coordinates),
           (void *)coordinates.data()
         );

src/dawnopengl/display/shader/Shader.cpp

@@ -61,6 +61,10 @@ void Shader::compileShader(
   // Now parse out the variables.
 }
 
+void Shader::setTextureSlot(shaderparameter_t param, textureslot_t slot) {
+  glUniform1i(param, slot);
+}
+
 shaderparameter_t Shader::getParameterByName(std::string name) {
   return glGetUniformLocation(this->shaderProgram, name.c_str());
 }
@@ -81,6 +85,13 @@ void Shader::setVector3(shaderparameter_t uniform, glm::vec3 vector) {
   glUniform3f(uniform, vector.x, vector.y, vector.z);
 }
 
+void Shader::setTexture(
+  shaderparameter_t param,
+  std::shared_ptr<Texture> texture
+) {
+  this->bindTexture(param, texture);
+}
+
 void Shader::bind() {
   if(this->shaderProgram == -1) throw "Shader has not yet been compiled";
   glUseProgram(this->shaderProgram);

src/dawnopengl/display/shader/Shader.hpp

@@ -32,6 +32,29 @@ namespace Dawn {
        */
       void compileShader(std::string vertexShader, std::string fragmentShader);
 
+      /**
+       * Bind a specific texture slot (of an already bound texture) to a shader
+       * parameter.
+       * 
+       * @param param Parameter to bind the texture slot for.
+       * @param slot Slot to bind.
+       */
+      void setTextureSlot(shaderparameter_t param, textureslot_t slot);
+    
+      /**
+       * Method designed to be overwritten by child shaders on how to handle a
+       * bind texture request. This is left to the discretion of the child 
+       * shader for which slot(s) to use, how to handle nullptr textures, etc.
+       * 
+       * @param param Parameter to bind the requested texture to.
+       * @param texture Texture trying to be bound, may be nullptr.
+       */
+      virtual void bindTexture(
+        shaderparameter_t param,
+        std::shared_ptr<Texture> texture
+      ) = 0;
+
+
     public:
       /**
        * Locate a shader parameter by its name.
@@ -52,6 +75,10 @@ namespace Dawn {
       void setBoolean(shaderparameter_t parameter, bool_t value) override;
       void setColor(shaderparameter_t parameter, struct Color color) override;
       void setVector3(shaderparameter_t parameter, glm::vec3 vector) override;
+      void setTexture(
+        shaderparameter_t parameter,
+        std::shared_ptr<Texture> texture
+      ) override;
 
       /**
        * Destroys and deletes the shader from the GPU.

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -24,7 +24,7 @@ namespace Dawn {
 
         ps[this->paramColor] = SHADER_PARAMETER_TYPE_COLOR;
         ps[this->paramHasTexture] = SHADER_PARAMETER_TYPE_BOOLEAN;
-        // ps[paramTexture] SHADER_PARAMETER_TYPE_TEXTURE;
+        ps[this->paramTexture] = SHADER_PARAMETER_TYPE_TEXTURE;
 
         return ps;
       }
@@ -42,6 +42,19 @@ namespace Dawn {
         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

src/dawnpokergame/game/DawnPokerGame.cpp

@@ -21,13 +21,28 @@ int32_t DawnGame::init() {
 
   auto cameraObject = this->scene->createSceneItem();
   auto camera = cameraObject->addComponent<Camera>();
-  camera->lookAt(glm::vec3(3, 3, 3), glm::vec3(0, 0, 0));
+  camera->lookAt(glm::vec3(5, 5, 5), glm::vec3(0, 0, 0));
 
   auto cubeObject = this->scene->createSceneItem();
   auto cubeMeshRenderer = cubeObject->addComponent<MeshRenderer>();
   auto cubeMaterial = cubeObject->addComponent<Material>();
   cubeMeshRenderer->mesh = std::make_shared<Mesh>();
-  TriangleMesh::createTriangleMesh(*cubeMeshRenderer->mesh);
+  cubeMeshRenderer->mesh->createBuffers(QUAD_VERTICE_COUNT, QUAD_INDICE_COUNT);
+  QuadMesh::bufferQuadMeshWithZ(
+    *cubeMeshRenderer->mesh,
+    glm::vec2(-1, -1), glm::vec2(0, 0),
+    glm::vec2(1, 1), glm::vec2(1, 1),
+    0, 0, 0
+  );
+
+  auto testTexture = std::make_shared<Texture>();
+  testTexture->setSize(2, 2);
+  struct Color colors[4] = {
+    COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE
+  };
+  testTexture->buffer(colors);
+  cubeMaterial->textureValues[cubeMaterial->getShader()->getParameterByName("u_Text")] = testTexture;
+
 
   return DAWN_GAME_INIT_RESULT_SUCCESS;
 }

src/dawnpokergame/game/DawnPokerGame.hpp

@@ -6,4 +6,5 @@
 #pragma once
 #include "game/DawnGame.hpp"
 #include "scene/components/Components.hpp"
+#include "display/mesh/QuadMesh.hpp"
 #include "display/mesh/TriangleMesh.hpp"