NSMBW-Decomp
A decompilation of New Super Mario Bros. Wii
Loading...
Searching...
No Matches
g3d_scnobj.h
1#ifndef NW4R_G3D_SCN_OBJ_H
2#define NW4R_G3D_SCN_OBJ_H
3#include <nw4r/types_nw4r.h>
4
5#include <nw4r/g3d/g3d_obj.h>
6
7#include <nw4r/math.h>
8
9namespace nw4r {
10namespace g3d {
11
12extern const math::FRUSTUM* gpCullingFrustum;
13
14enum ResMdlDrawMode {
15 RESMDL_DRAWMODE_SORT_OPA_NONE = 0,
16 RESMDL_DRAWMODE_SORT_OPA_Z = (1 << 0),
17
18 RESMDL_DRAWMODE_SORT_XLU_NONE = 0,
19 RESMDL_DRAWMODE_SORT_XLU_Z = (1 << 1),
20
21 RESMDL_DRAWMODE_IGNORE_MATERIAL = (1 << 2),
22 RESMDL_DRAWMODE_FORCE_LIGHTOFF = (1 << 3),
23 RESMDL_DRAWMODE_NOPPCSYNC = (1 << 4),
24
25 RESMDL_DRAWMODE_DEFAULT = RESMDL_DRAWMODE_SORT_XLU_Z,
26 REDMDL_DRAWMODE_SORT_NONE = 0,
27 RESMDL_DRAWMODE_SORT_Z =
28 RESMDL_DRAWMODE_SORT_OPA_Z | RESMDL_DRAWMODE_SORT_XLU_Z,
29};
30
31/******************************************************************************
32 *
33 * ScnObj
34 *
35 ******************************************************************************/
36// Forward declarations
37class IScnObjCallback;
38
39class ScnObj : public G3dObj {
40public:
41 enum ForEachResult {
42 FOREACHRESULT_OK,
43 FOREACHRESULT_CONTINUE,
44 FOREACHRESULT_RETURN,
45 FOREACHRESULT_GOBACK
46 };
47
48 typedef ForEachResult (*ForEachFunc)(ScnObj* pParent, void* pInfo);
49
50 enum ScnObjMtxType { MTX_LOCAL, MTX_WORLD, MTX_VIEW, MTX_TYPE_MAX };
51
52 enum ScnObjBoundingVolumeType {
53 BOUNDINGVOLUME_AABB_LOCAL,
54 BOUNDINGVOLUME_AABB_WORLD,
55 BOUNDINGVOLUME_MAX
56 };
57
58#define OPT(KEY, VALUE) OPTID_##KEY = (0x00000 | (VALUE))
59 enum ScnObjOption {
60 OPT(NONE, 0),
61 OPT(DISABLE_GATHER_SCNOBJ, 1),
62 OPT(DISABLE_CALC_WORLD, 2),
63 OPT(DISABLE_CALC_MAT, 3),
64 OPT(DISABLE_CALC_VTX, 4),
65 OPT(DISABLE_CALC_VIEW, 5),
66 OPT(DISABLE_DRAW_OPA, 6),
67 OPT(DISABLE_DRAW_XLU, 7),
68 OPT(DISABLE_UPDATEFRAME, 8),
69 OPT(ENABLE_CULLING, 9),
70 };
71#undef OPT
72
73 enum Timing {
74 CALLBACK_TIMING_A = (1 << 0),
75 CALLBACK_TIMING_B = (1 << 1),
76 CALLBACK_TIMING_C = (1 << 2),
77 CALLBACK_TIMING_ALL = (CALLBACK_TIMING_A | CALLBACK_TIMING_B | CALLBACK_TIMING_C)
78 };
79
80 enum ExecOp {
81 EXECOP_CALC_WORLD = (1 << 0),
82 EXECOP_CALC_MAT = (1 << 1),
83 EXECOP_CALC_VIEW = (1 << 2),
84 EXECOP_DRAW_OPA = (1 << 4),
85 EXECOP_DRAW_XLU = (1 << 5)
86 };
87
88public:
89 explicit ScnObj(MEMAllocator* pAllocator);
90
91 virtual void G3dProc(ulong task, ulong param, void* pInfo) = 0; // at 0xC
92 virtual ~ScnObj(); // at 0x10
93
94 virtual ForEachResult ForEach(ForEachFunc pFunc, void* pInfo,
95 bool postOrder) = 0; // at 0x1C
96
97 virtual bool SetScnObjOption(ulong option, ulong value); // at 0x20
98 virtual bool GetScnObjOption(ulong option, ulong* pValue) const; // at 0x24
99
100 virtual f32 GetValueForSortOpa() const; // at 0x28
101 virtual f32 GetValueForSortXlu() const; // at 0x2C
102
103 virtual void CalcWorldMtx(const math::MTX34* pParent,
104 ulong* pParam); // at 0x30
105
106 void CalcViewMtx(const math::MTX34* pCamera);
107
108 bool SetMtx(ScnObjMtxType type, const math::MTX34* pMtx);
109 bool GetMtx(ScnObjMtxType type, math::MTX34* pMtx) const;
110 const math::MTX34* GetMtxPtr(ScnObjMtxType type) const {
111 return &mMtxArray[type];
112 }
113
114 void SetPriorityDrawOpa(int prio);
115 int GetPriorityDrawOpa() const {
116 return mPriorityDrawOpa;
117 }
118
119 void SetPriorityDrawXlu(int prio);
120 int GetPriorityDrawXlu() const {
121 return mPriorityDrawXlu;
122 }
123
124 void EnableScnObjCallbackTiming(Timing timing);
125 void EnableScnObjCallbackExecOp(ExecOp op);
126
127 bool SetBoundingVolume(ScnObjBoundingVolumeType type,
128 const math::AABB* pAABB);
129 bool GetBoundingVolume(ScnObjBoundingVolumeType type,
130 math::AABB* pAABB) const;
131
132 bool SetBoundingVolume(const math::AABB* pAABB) {
133 return SetBoundingVolume(BOUNDINGVOLUME_AABB_LOCAL, pAABB);
134 }
135
136protected:
137 enum ScnObjFlag {
138 SCNOBJFLAG_DISABLE_CALC_WORLD = (1 << 0),
139 SCNOBJFLAG_DISABLE_CALC_MAT = (1 << 1),
140 SCNOBJFLAG_DISABLE_CALC_VTX = (1 << 2),
141 SCNOBJFLAG_DISABLE_CALC_VIEW = (1 << 3),
142 SCNOBJFLAG_DISABLE_GATHER_SCNOBJ = (1 << 4),
143 SCNOBJFLAG_DISABLE_DRAW_OPA = (1 << 5),
144 SCNOBJFLAG_DISABLE_DRAW_XLU = (1 << 6),
145 SCNOBJFLAG_DISABLE_UPDATEFRAME = (1 << 7),
146 SCNOBJFLAG_IGNORE_ANMCHR_TRANS = (1 << 8),
147
148 SCNOBJFLAG_ENABLE_CULLING = (1 << 28),
149 SCNOBJFLAG_NOT_GATHER_DRAW_OPA = (1 << 29),
150 SCNOBJFLAG_NOT_GATHER_DRAW_XLU = (1 << 30),
151 SCNOBJFLAG_MTX_LOCAL_IDENTITY = (1 << 31),
152
153 SCNOBJFLAG_DISABLE_DRAW =
154 SCNOBJFLAG_DISABLE_DRAW_OPA | SCNOBJFLAG_DISABLE_DRAW_XLU
155 };
156
157protected:
158 void SetScnObjFlag(ScnObjFlag flag, ulong on) {
159 if (on) {
160 mScnObjFlags |= flag;
161 } else {
162 mScnObjFlags &= ~flag;
163 }
164 }
165 ulong TestScnObjFlag(ScnObjFlag flag) const {
166 return (mScnObjFlags & flag) != 0;
167 }
168
169 bool IsG3dProcDisabled(ulong task) const {
170 if (task < __G3DPROC_OPTIONAL_END && ((1 << task - 1) & mScnObjFlags)) {
171 return true;
172 }
173
174 return false;
175 }
176
177 /**
178 * Defined elsewhere to resolve circular dependency with IScnObjCallback
179 */
180 inline void CheckCallback_CALC_VIEW(Timing timing, ulong param, void* pInfo);
181 inline void CheckCallback_CALC_MAT(Timing timing, ulong param, void* pInfo);
182 inline void CheckCallback_CALC_WORLD(Timing timing, ulong param, void* pInfo);
183 inline void CheckCallback_DRAW_OPA(Timing timing, ulong param, void* pInfo);
184 inline void CheckCallback_DRAW_XLU(Timing timing, ulong param, void* pInfo);
185
186protected:
187 math::MTX34 mMtxArray[MTX_TYPE_MAX]; // at 0xC
188 math::AABB mAABB[BOUNDINGVOLUME_MAX]; // at 0x9C
189
190private:
191 ulong mScnObjFlags; // at 0xCC
192 u8 mPriorityDrawOpa; // at 0xD0
193 u8 mPriorityDrawXlu; // at 0xD1
194 u8 PADDING_0xD2; // at 0xD2
195 u8 PADDING_0xD3; // at 0xD3
196 IScnObjCallback* mpFuncObjExec; // at 0xD4
197 u8 mCallbackTiming; // at 0xD8
198 u8 mCallbackDeleteOption; // at 0xD9
199 u16 mCallbackExecOpMask; // at 0xDA
200
201 NW4R_G3D_RTTI_DECL_DERIVED(ScnObj, G3dObj);
202};
203
204/******************************************************************************
205 *
206 * IScnObjGather
207 *
208 ******************************************************************************/
209class IScnObjGather {
210public:
211 typedef bool (*LessThanFunc)(const ScnObj* pLhs, const ScnObj* pRhs);
212
213 enum CullingStatus {
214 CULLINGSTATUS_INTERSECT,
215 CULLINGSTATUS_INSIDE,
216 CULLINGSTATUS_OUTSIDE,
217 CULLINGSTATUS_NOTEST
218 };
219
220public:
221 virtual ~IScnObjGather() {} // at 0x8
222
223 virtual CullingStatus Add(ScnObj* pObj, bool opa, bool xlu) = 0; // at 0xC
224 virtual void Clear() = 0; // at 0x10
225 virtual void ZSort() = 0; // at 0x14
226
227 virtual void Sort() = 0; // at 0x18
228 virtual void Sort(LessThanFunc pOpaFunc,
229 LessThanFunc pXluFunc) = 0; // at 0x1C
230
231 virtual void DrawOpa(ResMdlDrawMode* pForceMode) = 0; // at 0x20
232 virtual void DrawXlu(ResMdlDrawMode* pForceMode) = 0; // at 0x24
233};
234
235/******************************************************************************
236 *
237 * IScnObjCallback
238 *
239 ******************************************************************************/
240class IScnObjCallback {
241public:
242 virtual ~IScnObjCallback() {} // at 0x8
243
244 virtual void ExecCallback_CALC_WORLD(ScnObj::Timing /* timing */,
245 ScnObj* /* pObj */, ulong /* param */,
246 void* /* pInfo */) {} // at 0xC
247
248 virtual void ExecCallback_CALC_MAT(ScnObj::Timing /* timing */,
249 ScnObj* /* pObj */, ulong /* param */,
250 void* /* pInfo */) {} // at 0x10
251
252 virtual void ExecCallback_CALC_VIEW(ScnObj::Timing /* timing */,
253 ScnObj* /* pObj */, ulong /* param */,
254 void* /* pInfo */) {} // at 0x14
255
256 virtual void ExecCallback_DRAW_OPA(ScnObj::Timing /* timing */,
257 ScnObj* /* pObj */, ulong /* param */,
258 void* /* pInfo */) {} // at 0x18
259
260 virtual void ExecCallback_DRAW_XLU(ScnObj::Timing /* timing */,
261 ScnObj* /* pObj */, ulong /* param */,
262 void* /* pInfo */) {} // at 0x1C
263};
264
265/******************************************************************************
266 *
267 * ScnObj implementation
268 *
269 ******************************************************************************/
270void ScnObj::CheckCallback_CALC_VIEW(Timing timing, ulong param, void* pInfo) {
271 if (mpFuncObjExec != NULL && (mCallbackExecOpMask & EXECOP_CALC_VIEW) &&
272 (mCallbackTiming & timing)) {
273
274 mpFuncObjExec->ExecCallback_CALC_VIEW(timing, this, param, pInfo);
275 }
276}
277
278void ScnObj::CheckCallback_CALC_MAT(Timing timing, ulong param, void* pInfo) {
279 if (mpFuncObjExec != NULL && (mCallbackExecOpMask & EXECOP_CALC_MAT) &&
280 (mCallbackTiming & timing)) {
281
282 mpFuncObjExec->ExecCallback_CALC_MAT(timing, this, param, pInfo);
283 }
284}
285
286void ScnObj::CheckCallback_CALC_WORLD(Timing timing, ulong param, void* pInfo) {
287 if (mpFuncObjExec != NULL && (mCallbackExecOpMask & EXECOP_CALC_WORLD) &&
288 (mCallbackTiming & timing)) {
289
290 mpFuncObjExec->ExecCallback_CALC_WORLD(timing, this, param, pInfo);
291 }
292}
293
294void ScnObj::CheckCallback_DRAW_OPA(Timing timing, ulong param, void* pInfo) {
295 if (mpFuncObjExec != NULL && (mCallbackExecOpMask & EXECOP_DRAW_OPA) &&
296 (mCallbackTiming & timing)) {
297
298 mpFuncObjExec->ExecCallback_DRAW_OPA(timing, this, param, pInfo);
299 }
300}
301
302void ScnObj::CheckCallback_DRAW_XLU(Timing timing, ulong param, void* pInfo) {
303 if (mpFuncObjExec != NULL && (mCallbackExecOpMask & EXECOP_DRAW_XLU) &&
304 (mCallbackTiming & timing)) {
305
306 mpFuncObjExec->ExecCallback_DRAW_XLU(timing, this, param, pInfo);
307 }
308}
309
310/******************************************************************************
311 *
312 * ScnLeaf
313 *
314 ******************************************************************************/
315class ScnLeaf : public ScnObj {
316public:
317 enum ScaleProperty {
318 NOT_SCALED,
319 UNIFORM_SCALED,
320 NONUNIFORM_SCALED,
321 };
322
323#define OPT(KEY, VALUE) OPTID_##KEY = (0x10000 | (VALUE))
324 enum ScnLeafOption {
325 OPT(NONE, 0),
326 OPT(DISABLE_DRAW_ALL, 1),
327 };
328#undef OPT
329
330public:
331 explicit ScnLeaf(MEMAllocator* pAllocator)
332 : ScnObj(pAllocator), mScale(1.0f, 1.0f, 1.0f) {}
333
334 virtual void G3dProc(ulong task, ulong param, void* pInfo) = 0; // at 0xC
335 virtual ~ScnLeaf() {} // at 0x10
336
337 virtual ForEachResult ForEach(ForEachFunc pFunc, void* pInfo,
338 bool postOrder); // at 0x1C
339
340 virtual bool SetScnObjOption(ulong option, ulong value); // at 0x20
341 virtual bool GetScnObjOption(ulong option, ulong* pValue) const; // at 0x24
342
343 virtual void CalcWorldMtx(const math::MTX34* pParent,
344 ulong* pParam); // at 0x30
345
346 ScaleProperty GetScaleProperty() const;
347
348 void SetScale(float x, float y, float z) {
349 mScale.x = x;
350 mScale.y = y;
351 mScale.z = z;
352 }
353
354 void SetScale(const math::VEC3& scale) {
355 mScale = scale;
356 }
357
358protected:
359 void DefG3dProcScnLeaf(ulong task, ulong param, void* pInfo);
360
361private:
362 math::VEC3 mScale; // at 0xDC
363
364 NW4R_G3D_RTTI_DECL_DERIVED(ScnLeaf, ScnObj);
365};
366
367/******************************************************************************
368 *
369 * ScnGroup
370 *
371 ******************************************************************************/
372class ScnGroup : public ScnObj {
373public:
374 ScnGroup(MEMAllocator* pAllocator, ScnObj** ppObj, ulong capacity);
375
376 virtual void G3dProc(ulong task, ulong param, void* pInfo); // at 0xC
377 virtual ~ScnGroup(); // at 0x10
378
379 virtual ForEachResult ForEach(ForEachFunc pFunc, void* pInfo,
380 bool postOrder); // at 0x1C
381
382 virtual bool Insert(ulong idx, ScnObj* pObj); // at 0x34
383 virtual ScnObj* Remove(ulong idx); // at 0x38
384 virtual bool Remove(ScnObj* pObj); // at 0x3C
385
386 ScnObj** Begin() {
387 return mpScnObjArray;
388 }
389 ScnObj** End() {
390 return mpScnObjArray + mNumScnObj;
391 }
392
393 ScnObj* operator[](ulong idx) {
394 return mpScnObjArray[idx];
395 }
396
397 ulong Size() const {
398 return mNumScnObj;
399 }
400 bool Empty() const {
401 return mNumScnObj == 0;
402 }
403
404 bool PushBack(ScnObj* pObj) {
405 return Insert(mNumScnObj, pObj);
406 }
407 ScnObj* PopBack() {
408 if (!Empty()) {
409 return Remove(Size() - 1);
410 }
411
412 return NULL;
413 }
414
415 void Clear() {
416 while (!Empty()) {
417 PopBack();
418 }
419 }
420
421protected:
422 void DefG3dProcScnGroup(ulong task, ulong param, void* pInfo);
423
424private:
425 void ScnGroup_G3DPROC_GATHER_SCNOBJ(ulong param, IScnObjGather* pCollection);
426 void ScnGroup_G3DPROC_CALC_WORLD(ulong param, const math::MTX34* pParent);
427 void ScnGroup_G3DPROC_CALC_MAT(ulong param, void* pInfo);
428 void ScnGroup_G3DPROC_CALC_VIEW(ulong param, const math::MTX34* pCamera);
429
430private:
431 ScnObj** mpScnObjArray; // at 0xDC
432 ulong mSizeScnObj; // at 0xE0
433 ulong mNumScnObj; // at 0xE4
434
435 NW4R_G3D_RTTI_DECL_DERIVED(ScnGroup, ScnObj);
436};
437
438} // namespace g3d
439} // namespace nw4r
440
441#endif
nw4r::g3d::ScnObj::CheckCallback_CALC_VIEW
void CheckCallback_CALC_VIEW(Timing timing, ulong param, void *pInfo)
Definition g3d_scnobj.h:270
nw4r::g3d
3D graphics drawing library.
Definition g3d_3dsmax.h:10