IcePlane.h

Go to the documentation of this file.

// Include Guard
#ifndef __ICEPLANE_H__
#define __ICEPLANE_H__

        #define PLANE_EPSILON           (1.0e-7f)

        class ICEMATHS_API Plane
        {
                public:
                inline_                 Plane()                                                                                                                 {                                                                                               }
                inline_                 Plane(float nx, float ny, float nz, float d)                                    { Set(nx, ny, nz, d);                                                   }
                inline_                 Plane(const Point& p, const Point& n)                                                   { Set(p, n);                                                                    }
                inline_                 Plane(const Point& p0, const Point& p1, const Point& p2)                { Set(p0, p1, p2);                                                              }
                inline_                 Plane(const Point& _n, float _d)                                                                { n = _n; d = _d;                                                               }
                inline_                 Plane(const Plane& plane) : n(plane.n), d(plane.d)                              {                                                                                               }
                inline_                 ~Plane()                                                                                                                {                                                                                               }

                inline_ Plane&  Zero()                                                                                                                  { n.Zero(); d = 0.0f;                   return *this;   }
                inline_ Plane&  Set(float nx, float ny, float nz, float _d)                                             { n.Set(nx, ny, nz); d = _d;    return *this;   }
                inline_ Plane&  Set(const Point& p, const Point& _n)                                                    { n = _n; d = - p | _n;                 return *this;   }
                                Plane&  Set(const Point& p0, const Point& p1, const Point& p2);

                inline_ float   Distance(const Point& p)                        const                                           { return (p | n) + d;                                                   }
                inline_ bool    Belongs(const Point& p)                         const                                           { return fabsf(Distance(p)) < PLANE_EPSILON;    }

                inline_ void    Normalize()
                                                {
                                                        float Denom = 1.0f / n.Magnitude();
                                                        n.x     *= Denom;
                                                        n.y     *= Denom;
                                                        n.z     *= Denom;
                                                        d       *= Denom;
                                                }
                public:
                // Members
                                Point   n;              
                                float   d;              

                // Cast operators
                inline_                 operator Point()                                        const                                           { return n;                                                                             }
                inline_                 operator HPoint()                                       const                                           { return HPoint(n, d);                                                  }

                // Arithmetic operators
                inline_ Plane   operator*(const Matrix4x4& m)           const
                                                {
                                                        // Old code from Irion. Kept for reference.
                                                        Plane Ret(*this);
                                                        return Ret *= m;
                                                }

                inline_ Plane&  operator*=(const Matrix4x4& m)
                                                {
                                                        // Old code from Irion. Kept for reference.
                                                        Point n2 = HPoint(n, 0.0f) * m;
                                                        d = -((Point) (HPoint( -d*n, 1.0f ) * m) | n2);
                                                        n = n2;
                                                        return *this;
                                                }
        };


        inline_ void TransformPlane(Plane& transformed, const Plane& plane, const Matrix4x4& transform)
        {
                // Rotate the normal using the rotation part of the 4x4 matrix
                transformed.n = plane.n * Matrix3x3(transform);

                // Compute new d
                transformed.d = plane.d - (Point(transform.GetTrans())|transformed.n);
        }


        inline_ void TransformPlane(Plane& plane, const Matrix4x4& transform)
        {
                // Rotate the normal using the rotation part of the 4x4 matrix
                plane.n *= Matrix3x3(transform);

                // Compute new d
                plane.d -= Point(transform.GetTrans())|plane.n;
        }

#endif // __ICEPLANE_H__