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/asset/model.c | 5 +- src/core/core.c | 4 + src/gfx.c | 24 ++- 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 +- src/renderer/imm_renderer.c | 192 +++++++++++++++++++++++ src/renderer/imm_renderer_impl.h | 43 +++++ src/renderer/renderer.c | 46 ++++-- src/renderer/renderer_impl.h | 6 +- src/scene/node.c | 2 +- src/scene/object.c | 2 +- src/scene/object_impl.h | 2 - src/scene/scene_memory.c | 6 +- src/util/skyquad.c | 17 +- 18 files changed, 406 insertions(+), 350 deletions(-) create mode 100644 src/renderer/imm_renderer.c create mode 100644 src/renderer/imm_renderer_impl.h (limited to 'src') diff --git a/src/asset/model.c b/src/asset/model.c index 402b2e1..0c57470 100644 --- a/src/asset/model.c +++ b/src/asset/model.c @@ -84,13 +84,12 @@ #include "asset/texture.h" #include "gfx/core.h" #include "gfx/gfx.h" +#include "gfx/llr/material.h" +#include "gfx/llr/mesh.h" #include "gfx/scene/animation.h" #include "gfx/scene/camera.h" -#include "gfx/scene/material.h" -#include "gfx/scene/mesh.h" #include "gfx/scene/node.h" #include "gfx/scene/object.h" -#include "gfx/scene/scene.h" #include "gfx/sizes.h" #include "gfx/util/shader.h" diff --git a/src/core/core.c b/src/core/core.c index 90038c6..e1671ea 100644 --- a/src/core/core.c +++ b/src/core/core.c @@ -420,6 +420,10 @@ void gfx_destroy_shader_program(GfxCore* gfxcore, ShaderProgram** prog) { // Remove the shader program from the cache. ProgramCache* cache = &gfxcore->program_cache; ShaderProgramCacheEntry* entry = find_program_cache_entry(cache, *prog); + // TODO: The following assertion is too restrictive. Clients can end up + // re-using the same shader by virtue of the cache. The assertion assumes + // that no two "different" clients use the same set of shaders. This can + // be relaxed by reference-counting the shaders in the cache. assert(entry); // Must be there, shaders can't go untracked. mempool_free(cache, &entry); diff --git a/src/gfx.c b/src/gfx.c index cd2ac90..4291ae7 100644 --- a/src/gfx.c +++ b/src/gfx.c @@ -2,20 +2,20 @@ #include "asset/asset_cache.h" #include "core/core_impl.h" +#include "llr/llr_impl.h" #include "renderer/imm_renderer_impl.h" #include "renderer/renderer_impl.h" #include "scene/scene_memory.h" -#include - #include #include typedef struct Gfx { AssetCache asset_cache; GfxCore gfxcore; - Renderer renderer; + LLR llr; ImmRenderer imm_renderer; + Renderer renderer; } Gfx; Gfx* gfx_init(void) { @@ -24,16 +24,20 @@ Gfx* gfx_init(void) { return 0; } gfx_init_gfxcore(&gfx->gfxcore); - if (!renderer_make(&gfx->renderer, &gfx->gfxcore)) { + if (!gfx_llr_make(&gfx->llr, &gfx->gfxcore)) { gfx_destroy(&gfx); return 0; } - if (!imm_renderer_make(&gfx->imm_renderer, &gfx->gfxcore)) { + if (!gfx_imm_make(&gfx->imm_renderer, &gfx->gfxcore, &gfx->llr)) { // TODO: Add error logs to the initialization failure cases here and inside // the renderers. gfx_destroy(&gfx); return 0; } + if (!gfx_renderer_make(&gfx->renderer, &gfx->llr, &gfx->gfxcore)) { + gfx_destroy(&gfx); + return 0; + } gfx_init_asset_cache(&gfx->asset_cache); scene_mem_init(); return gfx; @@ -45,8 +49,9 @@ void gfx_destroy(Gfx** gfx) { } scene_mem_destroy(); gfx_destroy_asset_cache(&(*gfx)->asset_cache); - renderer_destroy(&(*gfx)->renderer); - imm_renderer_destroy(&(*gfx)->imm_renderer); + gfx_renderer_destroy(&(*gfx)->renderer); + gfx_imm_destroy(&(*gfx)->imm_renderer); + gfx_llr_destroy(&(*gfx)->llr); gfx_del_gfxcore(&(*gfx)->gfxcore); free(*gfx); *gfx = 0; @@ -67,6 +72,11 @@ ImmRenderer* gfx_get_imm_renderer(Gfx* gfx) { return &gfx->imm_renderer; } +LLR* gfx_get_llr(Gfx* gfx) { + assert(gfx); + return &gfx->llr; +} + AssetCache* gfx_get_asset_cache(Gfx* gfx) { assert(gfx); return &gfx->asset_cache; 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" diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c new file mode 100644 index 0000000..01cc5bb --- /dev/null +++ b/src/renderer/imm_renderer.c @@ -0,0 +1,192 @@ +#include "imm_renderer_impl.h" + +#include +#include +#include +#include + +#include + +#include +#include // memcpy + +bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore, LLR* llr) { + assert(renderer); + assert(gfxcore); + assert(llr); + + const size_t num_triangle_verts = GFX_IMM_MAX_NUM_TRIANGLES * 3; + + renderer->gfxcore = gfxcore; + renderer->llr = llr; + + 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->shader = gfx_make_immediate_mode_shader(gfxcore); + if (!renderer->shader) { + goto cleanup; + } + + gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f)); + + return true; + +cleanup: + gfx_imm_destroy(renderer); + return false; +} + +void gfx_imm_destroy(ImmRenderer* 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->shader) { + gfx_destroy_shader_program(renderer->gfxcore, &renderer->shader); + } +} + +void gfx_imm_flush(ImmRenderer* renderer) { + assert(renderer); + + if (renderer->num_triangle_verts > 0) { + 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_llr_render_geometry(renderer->llr, renderer->triangles); + + renderer->num_triangle_verts = 0; + } +} + +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); + gfx_llr_set_shader(renderer->llr, renderer->shader); +} + +void gfx_imm_end(ImmRenderer* renderer) { + assert(renderer); + + gfx_imm_flush(renderer); + // gfx_deactivate_shader_program(renderer->shader); + gfx_llr_set_shader(renderer->llr, 0); +} + +void gfx_imm_draw_triangles( + ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) { + assert(renderer); + assert(verts); + const size_t new_verts = num_triangles * 3; + assert( + renderer->num_triangle_verts + new_verts < + (GFX_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); +} + +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_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) { + assert(renderer); + + // 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); +} + +void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) { + assert(renderer); + assert(renderer->shader); + + gfx_imm_flush(renderer); + + gfx_set_vec4_uniform(renderer->shader, "Colour", colour); +} diff --git a/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h new file mode 100644 index 0000000..61b49a7 --- /dev/null +++ b/src/renderer/imm_renderer_impl.h @@ -0,0 +1,43 @@ +#pragma once + +#include + +#include + +#include +#include + +typedef struct Geometry Geometry; +typedef struct GfxCore GfxCore; +typedef struct IBL IBL; +typedef struct LLR LLR; +typedef struct Material Material; +typedef struct ShaderProgram ShaderProgram; +typedef struct Texture Texture; + +/// Immediate mode renderer. +/// +/// 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 { + GfxCore* gfxcore; + LLR* llr; + + ShaderProgram* 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[GFX_IMM_MAX_NUM_TRIANGLES * 3]; +} ImmRenderer; + +/// Create a new immediate mode renderer. +bool gfx_imm_make(ImmRenderer*, GfxCore*, LLR*); + +/// Destroy the immediate mode renderer. +void gfx_imm_destroy(ImmRenderer*); diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c index c2a7dda..0c1fe78 100644 --- a/src/renderer/renderer.c +++ b/src/renderer/renderer.c @@ -1,10 +1,10 @@ #include "renderer_impl.h" +#include "llr/light_impl.h" +#include "llr/material_impl.h" +#include "llr/mesh_impl.h" #include "scene/animation_impl.h" #include "scene/camera_impl.h" -#include "scene/light_impl.h" -#include "scene/material_impl.h" -#include "scene/mesh_impl.h" #include "scene/model_impl.h" #include "scene/node_impl.h" #include "scene/object_impl.h" @@ -12,16 +12,18 @@ #include "scene/scene_memory.h" #include +#include #include #include -#include +// #include +#include "gfx/gfx.h" + #include #include #include -// TODO: Move to a header like "constants.h". static const int IRRADIANCE_MAP_WIDTH = 1024; static const int IRRADIANCE_MAP_HEIGHT = 1024; static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH = 128; @@ -29,16 +31,18 @@ static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128; static const int BRDF_INTEGRATION_MAP_WIDTH = 512; static const int BRDF_INTEGRATION_MAP_HEIGHT = 512; -bool renderer_make(Renderer* renderer, GfxCore* gfxcore) { +bool gfx_renderer_make(Renderer* renderer, LLR* llr, GfxCore* gfxcore) { assert(renderer); + assert(llr); assert(gfxcore); renderer->gfxcore = gfxcore; + renderer->llr = llr; return true; } -void renderer_destroy(Renderer* renderer) { +void gfx_renderer_destroy(Renderer* renderer) { if (!renderer) { return; } @@ -117,9 +121,9 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) { // } // } -/// Computes irradiance and prefiltered environment maps for the light if they +/// Compute irradiance and prefiltered environment maps for the light if they /// have not been already computed. -static bool setup_environment_light( +static bool set_up_environment_light( Renderer* renderer, GfxCore* gfxcore, EnvironmentLight* light) { assert(renderer); assert(light); @@ -168,6 +172,7 @@ cleanup: typedef struct RenderState { GfxCore* gfxcore; + LLR* llr; Renderer* renderer; ShaderProgram* shader; // Null to use scene shaders. const Scene* scene; @@ -209,6 +214,7 @@ static void draw_recursively( // Anima. if (node->type == AnimaNode) { + // Save the anima so that we can animate objects. state->anima = gfx_get_node_anima(node); } // Activate light. @@ -217,7 +223,7 @@ static void draw_recursively( assert(light); if (light->type == EnvironmentLightType) { - bool result = setup_environment_light( + bool result = set_up_environment_light( state->renderer, state->gfxcore, &light->environment); // TODO: Handle the result in a better way. assert(result); @@ -238,11 +244,13 @@ static void draw_recursively( // TODO: Here we would frustum-cull the object. // TODO: Avoid computing matrices like Modelview or MVP if the shader does - // not use them. + // not use them. const mat4 model_matrix = node_transform; const mat4 modelview = mat4_mul(*state->view_matrix, model_matrix); const mat4 mvp = mat4_mul(*state->projection, modelview); + // A model/anima can have many skeletons. We need to animate the given + // object using its skeleton, not just any skeleton of the anima. if (object->skeleton.val) { load_skeleton(state, object->skeleton); } @@ -260,9 +268,11 @@ static void draw_recursively( assert(mesh->material); // TODO: Here we would frustum-cull the mesh. The AABB would have to be - // transformed by the model matrix. Rotation would make the AABB - // relatively large, but still, the culling would be conservative. + // transformed by the model matrix. Rotation would make the AABB + // relatively large, but still, the culling would be conservative. + // TODO: Make sure we strictly set only the uniforms that are required by + // mesh rendering. See the other item below. // Apply common shader uniforms not captured by materials. ShaderProgram* shader = state->shader ? state->shader : mesh->shader; gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix); @@ -270,7 +280,10 @@ static void draw_recursively( gfx_set_mat4_uniform(shader, "View", state->view_matrix); gfx_set_mat4_uniform(shader, "Projection", state->projection); gfx_set_mat4_uniform(shader, "MVP", &mvp); + // TODO: CameraRotation is only used by the skyquad and cubemap_filtering + // shaders, not mesh rendering. gfx_set_mat4_uniform(shader, "CameraRotation", state->camera_rotation); + // TODO: Fovy and Aspect are only used by the skyquad, not necessary here. gfx_set_float_uniform(shader, "Fovy", state->fovy); gfx_set_float_uniform(shader, "Aspect", state->aspect); if (state->camera) { @@ -297,9 +310,9 @@ static void draw_recursively( shader, "PrefilteredEnvironmentMap", light->prefiltered_environment_map); gfx_set_float_uniform( - shader, "MaxReflectionLOD", light->max_reflection_lod); + shader, "MaxReflectionLOD", (float)light->max_reflection_lod); } - material_activate(shader, mesh->material); + gfx_material_activate(shader, mesh->material); gfx_activate_shader_program(shader); gfx_apply_uniforms(shader); gfx_render_geometry(mesh->geometry); @@ -327,7 +340,7 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) { const Scene* scene = params->scene; const SceneCamera* camera = params->camera; - GfxCore* gfxcore = renderer->gfxcore; + GfxCore* const gfxcore = renderer->gfxcore; mat4 projection, camera_rotation, view_matrix; if (camera) { @@ -347,6 +360,7 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) { RenderState state = { .gfxcore = gfxcore, + .llr = renderer->llr, .renderer = renderer, .shader = shader, .scene = scene, diff --git a/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h index fc14dcb..6fd0c15 100644 --- a/src/renderer/renderer_impl.h +++ b/src/renderer/renderer_impl.h @@ -5,11 +5,13 @@ #include typedef struct IBL IBL; +typedef struct LLR LLR; typedef struct ShaderProgram ShaderProgram; typedef struct Texture Texture; typedef struct Renderer { GfxCore* gfxcore; + LLR* llr; IBL* ibl; Texture* brdf_integration_map; struct { @@ -21,7 +23,7 @@ typedef struct Renderer { } Renderer; /// Create a new renderer. -bool renderer_make(Renderer*, GfxCore*); +bool gfx_renderer_make(Renderer*, LLR*, GfxCore*); /// Destroy the renderer. -void renderer_destroy(Renderer*); +void gfx_renderer_destroy(Renderer*); diff --git a/src/scene/node.c b/src/scene/node.c index 67ce93c..e359f73 100644 --- a/src/scene/node.c +++ b/src/scene/node.c @@ -2,7 +2,7 @@ #include "animation_impl.h" #include "camera_impl.h" -#include "light_impl.h" +#include "llr/light_impl.h" #include "model_impl.h" #include "object_impl.h" #include "scene_graph.h" diff --git a/src/scene/object.c b/src/scene/object.c index e8e3ee6..27ff5db 100644 --- a/src/scene/object.c +++ b/src/scene/object.c @@ -2,7 +2,7 @@ #include -#include "mesh_impl.h" +#include "llr/mesh_impl.h" #include "node_impl.h" #include "scene_memory.h" diff --git a/src/scene/object_impl.h b/src/scene/object_impl.h index ead93f1..e864e53 100644 --- a/src/scene/object_impl.h +++ b/src/scene/object_impl.h @@ -4,8 +4,6 @@ #include "types.h" -#include - typedef struct MeshLink { mesh_idx mesh; mesh_link_idx next; // Next MeshLink in the list. diff --git a/src/scene/scene_memory.c b/src/scene/scene_memory.c index 91880bb..3a01325 100644 --- a/src/scene/scene_memory.c +++ b/src/scene/scene_memory.c @@ -4,9 +4,9 @@ #include "animation_impl.h" #include "camera_impl.h" -#include "light_impl.h" -#include "material_impl.h" -#include "mesh_impl.h" +#include "llr/light_impl.h" +#include "llr/material_impl.h" +#include "llr/mesh_impl.h" #include "model_impl.h" #include "node_impl.h" #include "object_impl.h" diff --git a/src/util/skyquad.c b/src/util/skyquad.c index 08fa044..094de67 100644 --- a/src/util/skyquad.c +++ b/src/util/skyquad.c @@ -1,18 +1,14 @@ #include #include -#include -#include -#include -#include +#include +#include +#include #include #include -#include #include #include -#include - #include SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) { @@ -36,10 +32,9 @@ SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) { } MaterialDesc material_desc = (MaterialDesc){0}; - material_desc.uniforms[0] = (ShaderUniform){ - .type = UniformTexture, - .value.texture = texture, - .name = sstring_make("Skyquad")}; + material_desc.uniforms[0] = (ShaderUniform){.type = UniformTexture, + .value.texture = texture, + .name = sstring_make("Skyquad")}; material_desc.num_uniforms = 1; material = gfx_make_material(&material_desc); if (!material) { -- cgit v1.2.3