aboutsummaryrefslogtreecommitdiff
path: root/src/renderer
diff options
context:
space:
mode:
author3gg <3gg@shellblade.net>2025-10-24 18:33:36 -0700
committer3gg <3gg@shellblade.net>2025-10-24 18:33:36 -0700
commit65d448aad0e6c792b1adba1272efef73b31c4885 (patch)
treeeb63247058bcaa11c8f792b52df20e96ee92e8b5 /src/renderer
parent175c72557b21f356e295a6f8a4acd91b7e744bef (diff)
Consolidate renderers
Diffstat (limited to 'src/renderer')
-rw-r--r--src/renderer/imm_renderer.c192
-rw-r--r--src/renderer/imm_renderer_impl.h43
-rw-r--r--src/renderer/renderer.c246
-rw-r--r--src/renderer/renderer_impl.h25
4 files changed, 0 insertions, 506 deletions
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 @@
1#include "imm_renderer_impl.h"
2
3#include <gfx/core.h>
4#include <gfx/llr/llr.h>
5#include <gfx/renderer/imm_renderer.h>
6#include <gfx/util/shader.h>
7
8#include <math/aabb3.h>
9
10#include <assert.h>
11#include <string.h> // memcpy
12
13bool gfx_imm_make(Imm* renderer, GfxCore* gfxcore, LLR* llr) {
14 assert(renderer);
15 assert(gfxcore);
16 assert(llr);
17
18 const size_t num_triangle_verts = GFX_IMM_MAX_NUM_TRIANGLES * 3;
19
20 renderer->gfxcore = gfxcore;
21 renderer->llr = llr;
22
23 renderer->triangles = gfx_make_geometry(
24 gfxcore,
25 &(GeometryDesc){.type = Triangles,
26 .buffer_usage = BufferDynamic,
27 .num_verts = num_triangle_verts,
28 .positions3d = (BufferView3d){
29 .size_bytes = num_triangle_verts * sizeof(vec3)}});
30 if (!renderer->triangles) {
31 goto cleanup;
32 }
33
34 renderer->shader = gfx_make_immediate_mode_shader(gfxcore);
35 if (!renderer->shader) {
36 goto cleanup;
37 }
38
39 gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f));
40
41 return true;
42
43cleanup:
44 gfx_imm_destroy(renderer);
45 return false;
46}
47
48void gfx_imm_destroy(Imm* renderer) {
49 assert(renderer);
50 assert(renderer->gfxcore);
51
52 if (renderer->triangles) {
53 gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles);
54 // TODO: Could also destroy the geometry's buffers here.
55 }
56
57 if (renderer->shader) {
58 gfx_destroy_shader_program(renderer->gfxcore, &renderer->shader);
59 }
60}
61
62void gfx_imm_flush(Imm* renderer) {
63 assert(renderer);
64
65 if (renderer->num_triangle_verts > 0) {
66 gfx_update_geometry(
67 renderer->triangles,
68 &(GeometryDesc){
69 .num_verts = renderer->num_triangle_verts,
70 .positions3d = (BufferView3d){
71 .data = renderer->triangle_verts,
72 .size_bytes = renderer->num_triangle_verts * sizeof(vec3)}
73 });
74
75 gfx_llr_render_geometry(renderer->llr, renderer->triangles);
76
77 renderer->num_triangle_verts = 0;
78 }
79}
80
81void gfx_imm_start(Imm* renderer) {
82 assert(renderer);
83
84 // Shader uniforms are applied lazily.
85 // TODO: In the event that gfx_activate_shader_program() activates uniforms
86 // automatically for convenience, call an overload here that doesn't do so.
87 // gfx_activate_shader_program(renderer->shader);
88 gfx_llr_set_shader(renderer->llr, renderer->shader);
89}
90
91void gfx_imm_end(Imm* renderer) {
92 assert(renderer);
93
94 gfx_imm_flush(renderer);
95 // gfx_deactivate_shader_program(renderer->shader);
96 gfx_llr_set_shader(renderer->llr, 0);
97}
98
99void gfx_imm_draw_triangles(
100 Imm* renderer, const vec3 verts[], size_t num_triangles) {
101 assert(renderer);
102 assert(verts);
103 const size_t new_verts = num_triangles * 3;
104 assert(
105 renderer->num_triangle_verts + new_verts <
106 (GFX_IMM_MAX_NUM_TRIANGLES * 3));
107
108 memcpy(
109 renderer->triangle_verts + renderer->num_triangle_verts, verts,
110 new_verts * sizeof(vec3));
111
112 renderer->num_triangle_verts += new_verts;
113}
114
115void gfx_imm_draw_triangle(Imm* renderer, const vec3 verts[3]) {
116 gfx_imm_draw_triangles(renderer, verts, 1);
117}
118
119void gfx_imm_draw_aabb2(Imm* renderer, aabb2 box) {
120 assert(renderer);
121
122 // clang-format off
123 const vec3 verts[4] = {
124 vec3_make(box.min.x, box.min.y, 0), // 3 ---- 2
125 vec3_make(box.max.x, box.min.y, 0), // | |
126 vec3_make(box.max.x, box.max.y, 0), // | |
127 vec3_make(box.min.x, box.max.y, 0)}; // 0 ---- 1
128 // clang-format on
129
130#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2]
131 const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)};
132#undef tri
133
134 gfx_imm_draw_triangles(renderer, tris, 2);
135}
136
137void gfx_imm_draw_aabb3(Imm* renderer, aabb3 box) {
138 assert(renderer);
139
140 // clang-format off
141 const vec3 vertices[8] = {
142 vec3_make(box.min.x, box.min.y, box.max.z), // 7 ----- 6
143 vec3_make(box.max.x, box.min.y, box.max.z), // / /|
144 vec3_make(box.max.x, box.max.y, box.max.z), // 3 ----- 2 |
145 vec3_make(box.min.x, box.max.y, box.max.z), // | | |
146 vec3_make(box.min.x, box.min.y, box.min.z), // | 4 ----- 5
147 vec3_make(box.max.x, box.min.y, box.min.z), // |/ |/
148 vec3_make(box.max.x, box.max.y, box.min.z), // 0 ----- 1
149 vec3_make(box.min.x, box.max.y, box.min.z)};
150 // clang-format on
151
152 gfx_imm_draw_box3(renderer, vertices);
153}
154
155void gfx_imm_draw_box3(Imm* renderer, const vec3 vertices[8]) {
156 assert(renderer);
157 assert(vertices);
158
159 // 7 ----- 6
160 // / /|
161 // 3 ----- 2 |
162 // | | |
163 // | 4 ----- 5
164 // |/ |/
165 // 0 ----- 1
166
167#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2]
168 const vec3 tris[36] = {
169 // Front.
170 tri(0, 1, 2), tri(0, 2, 3),
171 // Right.
172 tri(1, 5, 6), tri(1, 6, 2),
173 // Back.
174 tri(5, 4, 7), tri(5, 7, 6),
175 // Left.
176 tri(4, 0, 03), tri(4, 3, 7),
177 // Top.
178 tri(3, 2, 6), tri(3, 6, 7),
179 // Bottom.
180 tri(0, 4, 5), tri(0, 5, 1)};
181
182 gfx_imm_draw_triangles(renderer, tris, 12);
183}
184
185void gfx_imm_set_colour(Imm* renderer, vec4 colour) {
186 assert(renderer);
187 assert(renderer->shader);
188
189 gfx_imm_flush(renderer);
190
191 gfx_set_vec4_uniform(renderer->shader, "Colour", colour);
192}
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 @@
1#pragma once
2
3#include <gfx/sizes.h>
4
5#include <math/vec3.h>
6
7#include <stdbool.h>
8#include <stddef.h>
9
10typedef struct Geometry Geometry;
11typedef struct GfxCore GfxCore;
12typedef struct IBL IBL;
13typedef struct LLR LLR;
14typedef struct Material Material;
15typedef struct ShaderProgram ShaderProgram;
16typedef struct Texture Texture;
17
18/// Immediate mode renderer.
19///
20/// Currently, the immediate mode renderer can only draw up to a maximum number
21/// of primitives per frame. It does not adjust this number dynamically. Keeps
22/// things simple while the extra complexity is not needed.
23/// TODO: Flush the buffer when it reaches its maximum size to remove this
24/// constraint.
25typedef struct Imm {
26 GfxCore* gfxcore;
27 LLR* llr;
28
29 ShaderProgram* shader; // Immediate-mode shader program for primitives.
30 Geometry* triangles;
31 size_t num_triangle_verts; // Number of triangle verts this frame.
32 // TODO: wireframe rendering.
33 struct {
34 bool wireframe : 1;
35 } flags;
36 vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3];
37} Imm;
38
39/// Create a new immediate mode renderer.
40bool gfx_imm_make(Imm*, GfxCore*, LLR*);
41
42/// Destroy the immediate mode renderer.
43void 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 @@
1#include "renderer_impl.h"
2
3#include "llr/llr_impl.h"
4#include "memory.h"
5#include "scene/animation_impl.h"
6#include "scene/camera_impl.h"
7#include "scene/model_impl.h"
8#include "scene/node_impl.h"
9#include "scene/object_impl.h"
10#include "scene/scene_impl.h"
11
12#include <gfx/core.h>
13#include <gfx/llr/llr.h>
14#include <gfx/util/shader.h>
15
16#include <math/mat4.h>
17
18#include <assert.h>
19
20bool gfx_renderer_make(Renderer* renderer, LLR* llr, GfxCore* gfxcore) {
21 assert(renderer);
22 assert(llr);
23 assert(gfxcore);
24
25 renderer->gfxcore = gfxcore;
26 renderer->llr = llr;
27
28 return true;
29}
30
31void gfx_renderer_destroy(Renderer* renderer) {
32 if (!renderer) {
33 return;
34 }
35 assert(renderer->gfxcore);
36 GfxCore* gfxcore = renderer->gfxcore;
37 if (renderer->shaders.debug) {
38 gfx_destroy_shader_program(gfxcore, &renderer->shaders.debug);
39 }
40 if (renderer->shaders.normals) {
41 gfx_destroy_shader_program(gfxcore, &renderer->shaders.normals);
42 }
43 if (renderer->shaders.normal_mapped_normals) {
44 gfx_destroy_shader_program(
45 gfxcore, &renderer->shaders.normal_mapped_normals);
46 }
47 if (renderer->shaders.tangents) {
48 gfx_destroy_shader_program(gfxcore, &renderer->shaders.tangents);
49 }
50}
51
52static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
53 assert(renderer);
54
55#define LOAD_AND_RETURN(pShader, constructor) \
56 { \
57 if (!pShader) { \
58 pShader = constructor(renderer->gfxcore); \
59 } \
60 assert(pShader); \
61 return pShader; \
62 }
63
64 switch (mode) {
65 case RenderDefault:
66 return 0;
67 case RenderDebug:
68 LOAD_AND_RETURN(renderer->shaders.debug, gfx_make_debug3d_shader);
69 case RenderNormals:
70 LOAD_AND_RETURN(renderer->shaders.normals, gfx_make_view_normals_shader);
71 case RenderNormalMappedNormals:
72 LOAD_AND_RETURN(
73 renderer->shaders.normal_mapped_normals,
74 gfx_make_view_normal_mapped_normals_shader);
75 case RenderTangents:
76 LOAD_AND_RETURN(renderer->shaders.tangents, gfx_make_view_tangents_shader);
77 }
78 assert(false);
79 return 0;
80}
81
82// static void log_matrix(const mat4* m) {
83// for (int row = 0; row < 4; ++row) {
84// LOGI("[ %5.2f, %5.2f, %5.2f, %5.2f ]", m->val[0][row], m->val[1][row],
85// m->val[2][row], m->val[3][row]);
86// }
87// }
88
89typedef struct RenderState {
90 GfxCore* gfxcore;
91 LLR* llr;
92 Renderer* renderer;
93 ShaderProgram* shader; // Null to use scene shaders.
94 const Scene* scene;
95 const Anima* anima;
96} RenderState;
97
98static void draw_children(
99 RenderState* state, const mat4* node_transform, const SceneNode* node);
100
101/// Draw the scene recursively.
102static void draw_recursively(
103 RenderState* state, mat4 parent_transform, const SceneNode* node) {
104 assert(state);
105 const mat4 node_transform = mat4_mul(parent_transform, node->transform);
106
107 // Anima.
108 if (node->type == AnimaNode) {
109 // Save the anima so that we can animate objects.
110 state->anima = gfx_get_node_anima(node);
111
112 draw_children(state, &node_transform, node);
113 }
114 // Activate light.
115 else if (node->type == LightNode) {
116 Light* light = mem_get_light(node->light);
117 assert(light);
118 gfx_llr_push_light(state->llr, light);
119 {
120 draw_children(state, &node_transform, node);
121 }
122 gfx_llr_pop_light(state->llr);
123 }
124 // Model.
125 else if (node->type == ModelNode) {
126 const Model* model = gfx_get_node_model(node);
127 const SceneNode* root = mem_get_node(model->root);
128 draw_recursively(state, parent_transform, root);
129 draw_children(state, &node_transform, node);
130 }
131 // Render object.
132 else if (node->type == ObjectNode) {
133 const SceneObject* object = mem_get_object(node->object);
134 assert(object);
135
136 // TODO: Here we would frustum-cull the object.
137
138 // A model/anima can have many skeletons. We need to animate the given
139 // object using its skeleton, not just any skeleton of the anima.
140 if (object->skeleton.val) {
141 const Skeleton* skeleton = mem_get_skeleton(object->skeleton);
142 gfx_llr_set_skeleton(state->llr, state->anima, skeleton);
143 }
144
145 const mat4 model_matrix = node_transform;
146
147 for (mesh_link_idx mesh_link_index = object->mesh_link;
148 mesh_link_index.val;) {
149 const MeshLink* mesh_link = mem_get_mesh_link(mesh_link_index);
150 mesh_link_index = mesh_link->next;
151
152 const Mesh* mesh = mem_get_mesh(mesh_link->mesh);
153 if (!mesh) {
154 continue;
155 }
156
157 // TODO: Here we would frustum-cull the mesh. The AABB would have to be
158 // transformed by the model matrix. Rotation would make the AABB
159 // relatively large, but still, the culling would be conservative.
160
161 ShaderProgram* shader = state->shader ? state->shader : mesh->shader;
162 gfx_llr_set_shader(state->llr, shader);
163 gfx_llr_set_model_matrix(state->llr, &model_matrix);
164 gfx_llr_render_mesh(state->llr, mesh);
165 }
166
167 if (object->skeleton.val) {
168 gfx_llr_clear_skeleton(state->llr);
169 }
170
171 draw_children(state, &node_transform, node);
172 } else {
173 draw_children(state, &node_transform, node);
174 }
175}
176
177/// Draw the node's children.
178static void draw_children(
179 RenderState* state, const mat4* node_transform, const SceneNode* node) {
180 // Render children recursively.
181 for (node_idx child_index = node->child; child_index.val;) {
182 const SceneNode* child = mem_get_node(child_index);
183 draw_recursively(state, *node_transform, child);
184 child_index = child->next;
185 }
186}
187
188void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
189 assert(renderer);
190 assert(params);
191 assert(params->scene);
192
193 ShaderProgram* const shader = load_shader(renderer, params->mode);
194
195 const Scene* scene = params->scene;
196 const SceneCamera* camera = params->camera;
197 GfxCore* const gfxcore = renderer->gfxcore;
198
199 int x, y, width, height;
200 gfx_get_viewport(gfxcore, &x, &y, &width, &height);
201 const R aspect = (R)width / (R)height;
202
203 RenderState state = {
204 .gfxcore = gfxcore,
205 .llr = renderer->llr,
206 .renderer = renderer,
207 .shader = shader,
208 .scene = scene};
209
210 gfx_llr_set_camera(renderer->llr, &camera->camera);
211 gfx_llr_set_aspect(renderer->llr, aspect);
212 draw_recursively(&state, mat4_id(), scene->root);
213}
214
215static void update_rec(SceneNode* node, const SceneCamera* camera, R t) {
216 assert(node);
217 assert(camera);
218
219 const NodeType node_type = gfx_get_node_type(node);
220
221 // TODO: Models do not need to be animated if they are not visible to the
222 // camera.
223 if (node_type == AnimaNode) {
224 Anima* anima = gfx_get_node_anima_mut(node);
225 gfx_update_animation(anima, (R)t);
226 } else if (node_type == ModelNode) {
227 Model* model = gfx_get_node_model_mut(node);
228 SceneNode* root = gfx_get_model_root_mut(model);
229 update_rec(root, camera, t);
230 }
231
232 // Children.
233 SceneNode* child = gfx_get_node_child_mut(node);
234 while (child) {
235 update_rec(child, camera, t);
236 child = gfx_get_node_sibling_mut(child);
237 }
238}
239
240void gfx_update(Scene* scene, const SceneCamera* camera, R t) {
241 assert(scene);
242 assert(camera);
243
244 SceneNode* node = gfx_get_scene_root(scene);
245 update_rec(node, camera, t);
246}
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 @@
1#pragma once
2
3#include <gfx/renderer.h>
4
5#include <stdbool.h>
6
7typedef struct LLR LLR;
8typedef struct ShaderProgram ShaderProgram;
9
10typedef struct Renderer {
11 GfxCore* gfxcore;
12 LLR* llr;
13 struct {
14 ShaderProgram* debug;
15 ShaderProgram* normals;
16 ShaderProgram* normal_mapped_normals;
17 ShaderProgram* tangents;
18 } shaders;
19} Renderer;
20
21/// Create a new renderer.
22bool gfx_renderer_make(Renderer*, LLR*, GfxCore*);
23
24/// Destroy the renderer.
25void gfx_renderer_destroy(Renderer*);
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-03 07:12:29 +0000