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__