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

@@ -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

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

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]
+                           2 * ( ray_inv.getOrigin()[0] * ray_inv.getDirection()[0]
-                               + ray.getOrigin()[1] * ray.getDirection()[1]
+                               + ray_inv.getOrigin()[1] * ray_inv.getDirection()[1]
-                               + ray.getOrigin()[2] * ray.getDirection()[2] ),
+                               + ray_inv.getOrigin()[2] * ray_inv.getDirection()[2] ),
-                             ray.getOrigin()[0] * ray.getOrigin()[0]
+                             ray_inv.getOrigin()[0] * ray_inv.getOrigin()[0]
-                           + ray.getOrigin()[1] * ray.getOrigin()[1]
+                           + ray_inv.getOrigin()[1] * ray_inv.getOrigin()[1]
-                           + ray.getOrigin()[2] * ray.getOrigin()[2]
+                           + 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();
 }

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;
+}

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