vector.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma  once

#include "legionDataStore/export.h"
#include "legionDataStore/dataTypes.h"
#include <ostream>

namespace Legion
{
   class Vector2d;

//---------------------------------Vector2 Float --------------------------------------

   class LEGION_DLL Vector2f
   {
   public:
      //constructors
      Vector2f();
      Vector2f(const float x, const float y);
      Vector2f(const float* tuple);
      Vector2f(const Vector2f& other);
      Vector2f(const Vector2d& other);

      //assignment
      Vector2f& operator= (const Vector2f& vec);

      //comparison
      bool operator== (const Vector2f& vec) const;
      bool operator!= (const Vector2f& vec) const;
      bool operator<  (const Vector2f& vec) const;
      bool operator<= (const Vector2f& vec) const;
      bool operator>  (const Vector2f& vec) const;
      bool operator>= (const Vector2f& vec) const;

      //arithmetic operations
      Vector2f operator+ (const Vector2f& vec) const;
      Vector2f operator- (const Vector2f& vec) const;
      Vector2f operator* (float scalar) const;
      Vector2f operator/ (float scalar) const;
      Vector2f operator- () const;

      //arithmetic updates
      Vector2f& operator+= (const Vector2f& vec);
      Vector2f& operator-= (const Vector2f& vec);
      Vector2f& operator*= (float scalar);
      Vector2f& operator/= (float scalar);

      //vector operations
      float length() const;
      float lengthSquared() const;
      float dot(const Vector2f& vec) const;
      float normalize();
      float distanceFrom(const Vector2f& other) const;
      float distanceFromSquared(const Vector2f& other) const;
      void setLength(float newLength);
      void invert();

      bool isZero();

      //perpendicular operations
      // returns (y,-x)
      Vector2f perpendicular() const;
      // returns (y,-x)/sqrt(x*x+y*y)
      Vector2f unitPerp() const;
      // returns DotPerp((x,y),(V.x,V.y)) = x*V.y - y*V.x
      float dotPerp(const Vector2f& vec) const;

      //functions
      void rotateBy(float degrees, const Vector2f& center);

      float angleTrig() const;

      float angle() const;

      float angleBetween(const Vector2f& b) const;


      bool isBetweenPoints(const Vector2f& begin, const Vector2f& end) const;

      static Vector2f interpolate(const Vector2f& v0, const Vector2f& v1, float t);

      union {
         struct {
            float x;
            float y;
         };
         float data[2];
      };
   };

   LEGION_DLL Vector2f operator* (float scalar, const Vector2f& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector2f& vec);

//---------------------------------Vector2 Double --------------------------------------

   class LEGION_DLL  Vector2d
   {
   public:
      //constructors
      Vector2d();
      Vector2d(double x, double y);
      Vector2d(const double* tuple);
      Vector2d(const Vector2d& other);
      Vector2d(const Vector2f& other);

      //assignment
      Vector2d& operator= (const Vector2d& vec);

      //comparison
      bool operator== (const Vector2d& vec) const;
      bool operator!= (const Vector2d& vec) const;
      bool operator<  (const Vector2d& vec) const;
      bool operator<= (const Vector2d& vec) const;
      bool operator>  (const Vector2d& vec) const;
      bool operator>= (const Vector2d& vec) const;

      //arithmetic operations
      Vector2d operator+ (const Vector2d& vec) const;
      Vector2d operator- (const Vector2d& vec) const;
      Vector2d operator* (double scalar) const;
      Vector2d operator/ (double scalar) const;
      Vector2d operator- () const;

      //arithmetic updates
      Vector2d& operator+= (const Vector2d& vec);
      Vector2d& operator-= (const Vector2d& vec);
      Vector2d& operator*= (double scalar);
      Vector2d& operator/= (double scalar);

      //vector operations
      double length() const;
      double lengthSquared() const;
      double dot(const Vector2d& vec) const;
      double normalize();
      double distanceFrom(const Vector2d& other) const;
      double distanceFromSquared(const Vector2d& other) const;
      void setLength(double newLength);
      void invert();

      bool isZero();

      //perpendicular operations
      // returns (y,-x)
      Vector2d perpendicular() const;
      // returns (y,-x)/sqrt(x*x+y*y)
      Vector2d unitPerp() const;
      // returns DotPerp((x,y),(V.x,V.y)) = x*V.y - y*V.x
      double dotPerp(const Vector2d& vec) const;

      //functions
      void rotateBy(double degrees, const Vector2d& center);

      double angleTrig() const;

      double angle() const;

      double angleBetween(const Vector2d& b) const;


      bool isBetweenPoints(const Vector2d& begin, const Vector2d& end) const;

      static Vector2d interpolate(const Vector2d& v0, const Vector2d& v1, double t);
      
      union {
         struct {
            double x;
            double y;
         };
         double data[2];
      };
   };

   LEGION_DLL Vector2d operator* (double scalar, const Vector2d& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector2d& vec);

//---------------------------------Vector3 Float --------------------------------------

   class Vector3d;

   class LEGION_DLL Vector3f
   {
   public:
      //constructors
      Vector3f();
      Vector3f(float x, float y, float z);
      Vector3f(const float* tuple);
      Vector3f(const Vector3f& other);
      Vector3f(const Vector3d& other);

      //assignment
      Vector3f& operator= (const Vector3f& vec);

      //comparison
      bool operator== (const Vector3f& vec) const;
      bool operator!= (const Vector3f& vec) const;
      bool operator<  (const Vector3f& vec) const;
      bool operator<= (const Vector3f& vec) const;
      bool operator>  (const Vector3f& vec) const;
      bool operator>= (const Vector3f& vec) const;

      //arithmetic operations
      Vector3f operator+ (const Vector3f& vec) const;
      Vector3f operator- (const Vector3f& vec) const;
      Vector3f operator* (float scalar) const;
      Vector3f operator/ (float scalar) const;
      Vector3f operator- () const;

      //arithmetic updates
      Vector3f& operator+= (const Vector3f& vec);
      Vector3f& operator-= (const Vector3f& vec);
      Vector3f& operator*= (float scalar);
      Vector3f& operator/= (float scalar);

      //vector operations
      float length() const;
      float lengthSquared() const;
      float dot(const Vector3f& vec) const;
      Vector3f cross(const Vector3f& vec) const;
      Vector3f unitCross(const Vector3f& vec) const;
      float normalize();
      float distanceFrom(const Vector3f& vec) const;
      float distanceFromSquared(const Vector3f& vec) const;

      void setLength(float newLength);
      void invert();

      bool isZero();


      //functions
      float angleBetween(const Vector3f& v) const;


      bool isBetweenPoints(const Vector3f& begin, const Vector3f& end) const;

      static Vector3f interpolate(const Vector3f& v0, const Vector3f& v1, float t);

      union {
         struct {
            float x;
            float y;
            float z;
         };
         float data[3];
      };
   };

   // arithmetic operations
   LEGION_DLL Vector3f operator* (float scalar, const Vector3f& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector3f& vec);


//---------------------------------Vector3 Double --------------------------------------

   class LEGION_DLL Vector3d
   {
   public:
      //constructors
      Vector3d();
      Vector3d(double x, double y, double z);
      Vector3d(const double* tuple);
      Vector3d(const Vector3d& other);
      Vector3d(const Vector3f& other);

      //assignment
      Vector3d& operator= (const Vector3d& vec);

      //comparison
      bool operator== (const Vector3d& vec) const;
      bool operator!= (const Vector3d& vec) const;
      bool operator<  (const Vector3d& vec) const;
      bool operator<= (const Vector3d& vec) const;
      bool operator>  (const Vector3d& vec) const;
      bool operator>= (const Vector3d& vec) const;

      //arithmetic operations
      Vector3d operator+ (const Vector3d& vec) const;
      Vector3d operator- (const Vector3d& vec) const;
      Vector3d operator* (double scalar) const;
      Vector3d operator/ (double scalar) const;
      Vector3d operator- () const;

      //arithmetic updates
      Vector3d& operator+= (const Vector3d& vec);
      Vector3d& operator-= (const Vector3d& vec);
      Vector3d& operator*= (double scalar);
      Vector3d& operator/= (double scalar);

      //vector operations
      double length() const;
      double lengthSquared() const;
      double dot(const Vector3d& vec) const;
      Vector3d cross(const Vector3d& vec) const;
      Vector3d unitCross(const Vector3d& vec) const;
      double normalize();
      double distanceFrom(const Vector3d& vec) const;
      double distanceFromSquared(const Vector3d& vec) const;
      void setLength(double newLength);
      void invert();

      bool isZero();


      //functions
      double angleBetween(const Vector3d& v) const;


      bool isBetweenPoints(const Vector3d& begin, const Vector3d& end) const;

      static Vector3d interpolate(const Vector3d& v0, const Vector3d& v1, double t);

      union {
         struct {
            double x;
            double y;
            double z;
         };
         double data[3];
      };
   };

   // arithmetic operations
   LEGION_DLL Vector3d operator* (double scalar, const Vector3d& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector3d& vec);


   //---------------------------------Vector4 Float --------------------------------------

   class Vector4d;

   class LEGION_DLL Vector4f
   {
   public:
      //constructors
      Vector4f();
      Vector4f(float x, float y, float z, float w);
      Vector4f(const float* tuple);
      Vector4f(const Vector4f& other);
      Vector4f(const Vector4d& other);

      //assignment
      Vector4f& operator= (const Vector4f& vec);

      //comparison
      bool operator== (const Vector4f& vec) const;
      bool operator!= (const Vector4f& vec) const;
      bool operator<  (const Vector4f& vec) const;
      bool operator<= (const Vector4f& vec) const;
      bool operator>  (const Vector4f& vec) const;
      bool operator>= (const Vector4f& vec) const;

      //arithmetic operations
      Vector4f operator+ (const Vector4f& vec) const;
      Vector4f operator- (const Vector4f& vec) const;
      Vector4f operator* (float scalar) const;
      Vector4f operator/ (float scalar) const;
      Vector4f operator- () const;

      //arithmetic updates
      Vector4f& operator+= (const Vector4f& vec);
      Vector4f& operator-= (const Vector4f& vec);
      Vector4f& operator*= (float scalar);
      Vector4f& operator/= (float scalar);

      //vector operations
      float length() const;
      float lengthSquared() const;

      float normalize();
      float distanceFrom(const Vector4f& vec) const;
      float distanceFromSquared(const Vector4f& vec) const;

      void setLength(float newLength);
      void invert();

      bool isZero();



      bool isBetweenPoints(const Vector4f& begin, const Vector4f& end) const;

      static Vector4f interpolate(const Vector4f& v0, const Vector4f& v1, float t);

      union {
         struct {
            float x;
            float y;
            float z;
            float w;
         };
         float data[4];
      };
   };

   // arithmetic operations
   LEGION_DLL Vector4f operator* (float scalar, const Vector4f& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector4f& vec);


   //---------------------------------Vector4 Double --------------------------------------

   class LEGION_DLL Vector4d
   {
   public:
      //constructors
      Vector4d();
      Vector4d(double x, double y, double z, double w);
      Vector4d(const double* tuple);
      Vector4d(const Vector4d& other);
      Vector4d(const Vector4f& other);

      //assignment
      Vector4d& operator= (const Vector4d& vec);

      //comparison
      bool operator== (const Vector4d& vec) const;
      bool operator!= (const Vector4d& vec) const;
      bool operator<  (const Vector4d& vec) const;
      bool operator<= (const Vector4d& vec) const;
      bool operator>  (const Vector4d& vec) const;
      bool operator>= (const Vector4d& vec) const;

      //arithmetic operations
      Vector4d operator+ (const Vector4d& vec) const;
      Vector4d operator- (const Vector4d& vec) const;
      Vector4d operator* (double scalar) const;
      Vector4d operator/ (double scalar) const;
      Vector4d operator- () const;

      //arithmetic updates
      Vector4d& operator+= (const Vector4d& vec);
      Vector4d& operator-= (const Vector4d& vec);
      Vector4d& operator*= (double scalar);
      Vector4d& operator/= (double scalar);

      //vector operations
      double length() const;
      double lengthSquared() const;
      double normalize();
      double distanceFrom(const Vector4d& vec) const;
      double distanceFromSquared(const Vector4d& vec) const;
      void setLength(double newLength);
      void invert();

      bool isZero();



      bool isBetweenPoints(const Vector4d& begin, const Vector4d& end) const;

      static Vector4d interpolate(const Vector4d& v0, const Vector4d& v1, double t);

      union {
         struct {
            double x;
            double y;
            double z;
            double w;
         };
         double data[4];
      };
   };

   // arithmetic operations
   LEGION_DLL Vector4d operator* (double scalar, const Vector4d& vec);

   // debugging output
   LEGION_DLL std::ostream& operator<< (std::ostream& outputStr, const Vector4d& vec);
}