A reimplementation of Mario Kart Wii's physics engine in C++
Loading...
Searching...
No Matches
ObjColMgr.cc
1#include "ObjColMgr.hh"
2
3#include "game/field/CourseColMgr.hh"
4
5namespace Field {
6
8ObjColMgr::ObjColMgr(const void *file)
9 : m_mtx(EGG::Matrix34f::ident), m_mtxInv(EGG::Matrix34f::ident), m_kclScale(1.0f) {
10 m_data = new KColData(file);
11}
12
14ObjColMgr::~ObjColMgr() {
15 ASSERT(m_data);
16 delete m_data;
17}
18
20void ObjColMgr::narrScLocal(f32 radius, const EGG::Vector3f &pos, KCLTypeMask flags) {
21 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
22 CourseColMgr::Instance()->scaledNarrowScopeLocal(m_kclScale, radius, m_data, posWrtModel,
23 flags);
24}
25
27EGG::Vector3f ObjColMgr::kclLowWorld() const {
28 EGG::Vector3f posLocal = m_data->bbox().min * m_kclScale;
29 return m_mtx.ps_multVector(posLocal);
30}
31
33EGG::Vector3f ObjColMgr::kclHighWorld() const {
34 EGG::Vector3f posLocal = m_data->bbox().max * m_kclScale;
35 return m_mtx.ps_multVector(posLocal);
36}
37
39bool ObjColMgr::checkPointPartial(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
40 KCLTypeMask flags, CollisionInfoPartial *info, KCLTypeMask *typeMaskOut) {
41 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
42 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
43 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
44 auto *courseColMgr = CourseColMgr::Instance();
45
46 if (info) {
47 CollisionInfoPartial tempInfo;
48 tempInfo.bbox.setZero();
49
50 if (courseColMgr->noBounceWallInfo()) {
51 courseColMgr->setLocalMtx(&m_mtx);
52 }
53
54 if (courseColMgr->checkPointPartial(m_kclScale, m_data, posWrtModel, prevPosWrtModel, flags,
55 &tempInfo, typeMaskOut)) {
56 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
57 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
58
59 EGG::Vector3f min = tempInfo.bbox.min;
60 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
61 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
62
63 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
64 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
65
66 return true;
67 }
68
69 return false;
70 }
71
72 return courseColMgr->checkPointPartial(m_kclScale, m_data, posWrtModel, prevPosWrtModel, flags,
73 info, typeMaskOut);
74}
75
77bool ObjColMgr::checkPointPartialPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
78 KCLTypeMask flags, CollisionInfoPartial *info, KCLTypeMask *typeMaskOut) {
79 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
80 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
81 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
82 auto *courseColMgr = CourseColMgr::Instance();
83
84 if (info) {
85 CollisionInfoPartial tempInfo;
86 tempInfo.bbox.setZero();
87
88 if (courseColMgr->noBounceWallInfo()) {
89 courseColMgr->setLocalMtx(&m_mtx);
90 }
91
92 if (courseColMgr->checkPointPartialPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
93 flags, &tempInfo, typeMaskOut)) {
94 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
95 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
96
97 EGG::Vector3f min = tempInfo.bbox.min;
98 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
99 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
100
101 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
102 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
103
104 return true;
105 }
106
107 return false;
108 }
109
110 return courseColMgr->checkPointPartialPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
111 flags, info, typeMaskOut);
112}
113
115bool ObjColMgr::checkPointFull(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
116 KCLTypeMask flags, CollisionInfo *info, KCLTypeMask *typeMaskOut) {
117 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
118 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
119 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
120 auto *courseColMgr = CourseColMgr::Instance();
121
122 if (info) {
123 CollisionInfo tempInfo;
124 tempInfo.reset();
125
126 if (courseColMgr->noBounceWallInfo()) {
127 courseColMgr->setLocalMtx(&m_mtx);
128 }
129
130 if (courseColMgr->checkPointFull(m_kclScale, m_data, posWrtModel, prevPosWrtModel, flags,
131 &tempInfo, typeMaskOut)) {
132 info->transformInfo(tempInfo, m_mtx);
133
134 return true;
135 }
136
137 return false;
138 }
139
140 return courseColMgr->checkPointFull(m_kclScale, m_data, posWrtModel, prevPosWrtModel, flags,
141 info, typeMaskOut);
142}
143
145bool ObjColMgr::checkPointFullPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
146 KCLTypeMask flags, CollisionInfo *info, KCLTypeMask *typeMaskOut) {
147 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
148 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
149 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
150 auto *courseColMgr = CourseColMgr::Instance();
151
152 if (info) {
153 CollisionInfo tempInfo;
154 tempInfo.reset();
155
156 if (courseColMgr->noBounceWallInfo()) {
157 courseColMgr->setLocalMtx(&m_mtx);
158 }
159
160 if (courseColMgr->checkPointFullPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
161 flags, &tempInfo, typeMaskOut)) {
162 info->transformInfo(tempInfo, m_mtx);
163
164 return true;
165 }
166
167 return false;
168 }
169
170 return courseColMgr->checkPointFullPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel, flags,
171 info, typeMaskOut);
172}
173
175bool ObjColMgr::checkSpherePartial(f32 radius, const EGG::Vector3f &pos,
176 const EGG::Vector3f &prevPos, KCLTypeMask flags, CollisionInfoPartial *info,
177 KCLTypeMask *typeMaskOut) {
178 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
179 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
180 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
181 auto *courseColMgr = CourseColMgr::Instance();
182
183 if (info) {
184 CollisionInfoPartial tempInfo;
185 tempInfo.bbox.setZero();
186
187 if (courseColMgr->noBounceWallInfo()) {
188 courseColMgr->setLocalMtx(&m_mtx);
189 }
190
191 if (courseColMgr->checkSpherePartial(m_kclScale, radius, m_data, posWrtModel,
192 prevPosWrtModel, flags, &tempInfo, typeMaskOut)) {
193 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
194 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
195
196 EGG::Vector3f min = tempInfo.bbox.min;
197 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
198 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
199
200 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
201 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
202
203 return true;
204 }
205
206 return false;
207 }
208
209 return courseColMgr->checkSpherePartial(m_kclScale, radius, m_data, posWrtModel,
210 prevPosWrtModel, flags, info, typeMaskOut);
211}
212
214bool ObjColMgr::checkSpherePartialPush(f32 radius, const EGG::Vector3f &pos,
215 const EGG::Vector3f &prevPos, KCLTypeMask flags, CollisionInfoPartial *info,
216 KCLTypeMask *typeMaskOut) {
217 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
218 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
219 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
220 auto *courseColMgr = CourseColMgr::Instance();
221
222 if (info) {
223 CollisionInfoPartial tempInfo;
224 tempInfo.bbox.setZero();
225
226 if (courseColMgr->noBounceWallInfo()) {
227 courseColMgr->setLocalMtx(&m_mtx);
228 }
229
230 if (courseColMgr->checkSpherePartialPush(m_kclScale, radius, m_data, posWrtModel,
231 prevPosWrtModel, flags, &tempInfo, typeMaskOut)) {
232 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
233 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
234
235 EGG::Vector3f min = tempInfo.bbox.min;
236 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
237 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
238
239 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
240 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
241
242 return true;
243 }
244
245 return false;
246 }
247
248 return courseColMgr->checkSpherePartialPush(m_kclScale, radius, m_data, posWrtModel,
249 prevPosWrtModel, flags, info, typeMaskOut);
250}
251
253bool ObjColMgr::checkSphereFull(f32 radius, const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
254 KCLTypeMask flags, CollisionInfo *info, KCLTypeMask *typeMaskOut) {
255 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
256 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
257 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
258 auto *courseColMgr = CourseColMgr::Instance();
259
260 if (info) {
261 CollisionInfo tempInfo;
262 tempInfo.reset();
263
264 if (courseColMgr->noBounceWallInfo()) {
265 courseColMgr->setLocalMtx(&m_mtx);
266 }
267
268 if (courseColMgr->checkSphereFull(m_kclScale, radius, m_data, posWrtModel, prevPosWrtModel,
269 flags, &tempInfo, typeMaskOut)) {
270 info->transformInfo(tempInfo, m_mtx);
271
272 return true;
273 }
274
275 return false;
276 }
277
278 return courseColMgr->checkSphereFull(m_kclScale, radius, m_data, posWrtModel, prevPosWrtModel,
279 flags, info, typeMaskOut);
280}
281
283bool ObjColMgr::checkSphereFullPush(f32 radius, const EGG::Vector3f &pos,
284 const EGG::Vector3f &prevPos, KCLTypeMask flags, CollisionInfo *info,
285 KCLTypeMask *typeMaskOut) {
286 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
287 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
288 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
289 auto *courseColMgr = CourseColMgr::Instance();
290
291 if (info) {
292 CollisionInfo tempInfo;
293 tempInfo.reset();
294
295 if (courseColMgr->noBounceWallInfo()) {
296 courseColMgr->setLocalMtx(&m_mtx);
297 }
298
299 if (courseColMgr->checkSphereFullPush(m_kclScale, radius, m_data, posWrtModel,
300 prevPosWrtModel, flags, &tempInfo, typeMaskOut)) {
301 info->transformInfo(tempInfo, m_mtx);
302
303 return true;
304 }
305
306 return false;
307 }
308
309 return courseColMgr->checkSphereFullPush(m_kclScale, radius, m_data, posWrtModel,
310 prevPosWrtModel, flags, info, typeMaskOut);
311}
312
314bool ObjColMgr::checkPointCachedPartial(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
315 KCLTypeMask flags, CollisionInfoPartial *info, KCLTypeMask *typeMaskOut) {
316 if (m_data->prismCache(0) == 0) {
317 return false;
318 }
319
320 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
321 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
322 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
323 auto *courseColMgr = CourseColMgr::Instance();
324
325 if (info) {
326 CollisionInfoPartial tempInfo;
327 tempInfo.bbox.setZero();
328
329 if (courseColMgr->noBounceWallInfo()) {
330 courseColMgr->setLocalMtx(&m_mtx);
331 }
332
333 if (courseColMgr->checkPointCachedPartial(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
334 flags, &tempInfo, typeMaskOut)) {
335 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
336 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
337
338 EGG::Vector3f min = tempInfo.bbox.min;
339 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
340 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
341
342 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
343 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
344
345 return true;
346 }
347
348 return false;
349 }
350
351 return courseColMgr->checkPointCachedPartial(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
352 flags, info, typeMaskOut);
353}
354
356bool ObjColMgr::checkPointCachedPartialPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
357 KCLTypeMask flags, CollisionInfoPartial *info, KCLTypeMask *typeMaskOut) {
358 if (m_data->prismCache(0) == 0) {
359 return false;
360 }
361
362 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
363 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
364 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
365 auto *courseColMgr = CourseColMgr::Instance();
366
367 if (info) {
368 CollisionInfoPartial tempInfo;
369 tempInfo.bbox.setZero();
370
371 if (courseColMgr->noBounceWallInfo()) {
372 courseColMgr->setLocalMtx(&m_mtx);
373 }
374
375 if (courseColMgr->checkPointCachedPartialPush(m_kclScale, m_data, posWrtModel,
376 prevPosWrtModel, flags, &tempInfo, typeMaskOut)) {
377 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
378 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
379
380 EGG::Vector3f min = tempInfo.bbox.min;
381 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
382 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
383
384 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
385 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
386
387 return true;
388 }
389
390 return false;
391 }
392
393 return courseColMgr->checkPointCachedPartialPush(m_kclScale, m_data, posWrtModel,
394 prevPosWrtModel, flags, info, typeMaskOut);
395}
396
398bool ObjColMgr::checkPointCachedFull(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
399 KCLTypeMask flags, CollisionInfo *info, KCLTypeMask *typeMaskOut) {
400 if (m_data->prismCache(0) == 0) {
401 return false;
402 }
403
404 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
405 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
406 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
407 auto *courseColMgr = CourseColMgr::Instance();
408
409 if (info) {
410 CollisionInfo tempInfo;
411 tempInfo.reset();
412
413 if (courseColMgr->noBounceWallInfo()) {
414 courseColMgr->setLocalMtx(&m_mtx);
415 }
416
417 if (courseColMgr->checkPointCachedFull(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
418 flags, &tempInfo, typeMaskOut)) {
419 info->transformInfo(tempInfo, m_mtx);
420
421 return true;
422 }
423
424 return false;
425 }
426
427 return courseColMgr->checkPointCachedFull(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
428 flags, info, typeMaskOut);
429}
430
432bool ObjColMgr::checkPointCachedFullPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
433 KCLTypeMask flags, CollisionInfo *info, KCLTypeMask *typeMaskOut) {
434 if (m_data->prismCache(0) == 0) {
435 return false;
436 }
437
438 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
439 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
440 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
441 auto *courseColMgr = CourseColMgr::Instance();
442
443 if (info) {
444 CollisionInfo tempInfo;
445 tempInfo.reset();
446
447 if (courseColMgr->noBounceWallInfo()) {
448 courseColMgr->setLocalMtx(&m_mtx);
449 }
450
451 if (courseColMgr->checkPointCachedFullPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
452 flags, &tempInfo, typeMaskOut)) {
453 info->transformInfo(tempInfo, m_mtx);
454
455 return true;
456 }
457
458 return false;
459 }
460
461 return courseColMgr->checkPointCachedFullPush(m_kclScale, m_data, posWrtModel, prevPosWrtModel,
462 flags, info, typeMaskOut);
463}
464
466bool ObjColMgr::checkSphereCachedPartial(f32 radius, const EGG::Vector3f &pos,
467 const EGG::Vector3f &prevPos, KCLTypeMask typeflags, CollisionInfoPartial *info,
468 KCLTypeMask *typeMaskOut) {
469 if (m_data->prismCache(0) == 0) {
470 return false;
471 }
472
473 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
474 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
475 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
476 auto *courseColMgr = CourseColMgr::Instance();
477
478 if (info) {
479 CollisionInfoPartial tempInfo;
480 tempInfo.bbox.setZero();
481
482 if (courseColMgr->noBounceWallInfo()) {
483 courseColMgr->setLocalMtx(&m_mtx);
484 }
485
486 if (courseColMgr->checkSphereCachedPartial(m_kclScale, radius, m_data, posWrtModel,
487 prevPosWrtModel, typeflags, &tempInfo, typeMaskOut)) {
488 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
489 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
490
491 EGG::Vector3f min = tempInfo.bbox.min;
492 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
493 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
494
495 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
496 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
497
498 return true;
499 }
500
501 return false;
502 }
503
504 return courseColMgr->checkSphereCachedPartial(m_kclScale, radius, m_data, posWrtModel,
505 prevPosWrtModel, typeflags, info, typeMaskOut);
506}
507
509bool ObjColMgr::checkSphereCachedPartialPush(f32 radius, const EGG::Vector3f &pos,
510 const EGG::Vector3f &prevPos, KCLTypeMask typeflags, CollisionInfoPartial *info,
511 KCLTypeMask *typeMaskOut) {
512 if (m_data->prismCache(0) == 0) {
513 return false;
514 }
515
516 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
517 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
518 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
519 auto *courseColMgr = CourseColMgr::Instance();
520
521 if (info) {
522 CollisionInfoPartial tempInfo;
523 tempInfo.bbox.setZero();
524
525 if (courseColMgr->noBounceWallInfo()) {
526 courseColMgr->setLocalMtx(&m_mtx);
527 }
528
529 if (courseColMgr->checkSphereCachedPartialPush(m_kclScale, radius, m_data, posWrtModel,
530 prevPosWrtModel, typeflags, &tempInfo, typeMaskOut)) {
531 tempInfo.bbox.min = m_mtx.ps_multVector33(tempInfo.bbox.min);
532 tempInfo.bbox.max = m_mtx.ps_multVector33(tempInfo.bbox.max);
533
534 EGG::Vector3f min = tempInfo.bbox.min;
535 tempInfo.bbox.min = min.minimize(tempInfo.bbox.max);
536 tempInfo.bbox.max = min.maximize(tempInfo.bbox.max);
537
538 info->bbox.min = info->bbox.min.minimize(tempInfo.bbox.min);
539 info->bbox.max = info->bbox.max.maximize(tempInfo.bbox.max);
540
541 return true;
542 }
543
544 return false;
545 }
546
547 return courseColMgr->checkSphereCachedPartialPush(m_kclScale, radius, m_data, posWrtModel,
548 prevPosWrtModel, typeflags, info, typeMaskOut);
549}
550
552bool ObjColMgr::checkSphereCachedFull(f32 radius, const EGG::Vector3f &pos,
553 const EGG::Vector3f &prevPos, KCLTypeMask typeflags, CollisionInfo *info,
554 KCLTypeMask *typeMaskOut) {
555 if (m_data->prismCache(0) == 0) {
556 return false;
557 }
558
559 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
560 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
561 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
562 auto *courseColMgr = CourseColMgr::Instance();
563
564 if (info) {
565 CollisionInfo tempInfo;
566 tempInfo.reset();
567
568 if (courseColMgr->noBounceWallInfo()) {
569 courseColMgr->setLocalMtx(&m_mtx);
570 }
571
572 if (courseColMgr->checkSphereCachedFull(m_kclScale, radius, m_data, posWrtModel,
573 prevPosWrtModel, typeflags, &tempInfo, typeMaskOut)) {
574 info->transformInfo(tempInfo, m_mtx);
575
576 return true;
577 }
578
579 return false;
580 }
581
582 return courseColMgr->checkSphereCachedFull(m_kclScale, radius, m_data, posWrtModel,
583 prevPosWrtModel, typeflags, info, typeMaskOut);
584}
585
587bool ObjColMgr::checkSphereCachedFullPush(f32 radius, const EGG::Vector3f &pos,
588 const EGG::Vector3f &prevPos, KCLTypeMask typeflags, CollisionInfo *info,
589 KCLTypeMask *typeMaskOut) {
590 if (m_data->prismCache(0) == 0) {
591 return false;
592 }
593
594 EGG::Vector3f posWrtModel = m_mtxInv.ps_multVector(pos);
595 bool hasPrevY = prevPos.y != std::numeric_limits<f32>::infinity();
596 EGG::Vector3f prevPosWrtModel = hasPrevY ? m_mtxInv.ps_multVector(prevPos) : EGG::Vector3f::inf;
597 auto *courseColMgr = CourseColMgr::Instance();
598
599 if (info) {
600 CollisionInfo tempInfo;
601 tempInfo.reset();
602
603 if (courseColMgr->noBounceWallInfo()) {
604 courseColMgr->setLocalMtx(&m_mtx);
605 }
606
607 if (courseColMgr->checkSphereCachedFullPush(m_kclScale, radius, m_data, posWrtModel,
608 prevPosWrtModel, typeflags, &tempInfo, typeMaskOut)) {
609 info->transformInfo(tempInfo, m_mtx);
610
611 return true;
612 }
613
614 return false;
615 }
616
617 return courseColMgr->checkSphereCachedFullPush(m_kclScale, radius, m_data, posWrtModel,
618 prevPosWrtModel, typeflags, info, typeMaskOut);
619}
620
621} // namespace Field
EGG
EGG core library.
Definition Archive.cc:6
Field
Pertains to collision.
Definition BoxColManager.cc:8
EGG::Vector3f
A 3D float vector.
Definition Vector.hh:83
EGG::Vector3f::maximize
Vector3f maximize(const Vector3f &rhs) const
Returns a vector whose elements are the max of the elements of both vectors.
Definition Vector.cc:65
EGG::Vector3f::minimize
Vector3f minimize(const Vector3f &rhs) const
Returns a vector whose elements are the min of the elements of both vectors.
Definition Vector.cc:77