2 files changed, 83 insertions, 60 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) {
diff --git a/src/asset/texture.c b/src/asset/texture.c
index c790394..fb423cc 100644
--- a/src/asset/texture.c
+++ b/src/asset/texture.c
@@ -49,7 +49,7 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
   assert(cmd->origin == AssetFromFile || cmd->origin == AssetFromMemory);
   assert(cmd->type == LoadTexture || cmd->type == LoadCubemap);
 
-  int            width, height, components, old_components;
+  int            width, height, components;
   unsigned char* pixels[6] = {0};
 
   switch (cmd->origin) {
@@ -64,7 +64,8 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
       }
       break;
     }
-    case LoadCubemap:
+    case LoadCubemap: {
+      int old_components = 0;
       for (int i = 0; i < 6; ++i) {
         // Flip +Y and -Y textures vertically.
         stbi_set_flip_vertically_on_load(((i == 2) || (i == 3)) ? 1 : 0);
@@ -76,9 +77,10 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
           log_error("Failed to load texture file: %s", filepath);
           break;
         }
-        if (i > 0 && components != old_components) {
-          log_error("All textures in a cubemap must have the same number of "
-                    "components");
+        if ((i > 0) && (components != old_components)) {
+          log_error(
+              "All textures in a cubemap must have the same number of "
+              "components");
           break;
         }
         if ((i != 2) && (i != 3)) {
@@ -89,6 +91,7 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
       }
       break;
     }
+    }
     break;
   case AssetFromMemory:
     // TODO: Load textures from memory.
@@ -122,6 +125,25 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
   }
 
   switch (components) {
+  case 1:
+    switch (cmd->colour_space) {
+    case LinearColourSpace:
+      desc.format = TextureR8;
+      break;
+    case sRGB:
+      // TODO: Gamma single-channel textures are not implemented yet.
+      //  The caller should convert the single-channel to RGB and pass it down
+      //  as sRGB. This is why the ChronographWatch currently appears red on the
+      //  back.
+      log_error("Gamma colour space is not supported for 1-channel textures");
+      // return 0;
+      desc.format = TextureR8;
+      break;
+    default:
+      log_error("Unsupported texture colour space: %d", cmd->colour_space);
+      return 0;
+    }
+    break;
   case 3:
     switch (cmd->colour_space) {
     case LinearColourSpace: