aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/asset/model.c109
-rw-r--r--src/core/geometry.c73
-rw-r--r--src/core/shader_program.c148
-rw-r--r--src/memory.c4
-rw-r--r--src/render/imm.c14
-rw-r--r--src/render/llr.c121
-rw-r--r--src/render/llr_impl.h31
-rw-r--r--src/render/renderer.c51
-rw-r--r--src/scene/light.c39
-rw-r--r--src/scene/light_impl.h20
-rw-r--r--src/scene/material.c24
-rw-r--r--src/scene/material_impl.h13
-rw-r--r--src/scene/mesh.c26
-rw-r--r--src/scene/mesh_impl.h11
-rw-r--r--src/scene/object.c3
-rw-r--r--src/util/geometry.c13
16 files changed, 423 insertions, 277 deletions
diff --git a/src/asset/model.c b/src/asset/model.c
index 2ee3cd1..b5c6b0d 100644
--- a/src/asset/model.c
+++ b/src/asset/model.c
@@ -138,6 +138,7 @@
138#define DEFINE_HAS_NORMAL_MAP "HAS_NORMAL_MAP" 138#define DEFINE_HAS_NORMAL_MAP "HAS_NORMAL_MAP"
139#define DEFINE_HAS_OCCLUSION_MAP "HAS_OCCLUSION_MAP" 139#define DEFINE_HAS_OCCLUSION_MAP "HAS_OCCLUSION_MAP"
140#define DEFINE_HAS_EMISSIVE_MAP "HAS_EMISSIVE_MAP" 140#define DEFINE_HAS_EMISSIVE_MAP "HAS_EMISSIVE_MAP"
141#define DEFINE_HAS_TRANSPARENCY "HAS_TRANSPARENCY"
141#define DEFINE_HAS_JOINTS "HAS_JOINTS" 142#define DEFINE_HAS_JOINTS "HAS_JOINTS"
142#define DEFINE_MAX_JOINTS "MAX_JOINTS" 143#define DEFINE_MAX_JOINTS "MAX_JOINTS"
143 144
@@ -166,6 +167,8 @@ typedef struct MeshPermutation {
166 bool has_normal_map : 1; 167 bool has_normal_map : 1;
167 bool has_occlusion_map : 1; 168 bool has_occlusion_map : 1;
168 bool has_emissive_map : 1; 169 bool has_emissive_map : 1;
170 // Material.
171 bool has_transparency : 1;
169 }; 172 };
170 int32_t all; 173 int32_t all;
171 }; 174 };
@@ -192,6 +195,7 @@ static size_t make_defines(
192 check(has_normal_map, DEFINE_HAS_NORMAL_MAP); 195 check(has_normal_map, DEFINE_HAS_NORMAL_MAP);
193 check(has_occlusion_map, DEFINE_HAS_OCCLUSION_MAP); 196 check(has_occlusion_map, DEFINE_HAS_OCCLUSION_MAP);
194 check(has_emissive_map, DEFINE_HAS_EMISSIVE_MAP); 197 check(has_emissive_map, DEFINE_HAS_EMISSIVE_MAP);
198 check(has_transparency, DEFINE_HAS_TRANSPARENCY);
195 199
196 if (perm.has_joints) { 200 if (perm.has_joints) {
197 defines[next].name = sstring_make(DEFINE_MAX_JOINTS); 201 defines[next].name = sstring_make(DEFINE_MAX_JOINTS);
@@ -208,12 +212,12 @@ static ShaderProgram* make_shader_permutation(
208 LOGD( 212 LOGD(
209 "Compiling Cook-Torrance shader permutation: texcoords: %d, normals: " 213 "Compiling Cook-Torrance shader permutation: texcoords: %d, normals: "
210 "%d, tangents: %d, joints: %d, weights: %d, albedo map: %d, " 214 "%d, tangents: %d, joints: %d, weights: %d, albedo map: %d, "
211 "metallic-roughness map: " 215 "metallic-roughness map: %d, normal map: %d, AO map: %d, emissive map: "
212 "%d, normal " 216 "%d, has transparency: %d",
213 "map: %d, AO map: %d, emissive map: %d",
214 perm.has_texcoords, perm.has_normals, perm.has_tangents, perm.has_joints, 217 perm.has_texcoords, perm.has_normals, perm.has_tangents, perm.has_joints,
215 perm.has_weights, perm.has_albedo_map, perm.has_metallic_roughness_map, 218 perm.has_weights, perm.has_albedo_map, perm.has_metallic_roughness_map,
216 perm.has_normal_map, perm.has_occlusion_map, perm.has_emissive_map); 219 perm.has_normal_map, perm.has_occlusion_map, perm.has_emissive_map,
220 perm.has_transparency);
217 221
218 ShaderCompilerDefine defines[GFX_MAX_SHADER_COMPILER_DEFINES]; 222 ShaderCompilerDefine defines[GFX_MAX_SHADER_COMPILER_DEFINES];
219 const size_t num_defines = make_defines(perm, defines); 223 const size_t num_defines = make_defines(perm, defines);
@@ -742,6 +746,19 @@ static bool load_texture_and_uniform(
742 return true; 746 return true;
743} 747}
744 748
749static AlphaMode to_gfx_alpha_mode(cgltf_alpha_mode mode) {
750 switch (mode) {
751 case cgltf_alpha_mode_opaque:
752 return Opaque;
753 case cgltf_alpha_mode_mask:
754 return Mask;
755 case cgltf_alpha_mode_blend:
756 return Blend;
757 }
758 FAIL("unhandled alpha mode");
759 return Opaque;
760}
761
745/// Load all materials from the glTF scene. 762/// Load all materials from the glTF scene.
746/// 763///
747/// Return an array of Materials such that the index of each descriptor matches 764/// Return an array of Materials such that the index of each descriptor matches
@@ -770,27 +787,27 @@ static bool load_materials(
770 787
771 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL); 788 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
772 desc.uniforms[next_uniform++] = (ShaderUniform){ 789 desc.uniforms[next_uniform++] = (ShaderUniform){
773 .name = sstring_make(UNIFORM_BASE_COLOR_FACTOR), 790 .name = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
774 .type = UniformVec4, 791 .type = UniformVec4,
775 .value.vec4 = vec4_from_array(pbr->base_color_factor)}; 792 .value.uniform_vec4 = vec4_from_array(pbr->base_color_factor)};
776 793
777 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL); 794 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
778 desc.uniforms[next_uniform++] = 795 desc.uniforms[next_uniform++] =
779 (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR), 796 (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR),
780 .type = UniformFloat, 797 .type = UniformFloat,
781 .value.scalar = pbr->metallic_factor}; 798 .value.uniform_float = pbr->metallic_factor};
782 799
783 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL); 800 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
784 desc.uniforms[next_uniform++] = 801 desc.uniforms[next_uniform++] =
785 (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR), 802 (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
786 .type = UniformFloat, 803 .type = UniformFloat,
787 .value.scalar = pbr->roughness_factor}; 804 .value.uniform_float = pbr->roughness_factor};
788 805
789 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL); 806 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
790 desc.uniforms[next_uniform++] = 807 desc.uniforms[next_uniform++] = (ShaderUniform){
791 (ShaderUniform){.name = sstring_make(UNIFORM_EMISSIVE_FACTOR), 808 .name = sstring_make(UNIFORM_EMISSIVE_FACTOR),
792 .type = UniformVec3, 809 .type = UniformVec3,
793 .value.vec3 = vec3_from_array(mat->emissive_factor)}; 810 .value.uniform_vec3 = vec3_from_array(mat->emissive_factor)};
794 811
795 if (pbr->base_color_texture.texture) { 812 if (pbr->base_color_texture.texture) {
796 if (!load_texture_and_uniform( 813 if (!load_texture_and_uniform(
@@ -837,6 +854,9 @@ static bool load_materials(
837 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL); 854 assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
838 desc.num_uniforms = next_uniform; 855 desc.num_uniforms = next_uniform;
839 856
857 desc.alpha_mode = to_gfx_alpha_mode(mat->alpha_mode);
858 desc.alpha_cutoff = mat->alpha_cutoff;
859
840 materials[i] = gfx_make_material(&desc); 860 materials[i] = gfx_make_material(&desc);
841 if (!materials[i]) { 861 if (!materials[i]) {
842 return false; 862 return false;
@@ -852,27 +872,27 @@ static Material* make_default_material() {
852 872
853 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); 873 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
854 desc.uniforms[desc.num_uniforms++] = 874 desc.uniforms[desc.num_uniforms++] =
855 (ShaderUniform){.name = sstring_make(UNIFORM_BASE_COLOR_FACTOR), 875 (ShaderUniform){.name = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
856 .type = UniformVec4, 876 .type = UniformVec4,
857 .value.vec4 = vec4_make(1, 1, 1, 1)}; 877 .value.uniform_vec4 = vec4_make(1, 1, 1, 1)};
858 878
859 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); 879 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
860 desc.uniforms[desc.num_uniforms++] = 880 desc.uniforms[desc.num_uniforms++] =
861 (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR), 881 (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR),
862 .type = UniformFloat, 882 .type = UniformFloat,
863 .value.scalar = 0}; 883 .value.uniform_float = 0};
864 884
865 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); 885 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
866 desc.uniforms[desc.num_uniforms++] = 886 desc.uniforms[desc.num_uniforms++] =
867 (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR), 887 (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
868 .type = UniformFloat, 888 .type = UniformFloat,
869 .value.scalar = 1}; 889 .value.uniform_float = 1};
870 890
871 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL); 891 assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
872 desc.uniforms[desc.num_uniforms++] = 892 desc.uniforms[desc.num_uniforms++] =
873 (ShaderUniform){.name = sstring_make(UNIFORM_EMISSIVE_FACTOR), 893 (ShaderUniform){.name = sstring_make(UNIFORM_EMISSIVE_FACTOR),
874 .type = UniformVec3, 894 .type = UniformVec3,
875 .value.vec3 = vec3_make(0, 0, 0)}; 895 .value.uniform_vec3 = vec3_make(0, 0, 0)};
876 896
877 return gfx_make_material(&desc); 897 return gfx_make_material(&desc);
878} 898}
@@ -950,6 +970,7 @@ static bool load_meshes(
950 perm.has_normal_map = mat->normal_texture.texture != 0; 970 perm.has_normal_map = mat->normal_texture.texture != 0;
951 perm.has_occlusion_map = mat->occlusion_texture.texture != 0; 971 perm.has_occlusion_map = mat->occlusion_texture.texture != 0;
952 perm.has_emissive_map = mat->emissive_texture.texture != 0; 972 perm.has_emissive_map = mat->emissive_texture.texture != 0;
973 perm.has_transparency = mat->alpha_mode != cgltf_alpha_mode_opaque;
953 974
954 if (mat->has_pbr_metallic_roughness) { 975 if (mat->has_pbr_metallic_roughness) {
955 const cgltf_pbr_metallic_roughness* pbr = 976 const cgltf_pbr_metallic_roughness* pbr =
@@ -1009,7 +1030,6 @@ static bool load_meshes(
1009 const cgltf_attribute* attrib = &prim->attributes[a]; 1030 const cgltf_attribute* attrib = &prim->attributes[a];
1010 const cgltf_accessor* accessor = attrib->data; 1031 const cgltf_accessor* accessor = attrib->data;
1011 const cgltf_buffer_view* view = accessor->buffer_view; 1032 const cgltf_buffer_view* view = accessor->buffer_view;
1012 const cgltf_size offset = accessor->offset + view->offset;
1013 const cgltf_size buffer_index = view->buffer - data->buffers; 1033 const cgltf_size buffer_index = view->buffer - data->buffers;
1014 1034
1015 assert(buffer_index < data->buffers_count); 1035 assert(buffer_index < data->buffers_count);
@@ -1099,12 +1119,20 @@ static bool load_meshes(
1099 break; 1119 break;
1100 } 1120 }
1101 1121
1102#define CONFIGURE_BUFFER(buf) \ 1122 // See comments here for accessor/view/buffer invariants:
1103 if (buf) { \ 1123 // https://github.com/KhronosGroup/glTF-Sample-Assets/issues/242
1104 buf->buffer = buffer; \ 1124 // Gfx only has Buffer and BufferView, not accessors. We must combine
1105 buf->offset_bytes = offset; \ 1125 // the glTF's accessor and view offsets correctly.
1106 buf->size_bytes = view->size; \ 1126 const cgltf_size offset = accessor->offset + view->offset;
1107 buf->stride_bytes = view->stride; \ 1127 const cgltf_size size_bytes = view->size - accessor->offset;
1128
1129#define CONFIGURE_BUFFER(buf) \
1130 if (buf) { \
1131 buf->buffer = buffer; \
1132 buf->offset_bytes = offset; \
1133 buf->size_bytes = size_bytes; \
1134 buf->stride_bytes = view->stride; \
1135 buf->count = accessor->count; \
1108 } 1136 }
1109 CONFIGURE_BUFFER(buffer_view_2d); 1137 CONFIGURE_BUFFER(buffer_view_2d);
1110 CONFIGURE_BUFFER(buffer_view_3d); 1138 CONFIGURE_BUFFER(buffer_view_3d);
@@ -1139,14 +1167,11 @@ static bool load_meshes(
1139 // either 2d or 3d positions but not both, here we can perform addition 1167 // either 2d or 3d positions but not both, here we can perform addition
1140 // to compute the total number of vertices. 1168 // to compute the total number of vertices.
1141 geometry_desc.num_verts = 1169 geometry_desc.num_verts =
1142 (geometry_desc.positions2d.size_bytes / sizeof(vec2)) + 1170 geometry_desc.positions2d.count + geometry_desc.positions3d.count;
1143 (geometry_desc.positions3d.size_bytes / sizeof(vec3)); 1171
1144 1172#define CHECK_COUNT(buffer_view, type, num_components) \
1145#define CHECK_COUNT(buffer_view, type, num_components) \ 1173 if (geometry_desc.buffer_view.buffer) { \
1146 if (geometry_desc.buffer_view.buffer) { \ 1174 assert(geometry_desc.buffer_view.count == geometry_desc.num_verts); \
1147 assert( \
1148 (geometry_desc.buffer_view.size_bytes / \
1149 (num_components * sizeof(type))) == geometry_desc.num_verts); \
1150 } 1175 }
1151 1176
1152 // Check that the number of vertices is consistent across all vertex 1177 // Check that the number of vertices is consistent across all vertex
diff --git a/src/core/geometry.c b/src/core/geometry.c
index cfc749f..488dc23 100644
--- a/src/core/geometry.c
+++ b/src/core/geometry.c
@@ -12,7 +12,7 @@
12/// 12///
13/// Note that views are allowed to have no data, in which case a buffer of the 13/// Note that views are allowed to have no data, in which case a buffer of the
14/// specified size is created. 14/// specified size is created.
15#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.size_bytes > 0) 15#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.count > 0)
16 16
17static GLenum primitive_type_to_gl(PrimitiveType type) { 17static GLenum primitive_type_to_gl(PrimitiveType type) {
18 switch (type) { 18 switch (type) {
@@ -34,30 +34,25 @@ void init_view_buffer(
34 BufferUsage buffer_usage) { 34 BufferUsage buffer_usage) {
35 if (!view->buffer) { 35 if (!view->buffer) {
36 view->buffer = gfx_make_buffer( 36 view->buffer = gfx_make_buffer(
37 gfxcore, 37 gfxcore, &(BufferDesc){.usage = buffer_usage,
38 &(BufferDesc){ 38 .type = buffer_type,
39 .usage = buffer_usage, 39 .data.data = view->data,
40 .type = buffer_type, 40 .data.count = view->count});
41 .data.data = view->data, 41 assert(view->buffer);
42 .data.count = view->size_bytes /
43 gfx_get_buffer_type_size_bytes(buffer_type)});
44 } 42 }
45 assert(view->size_bytes <= view->buffer->size_bytes);
46} 43}
47 44
48/// Configure the buffer in teh VAO. 45/// Configure the buffer in the VAO.
49static void configure_buffer( 46static void configure_buffer(
50 GfxCore* gfxcore, const GeometryDesc* desc, BufferView* view, 47 GfxCore* gfxcore, const GeometryDesc* desc, BufferView* view,
51 size_t num_components, size_t component_size_bytes, GLenum component_type, 48 size_t num_components, GLenum component_type, GLboolean normalized,
52 GLboolean normalized, GLuint channel) { 49 GLuint channel) {
53 assert(gfxcore); 50 assert(gfxcore);
54 assert(desc); 51 assert(desc);
55 assert(view); 52 assert(view);
56 assert(view->buffer); 53 assert(view->buffer);
57 assert( 54 assert(view->count == desc->num_verts);
58 desc->num_verts <= 55 assert((view->offset_bytes + view->size_bytes) <= view->buffer->size_bytes);
59 view->size_bytes / (num_components * component_size_bytes));
60 assert(view->size_bytes <= view->buffer->size_bytes);
61 56
62 glBindBuffer(GL_ARRAY_BUFFER, view->buffer->vbo); 57 glBindBuffer(GL_ARRAY_BUFFER, view->buffer->vbo);
63 glEnableVertexAttribArray(channel); 58 glEnableVertexAttribArray(channel);
@@ -89,8 +84,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
89 return false; 84 return false;
90 } 85 }
91 configure_buffer( 86 configure_buffer(
92 gfxcore, desc, (BufferView*)&desc->positions3d, 3, sizeof(float), 87 gfxcore, desc, (BufferView*)&desc->positions3d, 3, GL_FLOAT, GL_FALSE,
93 GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL); 88 GFX_POSITION_CHANNEL);
94 } else if (view_is_populated(desc->positions2d)) { 89 } else if (view_is_populated(desc->positions2d)) {
95 init_view_buffer( 90 init_view_buffer(
96 gfxcore, (BufferView*)&desc->positions2d, Buffer2d, desc->buffer_usage); 91 gfxcore, (BufferView*)&desc->positions2d, Buffer2d, desc->buffer_usage);
@@ -98,8 +93,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
98 return false; 93 return false;
99 } 94 }
100 configure_buffer( 95 configure_buffer(
101 gfxcore, desc, (BufferView*)&desc->positions2d, 2, sizeof(float), 96 gfxcore, desc, (BufferView*)&desc->positions2d, 2, GL_FLOAT, GL_FALSE,
102 GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL); 97 GFX_POSITION_CHANNEL);
103 } 98 }
104 if (view_is_populated(desc->normals)) { 99 if (view_is_populated(desc->normals)) {
105 init_view_buffer( 100 init_view_buffer(
@@ -108,8 +103,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
108 return false; 103 return false;
109 } 104 }
110 configure_buffer( 105 configure_buffer(
111 gfxcore, desc, (BufferView*)&desc->normals, 3, sizeof(float), GL_FLOAT, 106 gfxcore, desc, (BufferView*)&desc->normals, 3, GL_FLOAT, GL_FALSE,
112 GL_FALSE, GFX_NORMAL_CHANNEL); 107 GFX_NORMAL_CHANNEL);
113 } 108 }
114 if (view_is_populated(desc->tangents)) { 109 if (view_is_populated(desc->tangents)) {
115 init_view_buffer( 110 init_view_buffer(
@@ -118,8 +113,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
118 return false; 113 return false;
119 } 114 }
120 configure_buffer( 115 configure_buffer(
121 gfxcore, desc, (BufferView*)&desc->tangents, 4, sizeof(float), GL_FLOAT, 116 gfxcore, desc, (BufferView*)&desc->tangents, 4, GL_FLOAT, GL_FALSE,
122 GL_FALSE, GFX_TANGENT_CHANNEL); 117 GFX_TANGENT_CHANNEL);
123 } 118 }
124 if (view_is_populated(desc->texcoords)) { 119 if (view_is_populated(desc->texcoords)) {
125 init_view_buffer( 120 init_view_buffer(
@@ -128,8 +123,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
128 return false; 123 return false;
129 } 124 }
130 configure_buffer( 125 configure_buffer(
131 gfxcore, desc, (BufferView*)&desc->texcoords, 2, sizeof(float), 126 gfxcore, desc, (BufferView*)&desc->texcoords, 2, GL_FLOAT, GL_FALSE,
132 GL_FLOAT, GL_FALSE, GFX_TEXCOORDS_CHANNEL); 127 GFX_TEXCOORDS_CHANNEL);
133 } 128 }
134 if (view_is_populated(desc->joints.u8)) { 129 if (view_is_populated(desc->joints.u8)) {
135 init_view_buffer( 130 init_view_buffer(
@@ -138,8 +133,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
138 return false; 133 return false;
139 } 134 }
140 configure_buffer( 135 configure_buffer(
141 gfxcore, desc, (BufferView*)&desc->joints.u8, 4, sizeof(uint8_t), 136 gfxcore, desc, (BufferView*)&desc->joints.u8, 4, GL_UNSIGNED_BYTE,
142 GL_UNSIGNED_BYTE, GL_FALSE, GFX_JOINTS_CHANNEL); 137 GL_FALSE, GFX_JOINTS_CHANNEL);
143 } else if (view_is_populated(desc->joints.u16)) { 138 } else if (view_is_populated(desc->joints.u16)) {
144 init_view_buffer( 139 init_view_buffer(
145 gfxcore, (BufferView*)&desc->joints.u16, BufferU16, desc->buffer_usage); 140 gfxcore, (BufferView*)&desc->joints.u16, BufferU16, desc->buffer_usage);
@@ -147,8 +142,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
147 return false; 142 return false;
148 } 143 }
149 configure_buffer( 144 configure_buffer(
150 gfxcore, desc, (BufferView*)&desc->joints.u16, 4, sizeof(uint16_t), 145 gfxcore, desc, (BufferView*)&desc->joints.u16, 4, GL_UNSIGNED_SHORT,
151 GL_UNSIGNED_SHORT, GL_FALSE, GFX_JOINTS_CHANNEL); 146 GL_FALSE, GFX_JOINTS_CHANNEL);
152 } 147 }
153 148
154 // If weights are given as unsigned integers, then they are normalized 149 // If weights are given as unsigned integers, then they are normalized
@@ -160,8 +155,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
160 return false; 155 return false;
161 } 156 }
162 configure_buffer( 157 configure_buffer(
163 gfxcore, desc, (BufferView*)&desc->weights.u8, 4, sizeof(uint8_t), 158 gfxcore, desc, (BufferView*)&desc->weights.u8, 4, GL_UNSIGNED_BYTE,
164 GL_UNSIGNED_BYTE, GL_TRUE, GFX_WEIGHTS_CHANNEL); 159 GL_TRUE, GFX_WEIGHTS_CHANNEL);
165 } else if (view_is_populated(desc->weights.u16)) { 160 } else if (view_is_populated(desc->weights.u16)) {
166 init_view_buffer( 161 init_view_buffer(
167 gfxcore, (BufferView*)&desc->weights.u16, BufferU16, 162 gfxcore, (BufferView*)&desc->weights.u16, BufferU16,
@@ -170,8 +165,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
170 return false; 165 return false;
171 } 166 }
172 configure_buffer( 167 configure_buffer(
173 gfxcore, desc, (BufferView*)&desc->weights.u16, 4, sizeof(uint16_t), 168 gfxcore, desc, (BufferView*)&desc->weights.u16, 4, GL_UNSIGNED_SHORT,
174 GL_UNSIGNED_SHORT, GL_TRUE, GFX_WEIGHTS_CHANNEL); 169 GL_TRUE, GFX_WEIGHTS_CHANNEL);
175 } else if (view_is_populated(desc->weights.floats)) { 170 } else if (view_is_populated(desc->weights.floats)) {
176 init_view_buffer( 171 init_view_buffer(
177 gfxcore, (BufferView*)&desc->weights.floats, BufferFloat, 172 gfxcore, (BufferView*)&desc->weights.floats, BufferFloat,
@@ -180,8 +175,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
180 return false; 175 return false;
181 } 176 }
182 configure_buffer( 177 configure_buffer(
183 gfxcore, desc, (BufferView*)&desc->weights.floats, 4, sizeof(float), 178 gfxcore, desc, (BufferView*)&desc->weights.floats, 4, GL_FLOAT,
184 GL_FLOAT, GL_FALSE, GFX_WEIGHTS_CHANNEL); 179 GL_FALSE, GFX_WEIGHTS_CHANNEL);
185 } 180 }
186 181
187 return true; 182 return true;
@@ -282,9 +277,9 @@ void gfx_update_geometry(Geometry* geometry, const GeometryDesc* desc) {
282 assert(geometry->desc.positions3d.buffer); 277 assert(geometry->desc.positions3d.buffer);
283 gfx_update_buffer( 278 gfx_update_buffer(
284 geometry->desc.positions3d.buffer, 279 geometry->desc.positions3d.buffer,
285 &(BufferDataDesc){ 280 &(BufferDataDesc){.vec3s = desc->positions3d.data,
286 .vec3s = desc->positions3d.data, 281 .count =
287 .count = desc->positions3d.size_bytes / sizeof(vec3)}); 282 desc->positions3d.size_bytes / sizeof(vec3)});
288 } 283 }
289 // TODO: more 284 // TODO: more
290 else { 285 else {
diff --git a/src/core/shader_program.c b/src/core/shader_program.c
index 3cbe48d..3840019 100644
--- a/src/core/shader_program.c
+++ b/src/core/shader_program.c
@@ -72,17 +72,23 @@ void gfx_deactivate_shader_program(const ShaderProgram* prog) {
72 ASSERT_GL; 72 ASSERT_GL;
73} 73}
74 74
75static void set_texture_uniform( 75static void set_int_uniform(GLuint prog, const char* name, int value) {
76 GLuint prog, const char* name, int texture_unit, const Texture* texture) {
77 assert(prog != 0); 76 assert(prog != 0);
78 assert(name); 77 assert(name);
79 assert(texture);
80 78
81 const GLint location = glGetUniformLocation(prog, name); 79 const GLint location = glGetUniformLocation(prog, name);
82 if (location >= 0) { 80 if (location >= 0) {
83 glActiveTexture(GL_TEXTURE0 + texture_unit); 81 glUniform1i(location, value);
84 glBindTexture(texture->target, texture->id); 82 }
85 glUniform1i(location, texture_unit); 83}
84
85static void set_float_uniform(GLuint prog, const char* name, float value) {
86 assert(prog != 0);
87 assert(name);
88
89 const GLint location = glGetUniformLocation(prog, name);
90 if (location >= 0) {
91 glUniform1f(location, value);
86 } 92 }
87} 93}
88 94
@@ -118,13 +124,17 @@ static void set_vec4_uniform(GLuint prog, const char* name, vec4 value) {
118 } 124 }
119} 125}
120 126
121static void set_float_uniform(GLuint prog, const char* name, float value) { 127static void set_texture_uniform(
128 GLuint prog, const char* name, int texture_unit, const Texture* texture) {
122 assert(prog != 0); 129 assert(prog != 0);
123 assert(name); 130 assert(name);
131 assert(texture);
124 132
125 const GLint location = glGetUniformLocation(prog, name); 133 const GLint location = glGetUniformLocation(prog, name);
126 if (location >= 0) { 134 if (location >= 0) {
127 glUniform1f(location, value); 135 glActiveTexture(GL_TEXTURE0 + texture_unit);
136 glBindTexture(texture->target, texture->id);
137 glUniform1i(location, texture_unit);
128 } 138 }
129} 139}
130 140
@@ -135,23 +145,30 @@ void gfx_apply_uniforms(const ShaderProgram* prog) {
135 for (int i = 0; i < prog->num_uniforms; ++i) { 145 for (int i = 0; i < prog->num_uniforms; ++i) {
136 const ShaderUniform* uniform = &prog->uniforms[i]; 146 const ShaderUniform* uniform = &prog->uniforms[i];
137 switch (uniform->type) { 147 switch (uniform->type) {
138 case UniformTexture: 148 case UniformInt:
139 set_texture_uniform( 149 set_int_uniform(prog->id, uniform->name.str, uniform->value.uniform_int);
140 prog->id, uniform->name.str, next_texture_unit, 150 break;
141 uniform->value.texture); 151 case UniformFloat:
142 next_texture_unit++; 152 set_float_uniform(
153 prog->id, uniform->name.str, uniform->value.uniform_float);
143 break; 154 break;
144 case UniformMat4: 155 case UniformMat4:
145 set_mat4_uniform(prog->id, uniform->name.str, &uniform->value.mat4, 1); 156 set_mat4_uniform(
157 prog->id, uniform->name.str, &uniform->value.uniform_mat4, 1);
146 break; 158 break;
147 case UniformVec3: 159 case UniformVec3:
148 set_vec3_uniform(prog->id, uniform->name.str, uniform->value.vec3); 160 set_vec3_uniform(
161 prog->id, uniform->name.str, uniform->value.uniform_vec3);
149 break; 162 break;
150 case UniformVec4: 163 case UniformVec4:
151 set_vec4_uniform(prog->id, uniform->name.str, uniform->value.vec4); 164 set_vec4_uniform(
165 prog->id, uniform->name.str, uniform->value.uniform_vec4);
152 break; 166 break;
153 case UniformFloat: 167 case UniformTexture:
154 set_float_uniform(prog->id, uniform->name.str, uniform->value.scalar); 168 set_texture_uniform(
169 prog->id, uniform->name.str, next_texture_unit,
170 uniform->value.texture);
171 next_texture_unit++;
155 break; 172 break;
156 case UniformMat4Array: 173 case UniformMat4Array:
157 set_mat4_uniform( 174 set_mat4_uniform(
@@ -179,8 +196,9 @@ static ShaderUniform* get_or_allocate_uniform(
179 196
180 // Create the uniform if it does not exist. 197 // Create the uniform if it does not exist.
181 if (prog->num_uniforms == GFX_MAX_UNIFORMS_PER_SHADER) { 198 if (prog->num_uniforms == GFX_MAX_UNIFORMS_PER_SHADER) {
182 FAIL("Exceeded the maximum number of uniforms per shader. Please increase " 199 FAIL(
183 "this value."); 200 "Exceeded the maximum number of uniforms per shader. Please increase "
201 "this value.");
184 return 0; 202 return 0;
185 } 203 }
186 ShaderUniform* uniform = &prog->uniforms[prog->num_uniforms]; 204 ShaderUniform* uniform = &prog->uniforms[prog->num_uniforms];
@@ -191,21 +209,67 @@ static ShaderUniform* get_or_allocate_uniform(
191// The functions below save the value of a uniform in the shader program. If the 209// The functions below save the value of a uniform in the shader program. If the
192// uniform does not even exist, then there is no need to store the value. 210// uniform does not even exist, then there is no need to store the value.
193 211
194void gfx_set_texture_uniform( 212void gfx_set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
195 ShaderProgram* prog, const char* name, const Texture* texture) { 213 switch (uniform->type) {
214 case UniformInt:
215 gfx_set_int_uniform(prog, uniform->name.str, uniform->value.uniform_int);
216 break;
217 case UniformFloat:
218 gfx_set_float_uniform(
219 prog, uniform->name.str, uniform->value.uniform_float);
220 break;
221 case UniformMat4:
222 gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.uniform_mat4);
223 break;
224 case UniformVec3:
225 gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.uniform_vec3);
226 break;
227 case UniformVec4:
228 gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.uniform_vec4);
229 break;
230 case UniformTexture:
231 gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture);
232 break;
233 case UniformMat4Array:
234 gfx_set_mat4_array_uniform(
235 prog, uniform->name.str, uniform->value.array.values,
236 uniform->value.array.count);
237 break;
238 }
239}
240
241void gfx_set_int_uniform(ShaderProgram* prog, const char* name, int value) {
196 assert(prog); 242 assert(prog);
197 assert(name); 243 assert(name);
198 assert(texture);
199 244
245 // No need to store the uniform on our side if it does not exist in the
246 // program.
200 const GLint location = glGetUniformLocation(prog->id, name); 247 const GLint location = glGetUniformLocation(prog->id, name);
201 if (location < 0) { 248 if (location < 0) {
202 return; 249 return;
203 } 250 }
204 ShaderUniform* uniform = get_or_allocate_uniform(prog, name); 251 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
205 assert(uniform); 252 assert(uniform);
206 uniform->name = sstring_make(name); 253 uniform->name = sstring_make(name);
207 uniform->type = UniformTexture; 254 uniform->type = UniformInt;
208 uniform->value.texture = texture; 255 uniform->value.uniform_int = value;
256}
257
258void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) {
259 assert(prog);
260 assert(name);
261
262 // No need to store the uniform on our side if it does not exist in the
263 // program.
264 const GLint location = glGetUniformLocation(prog->id, name);
265 if (location < 0) {
266 return;
267 }
268 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
269 assert(uniform);
270 uniform->name = sstring_make(name);
271 uniform->type = UniformFloat;
272 uniform->value.uniform_float = value;
209} 273}
210 274
211void gfx_set_mat4_uniform( 275void gfx_set_mat4_uniform(
@@ -220,9 +284,9 @@ void gfx_set_mat4_uniform(
220 } 284 }
221 ShaderUniform* uniform = get_or_allocate_uniform(prog, name); 285 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
222 assert(uniform); 286 assert(uniform);
223 uniform->name = sstring_make(name); 287 uniform->name = sstring_make(name);
224 uniform->type = UniformMat4; 288 uniform->type = UniformMat4;
225 uniform->value.mat4 = *mat; 289 uniform->value.uniform_mat4 = *mat;
226} 290}
227 291
228void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) { 292void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
@@ -235,9 +299,9 @@ void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
235 } 299 }
236 ShaderUniform* uniform = get_or_allocate_uniform(prog, name); 300 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
237 assert(uniform); 301 assert(uniform);
238 uniform->name = sstring_make(name); 302 uniform->name = sstring_make(name);
239 uniform->type = UniformVec3; 303 uniform->type = UniformVec3;
240 uniform->value.vec3 = value; 304 uniform->value.uniform_vec3 = value;
241} 305}
242 306
243void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) { 307void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
@@ -250,26 +314,26 @@ void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
250 } 314 }
251 ShaderUniform* uniform = get_or_allocate_uniform(prog, name); 315 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
252 assert(uniform); 316 assert(uniform);
253 uniform->name = sstring_make(name); 317 uniform->name = sstring_make(name);
254 uniform->type = UniformVec4; 318 uniform->type = UniformVec4;
255 uniform->value.vec4 = value; 319 uniform->value.uniform_vec4 = value;
256} 320}
257 321
258void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) { 322void gfx_set_texture_uniform(
323 ShaderProgram* prog, const char* name, const Texture* texture) {
259 assert(prog); 324 assert(prog);
260 assert(name); 325 assert(name);
326 assert(texture);
261 327
262 // No need to store the uniform on our side if it does not exist in the
263 // program.
264 const GLint location = glGetUniformLocation(prog->id, name); 328 const GLint location = glGetUniformLocation(prog->id, name);
265 if (location < 0) { 329 if (location < 0) {
266 return; 330 return;
267 } 331 }
268 ShaderUniform* uniform = get_or_allocate_uniform(prog, name); 332 ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
269 assert(uniform); 333 assert(uniform);
270 uniform->name = sstring_make(name); 334 uniform->name = sstring_make(name);
271 uniform->type = UniformFloat; 335 uniform->type = UniformTexture;
272 uniform->value.scalar = value; 336 uniform->value.texture = texture;
273} 337}
274 338
275void gfx_set_mat4_array_uniform( 339void gfx_set_mat4_array_uniform(
@@ -277,7 +341,7 @@ void gfx_set_mat4_array_uniform(
277 assert(prog); 341 assert(prog);
278 assert(name); 342 assert(name);
279 assert(mats); 343 assert(mats);
280 344
281 const GLint location = glGetUniformLocation(prog->id, name); 345 const GLint location = glGetUniformLocation(prog->id, name);
282 if (location < 0) { 346 if (location < 0) {
283 return; 347 return;
diff --git a/src/memory.c b/src/memory.c
index de20f78..754f04d 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -4,7 +4,9 @@
4#include <gfx/sizes.h> 4#include <gfx/sizes.h>
5 5
6#include "animation_impl.h" 6#include "animation_impl.h"
7#include "render/llr_impl.h" 7#include "scene/light_impl.h"
8#include "scene/material_impl.h"
9#include "scene/mesh_impl.h"
8#include "scene/model_impl.h" 10#include "scene/model_impl.h"
9#include "scene/node_impl.h" 11#include "scene/node_impl.h"
10#include "scene/object_impl.h" 12#include "scene/object_impl.h"
diff --git a/src/render/imm.c b/src/render/imm.c
index 8a93488..7ab8d62 100644
--- a/src/render/imm.c
+++ b/src/render/imm.c
@@ -21,12 +21,14 @@ bool gfx_imm_make(Imm* renderer, GfxCore* gfxcore, LLR* llr) {
21 renderer->llr = llr; 21 renderer->llr = llr;
22 22
23 renderer->triangles = gfx_make_geometry( 23 renderer->triangles = gfx_make_geometry(
24 gfxcore, 24 gfxcore, &(GeometryDesc){
25 &(GeometryDesc){.type = Triangles, 25 .type = Triangles,
26 .buffer_usage = BufferDynamic, 26 .buffer_usage = BufferDynamic,
27 .num_verts = num_triangle_verts, 27 .num_verts = num_triangle_verts,
28 .positions3d = (BufferView3d){ 28 .positions3d = (BufferView3d){
29 .size_bytes = num_triangle_verts * sizeof(vec3)}}); 29 .size_bytes = num_triangle_verts * sizeof(vec3),
30 .count = num_triangle_verts}
31 });
30 if (!renderer->triangles) { 32 if (!renderer->triangles) {
31 goto cleanup; 33 goto cleanup;
32 } 34 }
diff --git a/src/render/llr.c b/src/render/llr.c
index 76935f9..752b65b 100644
--- a/src/render/llr.c
+++ b/src/render/llr.c
@@ -1,14 +1,15 @@
1#include "llr_impl.h" 1#include "llr_impl.h"
2 2
3#include "animation_impl.h" 3#include "animation_impl.h"
4#include "memory.h" 4#include "scene/light_impl.h"
5#include "scene/material_impl.h"
6#include "scene/mesh_impl.h"
5#include "scene/node_impl.h" 7#include "scene/node_impl.h"
6 8
7#include <gfx/core.h> 9#include <gfx/core.h>
8#include <gfx/util/ibl.h> 10#include <gfx/util/ibl.h>
9 11
10#include <cassert.h> 12#include <cassert.h>
11#include <error.h>
12 13
13static const int IRRADIANCE_MAP_WIDTH = 1024; 14static const int IRRADIANCE_MAP_WIDTH = 1024;
14static const int IRRADIANCE_MAP_HEIGHT = 1024; 15static const int IRRADIANCE_MAP_HEIGHT = 1024;
@@ -17,114 +18,30 @@ static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128;
17static const int BRDF_INTEGRATION_MAP_WIDTH = 512; 18static const int BRDF_INTEGRATION_MAP_WIDTH = 512;
18static const int BRDF_INTEGRATION_MAP_HEIGHT = 512; 19static const int BRDF_INTEGRATION_MAP_HEIGHT = 512;
19 20
20static void make_environment_light(
21 Light* light, const EnvironmentLightDesc* desc) {
22 assert(light);
23 assert(desc);
24 light->type = EnvironmentLightType;
25 light->environment.environment_map = desc->environment_map;
26}
27
28Light* gfx_make_light(const LightDesc* desc) {
29 assert(desc);
30
31 Light* light = mem_alloc_light();
32
33 switch (desc->type) {
34 case EnvironmentLightType:
35 make_environment_light(light, &desc->light.environment);
36 break;
37 default:
38 log_error("Unhandled light type");
39 gfx_destroy_light(&light);
40 return 0;
41 }
42
43 return light;
44}
45
46void gfx_destroy_light(Light** light) {
47 assert(light);
48 if (*light) {
49 mem_free_light(light);
50 }
51}
52
53static void material_make(Material* material, const MaterialDesc* desc) {
54 assert(material);
55 assert(desc);
56 assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
57 material->num_uniforms = desc->num_uniforms;
58 for (int i = 0; i < desc->num_uniforms; ++i) {
59 material->uniforms[i] = desc->uniforms[i];
60 }
61}
62
63Material* gfx_make_material(const MaterialDesc* desc) {
64 assert(desc);
65 Material* material = mem_alloc_material();
66 material_make(material, desc);
67 return material;
68}
69
70void gfx_destroy_material(Material** material) { mem_free_material(material); }
71
72static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
73 switch (uniform->type) {
74 case UniformTexture:
75 gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture);
76 break;
77 case UniformMat4:
78 gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.mat4);
79 break;
80 case UniformVec3:
81 gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.vec3);
82 break;
83 case UniformVec4:
84 gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.vec4);
85 break;
86 case UniformFloat:
87 gfx_set_float_uniform(prog, uniform->name.str, uniform->value.scalar);
88 break;
89 case UniformMat4Array:
90 gfx_set_mat4_array_uniform(
91 prog, uniform->name.str, uniform->value.array.values,
92 uniform->value.array.count);
93 break;
94 }
95}
96
97/// Activate the material. 21/// Activate the material.
98/// 22///
99/// This configures the shader uniforms that are specific to the material. 23/// This configures the shader uniforms that are specific to the material.
100static void gfx_material_activate( 24static void material_activate(ShaderProgram* shader, const Material* material) {
101 ShaderProgram* shader, const Material* material) {
102 assert(material); 25 assert(material);
103 for (int i = 0; i < material->num_uniforms; ++i) { 26 for (int i = 0; i < material->num_uniforms; ++i) {
104 const ShaderUniform* uniform = &material->uniforms[i]; 27 const ShaderUniform* uniform = &material->uniforms[i];
105 set_uniform(shader, uniform); 28 gfx_set_uniform(shader, uniform);
29 }
30 if (material->alpha_mode != Opaque) {
31 gfx_set_uniform(
32 shader, &(ShaderUniform){.name = sstring_make("AlphaMode"),
33 .type = UniformInt,
34 .value.uniform_int = material->alpha_mode});
35 }
36 if (material->alpha_mode == Mask) {
37 gfx_set_uniform(
38 shader,
39 &(ShaderUniform){.name = sstring_make("AlphaCutoff"),
40 .type = UniformFloat,
41 .value.uniform_float = material->alpha_cutoff});
106 } 42 }
107} 43}
108 44
109static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
110 assert(mesh);
111 assert(desc);
112 assert(desc->geometry);
113 assert(desc->material);
114 assert(desc->shader);
115 mesh->geometry = desc->geometry;
116 mesh->material = desc->material;
117 mesh->shader = desc->shader;
118}
119
120Mesh* gfx_make_mesh(const MeshDesc* desc) {
121 Mesh* mesh = mem_alloc_mesh();
122 mesh_make(mesh, desc);
123 return mesh;
124}
125
126void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
127
128/// Initialize renderer state for IBL. 45/// Initialize renderer state for IBL.
129static bool init_ibl(LLR* renderer) { 46static bool init_ibl(LLR* renderer) {
130 assert(renderer); 47 assert(renderer);
@@ -314,7 +231,7 @@ static void configure_state(LLR* renderer) {
314 231
315 // Geometry may be rendered without a material. 232 // Geometry may be rendered without a material.
316 if (renderer->material) { 233 if (renderer->material) {
317 gfx_material_activate(renderer->shader, renderer->material); 234 material_activate(renderer->shader, renderer->material);
318 } 235 }
319 } 236 }
320 237
diff --git a/src/render/llr_impl.h b/src/render/llr_impl.h
index c85ad15..9d70843 100644
--- a/src/render/llr_impl.h
+++ b/src/render/llr_impl.h
@@ -3,8 +3,6 @@
3#include <gfx/render/llr.h> 3#include <gfx/render/llr.h>
4#include <gfx/sizes.h> 4#include <gfx/sizes.h>
5 5
6#include "../types.h"
7
8#include <math/mat4.h> 6#include <math/mat4.h>
9#include <math/vec3.h> 7#include <math/vec3.h>
10 8
@@ -12,41 +10,12 @@
12#include <stddef.h> 10#include <stddef.h>
13#include <stdint.h> 11#include <stdint.h>
14 12
15typedef struct Geometry Geometry;
16typedef struct GfxCore GfxCore; 13typedef struct GfxCore GfxCore;
17typedef struct IBL IBL; 14typedef struct IBL IBL;
18typedef struct Material Material; 15typedef struct Material Material;
19typedef struct ShaderProgram ShaderProgram; 16typedef struct ShaderProgram ShaderProgram;
20typedef struct Texture Texture; 17typedef struct Texture Texture;
21 18
22/// An environment light.
23typedef struct EnvironmentLight {
24 const Texture* environment_map;
25 const Texture* irradiance_map; // Renderer implementation.
26 const Texture* prefiltered_environment_map; // Renderer implementation.
27 int max_reflection_lod; // Mandatory when prefiltered_environment_map is
28 // given.
29} EnvironmentLight;
30
31/// A scene light.
32typedef struct Light {
33 LightType type;
34 union {
35 EnvironmentLight environment;
36 };
37} Light;
38
39typedef struct Material {
40 ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
41 int num_uniforms;
42} Material;
43
44typedef struct Mesh {
45 const Geometry* geometry;
46 const Material* material;
47 ShaderProgram* shader; // TODO: Move this back to Material?
48} Mesh;
49
50/// Immediate mode renderer. 19/// Immediate mode renderer.
51/// 20///
52/// The renderer caches state changes in memory and only programs the underlying 21/// The renderer caches state changes in memory and only programs the underlying
diff --git a/src/render/renderer.c b/src/render/renderer.c
index b513ed4..a9d9bef 100644
--- a/src/render/renderer.c
+++ b/src/render/renderer.c
@@ -3,10 +3,11 @@
3#include "animation_impl.h" 3#include "animation_impl.h"
4#include "llr_impl.h" 4#include "llr_impl.h"
5#include "memory.h" 5#include "memory.h"
6#include "scene/material_impl.h"
7#include "scene/mesh_impl.h"
6#include "scene/model_impl.h" 8#include "scene/model_impl.h"
7#include "scene/node_impl.h" 9#include "scene/node_impl.h"
8#include "scene/object_impl.h" 10#include "scene/object_impl.h"
9#include "scene/scene_impl.h"
10 11
11#include <gfx/core.h> 12#include <gfx/core.h>
12#include <gfx/render/llr.h> 13#include <gfx/render/llr.h>
@@ -86,12 +87,13 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
86// } 87// }
87 88
88typedef struct RenderState { 89typedef struct RenderState {
89 GfxCore* gfxcore; 90 GfxCore* gfxcore;
90 LLR* llr; 91 LLR* llr;
91 Renderer* renderer; 92 Renderer* renderer;
92 ShaderProgram* shader; // Null to use scene shaders. 93 ShaderProgram* shader; // Null to use scene shaders.
93 const Scene* scene; 94 const Scene* scene;
94 const Anima* anima; 95 const Anima* anima;
96 RenderSceneFilter filter;
95} RenderState; 97} RenderState;
96 98
97static void draw_children( 99static void draw_children(
@@ -153,6 +155,24 @@ static void draw_recursively(
153 continue; 155 continue;
154 } 156 }
155 157
158 // Filter out by material.
159 const Material* material = mesh->material;
160 if (material) {
161 const AlphaMode mode = material->alpha_mode;
162 switch (state->filter) {
163 case RenderOpaqueAndAlphaMasked:
164 if (mode == Blend) {
165 continue;
166 }
167 break;
168 case RenderTransparent:
169 if (mode != Blend) {
170 continue;
171 }
172 break;
173 }
174 }
175
156 // TODO: Here we would frustum-cull the mesh. The AABB would have to be 176 // TODO: Here we would frustum-cull the mesh. The AABB would have to be
157 // transformed by the model matrix. Rotation would make the AABB 177 // transformed by the model matrix. Rotation would make the AABB
158 // relatively large, but still, the culling would be conservative. 178 // relatively large, but still, the culling would be conservative.
@@ -208,6 +228,22 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
208 228
209 gfx_llr_set_camera(renderer->llr, camera); 229 gfx_llr_set_camera(renderer->llr, camera);
210 gfx_llr_set_aspect(renderer->llr, aspect); 230 gfx_llr_set_aspect(renderer->llr, aspect);
231 // TODO: Render Opaque and Mask alpha-mode materials first, then Blend ones.
232 // TODO: I'm not sure if this belongs to the scene renderer per se, or if it
233 // is something that should be driven from the outside. Specifically, the
234 // caller could pass in a filter that determines what objects to render. The
235 // filter could include alpha mode.
236 // This caller would be some component that understands render passes and
237 // potentially renders the scene multiple times as needed. For example, a
238 // depth-prepass, followed by G-buffer, followed by some post-processing,
239 // etc. Rename this renderer to scene_renderer?
240 // TODO: When rendering transparent geometry, we need to turn off depth
241 // writes.
242 // Opaque.
243 state.filter = RenderOpaqueAndAlphaMasked;
244 draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene));
245 // Transparent.
246 state.filter = RenderTransparent;
211 draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene)); 247 draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene));
212} 248}
213 249
@@ -236,6 +272,7 @@ static void update_rec(SceneNode* node, const Camera* camera, R t) {
236 } 272 }
237} 273}
238 274
275// TODO: Move this outside the renderer.
239void gfx_update(Scene* scene, const Camera* camera, R t) { 276void gfx_update(Scene* scene, const Camera* camera, R t) {
240 assert(scene); 277 assert(scene);
241 assert(camera); 278 assert(camera);
diff --git a/src/scene/light.c b/src/scene/light.c
new file mode 100644
index 0000000..4233330
--- /dev/null
+++ b/src/scene/light.c
@@ -0,0 +1,39 @@
1#include "light_impl.h"
2
3#include "memory.h"
4
5#include <cassert.h>
6#include <error.h>
7
8static void make_environment_light(
9 Light* light, const EnvironmentLightDesc* desc) {
10 assert(light);
11 assert(desc);
12 light->type = EnvironmentLightType;
13 light->environment.environment_map = desc->environment_map;
14}
15
16Light* gfx_make_light(const LightDesc* desc) {
17 assert(desc);
18
19 Light* light = mem_alloc_light();
20
21 switch (desc->type) {
22 case EnvironmentLightType:
23 make_environment_light(light, &desc->light.environment);
24 break;
25 default:
26 log_error("Unhandled light type");
27 gfx_destroy_light(&light);
28 return 0;
29 }
30
31 return light;
32}
33
34void gfx_destroy_light(Light** light) {
35 assert(light);
36 if (*light) {
37 mem_free_light(light);
38 }
39}
diff --git a/src/scene/light_impl.h b/src/scene/light_impl.h
new file mode 100644
index 0000000..3191a50
--- /dev/null
+++ b/src/scene/light_impl.h
@@ -0,0 +1,20 @@
1#pragma once
2
3#include <gfx/scene.h>
4
5/// An environment light.
6typedef struct EnvironmentLight {
7 const Texture* environment_map;
8 const Texture* irradiance_map; // Renderer implementation.
9 const Texture* prefiltered_environment_map; // Renderer implementation.
10 int max_reflection_lod; // Mandatory when prefiltered_environment_map is
11 // given.
12} EnvironmentLight;
13
14/// A scene light.
15typedef struct Light {
16 LightType type;
17 union {
18 EnvironmentLight environment;
19 };
20} Light;
diff --git a/src/scene/material.c b/src/scene/material.c
new file mode 100644
index 0000000..9fe6c1b
--- /dev/null
+++ b/src/scene/material.c
@@ -0,0 +1,24 @@
1#include "material_impl.h"
2
3#include "memory.h"
4
5static void material_make(Material* material, const MaterialDesc* desc) {
6 assert(material);
7 assert(desc);
8 assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
9 material->alpha_mode = desc->alpha_mode;
10 material->alpha_cutoff = desc->alpha_cutoff;
11 material->num_uniforms = (int8_t)desc->num_uniforms;
12 for (int i = 0; i < desc->num_uniforms; ++i) {
13 material->uniforms[i] = desc->uniforms[i];
14 }
15}
16
17Material* gfx_make_material(const MaterialDesc* desc) {
18 assert(desc);
19 Material* material = mem_alloc_material();
20 material_make(material, desc);
21 return material;
22}
23
24void gfx_destroy_material(Material** material) { mem_free_material(material); }
diff --git a/src/scene/material_impl.h b/src/scene/material_impl.h
new file mode 100644
index 0000000..488ffc7
--- /dev/null
+++ b/src/scene/material_impl.h
@@ -0,0 +1,13 @@
1#pragma once
2
3#include <gfx/scene.h>
4#include <gfx/sizes.h>
5
6typedef struct ShaderProgram ShaderProgram;
7
8typedef struct Material {
9 AlphaMode alpha_mode;
10 float alpha_cutoff;
11 int8_t num_uniforms;
12 ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
13} Material;
diff --git a/src/scene/mesh.c b/src/scene/mesh.c
new file mode 100644
index 0000000..770c3fb
--- /dev/null
+++ b/src/scene/mesh.c
@@ -0,0 +1,26 @@
1#include "mesh_impl.h"
2
3#include <gfx/scene.h>
4
5#include "memory.h"
6
7#include <cassert.h>
8
9static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
10 assert(mesh);
11 assert(desc);
12 assert(desc->geometry);
13 assert(desc->material);
14 assert(desc->shader);
15 mesh->geometry = desc->geometry;
16 mesh->material = desc->material;
17 mesh->shader = desc->shader;
18}
19
20Mesh* gfx_make_mesh(const MeshDesc* desc) {
21 Mesh* mesh = mem_alloc_mesh();
22 mesh_make(mesh, desc);
23 return mesh;
24}
25
26void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
diff --git a/src/scene/mesh_impl.h b/src/scene/mesh_impl.h
new file mode 100644
index 0000000..c7e2211
--- /dev/null
+++ b/src/scene/mesh_impl.h
@@ -0,0 +1,11 @@
1#pragma once
2
3typedef struct Geometry Geometry;
4typedef struct Material Material;
5typedef struct ShaderProgram ShaderProgram;
6
7typedef struct Mesh {
8 const Geometry* geometry;
9 const Material* material;
10 ShaderProgram* shader; // TODO: Move this back to Material?
11} Mesh;
diff --git a/src/scene/object.c b/src/scene/object.c
index 7004ce1..ac86b39 100644
--- a/src/scene/object.c
+++ b/src/scene/object.c
@@ -3,8 +3,9 @@
3#include <gfx/core.h> 3#include <gfx/core.h>
4 4
5#include "memory.h" 5#include "memory.h"
6#include "node_impl.h"
7#include "render/llr_impl.h" 6#include "render/llr_impl.h"
7#include "scene/mesh_impl.h"
8#include "scene/node_impl.h"
8 9
9#include <assert.h> 10#include <assert.h>
10 11
diff --git a/src/util/geometry.c b/src/util/geometry.c
index afe0109..2ea0c82 100644
--- a/src/util/geometry.c
+++ b/src/util/geometry.c
@@ -17,12 +17,13 @@ static void make_quad_01_positions(vec2 positions[4]) {
17} 17}
18 18
19static GeometryDesc make_quad_desc(vec2 positions[4]) { 19static GeometryDesc make_quad_desc(vec2 positions[4]) {
20 GeometryDesc desc = (GeometryDesc){0}; 20 return (GeometryDesc){
21 desc.positions2d.data = positions; 21 .positions2d = (BufferView2d){.data = positions,
22 desc.positions2d.size_bytes = 4 * sizeof(vec2); 22 .size_bytes = 4 * sizeof(vec2),
23 desc.num_verts = 4; 23 .count = 4},
24 desc.type = TriangleStrip; 24 .num_verts = 4,
25 return desc; 25 .type = TriangleStrip
26 };
26} 27}
27 28
28Geometry* gfx_make_quad_11(GfxCore* gfxcore) { 29Geometry* gfx_make_quad_11(GfxCore* gfxcore) {
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-03 03:16:03 +0000