IceHPoint.h

Go to the documentation of this file.

// Include Guard
#ifndef __ICEHPOINT_H__
#define __ICEHPOINT_H__

        class ICEMATHS_API HPoint : public Point
        {
                public:

                inline_                         HPoint()                                                                                                                                                {}
                inline_                         HPoint(float _x, float _y, float _z, float _w=0.0f) : Point(_x, _y, _z), w(_w)  {}
                inline_                         HPoint(const float f[4]) : Point(f), w(f[3])                                                                    {}
                inline_                         HPoint(const Point& p, float _w=0.0f) : Point(p), w(_w)                                                 {}
                inline_                         ~HPoint()                                                                                                                                               {}

                inline_ HPoint&         Zero()                                                                                  { x =                   y =                     z =                     w = 0.0f;               return *this;   }

                inline_ HPoint&         Set(float _x, float _y, float _z, float _w )    { x  = _x;              y  = _y;        z  = _z;        w  = _w;                return *this;   }
                inline_ HPoint&         Set(const float f[4])                                                   { x  = f[_X];   y  = f[_Y];     z  = f[_Z];     w  = f[_W];             return *this;   }
                inline_ HPoint&         Set(const HPoint& src)                                                  { x  = src.x;   y  = src.y;     z  = src.z;     w = src.w;              return *this;   }

                inline_ HPoint&         Add(float _x, float _y, float _z, float _w )    { x += _x;              y += _y;        z += _z;        w += _w;                return *this;   }
                inline_ HPoint&         Add(const float f[4])                                                   { x += f[_X];   y += f[_Y];     z += f[_Z];     w += f[_W];             return *this;   }

                inline_ HPoint&         Sub(float _x, float _y, float _z, float _w )    { x -= _x;              y -= _y;        z -= _z;        w -= _w;                return *this;   }
                inline_ HPoint&         Sub(const float f[4])                                                   { x -= f[_X];   y -= f[_Y];     z -= f[_Z];     w -= f[_W];             return *this;   }
                
                inline_ HPoint&         Mul(float s)                                                                    { x *= s;               y *= s;         z *= s;         w *= s;                 return *this;   }

                                float           Min()                                                           const           { return MIN(x, MIN(y, MIN(z, w)));                                                                             }
                                float           Max()                                                           const           { return MAX(x, MAX(y, MAX(z, w)));                                                                             }
                                HPoint&         Min(const HPoint& p)                                                    { x = MIN(x, p.x); y = MIN(y, p.y); z = MIN(z, p.z); w = MIN(w, p.w);   return *this;   }
                                HPoint&         Max(const HPoint& p)                                                    { x = MAX(x, p.x); y = MAX(y, p.y); z = MAX(z, p.z); w = MAX(w, p.w);   return *this;   }

                inline_ float           SquareMagnitude()                                       const           { return x*x + y*y + z*z + w*w;                                                                                 }
                inline_ float           Magnitude()                                                     const           { return sqrtf(x*x + y*y + z*z + w*w);                                                                  }

                inline_ HPoint&         Normalize()
                                                        {
                                                                float M = Magnitude();
                                                                if(M)
                                                                {
                                                                        M = 1.0f / M;
                                                                        x *= M;
                                                                        y *= M;
                                                                        z *= M;
                                                                        w *= M;
                                                                }
                                                                return *this;
                                                        }

                // Arithmetic operators
                inline_ HPoint          operator-()                                                     const           { return HPoint(-x, -y, -z, -w);                                                        }

                inline_ HPoint          operator+(const HPoint& p)                      const           { return HPoint(x + p.x, y + p.y, z + p.z, w + p.w);            }
                inline_ HPoint          operator-(const HPoint& p)                      const           { return HPoint(x - p.x, y - p.y, z - p.z, w - p.w);            }

                inline_ HPoint          operator*(const HPoint& p)                      const           { return HPoint(x * p.x, y * p.y, z * p.z, w * p.w);            }
                inline_ HPoint          operator*(float s)                                      const           { return HPoint(x * s, y * s, z * s, w * s);                            }
                inline_ friend  HPoint  operator*(float s, const HPoint& p)                     { return HPoint(s * p.x, s * p.y, s * p.z, s * p.w);            }

                inline_ HPoint          operator/(const HPoint& p)                      const           { return HPoint(x / p.x, y / p.y, z / p.z, w / p.w);            }
                inline_ HPoint          operator/(float s)                                      const           { s = 1.0f / s; return HPoint(x * s, y * s, z * s, w * s);      }
                inline_ friend  HPoint  operator/(float s, const HPoint& p)                     { return HPoint(s / p.x, s / p.y, s / p.z, s / p.w);            }

                inline_ float           operator|(const HPoint& p)                      const           { return x*p.x + y*p.y + z*p.z + w*p.w;                                         }
                // No cross-product in 4D

                inline_ HPoint&         operator+=(const HPoint& p)                                             { x += p.x; y += p.y; z += p.z; w += p.w;       return *this;   }
                inline_ HPoint&         operator+=(float s)                                                             { x += s;   y += s;   z += s;   w += s;         return *this;   }

                inline_ HPoint&         operator-=(const HPoint& p)                                             { x -= p.x; y -= p.y; z -= p.z; w -= p.w;       return *this;   }
                inline_ HPoint&         operator-=(float s)                                                             { x -= s;   y -= s;   z -= s;   w -= s;         return *this;   }

                inline_ HPoint&         operator*=(const HPoint& p)                                             { x *= p.x; y *= p.y; z *= p.z; w *= p.w;       return *this;   }
                inline_ HPoint&         operator*=(float s)                                                             { x*=s; y*=s; z*=s; w*=s;                                       return *this;   }

                inline_ HPoint&         operator/=(const HPoint& p)                                             { x /= p.x; y /= p.y; z /= p.z; w /= p.w;       return *this;   }
                inline_ HPoint&         operator/=(float s)                                                             { s = 1.0f / s; x*=s; y*=s; z*=s; w*=s;         return *this;   }

                // Arithmetic operators

                                Point           operator*(const Matrix3x3& mat)         const;
                                HPoint          operator*(const Matrix4x4& mat)         const;

                // HPoint *= Matrix3x3 doesn't exist, the matrix is first casted to a 4x4
                                HPoint&         operator*=(const Matrix4x4& mat);

                // Logical operators

                inline_ bool            operator==(const HPoint& p)                     const           { return ( (x==p.x)&&(y==p.y)&&(z==p.z)&&(w==p.w));                     }
                inline_ bool            operator!=(const HPoint& p)                     const           { return ( (x!=p.x)||(y!=p.y)||(z!=p.z)||(w!=p.w));                     }

                // Cast operators

#ifdef _MSC_VER
                inline_                         operator        Point()                                 const           { return Point(x, y, z);                                                                        }
                // gcc complains that conversion to a base class will never use a type conversion operator
#endif

                public:
                                float           w;
        };

#endif // __ICEHPOINT_H__