A reimplementation of Mario Kart Wii's physics engine in C++
Loading...
Searching...
No Matches
CourseColMgr.cc
1#include "CourseColMgr.hh"
2
3#include "game/field/CollisionDirector.hh"
4
5#include "game/system/ResourceManager.hh"
6
7// Credit: em-eight/mkw
8
9namespace Field {
10
12void CourseColMgr::init() {
13 // In the base game, this file is loaded in CollisionDirector::CreateInstance and passed into
14 // this function. It's simpler to just keep it here.
15 void *file = LoadFile("course.kcl");
16 m_data = new KColData(file);
17}
18
20void CourseColMgr::scaledNarrowScopeLocal(f32 scale, f32 radius, KColData *data,
21 const EGG::Vector3f &pos, KCLTypeMask mask) {
22 if (!data) {
23 data = m_data;
24 }
25
26 data->narrowScopeLocal(pos / scale, radius / scale, mask);
27}
28
30bool CourseColMgr::checkPointPartial(f32 scale, KColData *data, const EGG::Vector3f &v0,
31 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfoPartial *info,
32 KCLTypeMask *maskOut) {
33 if (!data) {
34 data = m_data;
35 }
36
37 m_kclScale = scale;
38
39 data->lookupPoint(v0 / scale, v1 / scale, mask);
40
41 if (info) {
42 return doCheckWithPartialInfo(data, &KColData::checkPointCollision, info, maskOut);
43 }
44
45 return doCheckMaskOnly(data, &KColData::checkPointCollision, maskOut);
46}
47
49bool CourseColMgr::checkPointPartialPush(f32 scale, KColData *data, const EGG::Vector3f &v0,
50 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfoPartial *info,
51 KCLTypeMask *maskOut) {
52 if (!data) {
53 data = m_data;
54 }
55
56 m_kclScale = scale;
57
58 data->lookupPoint(v0 / scale, v1 / scale, mask);
59
60 if (info) {
61 return doCheckWithPartialInfoPush(data, &KColData::checkPointCollision, info, maskOut);
62 }
63 return doCheckMaskOnlyPush(data, &KColData::checkPointCollision, maskOut);
64}
65
67bool CourseColMgr::checkPointFull(f32 scale, KColData *data, const EGG::Vector3f &v0,
68 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *info, KCLTypeMask *maskOut) {
69 if (!data) {
70 data = m_data;
71 }
72
73 m_kclScale = scale;
74
75 data->lookupPoint(v0 / scale, v1 / scale, mask);
76
77 if (info) {
78 return doCheckWithFullInfo(data, &KColData::checkPointCollision, info, maskOut);
79 }
80 return doCheckMaskOnly(data, &KColData::checkPointCollision, maskOut);
81}
82
84bool CourseColMgr::checkPointFullPush(f32 scale, KColData *data, const EGG::Vector3f &v0,
85 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *info, KCLTypeMask *maskOut) {
86 if (!data) {
87 data = m_data;
88 }
89
90 m_kclScale = scale;
91
92 data->lookupPoint(v0 / scale, v1 / scale, mask);
93
94 if (info) {
95 return doCheckWithFullInfoPush(data, &KColData::checkPointCollision, info, maskOut);
96 }
97 return doCheckMaskOnlyPush(data, &KColData::checkPointCollision, maskOut);
98}
99
101bool CourseColMgr::checkSpherePartial(f32 scale, f32 radius, KColData *data,
102 const EGG::Vector3f &v0, const EGG::Vector3f &v1, KCLTypeMask mask,
103 CollisionInfoPartial *info, KCLTypeMask *maskOut) {
104 if (!data) {
105 data = m_data;
106 }
107
108 m_kclScale = scale;
109
110 data->lookupSphere(radius, v0 / scale, v1 / scale, mask);
111
112 if (info) {
113 return doCheckWithPartialInfo(data, &KColData::checkSphereCollision, info, maskOut);
114 }
115 return doCheckMaskOnly(data, &KColData::checkSphereCollision, maskOut);
116}
117
119bool CourseColMgr::checkSpherePartialPush(f32 scale, f32 radius, KColData *data,
120 const EGG::Vector3f &v0, const EGG::Vector3f &v1, KCLTypeMask mask,
121 CollisionInfoPartial *info, KCLTypeMask *maskOut) {
122 if (!data) {
123 data = m_data;
124 }
125
126 m_kclScale = scale;
127
128 data->lookupSphere(radius, v0 / scale, v1 / scale, mask);
129
130 if (info) {
131 return doCheckWithPartialInfoPush(data, &KColData::checkSphereCollision, info, maskOut);
132 }
133 return doCheckMaskOnlyPush(data, &KColData::checkSphereCollision, maskOut);
134}
135
137bool CourseColMgr::checkSphereFull(f32 scalar, f32 radius, KColData *data, const EGG::Vector3f &v0,
138 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *info, KCLTypeMask *maskOut) {
139 if (!data) {
140 data = m_data;
141 }
142
143 m_kclScale = scalar;
144
145 data->lookupSphere(radius, v0 / scalar, v1 / scalar, mask);
146
147 if (info) {
148 return doCheckWithFullInfo(data, &KColData::checkSphereCollision, info, maskOut);
149 }
150 return doCheckMaskOnly(data, &KColData::checkSphereCollision, maskOut);
151}
152
154bool CourseColMgr::checkSphereFullPush(f32 scalar, f32 radius, KColData *data,
155 const EGG::Vector3f &v0, const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *info,
156 KCLTypeMask *maskOut) {
157 if (!data) {
158 data = m_data;
159 }
160
161 m_kclScale = scalar;
162
163 data->lookupSphere(radius, v0 / scalar, v1 / scalar, mask);
164
165 if (info) {
166 return doCheckWithFullInfoPush(data, &KColData::checkSphereCollision, info, maskOut);
167 }
168 return doCheckMaskOnlyPush(data, &KColData::checkSphereCollision, maskOut);
169}
170
172bool CourseColMgr::checkPointCachedPartial(f32 scale, KColData *data, const EGG::Vector3f &v0,
173 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfoPartial *info,
174 KCLTypeMask *maskOut) {
175 if (!data) {
176 data = m_data;
177 }
178
179 m_kclScale = scale;
180
181 data->lookupPoint(v0 / scale, v1 / scale, mask);
182
183 if (info) {
184 return doCheckWithPartialInfo(data, &KColData::checkPointCollision, info, maskOut);
185 }
186 return doCheckMaskOnly(data, &KColData::checkPointCollision, maskOut);
187}
188
190bool CourseColMgr::checkPointCachedPartialPush(f32 scale, KColData *data, const EGG::Vector3f &v0,
191 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfoPartial *info,
192 KCLTypeMask *maskOut) {
193 if (!data) {
194 data = m_data;
195 }
196
197 if (data->prismCache(0) == 0) {
198 return false;
199 }
200
201 m_kclScale = scale;
202
203 data->lookupPoint(v0 / scale, v1 / scale, mask);
204
205 if (info) {
206 return doCheckWithPartialInfoPush(data, &KColData::checkPointCollision, info, maskOut);
207 }
208 return doCheckMaskOnlyPush(data, &KColData::checkPointCollision, maskOut);
209}
210
212bool CourseColMgr::checkPointCachedFull(f32 scale, KColData *data, const EGG::Vector3f &v0,
213 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *pInfo, KCLTypeMask *maskOut) {
214 if (!data) {
215 data = m_data;
216 }
217
218 if (data->prismCache(0) == 0) {
219 return false;
220 }
221
222 m_kclScale = scale;
223
224 data->lookupPoint(v0 / scale, v1 / scale, mask);
225
226 if (pInfo) {
227 return doCheckWithFullInfo(data, &KColData::checkPointCollision, pInfo, maskOut);
228 }
229 return doCheckMaskOnly(data, &KColData::checkPointCollision, maskOut);
230}
231
233bool CourseColMgr::checkPointCachedFullPush(f32 scale, KColData *data, const EGG::Vector3f &v0,
234 const EGG::Vector3f &v1, KCLTypeMask mask, CollisionInfo *pInfo, KCLTypeMask *maskOut) {
235 if (!data) {
236 data = m_data;
237 }
238
239 if (data->prismCache(0) == 0) {
240 return false;
241 }
242
243 m_kclScale = scale;
244
245 data->lookupPoint(v0 / scale, v1 / scale, mask);
246
247 if (pInfo) {
248 return doCheckWithFullInfoPush(data, &KColData::checkPointCollision, pInfo, maskOut);
249 }
250 return doCheckMaskOnlyPush(data, &KColData::checkPointCollision, maskOut);
251}
252
254bool CourseColMgr::checkSphereCachedPartial(f32 scale, f32 radius, KColData *data,
255 const EGG::Vector3f &pos, const EGG::Vector3f &prevPos, KCLTypeMask mask,
256 CollisionInfoPartial *info, KCLTypeMask *maskOut) {
257 if (!data) {
258 data = m_data;
259 }
260
261 if (data->prismCache(0) == 0) {
262 return false;
263 }
264
265 m_kclScale = scale;
266
267 data->lookupSphereCached(pos / scale, prevPos / scale, mask, radius / scale);
268
269 if (info) {
270 return doCheckWithPartialInfo(data, &KColData::checkSphereCollision, info, maskOut);
271 }
272
273 return doCheckMaskOnly(data, &KColData::checkSphereCollision, maskOut);
274}
275
277bool CourseColMgr::checkSphereCachedPartialPush(f32 scale, f32 radius, KColData *data,
278 const EGG::Vector3f &pos, const EGG::Vector3f &prevPos, KCLTypeMask mask,
279 CollisionInfoPartial *info, KCLTypeMask *maskOut) {
280 if (!data) {
281 data = m_data;
282 }
283
284 if (data->prismCache(0) == 0) {
285 return false;
286 }
287
288 m_kclScale = scale;
289
290 data->lookupSphereCached(pos / scale, prevPos / scale, mask, radius / scale);
291
292 if (info) {
293 return doCheckWithPartialInfoPush(data, &KColData::checkSphereCollision, info, maskOut);
294 }
295
296 return doCheckMaskOnlyPush(data, &KColData::checkSphereCollision, maskOut);
297}
298
300bool CourseColMgr::checkSphereCachedFull(f32 scale, f32 radius, KColData *data,
301 const EGG::Vector3f &pos, const EGG::Vector3f &prevPos, KCLTypeMask mask,
302 CollisionInfo *pInfo, KCLTypeMask *maskOut) {
303 if (!data) {
304 data = m_data;
305 }
306
307 if (data->prismCache(0) == 0) {
308 return false;
309 }
310
311 m_kclScale = scale;
312
313 data->lookupSphereCached(pos / scale, prevPos / scale, mask, radius / scale);
314
315 if (pInfo) {
316 return doCheckWithFullInfo(data, &KColData::checkSphereCollision, pInfo, maskOut);
317 }
318
319 return doCheckMaskOnly(data, &KColData::checkSphereCollision, maskOut);
320}
321
323bool CourseColMgr::checkSphereCachedFullPush(f32 scale, f32 radius, KColData *data,
324 const EGG::Vector3f &pos, const EGG::Vector3f &prevPos, KCLTypeMask mask,
325 CollisionInfo *colInfo, KCLTypeMask *maskOut) {
326 if (!data) {
327 data = m_data;
328 }
329
330 if (data->prismCache(0) == 0) {
331 return false;
332 }
333
334 m_kclScale = scale;
335
336 data->lookupSphereCached(pos / scale, prevPos / scale, mask, radius / scale);
337
338 if (colInfo) {
339 return doCheckWithFullInfoPush(data, &KColData::checkSphereCollision, colInfo, maskOut);
340 }
341
342 return doCheckMaskOnlyPush(data, &KColData::checkSphereCollision, maskOut);
343}
344
346void *CourseColMgr::LoadFile(const char *filename) {
347 auto *resMgr = System::ResourceManager::Instance();
348 return resMgr->getFile(filename, nullptr, System::ArchiveId::Course);
349}
350
352CourseColMgr *CourseColMgr::CreateInstance() {
353 ASSERT(!s_instance);
354 s_instance = new CourseColMgr;
355 return s_instance;
356}
357
359void CourseColMgr::DestroyInstance() {
360 ASSERT(s_instance);
361 auto *instance = s_instance;
362 s_instance = nullptr;
363 delete instance;
364}
365
367CourseColMgr::CourseColMgr()
368 : m_data(nullptr), m_kclScale(1.0f), m_noBounceWallInfo(nullptr), m_localMtx(nullptr) {}
369
371CourseColMgr::~CourseColMgr() {
372 if (s_instance) {
373 s_instance = nullptr;
374 WARN("CourseColMgr instance not explicitly handled!");
375 }
376
377 ASSERT(m_data);
378 delete m_data;
379}
380
382bool CourseColMgr::doCheckWithPartialInfo(KColData *data, CollisionCheckFunc collisionCheckFunc,
383 CollisionInfoPartial *info, KCLTypeMask *typeMask) {
384 f32 dist;
385 EGG::Vector3f fnrm;
386 u16 attribute;
387 bool hasCol = false;
388
389 while ((data->*collisionCheckFunc)(&dist, &fnrm, &attribute)) {
390 hasCol = true;
391 dist *= m_kclScale;
392
393 if (m_noBounceWallInfo && (attribute & KCL_SOFT_WALL_MASK)) {
394 if (m_localMtx) {
395 fnrm = m_localMtx->multVector33(fnrm);
396 }
397 EGG::Vector3f offset = fnrm * dist;
398 m_noBounceWallInfo->bbox.min = m_noBounceWallInfo->bbox.min.minimize(offset);
399 m_noBounceWallInfo->bbox.max = m_noBounceWallInfo->bbox.max.maximize(offset);
400 if (m_noBounceWallInfo->dist < dist) {
401 m_noBounceWallInfo->dist = dist;
402 m_noBounceWallInfo->fnrm = fnrm;
403 }
404 } else {
405 u32 flags = KCL_ATTRIBUTE_TYPE_BIT(attribute);
406 if (typeMask) {
407 *typeMask = *typeMask | flags;
408 }
409 if (flags & KCL_TYPE_SOLID_SURFACE) {
410 EGG::Vector3f offset = fnrm * dist;
411 info->bbox.min = info->bbox.min.minimize(offset);
412 info->bbox.max = info->bbox.max.maximize(offset);
413 }
414 }
415 }
416
417 m_localMtx = nullptr;
418
419 return hasCol;
420}
421
423bool CourseColMgr::doCheckWithPartialInfoPush(KColData *data, CollisionCheckFunc collisionCheckFunc,
424 CollisionInfoPartial *info, KCLTypeMask *typeMask) {
425 f32 dist;
426 EGG::Vector3f fnrm;
427 u16 attribute;
428 bool hasCol = false;
429
430 while ((data->*collisionCheckFunc)(&dist, &fnrm, &attribute)) {
431 hasCol = true;
432 dist *= m_kclScale;
433
434 if (!m_noBounceWallInfo || !(attribute & KCL_SOFT_WALL_MASK)) {
435 u32 flags = KCL_ATTRIBUTE_TYPE_BIT(attribute);
436 if (typeMask) {
437 CollisionDirector::Instance()->pushCollisionEntry(dist, typeMask, flags, attribute);
438 }
439 if (flags & KCL_TYPE_SOLID_SURFACE) {
440 EGG::Vector3f offset = fnrm * dist;
441 info->bbox.min = info->bbox.min.minimize(offset);
442 info->bbox.max = info->bbox.max.maximize(offset);
443 }
444 } else {
445 if (m_localMtx) {
446 fnrm = m_localMtx->multVector33(fnrm);
447 }
448 EGG::Vector3f offset = fnrm * dist;
449 m_noBounceWallInfo->bbox.min = m_noBounceWallInfo->bbox.min.minimize(offset);
450 m_noBounceWallInfo->bbox.max = m_noBounceWallInfo->bbox.max.maximize(offset);
451 if (m_noBounceWallInfo->dist < dist) {
452 m_noBounceWallInfo->dist = dist;
453 m_noBounceWallInfo->fnrm = fnrm;
454 }
455 }
456 }
457
458 m_localMtx = nullptr;
459
460 return hasCol;
461}
462
464bool CourseColMgr::doCheckWithFullInfo(KColData *data, CollisionCheckFunc collisionCheckFunc,
465 CollisionInfo *colInfo, KCLTypeMask *flagsOut) {
466 f32 dist;
467 EGG::Vector3f fnrm;
468 u16 attribute;
469 bool hasCol = false;
470
471 while ((data->*collisionCheckFunc)(&dist, &fnrm, &attribute)) {
472 dist *= m_kclScale;
473
474 if (m_noBounceWallInfo && attribute & KCL_SOFT_WALL_MASK) {
475 if (m_localMtx) {
476 fnrm = m_localMtx->multVector33(fnrm);
477 }
478 EGG::Vector3f offset = fnrm * dist;
479 m_noBounceWallInfo->bbox.min = m_noBounceWallInfo->bbox.min.minimize(offset);
480 m_noBounceWallInfo->bbox.max = m_noBounceWallInfo->bbox.max.maximize(offset);
481 if (m_noBounceWallInfo->dist < dist) {
482 m_noBounceWallInfo->dist = dist;
483 m_noBounceWallInfo->fnrm = fnrm;
484 }
485 } else {
486 u32 kclAttributeTypeBit = KCL_ATTRIBUTE_TYPE_BIT(attribute);
487 if (flagsOut) {
488 *flagsOut |= kclAttributeTypeBit;
489 }
490 if (kclAttributeTypeBit & KCL_TYPE_SOLID_SURFACE) {
491 colInfo->update(dist, fnrm * dist, fnrm, kclAttributeTypeBit);
492 }
493 }
494
495 hasCol = true;
496 }
497
498 m_localMtx = nullptr;
499
500 return hasCol;
501}
502
504bool CourseColMgr::doCheckWithFullInfoPush(KColData *data, CollisionCheckFunc collisionCheckFunc,
505 CollisionInfo *colInfo, KCLTypeMask *flagsOut) {
506 f32 dist;
507 EGG::Vector3f fnrm;
508 u16 attribute;
509 bool hasCol = false;
510
511 while ((data->*collisionCheckFunc)(&dist, &fnrm, &attribute)) {
512 dist *= m_kclScale;
513
514 if (m_noBounceWallInfo && attribute & KCL_SOFT_WALL_MASK) {
515 if (m_localMtx) {
516 fnrm = m_localMtx->multVector33(fnrm);
517 }
518 EGG::Vector3f offset = fnrm * dist;
519 m_noBounceWallInfo->bbox.min = m_noBounceWallInfo->bbox.min.minimize(offset);
520 m_noBounceWallInfo->bbox.max = m_noBounceWallInfo->bbox.max.maximize(offset);
521 if (m_noBounceWallInfo->dist < dist) {
522 m_noBounceWallInfo->dist = dist;
523 m_noBounceWallInfo->fnrm = fnrm;
524 }
525 } else {
526 u32 kclAttributeTypeBit = KCL_ATTRIBUTE_TYPE_BIT(attribute);
527 if (flagsOut) {
528 CollisionDirector::Instance()->pushCollisionEntry(dist, flagsOut,
529 kclAttributeTypeBit, attribute);
530 }
531 if (kclAttributeTypeBit & KCL_TYPE_SOLID_SURFACE) {
532 colInfo->update(dist, fnrm * dist, fnrm, kclAttributeTypeBit);
533 }
534 }
535
536 hasCol = true;
537 }
538
539 m_localMtx = nullptr;
540
541 return hasCol;
542}
543
544bool CourseColMgr::doCheckMaskOnly(KColData *data, CollisionCheckFunc collisionCheckFunc,
545 KCLTypeMask *maskOut) {
546 bool hasCol = false;
547 f32 dist;
548 u16 attribute;
549
550 while ((data->*collisionCheckFunc)(&dist, nullptr, &attribute)) {
551 if ((!m_noBounceWallInfo || !(attribute & KCL_SOFT_WALL_MASK)) && maskOut) {
552 *maskOut |= KCL_ATTRIBUTE_TYPE_BIT(attribute);
553 }
554 hasCol = true;
555 }
556
557 return hasCol;
558}
559
560bool CourseColMgr::doCheckMaskOnlyPush(KColData *data, CollisionCheckFunc collisionCheckFunc,
561 KCLTypeMask *maskOut) {
562 bool hasCol = false;
563 f32 dist;
564 u16 attribute;
565
566 while ((data->*collisionCheckFunc)(&dist, nullptr, &attribute)) {
567 if ((!m_noBounceWallInfo || !(attribute & KCL_SOFT_WALL_MASK)) && maskOut) {
568 CollisionDirector::Instance()->pushCollisionEntry(dist, maskOut,
569 KCL_ATTRIBUTE_TYPE_BIT(attribute), attribute);
570 }
571 hasCol = true;
572 }
573
574 return hasCol;
575}
576
577CourseColMgr *CourseColMgr::s_instance = nullptr;
578
579} // namespace Field
KCL_ATTRIBUTE_TYPE_BIT
#define KCL_ATTRIBUTE_TYPE_BIT(x)
Given the full 2 byte KCL flag for a triangle, extracts the "Base Type" portion of the flag.
Definition KCollisionTypes.hh:30
KCL_TYPE_SOLID_SURFACE
#define KCL_TYPE_SOLID_SURFACE
0xF0F8FFFF
Definition KCollisionTypes.hh:83
EGG::Matrix34f::multVector33
Vector3f multVector33(const Vector3f &vec) const
Multiplies a 3x3 matrix by a vector.
Definition Matrix.cc:243
Field::CourseColMgr
Manager for course KCL interactions.
Definition CourseColMgr.hh:18
Field::CourseColMgr::LoadFile
static void * LoadFile(const char *filename)
Loads a particular section of a .szs file.
Definition CourseColMgr.cc:346
uint16_t
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