From b37b5398a6afa940acd1138bde922a70838f33af Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Fri, 4 Jul 2025 10:37:01 -0700 Subject: Add the new low-level renderer, shared between the imm and scene graph renderer. LLR integration with the scene graph renderer not yet done. --- src/llr/light.c | 2 +- src/llr/llr.c | 329 +++++++++++------------------------------------- src/llr/llr_impl.h | 67 ++++------ src/llr/material.c | 2 +- src/llr/material_impl.h | 5 +- src/llr/mesh.c | 2 +- 6 files changed, 103 insertions(+), 304 deletions(-) (limited to 'src/llr') diff --git a/src/llr/light.c b/src/llr/light.c index 168f16a..1d1c40d 100644 --- a/src/llr/light.c +++ b/src/llr/light.c @@ -1,4 +1,4 @@ -#include "../scene/light_impl.h" +#include "light_impl.h" #include "../scene/node_impl.h" #include "../scene/scene_memory.h" diff --git a/src/llr/llr.c b/src/llr/llr.c index 62a7c30..746f4b3 100644 --- a/src/llr/llr.c +++ b/src/llr/llr.c @@ -1,17 +1,14 @@ -#include "imm_renderer_impl.h" #include "light_impl.h" +#include "llr_impl.h" #include "mesh_impl.h" +#include "llr/material_impl.h" #include "scene/animation_impl.h" #include #include -#include - -#include #include -#include // memcpy static const int IRRADIANCE_MAP_WIDTH = 1024; static const int IRRADIANCE_MAP_HEIGHT = 1024; @@ -21,7 +18,7 @@ static const int BRDF_INTEGRATION_MAP_WIDTH = 512; static const int BRDF_INTEGRATION_MAP_HEIGHT = 512; /// Initialize renderer state for IBL. -static bool init_ibl(ImmRenderer* renderer) { +static bool init_ibl(LLR* renderer) { assert(renderer); assert(!renderer->ibl); assert(!renderer->brdf_integration_map); @@ -44,8 +41,7 @@ static bool init_ibl(ImmRenderer* renderer) { // /// Compute irradiance and prefiltered environment maps for the light if they /// have not been already computed. -static bool set_up_environment_light( - ImmRenderer* renderer, EnvironmentLight* light) { +static bool set_up_environment_light(LLR* renderer, EnvironmentLight* light) { assert(renderer); assert(light); assert(renderer->ibl); @@ -92,7 +88,7 @@ cleanup: return false; } -static void configure_light(ImmRenderer* renderer, Light* light) { +static void configure_light(LLR* renderer, Light* light) { assert(renderer); assert(light); @@ -127,20 +123,35 @@ static void configure_light(ImmRenderer* renderer, Light* light) { } } -static void configure_state(ImmRenderer* renderer) { +static void configure_state(LLR* renderer) { assert(renderer); // Check if anything changed first so that we don't call gfx_apply_uniforms() // unnecessarily. - const bool anything_changed = - renderer->camera_changed || renderer->lights_changed || - renderer->skeleton_changed || renderer->shader_changed; - if (!anything_changed) { + const bool nothing_changed = (renderer->changed_flags == 0); + if (nothing_changed) { + return; + } + // Setting a null shader is also allowed, in which case there is nothing to + // configure. + if (renderer->shader == 0) { + renderer->shader_changed = false; return; } // For convenience. ShaderProgram* const shader = renderer->shader; + const mat4* const model = &renderer->matrix_stack[renderer->stack_pointer]; + + // TODO: Check to see which ones the shader actually uses and avoid + // computing the unnecessary matrices. + + if (renderer->matrix_changed || renderer->shader_changed) { + renderer->matrix_changed = false; + + gfx_set_mat4_uniform(shader, "Model", model); + gfx_set_mat4_uniform(shader, "ModelMatrix", model); + } // TODO: camera_changed is not set anywhere. Need to think how imm primitive // rendering and imm mesh rendering work together. We could treat imm @@ -150,14 +161,10 @@ static void configure_state(ImmRenderer* renderer) { // Set all supported camera-related uniforms. Shaders can choose which ones // to use. - // TODO: Check to see which ones the shader actually uses and avoid - // computing the unnecessary matrices. - const mat4* const model = &renderer->matrix_stack[renderer->stack_pointer]; - const mat4 modelview = mat4_mul(renderer->view, *model); + const mat4 modelview = mat4_mul(renderer->view, *model); const mat4 view_proj = mat4_mul(renderer->projection, renderer->view); const mat4 mvp = mat4_mul(renderer->projection, modelview); - gfx_set_mat4_uniform(shader, "ModelMatrix", model); gfx_set_mat4_uniform(shader, "Modelview", &modelview); gfx_set_mat4_uniform(shader, "View", &renderer->view); gfx_set_mat4_uniform(shader, "Projection", &renderer->projection); @@ -195,58 +202,26 @@ static void configure_state(ImmRenderer* renderer) { gfx_apply_uniforms(renderer->shader); } -bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore) { +bool gfx_llr_make(LLR* renderer, GfxCore* gfxcore) { assert(renderer); assert(gfxcore); - const size_t num_triangle_verts = IMM_MAX_NUM_TRIANGLES * 3; - renderer->gfxcore = gfxcore; - - renderer->triangles = gfx_make_geometry( - gfxcore, - &(GeometryDesc){.type = Triangles, - .buffer_usage = BufferDynamic, - .num_verts = num_triangle_verts, - .positions3d = (BufferView3d){ - .size_bytes = num_triangle_verts * sizeof(vec3)}}); - if (!renderer->triangles) { - goto cleanup; - } - - renderer->imm_shader = gfx_make_immediate_mode_shader(gfxcore); - if (!renderer->imm_shader) { - goto cleanup; - } - renderer->shader = renderer->imm_shader; - if (!init_ibl(renderer)) { goto cleanup; } - - gfx_imm_load_identity(renderer); - gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f)); - + gfx_llr_load_identity(renderer); return true; cleanup: - gfx_imm_destroy(renderer); + gfx_llr_destroy(renderer); return false; } -void gfx_imm_destroy(ImmRenderer* renderer) { +void gfx_llr_destroy(LLR* renderer) { assert(renderer); assert(renderer->gfxcore); - if (renderer->triangles) { - gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles); - // TODO: Could also destroy the geometry's buffers here. - } - - if (renderer->imm_shader) { - gfx_destroy_shader_program(renderer->gfxcore, &renderer->imm_shader); - } - if (renderer->brdf_integration_map) { gfx_destroy_texture(renderer->gfxcore, &renderer->brdf_integration_map); } @@ -257,43 +232,9 @@ void gfx_imm_destroy(ImmRenderer* renderer) { } } -void gfx_imm_flush(ImmRenderer* renderer) { - assert(renderer); - - if (renderer->num_triangle_verts > 0) { - configure_state(renderer); - - gfx_update_geometry( - renderer->triangles, - &(GeometryDesc){ - .num_verts = renderer->num_triangle_verts, - .positions3d = (BufferView3d){ - .data = renderer->triangle_verts, - .size_bytes = renderer->num_triangle_verts * sizeof(vec3)} - }); - - gfx_apply_uniforms(renderer->shader); - gfx_render_geometry(renderer->triangles); - - renderer->num_triangle_verts = 0; - } -} - -void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) { +void gfx_llr_set_shader(LLR* renderer, ShaderProgram* shader) { assert(renderer); - assert(shader); - - // TODO: It would probably be best to make the imm renderer work in terms of a - // new LLR renderer. Otherwise we need to constantly flush stuff everywhere - // "just in case". This would still allow the imm to render meshes with - // lighting etc. We just need to create an actual Mesh out of the 'triangles' - // Geometry that imm currently has. The change would greatly simplify the - // implementation of this otherwise coupled LLR-IMM renderer. - // Need to decide where to put the matrix stack manipulation. Might be good - // to move to the LLR. (Currently, manipulating the stack causes an imm - // flush, but that's because we have coupled imm with stack manipulation, - // which the new design seems like would address.) - gfx_imm_flush(renderer); + // null shader is allowed, so do not assert it. // It's important to not set shader_changed unnecessarily, since that would // re-trigger the setting of uniforms. @@ -303,36 +244,17 @@ void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) { } } -void gfx_imm_start(ImmRenderer* renderer) { - assert(renderer); - - // Shader uniforms are applied lazily. - // TODO: In the event that gfx_activate_shader_program() activates uniforms - // automatically for convenience, call an overload here that doesn't do so. - gfx_activate_shader_program(renderer->shader); -} - -void gfx_imm_end(ImmRenderer* renderer) { - assert(renderer); - - gfx_imm_flush(renderer); - gfx_deactivate_shader_program(renderer->shader); - - // TODO: Should we clear all of the render state here as well? At least set - // the 'changed' variables to false, for example. -} - -void gfx_imm_push_light(ImmRenderer* renderer, Light* light) { +void gfx_llr_push_light(LLR* renderer, Light* light) { assert(renderer); assert(light); assert(renderer->num_lights >= 0); - ASSERT(renderer->num_lights < IMM_MAX_NUM_LIGHTS); + ASSERT(renderer->num_lights < GFX_LLR_MAX_NUM_LIGHTS); renderer->lights[renderer->num_lights++] = light; renderer->lights_changed = true; } -void gfx_imm_pop_light(ImmRenderer* renderer) { +void gfx_llr_pop_light(LLR* renderer) { assert(renderer); ASSERT(renderer->num_lights > 0); @@ -340,8 +262,8 @@ void gfx_imm_pop_light(ImmRenderer* renderer) { renderer->lights_changed = true; } -void gfx_imm_set_skeleton( - ImmRenderer* renderer, const Anima* anima, const Skeleton* skeleton) { +void gfx_llr_set_skeleton( + LLR* renderer, const Anima* anima, const Skeleton* skeleton) { assert(renderer); assert(anima); assert(skeleton); @@ -356,150 +278,73 @@ void gfx_imm_set_skeleton( renderer->skeleton_changed = true; } -void gfx_imm_unset_skeleton(ImmRenderer* renderer) { +void gfx_llr_unset_skeleton(LLR* renderer) { assert(renderer); renderer->num_joints = 0; renderer->skeleton_changed = true; } -void gfx_imm_render_mesh(ImmRenderer* renderer, const Mesh* mesh) { - assert(renderer); - assert(mesh); - assert(mesh->geometry); - assert(mesh->material); - - configure_state(renderer); - gfx_render_geometry(mesh->geometry); -} - -void gfx_imm_draw_triangles( - ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) { +void gfx_llr_set_camera(LLR* renderer, const Camera* camera) { assert(renderer); - assert(verts); - const size_t new_verts = num_triangles * 3; - assert( - renderer->num_triangle_verts + new_verts < (IMM_MAX_NUM_TRIANGLES * 3)); - - memcpy( - renderer->triangle_verts + renderer->num_triangle_verts, verts, - new_verts * sizeof(vec3)); - renderer->num_triangle_verts += new_verts; -} - -void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) { - gfx_imm_draw_triangles(renderer, verts, 1); + const mat4 view = spatial3_inverse_transform(&camera->spatial); + // const mat4 view_proj = mat4_mul(camera->projection, view); + // gfx_llr_set_view_projection_matrix(renderer, &view_proj); + renderer->view = view; + renderer->projection = camera->projection; + renderer->camera_changed = true; } -void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) { - assert(renderer); - - // clang-format off - const vec3 verts[4] = { - vec3_make(box.min.x, box.min.y, 0), // 3 ---- 2 - vec3_make(box.max.x, box.min.y, 0), // | | - vec3_make(box.max.x, box.max.y, 0), // | | - vec3_make(box.min.x, box.max.y, 0)}; // 0 ---- 1 - // clang-format on - -#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2] - const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)}; -#undef tri - - gfx_imm_draw_triangles(renderer, tris, 2); -} +// void gfx_llr_set_view_projection_matrix( +// LLR* renderer, const mat4* view_proj) { +// assert(renderer); +// assert(renderer->shader); +// +// gfx_llr_flush(renderer); +// gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj); +// } -void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) { +void gfx_llr_render_geometry(LLR* renderer, const Geometry* geometry) { assert(renderer); + assert(geometry); - // clang-format off - const vec3 vertices[8] = { - vec3_make(box.min.x, box.min.y, box.max.z), // 7 ----- 6 - vec3_make(box.max.x, box.min.y, box.max.z), // / /| - vec3_make(box.max.x, box.max.y, box.max.z), // 3 ----- 2 | - vec3_make(box.min.x, box.max.y, box.max.z), // | | | - vec3_make(box.min.x, box.min.y, box.min.z), // | 4 ----- 5 - vec3_make(box.max.x, box.min.y, box.min.z), // |/ |/ - vec3_make(box.max.x, box.max.y, box.min.z), // 0 ----- 1 - vec3_make(box.min.x, box.max.y, box.min.z)}; - // clang-format on - - gfx_imm_draw_box3(renderer, vertices); -} - -void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) { - assert(renderer); - assert(vertices); - - // 7 ----- 6 - // / /| - // 3 ----- 2 | - // | | | - // | 4 ----- 5 - // |/ |/ - // 0 ----- 1 - -#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2] - const vec3 tris[36] = { - // Front. - tri(0, 1, 2), tri(0, 2, 3), - // Right. - tri(1, 5, 6), tri(1, 6, 2), - // Back. - tri(5, 4, 7), tri(5, 7, 6), - // Left. - tri(4, 0, 03), tri(4, 3, 7), - // Top. - tri(3, 2, 6), tri(3, 6, 7), - // Bottom. - tri(0, 4, 5), tri(0, 5, 1)}; - - gfx_imm_draw_triangles(renderer, tris, 12); + configure_state(renderer); + gfx_render_geometry(geometry); } -void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) { +void gfx_llr_render_mesh(LLR* renderer, const Mesh* mesh) { assert(renderer); assert(renderer->shader); + assert(mesh); + assert(mesh->geometry); + assert(mesh->material); - gfx_imm_flush(renderer); - - gfx_set_vec4_uniform(renderer->shader, "Colour", colour); -} - -// Load the top of the matrix stack into the shader. -static void update_shader_model_matrix(ImmRenderer* renderer) { - assert(renderer); - - gfx_imm_flush(renderer); - - gfx_set_mat4_uniform( - renderer->shader, "Model", - &renderer->matrix_stack[renderer->stack_pointer]); + gfx_material_activate(renderer->shader, mesh->material); + gfx_llr_render_geometry(renderer, mesh->geometry); } -void gfx_imm_load_identity(ImmRenderer* renderer) { +void gfx_llr_load_identity(LLR* renderer) { assert(renderer); renderer->matrix_stack[0] = mat4_id(); renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) { +void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix) { assert(renderer); assert(matrix); assert(renderer->stack_pointer >= 0); - ASSERT(renderer->stack_pointer < IMM_MAX_NUM_MATRICES); + ASSERT(renderer->stack_pointer < GFX_LLR_MAX_NUM_MATRICES); renderer->stack_pointer += 1; renderer->matrix_stack[renderer->stack_pointer] = mat4_mul(*matrix, renderer->matrix_stack[renderer->stack_pointer - 1]); - - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_pop_matrix(ImmRenderer* renderer) { +void gfx_llr_pop_matrix(LLR* renderer) { assert(renderer); ASSERT(renderer->stack_pointer > 0); @@ -508,47 +353,21 @@ void gfx_imm_pop_matrix(ImmRenderer* renderer) { &renderer->matrix_stack[renderer->stack_pointer], 0, sizeof(renderer->matrix_stack[0])); renderer->stack_pointer -= 1; - - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) { +void gfx_llr_translate(LLR* renderer, vec3 offset) { assert(renderer); const mat4 mat = mat4_translate(offset); - gfx_imm_push_matrix(renderer, &mat); + gfx_llr_push_matrix(renderer, &mat); } -void gfx_imm_set_model_matrix(ImmRenderer* renderer, const mat4* model) { +void gfx_llr_set_model_matrix(LLR* renderer, const mat4* model) { assert(renderer); assert(model); - gfx_imm_flush(renderer); - renderer->matrix_stack[0] = *model; renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } - -void gfx_imm_set_camera(ImmRenderer* renderer, const Camera* camera) { - assert(renderer); - assert(renderer->shader); - - gfx_imm_flush(renderer); - - const mat4 view = spatial3_inverse_transform(&camera->spatial); - // const mat4 view_proj = mat4_mul(camera->projection, view); - // gfx_imm_set_view_projection_matrix(renderer, &view_proj); - renderer->view = view; - renderer->projection = camera->projection; - renderer->camera_changed = true; -} - -// void gfx_imm_set_view_projection_matrix( -// ImmRenderer* renderer, const mat4* view_proj) { -// assert(renderer); -// assert(renderer->shader); -// -// gfx_imm_flush(renderer); -// gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj); -// } diff --git a/src/llr/llr_impl.h b/src/llr/llr_impl.h index 5ccabd1..e9dc0ac 100644 --- a/src/llr/llr_impl.h +++ b/src/llr/llr_impl.h @@ -8,6 +8,7 @@ #include #include +#include typedef struct Geometry Geometry; typedef struct GfxCore GfxCore; @@ -33,67 +34,47 @@ typedef struct Texture Texture; /// Note that the shader program API has its own level of caching as well, so /// reconfiguration at the level of the renderer does not result in the /// worst-case set of graphics API calls. -/// -/// Currently, the immediate mode renderer can only draw up to a maximum number -/// of primitives per frame. It does not adjust this number dynamically. Keeps -/// things simple while the extra complexity is not needed. -/// TODO: Flush the buffer when it reaches its maximum size to remove this -/// constraint. -typedef struct ImmRenderer { +typedef struct LLR { GfxCore* gfxcore; - vec3 camera_position; - mat4 view; // Camera view matrix. - mat4 projection; // Camera projection matrix. - bool camera_changed; // Whether the camera parameters have changed. - - // ------------------------------------------- - // Immediate-mode rendering of scene elements. + union { + struct { + bool shader_changed : 1; // Whether the shader has changed. + bool camera_changed : 1; // Whether the camera parameters have changed. + bool lights_changed : 1; // Whether the lights have changed. + bool skeleton_changed : 1; // Whether the skeleton has changed. + bool matrix_changed : 1; // Whether the matrix stack has changed. + }; + uint8_t changed_flags; + }; IBL* ibl; Texture* brdf_integration_map; - ShaderProgram* shader; // Active shader. Not owned. - bool shader_changed; // Whether the shader has changed. + ShaderProgram* shader; // Active shader. Not owned. + + vec3 camera_position; + mat4 view; // Camera view matrix. + mat4 projection; // Camera projection matrix. // Lights are not const because environment lights store lazily-computed // irradiance maps. - Light* lights[IMM_MAX_NUM_LIGHTS]; // Lights stack. - int num_lights; // Number of lights enabled at a given point in time. It - // points to one past the top of the stack. - bool lights_changed; // Whether the lights have changed. + Light* lights[GFX_LLR_MAX_NUM_LIGHTS]; // Lights stack. + int num_lights; // Number of lights enabled at a given point in time. It + // points to one past the top of the stack. - bool skeleton_changed; size_t num_joints; mat4 joint_matrices[GFX_MAX_NUM_JOINTS]; - // --------------------------------------- - // Immediate-mode rendering of primitives. - - ShaderProgram* imm_shader; // Immediate-mode shader program for primitives. - Geometry* triangles; - size_t num_triangle_verts; // Number of triangle verts this frame. - // TODO: wireframe rendering. - struct { - bool wireframe : 1; - } flags; - vec3 triangle_verts[IMM_MAX_NUM_TRIANGLES * 3]; - - // ------------- - // Matrix stack. - // The matrix stack contains pre-multiplied matrices. // It is also never empty. The top of the stack is an identity matrix when the // stack is "empty" from the user's perspective. - mat4 matrix_stack[IMM_MAX_NUM_MATRICES]; + mat4 matrix_stack[GFX_LLR_MAX_NUM_MATRICES]; int stack_pointer; // Points to the top of the stack. -} ImmRenderer; +} LLR; /// Create a new immediate mode renderer. -bool gfx_imm_make(ImmRenderer*, GfxCore*); +bool gfx_llr_make(LLR*, GfxCore*); /// Destroy the immediate mode renderer. -void gfx_imm_destroy(ImmRenderer*); - -/// Flush draw commands. -void gfx_imm_flush(ImmRenderer*); +void gfx_llr_destroy(LLR*); diff --git a/src/llr/material.c b/src/llr/material.c index 47cb45f..4014482 100644 --- a/src/llr/material.c +++ b/src/llr/material.c @@ -48,7 +48,7 @@ static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) { } } -void material_activate(ShaderProgram* shader, const Material* material) { +void gfx_material_activate(ShaderProgram* shader, const Material* material) { assert(material); for (int i = 0; i < material->num_uniforms; ++i) { const ShaderUniform* uniform = &material->uniforms[i]; diff --git a/src/llr/material_impl.h b/src/llr/material_impl.h index f27bf4d..138497f 100644 --- a/src/llr/material_impl.h +++ b/src/llr/material_impl.h @@ -11,6 +11,5 @@ typedef struct Material { /// Activate the material. /// -/// This activates the material's shader and configures the shader uniforms that -/// are specific to the material. -void material_activate(ShaderProgram* shader, const Material* material); +/// This configures the shader uniforms that are specific to the material. +void gfx_material_activate(ShaderProgram* shader, const Material* material); diff --git a/src/llr/mesh.c b/src/llr/mesh.c index ae75d8c..3aebb04 100644 --- a/src/llr/mesh.c +++ b/src/llr/mesh.c @@ -1,4 +1,4 @@ -#include "../scene/mesh_impl.h" +#include "mesh_impl.h" #include "../scene/scene_memory.h" -- cgit v1.2.3