From 7d7ec130e0c40b77ab27fc6f556c526f644067d4 Mon Sep 17 00:00:00 2001
From: Josh Holtrop <jholtrop+git@gmail.com>
Date: Mon, 26 Jan 2009 14:02:15 +0000
Subject: [PATCH] added operators +, - to Vector, added inverse transform
 instance variable to shapes/Shape, changed Sphere to use its inverse
 transform when calculating intersections and normals, removed simplistic
 lighting from main/Scene

git-svn-id: svn://anubis/fart/trunk@47 7f9b0f55-74a9-4bce-be96-3c2cd072584d
---
 main/Scene.cc    | 17 +----------------
 shapes/Shape.h   | 10 ++++++++--
 shapes/Sphere.cc | 18 +++++++++++-------
 util/Vector.cc   | 18 ++++++++++++++++++
 util/Vector.h    |  2 ++
 5 files changed, 40 insertions(+), 25 deletions(-)

diff --git a/main/Scene.cc b/main/Scene.cc
index d92c43b..8e17bca 100644
--- a/main/Scene.cc
+++ b/main/Scene.cc
@@ -151,26 +151,11 @@ Vector Scene::traceRay(const Ray & ray)
          it != m_shapes.end();
          it++)
     {
-        /* transform the ray by the inverse of the shape's transform */
-        Transform inv = (*it)->getTransform().getInverse();
-        Ray local_ray = inv.transform_ray(ray);
-
         /* then intersect this inversely transformed ray with the shape */
-        Solver::Result intersections = (*it)->intersect(local_ray);
+        Solver::Result intersections = (*it)->intersect(ray);
 
         if (intersections.numResults > 0)
         {
-            Vector local_normal =
-                (*it)->getNormalAt(local_ray[intersections.results[0]]);
-            double dot = local_ray.getDirection() % local_normal;
-            dot = -dot;
-            if (dot < 0.0)
-                dot = 0.0;
-#if 0
-            color[0] = dot;
-            color[1] = dot;
-            color[2] = dot;
-#endif
             color[0] = color[1] = color[2] = 1.0;
         }
         else
diff --git a/shapes/Shape.h b/shapes/Shape.h
index 748703e..566cb8c 100644
--- a/shapes/Shape.h
+++ b/shapes/Shape.h
@@ -11,12 +11,18 @@ class Shape
 {
     public:
         virtual Solver::Result intersect(const Ray & ray) = 0;
-        void setTransform(const Transform & t) { m_transform = t; }
-        Transform & getTransform() { return m_transform; }
         virtual Vector getNormalAt(const Vector & pt) = 0;
 
+        void setTransform(Transform & t)
+        {
+            m_transform = t;
+            m_inverse = t.getInverse();
+        }
+        Transform & getTransform() { return m_transform; }
+
     protected:
         Transform m_transform;
+        Transform m_inverse;
 };
 
 #endif
diff --git a/shapes/Sphere.cc b/shapes/Sphere.cc
index 810d560..32d60fb 100644
--- a/shapes/Sphere.cc
+++ b/shapes/Sphere.cc
@@ -13,14 +13,16 @@ Sphere::Sphere(double radius)
 
 Solver::Result Sphere::intersect(const Ray & ray)
 {
+    Ray ray_inv = m_inverse.transform_ray(ray);
+
     Solver::Result res;
     QuadraticSolver solver(1.0,
-                           2 * ( ray.getOrigin()[0] * ray.getDirection()[0]
-                               + ray.getOrigin()[1] * ray.getDirection()[1]
-                               + ray.getOrigin()[2] * ray.getDirection()[2] ),
-                             ray.getOrigin()[0] * ray.getOrigin()[0]
-                           + ray.getOrigin()[1] * ray.getOrigin()[1]
-                           + ray.getOrigin()[2] * ray.getOrigin()[2]
+                           2 * ( ray_inv.getOrigin()[0] * ray_inv.getDirection()[0]
+                               + ray_inv.getOrigin()[1] * ray_inv.getDirection()[1]
+                               + ray_inv.getOrigin()[2] * ray_inv.getDirection()[2] ),
+                             ray_inv.getOrigin()[0] * ray_inv.getOrigin()[0]
+                           + ray_inv.getOrigin()[1] * ray_inv.getOrigin()[1]
+                           + ray_inv.getOrigin()[2] * ray_inv.getOrigin()[2]
                            - m_radius2);
     Solver::Result quadSolutions = solver.solve();
     for (int i = 0; i < quadSolutions.numResults; i++)
@@ -35,6 +37,8 @@ Solver::Result Sphere::intersect(const Ray & ray)
 
 Vector Sphere::getNormalAt(const Vector & pt)
 {
-    Vector normal = pt;
+    Vector pt_inv = m_inverse.transform_point(pt);
+
+    Vector normal = pt_inv;
     return normal.normalize();
 }
diff --git a/util/Vector.cc b/util/Vector.cc
index 871881c..6ed1a23 100644
--- a/util/Vector.cc
+++ b/util/Vector.cc
@@ -61,3 +61,21 @@ Vector operator*(const Vector & v1, const Vector & v2)
     result[2] = v1[0] * v2[1] - v1[1] * v2[0];
     return result;
 }
+
+Vector operator+(const Vector & v1, const Vector & v2)
+{
+    Vector result;
+    result[0] = v1[0] + v2[0];
+    result[1] = v1[1] + v2[1];
+    result[2] = v1[2] + v2[2];
+    return result;
+}
+
+Vector operator-(const Vector & v1, const Vector & v2)
+{
+    Vector result;
+    result[0] = v1[0] - v2[0];
+    result[1] = v1[1] - v2[1];
+    result[2] = v1[2] - v2[2];
+    return result;
+}
diff --git a/util/Vector.h b/util/Vector.h
index a7e4c61..3fb7009 100644
--- a/util/Vector.h
+++ b/util/Vector.h
@@ -22,5 +22,7 @@ class Vector
 std::ostream & operator<<(std::ostream & out, const Vector & v);
 double operator%(const Vector & v1, const Vector & v2);
 Vector operator*(const Vector & v1, const Vector & v2);
+Vector operator+(const Vector & v1, const Vector & v2);
+Vector operator-(const Vector & v1, const Vector & v2);
 
 #endif