More correct vec3 calculations

Correct and faster operators.

Author: allywarner

Tests/Vec3Tests.cpp

@@ -117,7 +117,7 @@ TEST_F(Vec3Test, GreaterThanEq)
 TEST_F(Vec3Test, GreaterThan)
 {
   ASSERT_TRUE( sample3Vec > sample1Vec );
-  ASSERT_FALSE( sample2Vec > sample1Vec );
+  ASSERT_TRUE( sample2Vec > sample1Vec );
 }
 
 TEST_F(Vec3Test, LessThanEq)
@@ -128,6 +128,5 @@ TEST_F(Vec3Test, LessThanEq)
 TEST_F(Vec3Test, LessThan)
 {
   ASSERT_TRUE( sample1Vec < sample3Vec );
-  ASSERT_FALSE( sample1Vec < sample2Vec );
+  ASSERT_TRUE( sample1Vec < sample2Vec );
 }
-

vec3.cpp

@@ -42,133 +42,123 @@ vec3 vec3::unitY(0,1,0);
 vec3 vec3::unitZ(0,0,1);
 const double vec3::PI = 3.14159265;
 
-vec3::vec3() : x_(0), y_(0), z_(0)
+vec3::vec3() : data_{0,0,0}
 {
 }
 
-// default constructor
-vec3::vec3(double x, double  y, double z) : x_(x), y_(y), z_(z)
-{
-}
-
-// copy constructor
-vec3::vec3(const vec3 &x) : x_(x.x_), y_(x.y_), z_(x.z_)
+vec3::vec3(double x, double  y, double z) : data_{x,y,z}
 {
 }
 
 bool vec3::operator!=(const vec3 &a) const
 {
-  if(this->x_ != a.x_ ||
-     this->y_ != a.y_ ||
-     this->z_ != a.z_)
+  if(this->x() != a.x() ||
+     this->y() != a.y() ||
+     this->z() != a.z())
     return true;
   else
     return false;
 }
 
 bool vec3::operator==(const vec3 &a) const
 {
-  return(this->x_ == a.x_ &&
-         this->y_ == a.y_ &&
-         this->z_ == a.z_);
+  return(this->x() == a.x() &&
+         this->y() == a.y() &&
+         this->z() == a.z());
 }
 
 bool vec3::operator<=(const vec3 &a) const
 {
-  return ((this->x_ <= a.x_) &&
-          (this->y_ <= a.y_) &&
-          (this->z_ <= a.z_));
+  return *this < a || *this == a;
 }
 
 bool vec3::operator>=(const vec3 &a) const
 {
-  return ((this->x_ >= a.x_) &&
-          (this->y_ >= a.y_) &&
-          (this->z_ >= a.z_));
+  return *this > a || *this == a;
 }
 
 bool vec3::operator<(const vec3 &a) const
 {
-  return ((this->x_ < a.x_) &&
-          (this->y_ < a.y_) &&
-          (this->z_ < a.z_));
+  if (x() < a.x())
+    return true;
+  if (x() > a.x())
+    return false;
+
+  // equal x
+  if (y() < a.y())
+    return true;
+  if (y() > a.y())
+    return false;
+
+  // equal x and y
+  if (z() < a.z())
+    return true;
+  if (z() > a.z())
+    return false;
+
+  return false;
 }
 
 bool vec3::operator>(const vec3 &a) const
 {
-  return ((this->x_ > a.x_) &&
-          (this->y_ > a.y_) &&
-          (this->z_ > a.z_));
+  return a < *this;
 }
 
-
 vec3& vec3::operator=(const vec3 &a)
 {
-  this->x_ = a.x_;
-  this->y_ = a.y_;
-  this->z_ = a.z_;
+  this->x() = a.x();
+  this->y() = a.y();
+  this->z() = a.z();
 
   return *this;
 }
 
 vec3& vec3::operator+=(const vec3 &a)
 {
-  this->x_ += a.x_;
-  this->y_ += a.y_;
-  this->z_ += a.z_;
+  this->x() += a.x();
+  this->y() += a.y();
+  this->z() += a.z();
 
   return *this;
 }
 
 vec3& vec3::operator*=(double c)
 {
-  this->x_ *= c;
-  this->y_ *= c;
-  this->z_ *= c;
+  this->x() *= c;
+  this->y() *= c;
+  this->z() *= c;
 
   return *this;
 }
 
 vec3& vec3::operator/=(double c)
 {
   // TODO: throw exception if c == 0
-  this->x_ /= c;
-  this->y_ /= c;
-  this->z_ /= c;
+  this->x() /= c;
+  this->y() /= c;
+  this->z() /= c;
   return *this;
 }
 
 double& vec3::operator[](const size_t idx)
 {
-  switch(idx)
-  {
-    case 0: return this->x_;
-    case 1: return this->y_;
-    case 2: return this->z_;
-    default: throw -1;  // bad index
-  }
+  return data_[idx];
 }
 
 // TODO: Restructure this class so this lookup is FASTER
 double vec3::operator[](const size_t idx) const
 {
-  switch(idx)
-  {
-    case 0: return this->x_;
-    case 1: return this->y_;
-    case 2: return this->z_;
-    default: throw -1;  // bad index
-  }
+  return data_[idx];
 }
 
 double vec3::dot(const vec3 &b) const
 {
-  return this->x_*b.x_ + this->y_*b.y_ + this->z_*b.z_;
+  return this->x()*b.x() + this->y()*b.y() + this->z()*b.z();
 }
 
 vec3 vec3::cross(const vec3 &b)
 {
-  return vec3(this->y_*b.z_ - this->z_*b.y_, this->z_*b.x_ - this->x_*b.z_, this->x_*b.y_ - this->y_*b.x_);
+  return vec3(this->y()*b.z() - this->z()*b.y(), this->z()*b.x() - this->x()*b.z(), this->x()*b.y() - this->y()*b.x());
 }
 
 vec3 cross(const vec3 &a, const vec3 &b)
@@ -186,6 +176,11 @@ double length(const vec3 &a)
   return sqrt(a.x()*a.x() + a.y()*a.y() + a.z()*a.z());
 }
 
+double lengthSquared(const vec3 &a)
+{
+  return a.x()*a.x() + a.y()*a.y() + a.z()*a.z();
+}
+
 double distance(const vec3 &a, const vec3 &b)
 {
   double xdiff = a.x()-b.x(), ydiff = a.y()-b.y(), zdiff = a.z()-b.z();
@@ -281,22 +276,22 @@ double clamp(double value, double min, double max)
 std::string vec3::toString() const
 {
   std::stringstream ss;
-  ss << "[" << std::setprecision(5) << this->x() << ", " << this->y_ << ", " << this->z_ << "]";
+  ss << "[" << std::setprecision(5) << this->x() << ", " << this->y() << ", " << this->z() << "]";
   return ss.str();
 }
 
 vec3 vec3::min(const vec3 &a, const vec3 &b)
 {
-  return vec3((a.x_ < b.x_) ? a.x_ : b.x_,
-              (a.y_ < b.y_) ? a.y_ : b.y_,
-              (a.z_ < b.z_) ? a.z_ : b.z_);
+  return vec3((a.x() < b.x()) ? a.x() : b.x(),
+              (a.y() < b.y()) ? a.y() : b.y(),
+              (a.z() < b.z()) ? a.z() : b.z());
 }
 
 vec3 vec3::max(const vec3 &a, const vec3 &b)
 {
-  return vec3((a.x_ > b.x_) ? a.x_ : b.x_,
-              (a.y_ > b.y_) ? a.y_ : b.y_,
-              (a.z_ > b.z_) ? a.z_ : b.z_);
+  return vec3((a.x() > b.x()) ? a.x() : b.x(),
+              (a.y() > b.y()) ? a.y() : b.y(),
+              (a.z() > b.z()) ? a.z() : b.z());
 }
 
 double angleBetween(const vec3 &a, const vec3 &b)
@@ -308,4 +303,3 @@ double angleBetween(const vec3 &a, const vec3 &b, float epsilon)
 {
   return acos( dot(a,b) / ( ( L2(a)*L2(b) ) + epsilon ) );
 }
-

vec3.h

@@ -46,12 +46,9 @@ class vec3
 public:
   vec3();
   vec3(double x, double y, double z);
-  vec3(const vec3 &x);
 
 private:
-  double x_;
-  double y_;
-  double z_;
+  double data_[3];
 
 public:
   bool operator!=(const vec3 &a) const;
@@ -71,14 +68,17 @@ class vec3
   double dot(const vec3 &b) const;
   vec3 cross(const vec3 &b);
 
-  const double x() const { return this->x_; }
-  void x( double b ) { this->x_ = b; }
+  const double x() const { return data_[0]; }
+  double& x() { return data_[0]; }
+  void x( double b ) { data_[0] = b; }
 
-  const double y() const { return this->y_; }
-  void y( double b ) { this->y_ = b; }
+  const double y() const { return data_[1]; }
+  double& y() { return data_[1]; }
+  void y( double b ) { data_[1] = b; }
 
-  const double z() const { return this->z_; }
-  void z( double b ) { this->z_ = b; }
+  const double z() const { return data_[2]; }
+  double& z() { return data_[2]; }
+  void z( double b ) { data_[2] = b; }
 
   static vec3 zero;
   static vec3 unitX;
@@ -96,6 +96,7 @@ vec3 cross(const vec3 &a, const vec3 &b);
 vec3 bisect(const vec3 &a, const vec3 &b);
 double dot(const vec3 &a, const vec3 &b);
 double length(const vec3 &a);
+double lengthSquared(const vec3 &a);
 double distance(const vec3 &a, const vec3 &b);
 double L1(const vec3 &a);
 double L2(const vec3 &a);