Shader working.

src/duskgl/display/render.c

@@ -21,6 +21,9 @@ void renderInit() {
 }
 
 void renderUpdate() {
+  // Update shader stuff
+  shaderManagerUpdate();
+  
   // Hand off to the scene to do its rendering.
   sceneRender();
 }

src/duskgl/display/shader/CMakeLists.txt

@@ -12,4 +12,5 @@ target_sources(${DUSK_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(entityshader)
+add_subdirectory(entityshader)
+add_subdirectory(fragments)

src/duskgl/display/shader/entityshader/entity.glsl

@@ -1,27 +0,0 @@
-#include "../fragments/header.glsl"
-#include "../fragments/transforms.glsl"
-
-#define ENTITY_TILE_OFFSET_X (MAP_TILE_WIDTH - ENTITY_WIDTH) / 2
-#define ENTITY_TILE_OFFSET_Y (MAP_TILE_HEIGHT - ENTITY_HEIGHT) / 2
-
-struct Entity {
-  int x;
-  int y;
-  int tileset;
-  int tile;
-};
-
-layout(std140) uniform b_Data {
-  Entity entities[MAP_ENTITY_COUNT_MAX];
-  int entityCount;
-};
-
-vec4 entityGetCoordinates(Entity ent) {
-  int vx = (ent.x * MAP_TILE_WIDTH) + ENTITY_TILE_OFFSET_X;
-  int vy = (ent.y * MAP_TILE_HEIGHT) + ENTITY_TILE_OFFSET_Y;
-  return vec4(vx, vy, vx + ENTITY_WIDTH, vy + ENTITY_HEIGHT);
-}
-
-vec4 entityGetUVs(Entity ent) {
-  return tilesetGetUVsByIndex(ent.tileset, ent.tile);
-}

src/duskgl/display/shader/entityshader/entity_frag.glsl

@@ -1,18 +1,11 @@
-#include "entity.glsl"
+#include "../fragments/header.glsl"
 
+// Inputs from vertex shader
 in vec2 v_TextureCoord;
-flat in int v_Entity;
 
+// Frag pixel color
 out vec4 FragColor;
 
 void main() {
-  Entity e = entities[v_Entity];
+  FragColor = vec4(1, 1, 1, 1);
-  vec4 textureColor = tilesetGetColor(e.tileset, v_TextureCoord);
-
-  // We remove the pink color as transparent
-  if(textureColor.r == 1.0 && textureColor.g == 0.0 && textureColor.b == 1.0) {
-    discard;
-  }
-
-  FragColor = textureColor;
 }

src/duskgl/display/shader/entityshader/entity_vert.glsl

@@ -1,35 +1,17 @@
-#include "entity.glsl"
+#include "../fragments/header.glsl"
+#include "../fragments/transforms.glsl"
+#include "../fragments/quad.glsl"
 
 // Outputs to fragment shader
 out vec2 v_TextureCoord;
-flat out int v_Entity;
 
 void main() {
-  int entityIndex = gl_InstanceID;
+  uint instanceIndex = uint(gl_InstanceID);
-  int indiceIndex = gl_VertexID % 6;
+  uint indiceIndex = uint(gl_VertexID % 6);
-  
-  Entity entity = entities[entityIndex];
-  
-  vec4 quadPos = entityGetCoordinates(entity);
-  vec4 quadUVs = entityGetUVs(entity);
-  
-  vec2 vertex;
-  vec2 uv;
-  if(indiceIndex == 0 || indiceIndex == 4) {
-    vertex = quadPos.xy;
-    uv = quadUVs.xy;
-  } else if(indiceIndex == 1) {
-    vertex = quadPos.zy;
-    uv = quadUVs.zy;
-  } else if(indiceIndex == 2 || indiceIndex == 5) {
-    vertex = quadPos.zw; 
-    uv = quadUVs.zw; 
-  } else if(indiceIndex == 3) {
-    vertex = quadPos.xw; 
-    uv = quadUVs.xw; 
-  }
 
-  gl_Position = transforms.projection * transforms.view * vec4(vertex, 0.0, 1.0);
+  vec2 vert = quadGetVertice(indiceIndex);
+  vec2 uv = quadGetTextureCoordinate(indiceIndex);
+
+  gl_Position = transforms.projection * transforms.view * vec4(vert, 0.0, 1.0);
   v_TextureCoord = uv;
-  v_Entity = entityIndex;
 }

src/duskgl/display/shader/entityshader/entityshader.c

@@ -10,6 +10,7 @@
 #include "entityshader.h"
 #include "entity_vert.glsl.h"
 #include "entity_frag.glsl.h"
+#include "display/shader/fragments/transforms.h"
 
 entityshader_t ENTITY_SHADER;
 
@@ -23,10 +24,19 @@ void entityShaderInit() {
   );
 
   // Uniform buffers
+  ENTITY_SHADER.transformsBlock = shaderGetBlock(
+    &ENTITY_SHADER.shader,
+    TRANSFORMS_BLOCK_NAME
+  );
 
   // Uniforms
 }
 
+void entityShaderUse() {
+  shaderUse(&ENTITY_SHADER.shader);
+  shaderBufferBindToBlock(&TRANSFORMS_BUFFER, ENTITY_SHADER.transformsBlock);
+}
+
 void entityShaderDispose() {
   shaderDispose(&ENTITY_SHADER.shader);
 }

src/duskgl/display/shader/entityshader/entityshader.h

@@ -12,7 +12,7 @@ typedef struct {
   shader_t shader;
   
   // GLuint dataBlock;
-  // GLuint transformsBlock;
+  GLuint transformsBlock;
   // GLuint tilesetsBlock;
   
   // GLuint uniformTilesetTextures;
@@ -25,6 +25,11 @@ extern entityshader_t ENTITY_SHADER;
  */
 void entityShaderInit();
 
+/**
+ * Uses the entity shader.
+ */
+void entityShaderUse();
+
 /**
  * Disposes of the entity shader.
  */

src/duskgl/display/shader/fragments/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2025 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_TARGET_NAME}
+  PRIVATE
+    transforms.c
+)

src/duskgl/display/shader/fragments/transforms.c

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "transforms.h"
+#include "display/window.h"
+
+shaderbuffer_t TRANSFORMS_BUFFER;
+transformsdata_t TRANSFORMS_DATA;
+
+void transformsInit() {
+  shaderBufferInit(&TRANSFORMS_BUFFER, sizeof(transformsdata_t));
+
+  glm_mat4_identity(TRANSFORMS_DATA.projection);
+  glm_mat4_identity(TRANSFORMS_DATA.view);
+}
+
+void transformsUpdate() {
+  TRANSFORMS_DATA.resolution[0] = WINDOW_WIDTH;
+  TRANSFORMS_DATA.resolution[1] = WINDOW_HEIGHT;
+
+  glm_perspective(
+    glm_rad(45.0f),
+    TRANSFORMS_DATA.resolution[0] / TRANSFORMS_DATA.resolution[1],
+    0.1f,
+    100.0f,
+    TRANSFORMS_DATA.projection
+  );
+
+  glm_lookat(
+    (vec3){ 3, 3, 3 },
+    (vec3){ 0, 0, 0 },
+    (vec3){ 0, 1, 0 },
+    TRANSFORMS_DATA.view
+  );
+
+  shaderBufferBind(&TRANSFORMS_BUFFER);
+  shaderBufferSetData(&TRANSFORMS_BUFFER, &TRANSFORMS_DATA);
+}
+
+void transformsDispose() {
+  shaderBufferDispose(&TRANSFORMS_BUFFER);
+}

src/duskgl/display/shader/fragments/transforms.glsl

@@ -16,11 +16,11 @@ layout(std140) uniform b_Transforms {
 };
 
 vec2 transformDisplayGetSize() {
-  return vec2(DISPLAY_WIDTH, DISPLAY_HEIGHT);
+  return vec2(SCREEN_WIDTH, SCREEN_HEIGHT);
 }
 
 float transformDisplayGetAspectRatio() {
-  return (float(DISPLAY_WIDTH) / float(DISPLAY_HEIGHT));
+  return (float(SCREEN_WIDTH) / float(SCREEN_HEIGHT));
 }
 
 vec2 transformResolutionGetSize() {

src/duskgl/display/shader/fragments/transforms.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "display/shader/shaderbuffer.h"
+
+#define TRANSFORMS_BLOCK_NAME "b_Transforms"
+
+typedef struct {
+  mat4 projection;
+  mat4 view;
+  vec2 resolution;
+} transformsdata_t;
+
+extern shaderbuffer_t TRANSFORMS_BUFFER;
+extern transformsdata_t TRANSFORMS_DATA;
+
+/**
+ * Initializes the transforms buffer and data.
+ */
+void transformsInit();
+
+/**
+ * Updates the transforms buffer with the current data.
+ */
+void transformsUpdate();
+
+/**
+ * Destroys the transforms buffer.
+ */
+void transformsDispose();

src/duskgl/display/shader/shadermanager.c

@@ -6,11 +6,26 @@
  */
 
 #include "shadermanager.h"
+#include "display/shader/fragments/transforms.h"
+#include "display/shader/entityshader/entityshader.h"
 
 void shaderManagerInit() {
+  // Initialize the shader buffers
+  transformsInit();
 
+  // Initialize the shaders
+  entityShaderInit();
+}
+
+void shaderManagerUpdate() {
+  // Update shader buffers
+  transformsUpdate();
 }
 
 void shaderManagerDispose() {
-  
+  // Dispose the shaders
+  entityShaderDispose();
+
+  // Dispose the shader buffers
+  transformsDispose();
 }

src/duskgl/display/shader/shadermanager.h

@@ -6,17 +6,17 @@
  */
 
 #pragma once
-#include "duskgl.h"
-
-// typedef struct {
-
-// } shadermanager_t;
 
 /**
  * Initializes the Shader Manager
  */
 void shaderManagerInit();
 
+/**
+ * Updates the Shader Manager
+ */
+void shaderManagerUpdate();
+
 /**
  * Disposes of the Shader Manager
  */

src/duskgl/overworld/overworld.c

@@ -6,7 +6,10 @@
  */
 
 #include "overworld/overworld.h"
+#include "display/quad.h"
+#include "display/shader/entityshader/entityshader.h"
 
 void overworldRender() {
-  
+  entityShaderUse();
+  quadRender(1);
 }

src/duskglfw/display/window.h

@@ -9,8 +9,8 @@
 #include "duskglfw.h"
 #include "display/displaydefs.h"
 
-#define WINDOW_WIDTH_DEFAULT SCREEN_WIDTH*4
+#define WINDOW_WIDTH_DEFAULT SCREEN_WIDTH*3
-#define WINDOW_HEIGHT_DEFAULT SCREEN_HEIGHT*4
+#define WINDOW_HEIGHT_DEFAULT SCREEN_HEIGHT*3
 
 extern GLFWwindow* window;
 extern int32_t WINDOW_WIDTH;