summaryrefslogtreecommitdiff
path: root/hw6/src/triangle.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'hw6/src/triangle.cpp')
-rw-r--r--hw6/src/triangle.cpp465
1 files changed, 465 insertions, 0 deletions
diff --git a/hw6/src/triangle.cpp b/hw6/src/triangle.cpp
new file mode 100644
index 0000000..940363e
--- /dev/null
+++ b/hw6/src/triangle.cpp
@@ -0,0 +1,465 @@
+/******************************************************************/
+/* This file is part of the homework assignments for CSCI-427/527 */
+/* at The College of William & Mary and authored by Pieter Peers. */
+/* No part of this file, whether altered or in original form, can */
+/* be distributed or used outside the context of CSCI-427/527 */
+/* without consent of either the College of William & Mary or */
+/* Pieter Peers. */
+/******************************************************************/
+
+#include <cassert>
+#include <algorithm>
+
+#include "triangle.h"
+#include "constants.h"
+
+//////////////////
+// Constructors //
+//////////////////
+triangle::triangle(void)
+{
+ _vertex_list = nullptr;
+ _normal_list = nullptr;
+ _textureCoord_list = nullptr;
+}
+
+
+//////////////////////
+// Copy Constructor //
+//////////////////////
+triangle::triangle(const triangle& t)
+ : triangle()
+{
+ // share ptr to list
+ _vertex_list = t._vertex_list;
+ _normal_list = t._normal_list;
+ _textureCoord_list = t._textureCoord_list;
+
+ // copy indices
+ _vertex_idx = t._vertex_idx;
+ _normal_idx = t._normal_idx;
+ _textureCoord_idx = t._textureCoord_idx;
+}
+
+
+//////////////////////
+// Move Constructor //
+//////////////////////
+triangle::triangle(triangle&& t)
+ : triangle()
+{
+ // swap list (no need to increment ref-count)
+ std::swap(_vertex_list, t._vertex_list);
+ std::swap(_normal_list, t._normal_list);
+ std::swap(_textureCoord_list, t._textureCoord_list);
+
+ // copy indices
+ _vertex_idx = t._vertex_idx;
+ _normal_idx = t._normal_idx;
+ _textureCoord_idx = t._textureCoord_idx;
+}
+
+
+//////////////////////////
+// General Constructors //
+//////////////////////////
+triangle::triangle(const vec3d& v1, const vec3d& v2, const vec3d& v3)
+ : triangle()
+{
+ // create a list of three vertices
+ auto vertex_list = std::make_shared<std::vector<vec3d>>(3);
+ _vertex_list = vertex_list;
+
+ // copy values
+ (*vertex_list)[0] = v1;
+ (*vertex_list)[1] = v2;
+ (*vertex_list)[2] = v3;
+
+ // set indices
+ _vertex_idx = {0,1,2};
+}
+
+
+triangle::triangle(size_t v1_idx, size_t v2_idx, size_t v3_idx, const std::shared_ptr<const std::vector<vec3d>>& vertex_list)
+ : triangle()
+{
+ // share vertex list
+ _vertex_list = vertex_list;
+
+ // copy indices
+ _vertex_idx[0] = v1_idx;
+ _vertex_idx[1] = v2_idx;
+ _vertex_idx[2] = v3_idx;
+}
+
+
+
+triangle::triangle(const vec3d& v1, const vec3d& v2, const vec3d& v3,
+ const vec3d& n1, const vec3d& n2, const vec3d& n3)
+ : triangle(v1, v2, v3)
+{
+ // create a list of three normals
+ auto normal_list = std::make_shared<std::vector<vec3d>>(3);
+ _normal_list = normal_list;
+
+ // copy values
+ (*normal_list)[0] = n1;
+ (*normal_list)[1] = n2;
+ (*normal_list)[2] = n3;
+
+ // set indices
+ _normal_idx = {0,1,2};
+}
+
+
+triangle::triangle(size_t v1_idx, size_t v2_idx, size_t v3_idx, const std::shared_ptr<const std::vector<vec3d>>& vertex_list,
+ size_t n1_idx, size_t n2_idx, size_t n3_idx, const std::shared_ptr<const std::vector<vec3d>>& normal_list)
+ : triangle(v1_idx, v2_idx, v3_idx, vertex_list)
+{
+ // share normal list
+ _normal_list = normal_list;
+
+ // copy indices
+ _normal_idx[0] = n1_idx;
+ _normal_idx[1] = n2_idx;
+ _normal_idx[2] = n3_idx;
+}
+
+
+
+triangle::triangle(const vec3d& v1, const vec3d& v2, const vec3d& v3,
+ const vec2d& t1, const vec2d& t2, const vec2d& t3)
+ : triangle(v1, v2, v3)
+{
+ // create a list of three texture coordinates
+ auto textureCoord_list = std::make_shared<std::vector<vec2d>>(3);
+ _textureCoord_list = textureCoord_list;
+
+ // copy values
+ (*textureCoord_list)[0] = t1;
+ (*textureCoord_list)[1] = t2;
+ (*textureCoord_list)[2] = t3;
+
+ // set indices
+ _textureCoord_idx = {0,1,2};
+}
+
+
+triangle::triangle(size_t v1_idx, size_t v2_idx, size_t v3_idx, const std::shared_ptr<const std::vector<vec3d>>& vertex_list,
+ size_t t1_idx, size_t t2_idx, size_t t3_idx, const std::shared_ptr<const std::vector<vec2d>>& texcoord_list)
+ : triangle(v1_idx, v2_idx, v3_idx, vertex_list)
+{
+ // share normal list
+ _textureCoord_list = texcoord_list;
+
+ // copy indices
+ _textureCoord_idx[0] = t1_idx;
+ _textureCoord_idx[1] = t2_idx;
+ _textureCoord_idx[2] = t3_idx;
+}
+
+
+
+triangle::triangle(const vec3d& v1, const vec3d& v2, const vec3d& v3,
+ const vec3d& n1, const vec3d& n2, const vec3d& n3,
+ const vec2d& t1, const vec2d& t2, const vec2d& t3)
+ : triangle(v1, v2, v3, n1, n2, n3)
+{
+ // create a list of three texture coordinates
+ auto textureCoord_list = std::make_shared<std::vector<vec2d>>(3);
+ _textureCoord_list = textureCoord_list;
+
+ // copy values
+ (*textureCoord_list)[0] = t1;
+ (*textureCoord_list)[1] = t2;
+ (*textureCoord_list)[2] = t3;
+
+ // set indices
+ _textureCoord_idx = {0,1,2};
+}
+
+
+triangle::triangle(size_t v1_idx, size_t v2_idx, size_t v3_idx, const std::shared_ptr<const std::vector<vec3d>>& vertex_list,
+ size_t n1_idx, size_t n2_idx, size_t n3_idx, const std::shared_ptr<const std::vector<vec3d>>& normal_list,
+ size_t t1_idx, size_t t2_idx, size_t t3_idx, const std::shared_ptr<const std::vector<vec2d>>& texcoord_list)
+ : triangle(v1_idx, v2_idx, v3_idx, vertex_list,
+ n1_idx, n2_idx, n3_idx, normal_list)
+{
+ // share normal list
+ _textureCoord_list = texcoord_list;
+
+ // copy indices
+ _textureCoord_idx[0] = t1_idx;
+ _textureCoord_idx[1] = t2_idx;
+ _textureCoord_idx[2] = t3_idx;
+}
+
+
+
+////////////////
+// Inspectors //
+////////////////
+const vec3d& triangle::vertex(size_t index) const
+{
+ // bounds check
+ assert(_vertex_list && index < 3);
+
+ // Done.
+ return (*_vertex_list)[_vertex_idx[index]];
+}
+
+
+const vec3d& triangle::normal(size_t index) const
+{
+ // bounds check
+ assert(_normal_list && index < 3);
+
+ // Done.
+ return (*_normal_list)[_normal_idx[index]];
+}
+
+
+const vec2d& triangle::textureCoordinate(size_t index) const
+{
+ // bounds check
+ assert(_textureCoord_list && index < 3);
+
+ // Done.
+ return (*_textureCoord_list)[_textureCoord_idx[index]];
+}
+
+
+bool triangle::hasPerVertexNormals(void) const
+{
+ return (bool)(_normal_list);
+}
+
+
+bool triangle::hasPerVertexTextureCoordinates(void) const
+{
+ return (bool)(_textureCoord_list);
+}
+
+
+///////////////
+// Operators //
+///////////////
+triangle& triangle::operator=(const triangle& t)
+{
+ _assign(t);
+ return *this;
+}
+
+
+triangle& triangle::operator=(triangle&& t)
+{
+ // swap list (no need to increment ref-count)
+ std::swap(_vertex_list, t._vertex_list);
+ std::swap(_normal_list, t._normal_list);
+ std::swap(_textureCoord_list, t._textureCoord_list);
+
+ // copy indices
+ _vertex_idx = t._vertex_idx;
+ _normal_idx = t._normal_idx;
+ _textureCoord_idx = t._textureCoord_idx;
+
+ // Done.
+ return *this;
+}
+
+
+/////////////
+// Methods //
+/////////////
+bool triangle::intersect(const ray& r, vec3d& barycentricCoord, float& t) const
+{
+ // Ray-Triangle intersection [Moller and Trumbore 1997]
+ //
+ // [t ] 1 [ ((r.origin-v0) x (v1-v0)).(v2-v0) ]
+ // [barycenter.y] = -------------------------- [ (r.dir x (v2-v0)).(r.origin-v0) ]
+ // [barycenter.z] ((r.dir x (v2-vo)).(v1-v0) [ ((r.origin-v0) x (v1-v0)).r.dir ]
+ //
+
+ // compute denominator
+ vec3d e1 = vertex(1) - vertex(0);
+ vec3d e2 = vertex(2) - vertex(0);
+ vec3d p = r.direction().cross(e2);
+ float denom = p.dot(e1);
+
+ // check if parallel (denominator == 0)
+ if(fabs(denom) < EPSILON) return false;
+ denom = 1.0f / denom;
+
+ // compute barycentricCoord.y
+ vec3d diff = r.origin() - vertex(0);
+ barycentricCoord.y = denom * p.dot(diff);
+
+ // check if barycenter.y inside triangle
+ if(barycentricCoord.y < -EPSILON || barycentricCoord.y > 1.0f+EPSILON) return false;
+
+ // compute barycentricCoord.z
+ vec3d diffXe1 = diff.cross(e1);
+ barycentricCoord.z = denom * diffXe1.dot(r.direction());
+
+ // check if barycenter.z inside triangle
+ if(barycentricCoord.z < -EPSILON || barycentricCoord.z > 1.0f+EPSILON) return false;
+
+ // compute barycenter.x and check if inside
+ barycentricCoord.x = 1.0f - barycentricCoord.y - barycentricCoord.z;
+ if(barycentricCoord.y + barycentricCoord.z > 1.0f+EPSILON) return false;
+
+ // compute t
+ t = denom * diffXe1.dot(e2);
+
+ // check if in front (i.e., t>0)
+ if(t < EPSILON) return false;
+
+ // Clamp (to compensate for roundoff errors)
+ barycentricCoord.clamp(0.0f, 1.0f);
+
+ // Done.
+ return true;
+}
+
+
+boundingBox triangle::boundingbox(void) const
+{
+ boundingBox bb;
+ for(unsigned int i=0; i < 3; i++)
+ bb += vertex(i);
+ return bb;
+}
+
+
+vec3d triangle::vertex(const vec3d& barycentricCoord) const
+{
+ vec3d result(0.0f);
+ for(unsigned int i=0; i < 3; i++)
+ result += vertex(i) * barycentricCoord[i];
+ return result;
+}
+
+
+vec3d triangle::normal(void) const
+{
+ vec3d e1 = vertex(1) - vertex(0);
+ vec3d e2 = vertex(2) - vertex(0);
+ return e1.cross(e2).normalize();
+}
+
+vec3d triangle::shadingAxis(void) const
+{
+ // follow texture coordinates if defined, otherwise, return the first axis.
+ if(!_textureCoord_list) return normalize(vertex(1)-vertex(0));
+
+ // find the vector that follows the U-axis of the texture coordinates
+ // solve:
+ // [ (t1-t0) (t2-t0) ] [ delta_beta delta_gamma ]^T = [1 0]^T
+ // for delta_beta and delta_gamma.
+ vec3d v1 = vertex(1) - vertex(0);
+ vec3d v2 = vertex(2) - vertex(0);
+ vec2d t1 = textureCoordinate(1) - textureCoordinate(0);
+ vec2d t2 = textureCoordinate(2) - textureCoordinate(0);
+
+ // check special cases where U or V is aligned with a vertex
+ if( fabs(t1.v) < EPSILON ) return normalize(t1.u*v1);
+ if( fabs(t2.v) < EPSILON ) return normalize(t2.u*v2);
+
+ // compute delta_beta
+ float inv_delta_beta = t1.u - t1.v*t2.u/t2.v;
+
+ // => degenrate case
+ if(fabs(inv_delta_beta) < EPSILON) return normalize(v1);
+
+ float delta_beta = 1.0f / inv_delta_beta;
+ float delta_gamma = -delta_beta * t1.v / t2.v;
+
+ // compute U
+ return normalize( delta_beta*v1 + delta_gamma*v2 );
+}
+
+
+vec3d triangle::normal(const vec3d& barycentricCoord) const
+{
+ // sanity check
+ if(!hasPerVertexNormals()) return normal();
+
+ // interpolate
+ vec3d result(0.0f);
+ for(unsigned int i=0; i < 3; i++)
+ result += normal(i) * barycentricCoord[i];
+ return result.normalize();
+}
+
+
+vec2d triangle::textureCoordinate(const vec3d& barycentricCoord) const
+{
+ // sanity check
+ if(!hasPerVertexTextureCoordinates()) return vec2d();
+
+ // interpolate
+ vec2d result(0.0f);
+ for(unsigned int i=0; i < 3; i++)
+ result += textureCoordinate(i) * barycentricCoord[i];
+ return result;
+}
+
+
+float triangle::area(void) const
+{
+ vec3d e1 = vertex(1) - vertex(0);
+ vec3d e2 = vertex(2) - vertex(0);
+ return 0.5f * e1.cross(e2).length();
+}
+
+
+vec3d triangle::sample(float r1, float r2, vec3d& barycentricCoord, float& pdf) const
+{
+ r2 = sqrt(r2);
+
+ // compute barycentric coordinate
+ barycentricCoord.x = r1*r2;
+ barycentricCoord.y = (1.0f - r2);
+ barycentricCoord.z = 1.0f - barycentricCoord.x - barycentricCoord.y;
+
+ // compute pdf
+ pdf = 1.0f / area();
+
+ // Done.
+ return vertex(barycentricCoord);
+}
+
+
+/////////////////////
+// Private Methods //
+/////////////////////
+void triangle::_assign(const triangle& t)
+{
+ // avoid self-assign
+ if(&t == this) return;
+
+ // share ptr to list
+ _vertex_list = t._vertex_list;
+ _normal_list = t._normal_list;
+ _textureCoord_list = t._textureCoord_list;
+
+ // copy indices
+ _vertex_idx = t._vertex_idx;
+ _normal_idx = t._normal_idx;
+ _textureCoord_idx = t._textureCoord_idx;
+}
+
+
+void triangle::_swap(triangle& t)
+{
+ // copy list ptr
+ std::swap(_vertex_list, t._vertex_list);
+ std::swap(_normal_list, t._normal_list);
+ std::swap(_textureCoord_list, t._textureCoord_list);
+
+ // copy indices
+ std::swap(_vertex_idx, t._vertex_idx);
+ std::swap(_normal_idx, t._normal_idx);
+ std::swap(_textureCoord_idx, t._textureCoord_idx);
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-14 17:17:25 +0000