aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/illuminate/illuminate.cpp81
-rw-r--r--src/intersect/intersect.cpp6
-rw-r--r--src/intersect/normals.cpp118
-rw-r--r--src/raytracer/raytracer.cpp9
-rw-r--r--src/raytracer/raytracer.h30
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);
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-10-06 12:35:06 +0000