1 files changed, 56 insertions, 55 deletions

diff --git a/src/asset/model.c b/src/asset/model.c
index 25f2780..402b2e1 100644
--- a/src/asset/model.c
+++ b/src/asset/model.c
@@ -578,11 +578,10 @@ static bool load_buffers(
     const cgltf_buffer* buffer = &data->buffers[i];
     assert(buffer->data);
     buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
-                     .usage      = BufferStatic,
-                     .type       = BufferUntyped,
-                     .data.data  = buffer->data,
-                     .data.count = buffer->size});
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
+                               .type       = BufferUntyped,
+                               .data.data  = buffer->data,
+                               .data.count = buffer->size});
     if (!buffers[i]) {
       return false;
     }
@@ -604,11 +603,10 @@ static bool load_tangent_buffers(
     const cgltfTangentBuffer* buffer = &cgltf_tangent_buffers[i];
     assert(buffer->data);
     tangent_buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
-                     .usage      = BufferStatic,
-                     .type       = BufferUntyped,
-                     .data.data  = buffer->data,
-                     .data.count = buffer->size_bytes});
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
+                               .type       = BufferUntyped,
+                               .data.data  = buffer->data,
+                               .data.count = buffer->size_bytes});
     if (!tangent_buffers[i]) {
       return false;
     }
@@ -682,14 +680,13 @@ static void load_textures_lazy(
     mstring fullpath =
         mstring_concat_path(mstring_make(directory), mstring_make(image->uri));
 
-    load_texture_cmds[i] = (LoadTextureCmd){
-        .origin                = AssetFromFile,
-        .type                  = LoadTexture,
-        .colour_space          = sRGB,
-        .filtering             = filtering,
-        .wrap                  = wrap,
-        .mipmaps               = mipmaps,
-        .data.texture.filepath = fullpath};
+    load_texture_cmds[i] = (LoadTextureCmd){.origin       = AssetFromFile,
+                                            .type         = LoadTexture,
+                                            .colour_space = LinearColourSpace,
+                                            .filtering    = filtering,
+                                            .wrap         = wrap,
+                                            .mipmaps      = mipmaps,
+                                            .data.texture.filepath = fullpath};
   }
 }
 
@@ -717,8 +714,12 @@ static bool load_texture_and_uniform(
   // not be used as albedo and vice versa.
   if (!textures[texture_index]) {
     LoadTextureCmd* cmd = &load_texture_cmds[texture_index];
-    // TODO: Check for colour textures and default to LinearColourSpace instead.
-    if (texture_type == NormalMap) {
+    // Albedo and emissive use sRGB. Other textures use a linear colour space.
+    // See the notes on the spec.
+    if ((texture_type == BaseColorTexture) ||
+        (texture_type == EmissiveTexture)) {
+      cmd->colour_space = sRGB;
+    } else {
       cmd->colour_space = LinearColourSpace;
     }
 
@@ -778,22 +779,22 @@ static bool load_materials(
           .value.vec4 = vec4_from_array(pbr->base_color_factor)};
 
       assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
-      desc.uniforms[next_uniform++] = (ShaderUniform){
-          .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
-          .type         = UniformFloat,
-          .value.scalar = pbr->metallic_factor};
+      desc.uniforms[next_uniform++] =
+          (ShaderUniform){.name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+                          .type         = UniformFloat,
+                          .value.scalar = pbr->metallic_factor};
 
       assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
-      desc.uniforms[next_uniform++] = (ShaderUniform){
-          .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
-          .type         = UniformFloat,
-          .value.scalar = pbr->roughness_factor};
+      desc.uniforms[next_uniform++] =
+          (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+                          .type = UniformFloat,
+                          .value.scalar = pbr->roughness_factor};
 
       assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
-      desc.uniforms[next_uniform++] = (ShaderUniform){
-          .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-          .type       = UniformVec3,
-          .value.vec3 = vec3_from_array(mat->emissive_factor)};
+      desc.uniforms[next_uniform++] =
+          (ShaderUniform){.name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+                          .type       = UniformVec3,
+                          .value.vec3 = vec3_from_array(mat->emissive_factor)};
 
       if (pbr->base_color_texture.texture) {
         if (!load_texture_and_uniform(
@@ -854,28 +855,28 @@ static Material* make_default_material() {
   MaterialDesc desc = (MaterialDesc){0};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
-      .type       = UniformVec4,
-      .value.vec4 = vec4_make(1, 1, 1, 1)};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+                      .type       = UniformVec4,
+                      .value.vec4 = vec4_make(1, 1, 1, 1)};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
-      .type         = UniformFloat,
-      .value.scalar = 0};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+                      .type         = UniformFloat,
+                      .value.scalar = 0};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
-      .type         = UniformFloat,
-      .value.scalar = 1};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+                      .type         = UniformFloat,
+                      .value.scalar = 1};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-      .type       = UniformVec3,
-      .value.vec3 = vec3_make(0, 0, 0)};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+                      .type       = UniformVec3,
+                      .value.vec3 = vec3_make(0, 0, 0)};
 
   return gfx_make_material(&desc);
 }
@@ -1192,10 +1193,10 @@ static bool load_meshes(
           shader ? shader : make_shader_permutation(gfxcore, perm);
       assert(mesh_shader);
 
-      meshes[next_mesh] = gfx_make_mesh(&(MeshDesc){
-          .geometry = geometries[next_mesh],
-          .material = material,
-          .shader   = mesh_shader});
+      meshes[next_mesh] =
+          gfx_make_mesh(&(MeshDesc){.geometry = geometries[next_mesh],
+                                    .material = material,
+                                    .shader   = mesh_shader});
 
       if (!meshes[next_mesh]) {
         return false;
@@ -1432,9 +1433,9 @@ static void load_animations(
     const cgltf_animation* animation      = &data->animations[a];
     AnimationDesc*         animation_desc = &anima_desc->animations[a];
 
-    *animation_desc = (AnimationDesc){
-        .name         = sstring_make(animation->name),
-        .num_channels = animation->channels_count};
+    *animation_desc =
+        (AnimationDesc){.name         = sstring_make(animation->name),
+                        .num_channels = animation->channels_count};
 
     assert(animation->channels_count <= GFX_MAX_NUM_CHANNELS);
     for (cgltf_size c = 0; c < animation->channels_count; ++c) {