~ubuntu-branches/debian/sid/ember/sid

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Contains OBB-related code.

* \file IceOBB.cpp

* \author Pierre Terdiman

* \date January, 29, 2000

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* An Oriented Bounding Box (OBB).

* \class OBB

* \author Pierre Terdiman

* \version 1.0

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Precompiled Header

#include "Opcode/Stdafx.h"

using namespace IceMaths;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Tests if a point is contained within the OBB.

* \param p [in] the world point to test

* \return true if inside the OBB

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool OBB::ContainsPoint(const Point& p) const

{

// Point in OBB test using lazy evaluation and early exits

// Translate to box space

Point RelPoint = p - mCenter;

// Point * mRot maps from box space to world space

// mRot * Point maps from world space to box space (what we need here)

float f = mRot.m[0][0] * RelPoint.x + mRot.m[0][1] * RelPoint.y + mRot.m[0][2] * RelPoint.z;

if(f >= mExtents.x || f <= -mExtents.x) return false;

f = mRot.m[1][0] * RelPoint.x + mRot.m[1][1] * RelPoint.y + mRot.m[1][2] * RelPoint.z;

if(f >= mExtents.y || f <= -mExtents.y) return false;

f = mRot.m[2][0] * RelPoint.x + mRot.m[2][1] * RelPoint.y + mRot.m[2][2] * RelPoint.z;

if(f >= mExtents.z || f <= -mExtents.z) return false;

return true;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Builds an OBB from an AABB and a world transform.

* \param aabb [in] the aabb

* \param mat [in] the world transform

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void OBB::Create(const AABB& aabb, const Matrix4x4& mat)

{

// Note: must be coherent with Rotate()

aabb.GetCenter(mCenter);

aabb.GetExtents(mExtents);

// Here we have the same as OBB::Rotate(mat) where the obb is (mCenter, mExtents, Identity).

// So following what's done in Rotate:

// - x-form the center

mCenter *= mat;

// - combine rotation with identity, i.e. just use given matrix

mRot = mat;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Computes the obb planes.

* \param planes [out] 6 box planes

* \return true if success

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool OBB::ComputePlanes(Plane* planes) const

{

// Checkings

if(!planes) return false;

Point Axis0 = mRot[0];

Point Axis1 = mRot[1];

Point Axis2 = mRot[2];

// Writes normals

planes[0].n = Axis0;

planes[1].n = -Axis0;

planes[2].n = Axis1;

planes[3].n = -Axis1;

planes[4].n = Axis2;

planes[5].n = -Axis2;

// Compute a point on each plane

100

Point p0 = mCenter + Axis0 * mExtents.x;

101

Point p1 = mCenter - Axis0 * mExtents.x;

102

Point p2 = mCenter + Axis1 * mExtents.y;

103

Point p3 = mCenter - Axis1 * mExtents.y;

104

Point p4 = mCenter + Axis2 * mExtents.z;

105

Point p5 = mCenter - Axis2 * mExtents.z;

106

107

// Compute d

108

planes[0].d = -(planes[0].n|p0);

109

planes[1].d = -(planes[1].n|p1);

110

planes[2].d = -(planes[2].n|p2);

111

planes[3].d = -(planes[3].n|p3);

112

planes[4].d = -(planes[4].n|p4);

113

planes[5].d = -(planes[5].n|p5);

114

115

return true;

116

}

117

118

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

119

/**

120

* Computes the obb points.

121

* \param pts [out] 8 box points

122

* \return true if success

123

124

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

125

bool OBB::ComputePoints(Point* pts) const

126

{

127

// Checkings

128

if(!pts) return false;

129

130

Point Axis0 = mRot[0];

131

Point Axis1 = mRot[1];

132

Point Axis2 = mRot[2];

133

134

Axis0 *= mExtents.x;

135

Axis1 *= mExtents.y;

136

Axis2 *= mExtents.z;

137

138

// 7+------+6 0 = ---

139

// /| /| 1 = +--

140

// / | / | 2 = ++-

141

// / 4+---/--+5 3 = -+-

142

// 3+------+2 / y z 4 = --+

143

// | / | / | / 5 = +-+

144

// |/ |/ |/ 6 = +++

145

// 0+------+1 *---x 7 = -++

146

147

pts[0] = mCenter - Axis0 - Axis1 - Axis2;

148

pts[1] = mCenter + Axis0 - Axis1 - Axis2;

149

pts[2] = mCenter + Axis0 + Axis1 - Axis2;

150

pts[3] = mCenter - Axis0 + Axis1 - Axis2;

151

pts[4] = mCenter - Axis0 - Axis1 + Axis2;

152

pts[5] = mCenter + Axis0 - Axis1 + Axis2;

153

pts[6] = mCenter + Axis0 + Axis1 + Axis2;

154

pts[7] = mCenter - Axis0 + Axis1 + Axis2;

155

156

return true;

157

}

158

159

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

160

/**

161

* Computes vertex normals.

162

* \param pts [out] 8 box points

163

* \return true if success

164

165

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

166

bool OBB::ComputeVertexNormals(Point* pts) const

167

{

168

static float VertexNormals[] =

169

{

170

-INVSQRT3, -INVSQRT3, -INVSQRT3,

171

INVSQRT3, -INVSQRT3, -INVSQRT3,

172

INVSQRT3, INVSQRT3, -INVSQRT3,

173

-INVSQRT3, INVSQRT3, -INVSQRT3,

174

-INVSQRT3, -INVSQRT3, INVSQRT3,

175

INVSQRT3, -INVSQRT3, INVSQRT3,

176

INVSQRT3, INVSQRT3, INVSQRT3,

177

-INVSQRT3, INVSQRT3, INVSQRT3

178

};

179

180

if(!pts) return false;

181

182

const Point* VN = (const Point*)VertexNormals;

183

for(udword i=0;i<8;i++)

184

{

185

pts[i] = VN[i] * mRot;

186

}

187

188

return true;

189

}

190

191

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

192

/**

193

* Returns edges.

194

* \return 24 indices (12 edges) indexing the list returned by ComputePoints()

195

196

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

197

const udword* OBB::GetEdges() const

198

{

199

static udword Indices[] = {

200

0, 1, 1, 2, 2, 3, 3, 0,

201

7, 6, 6, 5, 5, 4, 4, 7,

202

1, 5, 6, 2,

203

3, 7, 4, 0

204

};

205

return Indices;

206

}

207

208

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

209

/**

210

* Returns local edge normals.

211

* \return edge normals in local space

212

213

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

214

const Point* OBB::GetLocalEdgeNormals() const

215

{

216

static float EdgeNormals[] =

217

{

218

0, -INVSQRT2, -INVSQRT2, // 0-1

219

INVSQRT2, 0, -INVSQRT2, // 1-2

220

0, INVSQRT2, -INVSQRT2, // 2-3

221

-INVSQRT2, 0, -INVSQRT2, // 3-0

222

223

0, INVSQRT2, INVSQRT2, // 7-6

224

INVSQRT2, 0, INVSQRT2, // 6-5

225

0, -INVSQRT2, INVSQRT2, // 5-4

226

-INVSQRT2, 0, INVSQRT2, // 4-7

227

228

INVSQRT2, -INVSQRT2, 0, // 1-5

229

INVSQRT2, INVSQRT2, 0, // 6-2

230

-INVSQRT2, INVSQRT2, 0, // 3-7

231

-INVSQRT2, -INVSQRT2, 0 // 4-0

232

};

233

return (const Point*)EdgeNormals;

234

}

235

236

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

237

/**

238

* Returns world edge normal

239

* \param edge_index [in] 0 <= edge index < 12

240

* \param world_normal [out] edge normal in world space

241

242

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

243

void OBB::ComputeWorldEdgeNormal(udword edge_index, Point& world_normal) const

244

{

245

ASSERT(edge_index<12);

246

world_normal = GetLocalEdgeNormals()[edge_index] * mRot;

247

}

248

249

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

250

/**

251

* Computes an LSS surrounding the OBB.

252

* \param lss [out] the LSS

253

254

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

255

void OBB::ComputeLSS(LSS& lss) const

256

{

257

Point Axis0 = mRot[0];

258

Point Axis1 = mRot[1];

259

Point Axis2 = mRot[2];

260

261

switch(mExtents.LargestAxis())

262

{

263

case 0:

264

lss.mRadius = (mExtents.y + mExtents.z)*0.5f;

265

lss.mP0 = mCenter + Axis0 * (mExtents.x - lss.mRadius);

266

lss.mP1 = mCenter - Axis0 * (mExtents.x - lss.mRadius);

267

break;

268

case 1:

269

lss.mRadius = (mExtents.x + mExtents.z)*0.5f;

270

lss.mP0 = mCenter + Axis1 * (mExtents.y - lss.mRadius);

271

lss.mP1 = mCenter - Axis1 * (mExtents.y - lss.mRadius);

272

break;

273

case 2:

274

lss.mRadius = (mExtents.x + mExtents.y)*0.5f;

275

lss.mP0 = mCenter + Axis2 * (mExtents.z - lss.mRadius);

276

lss.mP1 = mCenter - Axis2 * (mExtents.z - lss.mRadius);

277

break;

278

}

279

}

280

281

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

282

/**

283

* Checks the OBB is inside another OBB.

284

* \param box [in] the other OBB

285

* \return TRUE if we're inside the other box

286

287

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

288

BOOL OBB::IsInside(const OBB& box) const

289

{

290

// Make a 4x4 from the box & inverse it

291

Matrix4x4 M0Inv;

292

{

293

Matrix4x4 M0 = box.mRot;

294

M0.SetTrans(box.mCenter);

295

InvertPRMatrix(M0Inv, M0);

296

}

297

298

// With our inversed 4x4, create box1 in space of box0

299

OBB _1in0;

300

Rotate(M0Inv, _1in0);

301

302

// This should cancel out box0's rotation, i.e. it's now an AABB.

303

// => Center(0,0,0), Rot(identity)

304

305

// The two boxes are in the same space so now we can compare them.

306

307

// Create the AABB of (box1 in space of box0)

308

const Matrix3x3& mtx = _1in0.mRot;

309

310

float f = fabsf(mtx.m[0][0] * mExtents.x) + fabsf(mtx.m[1][0] * mExtents.y) + fabsf(mtx.m[2][0] * mExtents.z) - box.mExtents.x;

311

if(f > _1in0.mCenter.x) return FALSE;

312

if(-f < _1in0.mCenter.x) return FALSE;

313

314

f = fabsf(mtx.m[0][1] * mExtents.x) + fabsf(mtx.m[1][1] * mExtents.y) + fabsf(mtx.m[2][1] * mExtents.z) - box.mExtents.y;

315

if(f > _1in0.mCenter.y) return FALSE;

316

if(-f < _1in0.mCenter.y) return FALSE;

317

318

f = fabsf(mtx.m[0][2] * mExtents.x) + fabsf(mtx.m[1][2] * mExtents.y) + fabsf(mtx.m[2][2] * mExtents.z) - box.mExtents.z;

319

if(f > _1in0.mCenter.z) return FALSE;

320

if(-f < _1in0.mCenter.z) return FALSE;

321

322

return TRUE;

323

}

Older »