from the start... checking in ode-0.9

1 files changed, 177 insertions, 0 deletions

diff --git a/libraries/ode-0.9/OPCODE/Ice/IceOBB.h b/libraries/ode-0.9/OPCODE/Ice/IceOBB.h
new file mode 100644
index 0000000..d6cf43e
--- /dev/null
+++ b/libraries/ode-0.9/OPCODE/Ice/IceOBB.h
@@ -0,0 +1,177 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ *      Contains OBB-related code. (oriented bounding box)
+ *      \file           IceOBB.h
+ *      \author         Pierre Terdiman
+ *      \date           January, 13, 2000
+ */
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Include Guard
+#ifndef __ICEOBB_H__
+#define __ICEOBB_H__
+
+        // Forward declarations
+        class LSS;
+
+        class ICEMATHS_API OBB
+        {
+                public:
+                //! Constructor
+                inline_                                         OBB()           {}
+                //! Constructor
+                inline_                                         OBB(const Point& center, const Point& extents, const Matrix3x3& rot) : mCenter(center), mExtents(extents), mRot(rot)    {}
+                //! Destructor
+                inline_                                         ~OBB()          {}
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Setups an empty OBB.
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                void                            SetEmpty()
+                                                                        {
+                                                                                mCenter.Zero();
+                                                                                mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
+                                                                                mRot.Identity();
+                                                                        }
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Tests if a point is contained within the OBB.
+                 *      \param          p       [in] the world point to test
+                 *      \return         true if inside the OBB
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                bool                            ContainsPoint(const Point& p)   const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Builds an OBB from an AABB and a world transform.
+                 *      \param          aabb    [in] the aabb
+                 *      \param          mat             [in] the world transform
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                void                            Create(const AABB& aabb, const Matrix4x4& mat);
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Recomputes the OBB after an arbitrary transform by a 4x4 matrix.
+                 *      \param          mtx             [in] the transform matrix
+                 *      \param          obb             [out] the transformed OBB
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                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);
+                                                                        }
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Checks the OBB is valid.
+                 *      \return         true if the box is valid
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                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;
+                                                                        }
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Computes the obb planes.
+                 *      \param          planes  [out] 6 box planes
+                 *      \return         true if success
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                bool                            ComputePlanes(Plane* planes)    const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Computes the obb points.
+                 *      \param          pts     [out] 8 box points
+                 *      \return         true if success
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                bool                            ComputePoints(Point* pts)       const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Computes vertex normals.
+                 *      \param          pts     [out] 8 box points
+                 *      \return         true if success
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                bool                            ComputeVertexNormals(Point* pts)        const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Returns edges.
+                 *      \return         24 indices (12 edges) indexing the list returned by ComputePoints()
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                const udword*           GetEdges()      const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Returns local edge normals.
+                 *      \return         edge normals in local space
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                const Point*            GetLocalEdgeNormals()   const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Returns world edge normal
+                 *      \param          edge_index              [in] 0 <= edge index < 12
+                 *      \param          world_normal    [out] edge normal in world space
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                void                            ComputeWorldEdgeNormal(udword edge_index, Point& world_normal)  const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Computes an LSS surrounding the OBB.
+                 *      \param          lss             [out] the LSS
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                void                            ComputeLSS(LSS& lss)    const;
+
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                /**
+                 *      Checks the OBB is inside another OBB.
+                 *      \param          box             [in] the other OBB
+                 *      \return         TRUE if we're inside the other box
+                 */
+                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                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;                //!< B for Box
+                                Point                           mExtents;               //!< B for Bounding
+                                Matrix3x3                       mRot;                   //!< O for Oriented
+
+                                // Orientation is stored in row-major format,
+                                // i.e. rows = eigen vectors of the covariance matrix
+        };
+
+#endif  // __ICEOBB_H__