summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMakeLists.txt2
-rw-r--r--src/rendering/include/engine/rendering/rendering.h45
-rw-r--r--src/rendering/src/gl.c49
-rw-r--r--src/rendering/src/rendering.c31
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
generated by cgit v1.3 (git 2.53.0) at 2026-05-23 16:12:27 +0000