Rendering working

src/dawn/game.c

@@ -12,8 +12,6 @@
 #include "rpg/world/maps/testmap.h"
 #include "ui/textbox.h"
 
-#include <font8x8_basic.h>
-
 map_t MAP;
 game_t GAME;
 

src/dawn/rpg/entity/entity.c

@@ -114,7 +114,7 @@ void entityWalk(entity_t *entity, const uint8_t dir) {
   entity->y = newY;
 
   entity->state = ENTITY_STATE_WALKING;
-  entity->walk.time = 0.0f;
+  entity->walk.time = 0.1f;
 }
 
 void entityPositionSet(entity_t *entity, const uint16_t x, const uint16_t y) {

src/dawnopengl/display/CMakeLists.txt

@@ -5,6 +5,7 @@
 
 # Subdirs
 add_subdirectory(shaders)
+add_subdirectory(primitives)
 
 # Sources
 target_sources(${DAWN_TARGET_NAME}
@@ -16,4 +17,5 @@ target_sources(${DAWN_TARGET_NAME}
     font.c
     texture.c
     textureframebuffer.c
+    colorgl.c
 )

src/dawnopengl/display/colorgl.c

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2023 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "colorgl.h"
+#include "assert/assert.h"
+
+void color4fCopy(const color4f_t src, color4f_t dest) {
+  memcpy(dest, src, sizeof(color4f_t));
+}

src/dawnopengl/display/colorgl.h

@@ -56,4 +56,12 @@ typedef color4f_t color_t;
 #define COLOR4F_CORNFLOWERBLUE COLOR4F(0.4f, 0.6f, 0.9f, 1)
 #define COLOR4F_TRANSPARENT_BLACK COLOR4F(0, 0, 0, 0)
 #define COLOR4F_TRANSPARENT_WHITE COLOR4F(1, 1, 1, 0)
-#define COLOR4F_TRANSPARENT COLOR4F_TRANSPARENT_BLACK
+#define COLOR4F_TRANSPARENT COLOR4F_TRANSPARENT_BLACK
+
+/**
+ * Copies a color.
+ * 
+ * @param src Source color.
+ * @param dest Destination color.
+ */
+void color4fCopy(const color4f_t src, color4f_t dest);

src/dawnopengl/display/display.c

@@ -12,25 +12,117 @@
 #include "display/font.h"
 #include "display/mesh.h"
 #include "display/frame.h"
+#include "display/primitives/quad.h"
+#include "time.h"
 
-
+mesh_t FRAMEBUFFER_MESH;
 
 void displayInit() {
   simpleTexturedShaderInit();
   fontInit();
   frameInit();
+
+  meshInit(&FRAMEBUFFER_MESH);
+  meshCreateBuffers(
+    &FRAMEBUFFER_MESH,
+    FRAME_WIDTH * FRAME_HEIGHT * PRIMITIVE_QUAD_VERTICE_COUNT,
+    FRAME_WIDTH * FRAME_HEIGHT * PRIMITIVE_QUAD_INDICE_COUNT
+  );
 }
 
 void displayUpdate() {
   frameUpdate();
 
+  size_t quadIndex = 0;
+  vec4_t uvs;
+  vec4_t positions;
+  uint8_t color;
+  color4f_t glColor;
+  for(uint32_t x = 0; x < FRAME_WIDTH; x++) {
+    for(uint32_t y = 0; y < FRAME_HEIGHT; y++) {
+      char_t c = FRAME_BUFFER[y * FRAME_WIDTH + x];
+      if(c == '\0' || c == ' ') continue;
+      
+      color = FRAME_COLOR[y * FRAME_WIDTH + x];
+      switch(color) {
+        case COLOR_BLACK:
+          color4fCopy(COLOR4F_BLACK, glColor);
+          break;
+        case COLOR_RED:
+          color4fCopy(COLOR4F_RED, glColor);
+          break;
+        case COLOR_GREEN:
+          color4fCopy(COLOR4F_GREEN, glColor);
+          break;
+        case COLOR_BLUE:
+          color4fCopy(COLOR4F_BLUE, glColor);
+          break;
+        case COLOR_YELLOW:
+          color4fCopy(COLOR4F_YELLOW, glColor);
+          break;
+        case COLOR_MAGENTA:
+          color4fCopy(COLOR4F_MAGENTA, glColor);
+          break;
+        case COLOR_CYAN:
+          color4fCopy(COLOR4F_CYAN, glColor);
+          break;
+        case COLOR_WHITE:
+          color4fCopy(COLOR4F_WHITE, glColor);
+          break;
+        default:
+          assertUnreachable("Unknown color: %d", color);
+          break;
+      }
+      fontCharGetUV(c, uvs);
+      
+      positions[0] = x * 8;
+      positions[1] = y * 8;
+      positions[2] = positions[0] + 8;
+      positions[3] = positions[1] + 8;
+
+      primitiveQuadBuffer(
+        &FRAMEBUFFER_MESH,
+        (vec2_t){positions[0], positions[1]},
+        (vec2_t){positions[2], positions[3]},
+        (vec2_t){uvs[0], uvs[1]},
+        (vec2_t){uvs[2], uvs[3]},
+        glColor,
+        quadIndex * PRIMITIVE_QUAD_VERTICE_COUNT,
+        quadIndex * PRIMITIVE_QUAD_INDICE_COUNT
+      );
+      quadIndex++;
+    }
+  }
+
   backBufferBind();
   backBufferClear();
 
+  mat4_t view, projection, model;
+
+  glm_mat4_identity(projection);
+  glm_ortho(0.0f, (float_t)BACK_BUFFER_WIDTH, (float_t)BACK_BUFFER_HEIGHT, 0.0f, 0.0f, 1.0f, projection);
+  simpleTexturedShaderSetProjection(projection);
+
+  glm_mat4_identity(view);
+  glm_lookat((vec3_t){0.0f, 0.0f, 1.0f}, (vec3_t){0.0f, 0.0f, 0.0f}, (vec3_t){0.0f, 1.0f, 0.0f}, view);
+  simpleTexturedShaderSetView(view);
+
+  glm_mat4_identity(model);
+  simpleTexturedShaderSetModel(model);
+
   simpleTexturedShaderBind();
+  simpleTexturedShaderSetTexture(&FONT.texture);
+  simpleTexturedShaderSetColor(COLOR4F_WHITE);
+
+  meshDraw(
+    &FRAMEBUFFER_MESH,
+    MESH_DRAW_MODE_TRIANGLES,
+    0, quadIndex * PRIMITIVE_QUAD_INDICE_COUNT
+  );
 }
 
 void displayDispose() {
   simpleTexturedShaderDispose();
   fontDispose();
+  meshDispose(&FRAMEBUFFER_MESH);
 }

src/dawnopengl/display/font.c

@@ -6,7 +6,11 @@
  */
 
 #include "font.h"
-#include <font8x8.h>
+
+#ifndef FONT8X8_BASIC_H
+  #include <font8x8_basic.h>
+  #define FONT8X8_BASIC_H
+#endif
 
 font_t FONT;
 
@@ -15,14 +19,50 @@ void fontInit() {
 
   // font is uint8_t[8] * count of chars
   size_t charCount = sizeof(font8x8_basic) / 8;
+  size_t totalPixels = charCount * 8 * 8;
+  int32_t width = (int32_t)(totalPixels / 8);
+  int32_t height = 8;
 
-  int32_t totalPixels = charCount * 8 * 8;
   textureInit(
     &FONT.texture,
-    totalPixels / 8, 8,
+    width,
+    height,
     TEXTURE_FORMAT_R,
     TEXTURE_DATA_FORMAT_UNSIGNED_BYTE
   );
+  FONT.texture.filterModeMag = TEXTURE_FILTER_MODE_NEAREST;
+  FONT.texture.filterModeMin = TEXTURE_FILTER_MODE_NEAREST;
+
+  uint8_t *pixels = (uint8_t*)malloc(totalPixels);
+
+  for(size_t i = 0; i < charCount; i++) {
+    for(size_t y = 0; y < 8; y++) {
+      for(size_t x = 0; x < 8; x++) {
+        uint8_t bit = (font8x8_basic[i][y] >> x) & 1;
+        pixels[(i * 8) + (y * 8 * charCount) + x] = bit * 255;
+      }
+    }
+  }
+
+  textureBuffer(&FONT.texture, pixels);
+  free(pixels);
+}
+
+void fontCharGetUV(const char_t c, vec4_t out) {
+  size_t charCount = sizeof(font8x8_basic) / 8;
+  int32_t index = (int32_t)c;
+  if(index >= charCount) index = 0;
+
+  int32_t x = index % charCount;
+  int32_t y = 0;
+
+  float_t width = (float_t)FONT.texture.width;
+  float_t height = (float_t)FONT.texture.height;
+
+  out[0] = (float_t)x * (8.0f / width);
+  out[1] = (float_t)y * (8.0f / height);
+  out[2] = out[0] + (8.0f / width);
+  out[3] = out[1] + (8.0f / height);
 }
 
 void fontDispose() {

src/dawnopengl/display/font.h

@@ -19,6 +19,14 @@ extern font_t FONT;
  */
 void fontInit();
 
+/**
+ * Gets the UV coordinates for a character.
+ * 
+ * @param c Character to get UV coordinates for.
+ * @return UV coordinates for the character.
+ */
+void fontCharGetUV(const char_t c, vec4_t out);
+
 /**
  * Disposes of the render font.
  */

src/dawnopengl/display/mesh.c

@@ -46,6 +46,7 @@ void meshCreateBuffers(
   size_t sizePos = sizeof(vec3_t) * verticeCount;
   size_t sizeInds = sizeof(meshindice_t) * indiceCount;
   size_t sizeCoords = sizeof(vec2_t) * verticeCount;
+  size_t sizeColors = sizeof(color4f_t) * verticeCount;
 
   // Generate vertex array, I don't think I need to do this tbh.
   glGenVertexArrays(1, &mesh->vertexArray);
@@ -74,8 +75,9 @@ void meshCreateBuffers(
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->indexBuffer);
   assertNoGLError();
   
-  glBufferData(GL_ARRAY_BUFFER, sizePos+sizeCoords, 0, GL_DYNAMIC_DRAW);
+  glBufferData(GL_ARRAY_BUFFER, sizePos+sizeCoords+sizeColors, 0, GL_DYNAMIC_DRAW);
   assertNoGLError();
+
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeInds, 0, GL_DYNAMIC_DRAW);
   assertNoGLError();
 
@@ -99,6 +101,16 @@ void meshCreateBuffers(
   assertNoGLError();
   glEnableVertexAttribArray(1);
   assertNoGLError();
+
+  offset += sizeCoords;
+  glVertexAttribPointer(
+    2, sizeof(color4f_t) / sizeof(float_t),
+    GL_FLOAT, GL_FALSE,
+    0, (void *)offset
+  );
+  assertNoGLError();
+  glEnableVertexAttribArray(2);
+  assertNoGLError();
 }
 
 void meshDestroyBuffers(mesh_t *mesh) {
@@ -207,6 +219,47 @@ void meshBufferCoordinates(
   assertNoGLError();
 }
 
+void meshBufferColors(
+  const mesh_t *mesh,
+  const color4f_t *colors,
+  const size_t position,
+  const size_t count
+) {
+  assertNotNull(mesh, "meshBufferColors: Mesh cannot be null");
+  assertNotNull(
+    colors,
+    "meshBufferColors: Colors cannot be null"
+  );
+  assertTrue(
+    position >= 0 && position < mesh->verticeCount,
+    "meshBufferColors: Position must be within range"
+  );
+  assertTrue(
+    position+count <= mesh->verticeCount,
+    "meshBufferColors: Position + count must be within range"
+  );
+  assertTrue(
+    count > 0,
+    "meshBufferColors: Count must be greater than zero"
+  );
+
+  size_t offsetColors = (
+    (sizeof(vec3_t) * mesh->verticeCount) +
+    (sizeof(vec2_t) * mesh->verticeCount) +
+    (sizeof(color4f_t) * position)
+  );
+
+  glBindBuffer(GL_ARRAY_BUFFER, mesh->vertexBuffer);
+  assertNoGLError();
+  glBufferSubData(
+    GL_ARRAY_BUFFER,
+    offsetColors,
+    sizeof(color4f_t) * count,
+    (void*)colors
+  );
+  assertNoGLError();
+}
+
 void meshBufferIndices(
   const mesh_t *mesh,
   const meshindice_t *indices,
@@ -293,6 +346,16 @@ void meshDraw(
   glEnableVertexAttribArray(1);
   assertNoGLError();
 
+  offset += sizeof(vec2_t) * mesh->verticeCount;
+  glVertexAttribPointer(
+    2, sizeof(color4f_t) / sizeof(float_t),
+    GL_FLOAT, GL_FALSE,
+    0, (void*)offset
+  );
+  assertNoGLError();
+  glEnableVertexAttribArray(2);
+  assertNoGLError();
+
   // Render the elements.
   glDrawElements(
     mode,

src/dawnopengl/display/mesh.h

@@ -8,6 +8,7 @@
 #pragma once
 #include "dawn.h"
 #include "dawnopengl.h"
+#include "colorgl.h"
 
 extern int32_t MESH_ACTIVE_COUNT;
 
@@ -96,6 +97,21 @@ void meshBufferCoordinates(
   const size_t count
 );
 
+/**
+ * Write colors to the mesh.
+ * 
+ * @param mesh Mesh to write to.
+ * @param colors Array of colors to write.
+ * @param position Position, within the buffer, to write to.
+ * @param count How many colors are in the array.
+ */
+void meshBufferColors(
+  const mesh_t *mesh,
+  const color4f_t *colors,
+  const size_t position,
+  const size_t count
+);
+
 /**
  * Write indices to the mesh.
  * 

src/dawnopengl/display/primitives/CMakeLists.txt

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

src/dawnopengl/display/primitives/quad.c

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2023 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "quad.h"
+
+void primitiveQuadBuffer(
+  mesh_t *mesh,
+  const vec2_t xy0,
+  const vec2_t xy1,
+  const vec2_t uv0,
+  const vec2_t uv1,
+  const color4f_t color,
+  const size_t verticeIndex,
+  const size_t indiceIndex
+) {
+  meshBufferPositions(
+    mesh,
+    (vec3_t[]){
+      { xy0[0], xy0[1], 0.0f },
+      { xy1[0], xy0[1], 0.0f },
+      { xy1[0], xy1[1], 0.0f },
+      { xy0[0], xy1[1], 0.0f }
+    },
+    verticeIndex,
+    PRIMITIVE_QUAD_VERTICE_COUNT
+  );
+
+  primitiveQuadBufferCoordinates(mesh, uv0, uv1, verticeIndex);
+
+  meshBufferIndices(
+    mesh,
+    (meshindice_t[]){
+      verticeIndex + 0, verticeIndex + 1, verticeIndex + 2,
+      verticeIndex + 2, verticeIndex + 3, verticeIndex + 0
+    },
+    indiceIndex,
+    PRIMITIVE_QUAD_INDICE_COUNT
+  );
+
+  color4f_t colors[PRIMITIVE_QUAD_VERTICE_COUNT];
+  color4fCopy(color, colors[0]);
+  color4fCopy(color, colors[1]);
+  color4fCopy(color, colors[2]);
+  color4fCopy(color, colors[3]);
+  
+  
+  meshBufferColors(
+    mesh,
+    colors,
+    verticeIndex,
+    PRIMITIVE_QUAD_VERTICE_COUNT
+  );
+}
+
+void primitiveQuadBufferCoordinates(
+  mesh_t *mesh,
+  const vec2_t uv0,
+  const vec2_t uv1,
+  int32_t verticeIndex
+) {
+  meshBufferCoordinates(
+    mesh,
+    (vec2_t[]){
+      { uv0[0], uv0[1] },
+      { uv1[0], uv0[1] },
+      { uv1[0], uv1[1] },
+      { uv0[0], uv1[1] }
+    },
+    verticeIndex,
+    PRIMITIVE_QUAD_VERTICE_COUNT
+  );
+}

src/dawnopengl/display/primitives/quad.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2023 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "display/mesh.h"
+
+#define PRIMITIVE_QUAD_VERTICE_COUNT 4
+#define PRIMITIVE_QUAD_INDICE_COUNT 6
+
+/**
+ * Buffers a quad into the mesh.
+ * 
+ * @param mesh The mesh to buffer into.
+ * @param xy0 The first xy coordinate.
+ * @param xy1 The second xy coordinate.
+ * @param uv0 The first uv coordinate.
+ * @param uv1 The second uv coordinate.
+ * @param color The color of the quad.
+ * @param verticeIndex The vertice index to start at.
+ * @param indiceIndex The indice index to start at.
+ */
+void primitiveQuadBuffer(
+  mesh_t *mesh,
+  const vec2_t xy0,
+  const vec2_t xy1,
+  const vec2_t uv0,
+  const vec2_t uv1,
+  const color4f_t color,
+  const size_t verticeIndex,
+  const size_t indiceIndex
+);
+
+/**
+ * Buffers quad uv coordinates into the mesh.
+ * 
+ * @param mesh The mesh to buffer into.
+ * @param uv0 The first uv coordinate.
+ * @param uv1 The second uv coordinate.
+ * @param verticeIndex The vertice index to start at.
+ */
+void primitiveQuadBufferCoordinates(
+  mesh_t *mesh,
+  const vec2_t uv0,
+  const vec2_t uv1,
+  int32_t verticeIndex
+);

src/dawnopengl/display/shaders/simpletexturedshader.c

@@ -16,24 +16,30 @@ void simpleTexturedShaderInit() {
     "#version 330 core\n"
     "layout (location = 0) in vec3 aPos;\n"
     "layout (location = 1) in vec2 aTexCoord;\n"
+    "layout (location = 2) in vec4 aColor;\n"
     "uniform mat4 u_Projection;\n"
     "uniform mat4 u_View;\n"
     "uniform mat4 u_Model;\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"
       "o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
+      "v_Color = aColor;\n"
     "}",
     // Fragment Shader
     "#version 330 core\n"
     "in vec2 o_TextCoord;\n"
+    "in vec4 v_Color;\n"
     "out vec4 o_Color;\n"
     "uniform vec4 u_Color;\n"
     "uniform bool u_HasTexture;\n"
     "uniform sampler2D u_Text;\n"
     "void main() {\n"
       "if(u_HasTexture) {\n"
-        "o_Color = texture(u_Text, o_TextCoord) * u_Color;\n"
+        "vec4 texColor = texture(u_Text, o_TextCoord);\n"
+        "if(texColor.r < 0.1) discard;\n"
+        "o_Color = u_Color * v_Color * vec4(1.0, 1.0, 1.0, texColor.r);\n"
       "} else {\n"
         "o_Color = u_Color;"
       "}\n"

src/dawnterm/display/frame.h

@@ -8,8 +8,8 @@
 #pragma once
 #include "display/color.h"
 
-#define FRAME_WIDTH 320/8
+#define FRAME_WIDTH 640/8
-#define FRAME_HEIGHT 240/8
+#define FRAME_HEIGHT 480/8
 
 
 extern char_t FRAME_BUFFER[FRAME_HEIGHT * FRAME_WIDTH];