From b37b5398a6afa940acd1138bde922a70838f33af Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Fri, 4 Jul 2025 10:37:01 -0700 Subject: Add the new low-level renderer, shared between the imm and scene graph renderer. LLR integration with the scene graph renderer not yet done. --- CMakeLists.txt | 7 +- README.md | 44 +++-- include/gfx/gfx.h | 6 +- include/gfx/llr/llr.h | 107 +++--------- include/gfx/renderer.h | 77 +-------- include/gfx/renderer/imm_renderer.h | 55 ++++++ include/gfx/scene.h | 7 +- include/gfx/sizes.h | 16 +- src/asset/model.c | 5 +- src/core/core.c | 4 + src/gfx.c | 24 ++- src/llr/light.c | 2 +- src/llr/llr.c | 329 ++++++++---------------------------- src/llr/llr_impl.h | 67 +++----- src/llr/material.c | 2 +- src/llr/material_impl.h | 5 +- src/llr/mesh.c | 2 +- src/renderer/imm_renderer.c | 192 +++++++++++++++++++++ src/renderer/imm_renderer_impl.h | 43 +++++ src/renderer/renderer.c | 46 +++-- src/renderer/renderer_impl.h | 6 +- src/scene/node.c | 2 +- src/scene/object.c | 2 +- src/scene/object_impl.h | 2 - src/scene/scene_memory.c | 6 +- src/util/skyquad.c | 17 +- 26 files changed, 539 insertions(+), 536 deletions(-) create mode 100644 include/gfx/renderer/imm_renderer.h create mode 100644 src/renderer/imm_renderer.c create mode 100644 src/renderer/imm_renderer_impl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4b1ba6a..c480daf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -49,13 +49,14 @@ add_library(gfx SHARED src/core/shader_program.c src/core/shader.c src/core/texture.c + src/llr/llr.c + src/llr/light.c + src/llr/material.c + src/llr/mesh.c src/renderer/imm_renderer.c src/renderer/renderer.c src/scene/animation.c src/scene/camera.c - src/scene/light.c - src/scene/material.c - src/scene/mesh.c src/scene/model.c src/scene/node.c src/scene/object.c diff --git a/README.md b/README.md index f0b103d..491761d 100644 --- a/README.md +++ b/README.md @@ -20,32 +20,35 @@ educational purposes. ### Gfx The `Gfx` object represents the graphics subsystem and is at the center of the -library's high-level API. The `Gfx` object exposes a `Render` backend and a -`Renderer` and allows the caller to create `Scene`s. +library's high-level API. The `Gfx` object exposes a render backend (`GfxCore`) +and a `Renderer`, and allows the caller to create `Scene`s. ### Render Backend -The `Render` backend is a thin abstraction layer over low-level graphics APIs -like OpenGL or Vulkan. It holds GPU resources such as geometry, textures, -shaders, etc, and exposes functions to manipulate them. +The render backend (`GfxCore`) is a thin abstraction layer over low-level +graphics APIs like OpenGL or Vulkan. It holds GPU resources such as geometry, +textures, shaders, etc, and exposes functions to manipulate them. -Currently there is only one implementation of the `Render` backend based on +Currently, there is only one implementation of the render backend based on OpenGL. #### Ownership -The `Render` backend owns all rendering resources: buffers, geometries, -textures, shaders, etc. Even resources that point to other resources do not own -those other resources (geometries pointing to buffers). +The render backend owns all rendering resources: buffers, geometries, textures, +shaders, etc. Even resources that point to other resources do not own those +other resources (geometries pointing to buffers). -There is no ownership tracking in the render backend. It is up to the client to +There is no lifetime tracking in the render backend. It is up to the client to manage resource lifetime. +### Low-level Renderer + +`ImmRenderer` is a low-level, immediate mode renderer. + ### Scene -A `Scene` encapsulates a scene graph. A scene graph contains the elements that -make up a scene: nodes, cameras, lights, objects, etc. The current scene graph -implementation includes: +A `Scene` graph contains the elements that make up a scene. The current scene +graph implementation includes: - Camera - Light @@ -64,7 +67,8 @@ functions to set the parent node of an object/camera/light. If we exposed the former, the API could create the illusion that the hierarchy can be a DAG. The strict tree hierarchy should not be that restrictive in practice. Even the -glTF 2.0 spec [enforces this](https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#nodes-and-hierarchy): +glTF 2.0 +spec [enforces this](https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#nodes-and-hierarchy): > *For Version 2.0 conformance, the glTF node hierarchy is not a directed > acyclic graph (DAG) or scene graph, but a disjoint union of strict trees. That @@ -76,9 +80,9 @@ glTF 2.0 spec [enforces this](https://github.com/KhronosGroup/glTF/blob/master/s Two use cases for instancing seem to be: 1. Creating N identical clones, but each with a unique transform. (Ex: N -animated characters animated in unison but located in different locations.) + animated characters animated in unison but located in different locations.) 2. Creating N copies of a sub-tree, each now being their own unique tree. (Ex: -The same N animated characters, but each of them now being animated separately.) + The same N animated characters, but each of them now being animated separately.) Some scene graphs ([Panda3D](https://docs.panda3d.org/1.10/python/programming/scene-graph/instancing)) @@ -87,10 +91,10 @@ to have multiple parents. This turns the scene graph into a DAG and adds a number of complications for us: 1. Shared ownership of children. We would now need some sort of ref counting or -deferred GC to delete nodes and their subtrees. + deferred GC to delete nodes and their subtrees. 2. Nodes no longer have a unique parent. 3. Given a node, we can no longer determine its location (which parent link do -you follow?), or any attribute that is derived from its parent(s). + you follow?), or any attribute that is derived from its parent(s). In our case, we stick to strict tree hierarchies. @@ -131,6 +135,10 @@ Code under `util/` provides functionality that need not be in the core part of the library (Gfx, render backend, scene or renderer). This includes functions to compute irradiance maps, create procedural geometry, etc. +### Memory management + +TODO + ## Ideas for Future Work - Render graphs to allow for custom multi-pass rendering algorithms. diff --git a/include/gfx/gfx.h b/include/gfx/gfx.h index 7c670a5..d5c25b6 100644 --- a/include/gfx/gfx.h +++ b/include/gfx/gfx.h @@ -3,6 +3,7 @@ typedef struct AssetCache AssetCache; typedef struct GfxCore GfxCore; typedef struct ImmRenderer ImmRenderer; +typedef struct LLR LLR; typedef struct Renderer Renderer; typedef struct Gfx Gfx; @@ -16,12 +17,15 @@ void gfx_destroy(Gfx**); /// Get the render backend. GfxCore* gfx_get_core(Gfx*); -/// Get the renderer. +/// Get the scene renderer. Renderer* gfx_get_renderer(Gfx*); /// Get the immediate mode renderer. ImmRenderer* gfx_get_imm_renderer(Gfx*); +/// Get the low-level renderer. +LLR* gfx_get_llr(Gfx*); + /// Get the asset cache. AssetCache* gfx_get_asset_cache(Gfx*); diff --git a/include/gfx/llr/llr.h b/include/gfx/llr/llr.h index 49b7706..57abffc 100644 --- a/include/gfx/llr/llr.h +++ b/include/gfx/llr/llr.h @@ -1,117 +1,64 @@ #pragma once -#include -#include #include #include #include -#include -typedef struct Anima Anima; -typedef struct Light Light; -typedef struct Mesh Mesh; -typedef struct Skeleton Skeleton; +typedef struct Anima Anima; +typedef struct Geometry Geometry; +typedef struct Light Light; +typedef struct Mesh Mesh; +typedef struct ShaderProgram ShaderProgram; +typedef struct Skeleton Skeleton; -typedef struct ImmRenderer ImmRenderer; +typedef struct LLR LLR; -/// Prepare the graphics systems for immediate-mode rendering. -/// -/// Call this before issuing any immediate-mode rendering draws. -void gfx_imm_start(ImmRenderer*); - -/// End immediate mode rendering. -/// -/// Call this after issuing immediate-mode rendering draws and before swapping -/// buffers. -void gfx_imm_end(ImmRenderer*); - -// ----------------------------------------------------------------------------- -// Immediate-mode rendering of scene elements. -// -// This renders models and meshes under lighting. It is up to the client to -// determine visibility, sort the calls optimally, etc. +/// 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_imm_push_light(ImmRenderer*, Light*); +void gfx_llr_push_light(LLR*, Light*); /// Pop the last light from the lights stack. -void gfx_imm_pop_light(ImmRenderer*); +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_imm_set_skeleton(ImmRenderer*, const Anima*, const Skeleton*); +void gfx_llr_set_skeleton(LLR*, const Anima*, const Skeleton*); /// Unload the loaded skeleton. -void gfx_imm_unset_skeleton(ImmRenderer*); +void gfx_llr_unset_skeleton(LLR*); -/// Render the mesh. -void gfx_imm_render_mesh(ImmRenderer*, const Mesh*); - -// ----------------------------------------------------------------------------- -// Immediate-mode rendering of primitives. -// -// This is rather inefficient and should be reserved for debug rendering. It -// also does not support lighting; the primitives are rendered with a constant -// colour. - -/// Draw a set of triangles. -void gfx_imm_draw_triangles(ImmRenderer*, const vec3[], size_t num_triangles); - -/// Draw a triangle. -void gfx_imm_draw_triangle(ImmRenderer*, const vec3[3]); +/// Set the camera. +void gfx_llr_set_camera(LLR*, const Camera*); -/// Draw a bounding box. -void gfx_imm_draw_aabb2(ImmRenderer*, aabb2); +/// Set the view-projection matrix. +// void gfx_llr_set_view_projection_matrix(LLR*, const mat4*); -/// Draw a bounding box. -void gfx_imm_draw_aabb3(ImmRenderer*, aabb3); +/// Render the geometry. +void gfx_llr_render_geometry(LLR*, const Geometry*); -/// 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(ImmRenderer* renderer, const vec3 vertices[8]); - -/// Set the render colour. -void gfx_imm_set_colour(ImmRenderer*, vec4 colour); +/// Render the mesh. +void gfx_llr_render_mesh(LLR*, const Mesh*); // ----------------------------------------------------------------------------- // Matrix stack manipulation. -// -// Common to both scene and and primitive rendering. /// Load an identity model matrix. Clears the matrix stack. -void gfx_imm_load_identity(ImmRenderer* renderer); +void gfx_llr_load_identity(LLR* renderer); /// Push the given matrix to the matrix stack. -void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix); +void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix); /// Pop the top of the matrix stack. -void gfx_imm_pop_matrix(ImmRenderer* renderer); +void gfx_llr_pop_matrix(LLR* renderer); /// Push a translation matrix to the matrix stack. -void gfx_imm_translate(ImmRenderer* renderer, vec3 offset); +void gfx_llr_translate(LLR* renderer, vec3 offset); /// Set the model matrix. Clears the matrix stack. -void gfx_imm_set_model_matrix(ImmRenderer*, const mat4*); - -// ----------------------------------------------------------------------------- -// Camera -// -// Common to both scene and and primitive rendering. - -/// Set the camera. -void gfx_imm_set_camera(ImmRenderer*, const Camera*); - -/// Set the view-projection matrix. -// void gfx_imm_set_view_projection_matrix(ImmRenderer*, const mat4*); +void gfx_llr_set_model_matrix(LLR*, const mat4*); diff --git a/include/gfx/renderer.h b/include/gfx/renderer.h index 2a4ada1..1da74eb 100644 --- a/include/gfx/renderer.h +++ b/include/gfx/renderer.h @@ -1,23 +1,12 @@ #pragma once -#include -#include -#include #include -#include -#include -#include typedef struct GfxCore GfxCore; typedef struct Scene Scene; typedef struct SceneCamera SceneCamera; -typedef struct ImmRenderer ImmRenderer; -typedef struct Renderer Renderer; - -// ----------------------------------------------------------------------------- -// Main Renderer. -// ----------------------------------------------------------------------------- +typedef struct Renderer Renderer; typedef enum RenderSceneMode { RenderDefault, @@ -38,67 +27,3 @@ void gfx_render_scene(Renderer*, const RenderSceneParams*); /// Update the scene. void gfx_update(Scene*, const SceneCamera*, R t); - -// ----------------------------------------------------------------------------- -// Immediate Mode Renderer. -// ----------------------------------------------------------------------------- - -/// Prepare the graphics systems for immediate-mode rendering. -/// -/// Call this before issuing any immediate-mode rendering draws. -void gfx_imm_start(ImmRenderer*); - -/// End immediate mode rendering. -/// -/// Call this after issuing immediate-mode rendering draws and before swapping -/// buffers. -void gfx_imm_end(ImmRenderer*); - -/// Draw a set of triangles. -void gfx_imm_draw_triangles(ImmRenderer*, const vec3[], size_t num_triangles); - -/// Draw a triangle. -void gfx_imm_draw_triangle(ImmRenderer*, const vec3[3]); - -/// Draw a bounding box. -void gfx_imm_draw_aabb2(ImmRenderer*, aabb2); - -/// Draw a bounding box. -void gfx_imm_draw_aabb3(ImmRenderer*, 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(ImmRenderer* renderer, const vec3 vertices[8]); - -/// Set the camera. -void gfx_imm_set_camera(ImmRenderer*, const Camera*); - -/// Load an identity model matrix. Clears the matrix stack. -void gfx_imm_load_identity(ImmRenderer* renderer); - -/// Push the given matrix to the matrix stack. -void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix); - -/// Pop the top of the matrix stack. -void gfx_imm_pop_matrix(ImmRenderer* renderer); - -/// Push a translation matrix to the matrix stack. -void gfx_imm_translate(ImmRenderer* renderer, vec3 offset); - -/// Set the model matrix. Clears the matrix stack. -void gfx_imm_set_model_matrix(ImmRenderer*, const mat4*); - -/// Set the view-projection matrix. -void gfx_imm_set_view_projection_matrix(ImmRenderer*, const mat4*); - -/// Set the render colour. -void gfx_imm_set_colour(ImmRenderer*, vec4 colour); diff --git a/include/gfx/renderer/imm_renderer.h b/include/gfx/renderer/imm_renderer.h new file mode 100644 index 0000000..db4d290 --- /dev/null +++ b/include/gfx/renderer/imm_renderer.h @@ -0,0 +1,55 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +typedef struct ImmRenderer ImmRenderer; + +/// Prepare the graphics systems for immediate-mode rendering. +/// +/// Call this before issuing any immediate-mode rendering draws. +void gfx_imm_start(ImmRenderer*); + +/// End immediate mode rendering. +/// +/// Call this after issuing immediate-mode rendering draws and before swapping +/// buffers. +void gfx_imm_end(ImmRenderer*); + +/// 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(ImmRenderer*); + +/// Draw a set of triangles. +void gfx_imm_draw_triangles(ImmRenderer*, const vec3[], size_t num_triangles); + +/// Draw a triangle. +void gfx_imm_draw_triangle(ImmRenderer*, const vec3[3]); + +/// Draw a bounding box. +void gfx_imm_draw_aabb2(ImmRenderer*, aabb2); + +/// Draw a bounding box. +void gfx_imm_draw_aabb3(ImmRenderer*, 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(ImmRenderer* renderer, const vec3 vertices[8]); + +/// Set the render colour. +void gfx_imm_set_colour(ImmRenderer*, vec4 colour); diff --git a/include/gfx/scene.h b/include/gfx/scene.h index abcaa70..37a7e0b 100644 --- a/include/gfx/scene.h +++ b/include/gfx/scene.h @@ -1,10 +1,11 @@ #pragma once +// TODO: Remove references to gfx/llr once the transition is complete. +#include +#include +#include #include #include -#include -#include -#include #include #include #include diff --git a/include/gfx/sizes.h b/include/gfx/sizes.h index 14f72bc..3eb7481 100644 --- a/include/gfx/sizes.h +++ b/include/gfx/sizes.h @@ -77,14 +77,20 @@ /// Maximum number of compiler defines in a Shader. #define GFX_MAX_SHADER_COMPILER_DEFINES 16 -// Renderer. +// Low-level renderer. + +/// Maximum number of lights that the low-level renderer can enable per rendered +/// mesh. +#define GFX_LLR_MAX_NUM_LIGHTS 8 + +/// Maximum number of matrices in the low-level renderer's matrix stack. +#define GFX_LLR_MAX_NUM_MATRICES 32 + +// Immediate-mode Renderer. /// Maximum number of triangles that the immediate-mode renderer can draw in a /// frame. -#define IMM_MAX_NUM_TRIANGLES 1024 - -/// Maximum number of matrices in the immediate-mode renderer's matrix stack. -#define IMM_MAX_NUM_MATRICES 32 +#define GFX_IMM_MAX_NUM_TRIANGLES 1024 // Asset Cache. diff --git a/src/asset/model.c b/src/asset/model.c index 402b2e1..0c57470 100644 --- a/src/asset/model.c +++ b/src/asset/model.c @@ -84,13 +84,12 @@ #include "asset/texture.h" #include "gfx/core.h" #include "gfx/gfx.h" +#include "gfx/llr/material.h" +#include "gfx/llr/mesh.h" #include "gfx/scene/animation.h" #include "gfx/scene/camera.h" -#include "gfx/scene/material.h" -#include "gfx/scene/mesh.h" #include "gfx/scene/node.h" #include "gfx/scene/object.h" -#include "gfx/scene/scene.h" #include "gfx/sizes.h" #include "gfx/util/shader.h" diff --git a/src/core/core.c b/src/core/core.c index 90038c6..e1671ea 100644 --- a/src/core/core.c +++ b/src/core/core.c @@ -420,6 +420,10 @@ void gfx_destroy_shader_program(GfxCore* gfxcore, ShaderProgram** prog) { // Remove the shader program from the cache. ProgramCache* cache = &gfxcore->program_cache; ShaderProgramCacheEntry* entry = find_program_cache_entry(cache, *prog); + // TODO: The following assertion is too restrictive. Clients can end up + // re-using the same shader by virtue of the cache. The assertion assumes + // that no two "different" clients use the same set of shaders. This can + // be relaxed by reference-counting the shaders in the cache. assert(entry); // Must be there, shaders can't go untracked. mempool_free(cache, &entry); diff --git a/src/gfx.c b/src/gfx.c index cd2ac90..4291ae7 100644 --- a/src/gfx.c +++ b/src/gfx.c @@ -2,20 +2,20 @@ #include "asset/asset_cache.h" #include "core/core_impl.h" +#include "llr/llr_impl.h" #include "renderer/imm_renderer_impl.h" #include "renderer/renderer_impl.h" #include "scene/scene_memory.h" -#include - #include #include typedef struct Gfx { AssetCache asset_cache; GfxCore gfxcore; - Renderer renderer; + LLR llr; ImmRenderer imm_renderer; + Renderer renderer; } Gfx; Gfx* gfx_init(void) { @@ -24,16 +24,20 @@ Gfx* gfx_init(void) { return 0; } gfx_init_gfxcore(&gfx->gfxcore); - if (!renderer_make(&gfx->renderer, &gfx->gfxcore)) { + if (!gfx_llr_make(&gfx->llr, &gfx->gfxcore)) { gfx_destroy(&gfx); return 0; } - if (!imm_renderer_make(&gfx->imm_renderer, &gfx->gfxcore)) { + if (!gfx_imm_make(&gfx->imm_renderer, &gfx->gfxcore, &gfx->llr)) { // TODO: Add error logs to the initialization failure cases here and inside // the renderers. gfx_destroy(&gfx); return 0; } + if (!gfx_renderer_make(&gfx->renderer, &gfx->llr, &gfx->gfxcore)) { + gfx_destroy(&gfx); + return 0; + } gfx_init_asset_cache(&gfx->asset_cache); scene_mem_init(); return gfx; @@ -45,8 +49,9 @@ void gfx_destroy(Gfx** gfx) { } scene_mem_destroy(); gfx_destroy_asset_cache(&(*gfx)->asset_cache); - renderer_destroy(&(*gfx)->renderer); - imm_renderer_destroy(&(*gfx)->imm_renderer); + gfx_renderer_destroy(&(*gfx)->renderer); + gfx_imm_destroy(&(*gfx)->imm_renderer); + gfx_llr_destroy(&(*gfx)->llr); gfx_del_gfxcore(&(*gfx)->gfxcore); free(*gfx); *gfx = 0; @@ -67,6 +72,11 @@ ImmRenderer* gfx_get_imm_renderer(Gfx* gfx) { return &gfx->imm_renderer; } +LLR* gfx_get_llr(Gfx* gfx) { + assert(gfx); + return &gfx->llr; +} + AssetCache* gfx_get_asset_cache(Gfx* gfx) { assert(gfx); return &gfx->asset_cache; diff --git a/src/llr/light.c b/src/llr/light.c index 168f16a..1d1c40d 100644 --- a/src/llr/light.c +++ b/src/llr/light.c @@ -1,4 +1,4 @@ -#include "../scene/light_impl.h" +#include "light_impl.h" #include "../scene/node_impl.h" #include "../scene/scene_memory.h" diff --git a/src/llr/llr.c b/src/llr/llr.c index 62a7c30..746f4b3 100644 --- a/src/llr/llr.c +++ b/src/llr/llr.c @@ -1,17 +1,14 @@ -#include "imm_renderer_impl.h" #include "light_impl.h" +#include "llr_impl.h" #include "mesh_impl.h" +#include "llr/material_impl.h" #include "scene/animation_impl.h" #include #include -#include - -#include #include -#include // memcpy static const int IRRADIANCE_MAP_WIDTH = 1024; static const int IRRADIANCE_MAP_HEIGHT = 1024; @@ -21,7 +18,7 @@ static const int BRDF_INTEGRATION_MAP_WIDTH = 512; static const int BRDF_INTEGRATION_MAP_HEIGHT = 512; /// Initialize renderer state for IBL. -static bool init_ibl(ImmRenderer* renderer) { +static bool init_ibl(LLR* renderer) { assert(renderer); assert(!renderer->ibl); assert(!renderer->brdf_integration_map); @@ -44,8 +41,7 @@ static bool init_ibl(ImmRenderer* renderer) { // /// Compute irradiance and prefiltered environment maps for the light if they /// have not been already computed. -static bool set_up_environment_light( - ImmRenderer* renderer, EnvironmentLight* light) { +static bool set_up_environment_light(LLR* renderer, EnvironmentLight* light) { assert(renderer); assert(light); assert(renderer->ibl); @@ -92,7 +88,7 @@ cleanup: return false; } -static void configure_light(ImmRenderer* renderer, Light* light) { +static void configure_light(LLR* renderer, Light* light) { assert(renderer); assert(light); @@ -127,20 +123,35 @@ static void configure_light(ImmRenderer* renderer, Light* light) { } } -static void configure_state(ImmRenderer* renderer) { +static void configure_state(LLR* renderer) { assert(renderer); // Check if anything changed first so that we don't call gfx_apply_uniforms() // unnecessarily. - const bool anything_changed = - renderer->camera_changed || renderer->lights_changed || - renderer->skeleton_changed || renderer->shader_changed; - if (!anything_changed) { + const bool nothing_changed = (renderer->changed_flags == 0); + if (nothing_changed) { + return; + } + // Setting a null shader is also allowed, in which case there is nothing to + // configure. + if (renderer->shader == 0) { + renderer->shader_changed = false; return; } // For convenience. ShaderProgram* const shader = renderer->shader; + const mat4* const model = &renderer->matrix_stack[renderer->stack_pointer]; + + // TODO: Check to see which ones the shader actually uses and avoid + // computing the unnecessary matrices. + + if (renderer->matrix_changed || renderer->shader_changed) { + renderer->matrix_changed = false; + + gfx_set_mat4_uniform(shader, "Model", model); + gfx_set_mat4_uniform(shader, "ModelMatrix", model); + } // TODO: camera_changed is not set anywhere. Need to think how imm primitive // rendering and imm mesh rendering work together. We could treat imm @@ -150,14 +161,10 @@ static void configure_state(ImmRenderer* renderer) { // Set all supported camera-related uniforms. Shaders can choose which ones // to use. - // TODO: Check to see which ones the shader actually uses and avoid - // computing the unnecessary matrices. - const mat4* const model = &renderer->matrix_stack[renderer->stack_pointer]; - const mat4 modelview = mat4_mul(renderer->view, *model); + const mat4 modelview = mat4_mul(renderer->view, *model); const mat4 view_proj = mat4_mul(renderer->projection, renderer->view); const mat4 mvp = mat4_mul(renderer->projection, modelview); - gfx_set_mat4_uniform(shader, "ModelMatrix", model); gfx_set_mat4_uniform(shader, "Modelview", &modelview); gfx_set_mat4_uniform(shader, "View", &renderer->view); gfx_set_mat4_uniform(shader, "Projection", &renderer->projection); @@ -195,58 +202,26 @@ static void configure_state(ImmRenderer* renderer) { gfx_apply_uniforms(renderer->shader); } -bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore) { +bool gfx_llr_make(LLR* renderer, GfxCore* gfxcore) { assert(renderer); assert(gfxcore); - const size_t num_triangle_verts = IMM_MAX_NUM_TRIANGLES * 3; - renderer->gfxcore = gfxcore; - - renderer->triangles = gfx_make_geometry( - gfxcore, - &(GeometryDesc){.type = Triangles, - .buffer_usage = BufferDynamic, - .num_verts = num_triangle_verts, - .positions3d = (BufferView3d){ - .size_bytes = num_triangle_verts * sizeof(vec3)}}); - if (!renderer->triangles) { - goto cleanup; - } - - renderer->imm_shader = gfx_make_immediate_mode_shader(gfxcore); - if (!renderer->imm_shader) { - goto cleanup; - } - renderer->shader = renderer->imm_shader; - if (!init_ibl(renderer)) { goto cleanup; } - - gfx_imm_load_identity(renderer); - gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f)); - + gfx_llr_load_identity(renderer); return true; cleanup: - gfx_imm_destroy(renderer); + gfx_llr_destroy(renderer); return false; } -void gfx_imm_destroy(ImmRenderer* renderer) { +void gfx_llr_destroy(LLR* renderer) { assert(renderer); assert(renderer->gfxcore); - if (renderer->triangles) { - gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles); - // TODO: Could also destroy the geometry's buffers here. - } - - if (renderer->imm_shader) { - gfx_destroy_shader_program(renderer->gfxcore, &renderer->imm_shader); - } - if (renderer->brdf_integration_map) { gfx_destroy_texture(renderer->gfxcore, &renderer->brdf_integration_map); } @@ -257,43 +232,9 @@ void gfx_imm_destroy(ImmRenderer* renderer) { } } -void gfx_imm_flush(ImmRenderer* renderer) { - assert(renderer); - - if (renderer->num_triangle_verts > 0) { - configure_state(renderer); - - gfx_update_geometry( - renderer->triangles, - &(GeometryDesc){ - .num_verts = renderer->num_triangle_verts, - .positions3d = (BufferView3d){ - .data = renderer->triangle_verts, - .size_bytes = renderer->num_triangle_verts * sizeof(vec3)} - }); - - gfx_apply_uniforms(renderer->shader); - gfx_render_geometry(renderer->triangles); - - renderer->num_triangle_verts = 0; - } -} - -void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) { +void gfx_llr_set_shader(LLR* renderer, ShaderProgram* shader) { assert(renderer); - assert(shader); - - // TODO: It would probably be best to make the imm renderer work in terms of a - // new LLR renderer. Otherwise we need to constantly flush stuff everywhere - // "just in case". This would still allow the imm to render meshes with - // lighting etc. We just need to create an actual Mesh out of the 'triangles' - // Geometry that imm currently has. The change would greatly simplify the - // implementation of this otherwise coupled LLR-IMM renderer. - // Need to decide where to put the matrix stack manipulation. Might be good - // to move to the LLR. (Currently, manipulating the stack causes an imm - // flush, but that's because we have coupled imm with stack manipulation, - // which the new design seems like would address.) - gfx_imm_flush(renderer); + // null shader is allowed, so do not assert it. // It's important to not set shader_changed unnecessarily, since that would // re-trigger the setting of uniforms. @@ -303,36 +244,17 @@ void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) { } } -void gfx_imm_start(ImmRenderer* renderer) { - assert(renderer); - - // Shader uniforms are applied lazily. - // TODO: In the event that gfx_activate_shader_program() activates uniforms - // automatically for convenience, call an overload here that doesn't do so. - gfx_activate_shader_program(renderer->shader); -} - -void gfx_imm_end(ImmRenderer* renderer) { - assert(renderer); - - gfx_imm_flush(renderer); - gfx_deactivate_shader_program(renderer->shader); - - // TODO: Should we clear all of the render state here as well? At least set - // the 'changed' variables to false, for example. -} - -void gfx_imm_push_light(ImmRenderer* renderer, Light* light) { +void gfx_llr_push_light(LLR* renderer, Light* light) { assert(renderer); assert(light); assert(renderer->num_lights >= 0); - ASSERT(renderer->num_lights < IMM_MAX_NUM_LIGHTS); + ASSERT(renderer->num_lights < GFX_LLR_MAX_NUM_LIGHTS); renderer->lights[renderer->num_lights++] = light; renderer->lights_changed = true; } -void gfx_imm_pop_light(ImmRenderer* renderer) { +void gfx_llr_pop_light(LLR* renderer) { assert(renderer); ASSERT(renderer->num_lights > 0); @@ -340,8 +262,8 @@ void gfx_imm_pop_light(ImmRenderer* renderer) { renderer->lights_changed = true; } -void gfx_imm_set_skeleton( - ImmRenderer* renderer, const Anima* anima, const Skeleton* skeleton) { +void gfx_llr_set_skeleton( + LLR* renderer, const Anima* anima, const Skeleton* skeleton) { assert(renderer); assert(anima); assert(skeleton); @@ -356,150 +278,73 @@ void gfx_imm_set_skeleton( renderer->skeleton_changed = true; } -void gfx_imm_unset_skeleton(ImmRenderer* renderer) { +void gfx_llr_unset_skeleton(LLR* renderer) { assert(renderer); renderer->num_joints = 0; renderer->skeleton_changed = true; } -void gfx_imm_render_mesh(ImmRenderer* renderer, const Mesh* mesh) { - assert(renderer); - assert(mesh); - assert(mesh->geometry); - assert(mesh->material); - - configure_state(renderer); - gfx_render_geometry(mesh->geometry); -} - -void gfx_imm_draw_triangles( - ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) { +void gfx_llr_set_camera(LLR* renderer, const Camera* camera) { assert(renderer); - assert(verts); - const size_t new_verts = num_triangles * 3; - assert( - renderer->num_triangle_verts + new_verts < (IMM_MAX_NUM_TRIANGLES * 3)); - - memcpy( - renderer->triangle_verts + renderer->num_triangle_verts, verts, - new_verts * sizeof(vec3)); - renderer->num_triangle_verts += new_verts; -} - -void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) { - gfx_imm_draw_triangles(renderer, verts, 1); + const mat4 view = spatial3_inverse_transform(&camera->spatial); + // const mat4 view_proj = mat4_mul(camera->projection, view); + // gfx_llr_set_view_projection_matrix(renderer, &view_proj); + renderer->view = view; + renderer->projection = camera->projection; + renderer->camera_changed = true; } -void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) { - assert(renderer); - - // clang-format off - const vec3 verts[4] = { - vec3_make(box.min.x, box.min.y, 0), // 3 ---- 2 - vec3_make(box.max.x, box.min.y, 0), // | | - vec3_make(box.max.x, box.max.y, 0), // | | - vec3_make(box.min.x, box.max.y, 0)}; // 0 ---- 1 - // clang-format on - -#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2] - const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)}; -#undef tri - - gfx_imm_draw_triangles(renderer, tris, 2); -} +// void gfx_llr_set_view_projection_matrix( +// LLR* renderer, const mat4* view_proj) { +// assert(renderer); +// assert(renderer->shader); +// +// gfx_llr_flush(renderer); +// gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj); +// } -void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) { +void gfx_llr_render_geometry(LLR* renderer, const Geometry* geometry) { assert(renderer); + assert(geometry); - // clang-format off - const vec3 vertices[8] = { - vec3_make(box.min.x, box.min.y, box.max.z), // 7 ----- 6 - vec3_make(box.max.x, box.min.y, box.max.z), // / /| - vec3_make(box.max.x, box.max.y, box.max.z), // 3 ----- 2 | - vec3_make(box.min.x, box.max.y, box.max.z), // | | | - vec3_make(box.min.x, box.min.y, box.min.z), // | 4 ----- 5 - vec3_make(box.max.x, box.min.y, box.min.z), // |/ |/ - vec3_make(box.max.x, box.max.y, box.min.z), // 0 ----- 1 - vec3_make(box.min.x, box.max.y, box.min.z)}; - // clang-format on - - gfx_imm_draw_box3(renderer, vertices); -} - -void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) { - assert(renderer); - assert(vertices); - - // 7 ----- 6 - // / /| - // 3 ----- 2 | - // | | | - // | 4 ----- 5 - // |/ |/ - // 0 ----- 1 - -#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2] - const vec3 tris[36] = { - // Front. - tri(0, 1, 2), tri(0, 2, 3), - // Right. - tri(1, 5, 6), tri(1, 6, 2), - // Back. - tri(5, 4, 7), tri(5, 7, 6), - // Left. - tri(4, 0, 03), tri(4, 3, 7), - // Top. - tri(3, 2, 6), tri(3, 6, 7), - // Bottom. - tri(0, 4, 5), tri(0, 5, 1)}; - - gfx_imm_draw_triangles(renderer, tris, 12); + configure_state(renderer); + gfx_render_geometry(geometry); } -void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) { +void gfx_llr_render_mesh(LLR* renderer, const Mesh* mesh) { assert(renderer); assert(renderer->shader); + assert(mesh); + assert(mesh->geometry); + assert(mesh->material); - gfx_imm_flush(renderer); - - gfx_set_vec4_uniform(renderer->shader, "Colour", colour); -} - -// Load the top of the matrix stack into the shader. -static void update_shader_model_matrix(ImmRenderer* renderer) { - assert(renderer); - - gfx_imm_flush(renderer); - - gfx_set_mat4_uniform( - renderer->shader, "Model", - &renderer->matrix_stack[renderer->stack_pointer]); + gfx_material_activate(renderer->shader, mesh->material); + gfx_llr_render_geometry(renderer, mesh->geometry); } -void gfx_imm_load_identity(ImmRenderer* renderer) { +void gfx_llr_load_identity(LLR* renderer) { assert(renderer); renderer->matrix_stack[0] = mat4_id(); renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) { +void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix) { assert(renderer); assert(matrix); assert(renderer->stack_pointer >= 0); - ASSERT(renderer->stack_pointer < IMM_MAX_NUM_MATRICES); + ASSERT(renderer->stack_pointer < GFX_LLR_MAX_NUM_MATRICES); renderer->stack_pointer += 1; renderer->matrix_stack[renderer->stack_pointer] = mat4_mul(*matrix, renderer->matrix_stack[renderer->stack_pointer - 1]); - - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_pop_matrix(ImmRenderer* renderer) { +void gfx_llr_pop_matrix(LLR* renderer) { assert(renderer); ASSERT(renderer->stack_pointer > 0); @@ -508,47 +353,21 @@ void gfx_imm_pop_matrix(ImmRenderer* renderer) { &renderer->matrix_stack[renderer->stack_pointer], 0, sizeof(renderer->matrix_stack[0])); renderer->stack_pointer -= 1; - - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } -void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) { +void gfx_llr_translate(LLR* renderer, vec3 offset) { assert(renderer); const mat4 mat = mat4_translate(offset); - gfx_imm_push_matrix(renderer, &mat); + gfx_llr_push_matrix(renderer, &mat); } -void gfx_imm_set_model_matrix(ImmRenderer* renderer, const mat4* model) { +void gfx_llr_set_model_matrix(LLR* renderer, const mat4* model) { assert(renderer); assert(model); - gfx_imm_flush(renderer); - renderer->matrix_stack[0] = *model; renderer->stack_pointer = 0; - update_shader_model_matrix(renderer); + renderer->matrix_changed = true; } - -void gfx_imm_set_camera(ImmRenderer* renderer, const Camera* camera) { - assert(renderer); - assert(renderer->shader); - - gfx_imm_flush(renderer); - - const mat4 view = spatial3_inverse_transform(&camera->spatial); - // const mat4 view_proj = mat4_mul(camera->projection, view); - // gfx_imm_set_view_projection_matrix(renderer, &view_proj); - renderer->view = view; - renderer->projection = camera->projection; - renderer->camera_changed = true; -} - -// void gfx_imm_set_view_projection_matrix( -// ImmRenderer* renderer, const mat4* view_proj) { -// assert(renderer); -// assert(renderer->shader); -// -// gfx_imm_flush(renderer); -// gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj); -// } diff --git a/src/llr/llr_impl.h b/src/llr/llr_impl.h index 5ccabd1..e9dc0ac 100644 --- a/src/llr/llr_impl.h +++ b/src/llr/llr_impl.h @@ -8,6 +8,7 @@ #include #include +#include typedef struct Geometry Geometry; typedef struct GfxCore GfxCore; @@ -33,67 +34,47 @@ typedef struct Texture Texture; /// Note that the shader program API has its own level of caching as well, so /// reconfiguration at the level of the renderer does not result in the /// worst-case set of graphics API calls. -/// -/// Currently, the immediate mode renderer can only draw up to a maximum number -/// of primitives per frame. It does not adjust this number dynamically. Keeps -/// things simple while the extra complexity is not needed. -/// TODO: Flush the buffer when it reaches its maximum size to remove this -/// constraint. -typedef struct ImmRenderer { +typedef struct LLR { GfxCore* gfxcore; - vec3 camera_position; - mat4 view; // Camera view matrix. - mat4 projection; // Camera projection matrix. - bool camera_changed; // Whether the camera parameters have changed. - - // ------------------------------------------- - // Immediate-mode rendering of scene elements. + union { + struct { + bool shader_changed : 1; // Whether the shader has changed. + bool camera_changed : 1; // Whether the camera parameters have changed. + bool lights_changed : 1; // Whether the lights have changed. + bool skeleton_changed : 1; // Whether the skeleton has changed. + bool matrix_changed : 1; // Whether the matrix stack has changed. + }; + uint8_t changed_flags; + }; IBL* ibl; Texture* brdf_integration_map; - ShaderProgram* shader; // Active shader. Not owned. - bool shader_changed; // Whether the shader has changed. + ShaderProgram* shader; // Active shader. Not owned. + + vec3 camera_position; + mat4 view; // Camera view matrix. + mat4 projection; // Camera projection matrix. // Lights are not const because environment lights store lazily-computed // irradiance maps. - Light* lights[IMM_MAX_NUM_LIGHTS]; // Lights stack. - int num_lights; // Number of lights enabled at a given point in time. It - // points to one past the top of the stack. - bool lights_changed; // Whether the lights have changed. + Light* lights[GFX_LLR_MAX_NUM_LIGHTS]; // Lights stack. + int num_lights; // Number of lights enabled at a given point in time. It + // points to one past the top of the stack. - bool skeleton_changed; size_t num_joints; mat4 joint_matrices[GFX_MAX_NUM_JOINTS]; - // --------------------------------------- - // Immediate-mode rendering of primitives. - - ShaderProgram* imm_shader; // Immediate-mode shader program for primitives. - Geometry* triangles; - size_t num_triangle_verts; // Number of triangle verts this frame. - // TODO: wireframe rendering. - struct { - bool wireframe : 1; - } flags; - vec3 triangle_verts[IMM_MAX_NUM_TRIANGLES * 3]; - - // ------------- - // Matrix stack. - // The matrix stack contains pre-multiplied matrices. // It is also never empty. The top of the stack is an identity matrix when the // stack is "empty" from the user's perspective. - mat4 matrix_stack[IMM_MAX_NUM_MATRICES]; + mat4 matrix_stack[GFX_LLR_MAX_NUM_MATRICES]; int stack_pointer; // Points to the top of the stack. -} ImmRenderer; +} LLR; /// Create a new immediate mode renderer. -bool gfx_imm_make(ImmRenderer*, GfxCore*); +bool gfx_llr_make(LLR*, GfxCore*); /// Destroy the immediate mode renderer. -void gfx_imm_destroy(ImmRenderer*); - -/// Flush draw commands. -void gfx_imm_flush(ImmRenderer*); +void gfx_llr_destroy(LLR*); diff --git a/src/llr/material.c b/src/llr/material.c index 47cb45f..4014482 100644 --- a/src/llr/material.c +++ b/src/llr/material.c @@ -48,7 +48,7 @@ static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) { } } -void material_activate(ShaderProgram* shader, const Material* material) { +void gfx_material_activate(ShaderProgram* shader, const Material* material) { assert(material); for (int i = 0; i < material->num_uniforms; ++i) { const ShaderUniform* uniform = &material->uniforms[i]; diff --git a/src/llr/material_impl.h b/src/llr/material_impl.h index f27bf4d..138497f 100644 --- a/src/llr/material_impl.h +++ b/src/llr/material_impl.h @@ -11,6 +11,5 @@ typedef struct Material { /// Activate the material. /// -/// This activates the material's shader and configures the shader uniforms that -/// are specific to the material. -void material_activate(ShaderProgram* shader, const Material* material); +/// This configures the shader uniforms that are specific to the material. +void gfx_material_activate(ShaderProgram* shader, const Material* material); diff --git a/src/llr/mesh.c b/src/llr/mesh.c index ae75d8c..3aebb04 100644 --- a/src/llr/mesh.c +++ b/src/llr/mesh.c @@ -1,4 +1,4 @@ -#include "../scene/mesh_impl.h" +#include "mesh_impl.h" #include "../scene/scene_memory.h" diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c new file mode 100644 index 0000000..01cc5bb --- /dev/null +++ b/src/renderer/imm_renderer.c @@ -0,0 +1,192 @@ +#include "imm_renderer_impl.h" + +#include +#include +#include +#include + +#include + +#include +#include // memcpy + +bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore, LLR* llr) { + assert(renderer); + assert(gfxcore); + assert(llr); + + const size_t num_triangle_verts = GFX_IMM_MAX_NUM_TRIANGLES * 3; + + renderer->gfxcore = gfxcore; + renderer->llr = llr; + + renderer->triangles = gfx_make_geometry( + gfxcore, + &(GeometryDesc){.type = Triangles, + .buffer_usage = BufferDynamic, + .num_verts = num_triangle_verts, + .positions3d = (BufferView3d){ + .size_bytes = num_triangle_verts * sizeof(vec3)}}); + if (!renderer->triangles) { + goto cleanup; + } + + renderer->shader = gfx_make_immediate_mode_shader(gfxcore); + if (!renderer->shader) { + goto cleanup; + } + + gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f)); + + return true; + +cleanup: + gfx_imm_destroy(renderer); + return false; +} + +void gfx_imm_destroy(ImmRenderer* renderer) { + assert(renderer); + assert(renderer->gfxcore); + + if (renderer->triangles) { + gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles); + // TODO: Could also destroy the geometry's buffers here. + } + + if (renderer->shader) { + gfx_destroy_shader_program(renderer->gfxcore, &renderer->shader); + } +} + +void gfx_imm_flush(ImmRenderer* renderer) { + assert(renderer); + + if (renderer->num_triangle_verts > 0) { + gfx_update_geometry( + renderer->triangles, + &(GeometryDesc){ + .num_verts = renderer->num_triangle_verts, + .positions3d = (BufferView3d){ + .data = renderer->triangle_verts, + .size_bytes = renderer->num_triangle_verts * sizeof(vec3)} + }); + + gfx_llr_render_geometry(renderer->llr, renderer->triangles); + + renderer->num_triangle_verts = 0; + } +} + +void gfx_imm_start(ImmRenderer* renderer) { + assert(renderer); + + // Shader uniforms are applied lazily. + // TODO: In the event that gfx_activate_shader_program() activates uniforms + // automatically for convenience, call an overload here that doesn't do so. + // gfx_activate_shader_program(renderer->shader); + gfx_llr_set_shader(renderer->llr, renderer->shader); +} + +void gfx_imm_end(ImmRenderer* renderer) { + assert(renderer); + + gfx_imm_flush(renderer); + // gfx_deactivate_shader_program(renderer->shader); + gfx_llr_set_shader(renderer->llr, 0); +} + +void gfx_imm_draw_triangles( + ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) { + assert(renderer); + assert(verts); + const size_t new_verts = num_triangles * 3; + assert( + renderer->num_triangle_verts + new_verts < + (GFX_IMM_MAX_NUM_TRIANGLES * 3)); + + memcpy( + renderer->triangle_verts + renderer->num_triangle_verts, verts, + new_verts * sizeof(vec3)); + + renderer->num_triangle_verts += new_verts; +} + +void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) { + gfx_imm_draw_triangles(renderer, verts, 1); +} + +void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) { + assert(renderer); + + // clang-format off + const vec3 verts[4] = { + vec3_make(box.min.x, box.min.y, 0), // 3 ---- 2 + vec3_make(box.max.x, box.min.y, 0), // | | + vec3_make(box.max.x, box.max.y, 0), // | | + vec3_make(box.min.x, box.max.y, 0)}; // 0 ---- 1 + // clang-format on + +#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2] + const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)}; +#undef tri + + gfx_imm_draw_triangles(renderer, tris, 2); +} + +void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) { + assert(renderer); + + // clang-format off + const vec3 vertices[8] = { + vec3_make(box.min.x, box.min.y, box.max.z), // 7 ----- 6 + vec3_make(box.max.x, box.min.y, box.max.z), // / /| + vec3_make(box.max.x, box.max.y, box.max.z), // 3 ----- 2 | + vec3_make(box.min.x, box.max.y, box.max.z), // | | | + vec3_make(box.min.x, box.min.y, box.min.z), // | 4 ----- 5 + vec3_make(box.max.x, box.min.y, box.min.z), // |/ |/ + vec3_make(box.max.x, box.max.y, box.min.z), // 0 ----- 1 + vec3_make(box.min.x, box.max.y, box.min.z)}; + // clang-format on + + gfx_imm_draw_box3(renderer, vertices); +} + +void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) { + assert(renderer); + assert(vertices); + + // 7 ----- 6 + // / /| + // 3 ----- 2 | + // | | | + // | 4 ----- 5 + // |/ |/ + // 0 ----- 1 + +#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2] + const vec3 tris[36] = { + // Front. + tri(0, 1, 2), tri(0, 2, 3), + // Right. + tri(1, 5, 6), tri(1, 6, 2), + // Back. + tri(5, 4, 7), tri(5, 7, 6), + // Left. + tri(4, 0, 03), tri(4, 3, 7), + // Top. + tri(3, 2, 6), tri(3, 6, 7), + // Bottom. + tri(0, 4, 5), tri(0, 5, 1)}; + + gfx_imm_draw_triangles(renderer, tris, 12); +} + +void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) { + assert(renderer); + assert(renderer->shader); + + gfx_imm_flush(renderer); + + gfx_set_vec4_uniform(renderer->shader, "Colour", colour); +} diff --git a/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h new file mode 100644 index 0000000..61b49a7 --- /dev/null +++ b/src/renderer/imm_renderer_impl.h @@ -0,0 +1,43 @@ +#pragma once + +#include + +#include + +#include +#include + +typedef struct Geometry Geometry; +typedef struct GfxCore GfxCore; +typedef struct IBL IBL; +typedef struct LLR LLR; +typedef struct Material Material; +typedef struct ShaderProgram ShaderProgram; +typedef struct Texture Texture; + +/// Immediate mode renderer. +/// +/// Currently, the immediate mode renderer can only draw up to a maximum number +/// of primitives per frame. It does not adjust this number dynamically. Keeps +/// things simple while the extra complexity is not needed. +/// TODO: Flush the buffer when it reaches its maximum size to remove this +/// constraint. +typedef struct ImmRenderer { + GfxCore* gfxcore; + LLR* llr; + + ShaderProgram* shader; // Immediate-mode shader program for primitives. + Geometry* triangles; + size_t num_triangle_verts; // Number of triangle verts this frame. + // TODO: wireframe rendering. + struct { + bool wireframe : 1; + } flags; + vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3]; +} ImmRenderer; + +/// Create a new immediate mode renderer. +bool gfx_imm_make(ImmRenderer*, GfxCore*, LLR*); + +/// Destroy the immediate mode renderer. +void gfx_imm_destroy(ImmRenderer*); diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c index c2a7dda..0c1fe78 100644 --- a/src/renderer/renderer.c +++ b/src/renderer/renderer.c @@ -1,10 +1,10 @@ #include "renderer_impl.h" +#include "llr/light_impl.h" +#include "llr/material_impl.h" +#include "llr/mesh_impl.h" #include "scene/animation_impl.h" #include "scene/camera_impl.h" -#include "scene/light_impl.h" -#include "scene/material_impl.h" -#include "scene/mesh_impl.h" #include "scene/model_impl.h" #include "scene/node_impl.h" #include "scene/object_impl.h" @@ -12,16 +12,18 @@ #include "scene/scene_memory.h" #include +#include #include #include -#include +// #include +#include "gfx/gfx.h" + #include #include #include -// TODO: Move to a header like "constants.h". static const int IRRADIANCE_MAP_WIDTH = 1024; static const int IRRADIANCE_MAP_HEIGHT = 1024; static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH = 128; @@ -29,16 +31,18 @@ static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128; static const int BRDF_INTEGRATION_MAP_WIDTH = 512; static const int BRDF_INTEGRATION_MAP_HEIGHT = 512; -bool renderer_make(Renderer* renderer, GfxCore* gfxcore) { +bool gfx_renderer_make(Renderer* renderer, LLR* llr, GfxCore* gfxcore) { assert(renderer); + assert(llr); assert(gfxcore); renderer->gfxcore = gfxcore; + renderer->llr = llr; return true; } -void renderer_destroy(Renderer* renderer) { +void gfx_renderer_destroy(Renderer* renderer) { if (!renderer) { return; } @@ -117,9 +121,9 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) { // } // } -/// Computes irradiance and prefiltered environment maps for the light if they +/// Compute irradiance and prefiltered environment maps for the light if they /// have not been already computed. -static bool setup_environment_light( +static bool set_up_environment_light( Renderer* renderer, GfxCore* gfxcore, EnvironmentLight* light) { assert(renderer); assert(light); @@ -168,6 +172,7 @@ cleanup: typedef struct RenderState { GfxCore* gfxcore; + LLR* llr; Renderer* renderer; ShaderProgram* shader; // Null to use scene shaders. const Scene* scene; @@ -209,6 +214,7 @@ static void draw_recursively( // Anima. if (node->type == AnimaNode) { + // Save the anima so that we can animate objects. state->anima = gfx_get_node_anima(node); } // Activate light. @@ -217,7 +223,7 @@ static void draw_recursively( assert(light); if (light->type == EnvironmentLightType) { - bool result = setup_environment_light( + bool result = set_up_environment_light( state->renderer, state->gfxcore, &light->environment); // TODO: Handle the result in a better way. assert(result); @@ -238,11 +244,13 @@ static void draw_recursively( // TODO: Here we would frustum-cull the object. // TODO: Avoid computing matrices like Modelview or MVP if the shader does - // not use them. + // not use them. const mat4 model_matrix = node_transform; const mat4 modelview = mat4_mul(*state->view_matrix, model_matrix); const mat4 mvp = mat4_mul(*state->projection, modelview); + // A model/anima can have many skeletons. We need to animate the given + // object using its skeleton, not just any skeleton of the anima. if (object->skeleton.val) { load_skeleton(state, object->skeleton); } @@ -260,9 +268,11 @@ static void draw_recursively( assert(mesh->material); // TODO: Here we would frustum-cull the mesh. The AABB would have to be - // transformed by the model matrix. Rotation would make the AABB - // relatively large, but still, the culling would be conservative. + // transformed by the model matrix. Rotation would make the AABB + // relatively large, but still, the culling would be conservative. + // TODO: Make sure we strictly set only the uniforms that are required by + // mesh rendering. See the other item below. // Apply common shader uniforms not captured by materials. ShaderProgram* shader = state->shader ? state->shader : mesh->shader; gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix); @@ -270,7 +280,10 @@ static void draw_recursively( gfx_set_mat4_uniform(shader, "View", state->view_matrix); gfx_set_mat4_uniform(shader, "Projection", state->projection); gfx_set_mat4_uniform(shader, "MVP", &mvp); + // TODO: CameraRotation is only used by the skyquad and cubemap_filtering + // shaders, not mesh rendering. gfx_set_mat4_uniform(shader, "CameraRotation", state->camera_rotation); + // TODO: Fovy and Aspect are only used by the skyquad, not necessary here. gfx_set_float_uniform(shader, "Fovy", state->fovy); gfx_set_float_uniform(shader, "Aspect", state->aspect); if (state->camera) { @@ -297,9 +310,9 @@ static void draw_recursively( shader, "PrefilteredEnvironmentMap", light->prefiltered_environment_map); gfx_set_float_uniform( - shader, "MaxReflectionLOD", light->max_reflection_lod); + shader, "MaxReflectionLOD", (float)light->max_reflection_lod); } - material_activate(shader, mesh->material); + gfx_material_activate(shader, mesh->material); gfx_activate_shader_program(shader); gfx_apply_uniforms(shader); gfx_render_geometry(mesh->geometry); @@ -327,7 +340,7 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) { const Scene* scene = params->scene; const SceneCamera* camera = params->camera; - GfxCore* gfxcore = renderer->gfxcore; + GfxCore* const gfxcore = renderer->gfxcore; mat4 projection, camera_rotation, view_matrix; if (camera) { @@ -347,6 +360,7 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) { RenderState state = { .gfxcore = gfxcore, + .llr = renderer->llr, .renderer = renderer, .shader = shader, .scene = scene, diff --git a/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h index fc14dcb..6fd0c15 100644 --- a/src/renderer/renderer_impl.h +++ b/src/renderer/renderer_impl.h @@ -5,11 +5,13 @@ #include typedef struct IBL IBL; +typedef struct LLR LLR; typedef struct ShaderProgram ShaderProgram; typedef struct Texture Texture; typedef struct Renderer { GfxCore* gfxcore; + LLR* llr; IBL* ibl; Texture* brdf_integration_map; struct { @@ -21,7 +23,7 @@ typedef struct Renderer { } Renderer; /// Create a new renderer. -bool renderer_make(Renderer*, GfxCore*); +bool gfx_renderer_make(Renderer*, LLR*, GfxCore*); /// Destroy the renderer. -void renderer_destroy(Renderer*); +void gfx_renderer_destroy(Renderer*); diff --git a/src/scene/node.c b/src/scene/node.c index 67ce93c..e359f73 100644 --- a/src/scene/node.c +++ b/src/scene/node.c @@ -2,7 +2,7 @@ #include "animation_impl.h" #include "camera_impl.h" -#include "light_impl.h" +#include "llr/light_impl.h" #include "model_impl.h" #include "object_impl.h" #include "scene_graph.h" diff --git a/src/scene/object.c b/src/scene/object.c index e8e3ee6..27ff5db 100644 --- a/src/scene/object.c +++ b/src/scene/object.c @@ -2,7 +2,7 @@ #include -#include "mesh_impl.h" +#include "llr/mesh_impl.h" #include "node_impl.h" #include "scene_memory.h" diff --git a/src/scene/object_impl.h b/src/scene/object_impl.h index ead93f1..e864e53 100644 --- a/src/scene/object_impl.h +++ b/src/scene/object_impl.h @@ -4,8 +4,6 @@ #include "types.h" -#include - typedef struct MeshLink { mesh_idx mesh; mesh_link_idx next; // Next MeshLink in the list. diff --git a/src/scene/scene_memory.c b/src/scene/scene_memory.c index 91880bb..3a01325 100644 --- a/src/scene/scene_memory.c +++ b/src/scene/scene_memory.c @@ -4,9 +4,9 @@ #include "animation_impl.h" #include "camera_impl.h" -#include "light_impl.h" -#include "material_impl.h" -#include "mesh_impl.h" +#include "llr/light_impl.h" +#include "llr/material_impl.h" +#include "llr/mesh_impl.h" #include "model_impl.h" #include "node_impl.h" #include "object_impl.h" diff --git a/src/util/skyquad.c b/src/util/skyquad.c index 08fa044..094de67 100644 --- a/src/util/skyquad.c +++ b/src/util/skyquad.c @@ -1,18 +1,14 @@ #include #include -#include -#include -#include -#include +#include +#include +#include #include #include -#include #include #include -#include - #include SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) { @@ -36,10 +32,9 @@ SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) { } MaterialDesc material_desc = (MaterialDesc){0}; - material_desc.uniforms[0] = (ShaderUniform){ - .type = UniformTexture, - .value.texture = texture, - .name = sstring_make("Skyquad")}; + material_desc.uniforms[0] = (ShaderUniform){.type = UniformTexture, + .value.texture = texture, + .name = sstring_make("Skyquad")}; material_desc.num_uniforms = 1; material = gfx_make_material(&material_desc); if (!material) { -- cgit v1.2.3