From 9fd9c5774e7d36c70bf1efbcf22606b7b497c758 Mon Sep 17 00:00:00 2001
From: Josh Holtrop <jholtrop+git@gmail.com>
Date: Tue, 28 Sep 2010 17:53:31 +0000
Subject: [PATCH] removed a few emtpy Vector x; statements

git-svn-id: svn://anubis/fart/trunk@309 7f9b0f55-74a9-4bce-be96-3c2cd072584d
---
 util/Ray.h    |  9 +++----
 util/Vector.h | 72 +++++++++++++++++++++++----------------------------
 2 files changed, 36 insertions(+), 45 deletions(-)

diff --git a/util/Ray.h b/util/Ray.h
index b0a175d..a38dd60 100644
--- a/util/Ray.h
+++ b/util/Ray.h
@@ -24,11 +24,10 @@ class Ray
          */
         Vector getPositionAt(double dist) const
         {
-            Vector v;
-            v[0] = m_origin[0] + dist * m_direction[0];
-            v[1] = m_origin[1] + dist * m_direction[1];
-            v[2] = m_origin[2] + dist * m_direction[2];
-            return v;
+            return Vector(
+                    m_origin[0] + dist * m_direction[0],
+                    m_origin[1] + dist * m_direction[1],
+                    m_origin[2] + dist * m_direction[2]);
         }
 
         Ray shift(double amt)
diff --git a/util/Vector.h b/util/Vector.h
index 35920b3..7fac54c 100644
--- a/util/Vector.h
+++ b/util/Vector.h
@@ -79,29 +79,26 @@ class Vector
 
         Vector mult(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] * v2.m_array[0];
-            result[1] = m_array[1] * v2.m_array[1];
-            result[2] = m_array[2] * v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] * v2.m_array[0],
+                    m_array[1] * v2.m_array[1],
+                    m_array[2] * v2.m_array[2]);
         }
 
         Vector div(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] / v2.m_array[0];
-            result[1] = m_array[1] / v2.m_array[1];
-            result[2] = m_array[2] / v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] / v2.m_array[0],
+                    m_array[1] / v2.m_array[1],
+                    m_array[2] / v2.m_array[2]);
         }
 
         Vector operator-() const
         {
-            Vector result;
-            result[0] = -m_array[0];
-            result[1] = -m_array[1];
-            result[2] = -m_array[2];
-            return result;
+            return Vector(
+                    -m_array[0],
+                    -m_array[1],
+                    -m_array[2]);
         }
 
         /* Compute the dot-product of two vectors */
@@ -115,47 +112,42 @@ class Vector
         /* Compute the cross-product of two vectors */
         Vector operator*(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[1] * v2.m_array[2] - m_array[2] * v2.m_array[1];
-            result[1] = m_array[2] * v2.m_array[0] - m_array[0] * v2.m_array[2];
-            result[2] = m_array[0] * v2.m_array[1] - m_array[1] * v2.m_array[0];
-            return result;
+            return Vector(
+                    m_array[1] * v2.m_array[2] - m_array[2] * v2.m_array[1],
+                    m_array[2] * v2.m_array[0] - m_array[0] * v2.m_array[2],
+                    m_array[0] * v2.m_array[1] - m_array[1] * v2.m_array[0]);
         }
 
         Vector operator+(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] + v2.m_array[0];
-            result[1] = m_array[1] + v2.m_array[1];
-            result[2] = m_array[2] + v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] + v2.m_array[0],
+                    m_array[1] + v2.m_array[1],
+                    m_array[2] + v2.m_array[2]);
         }
 
         Vector operator-(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] - v2.m_array[0];
-            result[1] = m_array[1] - v2.m_array[1];
-            result[2] = m_array[2] - v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] - v2.m_array[0],
+                    m_array[1] - v2.m_array[1],
+                    m_array[2] - v2.m_array[2]);
         }
 
         Vector operator*(double scale) const
         {
-            Vector result;
-            result[0] = m_array[0] * scale;
-            result[1] = m_array[1] * scale;
-            result[2] = m_array[2] * scale;
-            return result;
+            return Vector(
+                    m_array[0] * scale,
+                    m_array[1] * scale,
+                    m_array[2] * scale);
         }
 
         Vector operator/(double scale) const
         {
-            Vector result;
-            result[0] = m_array[0] / scale;
-            result[1] = m_array[0] / scale;
-            result[2] = m_array[0] / scale;
-            return result;
+            return Vector(
+                    m_array[0] / scale,
+                    m_array[0] / scale,
+                    m_array[0] / scale);
         }
 
         Vector & operator+=(const Vector & v2)