From 1ec46bead3cf87971a2329f9ef4ddde5a0c48325 Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Fri, 4 Jul 2025 10:27:06 -0700 Subject: Clarify doc --- src/llr/imm_renderer.c | 260 --------------------- src/llr/imm_renderer_impl.h | 44 ---- src/llr/light.c | 42 ++++ src/llr/light_impl.h | 25 ++ src/llr/llr.c | 554 ++++++++++++++++++++++++++++++++++++++++++++ src/llr/llr_impl.h | 99 ++++++++ src/llr/material.c | 57 +++++ src/llr/material_impl.h | 16 ++ src/llr/mesh.c | 24 ++ src/llr/mesh_impl.h | 12 + src/scene/light.c | 42 ---- src/scene/light_impl.h | 25 -- src/scene/material.c | 57 ----- src/scene/material_impl.h | 16 -- src/scene/mesh.c | 24 -- src/scene/mesh_impl.h | 12 - 16 files changed, 829 insertions(+), 480 deletions(-) delete mode 100644 src/llr/imm_renderer.c delete mode 100644 src/llr/imm_renderer_impl.h create mode 100644 src/llr/light.c create mode 100644 src/llr/light_impl.h create mode 100644 src/llr/llr.c create mode 100644 src/llr/llr_impl.h create mode 100644 src/llr/material.c create mode 100644 src/llr/material_impl.h create mode 100644 src/llr/mesh.c create mode 100644 src/llr/mesh_impl.h delete mode 100644 src/scene/light.c delete mode 100644 src/scene/light_impl.h delete mode 100644 src/scene/material.c delete mode 100644 src/scene/material_impl.h delete mode 100644 src/scene/mesh.c delete mode 100644 src/scene/mesh_impl.h (limited to 'src') diff --git a/src/llr/imm_renderer.c b/src/llr/imm_renderer.c deleted file mode 100644 index 4b856c9..0000000 --- a/src/llr/imm_renderer.c +++ /dev/null @@ -1,260 +0,0 @@ -#include "../renderer/imm_renderer_impl.h" - -#include -#include - -#include - -#include -#include // memcpy - -bool imm_renderer_make(ImmRenderer* 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->shader = gfx_make_immediate_mode_shader(gfxcore); - if (!renderer->shader) { - goto cleanup; - } - - renderer->matrix_stack[0] = mat4_id(); - renderer->stack_pointer = 0; - - gfx_imm_set_colour(renderer, vec4_make(0.0, 0.0, 0.0, 1.0)); - - return true; - -cleanup: - imm_renderer_destroy(renderer); - return false; -} - -void imm_renderer_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 imm_renderer_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_apply_uniforms(renderer->shader); - gfx_render_geometry(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. - ShaderProgram* shader = renderer->shader; - gfx_activate_shader_program(shader); -} - -void gfx_imm_end(ImmRenderer* renderer) { - assert(renderer); - imm_renderer_flush(renderer); - gfx_deactivate_shader_program(renderer->shader); -} - -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 < (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); -} - -// Load the top of the matrix stack into the shader. -static void update_shader_model_matrix(ImmRenderer* renderer) { - assert(renderer); - imm_renderer_flush(renderer); - gfx_set_mat4_uniform( - renderer->shader, "Model", - &renderer->matrix_stack[renderer->stack_pointer]); -} - -void gfx_imm_load_identity(ImmRenderer* renderer) { - assert(renderer); - renderer->matrix_stack[0] = mat4_id(); - renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); -} - -void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) { - assert(renderer); - assert(matrix); - assert(renderer->stack_pointer >= 0); - assert(renderer->stack_pointer < IMM_MAX_NUM_MATRICES); // TODO: hard assert. - - renderer->matrix_stack[renderer->stack_pointer + 1] = - mat4_mul(*matrix, renderer->matrix_stack[renderer->stack_pointer]); - renderer->stack_pointer += 1; - - update_shader_model_matrix(renderer); -} - -void gfx_imm_pop_matrix(ImmRenderer* renderer) { - assert(renderer); - assert(renderer->stack_pointer > 0); // TODO: hard assert. - - // For debugging, zero out the matrix stack as matrices are popped out. - memset( - &renderer->matrix_stack[renderer->stack_pointer], 0, - sizeof(renderer->matrix_stack[0])); - - renderer->stack_pointer -= 1; - - update_shader_model_matrix(renderer); -} - -void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) { - assert(renderer); - const mat4 mat = mat4_translate(offset); - gfx_imm_push_matrix(renderer, &mat); -} - -void gfx_imm_set_camera(ImmRenderer* renderer, const Camera* camera) { - assert(renderer); - assert(renderer->shader); - imm_renderer_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); -} - -void gfx_imm_set_model_matrix(ImmRenderer* renderer, const mat4* model) { - assert(renderer); - assert(model); - imm_renderer_flush(renderer); - renderer->matrix_stack[0] = *model; - renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); -} - -void gfx_imm_set_view_projection_matrix( - ImmRenderer* renderer, const mat4* view_proj) { - assert(renderer); - assert(renderer->shader); - imm_renderer_flush(renderer); - gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj); -} - -void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) { - assert(renderer); - assert(renderer->shader); - imm_renderer_flush(renderer); - gfx_set_vec4_uniform(renderer->shader, "Colour", colour); -} diff --git a/src/llr/imm_renderer_impl.h b/src/llr/imm_renderer_impl.h deleted file mode 100644 index 5ece354..0000000 --- a/src/llr/imm_renderer_impl.h +++ /dev/null @@ -1,44 +0,0 @@ -#pragma once - -#include -#include - -#include -#include - -#include -#include - -typedef struct Geometry Geometry; -typedef struct ShaderProgram ShaderProgram; - -/// 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. -typedef struct ImmRenderer { - GfxCore* gfxcore; - ShaderProgram* shader; - 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 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]; - int stack_pointer; -} ImmRenderer; - -/// Create a new immediate mode renderer. -bool imm_renderer_make(ImmRenderer*, GfxCore*); - -/// Destroy the immediate mode renderer. -void imm_renderer_destroy(ImmRenderer*); - -/// Flush draw commands. -void imm_renderer_flush(ImmRenderer*); diff --git a/src/llr/light.c b/src/llr/light.c new file mode 100644 index 0000000..168f16a --- /dev/null +++ b/src/llr/light.c @@ -0,0 +1,42 @@ +#include "../scene/light_impl.h" + +#include "../scene/node_impl.h" +#include "../scene/scene_memory.h" + +#include + +static void make_environment_light( + Light* light, const EnvironmentLightDesc* desc) { + assert(light); + assert(desc); + light->type = EnvironmentLightType; + light->environment.environment_map = desc->environment_map; +} + +Light* gfx_make_light(const LightDesc* desc) { + assert(desc); + + Light* light = mem_alloc_light(); + + switch (desc->type) { + case EnvironmentLightType: + make_environment_light(light, &desc->light.environment); + break; + default: + log_error("Unhandled light type"); + gfx_destroy_light(&light); + return 0; + } + + return light; +} + +void gfx_destroy_light(Light** light) { + assert(light); + if (*light) { + if ((*light)->parent.val) { + gfx_del_node((*light)->parent); + } + mem_free_light(light); + } +} diff --git a/src/llr/light_impl.h b/src/llr/light_impl.h new file mode 100644 index 0000000..32203c4 --- /dev/null +++ b/src/llr/light_impl.h @@ -0,0 +1,25 @@ +#pragma once + +#include <../../include/gfx/llr/light.h> + +#include "../scene/types.h" + +typedef struct Texture Texture; + +/// An environment light. +typedef struct EnvironmentLight { + const Texture* environment_map; + const Texture* irradiance_map; // Renderer implementation. + const Texture* prefiltered_environment_map; // Renderer implementation. + int max_reflection_lod; // Mandatory when prefiltered_environment_map is + // given. +} EnvironmentLight; + +/// A scene light. +typedef struct Light { + LightType type; + union { + EnvironmentLight environment; + }; + node_idx parent; // Parent SceneNode. +} Light; diff --git a/src/llr/llr.c b/src/llr/llr.c new file mode 100644 index 0000000..62a7c30 --- /dev/null +++ b/src/llr/llr.c @@ -0,0 +1,554 @@ +#include "imm_renderer_impl.h" +#include "light_impl.h" +#include "mesh_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; +static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH = 128; +static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128; +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) { + assert(renderer); + assert(!renderer->ibl); + assert(!renderer->brdf_integration_map); + + if (!((renderer->ibl = gfx_make_ibl(renderer->gfxcore)))) { + return false; + } + + if (!((renderer->brdf_integration_map = gfx_make_brdf_integration_map( + renderer->ibl, renderer->gfxcore, BRDF_INTEGRATION_MAP_WIDTH, + BRDF_INTEGRATION_MAP_HEIGHT)))) { + return false; + } + + return true; +} + +// TODO: Why is this done lazily here? Do it when the environment light is +// created. +// +/// 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) { + assert(renderer); + assert(light); + assert(renderer->ibl); + assert(renderer->brdf_integration_map); + + if (light->irradiance_map) { + assert(light->prefiltered_environment_map); + return true; + } + + // For convenience. + GfxCore* gfxcore = renderer->gfxcore; + + Texture* irradiance_map = 0; + Texture* prefiltered_environment_map = 0; + + if (!((irradiance_map = gfx_make_irradiance_map( + renderer->ibl, gfxcore, light->environment_map, + IRRADIANCE_MAP_WIDTH, IRRADIANCE_MAP_HEIGHT)))) { + goto cleanup; + } + + int max_mip_level = 0; + if (!((prefiltered_environment_map = gfx_make_prefiltered_environment_map( + renderer->ibl, gfxcore, light->environment_map, + PREFILTERED_ENVIRONMENT_MAP_WIDTH, + PREFILTERED_ENVIRONMENT_MAP_HEIGHT, &max_mip_level)))) { + goto cleanup; + } + + light->irradiance_map = irradiance_map; + light->prefiltered_environment_map = prefiltered_environment_map; + light->max_reflection_lod = max_mip_level; + + return true; + +cleanup: + if (irradiance_map) { + gfx_destroy_texture(gfxcore, &irradiance_map); + } + if (prefiltered_environment_map) { + gfx_destroy_texture(gfxcore, &prefiltered_environment_map); + } + return false; +} + +static void configure_light(ImmRenderer* renderer, Light* light) { + assert(renderer); + assert(light); + + // For convenience. + ShaderProgram* const shader = renderer->shader; + + switch (light->type) { + case EnvironmentLightType: { + EnvironmentLight* env = &light->environment; + + const bool initialized = set_up_environment_light(renderer, env); + ASSERT(initialized); + assert(env->environment_map); + assert(env->irradiance_map); + assert(env->prefiltered_environment_map); + assert(renderer->brdf_integration_map); + + gfx_set_texture_uniform( + shader, "BRDFIntegrationMap", renderer->brdf_integration_map); + gfx_set_texture_uniform(shader, "Sky", env->environment_map); + gfx_set_texture_uniform(shader, "IrradianceMap", env->irradiance_map); + gfx_set_texture_uniform( + shader, "PrefilteredEnvironmentMap", env->prefiltered_environment_map); + gfx_set_float_uniform( + shader, "MaxReflectionLOD", (float)env->max_reflection_lod); + + break; + } + default: + assert(false); // TODO: Implement other light types. + break; + } +} + +static void configure_state(ImmRenderer* 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) { + return; + } + + // For convenience. + ShaderProgram* const shader = renderer->shader; + + // TODO: camera_changed is not set anywhere. Need to think how imm primitive + // rendering and imm mesh rendering work together. We could treat imm + // primitive calls like setting a new shader. + if (renderer->camera_changed || renderer->shader_changed) { + renderer->camera_changed = false; + + // 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 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); + gfx_set_mat4_uniform(shader, "ViewProjection", &view_proj); + gfx_set_mat4_uniform(shader, "MVP", &mvp); + gfx_set_vec3_uniform(shader, "CameraPosition", renderer->camera_position); + } + + if (renderer->lights_changed || renderer->shader_changed) { + renderer->lights_changed = false; + + // TODO: Could do better by only setting the lights that have actually + // changed. + // TODO: Will also need to pass the number of lights to the shader once the + // other light types are implemented. + for (int i = 0; i < renderer->num_lights; ++i) { + configure_light(renderer, renderer->lights[i]); + } + } + + if (renderer->skeleton_changed || renderer->shader_changed) { + renderer->skeleton_changed = false; + + gfx_set_mat4_array_uniform( + shader, "JointMatrices", renderer->joint_matrices, + renderer->num_joints); + } + + if (renderer->shader_changed) { + renderer->shader_changed = false; + gfx_activate_shader_program(renderer->shader); + } + + // Must be called after activating the program. + gfx_apply_uniforms(renderer->shader); +} + +bool gfx_imm_make(ImmRenderer* 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)); + + 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->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); + } + + // TODO: Do this once the IBL from the scene renderer is gone. + if (renderer->ibl) { + // gfx_destroy_ibl(renderer->gfxcore, &renderer->ibl); + } +} + +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) { + 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); + + // It's important to not set shader_changed unnecessarily, since that would + // re-trigger the setting of uniforms. + if (renderer->shader != shader) { + renderer->shader = shader; + renderer->shader_changed = true; + } +} + +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) { + assert(renderer); + assert(light); + assert(renderer->num_lights >= 0); + ASSERT(renderer->num_lights < IMM_MAX_NUM_LIGHTS); + + renderer->lights[renderer->num_lights++] = light; + renderer->lights_changed = true; +} + +void gfx_imm_pop_light(ImmRenderer* renderer) { + assert(renderer); + ASSERT(renderer->num_lights > 0); + + renderer->lights[--renderer->num_lights] = 0; + renderer->lights_changed = true; +} + +void gfx_imm_set_skeleton( + ImmRenderer* renderer, const Anima* anima, const Skeleton* skeleton) { + assert(renderer); + assert(anima); + assert(skeleton); + assert(skeleton->num_joints <= GFX_MAX_NUM_JOINTS); + + for (size_t i = 0; i < skeleton->num_joints; ++i) { + const joint_idx joint_index = skeleton->joints[i]; + const Joint* joint = &anima->joints[joint_index]; + renderer->joint_matrices[i] = joint->joint_matrix; + } + renderer->num_joints = skeleton->num_joints; + renderer->skeleton_changed = true; +} + +void gfx_imm_unset_skeleton(ImmRenderer* 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) { + 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); +} + +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); +} + +// 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]); +} + +void gfx_imm_load_identity(ImmRenderer* renderer) { + assert(renderer); + + renderer->matrix_stack[0] = mat4_id(); + renderer->stack_pointer = 0; + update_shader_model_matrix(renderer); +} + +void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) { + assert(renderer); + assert(matrix); + assert(renderer->stack_pointer >= 0); + ASSERT(renderer->stack_pointer < IMM_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); +} + +void gfx_imm_pop_matrix(ImmRenderer* renderer) { + assert(renderer); + ASSERT(renderer->stack_pointer > 0); + + // For debugging, zero out the matrix stack as matrices are popped out. + memset( + &renderer->matrix_stack[renderer->stack_pointer], 0, + sizeof(renderer->matrix_stack[0])); + renderer->stack_pointer -= 1; + + update_shader_model_matrix(renderer); +} + +void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) { + assert(renderer); + + const mat4 mat = mat4_translate(offset); + gfx_imm_push_matrix(renderer, &mat); +} + +void gfx_imm_set_model_matrix(ImmRenderer* 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); +} + +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 new file mode 100644 index 0000000..5ccabd1 --- /dev/null +++ b/src/llr/llr_impl.h @@ -0,0 +1,99 @@ +#pragma once + +#include +#include + +#include +#include + +#include +#include + +typedef struct Geometry Geometry; +typedef struct GfxCore GfxCore; +typedef struct IBL IBL; +typedef struct Material Material; +typedef struct ShaderProgram ShaderProgram; +typedef struct Texture Texture; + +/// Immediate mode renderer. +/// +/// The renderer caches state changes in memory and only programs the underlying +/// shader program when a draw call is issued and if anything has changed. This +/// keeps the number of graphics API calls to a minimum, but requires tracking +/// state changes. The 'changed' booleans below fulfill this purpose, and +/// indicate whether a given state has changed since the last draw call. +/// +/// The renderer must combine state changes accordingly. For example, if only +/// the lights have changed, then it is sufficient to update light uniforms in +/// the current shader program. On the other hand, if the shader program has +/// changed, then the renderer must reconfigure it from scratch and set light +/// uniforms, camera uniforms, etc. +/// +/// 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 { + 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. + + IBL* ibl; + Texture* brdf_integration_map; + + ShaderProgram* shader; // Active shader. Not owned. + bool shader_changed; // Whether the shader has changed. + + // 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. + + 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]; + int stack_pointer; // Points to the top of the stack. +} ImmRenderer; + +/// Create a new immediate mode renderer. +bool gfx_imm_make(ImmRenderer*, GfxCore*); + +/// Destroy the immediate mode renderer. +void gfx_imm_destroy(ImmRenderer*); + +/// Flush draw commands. +void gfx_imm_flush(ImmRenderer*); diff --git a/src/llr/material.c b/src/llr/material.c new file mode 100644 index 0000000..47cb45f --- /dev/null +++ b/src/llr/material.c @@ -0,0 +1,57 @@ +#include "material_impl.h" + +#include "../scene/scene_memory.h" + +#include + +static void material_make(Material* material, const MaterialDesc* desc) { + assert(material); + assert(desc); + assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); + material->num_uniforms = desc->num_uniforms; + for (int i = 0; i < desc->num_uniforms; ++i) { + material->uniforms[i] = desc->uniforms[i]; + } +} + +Material* gfx_make_material(const MaterialDesc* desc) { + assert(desc); + Material* material = mem_alloc_material(); + material_make(material, desc); + return material; +} + +void gfx_destroy_material(Material** material) { mem_free_material(material); } + +static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) { + switch (uniform->type) { + case UniformTexture: + gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture); + break; + case UniformMat4: + gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.mat4); + break; + case UniformVec3: + gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.vec3); + break; + case UniformVec4: + gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.vec4); + break; + case UniformFloat: + gfx_set_float_uniform(prog, uniform->name.str, uniform->value.scalar); + break; + case UniformMat4Array: + gfx_set_mat4_array_uniform( + prog, uniform->name.str, uniform->value.array.values, + uniform->value.array.count); + break; + } +} + +void material_activate(ShaderProgram* shader, const Material* material) { + assert(material); + for (int i = 0; i < material->num_uniforms; ++i) { + const ShaderUniform* uniform = &material->uniforms[i]; + set_uniform(shader, uniform); + } +} diff --git a/src/llr/material_impl.h b/src/llr/material_impl.h new file mode 100644 index 0000000..f27bf4d --- /dev/null +++ b/src/llr/material_impl.h @@ -0,0 +1,16 @@ +#pragma once + +#include <../../include/gfx/llr/material.h> + +typedef struct ShaderProgram ShaderProgram; + +typedef struct Material { + ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL]; + int num_uniforms; +} 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); diff --git a/src/llr/mesh.c b/src/llr/mesh.c new file mode 100644 index 0000000..ae75d8c --- /dev/null +++ b/src/llr/mesh.c @@ -0,0 +1,24 @@ +#include "../scene/mesh_impl.h" + +#include "../scene/scene_memory.h" + +#include + +static void mesh_make(Mesh* mesh, const MeshDesc* desc) { + assert(mesh); + assert(desc); + assert(desc->geometry); + assert(desc->material); + assert(desc->shader); + mesh->geometry = desc->geometry; + mesh->material = desc->material; + mesh->shader = desc->shader; +} + +Mesh* gfx_make_mesh(const MeshDesc* desc) { + Mesh* mesh = mem_alloc_mesh(); + mesh_make(mesh, desc); + return mesh; +} + +void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); } diff --git a/src/llr/mesh_impl.h b/src/llr/mesh_impl.h new file mode 100644 index 0000000..47ff525 --- /dev/null +++ b/src/llr/mesh_impl.h @@ -0,0 +1,12 @@ +#pragma once + +#include <../../include/gfx/llr/mesh.h> + +typedef struct Mesh { + const Geometry* geometry; + const Material* material; + ShaderProgram* shader; +} Mesh; + +// TODO: a mesh_render() that takes a transform, applies the material and the +// transform, and then renders the geometry. diff --git a/src/scene/light.c b/src/scene/light.c deleted file mode 100644 index adbec8d..0000000 --- a/src/scene/light.c +++ /dev/null @@ -1,42 +0,0 @@ -#include "light_impl.h" - -#include "node_impl.h" -#include "scene_memory.h" - -#include - -static void make_environment_light( - Light* light, const EnvironmentLightDesc* desc) { - assert(light); - assert(desc); - light->type = EnvironmentLightType; - light->environment.environment_map = desc->environment_map; -} - -Light* gfx_make_light(const LightDesc* desc) { - assert(desc); - - Light* light = mem_alloc_light(); - - switch (desc->type) { - case EnvironmentLightType: - make_environment_light(light, &desc->light.environment); - break; - default: - log_error("Unhandled light type"); - gfx_destroy_light(&light); - return 0; - } - - return light; -} - -void gfx_destroy_light(Light** light) { - assert(light); - if (*light) { - if ((*light)->parent.val) { - gfx_del_node((*light)->parent); - } - mem_free_light(light); - } -} diff --git a/src/scene/light_impl.h b/src/scene/light_impl.h deleted file mode 100644 index 1aa0bb4..0000000 --- a/src/scene/light_impl.h +++ /dev/null @@ -1,25 +0,0 @@ -#pragma once - -#include - -#include "types.h" - -typedef struct Texture Texture; - -/// An environment light. -typedef struct EnvironmentLight { - const Texture* environment_map; - const Texture* irradiance_map; // Renderer implementation. - const Texture* prefiltered_environment_map; // Renderer implementation. - int max_reflection_lod; // Mandatory when prefiltered_environment_map is - // given. -} EnvironmentLight; - -/// A scene light. -typedef struct Light { - LightType type; - union { - EnvironmentLight environment; - }; - node_idx parent; // Parent SceneNode. -} Light; diff --git a/src/scene/material.c b/src/scene/material.c deleted file mode 100644 index 3248243..0000000 --- a/src/scene/material.c +++ /dev/null @@ -1,57 +0,0 @@ -#include "material_impl.h" - -#include "scene_memory.h" - -#include - -static void material_make(Material* material, const MaterialDesc* desc) { - assert(material); - assert(desc); - assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); - material->num_uniforms = desc->num_uniforms; - for (int i = 0; i < desc->num_uniforms; ++i) { - material->uniforms[i] = desc->uniforms[i]; - } -} - -Material* gfx_make_material(const MaterialDesc* desc) { - assert(desc); - Material* material = mem_alloc_material(); - material_make(material, desc); - return material; -} - -void gfx_destroy_material(Material** material) { mem_free_material(material); } - -static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) { - switch (uniform->type) { - case UniformTexture: - gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture); - break; - case UniformMat4: - gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.mat4); - break; - case UniformVec3: - gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.vec3); - break; - case UniformVec4: - gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.vec4); - break; - case UniformFloat: - gfx_set_float_uniform(prog, uniform->name.str, uniform->value.scalar); - break; - case UniformMat4Array: - gfx_set_mat4_array_uniform( - prog, uniform->name.str, uniform->value.array.values, - uniform->value.array.count); - break; - } -} - -void material_activate(ShaderProgram* shader, const Material* material) { - assert(material); - for (int i = 0; i < material->num_uniforms; ++i) { - const ShaderUniform* uniform = &material->uniforms[i]; - set_uniform(shader, uniform); - } -} diff --git a/src/scene/material_impl.h b/src/scene/material_impl.h deleted file mode 100644 index a6aa95b..0000000 --- a/src/scene/material_impl.h +++ /dev/null @@ -1,16 +0,0 @@ -#pragma once - -#include - -typedef struct ShaderProgram ShaderProgram; - -typedef struct Material { - ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL]; - int num_uniforms; -} 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); diff --git a/src/scene/mesh.c b/src/scene/mesh.c deleted file mode 100644 index 1a93bed..0000000 --- a/src/scene/mesh.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "mesh_impl.h" - -#include "scene_memory.h" - -#include - -static void mesh_make(Mesh* mesh, const MeshDesc* desc) { - assert(mesh); - assert(desc); - assert(desc->geometry); - assert(desc->material); - assert(desc->shader); - mesh->geometry = desc->geometry; - mesh->material = desc->material; - mesh->shader = desc->shader; -} - -Mesh* gfx_make_mesh(const MeshDesc* desc) { - Mesh* mesh = mem_alloc_mesh(); - mesh_make(mesh, desc); - return mesh; -} - -void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); } diff --git a/src/scene/mesh_impl.h b/src/scene/mesh_impl.h deleted file mode 100644 index 560b77e..0000000 --- a/src/scene/mesh_impl.h +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once - -#include - -typedef struct Mesh { - const Geometry* geometry; - const Material* material; - ShaderProgram* shader; -} Mesh; - -// TODO: a mesh_render() that takes a transform, applies the material and the -// transform, and then renders the geometry. -- cgit v1.2.3