aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/ode-0.9/OPCODE/Ice/IceOBB.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--libraries/ode-0.9/OPCODE/Ice/IceOBB.h177
1 files changed, 0 insertions, 177 deletions
diff --git a/libraries/ode-0.9/OPCODE/Ice/IceOBB.h b/libraries/ode-0.9/OPCODE/Ice/IceOBB.h
deleted file mode 100644
index d6cf43e..0000000
--- a/libraries/ode-0.9/OPCODE/Ice/IceOBB.h
+++ /dev/null
@@ -1,177 +0,0 @@
1///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2/**
3 * Contains OBB-related code. (oriented bounding box)
4 * \file IceOBB.h
5 * \author Pierre Terdiman
6 * \date January, 13, 2000
7 */
8///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
9
10///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
11// Include Guard
12#ifndef __ICEOBB_H__
13#define __ICEOBB_H__
14
15 // Forward declarations
16 class LSS;
17
18 class ICEMATHS_API OBB
19 {
20 public:
21 //! Constructor
22 inline_ OBB() {}
23 //! Constructor
24 inline_ OBB(const Point& center, const Point& extents, const Matrix3x3& rot) : mCenter(center), mExtents(extents), mRot(rot) {}
25 //! Destructor
26 inline_ ~OBB() {}
27
28 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
29 /**
30 * Setups an empty OBB.
31 */
32 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
33 void SetEmpty()
34 {
35 mCenter.Zero();
36 mExtents.Set(MIN_FLOAT, MIN_FLOAT, MIN_FLOAT);
37 mRot.Identity();
38 }
39
40 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
41 /**
42 * Tests if a point is contained within the OBB.
43 * \param p [in] the world point to test
44 * \return true if inside the OBB
45 */
46 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
47 bool ContainsPoint(const Point& p) const;
48
49 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
50 /**
51 * Builds an OBB from an AABB and a world transform.
52 * \param aabb [in] the aabb
53 * \param mat [in] the world transform
54 */
55 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
56 void Create(const AABB& aabb, const Matrix4x4& mat);
57
58 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
59 /**
60 * Recomputes the OBB after an arbitrary transform by a 4x4 matrix.
61 * \param mtx [in] the transform matrix
62 * \param obb [out] the transformed OBB
63 */
64 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
65 inline_ void Rotate(const Matrix4x4& mtx, OBB& obb) const
66 {
67 // The extents remain constant
68 obb.mExtents = mExtents;
69 // The center gets x-formed
70 obb.mCenter = mCenter * mtx;
71 // Combine rotations
72 obb.mRot = mRot * Matrix3x3(mtx);
73 }
74
75 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
76 /**
77 * Checks the OBB is valid.
78 * \return true if the box is valid
79 */
80 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
81 inline_ BOOL IsValid() const
82 {
83 // Consistency condition for (Center, Extents) boxes: Extents >= 0.0f
84 if(mExtents.x < 0.0f) return FALSE;
85 if(mExtents.y < 0.0f) return FALSE;
86 if(mExtents.z < 0.0f) return FALSE;
87 return TRUE;
88 }
89
90 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
91 /**
92 * Computes the obb planes.
93 * \param planes [out] 6 box planes
94 * \return true if success
95 */
96 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
97 bool ComputePlanes(Plane* planes) const;
98
99 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
100 /**
101 * Computes the obb points.
102 * \param pts [out] 8 box points
103 * \return true if success
104 */
105 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
106 bool ComputePoints(Point* pts) const;
107
108 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
109 /**
110 * Computes vertex normals.
111 * \param pts [out] 8 box points
112 * \return true if success
113 */
114 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
115 bool ComputeVertexNormals(Point* pts) const;
116
117 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
118 /**
119 * Returns edges.
120 * \return 24 indices (12 edges) indexing the list returned by ComputePoints()
121 */
122 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
123 const udword* GetEdges() const;
124
125 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
126 /**
127 * Returns local edge normals.
128 * \return edge normals in local space
129 */
130 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
131 const Point* GetLocalEdgeNormals() const;
132
133 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
134 /**
135 * Returns world edge normal
136 * \param edge_index [in] 0 <= edge index < 12
137 * \param world_normal [out] edge normal in world space
138 */
139 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
140 void ComputeWorldEdgeNormal(udword edge_index, Point& world_normal) const;
141
142 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
143 /**
144 * Computes an LSS surrounding the OBB.
145 * \param lss [out] the LSS
146 */
147 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
148 void ComputeLSS(LSS& lss) const;
149
150 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
151 /**
152 * Checks the OBB is inside another OBB.
153 * \param box [in] the other OBB
154 * \return TRUE if we're inside the other box
155 */
156 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
157 BOOL IsInside(const OBB& box) const;
158
159 inline_ const Point& GetCenter() const { return mCenter; }
160 inline_ const Point& GetExtents() const { return mExtents; }
161 inline_ const Matrix3x3& GetRot() const { return mRot; }
162
163 inline_ void GetRotatedExtents(Matrix3x3& extents) const
164 {
165 extents = mRot;
166 extents.Scale(mExtents);
167 }
168
169 Point mCenter; //!< B for Box
170 Point mExtents; //!< B for Bounding
171 Matrix3x3 mRot; //!< O for Oriented
172
173 // Orientation is stored in row-major format,
174 // i.e. rows = eigen vectors of the covariance matrix
175 };
176
177#endif // __ICEOBB_H__
generated by cgit v1.1 at 2024-12-28 08:23:55 +0000