| 1 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 2 | /** |
|---|
| 3 | * Contains code for planes. |
|---|
| 4 | * \file IcePlane.h |
|---|
| 5 | * \author Pierre Terdiman |
|---|
| 6 | * \date April, 4, 2000 |
|---|
| 7 | */ |
|---|
| 8 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 9 | |
|---|
| 10 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 11 | // Include Guard |
|---|
| 12 | #ifndef __ICEPLANE_H__ |
|---|
| 13 | #define __ICEPLANE_H__ |
|---|
| 14 | |
|---|
| 15 | #define PLANE_EPSILON (1.0e-7f) |
|---|
| 16 | |
|---|
| 17 | class ICEMATHS_API Plane |
|---|
| 18 | { |
|---|
| 19 | public: |
|---|
| 20 | //! Constructor |
|---|
| 21 | inline_ Plane() { } |
|---|
| 22 | //! Constructor from a normal and a distance |
|---|
| 23 | inline_ Plane(float nx, float ny, float nz, float d) { Set(nx, ny, nz, d); } |
|---|
| 24 | //! Constructor from a point on the plane and a normal |
|---|
| 25 | inline_ Plane(const Point& p, const Point& n) { Set(p, n); } |
|---|
| 26 | //! Constructor from three points |
|---|
| 27 | inline_ Plane(const Point& p0, const Point& p1, const Point& p2) { Set(p0, p1, p2); } |
|---|
| 28 | //! Constructor from a normal and a distance |
|---|
| 29 | inline_ Plane(const Point& _n, float _d) { n = _n; d = _d; } |
|---|
| 30 | //! Copy constructor |
|---|
| 31 | inline_ Plane(const Plane& plane) : n(plane.n), d(plane.d) { } |
|---|
| 32 | //! Destructor |
|---|
| 33 | inline_ ~Plane() { } |
|---|
| 34 | |
|---|
| 35 | inline_ Plane& Zero() { n.Zero(); d = 0.0f; return *this; } |
|---|
| 36 | inline_ Plane& Set(float nx, float ny, float nz, float _d) { n.Set(nx, ny, nz); d = _d; return *this; } |
|---|
| 37 | inline_ Plane& Set(const Point& p, const Point& _n) { n = _n; d = - p | _n; return *this; } |
|---|
| 38 | Plane& Set(const Point& p0, const Point& p1, const Point& p2); |
|---|
| 39 | |
|---|
| 40 | inline_ float Distance(const Point& p) const { return (p | n) + d; } |
|---|
| 41 | inline_ bool Belongs(const Point& p) const { return fabsf(Distance(p)) < PLANE_EPSILON; } |
|---|
| 42 | |
|---|
| 43 | inline_ void Normalize() |
|---|
| 44 | { |
|---|
| 45 | float Denom = 1.0f / n.Magnitude(); |
|---|
| 46 | n.x *= Denom; |
|---|
| 47 | n.y *= Denom; |
|---|
| 48 | n.z *= Denom; |
|---|
| 49 | d *= Denom; |
|---|
| 50 | } |
|---|
| 51 | public: |
|---|
| 52 | // Members |
|---|
| 53 | Point n; //!< The normal to the plane |
|---|
| 54 | float d; //!< The distance from the origin |
|---|
| 55 | |
|---|
| 56 | // Cast operators |
|---|
| 57 | inline_ operator Point() const { return n; } |
|---|
| 58 | inline_ operator HPoint() const { return HPoint(n, d); } |
|---|
| 59 | |
|---|
| 60 | // Arithmetic operators |
|---|
| 61 | inline_ Plane operator*(const Matrix4x4& m) const |
|---|
| 62 | { |
|---|
| 63 | // Old code from Irion. Kept for reference. |
|---|
| 64 | Plane Ret(*this); |
|---|
| 65 | return Ret *= m; |
|---|
| 66 | } |
|---|
| 67 | |
|---|
| 68 | inline_ Plane& operator*=(const Matrix4x4& m) |
|---|
| 69 | { |
|---|
| 70 | // Old code from Irion. Kept for reference. |
|---|
| 71 | Point n2 = HPoint(n, 0.0f) * m; |
|---|
| 72 | d = -((Point) (HPoint( -d*n, 1.0f ) * m) | n2); |
|---|
| 73 | n = n2; |
|---|
| 74 | return *this; |
|---|
| 75 | } |
|---|
| 76 | }; |
|---|
| 77 | |
|---|
| 78 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 79 | /** |
|---|
| 80 | * Transforms a plane by a 4x4 matrix. Same as Plane * Matrix4x4 operator, but faster. |
|---|
| 81 | * \param transformed [out] transformed plane |
|---|
| 82 | * \param plane [in] source plane |
|---|
| 83 | * \param transform [in] transform matrix |
|---|
| 84 | * \warning the plane normal must be unit-length |
|---|
| 85 | */ |
|---|
| 86 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 87 | inline_ void TransformPlane(Plane& transformed, const Plane& plane, const Matrix4x4& transform) |
|---|
| 88 | { |
|---|
| 89 | // Rotate the normal using the rotation part of the 4x4 matrix |
|---|
| 90 | transformed.n = plane.n * Matrix3x3(transform); |
|---|
| 91 | |
|---|
| 92 | // Compute new d |
|---|
| 93 | transformed.d = plane.d - (Point(transform.GetTrans())|transformed.n); |
|---|
| 94 | } |
|---|
| 95 | |
|---|
| 96 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 97 | /** |
|---|
| 98 | * Transforms a plane by a 4x4 matrix. Same as Plane * Matrix4x4 operator, but faster. |
|---|
| 99 | * \param plane [in/out] source plane (transformed on return) |
|---|
| 100 | * \param transform [in] transform matrix |
|---|
| 101 | * \warning the plane normal must be unit-length |
|---|
| 102 | */ |
|---|
| 103 | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// |
|---|
| 104 | inline_ void TransformPlane(Plane& plane, const Matrix4x4& transform) |
|---|
| 105 | { |
|---|
| 106 | // Rotate the normal using the rotation part of the 4x4 matrix |
|---|
| 107 | plane.n *= Matrix3x3(transform); |
|---|
| 108 | |
|---|
| 109 | // Compute new d |
|---|
| 110 | plane.d -= Point(transform.GetTrans())|plane.n; |
|---|
| 111 | } |
|---|
| 112 | |
|---|
| 113 | #endif // __ICEPLANE_H__ |
|---|
