Fix camera calculations

Author: pezcode

src/Cluster.cpp

@@ -114,22 +114,15 @@ void Cluster::initialize(int _argc, char* _argv[])
 
     // Sponza
     // debug camera + lights
-
-    //scene->camera.move({ -7.0f, 2.0f, 0.0f });
-    //scene->camera.rotate({ -45.0f, -90.0f });
-
-    //scene->camera.lookAt({ -7.0f, 2.0f, 0.0f }, scene->center, glm::vec3(0.0f, 1.0f, 0.0f));
-
+    scene->camera.lookAt({ -7.0f, 2.0f, 0.0f }, scene->center, glm::vec3(0.0f, 1.0f, 0.0f));
     scene->pointLights.lights = {
         // pos, power
         { { -5.0f, 0.3f, 0.0f }, { 100.0f, 100.0f, 100.0f } },
         { {  0.0f, 0.3f, 0.0f }, { 100.0f, 100.0f, 100.0f } },
         { {  5.0f, 0.3f, 0.0f }, { 100.0f, 100.0f, 100.0f } }
     };
     scene->pointLights.update();
-    config->lights = 3;
-
-    //generateLights(config->lights);
+    config->lights = scene->pointLights.lights.size();
 
     frameNumber = 0;
 }
@@ -413,7 +406,8 @@ void Cluster::generateLights(unsigned int count)
     for(size_t i = keep; i < count; i++)
     {
         glm::vec3 position = glm::vec3(dist(mt), dist(mt), dist(mt)) * scale - (scale * 0.5f);
-        position.y = glm::abs(position.y);
+        //position += scene->center; // not Sponza
+        position.y = glm::abs(position.y); // Sponza
         glm::vec3 color = glm::vec3(dist(mt), dist(mt), dist(mt));
         glm::vec3 power = color * (dist(mt) * (POWER_MAX - POWER_MIN) + POWER_MIN);
         lights[i] = {

src/Renderer/Shaders/fs_deferred_pointlight.sc

@@ -8,7 +8,6 @@
 SAMPLER2D(s_texDiffuseA,          SAMPLER_DEFERRED_DIFFUSE_A);
 SAMPLER2D(s_texNormal,            SAMPLER_DEFERRED_NORMAL);
 SAMPLER2D(s_texF0Metallic,        SAMPLER_DEFERRED_F0_METALLIC);
-SAMPLER2D(s_texEmissiveOcclusion, SAMPLER_DEFERRED_EMISSIVE_OCCLUSION);
 SAMPLER2D(s_texDepth,             SAMPLER_DEFERRED_DEPTH);
 
 uniform vec4 u_lightIndexVec;
@@ -35,8 +34,6 @@ void main()
     screen.z = texture2D(s_texDepth, texcoord).x;
     vec3 fragPos = screen2Eye(screen).xyz;
 
-    vec3 V = normalize(-fragPos);
-
     // lighting
 
     PointLight light = getPointLight(u_lightIndex);
@@ -47,6 +44,7 @@ void main()
     float attenuation = smoothAttenuation(dist, light.radius);
     if(attenuation > 0.0)
     {
+        vec3 V = normalize(-fragPos);
         vec3 L = normalize(light.position - fragPos);
         vec3 radianceIn = light.intensity * attenuation;
         float NoL = saturate(dot(N, L));

src/Renderer/Shaders/pbr.sh

@@ -81,7 +81,9 @@ vec3 pbrNormal(vec2 texcoord)
 {
     if(u_hasNormalTexture)
     {
-        return normalize((texture2D(s_texNormal, texcoord).rgb * 2.0) - 1.0) * u_normalScale;
+        // the normal scale can cause problems and serves no real purpose
+        // normal compression and BRDF calculations assume unit length
+        return normalize((texture2D(s_texNormal, texcoord).rgb * 2.0) - 1.0); // * u_normalScale;
     }
     else
     {

src/Scene/Camera.cpp

@@ -17,7 +17,7 @@ void Camera::rotate(glm::vec2 delta)
     delta = glm::radians(delta);
 
     // limit pitch
-    float dot = glm::dot(orthUp, forward());
+    float dot = glm::dot(upAxis, forward());
     if((dot < -0.99f && delta.x < 0.0f) || // angle nearing 180 degrees
        (dot >  0.99f && delta.x > 0.0f))   // angle nearing 0 degrees
         delta.x = 0.0f;
@@ -40,21 +40,19 @@ void Camera::zoom(float offset)
 void Camera::lookAt(const glm::vec3& position, const glm::vec3& target, const glm::vec3& up)
 {
     pos = position;
+    upAxis = up;
 
-    rotation = glm::quatLookAtLH(target - position, up);
-
-    /*
     // model rotation
     // maps vectors to camera space (x, y, z)
     glm::vec3 forward = glm::normalize(target - position);
     rotation = glm::rotation(forward, Z);
 
     // correct the up vector
-    glm::vec3 right = glm::cross(glm::normalize(up), forward); // left-handed coordinate system
-    orthUp = -glm::cross(right, forward);
+    // the cross product of non-orthogonal vectors is not normalized
+    glm::vec3 right = glm::normalize(glm::cross(glm::normalize(up), forward)); // left-handed coordinate system
+    glm::vec3 orthUp = glm::cross(forward, right);
     glm::quat upRotation = glm::rotation(rotation * orthUp, Y);
     rotation = upRotation * rotation;
-    */
 
     // inverse of the model rotation
     // maps camera space vectors to model vectors

src/Scene/Camera.h

@@ -40,7 +40,7 @@ struct Camera
     static constexpr float MIN_FOV = 10.0f;
     static constexpr float MAX_FOV = 90.0f;
 
-    glm::vec3 orthUp = Y;
+    glm::vec3 upAxis = Y;
 
     glm::vec3 pos = { 0.0f, 0.0f, 0.0f };
     glm::quat rotation = glm::identity<glm::quat>();

src/Scene/Scene.cpp

@@ -150,9 +150,10 @@ bool Scene::load(const char* file)
             }
             else
             {
-                Log->info("No camera, using default");
-
-                camera.lookAt(center - glm::vec3(0.0f, 0.0f, diagonal / 2.0f), center, glm::vec3(0.0f, 1.0f, 0.0f));
+                Log->info("No camera");
+                camera.lookAt(center - glm::vec3(0.0f, 0.0f, diagonal / 2.0f),
+                              center,
+                              glm::vec3(0.0f, 1.0f, 0.0f));
                 camera.zFar = diagonal;
                 camera.zNear = camera.zFar / 50.0f;
             }