Try squishing shader buffer info into a single i32

4 files changed, 103 insertions, 24 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f6ce42c..fda13ba 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,7 +37,7 @@ cmake_dependent_option(DAW_BUILD_UBSAN
   "Compile daw engine with undefined behaviour sanitizer (ubsan)" ON
   "DAW_BUILD_DEBUG;UBSAN" OFF)
 
-# unused
+# Unused
 cmake_dependent_option(DAW_BUILD_TOOLS
   "Build tools to manipulate a daw project" ON
   "CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME" OFF)
diff --git a/src/rendering/include/engine/rendering/rendering.h b/src/rendering/include/engine/rendering/rendering.h
index 2246601..25e3e8a 100644
--- a/src/rendering/include/engine/rendering/rendering.h
+++ b/src/rendering/include/engine/rendering/rendering.h
@@ -58,38 +58,56 @@ typedef struct {
 } Shader;
 
 typedef enum {
-  ShaderBufferDataType_nil,
+  ShaderBufferFlag_none = 0x00,
 
-  ShaderBufferDataType_f32,
-  ShaderBufferDataType_f64,
+  // First 3 bytes describe the access frequency.
+  ShaderBuffer_AccessFrequency_stream  = 0b0000000000001, // 1
+  ShaderBuffer_AccessFrequency_static  = 0b0000000000010, // 2
+  ShaderBuffer_AccessFrequency_dynamic = 0b0000000000011, // 3
 
-  ShaderBufferDataType_i32,
-  ShaderBufferDataType_i64,
-} ShaderBufferDataType;
+  // Next 3 bytes describe the access type.
+  ShaderBuffer_AccessType_draw         = 0b0000000001000, //  8
+  ShaderBuffer_AccessType_read         = 0b0000000010000, // 16
+  ShaderBuffer_AccessType_copy         = 0b0000000011000, // 24
+
+  // Next 3 bytes describe the buffer type
+  ShaderBuffer_Type_vertexData         = 0b0000001000000, // 64
+  ShaderBuffer_Type_vertexIndex        = 0b0000010000000, // 128
+
+  // Next 4 bytes are designated for the data type
+  ShaderBuffer_DataType_nil            = 0b0001000000000, //  512
+
+  ShaderBuffer_DataType_f32            = 0b0010000000000, // 1024
+  ShaderBuffer_DataType_f64            = 0b0011000000000, // 1536
+
+  ShaderBuffer_DataType_i32            = 0b0100000000000, // 2048
+  ShaderBuffer_DataType_i64            = 0b0101000000000, // 2560
+} ShaderBufferFlag;
 
 typedef struct {
   // The backend ID, ie. glGenBuffer(numBufferObjects, &this->buffername)
   u32 buffername;
+  // Array, access, and data, type.
+  u32 buffertype;
   // Buffer size of `data`. To get the size of the actual data, size_elem * count
   isize size;
   // Number of elements
   isize count;
   // components per generic vertex attribute (ie, 3 for RGB, 2 for UV)
   isize components;
-  // Type & size of each element
-  ShaderBufferDataType datatype;
+  // size of each element
   isize size_elem;
   // Pointer to the data
   void* data;
 } ShaderBuffer;
 
-#define SHADERBUFFER_NEW(T, COUNT, COMPONENTS, DATA) \
+#define SHADERBUFFER_NEW(T, COUNT, COMPONENTS, DATA, FLAGS) \
   (ShaderBuffer){ \
     .buffername = 0, \
+    .buffertype = ShaderBuffer_DataType_##T | FLAGS, \
     .size = COUNT * sizeof(T), \
     .count = COUNT, \
     .components = COMPONENTS, \
-    .datatype = ShaderBufferDataType_##T, \
     .size_elem = sizeof(T), \
     .data = DATA, \
   }
@@ -153,7 +171,12 @@ typedef struct {
 
 } Camera;
 
-const usize ShaderBufferDataType_size(ShaderBufferDataType t);
+const usize ShaderBufferDataType_size(u16 flags);
+
+ShaderBufferFlag ShaderBuffer_get_access_frequency(u64 flags);
+ShaderBufferFlag ShaderBuffer_get_access_type(u64 flags);
+ShaderBufferFlag ShaderBuffer_get_type(u64 flags);
+ShaderBufferFlag ShaderBuffer_get_data_type(u64 flags);
 
 /* Rendering functions */
 void render_begin(Window* w);
diff --git a/src/rendering/src/gl.c b/src/rendering/src/gl.c
index 7a04dbb..947d3ba 100644
--- a/src/rendering/src/gl.c
+++ b/src/rendering/src/gl.c
@@ -186,6 +186,45 @@ void shaders_delete(Shader* shader, isize shader_len) {
   }
 }
 
+GLenum ShaderBuffer_get_gl_access(u64 flags) {
+  const ShaderBufferFlag access = ShaderBuffer_get_access_type(flags);
+
+  switch(flags & 0b111) {
+    case ShaderBuffer_AccessFrequency_stream:
+      switch(access) {
+        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 GL_STREAM_DRAW;
+      }
+    case ShaderBuffer_AccessFrequency_static:
+      switch(access) {
+        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 GL_STATIC_DRAW;
+      }
+    case ShaderBuffer_AccessFrequency_dynamic:
+      switch(access) {
+        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 GL_DYNAMIC_DRAW;
+      }
+    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,
     u32 texture,
@@ -207,17 +246,21 @@ RenderObject RenderObject_new(
     gl->BufferData(GL_ARRAY_BUFFER, sz, buffers[i].data, GL_STATIC_DRAW);
   }
 
+  o.mvp = gl->GetUniformLocation(o.shader.program, "MVP");
+
+  gl->BindVertexArray(0);
+
   o.shader = *shader;
   o.texture = texture;
   o.buffer = buffers;
   o.buffer_len = num_buffers;
-  o.mvp = gl->GetUniformLocation(o.shader.program, "MVP");
-
-  gl->BindVertexArray(0);
 
   return o;
 }
 
+void RenderObject_generateBuffers(RenderObject *o) {
+}
+
 ShaderType guess_shadertype_from_filename(const char *restrict fname) {
   u32 stype = 0;
   const usize path_len = strlen(fname);
diff --git a/src/rendering/src/rendering.c b/src/rendering/src/rendering.c
index 1ce3997..d6d440f 100644
--- a/src/rendering/src/rendering.c
+++ b/src/rendering/src/rendering.c
@@ -19,17 +19,23 @@ RenderDrawCall drawcalls[drawcall_limit];
 i32 drawcall_len = 0;
 
 const usize
-ShaderBufferDataType_size(ShaderBufferDataType t) {
+ShaderBufferDataType_size(u16 flags) {
+  const ShaderBufferFlag t = ShaderBuffer_get_data_type(flags);
   switch (t) {
-  case ShaderBufferDataType_nil: return 0;
-  case ShaderBufferDataType_f32: return sizeof(f32);
-  case ShaderBufferDataType_f64: return sizeof(f64);
-  case ShaderBufferDataType_i32: return sizeof(i32);
-  case ShaderBufferDataType_i64: return sizeof(i64);
+  case ShaderBuffer_DataType_nil: return 0;
+  case ShaderBuffer_DataType_f32: return sizeof(f32);
+  case ShaderBuffer_DataType_f64: return sizeof(f64);
+  case ShaderBuffer_DataType_i32: return sizeof(i32);
+  case ShaderBuffer_DataType_i64: return sizeof(i64);
   default: return 0;
   }
 }
 
+ShaderBufferFlag ShaderBuffer_get_access_frequency(u64 flags) { return flags & 0b111; }
+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); }
+
 // `RenderBatch` is used for batch rendering. The struct is used as a
 // "management" parent structure to keep track of multiple `RenderObject`s that
 // are put into a final `RenderObject` to render.
@@ -76,8 +82,15 @@ int renderbatch_new(RenderBatch* renderbatch, isize count) {
 // Appends the data in src onto dst. More space for `data` is allocated if
 // necessary, in which case a pointer to the new ShaderBuffer is returned.
 ShaderBuffer* shaderbuffer_cat(ShaderBuffer* dst, ShaderBuffer *restrict src) {
-  if (dst->datatype != src->datatype) {
-    ERROR("Failed to concatenate shader buffers, incompatible datatypes: %d != %d", dst->datatype, src->datatype);
+  if (dst == NULL) {
+    ERROR("dst is null");
+  }
+  else if (src == NULL) {
+    ERROR("src is null");
+  }
+
+  if (ShaderBuffer_get_data_type(dst->buffertype) != ShaderBuffer_get_data_type(src->buffertype)) {
+    ERROR("Failed to concatenate shader buffers, incompatible datatypes: %d != %d", dst->buffertype, src->buffertype);
   }
   if (dst->components != src->components) {
     ERROR("Failed to concatenate shader buffers, incompatible number of components: %d != %d", dst->components, src->components);
@@ -141,7 +154,7 @@ int renderbatch_add(RenderBatch* renderbatch, RenderObject* obj) {
 
       // Copy meta data
       renderbatch->renderobj.buffer[i].components = obj->buffer[i].components;
-      renderbatch->renderobj.buffer[i].datatype = obj->buffer[i].datatype;
+      renderbatch->renderobj.buffer[i].buffertype = obj->buffer[i].buffertype;
       renderbatch->renderobj.buffer[i].size_elem = obj->buffer[i].size_elem;
 
       // Round up to nearest multiple of 4096 byte