glClear is causing stack corrpution

src/dawnopengl/display/BackBufferRenderTarget.cpp

@@ -45,13 +45,14 @@ void BackBufferRenderTarget::setClearColor(const struct Color color) {
 }
 
 void BackBufferRenderTarget::clear(const int32_t clearFlags) {
-  glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
+  glClearColor(clearColor.r, clearColor.g, clearColor.b, 1.0f);
   assertNoGLError();
 
   GLbitfield mask = 0;
   if(Flag::isOn(clearFlags, RENDER_TARGET_CLEAR_COLOR)) {
     mask |= GL_COLOR_BUFFER_BIT;
   }
+
   if(Flag::isOn(clearFlags, RENDER_TARGET_CLEAR_DEPTH)) {
     mask |= GL_DEPTH_BUFFER_BIT;
   }

src/dawnopengl/display/CMakeLists.txt

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

src/dawnopengl/display/Texture.cpp

@@ -0,0 +1,208 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "assert/assert.hpp"
+#include "assert/assertgl.hpp"
+#include "Texture.hpp"
+
+using namespace Dawn;
+
+void Texture::bind(const uint8_t slot) {
+  assertTrue(this->id != -1, "Texture is not ready!");
+  glActiveTexture(GL_TEXTURE0 + slot);
+  assertNoGLError();
+  glBindTexture(GL_TEXTURE_2D, this->id);
+  assertNoGLError();
+  this->updateTextureProperties();
+}
+
+int32_t Texture::getWidth() {
+  return this->width;
+}
+
+int32_t Texture::getHeight() {
+  return this->height;
+}
+
+void Texture::setSize(
+  const int32_t width,
+  const int32_t height,
+  const enum TextureFormat format,
+  const enum TextureDataFormat dataFormat
+) {
+  if(this->id != -1) {
+    glDeleteTextures(1, &this->id);
+    assertNoGLError();
+    this->id = -1;
+  }
+  
+  int32_t maxSize;
+  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+  assertTrue(width > 0 && width <= maxSize, "Width is out of bounds!");
+  assertTrue(height > 0 && height <= maxSize, "Height is out of bounds!");
+
+  this->width = width;
+  this->height = height;
+  this->format = format;
+  this->dataFormat = dataFormat;
+
+  glGenTextures(1, &this->id);
+  assertNoGLError();
+  if(this->id <= 0) assertUnreachable("Texture generation failed!");
+
+  // Initialize the texture to blank
+  glActiveTexture(GL_TEXTURE0);
+  assertNoGLError();
+  this->bufferRaw(NULL);
+}
+
+// bool_t Texture::isReady() {
+//   return this->id != -1;
+// }
+
+void Texture::updateTextureProperties() {
+  auto setWrapMode = [&](GLenum axis, enum TextureWrapMode wm) {
+    switch(wm) {
+      case TEXTURE_WRAP_MODE_REPEAT:
+        glTexParameteri(GL_TEXTURE_2D, axis, GL_REPEAT);
+        break;
+      
+      case TEXTURE_WRAP_MODE_MIRRORED_REPEAT:
+        glTexParameteri(GL_TEXTURE_2D, axis, GL_MIRRORED_REPEAT);
+        break;
+
+      case TEXTURE_WRAP_MODE_CLAMP_TO_EDGE:
+        glTexParameteri(GL_TEXTURE_2D, axis, GL_CLAMP_TO_EDGE);
+        break;
+
+      case TEXTURE_WRAP_MODE_CLAMP_TO_BORDER:
+        glTexParameteri(GL_TEXTURE_2D, axis, GL_CLAMP_TO_BORDER);
+        break;
+
+      default:
+        assertUnreachable("Unknown wrap mode!");
+    }
+    assertNoGLError();
+  };
+
+  setWrapMode(GL_TEXTURE_WRAP_S, this->wrapModeX);
+  setWrapMode(GL_TEXTURE_WRAP_T, this->wrapModeY);
+
+  auto setFilterMode = [&](
+    GLenum minMag,
+    enum TextureFilterMode filter,
+    enum TextureFilterMode mapFilterMode
+  ) {
+    switch(filter) {
+      case TEXTURE_FILTER_MODE_NEAREST: {
+        glTexParameteri(GL_TEXTURE_2D, minMag, GL_NEAREST);
+        break;
+      }
+      
+      case TEXTURE_FILTER_MODE_LINEAR: {
+        glTexParameteri(GL_TEXTURE_2D, minMag, GL_LINEAR);
+        break;
+      }
+
+      default: {
+        assertUnreachable("Unknown filter mode!");
+      }
+    }
+    assertNoGLError();
+  };
+
+  setFilterMode(
+    GL_TEXTURE_MIN_FILTER, this->filterModeMin, this->mipMapFilterModeMin
+  );
+  setFilterMode(
+    GL_TEXTURE_MAG_FILTER, this->filterModeMag, this->mipMapFilterModeMag
+  );
+}
+
+void Texture::bufferRaw(const void *data) {
+  assertTrue(this->id != -1, "Texture is not ready!");
+
+  GLenum format;
+  switch(this->format) {
+    case TEXTURE_FORMAT_R:
+      format = GL_RED;
+      break;
+
+    case TEXTURE_FORMAT_RG:
+      format = GL_RG;
+      break;
+
+    case TEXTURE_FORMAT_RGB:
+      format = GL_RGB;
+      break;
+
+    case TEXTURE_FORMAT_RGBA:
+      format = GL_RGBA;
+      break;
+    
+    default:
+      assertUnreachable("Unknown texture format!");
+  }
+
+  GLenum dataFormat;
+  switch(this->dataFormat) {
+    case TEXTURE_DATA_FORMAT_UNSIGNED_BYTE:
+      dataFormat = GL_UNSIGNED_BYTE;
+      break;
+
+    case TEXTURE_DATA_FORMAT_FLOAT:
+      dataFormat = GL_FLOAT;
+      break;
+
+    default:
+      assertUnreachable("Unknown texture data format!");
+  }
+
+  glBindTexture(GL_TEXTURE_2D, this->id);
+  assertNoGLError();
+  glTexImage2D(
+    GL_TEXTURE_2D, 0, format,
+    this->width, this->height,
+    0, format, dataFormat, data
+  );
+  assertNoGLError();
+  glGenerateMipmap(GL_TEXTURE_2D);
+  assertNoGLError();
+}
+
+void Texture::buffer(const struct ColorU8 pixels[]) {
+  assertTrue(
+    this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE,
+    "Texture data format must be unsigned byte!"
+  );
+  this->bufferRaw((void*)pixels);
+}
+
+void Texture::buffer(const struct Color pixels[]) {
+  assertTrue(
+    this->dataFormat == TEXTURE_DATA_FORMAT_FLOAT,
+    "Texture data format must be float!"
+  );
+  assertTrue(
+    this->format == TEXTURE_FORMAT_RGBA,
+    "Texture format must be RGBA!"
+  );
+  this->bufferRaw((void*)pixels);
+}
+
+void Texture::buffer(const uint8_t pixels[]) {
+  assertTrue(
+    this->dataFormat == TEXTURE_DATA_FORMAT_UNSIGNED_BYTE,
+    "Texture data format must be unsigned byte!"
+  );
+  this->bufferRaw((void*)pixels);
+}
+
+Texture::~Texture() {
+  if(this->id != -1) {
+    glDeleteTextures(1, &this->id);
+    assertNoGLError();
+  }
+}

src/dawnopengl/display/Texture.hpp

@@ -0,0 +1,43 @@
+// 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/ITexture.hpp"
+
+namespace Dawn {
+  class TextureRenderTarget;
+  
+  typedef GLuint textureslot_t;
+
+  class Texture : public ITexture {
+    private:
+      int32_t width = -1;
+      int32_t height = -1;
+      GLuint id = -1;
+      enum TextureFormat format;
+      enum TextureDataFormat dataFormat;
+
+      void updateTextureProperties();
+      void bufferRaw(const void *data);
+
+    public:
+      int32_t getWidth() override;
+      int32_t getHeight() override;
+      void setSize(
+        const int32_t width,
+        const int32_t height,
+        const enum TextureFormat format,
+        const enum TextureDataFormat dataForat
+      ) override;
+      // bool_t isReady() override;
+      void buffer(const struct ColorU8 pixels[]) override;
+      void buffer(const struct Color pixels[]);
+      void buffer(const uint8_t pixels[]) override;
+      void bind(const uint8_t slot) override;
+
+      ~Texture();
+  };
+}

src/dawnopengl/display/shader/Shader.hpp

@@ -9,8 +9,11 @@
 #include "assert/assert.hpp"
 #include "assert/assertgl.hpp"
 #include "display/Color.hpp"
+#include "display/Texture.hpp"
 
 namespace Dawn {
+  typedef GLuint shadertexturebinding_t;
+
   enum ShaderOpenGLVariant {
     GLSL_330_CORE
   };
@@ -151,6 +154,18 @@ namespace Dawn {
                   break;
                 }
 
+                case ShaderParameterType::BOOLEAN: {
+                  auto boolean = (bool_t *)value;
+                  glUniform1i(param.location, *boolean ? 1 : 0);
+                  break;
+                }
+
+                case ShaderParameterType::TEXTURE: {
+                  textureslot_t texture = *((textureslot_t*)value);
+                  glUniform1i(param.location, texture);
+                  break;
+                }
+
                 default: {
                   assertUnreachable("Unsupported ShaderParameterType");
                 }

src/dawnopengl/display/shader/SimpleTexturedShader.cpp

@@ -23,11 +23,14 @@ void SimpleTexturedShader::getStages(
         ShaderStageType::VERTEX,
         "#version 330 core\n"
         "layout (location = 0) in vec3 aPos;\n"
+        "layout (location = 1) in vec2 aTexCoord;\n"
         "uniform mat4 u_Projection;\n"
         "uniform mat4 u_View;\n"
         "uniform mat4 u_Model;\n"
+        "out vec2 o_TextCoord;\n"
         "void main() {\n"
           "gl_Position = u_Projection * u_View * u_Model * vec4(aPos, 1.0);\n"
+          "o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
         "}"
       );
       
@@ -37,8 +40,14 @@ void SimpleTexturedShader::getStages(
         "in vec2 o_TextCoord;\n"
         "out vec4 o_Color;\n"
         "uniform vec4 u_Color;\n"
+        "uniform bool u_HasTexture;\n"
+        "uniform sampler2D u_Texture;\n"
         "void main() {\n"
-          "o_Color = u_Color;"
+          "if(u_HasTexture) {\n"
+            "o_Color = texture(u_Texture, o_TextCoord) * u_Color;\n"
+          "} else {\n"
+            "o_Color = u_Color;"
+          "}\n"
         "}\n"
       );
       break;
@@ -75,4 +84,16 @@ void SimpleTexturedShader::getStages(
     &rel->color,
     ShaderParameterType::COLOR
   ));
+
+  parameters.push_back(ShaderOpenGLParameter(
+    "u_HasTexture",
+    &rel->hasTexture,
+    ShaderParameterType::BOOLEAN
+  ));
+
+  parameters.push_back(ShaderOpenGLParameter(
+    "u_Texture",
+    &rel->texture,
+    ShaderParameterType::TEXTURE
+  ));
 }

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -12,6 +12,8 @@ namespace Dawn {
     glm::mat4 view;
     glm::mat4 model;
     struct Color color = COLOR_WHITE;
+    bool hasTexture = false;
+    shadertexturebinding_t texture = 0;
   };
 
   class SimpleTexturedShader : public Shader<SimpleTexturedShaderData> {