IceOBB.h

Go to the documentation of this file.

 
 
// Include Guard
#ifndef __ICEOBB_H__
#define __ICEOBB_H__
 
        // Forward declarations
        class LSS;
 
        class ICEMATHS_API OBB
        {
                public:
                inline_                                         OBB()           {}
                inline_                                         OBB(const Point& center, const Point& extents, const Matrix3x3& rot) : mCenter(center), mExtents(extents), mRot(rot)    {}
                inline_                                         ~OBB()          {}
 
 
                                void                            SetEmpty()
                                                                        {
                                                                                mCenter.Zero();
                                                                                mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
                                                                                mRot.Identity();
                                                                        }
 
 
                                bool                            ContainsPoint(const Point& p)   const;
 
 
                                void                            Create(const AABB& aabb, const Matrix4x4& mat);
 
 
                inline_ void                            Rotate(const Matrix4x4& mtx, OBB& obb)  const
                                                                        {
                                                                                // The extents remain constant
                                                                                obb.mExtents = mExtents;
                                                                                // The center gets x-formed
                                                                                obb.mCenter = mCenter * mtx;
                                                                                // Combine rotations
                                                                                obb.mRot = mRot * Matrix3x3(mtx);
                                                                        }
 
 
                inline_ BOOL                            IsValid()       const
                                                                        {
                                                                                // Consistency condition for (Center, Extents) boxes: Extents >= 0.0f
                                                                                if(mExtents.x < 0.0f)   return FALSE;
                                                                                if(mExtents.y < 0.0f)   return FALSE;
                                                                                if(mExtents.z < 0.0f)   return FALSE;
                                                                                return TRUE;
                                                                        }
 
 
                                bool                            ComputePlanes(Plane* planes)    const;
 
 
                                bool                            ComputePoints(Point* pts)       const;
 
 
                                bool                            ComputeVertexNormals(Point* pts)        const;
 
 
                                const udword*           GetEdges()      const;
 
 
                                const Point*            GetLocalEdgeNormals()   const;
 
 
                                void                            ComputeWorldEdgeNormal(udword edge_index, Point& world_normal)  const;
 
 
                                void                            ComputeLSS(LSS& lss)    const;
 
 
                                BOOL                            IsInside(const OBB& box)        const;
 
                inline_ const Point&            GetCenter()             const   { return mCenter;       }
                inline_ const Point&            GetExtents()    const   { return mExtents;      }
                inline_ const Matrix3x3&        GetRot()                const   { return mRot;          }
 
                inline_ void                            GetRotatedExtents(Matrix3x3& extents)   const
                                                                        {
                                                                                extents = mRot;
                                                                                extents.Scale(mExtents);
                                                                        }
 
                                Point                           mCenter;                
                                Point                           mExtents;               
                                Matrix3x3                       mRot;                   
 
                                // Orientation is stored in row-major format,
                                // i.e. rows = eigen vectors of the covariance matrix
        };
 
#endif  // __ICEOBB_H__