Fix IBL cubemap coordinate system and put position-normal-tangent in world space in CookTorrance.

10 files changed, 127 insertions, 40 deletions

diff --git a/gfx/shaders/cook_torrance.frag b/gfx/shaders/cook_torrance.frag
index 1adb4ae..1975491 100644
--- a/gfx/shaders/cook_torrance.frag
+++ b/gfx/shaders/cook_torrance.frag
@@ -30,7 +30,7 @@ uniform float       MaxReflectionLOD;
 
 uniform vec3 CameraPosition; // World space.
 
-// World-space position and normal.
+// World-space position, normal and tangent.
 in vec3 Position;
 #ifdef HAS_NORMALS
 in vec3 Normal;
@@ -53,13 +53,14 @@ layout (location = 0) out vec4 Colour;
 /// |normalMapSample| is the normal map sample, not necessarily normalized.
 ///
 /// TODO: Move to "normal.h"
+#if defined(HAS_NORMAL_MAP) && (defined(HAS_TANGENTS) || defined(HAS_TEXCOORDS))
 vec3 get_ws_normal(vec3 normalWs, vec3 normalMapSample) {
   vec3 N = normalize(Normal);
 #ifdef HAS_TANGENTS
   //vec3 T = normalize(tangent.xyz - dot(tangent.xyz, N) * N);
   vec3 T = Tangent.xyz;
   vec3 B = Tangent.w * cross(N, T);
-#else // No tangents
+#elif HAS_TEXCOORDS // No tangents, but must have texcoords.
   vec3 pos_dx = dFdx(Position);
   vec3 pos_dy = dFdy(Position);
   // vec3 uv_dx = vec3(dFdx(Texcoord), 0.0);
@@ -71,7 +72,7 @@ vec3 get_ws_normal(vec3 normalWs, vec3 normalMapSample) {
   // vec3 T = pos_dx * uv_dy.t - pos_dy * uv_dx.t;
   T = normalize(T - dot(T, N) * N);
   vec3 B = normalize(cross(N, T));
-#endif // HAS_TANGENTS
+#endif
 
   if (gl_FrontFacing == false) {
     T = -T;
@@ -83,6 +84,7 @@ vec3 get_ws_normal(vec3 normalWs, vec3 normalMapSample) {
   //return normalize(s.x * T + s.y * B + s.z * N);
   return normalize(mat3(T,B,N) * s);
 }
+#endif // HAS_TANGENTS || HAS_TEXCOORDS
 
 float trowbridge_reitz_GGX(float roughness, float NdotH) {
   float a = roughness * roughness;
@@ -188,7 +190,7 @@ void main()
 #else
   float occlusion = 1.0;
 #endif
-  float metallic = metal_roughness.x;
+  float metallic  = metal_roughness.x;
   float roughness = metal_roughness.y;
 
   // For a single light direction:
diff --git a/gfx/shaders/cook_torrance.vert b/gfx/shaders/cook_torrance.vert
index 697bb0c..5f126c0 100644
--- a/gfx/shaders/cook_torrance.vert
+++ b/gfx/shaders/cook_torrance.vert
@@ -1,7 +1,8 @@
 precision highp float;
 
 uniform mat4 ModelMatrix;
-uniform mat4 Modelview;
+// uniform mat4 Modelview;
+uniform mat4 View;
 uniform mat4 Projection;
 //uniform mat4 MVP;
 #ifdef HAS_JOINTS
@@ -34,7 +35,7 @@ layout (location = 4) in uvec4 vJoint;
 layout (location = 5) in vec4  vWeight;
 #endif
 
-// World-space position and normal.
+// World-space position, normal and tangent.
 out vec3 Position;
 #ifdef HAS_NORMALS
 out vec3 Normal;
@@ -54,9 +55,9 @@ void main()
     vWeight.y * JointMatrices[vJoint.y] +
     vWeight.z * JointMatrices[vJoint.z] +
     vWeight.w * JointMatrices[vJoint.w];
-  Position = vec3(Modelview * skinMatrix * vec4(vPosition, 1.0));
+  Position = vec3(ModelMatrix * skinMatrix * vec4(vPosition, 1.0));
 #else
-  Position = vec3(Modelview * vec4(vPosition, 1.0));
+  Position = vec3(ModelMatrix * vec4(vPosition, 1.0));
 #endif
 #ifdef HAS_NORMALS
   Normal = mat3(ModelMatrix) * vNormal;
@@ -68,6 +69,7 @@ void main()
 #ifdef HAS_TEXCOORDS
   Texcoord = vTexcoord;
 #endif
-  gl_Position = Projection * vec4(Position, 1.0);
+  gl_Position = Projection * View * vec4(Position, 1.0);
+  //gl_Position = Projection * vec4(Position, 1.0);
   //gl_Position = MVP * vec4(vPosition, 1.0);
 }
diff --git a/gfx/shaders/cubemap_filtering.vert b/gfx/shaders/cubemap_filtering.vert
index cdc291c..d0cf73f 100644
--- a/gfx/shaders/cubemap_filtering.vert
+++ b/gfx/shaders/cubemap_filtering.vert
@@ -3,32 +3,37 @@ precision highp float;
 #define PI 3.1415926535897932384626433832795
 #define FOVY (90.0 * PI / 180.0)
 
-uniform mat4 Modelview;
+uniform mat4 CameraRotation; // From camera space to world space.
+uniform float Flip;
 
 layout (location = 0) in vec2 vPosition;
 
 out vec3 Ray;
 
+// DEBUG
+// out vec2 Texcoord;
+
 // This is very similar to the skyquad vertex shader.
 //
 // The ray is not normalized because it isn't necessary for cubemap sampling.
 //
 // We also use a fixed fovy = 90 degrees because we want the frustum to pass
 // exactly through each face of the cube. The aspect ratio is also just 1.
-//
-// |d| here appears with a positive sign in the returned vector because the
-// rotation part of the Modelview matrix is responsible for orienting the ray
-// appropriately.
-vec3 sky_ray(vec2 Texcoord)
+vec3 sky_ray(vec2 FilmPosition)
 {
   float d = 0.5 / tan(FOVY/2.0);
-  return vec3(Texcoord.x - 0.5, Texcoord.y - 0.5, d);
+  return vec3(FilmPosition, -d);
 }
 
 void main()
 {
-  mat3 Rotation = mat3(Modelview);
-  Ray = Rotation * sky_ray(vPosition*0.5 + 0.5); // map [-1,1] -> [0,1]
-  // Should disable depth test when rendering.
-  gl_Position = vec4(vPosition.xy, 0.99999, 1.0);
+  vec2 FilmPosition = vPosition * 0.5; // map [-1,1] -> [-1/2, +1/2]
+  FilmPosition *= Flip;
+  Ray = mat3(CameraRotation) * sky_ray(FilmPosition);
+  // TODO: Should disable depth test when rendering.
+  gl_Position = vec4(vPosition, 0.99999, 1.0); // z=1 -> send to background
+
+  // DEBUG
+  // Texcoord   = FilmPosition + 0.5;
+  // Texcoord.y = 1.0 - Texcoord.y;
 }
diff --git a/gfx/shaders/irradiance_map.frag b/gfx/shaders/irradiance_map.frag
index 3cfe5b2..8200e73 100644
--- a/gfx/shaders/irradiance_map.frag
+++ b/gfx/shaders/irradiance_map.frag
@@ -13,6 +13,9 @@ uniform samplerCube Sky;
 
 in vec3 Ray;
 
+// DEBUG
+// in vec2 Texcoord;
+
 layout (location = 0) out vec4 Color;
 
 void main()
@@ -29,8 +32,8 @@ void main()
   //     T
   vec3 N = normalize(Ray);
   vec3 B = (abs(N.x) - 1.0 <= EPS) ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-  vec3 T = cross(B, N);
-  B = cross(N, T);
+  vec3 T = normalize(cross(B, N));
+  B = normalize(cross(N, T));
 
   int num_samples = 0;
   vec3 irradiance = vec3(0.0);
@@ -54,6 +57,8 @@ void main()
   irradiance = PI * irradiance / float(num_samples);
 
   // For debugging in trace.
+  //irradiance = texture(Sky, Ray).rgb;
+  // irradiance = vec3(Texcoord, 0.0);
   //irradiance = pow(irradiance, vec3(1.0/2.2));
 
   Color = vec4(irradiance, 1.0);
diff --git a/gfx/shaders/skyquad.frag b/gfx/shaders/skyquad.frag
index 39af013..9b44bfd 100644
--- a/gfx/shaders/skyquad.frag
+++ b/gfx/shaders/skyquad.frag
@@ -8,4 +8,6 @@ void main()
 {
     vec3 R = normalize(Ray);
     Colour = vec4(pow(texture(Skyquad, R).rgb, vec3(1.0/2.2)), 1.0);
+    // Debug.
+    //Colour = vec4(pow(R*0.5 + 0.5, vec3(1.0 / 2.2)), 1.0);
 }
diff --git a/gfx/shaders/skyquad.vert b/gfx/shaders/skyquad.vert
index f0658d6..c0c46e6 100644
--- a/gfx/shaders/skyquad.vert
+++ b/gfx/shaders/skyquad.vert
@@ -1,4 +1,4 @@
-uniform mat4 Modelview;
+uniform mat4  CameraRotation; // From camera space to world space.
 uniform float Fovy;
 uniform float Aspect;
 
@@ -8,21 +8,20 @@ out vec3 Ray;
 
 // We would typically normalize the vector, but there is no need to do so when
 // sampling a cube map.
-vec3 sky_ray(vec2 Texcoord)
+vec3 sky_ray(vec2 FilmPosition)
 {
   //float d = 0.5 / tan(Fovy/2.0);
-  // return vec3((Texcoord.x - 0.5) * Aspect,
-  //              Texcoord.y - 0.5,
+  // return vec3((FilmPosition.x - 0.5) * Aspect,
+  //              FilmPosition.y - 0.5,
   //              -d);
   float d = 0.5 / tan(Fovy/2.0);
-  return vec3((Texcoord.x - 0.5),
-               Texcoord.y - 0.5,
-               -d);
+  return vec3(FilmPosition, -d);
 }
 
 void main()
 {
-  mat3 Rotation = mat3(Modelview);
-  Ray = Rotation * sky_ray(Position*0.5 + 0.5); // map [-1,1] -> [0,1]
+  vec2 FilmPosition = Position * 0.5; // map [-1,1] -> [-1/2, +1/2]
+  Ray = mat3(CameraRotation) * sky_ray(FilmPosition);
+  // Set z to the background.
   gl_Position = vec4(Position, 0.99999, 1.0); // z=1 -> send to background
 }
diff --git a/gfx/src/renderer/renderer.c b/gfx/src/renderer/renderer.c
index 47f1344..b0bef33 100644
--- a/gfx/src/renderer/renderer.c
+++ b/gfx/src/renderer/renderer.c
@@ -114,6 +114,7 @@ typedef struct RenderState {
   Renderer*      renderer;
   const Scene*   scene;
   const Camera*  camera;
+  const mat4*    camera_rotation; // From camera to world space, rotation only.
   const mat4*    view_matrix;
   const mat4*    projection;
   Light*         environment_light;
@@ -167,6 +168,8 @@ static void draw_recursively(
     const SceneObject* object = mem_get_object(node->object);
     assert(object);
 
+    // TODO: Avoid computing matrices like Modelview or MVP if the shader does
+    // not use them.
     const mat4 model_matrix = mat4_mul(node_transform, object->transform);
     const mat4 modelview    = mat4_mul(*state->view_matrix, model_matrix);
     const mat4 mvp          = mat4_mul(*state->projection, modelview);
@@ -187,13 +190,13 @@ static void draw_recursively(
       assert(mesh->geometry);
       assert(mesh->material);
       // Apply common shader uniforms not captured by materials.
-      // TODO: Avoid computing matrices like Modelview or MVP if the shader does
-      // not use them.
       ShaderProgram* shader = mesh->shader;
       gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix);
       gfx_set_mat4_uniform(shader, "Modelview", &modelview);
+      gfx_set_mat4_uniform(shader, "View", state->view_matrix);
       gfx_set_mat4_uniform(shader, "Projection", state->projection);
       gfx_set_mat4_uniform(shader, "MVP", &mvp);
+      gfx_set_mat4_uniform(shader, "CameraRotation", state->camera_rotation);
       gfx_set_float_uniform(shader, "Fovy", state->fovy);
       gfx_set_float_uniform(shader, "Aspect", state->aspect);
       gfx_set_vec3_uniform(shader, "CameraPosition", state->camera->spatial.p);
@@ -247,6 +250,8 @@ void gfx_render_scene(
   }
 
   const mat4 projection = camera ? camera->camera.projection : mat4_id();
+  const mat4 camera_rotation =
+      mat4_rotation(spatial3_transform(&camera->camera.spatial));
   const mat4 view_matrix =
       camera ? spatial3_inverse_transform(&camera->camera.spatial) : mat4_id();
 
@@ -259,6 +264,7 @@ void gfx_render_scene(
       .renderer          = renderer,
       .scene             = scene,
       .camera            = &camera->camera,
+      .camera_rotation   = &camera_rotation,
       .view_matrix       = &view_matrix,
       .projection        = &projection,
       .environment_light = 0,
diff --git a/gfx/src/util/ibl.c b/gfx/src/util/ibl.c
index c9bef43..6b7465c 100644
--- a/gfx/src/util/ibl.c
+++ b/gfx/src/util/ibl.c
@@ -24,7 +24,16 @@ static const CubemapFace faces[6] = {
     CubemapFacePosY, // Up.
     CubemapFaceNegY, // Down.
     CubemapFacePosZ, // Back.
-    CubemapFaceNegZ, // Forward.
+    CubemapFaceNegZ, // Front.
+};
+
+static const float flips[6] = {
+    -1.0f, // Right.
+    -1.0f, // Left.
+    +1.0f, // Up.
+    +1.0f, // Down.
+    -1.0f, // Back.
+    -1.0f, // Front.
 };
 
 IBL* gfx_make_ibl(RenderBackend* render_backend) {
@@ -70,6 +79,9 @@ IBL* gfx_make_ibl(RenderBackend* render_backend) {
     goto cleanup;
   }
 
+  // TODO: Debug the camera rotations. Irradiance debug output should appear
+  // just like the input cubemap.
+
   // Right.
   ibl->rotations[0] = mat4_lookat(
       /*position=*/vec3_make(0, 0, 0),
@@ -95,7 +107,7 @@ IBL* gfx_make_ibl(RenderBackend* render_backend) {
       /*position=*/vec3_make(0, 0, 0),
       /*target=*/vec3_make(0, 0, 1),
       /*up=*/vec3_make(0, 1, 0));
-  // Forward.
+  // Front.
   ibl->rotations[5] = mat4_lookat(
       /*position=*/vec3_make(0, 0, 0),
       /*target=*/vec3_make(0, 0, -1),
@@ -226,8 +238,9 @@ Texture* gfx_make_irradiance_map(
                                   .cubemap.texture = irradiance_map})) {
       goto cleanup;
     }
+    gfx_set_float_uniform(ibl->irradiance_map_shader, "Flip", flips[i]);
     gfx_set_mat4_uniform(
-        ibl->irradiance_map_shader, "Modelview", &ibl->rotations[i]);
+        ibl->irradiance_map_shader, "CameraRotation", &ibl->rotations[i]);
     gfx_apply_uniforms(ibl->irradiance_map_shader);
     gfx_render_geometry(ibl->quad);
   }
@@ -291,8 +304,10 @@ Texture* gfx_make_prefiltered_environment_map(
                                     .cubemap.texture = prefiltered_env_map})) {
         goto cleanup;
       }
+      gfx_set_float_uniform(
+          ibl->prefiltered_environment_map_shader, "Flip", flips[i]);
       gfx_set_mat4_uniform(
-          ibl->prefiltered_environment_map_shader, "Modelview",
+          ibl->prefiltered_environment_map_shader, "CameraRotation",
           &ibl->rotations[i]);
       gfx_apply_uniforms(ibl->prefiltered_environment_map_shader);
       gfx_render_geometry(ibl->quad);
diff --git a/gfx/src/util/texture.c b/gfx/src/util/texture.c
index 99241f4..0727dae 100644
--- a/gfx/src/util/texture.c
+++ b/gfx/src/util/texture.c
@@ -6,6 +6,42 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include <stb_image.h>
 
+#include <assert.h>
+
+static void flip_horizontally(
+    unsigned char* pixels, int width, int height, int components) {
+  assert(pixels);
+
+  for (int y = 0; y < height; ++y) {
+    for (int x = 0; x < width / 2; ++x) {
+      unsigned char* p1 = &pixels[(y * width + x) * components];
+      unsigned char* p2 = &pixels[(y * width + (width - x - 1)) * components];
+
+      for (int c = 0; c < components; ++c) {
+        unsigned char tmp = *p1;
+        *p1               = *p2;
+        *p2               = tmp;
+        p1++;
+        p2++;
+      }
+    }
+  }
+}
+
+// Note that the cubemap coordinate system uses the one in RenderMan:
+//
+//   https://www.khronos.org/opengl/wiki/Cubemap_Texture
+//
+// This is what happens:
+//
+//   - Cubemaps follow a left-handed coordinate system. Say, +X is right, +Y is
+//     up, and +Z is forward.
+//   - The texture coordinate system follow's DirectX's, so +V goes down, not up
+//     like it does in OpenGL.
+//
+// For this reason, we do X and Y flips when doing cubemap textures so that we
+// can sample cubemaps as if they were given in the usual OpenGL coordinate
+// system.
 Texture* gfx_load_texture(
     RenderBackend* render_backend, const LoadTextureCmd* cmd) {
   assert(render_backend);
@@ -21,6 +57,7 @@ Texture* gfx_load_texture(
     switch (cmd->type) {
     case LoadTexture: {
       const char* filepath = mstring_cstr(&cmd->data.texture.filepath);
+      stbi_set_flip_vertically_on_load(0);
       pixels[0] = stbi_load(filepath, &width, &height, &components, 0);
       if (!pixels[0]) {
         gfx_set_error("Failed to load texture file: %s", filepath);
@@ -29,6 +66,8 @@ Texture* gfx_load_texture(
     }
     case LoadCubemap:
       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);
         const char* filepath =
             mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_x + i);
         stbi_uc* image_pixels =
@@ -43,6 +82,9 @@ Texture* gfx_load_texture(
               "components");
           break;
         }
+        if ((i != 2) && (i != 3)) {
+          flip_horizontally(image_pixels, width, height, components);
+        }
         pixels[i]      = image_pixels;
         old_components = components;
       }
diff --git a/gltfview/src/game.c b/gltfview/src/game.c
index 1db7cba..f822b08 100644
--- a/gltfview/src/game.c
+++ b/gltfview/src/game.c
@@ -70,8 +70,8 @@ static Texture* load_environment_map(RenderBackend* render_backend) {
                                      mstring_make("/assets/skybox/clouds1/clouds1_west.bmp"),
                                      mstring_make("/assets/skybox/clouds1/clouds1_up.bmp"),
                                      mstring_make("/assets/skybox/clouds1/clouds1_down.bmp"),
-                                     mstring_make("/assets/skybox/clouds1/clouds1_north.bmp"),
-                                     mstring_make("/assets/skybox/clouds1/clouds1_south.bmp")}
+                                     mstring_make("/assets/skybox/clouds1/clouds1_south.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_north.bmp")}
   });
 }
 
@@ -222,7 +222,7 @@ bool game_new(Game* game, int argc, const char** argv) {
   //     false});
   const bool play_result = gfx_play_animation(
       anima, &(AnimationPlaySettings){.name = "Walk", .loop = true});
-  assert(play_result);
+  // assert(play_result);
 
   return true;
 
@@ -251,6 +251,15 @@ void game_update(Game* game, double t, double dt) {
       /*radius=*/2.5,
       /*azimuth=*/t * 0.5, /*zenith=*/0);
   spatial3_lookat(&camera->spatial, orbit_point);
+
+  // spatial3_set_position(&camera->spatial, vec3_make(0, 0, 2));
+  // spatial3_lookat(&camera->spatial, vec3_make(0, 0, -1));
+
+  // spatial3_orbit(
+  //     &camera->spatial, vec3_make(0, 0, 0),
+  //     /*radius=*/2.5,
+  //     /*azimuth=*/t * 0.2, /*zenith=*/0);
+  // spatial3_lookat(&camera->spatial, vec3_make(0, 0, 0));
 }
 
 void game_render(const Game* game) {