APIMath.h

浏览该文件的文档.

#pragma once

#include <vector>

namespace AnyCAD{ namespace API{

   typedef double Real;
   typedef void* Handle;

   class AnyPlatformAPI_API Vector2
   {
   public:
      Real x;
      Real y;
   public:
      Vector2()
         :x(0), y(0)
      
      {}
      Vector2(Real _x, Real _y)
         :x(_x), y(_y)
      {}
   };
   typedef std::vector<Vector2> Vector2List;
   class AnyPlatformAPI_API Vector3
   {
   public:
      Real x;
      Real y;
      Real z;
   public:
      Vector3()
         :x(0), y(0), z(0)
      
      {}
      Vector3(Real _x, Real _y, Real _z)
         :x(_x), y(_y), z(_z)
      {}

      Vector3 operator-(const Vector3& rhv) const
      {
         return Vector3(x-rhv.x, y-rhv.y, z-rhv.z);
      }
      Vector3 operator+(const Vector3& rhv) const
      {
         return Vector3(x+rhv.x, y+rhv.y, z+rhv.z);
      }
      Vector3 operator*(const Vector3& rhv) const
      {
         return Vector3(x*rhv.x, y*rhv.y, z*rhv.z);
      }
      Vector3 operator*(Real vv) const
      {
         return Vector3(x*vv, y*vv, z*vv);
      }
      Vector3 operator/(Real vv) const
      {
         return Vector3(x/vv, y/vv, z/vv);
      }
      Real length() const;
      Real distance(const Vector3& pt) const;
      Real dotProduct(const Vector3& pt) const;
      Real normalize();

      Vector3 crossProduct(const Vector3& pt) const;
      Real angleBetween(const Vector3& vv) const;
      Vector3 angleBetweenZUp(Real angleZ) const;


   public:
       static const Vector3 ZERO;
       static const Vector3 UNIT_X;
       static const Vector3 UNIT_Y;
       static const Vector3 UNIT_Z;
   };
   class  AnyPlatformAPI_API Vector3List
   {
   public:
      typedef std::vector<Vector3> Vector3Arr;
      Vector3List();
      Vector3List(const Vector3Arr& arr);
      int      size() const { return int(m_arr.size());}
      void     add(const Vector3& vec);

      Vector3  get(int idx) const;


      Vector3* ptr() { return &m_arr[0]; }
      const Vector3& operator[] (int idx) const
      {
         return m_arr[idx];
      }

      void resize(int nSize){ m_arr.resize(nSize); }

      void clear() { m_arr.clear(); }
   public:
      const Vector3Arr& GetImpl() const  {return m_arr; }
      Vector3Arr& GetImpl() { return m_arr; }

   protected:
      Vector3Arr m_arr;
   };
   class AnyPlatformAPI_API ColorValue
   {
   public:
      float r;
      float g;
      float b;
      float a;
   public:
      ColorValue()
         : r(0), g(0), b(0), a(0)
      {

      }
      ColorValue(float _r, float _g, float _b, float _a)
         : r(_r), g(_g), b(_b), a(_a)
      {

      }
      ColorValue(int _r, int _g, int _b, int _a = 255)
          :r(_r/255.0f), g(_g/255.0f), b(_b/255.0f), a(_a/255.0f)
      {

      }

      long AsRGB() const
      {
          return ((long)(((unsigned char)(r*255)|((unsigned short)((unsigned char)(g*255))<<8))|(((unsigned char)(unsigned short)(b*255))<<16)));
      }
   };
   class AnyPlatformAPI_API Matrix3
   {
   public:
      Real m[3][3];

   public:
      Matrix3()
      {
      }

      Real Get(int row, int col) const
      {
         return m[row][col];
      }

      void Set(int row, int col, Real data)
      {
         m[row][col] = data;
      }
      inline Real* operator[] (size_t iRow) const
      {
         return (Real*)m[iRow];
      }
   };
   class AnyPlatformAPI_API Matrix4
   {
   public:
      Real m[4][4];
   public:
      Matrix4()
      {

      }
      Real Get(int row, int col) const
      {
         return m[row][col];
      }

      void Set(int row, int col, Real data)
      {
         m[row][col] = data;
      }
      inline Real* operator[] (size_t iRow) const
      {
         return (Real*)m[iRow];
      }

      Vector3 operator * ( const Vector3 &pt ) const{ return transform(pt); }

      Vector3 transform(const Vector3& pt) const;
   };
   class AnyPlatformAPI_API AABox
   {
   public:
      Vector3 minPt;
      Vector3 maxPt;
   public:
      AABox(){}
      AABox(const Vector3& _minPt, const Vector3& _maxPt)
         : minPt(_minPt), maxPt(_maxPt)
      {

      }

      Vector3 GetSize() const { return maxPt - minPt; }

      Vector3 GetCenter() const {return (maxPt+minPt)/2; }

      bool intersects(const AABox& b2) const;

      bool intersects(const Vector3& v) const;

      void transform(const Matrix4& trf);

      void Merge(const AABox& b2);
   };

   class AnyPlatformAPI_API Quaternion
   {
   public:
      Real w;
      Real x;
      Real y;
      Real z;
   public:
      Quaternion():w(1.0),x(0),y(0),z(0){}
      Quaternion(Real _w, Real _x, Real _y, Real _z):w(_w),x(_x),y(_y),z(_z){}
      Quaternion(const Vector3& src, const Vector3& dest);
      void FromAngleAxis(const Real& rfAngle, const Vector3& rkAxis);

      enum EnumEularSequence
      {
          XYZ,
          XZY,
          YXZ,
          YZX,
          ZXY,
          ZYX,
      };
      bool ToEulerAngles(EnumEularSequence sequence, Vector3& euler) const;

      Vector3 operator*(const Vector3& vec) const;
   };

   typedef std::pair<bool, Real> RayResult;

   class AnyPlatformAPI_API Ray
   {
   public:
       Ray();
       Ray(const Vector3& origin, const Vector3& direction)
           :mOrigin(origin), mDirection(direction) {}

        void setOrigin(const Vector3& origin) {mOrigin = origin;} 
        const Vector3& getOrigin(void) const {return mOrigin;} 

        void setDirection(const Vector3& dir) {mDirection = dir;} 
        const Vector3& getDirection(void) const {return mDirection;} 

        Vector3 getPoint(Real t) const { 
            return Vector3(mOrigin + (mDirection * t));
        }

        RayResult Intersect(const Vector3& pos, const Vector3& dir) const;

   protected:
       Vector3 mOrigin;
       Vector3 mDirection;
   };


   class AnyPlatformAPI_API Coordinate3
   {
   public:
       Coordinate3();
       Coordinate3(const Vector3& o, const Vector3& x, const Vector3& y, const Vector3& z);
       ~Coordinate3();

   public:
       Vector3 Origion;
       Vector3 X;
       Vector3 Y;
       Vector3 Z;
   };
}}