From 65d448aad0e6c792b1adba1272efef73b31c4885 Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Fri, 24 Oct 2025 18:33:36 -0700 Subject: Consolidate renderers --- src/render/imm.c | 192 +++++++++++++++++ src/render/imm_impl.h | 43 ++++ src/render/llr.c | 527 +++++++++++++++++++++++++++++++++++++++++++++ src/render/llr_impl.h | 117 ++++++++++ src/render/renderer.c | 246 +++++++++++++++++++++ src/render/renderer_impl.h | 25 +++ 6 files changed, 1150 insertions(+) create mode 100644 src/render/imm.c create mode 100644 src/render/imm_impl.h create mode 100644 src/render/llr.c create mode 100644 src/render/llr_impl.h create mode 100644 src/render/renderer.c create mode 100644 src/render/renderer_impl.h (limited to 'src/render') diff --git a/src/render/imm.c b/src/render/imm.c new file mode 100644 index 0000000..8a93488 --- /dev/null +++ b/src/render/imm.c @@ -0,0 +1,192 @@ +#include "imm_impl.h" + +#include +#include +#include +#include + +#include + +#include +#include // memcpy + +bool gfx_imm_make(Imm* 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(Imm* 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(Imm* 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(Imm* 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(Imm* 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( + Imm* 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(Imm* renderer, const vec3 verts[3]) { + gfx_imm_draw_triangles(renderer, verts, 1); +} + +void gfx_imm_draw_aabb2(Imm* 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(Imm* 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(Imm* 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(Imm* renderer, vec4 colour) { + assert(renderer); + assert(renderer->shader); + + gfx_imm_flush(renderer); + + gfx_set_vec4_uniform(renderer->shader, "Colour", colour); +} diff --git a/src/render/imm_impl.h b/src/render/imm_impl.h new file mode 100644 index 0000000..d87b910 --- /dev/null +++ b/src/render/imm_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 Imm { + 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]; +} Imm; + +/// Create a new immediate mode renderer. +bool gfx_imm_make(Imm*, GfxCore*, LLR*); + +/// Destroy the immediate mode renderer. +void gfx_imm_destroy(Imm*); diff --git a/src/render/llr.c b/src/render/llr.c new file mode 100644 index 0000000..a1b37be --- /dev/null +++ b/src/render/llr.c @@ -0,0 +1,527 @@ +#include "llr_impl.h" + +#include "memory.h" +#include "scene/animation_impl.h" +#include "scene/node_impl.h" + +#include +#include + +#include +#include + +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; + +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); + } +} + +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; + } +} + +/// Activate the material. +/// +/// This configures the shader uniforms that are specific to the material. +static 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]; + set_uniform(shader, uniform); + } +} + +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); } + +/// Initialize renderer state for IBL. +static bool init_ibl(LLR* 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; +} + +/// Compute irradiance and prefiltered environment maps for the light if they +/// have not been already computed. +/// +/// This is done lazily here, and not when the light is created, because we +/// need an IBL instance to do this and it is more convenient for the public +/// API to create lights without worrying about those details. It also makes the +/// public API cheaper, since the maps are only computed when they are actually +/// needed. +static bool set_up_environment_light(LLR* 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(LLR* 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(LLR* renderer) { + assert(renderer); + + // Check if anything changed first so that we don't call gfx_apply_uniforms() + // unnecessarily. + 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 + // 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. + 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, "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); + gfx_set_mat4_uniform(shader, "CameraRotation", &renderer->camera_rotation); + gfx_set_float_uniform(shader, "Fovy", renderer->fovy); + gfx_set_float_uniform(shader, "Aspect", renderer->aspect); + } + + 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; + + if (renderer->num_joints > 0) { + gfx_set_mat4_array_uniform( + shader, "JointMatrices", renderer->joint_matrices, + renderer->num_joints); + } + } + + if (renderer->material_changed || renderer->shader_changed) { + renderer->material_changed = false; + + // Geometry may be rendered without a material. + if (renderer->material) { + gfx_material_activate(renderer->shader, renderer->material); + } + } + + if (renderer->shader_changed) { + renderer->shader_changed = false; + gfx_activate_shader_program(renderer->shader); + } + + // TODO: At present, this results in many redundant calls to + // glGetUniformLocation() and glUniformXyz(). Look at the trace. + // + // TODO: Could add to qapitrace functionality to detect redundant calls and + // other inefficiencies. Maybe ask in the Github first if there would be + // interest in this. + // + // Must be called after activating the program. + gfx_apply_uniforms(renderer->shader); +} + +bool gfx_llr_make(LLR* renderer, GfxCore* gfxcore) { + assert(renderer); + assert(gfxcore); + + renderer->gfxcore = gfxcore; + if (!init_ibl(renderer)) { + goto cleanup; + } + gfx_llr_load_identity(renderer); + renderer->view = mat4_id(); + renderer->projection = mat4_id(); + renderer->camera_rotation = mat4_id(); + return true; + +cleanup: + gfx_llr_destroy(renderer); + return false; +} + +void gfx_llr_destroy(LLR* renderer) { + assert(renderer); + assert(renderer->gfxcore); + + 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_llr_set_shader(LLR* renderer, ShaderProgram* shader) { + assert(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. + if (renderer->shader != shader) { + renderer->shader = shader; + renderer->shader_changed = true; + } +} + +void gfx_llr_push_light(LLR* renderer, Light* light) { + assert(renderer); + assert(light); + assert(renderer->num_lights >= 0); + ASSERT(renderer->num_lights < GFX_LLR_MAX_NUM_LIGHTS); + + renderer->lights[renderer->num_lights++] = light; + renderer->lights_changed = true; +} + +void gfx_llr_pop_light(LLR* renderer) { + assert(renderer); + ASSERT(renderer->num_lights > 0); + + renderer->lights[--renderer->num_lights] = 0; + renderer->lights_changed = true; +} + +void gfx_llr_set_skeleton( + LLR* 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_llr_clear_skeleton(LLR* renderer) { + assert(renderer); + + renderer->num_joints = 0; + renderer->skeleton_changed = true; +} + +void gfx_llr_set_material(LLR* renderer, const Material* material) { + assert(renderer); + assert(material); + + renderer->material = material; + renderer->material_changed = true; +} + +void gfx_llr_set_camera(LLR* renderer, const Camera* camera) { + assert(renderer); + + renderer->camera_position = camera->spatial.p; + renderer->camera_rotation = + mat4_rotation(spatial3_transform(&camera->spatial)); + renderer->view = spatial3_inverse_transform(&camera->spatial); + renderer->projection = camera->projection; + // Assuming a perspective matrix. + renderer->fovy = (R)atan(1.0 / (mat4_at(camera->projection, 1, 1))) * 2; + renderer->camera_changed = true; +} + +void gfx_llr_set_projection_matrix(LLR* renderer, const mat4* projection) { + assert(renderer); + + renderer->projection = *projection; + renderer->camera_changed = true; +} + +void gfx_llr_set_aspect(LLR* renderer, float aspect) { + assert(renderer); + + renderer->aspect = aspect; + renderer->camera_changed = true; +} + +void gfx_llr_render_geometry(LLR* renderer, const Geometry* geometry) { + assert(renderer); + assert(geometry); + + configure_state(renderer); + gfx_render_geometry(geometry); +} + +void gfx_llr_render_mesh(LLR* renderer, const Mesh* mesh) { + assert(renderer); + assert(mesh); + assert(mesh->geometry); + assert(mesh->material); + assert(mesh->shader); + + gfx_llr_set_material(renderer, mesh->material); + gfx_llr_set_shader(renderer, mesh->shader); + gfx_llr_render_geometry(renderer, mesh->geometry); +} + +void gfx_llr_load_identity(LLR* renderer) { + assert(renderer); + + renderer->matrix_stack[0] = mat4_id(); + renderer->stack_pointer = 0; + renderer->matrix_changed = true; +} + +void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix) { + assert(renderer); + assert(matrix); + assert(renderer->stack_pointer >= 0); + 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]); + renderer->matrix_changed = true; +} + +void gfx_llr_pop_matrix(LLR* 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; + renderer->matrix_changed = true; +} + +void gfx_llr_translate(LLR* renderer, vec3 offset) { + assert(renderer); + + const mat4 mat = mat4_translate(offset); + gfx_llr_push_matrix(renderer, &mat); +} + +void gfx_llr_set_model_matrix(LLR* renderer, const mat4* model) { + assert(renderer); + assert(model); + + renderer->matrix_stack[0] = *model; + renderer->stack_pointer = 0; + renderer->matrix_changed = true; +} diff --git a/src/render/llr_impl.h b/src/render/llr_impl.h new file mode 100644 index 0000000..319441c --- /dev/null +++ b/src/render/llr_impl.h @@ -0,0 +1,117 @@ +#pragma once + +#include +#include + +#include "scene/types.h" + +#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; + +/// 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; + +typedef struct Material { + ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL]; + int num_uniforms; +} Material; + +typedef struct Mesh { + const Geometry* geometry; + const Material* material; + ShaderProgram* shader; // TODO: Move this back to Material? +} Mesh; + +/// 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. +typedef struct LLR { + GfxCore* gfxcore; + + 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 material_changed : 1; // Whether the material 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. + + const Material* material; // Active material. Not owned. + + vec3 camera_position; + mat4 camera_rotation; + mat4 view; // Camera view matrix. + mat4 projection; // Camera projection matrix. + R fovy; // Camera vertical field of view. + R aspect; // Aspect ratio. + + // Lights are not const because environment lights store lazily-computed + // irradiance maps. + 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. + + size_t num_joints; + mat4 joint_matrices[GFX_MAX_NUM_JOINTS]; + + // 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[GFX_LLR_MAX_NUM_MATRICES]; + int stack_pointer; // Points to the top of the stack. +} LLR; + +/// Create a new immediate mode renderer. +bool gfx_llr_make(LLR*, GfxCore*); + +/// Destroy the immediate mode renderer. +void gfx_llr_destroy(LLR*); diff --git a/src/render/renderer.c b/src/render/renderer.c new file mode 100644 index 0000000..eca7551 --- /dev/null +++ b/src/render/renderer.c @@ -0,0 +1,246 @@ +#include "renderer_impl.h" + +#include "llr_impl.h" +#include "memory.h" +#include "scene/animation_impl.h" +#include "scene/camera_impl.h" +#include "scene/model_impl.h" +#include "scene/node_impl.h" +#include "scene/object_impl.h" +#include "scene/scene_impl.h" + +#include +#include +#include + +#include + +#include + +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 gfx_renderer_destroy(Renderer* renderer) { + if (!renderer) { + return; + } + assert(renderer->gfxcore); + GfxCore* gfxcore = renderer->gfxcore; + if (renderer->shaders.debug) { + gfx_destroy_shader_program(gfxcore, &renderer->shaders.debug); + } + if (renderer->shaders.normals) { + gfx_destroy_shader_program(gfxcore, &renderer->shaders.normals); + } + if (renderer->shaders.normal_mapped_normals) { + gfx_destroy_shader_program( + gfxcore, &renderer->shaders.normal_mapped_normals); + } + if (renderer->shaders.tangents) { + gfx_destroy_shader_program(gfxcore, &renderer->shaders.tangents); + } +} + +static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) { + assert(renderer); + +#define LOAD_AND_RETURN(pShader, constructor) \ + { \ + if (!pShader) { \ + pShader = constructor(renderer->gfxcore); \ + } \ + assert(pShader); \ + return pShader; \ + } + + switch (mode) { + case RenderDefault: + return 0; + case RenderDebug: + LOAD_AND_RETURN(renderer->shaders.debug, gfx_make_debug3d_shader); + case RenderNormals: + LOAD_AND_RETURN(renderer->shaders.normals, gfx_make_view_normals_shader); + case RenderNormalMappedNormals: + LOAD_AND_RETURN( + renderer->shaders.normal_mapped_normals, + gfx_make_view_normal_mapped_normals_shader); + case RenderTangents: + LOAD_AND_RETURN(renderer->shaders.tangents, gfx_make_view_tangents_shader); + } + assert(false); + return 0; +} + +// static void log_matrix(const mat4* m) { +// for (int row = 0; row < 4; ++row) { +// LOGI("[ %5.2f, %5.2f, %5.2f, %5.2f ]", m->val[0][row], m->val[1][row], +// m->val[2][row], m->val[3][row]); +// } +// } + +typedef struct RenderState { + GfxCore* gfxcore; + LLR* llr; + Renderer* renderer; + ShaderProgram* shader; // Null to use scene shaders. + const Scene* scene; + const Anima* anima; +} RenderState; + +static void draw_children( + RenderState* state, const mat4* node_transform, const SceneNode* node); + +/// Draw the scene recursively. +static void draw_recursively( + RenderState* state, mat4 parent_transform, const SceneNode* node) { + assert(state); + const mat4 node_transform = mat4_mul(parent_transform, node->transform); + + // Anima. + if (node->type == AnimaNode) { + // Save the anima so that we can animate objects. + state->anima = gfx_get_node_anima(node); + + draw_children(state, &node_transform, node); + } + // Activate light. + else if (node->type == LightNode) { + Light* light = mem_get_light(node->light); + assert(light); + gfx_llr_push_light(state->llr, light); + { + draw_children(state, &node_transform, node); + } + gfx_llr_pop_light(state->llr); + } + // Model. + else if (node->type == ModelNode) { + const Model* model = gfx_get_node_model(node); + const SceneNode* root = mem_get_node(model->root); + draw_recursively(state, parent_transform, root); + draw_children(state, &node_transform, node); + } + // Render object. + else if (node->type == ObjectNode) { + const SceneObject* object = mem_get_object(node->object); + assert(object); + + // TODO: Here we would frustum-cull the object. + + // 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) { + const Skeleton* skeleton = mem_get_skeleton(object->skeleton); + gfx_llr_set_skeleton(state->llr, state->anima, skeleton); + } + + const mat4 model_matrix = node_transform; + + for (mesh_link_idx mesh_link_index = object->mesh_link; + mesh_link_index.val;) { + const MeshLink* mesh_link = mem_get_mesh_link(mesh_link_index); + mesh_link_index = mesh_link->next; + + const Mesh* mesh = mem_get_mesh(mesh_link->mesh); + if (!mesh) { + continue; + } + + // 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. + + ShaderProgram* shader = state->shader ? state->shader : mesh->shader; + gfx_llr_set_shader(state->llr, shader); + gfx_llr_set_model_matrix(state->llr, &model_matrix); + gfx_llr_render_mesh(state->llr, mesh); + } + + if (object->skeleton.val) { + gfx_llr_clear_skeleton(state->llr); + } + + draw_children(state, &node_transform, node); + } else { + draw_children(state, &node_transform, node); + } +} + +/// Draw the node's children. +static void draw_children( + RenderState* state, const mat4* node_transform, const SceneNode* node) { + // Render children recursively. + for (node_idx child_index = node->child; child_index.val;) { + const SceneNode* child = mem_get_node(child_index); + draw_recursively(state, *node_transform, child); + child_index = child->next; + } +} + +void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) { + assert(renderer); + assert(params); + assert(params->scene); + + ShaderProgram* const shader = load_shader(renderer, params->mode); + + const Scene* scene = params->scene; + const SceneCamera* camera = params->camera; + GfxCore* const gfxcore = renderer->gfxcore; + + int x, y, width, height; + gfx_get_viewport(gfxcore, &x, &y, &width, &height); + const R aspect = (R)width / (R)height; + + RenderState state = { + .gfxcore = gfxcore, + .llr = renderer->llr, + .renderer = renderer, + .shader = shader, + .scene = scene}; + + gfx_llr_set_camera(renderer->llr, &camera->camera); + gfx_llr_set_aspect(renderer->llr, aspect); + draw_recursively(&state, mat4_id(), scene->root); +} + +static void update_rec(SceneNode* node, const SceneCamera* camera, R t) { + assert(node); + assert(camera); + + const NodeType node_type = gfx_get_node_type(node); + + // TODO: Models do not need to be animated if they are not visible to the + // camera. + if (node_type == AnimaNode) { + Anima* anima = gfx_get_node_anima_mut(node); + gfx_update_animation(anima, (R)t); + } else if (node_type == ModelNode) { + Model* model = gfx_get_node_model_mut(node); + SceneNode* root = gfx_get_model_root_mut(model); + update_rec(root, camera, t); + } + + // Children. + SceneNode* child = gfx_get_node_child_mut(node); + while (child) { + update_rec(child, camera, t); + child = gfx_get_node_sibling_mut(child); + } +} + +void gfx_update(Scene* scene, const SceneCamera* camera, R t) { + assert(scene); + assert(camera); + + SceneNode* node = gfx_get_scene_root(scene); + update_rec(node, camera, t); +} diff --git a/src/render/renderer_impl.h b/src/render/renderer_impl.h new file mode 100644 index 0000000..160ff52 --- /dev/null +++ b/src/render/renderer_impl.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +#include + +typedef struct LLR LLR; +typedef struct ShaderProgram ShaderProgram; + +typedef struct Renderer { + GfxCore* gfxcore; + LLR* llr; + struct { + ShaderProgram* debug; + ShaderProgram* normals; + ShaderProgram* normal_mapped_normals; + ShaderProgram* tangents; + } shaders; +} Renderer; + +/// Create a new renderer. +bool gfx_renderer_make(Renderer*, LLR*, GfxCore*); + +/// Destroy the renderer. +void gfx_renderer_destroy(Renderer*); -- cgit v1.2.3