summaryrefslogtreecommitdiff
path: root/src/rendering
diff options
context:
space:
mode:
Diffstat (limited to 'src/rendering')
-rw-r--r--src/rendering/include/engine/rendering/rendering.h23
-rw-r--r--src/rendering/src/gl.c12
-rw-r--r--src/rendering/src/rendering.c110
3 files changed, 124 insertions, 21 deletions
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
);
}
generated by cgit v1.3 (git 2.53.0) at 2026-05-23 19:39:52 +0000