ifndef _OF_TYPES
  define _OF_TYPES
  
  include <ofConstants.h>
  
  //----------------------------------------------------------
  // ofPoint
  //----------------------------------------------------------
  class ofPoint {
    public:
          virtual ~ofPoint(){}
  
      ofPoint( float _x=0.0f, float _y=0.0f, float _z=0.0f ) {
          x = _x;
          y = _y;
          z = _z;
      }
  
      ofPoint( const ofPoint & pnt){
          x = pnt.x;
          y = pnt.y;
          z = pnt.z;
      }
  
      void set(float _x, float _y, float _z = 0){
          x = _x;
          y = _y;
          z = _z;
      }
  
          //------ Operators:
  
            //Negative
      ofPoint operator-() const {
          return ofPoint( -x, -y, -z );
      }
  
      //equality
      bool operator==( const ofPoint& pnt ) {
          return (x == pnt.x) && (y == pnt.y) && (z == pnt.z);
      }
  
          //inequality
      bool operator!=( const ofPoint& pnt ) {
          return (x != pnt.x) || (y != pnt.y) || (z != pnt.z);
      }
  
          //Set
          ofPoint & operator=( const ofPoint& pnt ){
                  x = pnt.x;
                  y = pnt.y;
                  z = pnt.z;
                  return *this;
          }
  
          ofPoint & operator=( const float& val ){
                  x = val;
                  y = val;
                  z = val;
                  return *this;
          }
  
          // Add
      ofPoint operator+( const ofPoint& pnt ) const {
          return ofPoint( x+pnt.x, y+pnt.y, z+pnt.z );
      }
  
      ofPoint operator+( const float& val ) const {
          return ofPoint( x+val, y+val, z+val );
      }
  
          ofPoint & operator+=( const ofPoint& pnt ) {
          x+=pnt.x;
          y+=pnt.y;
          z+=pnt.z;
          return *this;
      }
  
          ofPoint & operator+=( const float & val ) {
          x+=val;
          y+=val;
          z+=val;
          return *this;
      }
  
          // Subtract
      ofPoint operator-(const ofPoint& pnt) const {
          return ofPoint( x-pnt.x, y-pnt.y, z-pnt.z );
      }
  
      ofPoint operator-(const float& val) const {
          return ofPoint( x-val, y-val, z-val);
      }
  
      ofPoint & operator-=( const ofPoint& pnt ) {
          x -= pnt.x;
          y -= pnt.y;
          z -= pnt.z;
          return *this;
      }
  
      ofPoint & operator-=( const float & val ) {
          x -= val;
          y -= val;
          z -= val;
          return *this;
      }
  
          // Multiply
      ofPoint operator*( const ofPoint& pnt ) const {
          return ofPoint( x*pnt.x, y*pnt.y, z*pnt.z );
      }
  
      ofPoint operator*(const float& val) const {
          return ofPoint( x*val, y*val, z*val);
      }
  
      ofPoint & operator*=( const ofPoint& pnt ) {
          x*=pnt.x;
          y*=pnt.y;
          z*=pnt.z;
          return *this;
      }
  
      ofPoint & operator*=( const float & val ) {
          x*=val;
          y*=val;
          z*=val;
          return *this;
      }
  
          // Divide
      ofPoint operator/( const ofPoint& pnt ) const {
          return ofPoint( pnt.x!=0 ? x/pnt.x : x , pnt.y!=0 ? y/pnt.y : y, pnt.z!=0 ? z/pnt.z : z );
      }
  
      ofPoint operator/( const float &val ) const {
                  if( val != 0){
                          return ofPoint( x/val, y/val, z/val );
                  }
          return ofPoint(x, y, z );
      }
  
      ofPoint& operator/=( const ofPoint& pnt ) {
          pnt.x!=0 ? x/=pnt.x : x;
          pnt.y!=0 ? y/=pnt.y : y;
          pnt.z!=0 ? z/=pnt.z : z;
  
          return *this;
      }
  
      ofPoint& operator/=( const float &val ) {
                  if( val != 0 ){
                          x /= val;
                          y /= val;
                          z /= val;
                  }
  
                  return *this;
      }
  
          // union allows us to access the coordinates through
      // both an array 'v' and 'x', 'y', 'z' member varibles
      union  {
          struct {
              float x;
              float y;
              float z;
          };
          float v[3];
      };
  
  };
  
  //----------------------------------------------------------
  // ofRectangle
  //----------------------------------------------------------
  
  class ofRectangle {
    public:
          ofRectangle(){ x = y = width = height = 0; };
          ofRectangle(float _x, float _y, float _w, float _h){
                  x = _x;
                  y = _y;
                  width = _w;
                  height = _h;
          }
          virtual ~ofRectangle(){}
  
     float x;
     float y;
     float width;
     float height;
  
  };
  
  //----------------------------------------------------------
  // ofColor
  //----------------------------------------------------------
  
  class ofColor{
          public:
                  ofColor(){
                          r = 255;
                          g = 255;
                          b = 255;
                          a = 255;
                  }
                  virtual ~ofColor(){}
                  float r, g, b, a;
  };
  
  //----------------------------------------------------------
  // ofStyle
  //----------------------------------------------------------
  
  class ofStyle{
          public:
                  ofStyle(){
                          bFill                                = true;
                          blending                        = false;
                          smoothing                        = false;
                          circleResolution        = 20;
                          lineWidth                        = 1.0;
                          polyMode                        = OF_POLY_WINDING_ODD;
                          rectMode                        = OF_RECTMODE_CORNER;
                  }
  
                  virtual ~ofStyle(){}
  
                  ofColor color;
                  int polyMode;
                  int rectMode;
                  bool bFill;
                  bool blending;
                  bool smoothing;
                  int circleResolution;
                  float lineWidth;
  };
  
  //----------------------------------------------------------
  // ofBaseDraws
  //----------------------------------------------------------
  
  class ofBaseDraws{
  public:
          virtual ~ofBaseDraws(){}
          virtual void draw(float x,float y)=0;
          virtual void draw(float x,float y,float w, float h)=0;
          virtual float getHeight()=0;
          virtual float getWidth()=0;
  
          virtual void setAnchorPercent(float xPct, float yPct){};
      virtual void setAnchorPoint(int x, int y){};
          virtual void resetAnchor(){};
  
  };
  
  //----------------------------------------------------------
  // ofBaseUpdates
  //----------------------------------------------------------
  
  class ofBaseUpdates{
  public:
          virtual ~ofBaseUpdates(){}
          virtual void update()=0;
  };
  
  //----------------------------------------------------------
  // ofBaseHasTexture
  //----------------------------------------------------------
  class ofTexture;
  
  class ofBaseHasTexture{
  public:
          virtual ~ofBaseHasTexture(){}
          virtual ofTexture & getTextureReference()=0;
  };
  
  //----------------------------------------------------------
  // ofBaseHasPixels
  //----------------------------------------------------------
  class ofBaseHasPixels{
  public:
          virtual ~ofBaseHasPixels(){}
          virtual unsigned char * getPixels()=0;
  };
  
  //----------------------------------------------------------
  // ofBaseVideo
  //----------------------------------------------------------
  class ofBaseVideo: public ofBaseDraws, public ofBaseUpdates, public ofBaseHasTexture, public ofBaseHasPixels{
  public:
          virtual ~ofBaseVideo(){}
          virtual unsigned char * getPixels()=0;
          virtual void close()=0;
  };
  endif