SMG-Decomp
A decompilation of Super Mario Galaxy 1
Loading...
Searching...
No Matches
JMapUtil.cpp
1#include "Game/Util/JMapUtil.hpp"
2#include "Game/Util.hpp"
3#include "math_types.hpp"
4#include <cstdio>
5#include <cmath>
6
7namespace {
8 bool getJMapInfoRailArg(const JMapInfoIter &rIter, const char *pName, s32 *pOut) NO_INLINE {
9 s32 val;
10 bool hasValue = rIter.getValue<s32>(pName, &val);
11
12 if (!hasValue) {
13 return false;
14 }
15
16 if (val != -1) {
17 *pOut = val;
18 return true;
19 }
20
21 return false;
22 }
23
24 bool getJMapInfoArgNoInit(const JMapInfoIter &rIter, const char *pName, s32 *pOut) NO_INLINE {
25 s32 val;
26 bool hasValue = rIter.getValue<s32>(pName, &val);
27
28 if (!hasValue) {
29 return false;
30 }
31
32 if (val != -1) {
33 *pOut = val;
34 return true;
35 }
36
37 return false;
38 }
39
40 bool getJMapInfoArgNoInit(const JMapInfoIter &rIter, const char *pName, f32 *pOut) NO_INLINE {
41 s32 val;
42 bool hasValue = ::getJMapInfoArgNoInit(rIter, pName, &val);
43
44 if (!hasValue) {
45 return false;
46 }
47
48 *pOut = val;
49 return true;
50 }
51
52 bool getJMapInfoArgNoInit(const JMapInfoIter &rIter, const char *pName, bool *pOut) NO_INLINE {
53 s32 val;
54 bool hasValue = rIter.getValue<s32>(pName, &val);
55
56 if (!hasValue) {
57 return false;
58 }
59
60 if (val != -1) {
61 *pOut = true;
62 }
63 else {
64 *pOut = false;
65 }
66
67 return true;
68 }
69};
70
71namespace MR {
72 bool isValidInfo(const JMapInfoIter &rIter) {
73 return rIter.isValid();
74 }
75
76 bool isObjectName(const JMapInfoIter &rIter, const char *pName) {
77 const char *objName = nullptr;
78 if (MR::getObjectName(&objName, rIter)) {
79 return MR::isEqualString(pName, objName);
80 }
81
82 return false;
83 }
84
85 inline bool getArgAndInit(const JMapInfoIter &rIter, const char *pName, s32 *pOut) {
86 *pOut = -1;
87 return ::getJMapInfoArgNoInit(rIter, pName, pOut);
88 }
89
90 inline bool getArgAndInit(const JMapInfoIter &rIter, const char *pName, f32 *pOut) {
91 *pOut = -1.0f;
92 return ::getJMapInfoArgNoInit(rIter, pName, pOut);
93 }
94
95 inline bool getArgAndInit(const JMapInfoIter &rIter, const char *pName, bool *pOut) {
96 *pOut = false;
97 return ::getJMapInfoArgNoInit(rIter, pName, pOut);
98 }
99};
100
101namespace MR {
102 bool getJMapInfoTrans(const JMapInfoIter &rIter, TVec3f *pOut) {
103 if (!getJMapInfoTransLocal(rIter, pOut)) {
104 return false;
105 }
106
107 if (isPlacementLocalStage()) {
108 getZonePlacementMtx(rIter)->mult(*pOut, *pOut);
109 }
110
111 return true;
112 }
113
114 bool getJMapInfoRotate(const JMapInfoIter &rIter, TVec3f *pOut) {
115 if (!getJMapInfoRotateLocal(rIter, pOut)) {
116 return false;
117 }
118
119 if (isPlacementLocalStage()) {
120 TMtx34f rotateMtx;
121 makeMtxRotate(rotateMtx.toMtxPtr(), *pOut);
122 TMtx34f* placementMtx = getZonePlacementMtx(rIter);
123 rotateMtx.concat(*placementMtx, rotateMtx);
124
125 if (-0.001f <= rotateMtx.mMtx[2][0] - 1.0f) {
126 pOut->x = std::atan2(-rotateMtx.mMtx[0][1], rotateMtx.mMtx[1][1]);
127 pOut->y = -1.5707964f;
128 pOut->z = 0.0f;
129 }
130 else if (rotateMtx.mMtx[2][0] + 1.0f <= 0.001f) {
131 pOut->x = std::atan2(rotateMtx.mMtx[0][1], rotateMtx.mMtx[1][1]);
132 pOut->y = 1.5707964f;
133 pOut->z = 0.0f;
134 }
135 else {
136 pOut->x = std::atan2(rotateMtx.mMtx[2][1], rotateMtx.mMtx[2][2]);
137 pOut->z = std::atan2(rotateMtx.mMtx[1][0], rotateMtx.mMtx[0][0]);
138 pOut->y = asin(-rotateMtx.mMtx[2][0]);
139 }
140
141 TVec3f stack_8;
142 stack_8.setInlinePS(*pOut);
143 stack_8.x *= 57.29578f;
144 stack_8.y *= 57.29578f;
145 stack_8.z *= 57.29578f;
146 pOut->setInlinePS(stack_8);
147 }
148
149 return true;
150 }
151
152 bool getJMapInfoMatrixFromRT(const JMapInfoIter &rIter, TPos3f *pOut) {
153 TVec3f trans;
154 if (!getJMapInfoTrans(rIter, &trans)) {
155 return false;
156 }
157
158 TVec3f rot;
159 if (!getJMapInfoRotate(rIter, &rot)) {
160 return false;
161 }
162
163 makeMtxTR(pOut->toMtxPtr(), trans, rot);
164 return true;
165 }
166
167 bool getJMapInfoArg0WithInit(const JMapInfoIter &rIter, s32 *pOut) {
168 return getArgAndInit(rIter, "Obj_arg0", pOut);
169 }
170
171 bool getJMapInfoArg0WithInit(const JMapInfoIter &rIter, f32 *pOut) {
172 return getArgAndInit(rIter, "Obj_arg0", pOut);
173 }
174
175 bool getJMapInfoArg0WithInit(const JMapInfoIter &rIter, bool *pOut) {
176 return getArgAndInit(rIter, "Obj_arg0", pOut);
177 }
178
179 bool getJMapInfoArg1WithInit(const JMapInfoIter &rIter, f32 *pOut) {
180 return getArgAndInit(rIter, "Obj_arg1", pOut);
181 }
182
183 bool getJMapInfoArg1WithInit(const JMapInfoIter &rIter, bool *pOut) {
184 return getArgAndInit(rIter, "Obj_arg1", pOut);
185 }
186
187 bool getJMapInfoArg2WithInit(const JMapInfoIter &rIter, f32 *pOut) {
188 return getArgAndInit(rIter, "Obj_arg2", pOut);
189 }
190
191 bool getJMapInfoArg2WithInit(const JMapInfoIter &rIter, bool *pOut) {
192 return getArgAndInit(rIter, "Obj_arg2", pOut);
193 }
194
195 bool getJMapInfoArg3WithInit(const JMapInfoIter &rIter, f32 *pOut) {
196 return getArgAndInit(rIter, "Obj_arg3", pOut);
197 }
198
199 bool getJMapInfoArg3WithInit(const JMapInfoIter &rIter, bool *pOut) {
200 return getArgAndInit(rIter, "Obj_arg3", pOut);
201 }
202
203 bool getJMapInfoArg4WithInit(const JMapInfoIter &rIter, bool *pOut) {
204 return getArgAndInit(rIter, "Obj_arg4", pOut);
205 }
206
207 bool getJMapInfoArg7WithInit(const JMapInfoIter &rIter, bool *pOut) {
208 return getArgAndInit(rIter, "Obj_arg7", pOut);
209 }
210
211 bool getJMapInfoArg0NoInit(const JMapInfoIter &rIter, s32 *pOut) {
212 return ::getJMapInfoArgNoInit(rIter, "Obj_arg0", pOut);
213 }
214
215 bool getJMapInfoArg0NoInit(const JMapInfoIter &rIter, f32 *pOut) {
216 return ::getJMapInfoArgNoInit(rIter, "Obj_arg0", pOut);
217 }
218
219 bool getJMapInfoArg0NoInit(const JMapInfoIter &rIter, bool *pOut) {
220 return ::getJMapInfoArgNoInit(rIter, "Obj_arg0", pOut);
221 }
222
223 bool getJMapInfoArg1NoInit(const JMapInfoIter &rIter, s32 *pOut) {
224 return ::getJMapInfoArgNoInit(rIter, "Obj_arg1", pOut);
225 }
226
227 bool getJMapInfoArg1NoInit(const JMapInfoIter &rIter, f32 *pOut) {
228 return ::getJMapInfoArgNoInit(rIter, "Obj_arg1", pOut);
229 }
230
231 bool getJMapInfoArg1NoInit(const JMapInfoIter &rIter, bool *pOut) {
232 return ::getJMapInfoArgNoInit(rIter, "Obj_arg1", pOut);
233 }
234
235 bool getJMapInfoArg2NoInit(const JMapInfoIter &rIter, s32 *pOut) {
236 return ::getJMapInfoArgNoInit(rIter, "Obj_arg2", pOut);
237 }
238
239 bool getJMapInfoArg2NoInit(const JMapInfoIter &rIter, f32 *pOut) {
240 return ::getJMapInfoArgNoInit(rIter, "Obj_arg2", pOut);
241 }
242
243 bool getJMapInfoArg2NoInit(const JMapInfoIter &rIter, bool *pOut) {
244 return ::getJMapInfoArgNoInit(rIter, "Obj_arg2", pOut);
245 }
246
247 bool getJMapInfoArg3NoInit(const JMapInfoIter &rIter, s32 *pOut) {
248 return ::getJMapInfoArgNoInit(rIter, "Obj_arg3", pOut);
249 }
250
251 bool getJMapInfoArg3NoInit(const JMapInfoIter &rIter, f32 *pOut) {
252 return ::getJMapInfoArgNoInit(rIter, "Obj_arg3", pOut);
253 }
254
255 bool getJMapInfoArg3NoInit(const JMapInfoIter &rIter, bool *pOut) {
256 return ::getJMapInfoArgNoInit(rIter, "Obj_arg3", pOut);
257 }
258
259 bool getJMapInfoArg4NoInit(const JMapInfoIter &rIter, s32 *pOut) {
260 return ::getJMapInfoArgNoInit(rIter, "Obj_arg4", pOut);
261 }
262
263 bool getJMapInfoArg4NoInit(const JMapInfoIter &rIter, f32 *pOut) {
264 return ::getJMapInfoArgNoInit(rIter, "Obj_arg4", pOut);
265 }
266
267 bool getJMapInfoArg4NoInit(const JMapInfoIter &rIter, bool *pOut) {
268 return ::getJMapInfoArgNoInit(rIter, "Obj_arg4", pOut);
269 }
270
271 bool getJMapInfoArg5NoInit(const JMapInfoIter &rIter, s32 *pOut) {
272 return ::getJMapInfoArgNoInit(rIter, "Obj_arg5", pOut);
273 }
274
275 bool getJMapInfoArg5NoInit(const JMapInfoIter &rIter, f32 *pOut) {
276 return ::getJMapInfoArgNoInit(rIter, "Obj_arg5", pOut);
277 }
278
279 bool getJMapInfoArg5NoInit(const JMapInfoIter &rIter, bool *pOut) {
280 return ::getJMapInfoArgNoInit(rIter, "Obj_arg5", pOut);
281 }
282
283 bool getJMapInfoArg6NoInit(const JMapInfoIter &rIter, s32 *pOut) {
284 return ::getJMapInfoArgNoInit(rIter, "Obj_arg6", pOut);
285 }
286
287 bool getJMapInfoArg6NoInit(const JMapInfoIter &rIter, f32 *pOut) {
288 return ::getJMapInfoArgNoInit(rIter, "Obj_arg6", pOut);
289 }
290
291 bool getJMapInfoArg6NoInit(const JMapInfoIter &rIter, bool *pOut) {
292 return ::getJMapInfoArgNoInit(rIter, "Obj_arg6", pOut);
293 }
294
295 bool getJMapInfoArg7NoInit(const JMapInfoIter &rIter, s32 *pOut) {
296 return ::getJMapInfoArgNoInit(rIter, "Obj_arg7", pOut);
297 }
298
299 bool getJMapInfoArg7NoInit(const JMapInfoIter &rIter, f32 *pOut) {
300 return ::getJMapInfoArgNoInit(rIter, "Obj_arg7", pOut);
301 }
302
303 bool getJMapInfoArg7NoInit(const JMapInfoIter &rIter, bool *pOut) {
304 return ::getJMapInfoArgNoInit(rIter, "Obj_arg7", pOut);
305 }
306
307 bool isEqualObjectName(const JMapInfoIter &rIter, const char *pOtherName) {
308 const char* objName;
309 getObjectName(&objName, rIter);
310 return isEqualStringCase(objName, pOtherName);
311 }
312
313 s32 getDemoGroupID(const JMapInfoIter &rIter) {
314 s32 groupID = -1;
315 rIter.getValue<s32>("DemoGroupId", &groupID);
316 return groupID;
317 }
318
319 s32 getDemoGroupLinkID(const JMapInfoIter &rIter) {
320 s32 linkID = -1;
321 rIter.getValue<s32>("l_id", &linkID);
322 return linkID;
323 }
324
325 bool getJMapInfoRailArg0NoInit(const JMapInfoIter &rIter, s32 *pRailArg0) {
326 return ::getJMapInfoRailArg(rIter, "path_arg0", pRailArg0);
327 }
328
329 bool getRailId(const JMapInfoIter &rIter, s32 *pRailID) {
330 return getArgAndInit(rIter, "CommonPath_ID", pRailID);
331 }
332
333 bool getObjectName(const char **pName, const JMapInfoIter &rIter) {
334 if (!rIter.isValid()) {
335 return false;
336 }
337
338 if (rIter.getValue<const char *>("type", pName)) {
339 return true;
340 }
341
342 return rIter.getValue<const char*>("name", pName);
343 }
344
345 bool isExistJMapArg(const JMapInfoIter &rIter) {
346 if (!rIter.isValid()) {
347 return false;
348 }
349
350 s32 val;
351 return rIter.getValue<s32>("Obj_arg0", &val);
352 }
353
354 bool getJMapInfoShapeIdWithInit(const JMapInfoIter &rIter, s32 *pShapeID) {
355 return rIter.getValue<s32>("ShapeModelNo", pShapeID);
356 }
357
358
359 bool getJMapInfoTransLocal(const JMapInfoIter &rIter, TVec3f *pOut) {
360 if (!MR::getValue<f32>(rIter, "pos_x", &pOut->x)) {
361 return false;
362 }
363 else if (!MR::getValue<f32>(rIter, "pos_y", &pOut->y)) {
364 return false;
365 }
366
367 return MR::getValue<f32>(rIter, "pos_z", &pOut->z);
368 }
369
370 bool getJMapInfoRotateLocal(const JMapInfoIter &rIter, TVec3f *pOut) {
371 if (!MR::getValue<f32>(rIter, "dir_x", &pOut->x)) {
372 return false;
373 }
374 else if (!MR::getValue<f32>(rIter, "dir_y", &pOut->y)) {
375 return false;
376 }
377
378 return MR::getValue<f32>(rIter, "dir_z", &pOut->z);
379 }
380
381 bool getJMapInfoScale(const JMapInfoIter &rIter, TVec3f *pOut) {
382 if (!MR::getValue<f32>(rIter, "scale_x", &pOut->x)) {
383 return false;
384 }
385 else if (!MR::getValue<f32>(rIter, "scale_y", &pOut->y)) {
386 return false;
387 }
388
389 return MR::getValue<f32>(rIter, "scale_z", &pOut->z);
390 }
391
392 bool getJMapInfoV3f(const JMapInfoIter &rIter, const char *pName, TVec3f *pOut) {
393 char str[0x20];
394 sprintf(str, "%sX", pName);
395
396 if (!MR::getValue<f32>(rIter, str, &pOut->x)) {
397 return false;
398 }
399
400 sprintf(str, "%sY", pName);
401
402 if (!MR::getValue<f32>(rIter, str, &pOut->y)) {
403 return false;
404 }
405
406 sprintf(str, "%sZ", pName);
407 return MR::getValue<f32>(rIter, str, &pOut->z);
408 }
409
410 bool getJMapInfoArg1WithInit(const JMapInfoIter &rIter, s32 *pOut) {
411 return MR::getArgAndInit(rIter, "Obj_arg1", pOut);
412 }
413
414 bool getJMapInfoArg2WithInit(const JMapInfoIter &rIter, s32 *pOut) {
415 return MR::getArgAndInit(rIter, "Obj_arg2", pOut);
416 }
417
418 bool getJMapInfoArg3WithInit(const JMapInfoIter &rIter, s32 *pOut) {
419 return MR::getArgAndInit(rIter, "Obj_arg3", pOut);
420 }
421
422 bool getJMapInfoArg4WithInit(const JMapInfoIter &rIter, s32 *pOut) {
423 return MR::getArgAndInit(rIter, "Obj_arg4", pOut);
424 }
425
426 bool getJMapInfoArg5WithInit(const JMapInfoIter &rIter, s32 *pOut) {
427 return MR::getArgAndInit(rIter, "Obj_arg5", pOut);
428 }
429
430 bool getJMapInfoArg6WithInit(const JMapInfoIter &rIter, s32 *pOut) {
431 return MR::getArgAndInit(rIter, "Obj_arg6", pOut);
432 }
433
434 bool getJMapInfoArg7WithInit(const JMapInfoIter &rIter, s32 *pOut) {
435 return MR::getArgAndInit(rIter, "Obj_arg7", pOut);
436 }
437
438 bool getJMapInfoFollowID(const JMapInfoIter &rIter, s32 *pOut) {
439 return MR::getArgAndInit(rIter, "FollowId", pOut);
440 }
441
442 bool getJMapInfoGroupID(const JMapInfoIter &rIter, s32 *pOut) {
443 if (MR::getArgAndInit(rIter, "GroupId", pOut)) {
444 return true;
445 }
446
447 return MR::getJMapInfoClippingGroupID(rIter, pOut);
448 }
449
450 bool getJMapInfoClippingGroupID(const JMapInfoIter &rIter, s32 *pOut) {
451 return MR::getArgAndInit(rIter, "ClippingGroupId", pOut);
452 }
453
454 bool getJMapInfoDemoGroupID(const JMapInfoIter &rIter, s32 *pOut) {
455 return MR::getArgAndInit(rIter, "DemoGroupId", pOut);
456 }
457
458 bool getJMapInfoLinkID(const JMapInfoIter &rIter, s32 *pOut) {
459 return rIter.getValue<s32>("l_id", pOut);
460 }
461
462 bool isConnectedWithRail(const JMapInfoIter &rIter) {
463 if (!rIter.isValid()) {
464 return false;
465 }
466
467 s32 id;
468 return !MR::getArgAndInit(rIter, "CommonPath_ID", &id) ? false : id != -1;
469 }
470
471 bool isExistStageSwitchA(const JMapInfoIter &rIter) {
472 if (!rIter.isValid()) {
473 return false;
474 }
475
476 s32 id;
477 MR::getArgAndInit(rIter, "SW_A", &id);
478 return id != -1;
479 }
480
481 bool isExistStageSwitchB(const JMapInfoIter &rIter) {
482 if (!rIter.isValid()) {
483 return false;
484 }
485
486 s32 id;
487 MR::getArgAndInit(rIter, "SW_B", &id);
488 return id != -1;
489 }
490
491 bool isExistStageSwitchAppear(const JMapInfoIter &rIter) {
492 if (!rIter.isValid()) {
493 return false;
494 }
495
496 s32 id;
497 MR::getArgAndInit(rIter, "SW_APPEAR", &id);
498 return id != -1;
499 }
500
501 bool isExistStageSwitchDead(const JMapInfoIter &rIter) {
502 if (!rIter.isValid()) {
503 return false;
504 }
505
506 s32 id;
507 MR::getArgAndInit(rIter, "SW_DEAD", &id);
508 return id != -1;
509 }
510
511 bool isExistStageSwitchSleep(const JMapInfoIter &rIter) {
512 if (!rIter.isValid()) {
513 return false;
514 }
515
516 s32 id;
517 MR::getArgAndInit(rIter, "SW_SLEEP", &id);
518 return id != -1;
519 }
520
521 bool getJMapInfoCameraSetID(const JMapInfoIter &rIter, s32 *pOut) {
522 *pOut = -1;
523
524 if (!rIter.isValid()) {
525 return false;
526 }
527
528 return ::getJMapInfoArgNoInit(rIter, "CameraSetId", pOut);
529 }
530
531 bool getJMapInfoViewGroupID(const JMapInfoIter &rIter, s32 *pOut) {
532 *pOut = -1;
533
534 if (!rIter.isValid()) {
535 return false;
536 }
537
538 return ::getJMapInfoArgNoInit(rIter, "ViewGroupId", pOut);
539 }
540
541 bool getJMapInfoMessageID(const JMapInfoIter &rIter, s32 *pOut) {
542 *pOut = -1;
543
544 if (!rIter.isValid()) {
545 return false;
546 }
547
548 return ::getJMapInfoArgNoInit(rIter, "MessageId", pOut);
549 }
550
551 s32 getDemoCastID(const JMapInfoIter &rIter) {
552 s32 id = -1;
553 rIter.getValue<s32>("CastId", &id);
554 return id;
555 }
556
557 const char* getDemoName(const JMapInfoIter &rIter) {
558 const char* name = nullptr;
559 rIter.getValue<const char *>("DemoName", &name);
560 return name;
561 }
562
563 const char* getDemoSheetName(const JMapInfoIter &rIter) {
564 const char* name = nullptr;
565 rIter.getValue<const char *>("TimeSheetName", &name);
566 return name;
567 }
568
569 bool getNextLinkRailID(const JMapInfoIter &rIter, s32 *pOut) {
570 return rIter.getValue<s32>("Path_ID", pOut);
571 }
572
573 bool isEqualRailUsage(const JMapInfoIter &rIter, const char *pUsage) {
574 const char* str = nullptr;
575 rIter.getValue<const char *>("usage", &str);
576 return isEqualStringCase(str, pUsage);
577 }
578
579 void getRailPointPos0(const JMapInfoIter &rIter, TVec3f *pOut) {
580 rIter.getValue<f32>("pnt0_x", &pOut->x);
581 rIter.getValue<f32>("pnt0_y", &pOut->y);
582 rIter.getValue<f32>("pnt0_z", &pOut->z);
583
584 if (isPlacementLocalStage()) {
585 getZonePlacementMtx(rIter)->mult(*pOut, *pOut);
586 }
587 }
588
589 void getRailPointPos1(const JMapInfoIter &rIter, TVec3f *pOut) {
590 rIter.getValue<f32>("pnt1_x", &pOut->x);
591 rIter.getValue<f32>("pnt1_y", &pOut->y);
592 rIter.getValue<f32>("pnt1_z", &pOut->z);
593
594 if (isPlacementLocalStage()) {
595 getZonePlacementMtx(rIter)->mult(*pOut, *pOut);
596 }
597 }
598
599 void getRailPointPos2(const JMapInfoIter &rIter, TVec3f *pOut) {
600 rIter.getValue<f32>("pnt2_x", &pOut->x);
601 rIter.getValue<f32>("pnt2_y", &pOut->y);
602 rIter.getValue<f32>("pnt2_z", &pOut->z);
603
604 if (isPlacementLocalStage()) {
605 getZonePlacementMtx(rIter)->mult(*pOut, *pOut);
606 }
607 }
608
609 bool isLoopRailPathIter(const JMapInfoIter &rIter) {
610 const char* status = "";
611 rIter.getValue<const char *>("closed", &status);
612 return isEqualString(status, "CLOSE");
613 }
614};
Generated by doxygen 1.10.0