Revisiting rendering

4 files changed, 124 insertions, 24 deletions

diff --git a/src/core/src/loop.c b/src/core/src/loop.c
index e54420f..19841ab 100644
--- a/src/core/src/loop.c
+++ b/src/core/src/loop.c
@@ -307,9 +307,6 @@ i32 engine_run(Platform* p, StateType initial_state, void* state_arg) {
   /* The target frametime measured in μs */
   const u32 fps_cap = p->fps_target > 0 ? 1000000 / p->fps_target : 0;
 
-  //window_resize(p->window, p->window->windowsize[0], p->window->windowsize[1]);
-  //r_reset_camera(p->cam);
-
   /* Main loop */
   do {
     /* frame_start is μs since engine was initialized */
diff --git a/src/rendering/include/engine/rendering/rendering.h b/src/rendering/include/engine/rendering/rendering.h
index abfb8d9..c5f805e 100644
--- a/src/rendering/include/engine/rendering/rendering.h
+++ b/src/rendering/include/engine/rendering/rendering.h
@@ -80,8 +80,15 @@ typedef enum {
   ShaderBuffer_DataType_f32            = 0b0010000000000, // 1024
   ShaderBuffer_DataType_f64            = 0b0011000000000, // 1536
 
-  ShaderBuffer_DataType_i32            = 0b0100000000000, // 2048
-  ShaderBuffer_DataType_i64            = 0b0101000000000, // 2560
+  ShaderBuffer_DataType_i8             = 0b0100000000000, // 2048
+  ShaderBuffer_DataType_i16            = 0b0101000000000, // 2560
+  ShaderBuffer_DataType_i32            = 0b0110000000000, // 3072
+  ShaderBuffer_DataType_i64            = 0b0111000000000, // 3584
+
+  ShaderBuffer_DataType_u8             = 0b1000000000000, // 4096
+  ShaderBuffer_DataType_u16            = 0b1001000000000, // 4608
+  ShaderBuffer_DataType_u32            = 0b1010000000000, // 5120
+  ShaderBuffer_DataType_u64            = 0b1011000000000, // 5632
 } ShaderBufferFlag;
 
 typedef struct {
@@ -101,6 +108,13 @@ typedef struct {
   void* data;
 } ShaderBuffer;
 
+// SHADERBUFFER_NEW is a constructor that takes the
+// * type T, as one of f32, f64, i8, i16, i32, i64, u8, u16, u32, or u64.
+// * COUNT, number of elements in the buffer
+// * COMPONENTS, number of elements to be grouped together, ie. 3 for a vec3.
+// * DATA, the buffer (it is pointed to automatically)
+// * FLAGS, are low-level GL flags that hints the access frequency, the access
+//   type, and what buffer type it is, such as "data" or an index buffer.
 #define SHADERBUFFER_NEW(T, COUNT, COMPONENTS, DATA, FLAGS) \
   (ShaderBuffer){ \
     .buffername = 0, \
@@ -178,6 +192,11 @@ ShaderBufferFlag ShaderBuffer_get_access_type(u64 flags);
 ShaderBufferFlag ShaderBuffer_get_type(u64 flags);
 ShaderBufferFlag ShaderBuffer_get_data_type(u64 flags);
 
+/* Conversion to GL types */
+u32 ShaderBuffer_get_gl_type(u64 flags);
+u32 ShaderBuffer_get_gl_accesstype(u64 flags);
+u32 ShaderBuffer_get_gl_datatype(u64 flags);
+
 /* Rendering functions */
 void render_begin(Window* w);
 void render_present(Window* w);
diff --git a/src/rendering/src/gl.c b/src/rendering/src/gl.c
index 029e540..0468c8b 100644
--- a/src/rendering/src/gl.c
+++ b/src/rendering/src/gl.c
@@ -216,16 +216,6 @@ GLenum ShaderBuffer_get_gl_access(u64 flags) {
     default: return GL_STATIC_DRAW;
   }
 }
-GLenum ShaderBuffer_get_gl_type(u64 flags) {
-  switch(flags & (0b111 << 6)) {
-    case ShaderBuffer_Type_vertexData:
-      return GL_ARRAY_BUFFER;
-    case ShaderBuffer_Type_vertexIndex:
-      return GL_ELEMENT_ARRAY_BUFFER;
-    default:
-      return GL_ARRAY_BUFFER;
-  }
-}
 
 RenderObject RenderObject_new(
     Shader* shader,
@@ -245,7 +235,7 @@ RenderObject RenderObject_new(
 
     gl->GenBuffers(1, &(buffers[i].buffername));
     gl->BindBuffer(GL_ARRAY_BUFFER, buffers[i].buffername);
-    gl->BufferData(GL_ARRAY_BUFFER, (isize)sz, buffers[i].data, GL_STATIC_DRAW);
+    gl->BufferData(GL_ARRAY_BUFFER, (isize)sz, buffers[i].data, ShaderBuffer_get_gl_accesstype(buffers[i].buffertype));
   }
 
   o.shader = *shader;
diff --git a/src/rendering/src/rendering.c b/src/rendering/src/rendering.c
index c2f8ab2..6f6e55b 100644
--- a/src/rendering/src/rendering.c
+++ b/src/rendering/src/rendering.c
@@ -25,16 +25,83 @@ ShaderBufferDataType_size(u16 flags) {
   case ShaderBuffer_DataType_nil: return 0;
   case ShaderBuffer_DataType_f32: return sizeof(f32);
   case ShaderBuffer_DataType_f64: return sizeof(f64);
+  case ShaderBuffer_DataType_i8:  return sizeof(i8);
+  case ShaderBuffer_DataType_i16: return sizeof(i16);
   case ShaderBuffer_DataType_i32: return sizeof(i32);
   case ShaderBuffer_DataType_i64: return sizeof(i64);
+  case ShaderBuffer_DataType_u8:  return sizeof(u8);
+  case ShaderBuffer_DataType_u16: return sizeof(u16);
+  case ShaderBuffer_DataType_u32: return sizeof(u32);
+  case ShaderBuffer_DataType_u64: return sizeof(u64);
   default: return 0;
   }
 }
 
-ShaderBufferFlag ShaderBuffer_get_access_frequency(u64 flags) { return flags & 0b111; }
+ShaderBufferFlag ShaderBuffer_get_access_frequency(u64 flags) { return flags & (0b111 << 0); }
 ShaderBufferFlag ShaderBuffer_get_access_type(u64 flags)      { return flags & (0b111 << 3); }
 ShaderBufferFlag ShaderBuffer_get_type(u64 flags)             { return flags & (0b111 << 6); }
-ShaderBufferFlag ShaderBuffer_get_data_type(u64 flags)        { return flags & (0b111 << 9); }
+ShaderBufferFlag ShaderBuffer_get_data_type(u64 flags)        { return flags & (0b1111 << 9); }
+
+u32 ShaderBuffer_get_gl_type(u64 flags) {
+  switch(ShaderBuffer_get_type(flags)) {
+    case ShaderBuffer_Type_vertexData:
+      return GL_ARRAY_BUFFER;
+    case ShaderBuffer_Type_vertexIndex:
+      return GL_ELEMENT_ARRAY_BUFFER;
+    default:
+      return GL_ARRAY_BUFFER;
+  }
+}
+
+
+u32 ShaderBuffer_get_gl_accesstype(u64 flags) {
+  switch (ShaderBuffer_get_access_frequency(flags)) {
+    case ShaderBuffer_AccessFrequency_stream:
+      switch (ShaderBuffer_get_access_type(flags)) {
+        case ShaderBuffer_AccessType_draw: return GL_STREAM_DRAW;
+        case ShaderBuffer_AccessType_read: return GL_STREAM_READ;
+        case ShaderBuffer_AccessType_copy: return GL_STREAM_COPY;
+        default: return 0;
+      }
+
+    case ShaderBuffer_AccessFrequency_static:
+      switch (ShaderBuffer_get_access_type(flags)) {
+        case ShaderBuffer_AccessType_draw: return GL_STATIC_DRAW;
+        case ShaderBuffer_AccessType_read: return GL_STATIC_READ;
+        case ShaderBuffer_AccessType_copy: return GL_STATIC_COPY;
+        default: return 0;
+      }
+    case ShaderBuffer_AccessFrequency_dynamic:
+      switch (ShaderBuffer_get_access_type(flags)) {
+        case ShaderBuffer_AccessType_draw: return GL_DYNAMIC_DRAW;
+        case ShaderBuffer_AccessType_read: return GL_DYNAMIC_READ;
+        case ShaderBuffer_AccessType_copy: return GL_DYNAMIC_COPY;
+        default: return 0;
+      }
+    default: return 0;
+  }
+}
+
+ShaderBufferFlag ShaderBuffer_get_gl_datatype(u64 flags) {
+  switch (ShaderBuffer_get_data_type(flags)) {
+    case ShaderBuffer_DataType_nil: return GL_NONE;
+
+    case ShaderBuffer_DataType_f32: return GL_FLOAT;
+    case ShaderBuffer_DataType_f64: return GL_DOUBLE;
+
+    case ShaderBuffer_DataType_i8:  return GL_BYTE;
+    case ShaderBuffer_DataType_i16: return GL_SHORT;
+    case ShaderBuffer_DataType_i32: return GL_INT;
+    case ShaderBuffer_DataType_i64: return GL_INT64_ARB;
+
+    case ShaderBuffer_DataType_u8:  return GL_UNSIGNED_BYTE;
+    case ShaderBuffer_DataType_u16: return GL_UNSIGNED_SHORT;
+    case ShaderBuffer_DataType_u32: return GL_UNSIGNED_INT;
+    case ShaderBuffer_DataType_u64: return GL_UNSIGNED_INT64_ARB;
+
+    default: return GL_NONE;
+  }
+}
 
 // `RenderBatch` is used for batch rendering. The struct is used as a
 // "management" parent structure to keep track of multiple `RenderObject`s that
@@ -46,6 +113,27 @@ ShaderBufferFlag ShaderBuffer_get_data_type(u64 flags)        { return flags & (
 
 // renderbatch_new: Create a new render batch with space for `count` models.
 int renderbatch_new(RenderBatch* renderbatch, usize count) {
+  /* TODO: Make it such that you can add identical models with different
+   * transforms, so you instead of relying on renderobject[n] to copy to the
+   * renderobject we have something like
+   *
+   * model {
+   *  renderobj_idx // index in renderobj[n] that this model represents
+   *  transform {
+   *    size;
+   *    pos;
+   *    rotation;
+   *  };
+   * } ;
+   *
+   * For this to work we will likely need to extend the shaderbuffer struct to
+   * also hold what type of data the buffer contains, s.t. we can apply the
+   * transformation to only geometry data.
+   *
+   * We'll therefore have both data type and buffer type stored somehow,
+   * maybe like we did the ShaderBufferDataType.
+   * TODO: Also use shaderbuffertype.
+   * */
   if (renderbatch == NULL) {
     ERROR("renderbatch was null!");
     return -1;
@@ -288,12 +376,18 @@ void render_present(Window* w) {
         gl->EnableVertexAttribArray((u32)i);
         gl->BindBuffer(GL_ARRAY_BUFFER, o->buffer[i].buffername);
         gl->VertexAttribPointer(
-            (u32)i,                  // ...
-            (i32)o->buffer[i].components,                  // size
-            GL_FLOAT,           // type
-            GL_FALSE,           // normalized?
-            0,                  // stride
-            (void*)0            // array buffer offset
+            // index of the attribute
+            (u32)i,
+            // number of component
+            (i32)o->buffer[i].components,
+            // type
+            ShaderBuffer_get_gl_datatype(o->buffer[i].buffertype),
+            // normalized?
+            GL_FALSE,
+            // stride
+            0,
+            // array buffer offset
+            (void*)0
             );
       }