potentially buggy normals and first update to phong

5 files changed, 130 insertions, 114 deletions

diff --git a/src/illuminate/illuminate.cpp b/src/illuminate/illuminate.cpp
index d6d43c8..a093fd1 100644
--- a/src/illuminate/illuminate.cpp
+++ b/src/illuminate/illuminate.cpp
@@ -2,23 +2,23 @@
 
 glm::vec4  RayTracer::illuminationFromPointLight(
         const SceneLightData &light,
-        glm::vec3 intersectionWorld,
-        glm::vec3 normalWorld,
-        glm::vec3  directionToCamera,
+        glm::vec4 intersectionWorld,
+        glm::vec4 normalWorld,
+        glm::vec4  directionToCamera,
         const RenderShapeData &shape,
         const RayTraceScene &scene
         )
 {
-    auto directionFromIntersectionToLight = light.pos.xyz() - intersectionWorld;
+    auto directionFromIntersectionToLight = light.pos - intersectionWorld;
     directionFromIntersectionToLight = glm::normalize(directionFromIntersectionToLight);
 
     // check if this light is blocked by an object
-    auto distanceToLight = glm::distance(light.pos.xyz(), intersectionWorld);
+    auto distanceToLight = glm::distance(light.pos, intersectionWorld);
     bool isShadow = RayTracer::isShadowed(
             light.pos,
             distanceToLight,
-            glm::vec4(directionFromIntersectionToLight, 0.f),
-            glm::vec4(intersectionWorld, 1.f),
+            glm::vec4(directionFromIntersectionToLight),
+            glm::vec4(intersectionWorld),
             scene);
     if (isShadow)
     {
@@ -45,20 +45,20 @@ glm::vec4  RayTracer::illuminationFromPointLight(
 
 glm::vec4  RayTracer::illuminationFromSpotLight(
         const SceneLightData &light,
-        glm::vec3 intersectionWorld,
-        glm::vec3 normalWorld,
-        glm::vec3 directionToCamera,
+        glm::vec4 intersectionWorld,
+        glm::vec4 normalWorld,
+        glm::vec4 directionToCamera,
         const RenderShapeData &shape,
         const RayTraceScene &scene
 )
 {
-    auto distance = glm::distance(light.pos.xyz(), intersectionWorld);
+    auto distance = glm::distance(light.pos, intersectionWorld);
 
     // calculate the angle from the shape to the spot light
-    auto directionFromIntersectionToLight = glm::normalize(light.pos.xyz() - intersectionWorld);
+    auto directionFromIntersectionToLight = glm::normalize(light.pos - intersectionWorld);
 
     // calculate intensity, based on angle. apply falloff if necessary
-    auto lightDirection = glm::normalize(light.dir.xyz());
+    auto lightDirection = glm::normalize(light.dir);
     // invert the direction of the intersection to light for dot product to work correctly
     auto cosTheta = glm::dot(-directionFromIntersectionToLight, lightDirection);
     auto theta = glm::acos(cosTheta);
@@ -87,12 +87,12 @@ glm::vec4  RayTracer::illuminationFromSpotLight(
     }
 
     // if the light is within the cone, see if it's a shadow
-    auto distanceToLight = glm::distance(light.pos.xyz(), intersectionWorld);
+    auto distanceToLight = glm::distance(light.pos, intersectionWorld);
     bool isShadow = RayTracer::isShadowed(
             light.pos,
             distanceToLight,
-            glm::vec4(directionFromIntersectionToLight, 0.f),
-            glm::vec4(intersectionWorld, 1.f),
+            glm::vec4(directionFromIntersectionToLight),
+            glm::vec4(intersectionWorld),
             scene);
     if (isShadow)
     {
@@ -119,9 +119,9 @@ glm::vec4  RayTracer::illuminationFromSpotLight(
 
 glm::vec4  RayTracer::illuminationFromDirectionalLight(
         const SceneLightData &light,
-        glm::vec3 intersectionWorld,
-        glm::vec3 normalWorld,
-        glm::vec3 directionToCamera,
+        glm::vec4 intersectionWorld,
+        glm::vec4 normalWorld,
+        glm::vec4 directionToCamera,
         const RenderShapeData &shape,
         const RayTraceScene &scene
 )
@@ -136,7 +136,7 @@ glm::vec4  RayTracer::illuminationFromDirectionalLight(
             light.pos,
             distanceToLight,
             directionFromIntersectionToLight,
-            glm::vec4(intersectionWorld, 1.f),
+            glm::vec4(intersectionWorld),
             scene);
     if (isShadow)
     {
@@ -160,9 +160,9 @@ glm::vec4  RayTracer::illuminationFromDirectionalLight(
 
 // Calculates the RGBA of a pixel from intersection infomation and globally-defined coefficients
 glm::vec4 RayTracer::illuminatePixel(
-        glm::vec3  intersectionWorld,
-        glm::vec3  normalWorld,
-        glm::vec3  directionToCamera,
+        glm::vec4  intersectionWorld,
+        glm::vec4  normalWorld,
+        glm::vec4  directionToCamera,
         const RenderShapeData& shape,
         const RayTraceScene &scene,
         int depth)
@@ -214,10 +214,10 @@ glm::vec4 RayTracer::illuminatePixel(
 glm::vec4 RayTracer::phong(
         glm::vec4 lightColor,
         float attenuation,
-        glm::vec3 directionFromIntersectionToLight,
-        glm::vec3 directionToCamera,
-        glm::vec3 intersectionWorld,
-        glm::vec3 normalWorld,
+        glm::vec4 directionFromIntersectionToLight,
+        glm::vec4 directionToCamera,
+        glm::vec4 intersectionWorld,
+        glm::vec4 normalWorld,
         const RenderShapeData &shape,
         const RayTraceScene &scene)
 {
@@ -232,11 +232,12 @@ glm::vec4 RayTracer::phong(
     if (dotDiffuse > 0) // ensure not facing away
     {
         auto diffuse = (kd * material.cDiffuse);
-        if (material.textureMap.isUsed)
-        {
-            glm::vec4 pObject = shape.inverseCTM * glm::vec4(intersectionWorld, 1.f);
-            diffuse = interpolateTexture(pObject, shape, diffuse);
-        }
+        // commenting out texture stuff bc 4d textures??????
+//        if (material.textureMap.isUsed)
+//        {
+//            glm::vec4 pObject = shape.inverseCTM * glm::vec4(intersectionWorld, 1.f);
+//            diffuse = interpolateTexture(pObject, shape, diffuse);
+//        }
         illumination += (attenuation * lightColor) * dotDiffuse * diffuse;
     }
 
@@ -256,9 +257,9 @@ glm::vec4 RayTracer::phong(
 // EXTRA CREDIT -> AREA LIGHT
 glm::vec4  RayTracer::illuminationFromAreaLight(
         const SceneLightData &light,
-        glm::vec3 intersectionWorld,
-        glm::vec3 normalWorld,
-        glm::vec3  directionToCamera,
+        glm::vec4 intersectionWorld,
+        glm::vec4 normalWorld,
+        glm::vec4  directionToCamera,
         const RenderShapeData &shape,
         const RayTraceScene &scene
 ) {
@@ -269,20 +270,20 @@ glm::vec4  RayTracer::illuminationFromAreaLight(
     float y = ((float) rand() / (float) RAND_MAX) * height - height / 2.f;
     glm::vec4 lightPosition = light.pos + glm::vec4(x, y, 0.f, 0.f);
 
-    auto directionFromIntersectionToLight = lightPosition.xyz() - intersectionWorld;
+    auto directionFromIntersectionToLight = lightPosition - intersectionWorld;
     directionFromIntersectionToLight = glm::normalize(directionFromIntersectionToLight);
 
     // check if this light is blocked by an object
-    auto distanceToLight = glm::distance(lightPosition.xyz(), intersectionWorld);
+    auto distanceToLight = glm::distance(lightPosition, intersectionWorld);
     bool isShadow = RayTracer::isShadowed(
             lightPosition,
             distanceToLight,
-            glm::vec4(directionFromIntersectionToLight, 0.f),
-            glm::vec4(intersectionWorld, 1.f),
+            glm::vec4(directionFromIntersectionToLight),
+            glm::vec4(intersectionWorld),
             scene);
     if (isShadow)
     {
-        // if this is a shadow, then shoow a ray to a random point in the light
+        // if this is a shadow, then show a ray to a random point in the light
         return glm::vec4(0.f);
     }
 
diff --git a/src/intersect/intersect.cpp b/src/intersect/intersect.cpp
index cc3143d..3e8493c 100644
--- a/src/intersect/intersect.cpp
+++ b/src/intersect/intersect.cpp
@@ -114,7 +114,7 @@ glm::vec4 intersectCylinder(
 {
     float t = FINF;
 
-    // implicit: x^2 + z^2 = r^2, y + w between -.5, 5 rectuangular side
+    // implicit: x^2 + z^2 = r^2, y + w between -.5, .5 rectuangular side
     float radius = 0.5f;
     float a = d.x*d.x + d.z*d.z;
     float b = 2.f * (p.x*d.x + p.z*d.z);
@@ -149,7 +149,7 @@ glm::vec4 intersectCylinder(
 
 
     // implicit y + w = .5f, top base
-    float tTop = (.5f - p.y - p.y) / (d[3] + d.y);
+    float tTop = (.5f - p.y - p[3]) / (d[3] + d.y);
     auto pTop = p + tTop * d;
     if (
         tTop > 0 &&
@@ -162,7 +162,7 @@ glm::vec4 intersectCylinder(
 
 
     // implicit p_y + t*d_y = -.5f, Bottom base
-    float tBase = (.5f - p.y - p.y) / (d[3] + d.y);
+    float tBase = (.5f - p.y - p[3]) / (d[3] + d.y);
     auto pBase = p + tBase * d;
     if (
         tBase > 0 &&
diff --git a/src/intersect/normals.cpp b/src/intersect/normals.cpp
index 50d4af5..84db534 100644
--- a/src/intersect/normals.cpp
+++ b/src/intersect/normals.cpp
@@ -4,104 +4,122 @@
 
 #include "raytracer/raytracer.h"
 
-glm::vec3 getConeNormal(
-        glm::vec4 intersectPointObject)
+glm::vec4 getConeNormal(
+    glm::vec4 intersectPointObject)
 {
-    if (RayTracer::floatEquals(intersectPointObject.y, -.5f)) // normal for base
+    if (RayTracer::floatEquals(intersectPointObject.y, -.5f)) // normal for y base
     {
-        return {0.f, -1.f, 0.f};
+        return {0.f, -1.f, 0.f, 0.f};
     }
-    if (RayTracer::floatEquals(intersectPointObject.y, .5f)) // normal for top
+    if (RayTracer::floatEquals(intersectPointObject[3], -.5f)) // normal for w base
     {
-        return {0.f, 1.f, 0.f};
+        return {0.f, 0.f, 0.f, -1.f};
+    }
+    if (RayTracer::floatEquals(intersectPointObject.y, .5f)) // normal for y top
+    {
+        return {0.f, 1.f, 0.f, 0.f};
+    }
+    if (RayTracer::floatEquals(intersectPointObject[3], .5f)) // normal for w top
+    {
+        return {0.f, 0.f, 0.f, 1.f};
     }
 
-    // gradient in object space for cone top is 2x, r^2 - .5*y, 2z
-    return glm::vec3{
-            2.f * intersectPointObject.x,
-            .25f - .5f * intersectPointObject.y,
-            2.f * intersectPointObject.z
+    // gradient in object space for cone top is 2x, r^2 - .5*y, 2z, r^2 - .5*w
+    return glm::vec4{
+        2.f * intersectPointObject.x,
+        .25f - .5f * intersectPointObject.y,
+        2.f * intersectPointObject.z,
+        .25f - .5f * intersectPointObject[3]
     };
 }
 
-glm::vec3  getCylinderNormal(
-        glm::vec4 intersectPointObject)
+glm::vec4  getCylinderNormal(
+    glm::vec4 intersectPointObject)
 {
-    if (RayTracer::floatEquals(intersectPointObject.y, -.5f)) // normal for base
+    if (RayTracer::floatEquals(intersectPointObject.y + intersectPointObject[3], -.5f)) // normal for base
     {
-        return {0.f, -1.f, 0.f};
+        return {0.f, -1.f, 0.f, -1.f};
     }
-    if (RayTracer::floatEquals(intersectPointObject.y, .5f)) // normal for top
+    if (RayTracer::floatEquals(intersectPointObject.y + intersectPointObject[3], .5f)) // normal for top
     {
-        return {0.f, 1.f, 0.f};
+        return {0.f, 1.f, 0.f, 1.f};
     }
 
     // gradient in object space for cylinder top is 2x, 0, 2z
-    return glm::vec3{
-            2.f * intersectPointObject.x,
-            0.f,
-            2.f * intersectPointObject.z
+    return glm::vec4{
+        2.f * intersectPointObject.x,
+        0.f,
+        2.f * intersectPointObject.z,
+        0.f
     };
 }
 
-glm::vec3 getCubeNormal(
-        glm::vec4 intersectPointObject)
+glm::vec4 getCubeNormal(
+    glm::vec4 intersectPointObject)
 {
     if (RayTracer::floatEquals(intersectPointObject.y, -.5f)) // neg y
     {
-        return {0.f, -1.f, 0.f};
+        return {0.f, -1.f, 0.f, 0.f};
     }
     if (RayTracer::floatEquals(intersectPointObject.y, .5f)) // pos y
     {
-        return {0.f, 1.f, 0.f};
+        return {0.f, 1.f, 0.f, 0.f};
     }
     if (RayTracer::floatEquals(intersectPointObject.x, -.5f)) // neg x
     {
-        return {-1.f, 0.f, 0.f};
+        return {-1.f, 0.f, 0.f, 0.f};
     }
     if (RayTracer::floatEquals(intersectPointObject.x, .5f)) // pos x
     {
-        return {1.f, 0.f, 0.f};
+        return {1.f, 0.f, 0.f, 0.f};
     }
     if (RayTracer::floatEquals(intersectPointObject.z, -.5f)) // neg z
     {
-        return {0.f, 0.f, -1.f};
+        return {0.f, 0.f, -1.f, 0.f};
     }
     if (RayTracer::floatEquals(intersectPointObject.z, .5f)) // pos z
     {
-        return {0.f, 0.f, 1.f};
+        return {0.f, 0.f, 1.f, 0.f};
     }
-    return glm::vec3(0.f);
+    if (RayTracer::floatEquals(intersectPointObject[3], -.5f)) // neg w
+    {
+        return {0.f, 0.f, 0.f, -1.f};
+    }
+    if (RayTracer::floatEquals(intersectPointObject[3], .5f)) // pos w
+    {
+        return {0.f, 0.f, 0.f, 1.f};
+    }
+    return glm::vec4(0.f);
 }
 
 glm::vec4 getSphereNormal(
-        glm::vec4 intersectPointObject)
+    glm::vec4 intersectPointObject)
 {
     return {2.f * intersectPointObject.x,
             2.f * intersectPointObject.y,
-            2.f * intersectPointObject.z, 
+            2.f * intersectPointObject.z,
             2.f * intersectPointObject.w};
 }
 
-glm::vec3 RayTracer::getNormal(
-        glm::vec4 intersectPointObject,
-        const RenderShapeData& shape,
-        const RayTraceScene &scene)
+glm::vec4 RayTracer::getNormal(
+    glm::vec4 intersectPointObject,
+    const RenderShapeData& shape,
+    const RayTraceScene &scene)
 {
     switch(shape.primitive.type)
     {
-        case PrimitiveType::PRIMITIVE_SPHERE:
-            // gradient in object space for sphere is 2x, 2y, 2z
-            // return 2.f * intersectPointObject;
-            return getSphereNormal(intersectPointObject);
-        case PrimitiveType::PRIMITIVE_CONE:
-            return getConeNormal(intersectPointObject);
-        case PrimitiveType::PRIMITIVE_CYLINDER:
-            return getCylinderNormal(intersectPointObject);
-        case PrimitiveType::PRIMITIVE_CUBE:
-            return getCubeNormal(intersectPointObject);
-        case PrimitiveType::PRIMITIVE_MESH:
-            break;
+    case PrimitiveType::PRIMITIVE_SPHERE:
+        // gradient in object space for sphere is 2x, 2y, 2z
+        // return 2.f * intersectPointObject;
+        return getSphereNormal(intersectPointObject);
+    case PrimitiveType::PRIMITIVE_CONE:
+        return getConeNormal(intersectPointObject);
+    case PrimitiveType::PRIMITIVE_CYLINDER:
+        return getCylinderNormal(intersectPointObject);
+    case PrimitiveType::PRIMITIVE_CUBE:
+        return getCubeNormal(intersectPointObject);
+    case PrimitiveType::PRIMITIVE_MESH:
+        break;
     }
-    return glm::vec3(0.f);
-}
\ No newline at end of file
+    return glm::vec4(0.f);
+}
diff --git a/src/raytracer/raytracer.cpp b/src/raytracer/raytracer.cpp
index acb229a..b393d40 100644
--- a/src/raytracer/raytracer.cpp
+++ b/src/raytracer/raytracer.cpp
@@ -127,12 +127,9 @@ glm::vec4 RayTracer::getPixelFromRay(
         }
     }
 
-    glm::vec3 normalObject = getNormal(closestIntersectionObj, intersectedShape, scene);
-    glm::vec3 normalWorld =
-            (
-                    glm::inverse(glm::transpose(intersectedShape.ctm))
-                    * glm::vec4(normalObject, 0.f)
-            ).xyz();
+    glm::vec4 normalObject = glm::normalize(getNormal(closestIntersectionObj, intersectedShape, scene));
+    // update
+    glm::vec4 normalWorld = glm::inverse(glm::transpose(intersectedShape.ctm)) * glm::vec4(normalObject);
 
     return illuminatePixel(closestIntersectionWorld, normalWorld, -dWorld, intersectedShape, scene, depth);
 }
diff --git a/src/raytracer/raytracer.h b/src/raytracer/raytracer.h
index 9bbeb5c..f8b3721 100644
--- a/src/raytracer/raytracer.h
+++ b/src/raytracer/raytracer.h
@@ -59,7 +59,7 @@ public:
         const RenderShapeData &shape,
         glm::vec4 illuminationToInterpolate);
 
-    glm::vec3 getNormal(
+    glm::vec4 getNormal(
             glm::vec4 intersectPointObject,
             const RenderShapeData &shape,
             const RayTraceScene &scene);
@@ -97,9 +97,9 @@ public:
             const RayTraceScene &scene,
             int depth);
     glm::vec4 illuminatePixel(
-            glm::vec3 intersectionWorld,
-            glm::vec3 normalWorld,
-            glm::vec3 directionToCamera,
+            glm::vec4 intersectionWorld,
+            glm::vec4 normalWorld,
+            glm::vec4 directionToCamera,
             const RenderShapeData &shape,
             const RayTraceScene &scene,
             int depth);
@@ -107,26 +107,26 @@ public:
 
     // shading, and helpers for each type of light
     glm::vec4
-    phong(glm::vec4 lightColor, float attenuation, glm::vec3 directionFromIntersectionToLight,
-          glm::vec3 directionToCamera,
-          glm::vec3 intersectionWorld, glm::vec3 normalWorld, const RenderShapeData &shape, const RayTraceScene &scene);
+    phong(glm::vec4 lightColor, float attenuation, glm::vec4 directionFromIntersectionToLight,
+          glm::vec4 directionToCamera,
+          glm::vec4 intersectionWorld, glm::vec4 normalWorld, const RenderShapeData &shape, const RayTraceScene &scene);
 
     glm::vec4
-    illuminationFromPointLight(const SceneLightData &light, glm::vec3 intersectionWorld, glm::vec3 normalWorld,
-                               glm::vec3 directionToCamera, const RenderShapeData &shape,
+    illuminationFromPointLight(const SceneLightData &light, glm::vec4 intersectionWorld, glm::vec4 normalWorld,
+                               glm::vec4 directionToCamera, const RenderShapeData &shape,
                                const RayTraceScene &scene);
 
-    glm::vec4 illuminationFromSpotLight(const SceneLightData &light, glm::vec3 intersectionWorld, glm::vec3 normalWorld,
-                                        glm::vec3 directionToCamera, const RenderShapeData &shape,
+    glm::vec4 illuminationFromSpotLight(const SceneLightData &light, glm::vec4 intersectionWorld, glm::vec4 normalWorld,
+                                        glm::vec4 directionToCamera, const RenderShapeData &shape,
                                         const RayTraceScene &scene);
 
     glm::vec4
-    illuminationFromDirectionalLight(const SceneLightData &light, glm::vec3 intersectionWorld, glm::vec3 normalWorld,
-                                     glm::vec3 directionToCamera, const RenderShapeData &shape,
+    illuminationFromDirectionalLight(const SceneLightData &light, glm::vec4 intersectionWorld, glm::vec4 normalWorld,
+                                     glm::vec4 directionToCamera, const RenderShapeData &shape,
                                      const RayTraceScene &scene);
 
-    glm::vec4 illuminationFromAreaLight(const SceneLightData &light, glm::vec3 intersectionWorld, glm::vec3 normalWorld,
-                                        glm::vec3 directionToCamera, const RenderShapeData &shape,
+    glm::vec4 illuminationFromAreaLight(const SceneLightData &light, glm::vec4 intersectionWorld, glm::vec4 normalWorld,
+                                        glm::vec4 directionToCamera, const RenderShapeData &shape,
                                         const RayTraceScene &scene);