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 --- CMakeLists.txt | 6 +- include/gfx/llr/llr.h | 146 ---------- include/gfx/render/imm.h | 52 ++++ include/gfx/render/llr.h | 147 ++++++++++ include/gfx/render/renderer.h | 29 ++ include/gfx/renderer.h | 29 -- include/gfx/renderer/imm_renderer.h | 52 ---- src/asset/model.c | 38 +-- src/gfx.c | 6 +- src/llr/llr.c | 527 ------------------------------------ src/llr/llr_impl.h | 117 -------- src/memory.c | 2 +- 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 ++ src/renderer/imm_renderer.c | 192 ------------- src/renderer/imm_renderer_impl.h | 43 --- src/renderer/renderer.c | 246 ----------------- src/renderer/renderer_impl.h | 25 -- src/scene/node.c | 2 +- src/scene/object.c | 2 +- src/util/skyquad.c | 2 +- 25 files changed, 1407 insertions(+), 1406 deletions(-) delete mode 100644 include/gfx/llr/llr.h create mode 100644 include/gfx/render/imm.h create mode 100644 include/gfx/render/llr.h create mode 100644 include/gfx/render/renderer.h delete mode 100644 include/gfx/renderer.h delete mode 100644 include/gfx/renderer/imm_renderer.h delete mode 100644 src/llr/llr.c delete mode 100644 src/llr/llr_impl.h 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 delete mode 100644 src/renderer/imm_renderer.c delete mode 100644 src/renderer/imm_renderer_impl.h delete mode 100644 src/renderer/renderer.c delete mode 100644 src/renderer/renderer_impl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index cda7b1b..6e05db1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -49,10 +49,10 @@ add_library(gfx SHARED src/core/shader_program.c src/core/shader.c src/core/texture.c - src/llr/llr.c src/memory.c - src/renderer/imm_renderer.c - src/renderer/renderer.c + src/render/imm.c + src/render/llr.c + src/render/renderer.c src/scene/animation.c src/scene/camera.c src/scene/model.c diff --git a/include/gfx/llr/llr.h b/include/gfx/llr/llr.h deleted file mode 100644 index 6d78a50..0000000 --- a/include/gfx/llr/llr.h +++ /dev/null @@ -1,146 +0,0 @@ -#pragma once - -#include -#include - -#include -#include -#include - -typedef struct Anima Anima; -typedef struct Geometry Geometry; -typedef struct Light Light; -typedef struct Material Material; -typedef struct Mesh Mesh; -typedef struct ShaderProgram ShaderProgram; -typedef struct Skeleton Skeleton; -typedef struct Texture Texture; - -typedef struct LLR LLR; - -// ----------------------------------------------------------------------------- -// Data structures. - -/// Light type. -typedef enum LightType { EnvironmentLightType } LightType; - -/// Describes an environment light. -typedef struct EnvironmentLightDesc { - const Texture* environment_map; -} EnvironmentLightDesc; - -/// Describes a light. -typedef struct LightDesc { - LightType type; - union { - EnvironmentLightDesc environment; - } light; -} LightDesc; - -/// Describes a material. -/// -/// TODO: It doesn't hold the shader program anymore...It's in the Mesh. -/// A material holds a shader program and a set of shader-specific uniform -/// variables. Two materials can share the same shader, but shader parameters -/// generally give two materials a different appearance. -typedef struct MaterialDesc { - ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL]; - int num_uniforms; -} MaterialDesc; - -/// Describes a mesh. -typedef struct MeshDesc { - const Geometry* geometry; - const Material* material; - ShaderProgram* shader; -} MeshDesc; - -/// Create a light. -Light* gfx_make_light(const LightDesc*); - -/// Destroy the light. -/// -/// The light is conveniently removed from the scene graph and its parent scene -/// node is destroyed. -void gfx_destroy_light(Light**); - -/// Create a material. -Material* gfx_make_material(const MaterialDesc*); - -/// Destroy the material. -/// -/// The caller must make sure that no Mesh points to the given Material. -/// For a safe purge of unused resources, see scene_purge(). -void gfx_destroy_material(Material**); - -/// Create a mesh. -Mesh* gfx_make_mesh(const MeshDesc*); - -/// Destroy the mesh. -/// -/// The caller must make sure that no SceneObject points to the given Mesh. -/// For a safe purge of unused resources, see scene_purge(). -void gfx_destroy_mesh(Mesh**); - -// ----------------------------------------------------------------------------- -// Low-level rendering. - -/// Set the shader to be used for subsequent draw calls. -/// The shader is not yet activated at this point. -void gfx_llr_set_shader(LLR*, ShaderProgram*); - -/// Push a light into the lights stack. -void gfx_llr_push_light(LLR*, Light*); - -/// Pop the last light from the lights stack. -void gfx_llr_pop_light(LLR*); - -/// Load a skeleton. -/// -/// If a skeleton is loaded, subsequent meshes are rendered with joint data -/// passed to the shader. This has a cost, so if subsequent meshes are not -/// animated, unload the skeleton prior to rendering them. -void gfx_llr_set_skeleton(LLR*, const Anima*, const Skeleton*); - -/// Clear the loaded skeleton. -void gfx_llr_clear_skeleton(LLR*); - -/// Set the material. -/// -/// The material need not be set explicitly when rendering a mesh -/// (gfx_llr_render_mesh). This is mostly useful when using the lower-level -/// function to render geometry (gfx_llr_render_geometry). -void gfx_llr_set_material(LLR*, const Material*); - -/// Set the camera. -void gfx_llr_set_camera(LLR*, const Camera*); - -/// Set the projection matrix. -void gfx_llr_set_projection_matrix(LLR* renderer, const mat4* projection); - -/// Set the aspect ratio. -void gfx_llr_set_aspect(LLR*, float aspect); - -/// Render the geometry. -void gfx_llr_render_geometry(LLR*, const Geometry*); - -/// Render the mesh. -void gfx_llr_render_mesh(LLR*, const Mesh*); - -// ----------------------------------------------------------------------------- -// Matrix stack manipulation. - -/// Load an identity model matrix. Clears the matrix stack. -void gfx_llr_load_identity(LLR* renderer); - -/// Push the given matrix to the matrix stack. -void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix); - -/// Pop the top of the matrix stack. -void gfx_llr_pop_matrix(LLR* renderer); - -/// Push a translation matrix to the matrix stack. -void gfx_llr_translate(LLR* renderer, vec3 offset); - -/// Set the model matrix. Clears the matrix stack. -void gfx_llr_set_model_matrix(LLR*, const mat4*); diff --git a/include/gfx/render/imm.h b/include/gfx/render/imm.h new file mode 100644 index 0000000..62c071e --- /dev/null +++ b/include/gfx/render/imm.h @@ -0,0 +1,52 @@ +#pragma once + +#include +#include +#include + +typedef struct Imm Imm; + +/// Prepare the graphics systems for immediate-mode rendering. +/// +/// Call this before issuing any immediate-mode rendering draws. +void gfx_imm_start(Imm*); + +/// End immediate mode rendering. +/// +/// Call this after issuing immediate-mode rendering draws and before swapping +/// buffers. +void gfx_imm_end(Imm*); + +/// Flush draw commands. +/// +/// This should be done when changing any state that may affect the rendering of +/// primitives; for example, LLR matrix stack changes. +void gfx_imm_flush(Imm*); + +/// Draw a set of triangles. +void gfx_imm_draw_triangles(Imm*, const vec3[], size_t num_triangles); + +/// Draw a triangle. +void gfx_imm_draw_triangle(Imm*, const vec3[3]); + +/// Draw a bounding box. +void gfx_imm_draw_aabb2(Imm*, aabb2); + +/// Draw a bounding box. +void gfx_imm_draw_aabb3(Imm*, aabb3); + +/// Draw a box. +/// +/// The vertices must be given in the following order: +/// +/// 7 ----- 6 +/// / /| +/// 3 ----- 2 | +/// | | | +/// | 4 ----- 5 +/// |/ |/ +/// 0 ----- 1 +void gfx_imm_draw_box3(Imm* renderer, const vec3 vertices[8]); + +/// Set the render colour. +void gfx_imm_set_colour(Imm*, vec4 colour); diff --git a/include/gfx/render/llr.h b/include/gfx/render/llr.h new file mode 100644 index 0000000..785f9cd --- /dev/null +++ b/include/gfx/render/llr.h @@ -0,0 +1,147 @@ +#pragma once + +#include +#include + +#include +#include +#include + +typedef struct Anima Anima; +typedef struct Geometry Geometry; +typedef struct Light Light; +typedef struct Material Material; +typedef struct Mesh Mesh; +typedef struct ShaderProgram ShaderProgram; +typedef struct Skeleton Skeleton; +typedef struct Texture Texture; + +typedef struct LLR LLR; + +// ----------------------------------------------------------------------------- +// Data structures. + +/// Light type. +typedef enum LightType { EnvironmentLightType } LightType; + +/// Describes an environment light. +typedef struct EnvironmentLightDesc { + const Texture* environment_map; +} EnvironmentLightDesc; + +/// Describes a light. +typedef struct LightDesc { + LightType type; + union { + EnvironmentLightDesc environment; + } light; +} LightDesc; + +/// Describes a material. +/// +/// TODO: It doesn't hold the shader program anymore...It's in the Mesh. +/// A material holds a shader program and a set of shader-specific uniform +/// variables. Two materials can share the same shader, but shader parameters +/// generally give two materials a different appearance. +typedef struct MaterialDesc { + ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL]; + int num_uniforms; +} MaterialDesc; + +/// Describes a mesh. +typedef struct MeshDesc { + const Geometry* geometry; + const Material* material; + ShaderProgram* shader; +} MeshDesc; + +/// Create a light. +Light* gfx_make_light(const LightDesc*); + +/// Destroy the light. +/// +/// TODO: Remove this comment. Inline node payload as described in node_impl.h +/// The light is conveniently removed from the scene graph and its parent scene +/// node is destroyed. +void gfx_destroy_light(Light**); + +/// Create a material. +Material* gfx_make_material(const MaterialDesc*); + +/// Destroy the material. +/// +/// The caller must make sure that no Mesh points to the given Material. +/// For a safe purge of unused resources, see scene_purge(). +void gfx_destroy_material(Material**); + +/// Create a mesh. +Mesh* gfx_make_mesh(const MeshDesc*); + +/// Destroy the mesh. +/// +/// The caller must make sure that no SceneObject points to the given Mesh. +/// For a safe purge of unused resources, see scene_purge(). +void gfx_destroy_mesh(Mesh**); + +// ----------------------------------------------------------------------------- +// Low-level rendering. + +/// Set the shader to be used for subsequent draw calls. +/// The shader is not yet activated at this point. +void gfx_llr_set_shader(LLR*, ShaderProgram*); + +/// Push a light into the lights stack. +void gfx_llr_push_light(LLR*, Light*); + +/// Pop the last light from the lights stack. +void gfx_llr_pop_light(LLR*); + +/// Load a skeleton. +/// +/// If a skeleton is loaded, subsequent meshes are rendered with joint data +/// passed to the shader. This has a cost, so if subsequent meshes are not +/// animated, unload the skeleton prior to rendering them. +void gfx_llr_set_skeleton(LLR*, const Anima*, const Skeleton*); + +/// Clear the loaded skeleton. +void gfx_llr_clear_skeleton(LLR*); + +/// Set the material. +/// +/// The material need not be set explicitly when rendering a mesh +/// (gfx_llr_render_mesh). This is mostly useful when using the lower-level +/// function to render geometry (gfx_llr_render_geometry). +void gfx_llr_set_material(LLR*, const Material*); + +/// Set the camera. +void gfx_llr_set_camera(LLR*, const Camera*); + +/// Set the projection matrix. +void gfx_llr_set_projection_matrix(LLR* renderer, const mat4* projection); + +/// Set the aspect ratio. +void gfx_llr_set_aspect(LLR*, float aspect); + +/// Render the geometry. +void gfx_llr_render_geometry(LLR*, const Geometry*); + +/// Render the mesh. +void gfx_llr_render_mesh(LLR*, const Mesh*); + +// ----------------------------------------------------------------------------- +// Matrix stack manipulation. + +/// Load an identity model matrix. Clears the matrix stack. +void gfx_llr_load_identity(LLR* renderer); + +/// Push the given matrix to the matrix stack. +void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix); + +/// Pop the top of the matrix stack. +void gfx_llr_pop_matrix(LLR* renderer); + +/// Push a translation matrix to the matrix stack. +void gfx_llr_translate(LLR* renderer, vec3 offset); + +/// Set the model matrix. Clears the matrix stack. +void gfx_llr_set_model_matrix(LLR*, const mat4*); diff --git a/include/gfx/render/renderer.h b/include/gfx/render/renderer.h new file mode 100644 index 0000000..1da74eb --- /dev/null +++ b/include/gfx/render/renderer.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +typedef struct GfxCore GfxCore; +typedef struct Scene Scene; +typedef struct SceneCamera SceneCamera; + +typedef struct Renderer Renderer; + +typedef enum RenderSceneMode { + RenderDefault, + RenderDebug, + RenderNormals, + RenderNormalMappedNormals, + RenderTangents +} RenderSceneMode; + +typedef struct RenderSceneParams { + RenderSceneMode mode; + const Scene* scene; + const SceneCamera* camera; +} RenderSceneParams; + +/// Render the scene. +void gfx_render_scene(Renderer*, const RenderSceneParams*); + +/// Update the scene. +void gfx_update(Scene*, const SceneCamera*, R t); diff --git a/include/gfx/renderer.h b/include/gfx/renderer.h deleted file mode 100644 index 1da74eb..0000000 --- a/include/gfx/renderer.h +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#include - -typedef struct GfxCore GfxCore; -typedef struct Scene Scene; -typedef struct SceneCamera SceneCamera; - -typedef struct Renderer Renderer; - -typedef enum RenderSceneMode { - RenderDefault, - RenderDebug, - RenderNormals, - RenderNormalMappedNormals, - RenderTangents -} RenderSceneMode; - -typedef struct RenderSceneParams { - RenderSceneMode mode; - const Scene* scene; - const SceneCamera* camera; -} RenderSceneParams; - -/// Render the scene. -void gfx_render_scene(Renderer*, const RenderSceneParams*); - -/// Update the scene. -void gfx_update(Scene*, const SceneCamera*, R t); diff --git a/include/gfx/renderer/imm_renderer.h b/include/gfx/renderer/imm_renderer.h deleted file mode 100644 index 62c071e..0000000 --- a/include/gfx/renderer/imm_renderer.h +++ /dev/null @@ -1,52 +0,0 @@ -#pragma once - -#include -#include -#include - -typedef struct Imm Imm; - -/// Prepare the graphics systems for immediate-mode rendering. -/// -/// Call this before issuing any immediate-mode rendering draws. -void gfx_imm_start(Imm*); - -/// End immediate mode rendering. -/// -/// Call this after issuing immediate-mode rendering draws and before swapping -/// buffers. -void gfx_imm_end(Imm*); - -/// Flush draw commands. -/// -/// This should be done when changing any state that may affect the rendering of -/// primitives; for example, LLR matrix stack changes. -void gfx_imm_flush(Imm*); - -/// Draw a set of triangles. -void gfx_imm_draw_triangles(Imm*, const vec3[], size_t num_triangles); - -/// Draw a triangle. -void gfx_imm_draw_triangle(Imm*, const vec3[3]); - -/// Draw a bounding box. -void gfx_imm_draw_aabb2(Imm*, aabb2); - -/// Draw a bounding box. -void gfx_imm_draw_aabb3(Imm*, aabb3); - -/// Draw a box. -/// -/// The vertices must be given in the following order: -/// -/// 7 ----- 6 -/// / /| -/// 3 ----- 2 | -/// | | | -/// | 4 ----- 5 -/// |/ |/ -/// 0 ----- 1 -void gfx_imm_draw_box3(Imm* renderer, const vec3 vertices[8]); - -/// Set the render colour. -void gfx_imm_set_colour(Imm*, vec4 colour); diff --git a/src/asset/model.c b/src/asset/model.c index 96d200f..1e05a85 100644 --- a/src/asset/model.c +++ b/src/asset/model.c @@ -82,28 +82,28 @@ #include "asset/model.h" #include "asset/texture.h" -#include "gfx/core.h" -#include "gfx/gfx.h" -#include "gfx/llr/llr.h" -#include "gfx/scene/animation.h" -#include "gfx/scene/camera.h" -#include "gfx/scene/node.h" -#include "gfx/scene/object.h" -#include "gfx/sizes.h" -#include "gfx/util/shader.h" - #include "gfx_assert.h" #include "scene/model_impl.h" -#include "cstring.h" -#include "error.h" -#include "log/log.h" -#include "math/camera.h" -#include "math/defs.h" -#include "math/mat4.h" -#include "math/quat.h" -#include "math/vec2.h" -#include "math/vec3.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "cgltf_tangents.h" #define CGLTF_IMPLEMENTATION diff --git a/src/gfx.c b/src/gfx.c index 18098d2..bf713ca 100644 --- a/src/gfx.c +++ b/src/gfx.c @@ -2,10 +2,10 @@ #include "asset/asset_cache.h" #include "core/core_impl.h" -#include "llr/llr_impl.h" #include "memory.h" -#include "renderer/imm_renderer_impl.h" -#include "renderer/renderer_impl.h" +#include "render/imm_impl.h" +#include "render/llr_impl.h" +#include "render/renderer_impl.h" #include #include diff --git a/src/llr/llr.c b/src/llr/llr.c deleted file mode 100644 index a1b37be..0000000 --- a/src/llr/llr.c +++ /dev/null @@ -1,527 +0,0 @@ -#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/llr/llr_impl.h b/src/llr/llr_impl.h deleted file mode 100644 index 6318ee0..0000000 --- a/src/llr/llr_impl.h +++ /dev/null @@ -1,117 +0,0 @@ -#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/memory.c b/src/memory.c index 39ae6ea..a68bc2b 100644 --- a/src/memory.c +++ b/src/memory.c @@ -2,7 +2,7 @@ #include -#include "llr/llr_impl.h" +#include "render/llr_impl.h" #include "scene/animation_impl.h" #include "scene/camera_impl.h" #include "scene/model_impl.h" 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*); diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c deleted file mode 100644 index b3af7e8..0000000 --- a/src/renderer/imm_renderer.c +++ /dev/null @@ -1,192 +0,0 @@ -#include "imm_renderer_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/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h deleted file mode 100644 index d87b910..0000000 --- a/src/renderer/imm_renderer_impl.h +++ /dev/null @@ -1,43 +0,0 @@ -#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/renderer/renderer.c b/src/renderer/renderer.c deleted file mode 100644 index 7797c83..0000000 --- a/src/renderer/renderer.c +++ /dev/null @@ -1,246 +0,0 @@ -#include "renderer_impl.h" - -#include "llr/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/renderer/renderer_impl.h b/src/renderer/renderer_impl.h deleted file mode 100644 index 7395915..0000000 --- a/src/renderer/renderer_impl.h +++ /dev/null @@ -1,25 +0,0 @@ -#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*); diff --git a/src/scene/node.c b/src/scene/node.c index b7cf467..c5c8d94 100644 --- a/src/scene/node.c +++ b/src/scene/node.c @@ -2,10 +2,10 @@ #include "animation_impl.h" #include "camera_impl.h" -#include "llr/llr_impl.h" #include "memory.h" #include "model_impl.h" #include "object_impl.h" +#include "render/llr_impl.h" #include "scene_graph.h" #include "gfx_assert.h" diff --git a/src/scene/object.c b/src/scene/object.c index 3b2d498..d1f355c 100644 --- a/src/scene/object.c +++ b/src/scene/object.c @@ -2,9 +2,9 @@ #include -#include "llr/llr_impl.h" #include "memory.h" #include "node_impl.h" +#include "render/llr_impl.h" #include diff --git a/src/util/skyquad.c b/src/util/skyquad.c index 847bc91..1a9b4af 100644 --- a/src/util/skyquad.c +++ b/src/util/skyquad.c @@ -1,7 +1,7 @@ #include +#include <../../include/gfx/render/llr.h> #include -#include #include #include #include -- cgit v1.2.3