diff options
Diffstat (limited to 'include')
101 files changed, 2257 insertions, 201 deletions
diff --git a/include/d/a/e/d_a_e_hb_leaf.h b/include/d/a/e/d_a_e_hb_leaf.h new file mode 100644 index 00000000..5ac98cd0 --- /dev/null +++ b/include/d/a/e/d_a_e_hb_leaf.h @@ -0,0 +1,59 @@ +#ifndef D_A_E_HB_LEAF_H +#define D_A_E_HB_LEAF_H + +#include <c/c_math.h> +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_anmmdl.h> +#include <m/m3d/m_anmtexpat.h> + +extern "C" bool fn_800B9D80(f32, f32, f32 *, int, const mVec3_c &, u32); + +class dAcEhb_leaf_c : public dAcObjBase_c { +public: + dAcEhb_leaf_c() : someFloat(unkFloat0), field_0x3CC(0), field_0x3DE(0) {} + virtual ~dAcEhb_leaf_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + void setAnm(const char *anm, f32 pos); + +private: + const static f32 unkFloat0; + const static f32 unkFloat1; + + m3d::mdlAnmChr mModel; // 0x330 + m3d::anmTexPat_c mAnm; // 0x398 + + f32 someFloat; // 0x3C4 + UNKWORD field_0x3C8; // 0x3C8 + u8 field_0x3CC; // 0x3CC + mVec3_c mStartingPos; // 0x3D0 + u16 someRot; // 0x3DC + u8 field_0x3DE; // 0x3DE + u8 mType; // 0x3DF + + bool isNearZero() { + return fabsf(someFloat) <= FLT_EPSILON; + } + + bool isHidden() { + return mType != 0 && isNearZero() ? true : false; + } + + void doCheck() { + fn_800B9D80(10.0f, 0.2f, &someFloat, roomid, mStartingPos, 0); + } + + int getParam1() { + return params & 7; + } + + int getParam2() { + return params >> 7 & 3; + } +}; + +#endif diff --git a/include/d/a/en/d_a_en_base.h b/include/d/a/e/d_a_en_base.h index a24957ba..a24957ba 100644 --- a/include/d/a/en/d_a_en_base.h +++ b/include/d/a/e/d_a_en_base.h diff --git a/include/d/a/obj/d_a_obj_base.h b/include/d/a/obj/d_a_obj_base.h index d4a30b6a..02a1b24e 100644 --- a/include/d/a/obj/d_a_obj_base.h +++ b/include/d/a/obj/d_a_obj_base.h @@ -4,7 +4,25 @@ #include "d/a/d_a_base.h" #include "m/m_mtx.h" #include "m/types_m.h" +#include "nw4r/g3d/g3d_resfile.h" +// Size: 0xA8 +struct ActorCarryStruct { + /* 0x00 */ fLiNdBa_c actorLink; + /* 0x0C */ fLiNdBa_c *carriedActor; + /* 0x10 */ u32 carryFlags; + /* 0x14 */ int carryType; + /* 0x18 */ u16 field_0x18; + /* 0x1A */ u16 field_0x1A; + /* 0x1C */ mVec3_c field_0x1C; + /* 0x28 */ mMtx_c carryTransMtx; + /* 0x58 */ mMtx_c field_0x58; + /* 0x88 */ s32 isCarried; + /* 0x8C */ u8 field_0x8C[0x10]; // mQuat_c + /* 0x9C */ void *dtor; // ??? + /* 0xA0 */ u32 field_0xA0; + /* 0xA4 */ u32 field_0xA4; +}; // Ghidra: ActorObjectBase // size: 0x330 @@ -26,23 +44,29 @@ public: f32 forwardSpeed; f32 forwardAccel; f32 forwardMaxSpeed; - // TODO: add the rest - u8 unk1[0x15C - 0x150]; + mVec3_c velocity; /* 0x15C */ mMtx_c worldMatrix; - nw4r::math::AABB boundingBox; - u8 unk_0x1A4[0x330 - 0x1A4]; + u8 unk_0x1A4[0x1E8 - 0x1A4]; + + /* 0x1E8 */ mVec3_c posIncrements; + + u8 unk_0x1F4[0x210 - 0x1F4]; + + /* 0x210 */ ActorCarryStruct mActorCarryInfo; + + u8 unk_0x1EC[0x330 - 0x2B8]; public: // could be their own thing? - /* 8002de40 */ static void *getOarcFile(char *oarcName, char *fileName); - /* 8002de60 */ static void *getOarcSubEntry(char *oarcName, char *fileName); - /* 8002de80 */ static void *getOarcResFile(char *oarcName); - /* 8002de90 */ static void *getOarcModelFile(char *oarcName); - /* 8002dea0 */ static void *getOarcZev(char *oarcName); - /* 8002deb0 */ static void *getOarcDZB(char *dzbName); - /* 8002ded0 */ static void *getOarcPLC(char *plcName); + /* 8002de40 */ static void *getOarcFile(const char *oarcName, const char *fileName); + /* 8002de60 */ static void *getOarcSubEntry(const char *oarcName, const char *fileName); + /* 8002de80 */ static void *getOarcResFile(const char *oarcName); + /* 8002de90 */ static void *getOarcModelFile(const char *oarcName); + /* 8002dea0 */ static void *getOarcZev(const char *oarcName); + /* 8002deb0 */ static void *getOarcDZB(const char *dzbName); + /* 8002ded0 */ static void *getOarcPLC(const char *plcName); public: /* 8002def0 */ dAcObjBase_c(); @@ -74,7 +98,7 @@ public: /* 8002eb30 */ void fn_8002EB30(void *); /* 8002eb90 */ void putInODesert(f32 depth, mVec3_c *position); // Disabling makes Items and Link Disappear - /* 8002ec70 */ void drawModelType1(); + /* 8002ec70 */ void drawModelType1(m3d::smdl_c *smdl); // Disabling make Lava and other objects Disappear /* 8002ecd0 */ void drawModel2(); /* 8002ed20 */ void fn_8002ed20(); @@ -93,6 +117,15 @@ public: mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2); /* 8002f260 */ static dAcBase_c *createActorUnkGroup3(char *name, u32 roomId, u32 params1, mVec3_c *pos, mAng3_c *rot, mVec3_c *scale, u32 params2, u16 id, u8 viewclipId); + +protected: + inline void setBoundingBox(mVec3_c min, mVec3_c max) { + boundingBox.min = min; + boundingBox.max = max; + } }; +// Actors' createHeap functions often have patterns that can be matched with this macro +#define TRY_CREATE(thing) do { bool result = (thing); if (!result) return result; } while (0); + #endif diff --git a/include/d/a/obj/d_a_obj_lava_F200.h b/include/d/a/obj/d_a_obj_lava_F200.h new file mode 100644 index 00000000..8024801e --- /dev/null +++ b/include/d/a/obj/d_a_obj_lava_F200.h @@ -0,0 +1,26 @@ +#ifndef D_A_OBJ_LAVA_F200_H +#define D_A_OBJ_LAVA_F200_H + +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_anmmatclr.h> +#include <m/m3d/m_anmtexsrt.h> +#include <m/m3d/m_smdl.h> + +class dAcOlavaF200_c : public dAcObjBase_c { +public: + dAcOlavaF200_c() {} + virtual ~dAcOlavaF200_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + +private: + nw4r::g3d::ResFile mBrres; + m3d::smdl_c mModels[2]; + m3d::anmTexSrt_c mTexAnms[2]; + m3d::anmMatClr_c mClrAnms[2]; +}; + +#endif diff --git a/include/d/a/obj/d_a_obj_mole_soil.h b/include/d/a/obj/d_a_obj_mole_soil.h new file mode 100644 index 00000000..34342bf8 --- /dev/null +++ b/include/d/a/obj/d_a_obj_mole_soil.h @@ -0,0 +1,39 @@ +#ifndef D_A_OBJ_MOLE_SOIL_H +#define D_A_OBJ_MOLE_SOIL_H + +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_smdl.h> +#include <s/s_State.hpp> +#include <s/s_StateMgr.hpp> + +class dAcOmoleSoil_c : public dAcObjBase_c { +public: + dAcOmoleSoil_c() : mStateMgr(*this, sStateID::null) {} + virtual ~dAcOmoleSoil_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + STATE_FUNC_DECLARE(dAcOmoleSoil_c, Wait); + STATE_FUNC_DECLARE(dAcOmoleSoil_c, Appear); + STATE_FUNC_DECLARE(dAcOmoleSoil_c, DisAppear); + +private: + const static f32 sHalfScale; + const static f32 sFullScale; + + u8 getNextState() { + return mDesiredNextState; + } + + nw4r::g3d::ResFile mBrres; + m3d::smdl_c mModel; + STATE_MGR_DECLARE(dAcOmoleSoil_c); + f32 mScale; + u8 mDesiredNextState; + bool field_0x391; +}; + +#endif diff --git a/include/d/a/obj/d_a_obj_ring.h b/include/d/a/obj/d_a_obj_ring.h new file mode 100644 index 00000000..5b5b69e7 --- /dev/null +++ b/include/d/a/obj/d_a_obj_ring.h @@ -0,0 +1,38 @@ +#ifndef D_A_OBJ_RING_H +#define D_A_OBJ_RING_H + +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_smdl.h> +#include <s/s_State.hpp> +#include <s/s_StateMgr.hpp> + +class dAcOring_c : public dAcObjBase_c { +public: + dAcOring_c() : mStateMgr(*this, sStateID::null) {} + virtual ~dAcOring_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + STATE_FUNC_DECLARE(dAcOring_c, Move); + + u8 getArgFromParams() { + u32 p = (params & 3); + return p != 3 ? p : 0; + } + +private: + + static u32 ROT_PER_TICK; + + m3d::smdl_c mModel; + STATE_MGR_DECLARE(dAcOring_c); + u8 field_0x388; + f32 field_0x38C; + + +}; + +#endif diff --git a/include/d/a/obj/d_a_obj_smoke.h b/include/d/a/obj/d_a_obj_smoke.h new file mode 100644 index 00000000..dd1f404b --- /dev/null +++ b/include/d/a/obj/d_a_obj_smoke.h @@ -0,0 +1,30 @@ +#ifndef D_A_OBJ_SMOKE_H +#define D_A_OBJ_SMOKE_H + +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_anmtexsrt.h> +#include <m/m3d/m_smdl.h> +#include <s/s_State.hpp> +#include <s/s_StateMgr.hpp> + +class dAcOsmoke_c : public dAcObjBase_c { +public: + dAcOsmoke_c() : mStateMgr(*this, sStateID::null) {} + virtual ~dAcOsmoke_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + STATE_FUNC_DECLARE(dAcOsmoke_c, Wait); + +private: + nw4r::g3d::ResFile mBrres; + m3d::smdl_c mModel; + m3d::anmTexSrt_c mTexAnm; + STATE_MGR_DECLARE(dAcOsmoke_c); + u8 mType; +}; + +#endif diff --git a/include/d/a/obj/d_a_obj_sun_light.h b/include/d/a/obj/d_a_obj_sun_light.h new file mode 100644 index 00000000..b3badc71 --- /dev/null +++ b/include/d/a/obj/d_a_obj_sun_light.h @@ -0,0 +1,31 @@ +#ifndef D_A_OBJ_SUN_LIGHT_H +#define D_A_OBJ_SUN_LIGHT_H + +#include <d/a/obj/d_a_obj_base.h> +#include <m/m3d/m_anmtexsrt.h> +#include <m/m3d/m_smdl.h> +#include <s/s_State.hpp> +#include <s/s_StateMgr.hpp> + +class dAcOsunLight_c : public dAcObjBase_c { +public: + dAcOsunLight_c() : mStateMgr(*this, sStateID::null) {} + virtual ~dAcOsunLight_c() {} + virtual bool createHeap() override; + virtual int create() override; + virtual int actorExecute() override; + virtual int draw() override; + virtual int doDelete() override; + + bool isDay(); + + STATE_FUNC_DECLARE(dAcOsunLight_c, Wait); + +private: + nw4r::g3d::ResFile mBrres; + m3d::smdl_c mModel; + STATE_MGR_DECLARE(dAcOsunLight_c); + m3d::anmTexSrt_c mTexAnm; +}; + +#endif diff --git a/include/egg/core/eggFrmHeap.h b/include/egg/core/eggFrmHeap.h index f68e8e4f..10757d7c 100644 --- a/include/egg/core/eggFrmHeap.h +++ b/include/egg/core/eggFrmHeap.h @@ -22,7 +22,7 @@ public: public: /* 80495fa0 */ FrmHeap(MEMiHeapHead *heapHead); /* 80496060 */ static FrmHeap *create(void *block, size_t size, u16 attr); - /* 804962a0 */ void free(u32 flags); + /* 804962a0 */ void free(s32 flags); /* 80496370 */ void recordState(u32 id); // non official for now /* 80496380 */ void freeState(u32 id); // non official for now }; diff --git a/include/egg/core/eggHeap.h b/include/egg/core/eggHeap.h index 548db726..e0730703 100644 --- a/include/egg/core/eggHeap.h +++ b/include/egg/core/eggHeap.h @@ -162,9 +162,9 @@ public: } // namespace EGG /* 80495a60 */ void *operator new(size_t, void *p); -/* 80495a70 */ void *operator new(size_t size, EGG::Heap *heap, int align); +/* 80495a70 */ void *operator new(size_t size, EGG::Heap *heap, int align = 4); /* 80495a80 */ void *operator new(size_t size, EGG::Allocator *alloc); /* 80495a90 */ void *operator new[](size_t size, int align); -/* 80495aa0 */ void *operator new[](size_t size, EGG::Heap *heap, int align); +/* 80495aa0 */ void *operator new[](size_t size, EGG::Heap *heap, int align = 4); #endif diff --git a/include/egg/core/eggSystem.h b/include/egg/core/eggSystem.h index e124b306..9fe8e9db 100644 --- a/include/egg/core/eggSystem.h +++ b/include/egg/core/eggSystem.h @@ -57,6 +57,9 @@ public: } }; +template <class TVideo, class TDisplay, class TXfbManager, class TAudioManager, class TSceneManager, class TPerfView> +class TSystem : ConfigurationData {}; + } // namespace EGG #endif diff --git a/include/egg/gfx/eggDrawGX.h b/include/egg/gfx/eggDrawGX.h new file mode 100644 index 00000000..91ce5fc8 --- /dev/null +++ b/include/egg/gfx/eggDrawGX.h @@ -0,0 +1,37 @@ +#ifndef EGG_DRAWGX_H +#define EGG_DRAWGX_H + +#include <common.h> +#include <egg/core/eggHeap.h> +#include <egg/gfx/eggTexture.h> +#include <egg/math/eggMatrix.h> +#include <rvl/GX.h> + + +namespace EGG { + +class DrawGX { +public: + static void Initialize(Heap *); + + static GXTexMapID GetTexMapDefault(); + static void LoadTexture(const EGG::ResTIMG *, GXTexMapID); + + // TODO MORE + + /* static ?? s_DL */ + + static Matrix34f s_cameraMtx; + + /* static ?? s_flag */ + + static GXColor BLACK; + static GXColor WHITE; + static GXColor GREEN; + static GXColor RED; + static GXColor BLUE; +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggFog.h b/include/egg/gfx/eggFog.h new file mode 100644 index 00000000..d9318066 --- /dev/null +++ b/include/egg/gfx/eggFog.h @@ -0,0 +1,28 @@ +#ifndef EGG_FOG_H +#define EGG_FOG_H + +#include <egg/prim/eggBinary.h> +#include <nw4r/types_nw4r.h> + +namespace EGG { + +// TODO: Add members +class FogManager : IBinary<FogManager> { +public: + FogManager(u16); + virtual ~FogManager(); + virtual void SetBinaryInner(Bin &) override; + virtual void GetBinaryInner(Bin *) const override; + virtual size_t GetBinarySize() override; + virtual void SetBinaryInner(const Bin &, const Bin &, f32) override; + + void Calc(); + void CopyToG3D(nw4r::g3d::ScnRoot *) const; + + /* 0x04 */ u8 mFlag; + /* 0x05 */ u8 TODO[0x10 - 0x05]; +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggFrustum.h b/include/egg/gfx/eggFrustum.h new file mode 100644 index 00000000..770dd328 --- /dev/null +++ b/include/egg/gfx/eggFrustum.h @@ -0,0 +1,24 @@ +#ifndef EGG_FRUSTUM_H +#define EGG_FRUSTUM_H + +#include <common.h> +#include <nw4r/g3d/g3d_camera.h> + +namespace EGG { + +// TODO: Fill out more +class Frustum { +public: + enum CanvasMode {}; + enum ProjectionType {}; + + u8 TODO_0x00[0x38]; + // vt at 0x38 + virtual ~Frustum(); + virtual void SetProjectionGX() const; + virtual void CopyToG3D(nw4r::g3d::Camera) const; +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggGfxEngine.h b/include/egg/gfx/eggGfxEngine.h new file mode 100644 index 00000000..8844587a --- /dev/null +++ b/include/egg/gfx/eggGfxEngine.h @@ -0,0 +1,30 @@ +#ifndef EGG_GFXENGINE_H +#define EGG_GFXENGINE_H + +#include <common.h> +#include <rvl/GX.h> + +namespace EGG { + +namespace GfxEngine { + +struct Configuration { + /* 0x00 */ u16 efbWidth; + /* 0x02 */ u16 efbHeight; + /* 0x04 */ GXColor clearColor; + /* 0x08 */ u32 field_0x08; + /* 0x0C */ u16 field_0x0C; + /* 0x0E */ u16 field_0x0E; + /* 0x10 */ u32 bufferSize; + /* 0x14 */ u16 field_0x14; + /* 0x16 */ u16 field_0x16; + /* 0x18 */ u8 UNK_0x18[4]; + Configuration(); + virtual ~Configuration() {} +}; + +} // namespace GfxEngine + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggLight.h b/include/egg/gfx/eggLight.h new file mode 100644 index 00000000..073705a7 --- /dev/null +++ b/include/egg/gfx/eggLight.h @@ -0,0 +1,53 @@ +#ifndef EGG_LIGHT_H +#define EGG_LIGHT_H + +#include <egg/prim/eggBinary.h> +#include <nw4r/types_nw4r.h> + +namespace EGG { + +// TODO: Fill out more +class LightTexture { +public: + static void initialize(u16 textureSize, Heap *pHeap); +}; + +// TODO: Fill out more +class LightTextureManager : public IBinary<LightTextureManager> { +public: + virtual ~LightTextureManager(); + virtual void SetBinaryInner(Bin &) override; + virtual void GetBinaryInner(Bin *) const override; + virtual size_t GetBinarySize() override; + virtual void SetBinaryInner(const Bin &, const Bin &, f32) override; + + void drawAndCaptureTexture(f32, f32, f32, f32); +}; + +// TODO: Fill out more +class LightManager : public IBinary<LightManager> { +public: + // vt at 0x00 + LightManager(u32, u32, u8); + virtual ~LightManager(); + virtual void SetBinaryInner(Bin &) override; + virtual void GetBinaryInner(Bin *) const override; + virtual size_t GetBinarySize() override; + virtual void SetBinaryInner(const Bin &, const Bin &, f32) override; + virtual void Reset(); + virtual void Calc(nw4r::g3d::ScnRoot *); + virtual void CalcView(const nw4r::math::MTX34 &, u8, nw4r::g3d::ScnRoot *); + virtual void DoneDraw(); + + LightTextureManager *GetTextureMgr() const { + return mTextureMgr; + } + + u8 TODO_0x04[0x14 - 0x04]; + LightTextureManager *mTextureMgr; + u8 TODO_0x18[0x28 - 0x18]; +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggScreen.h b/include/egg/gfx/eggScreen.h new file mode 100644 index 00000000..b1b1c422 --- /dev/null +++ b/include/egg/gfx/eggScreen.h @@ -0,0 +1,27 @@ +#ifndef EGG_SCREEN_H +#define EGG_SCREEN_H + +#include <common.h> +#include <egg/gfx/eggFrustum.h> + +namespace EGG { + +// TODO: Fill out more +class Screen : public Frustum { +public: + Screen(); + Screen(f32, f32, f32, f32, Screen *, CanvasMode); + + virtual ~Screen(); + virtual void SetProjectionGX() const override; + virtual void CopyToG3D(nw4r::g3d::Camera) const override; + + static void Initialize(const u16 *, const u16 *, Screen *); + static void SetTVModeDefault(); + + u8 TODO_0x3C[0x88 - 0x3C]; +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggStateGX.h b/include/egg/gfx/eggStateGX.h new file mode 100644 index 00000000..5d2badb6 --- /dev/null +++ b/include/egg/gfx/eggStateGX.h @@ -0,0 +1,45 @@ +#ifndef EGG_STATE_GX_H +#define EGG_STATE_GX_H + +#include <common.h> +#include <rvl/GX.h> + +namespace EGG { + +class StateGX { +public: + static void initialize(u16, u16, GXColor, GXPixelFmt); + static void frameInit(); + static void textureInit(); // Guess for 804b4810 + + static void resetGX(); + static void resetVtx(); + static void resetColorChannel(); + static void resetIndirect(); + static void resetTexture(); + static void resetTexGen(); + static void resetTev(); + static void resetPE(); + + static void resetGXCache(); + + static void GXSetPixelFmt(GXPixelFmt pixelFmt, GXZFmt16 zFmt); + + static void invalidateTexAllGX(); + + static bool GXSetColorUpdate(bool); + static bool GXSetAlphaUpdate(bool); + static bool GXSetDither(); + static void GXCopyTex(); + static bool GXSetDstAlpha(); + // Unk func here + static void GXSetProjection(Mtx44, int); + static void GXSetProjectionv(const f32 *); + static void GXSetViewport(f32, f32, f32, f32, f32, f32); + static void GZSetScissor(u32, u32, u32, u32); + static void GZSetScissorBoxOffset(s32, s32); +}; + +} // namespace EGG + +#endif diff --git a/include/egg/gfx/eggTexture.h b/include/egg/gfx/eggTexture.h new file mode 100644 index 00000000..dcf0e926 --- /dev/null +++ b/include/egg/gfx/eggTexture.h @@ -0,0 +1,11 @@ +#ifndef EGG_TEXTURE_H +#define EGG_TEXTURE_H + +namespace EGG { + +// TODO: Implement Members +struct ResTIMG {}; + +} // namespace EGG + +#endif diff --git a/include/egg/math/eggVector.h b/include/egg/math/eggVector.h index 9aa50ae8..43d340dd 100644 --- a/include/egg/math/eggVector.h +++ b/include/egg/math/eggVector.h @@ -127,6 +127,7 @@ struct Vector3s { s16 x, y, z; public: + Vector3s() {} Vector3s(s16 sx, s16 sy, s16 sz) { x = sx; y = sy; diff --git a/include/egg/prim/eggBinary.h b/include/egg/prim/eggBinary.h new file mode 100644 index 00000000..6f127955 --- /dev/null +++ b/include/egg/prim/eggBinary.h @@ -0,0 +1,23 @@ +#ifndef EGG_BINARY_H +#define EGG_BINARY_H + +template <class T> +class IBinary { +public: + class Bin {}; + virtual void SetBinaryInner(Bin &) = 0; + virtual void GetBinaryInner(Bin *) const = 0; + virtual size_t GetBinarySize() = 0; + virtual void SetBinaryInner(const Bin &, const Bin &, f32) = 0; + + static const char *GetBinaryType(); + int GetVersion(); + + void GetBinary(void *) const; + + void SetBinary(const void *); + + void SetBinaryBlend(const void *, const void *, f32); +}; + +#endif diff --git a/include/m/m3d/m3d.h b/include/m/m3d/m3d.h new file mode 100644 index 00000000..d8ba87fc --- /dev/null +++ b/include/m/m3d/m3d.h @@ -0,0 +1,59 @@ +#ifndef M3D_H +#define M3D_H + +#include <egg/core/eggHeap.h> +#include <egg/gfx/eggFog.h> +#include <egg/gfx/eggLight.h> +#include <m/m_allocator.h> +#include <nw4r/g3d/g3d_scnroot.h> + +namespace m3d { + +namespace internal { + +extern mAllocator_c *l_allocator_p; +extern nw4r::g3d::ScnRoot *l_scnRoot_p; +extern u32 l_numLightMgr; +extern EGG::LightManager **l_lightMgr_pp; +extern u32 l_numFogMgr; +extern EGG::FogManager **l_fogMgr_pp; +extern size_t l_alignment; + +} // namespace internal + +bool create(EGG::Heap *pHeap, u32 maxNumChildren, u32 maxNumScnObj, u32 numLightObj, u32 numLightSet); +bool create(EGG::Heap *pHeap, GXPixelFmt pxlFmt, GXColor clearColor, u32 maxNumChildren, u32 maxNumScnObj, + u32 numLightObj, u32 numLightSet, u32 numLightMgr, u32 numFogMgr); +bool createLightMgr(EGG::Heap *, u16, u16, u8, bool, int); +bool createFogMgr(EGG::Heap *, int, int); + +nw4r::g3d::ScnRoot *getScnRoot(); +nw4r::g3d::Camera getCamera(int id); +nw4r::g3d::Camera getCurrentCamera(); +int getCurrentCameraID(); + +EGG::LightManager *getLightMgr(int idx); +EGG::FogManager *getFogMgr(int idx); +void drawDone(int idx); +void drawLightMapTexture(int idx); + +void calcWorld(int idx); +void calcMaterial(); +void calcView(int idx); + +void drawOpa(); +void drawXlu(); + +bool pushBack(nw4r::g3d::ScnObj *obj); +void clear(); + +void reset(); + +int getMatID(nw4r::g3d::ResMdl, const char *); +int getNodeID(nw4r::g3d::ResMdl, const char *); + +void resetMaterial(); + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmchr.h b/include/m/m3d/m_anmchr.h new file mode 100644 index 00000000..082cf504 --- /dev/null +++ b/include/m/m3d/m_anmchr.h @@ -0,0 +1,24 @@ +#ifndef M3D_M_ANMCHR_H +#define M3D_M_ANMCHR_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> +#include <nw4r/g3d/g3d_resanmchr.h> + +namespace m3d { + +class anmChr_c : public fanm_c { +public: + virtual ~anmChr_c(); + + virtual int getType() const override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmChr, mAllocator_c *, u32 *); + void setAnm(bmdl_c &, nw4r::g3d::ResAnmChr, playMode_e); + void setAnmAfter(bmdl_c &, nw4r::g3d::ResAnmChr, playMode_e); + void setFrmCtrlDefault(nw4r::g3d::ResAnmChr &, m3d::playMode_e); +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmchrblend.h b/include/m/m3d/m_anmchrblend.h new file mode 100644 index 00000000..e8d038d3 --- /dev/null +++ b/include/m/m3d/m_anmchrblend.h @@ -0,0 +1,28 @@ +#ifndef M3D_M_ANMCHRBLEND_H +#define M3D_M_ANMCHRBLEND_H + +#include <m/m3d/m_anmchr.h> +#include <m/m3d/m_banm.h> +#include <m/m3d/m_bmdl.h> +#include <nw4r/g3d/g3d_anmchr.h> + +namespace m3d { + +class anmChrBlend_c : public banm_c { +public: + virtual ~anmChrBlend_c(); + + virtual int getType() const override; + + bool create(nw4r::g3d::ResMdl, int, mAllocator_c *, u32 *); + void attach(int, nw4r::g3d::AnmObjChrRes *, f32); + void attach(int, anmChr_c *, f32); + void detach(int); + // Not in NSMBW + void setWeight(int, f32); + f32 getWeight(int) const; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmmatclr.h b/include/m/m3d/m_anmmatclr.h new file mode 100644 index 00000000..1a2db51c --- /dev/null +++ b/include/m/m3d/m_anmmatclr.h @@ -0,0 +1,57 @@ +#ifndef M3D_M_ANMMATCLR_H +#define M3D_M_ANMMATCLR_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> +#include <nw4r/g3d/g3d_anmclr.h> + +namespace m3d { + +class anmMatClr_c : public banm_c { + class child_c : public fanm_c { + public: + child_c() {} + virtual ~child_c(); + virtual int getType() const override; + + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmClr, bool); + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmClr, mAllocator_c *, u32 *); + void setAnm(bmdl_c &, nw4r::g3d::ResAnmClr, playMode_e); + void releaseAnm(); + void setFrmCtrlDefault(nw4r::g3d::ResAnmClr &, playMode_e); + }; + +public: + anmMatClr_c() : mpChildren(nullptr) {} + virtual ~anmMatClr_c(); + + virtual int getType() const override; + virtual void remove() override; + virtual void play() override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmClr, mAllocator_c *, u32 *, s32); + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmClr, s32, bool); + + void setAnm(bmdl_c &, nw4r::g3d::ResAnmClr, s32, playMode_e); + + void play(s32); + f32 getFrame(s32) const; + void setFrame(f32, s32); + f32 getRate(s32) const; + void setRate(f32, s32); + bool isStop(s32) const; + + bool checkFrame(f32, s32) const; + + void setPlayMode(playMode_e, s32); + f32 getFrameMax(s32) const; + void setFrameStart(f32, s32); + f32 getFrameStart(s32) const; + +private: + child_c *mpChildren; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmmdl.h b/include/m/m3d/m_anmmdl.h new file mode 100644 index 00000000..1673b421 --- /dev/null +++ b/include/m/m3d/m_anmmdl.h @@ -0,0 +1,50 @@ +#ifndef M3D_M_ANMMDL_H +#define M3D_M_ANMMDL_H + +#include <m/m3d/m_anmchr.h> +#include <m/m3d/m_mdl.h> +#include <nw4r/g3d/g3d_resfile.h> + +namespace m3d { + +// Not in NSMBW, name pulled from City Folk +class mdlAnmChr { +public: + mdlAnmChr() {} + virtual ~mdlAnmChr(); // 0x08 + + virtual void play(); // 0x0C + virtual void setFrame(f32); // 0x10 + virtual void setAnm(const char *name, playMode_e mode, f32); // 0x14 + virtual void setAnm(const char *name, playMode_e mode); // 0x18 + virtual void setRate(f32); // 0x20 + + bool create(void *mdlFile, void *anmFile, const char *mdlName, const char *anmName, mAllocator_c *alloc, + u32 bufferOption, int nView, u32 *pSize); + // Unknown overload + bool create2(void *mdlFile, void *anmFile, const char *mdlName, const char *anmName, mAllocator_c *alloc, + u32 bufferOption, int nView, u32 *pSize); + bool create(void *resFile, const char *mdlName, const char *anmName, mAllocator_c *alloc, u32 bufferOption, + int nView, u32 *pSize); + bool create(void *mdlFile, void *anmFile, const char *mdlName, const char *anmName, mdl_c::mdlCallback_c *callback, + mAllocator_c *alloc, u32 bufferOption, int nView, u32 *pSize); + + inline bool create(void *resFile, const char *mdlName, const char *anmName, mAllocator_c *alloc, u32 bufferOption) { + return create(resFile, mdlName, anmName, alloc, bufferOption, 1, nullptr); + } + + inline mdl_c &getModel() { + return mMdl; + } + +private: + nw4r::g3d::ResFile mMdlFile; + nw4r::g3d::ResFile mAnmFile; + + mdl_c mMdl; + anmChr_c mAnm; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmshp.h b/include/m/m3d/m_anmshp.h new file mode 100644 index 00000000..2e550802 --- /dev/null +++ b/include/m/m3d/m_anmshp.h @@ -0,0 +1,24 @@ +#ifndef M_M3D_ANMSHP_H +#define M_M3D_ANMSHP_H + +#include <common.h> +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> +#include <nw4r/g3d/g3d_resanmshp.h> + +namespace m3d { + +class anmShp_c : public fanm_c { +public: + virtual ~anmShp_c(); + + virtual int getType() const override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmShp, mAllocator_c *, u32 *); + void setAnm(m3d::bmdl_c &, nw4r::g3d::ResAnmShp, m3d::playMode_e); + void setFrmCtrlDefault(nw4r::g3d::ResAnmShp &, m3d::playMode_e); +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmtexpat.h b/include/m/m3d/m_anmtexpat.h new file mode 100644 index 00000000..1fc5b1d0 --- /dev/null +++ b/include/m/m3d/m_anmtexpat.h @@ -0,0 +1,52 @@ +#ifndef M3D_M_ANMTEXPAT_H +#define M3D_M_ANMTEXPAT_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> +#include <nw4r/g3d/g3d_anmtexpat.h> + +namespace m3d { + +class anmTexPat_c : public banm_c { + class child_c : public fanm_c { + public: + child_c() {} + virtual ~child_c(); + virtual int getType() const override; + + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexPat, bool); + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexPat, mAllocator_c *, u32 *); + void setAnm(m3d::bmdl_c &, nw4r::g3d::ResAnmTexPat, m3d::playMode_e); + void releaseAnm(); + void setFrmCtrlDefault(nw4r::g3d::ResAnmTexPat &, playMode_e); + }; + +public: + anmTexPat_c() : mpChildren(nullptr) {} + virtual ~anmTexPat_c(); + + virtual int getType() const override; + virtual void remove() override; + virtual void play() override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexPat, mAllocator_c *, u32 *, s32); + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexPat, s32, bool); + + void setAnm(bmdl_c &, nw4r::g3d::ResAnmTexPat, s32, playMode_e); + + void play(s32); + f32 getFrame(s32) const; + void setFrame(f32, s32); + void setRate(f32, s32); + bool isStop(s32) const; + + f32 getFrameMax(s32) const; + void setFrameStart(f32, s32); + +private: + child_c *mpChildren; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmtexsrt.h b/include/m/m3d/m_anmtexsrt.h new file mode 100644 index 00000000..d736a7b1 --- /dev/null +++ b/include/m/m3d/m_anmtexsrt.h @@ -0,0 +1,56 @@ +#ifndef M3D_M_ANMTEXSRT_H +#define M3D_M_ANMTEXSRT_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> +#include <nw4r/g3d/g3d_anmtexsrt.h> + +namespace m3d { + +class anmTexSrt_c : public banm_c { + class child_c : public fanm_c { + public: + child_c() {} + virtual ~child_c(); + virtual int getType() const override; + + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexSrt, bool); + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexSrt, mAllocator_c *, u32 *); + void setAnm(m3d::bmdl_c &, nw4r::g3d::ResAnmTexSrt, m3d::playMode_e); + void releaseAnm(); + void setFrmCtrlDefault(nw4r::g3d::ResAnmTexSrt &, playMode_e); + }; + +public: + anmTexSrt_c() : mpChildren(nullptr) {} + virtual ~anmTexSrt_c(); + + virtual int getType() const override; + virtual void remove() override; + virtual void play() override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexSrt, mAllocator_c *, u32 *, s32); + static u32 heapCost(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmTexSrt, s32, bool); + + void setAnm(bmdl_c &, nw4r::g3d::ResAnmTexSrt, s32, playMode_e); + + void play(s32); + f32 getFrame(s32) const; + void setFrame(f32, s32); + void setRate(f32, s32); + bool isStop(s32) const; + + bool checkFrame(f32, s32) const; + + void setPlayMode(playMode_e, s32); + f32 getFrameMax(s32) const; + void setFrameStart(f32, s32); + f32 getFrameStart(s32) const; + +private: + child_c *mpChildren; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_anmvis.h b/include/m/m3d/m_anmvis.h new file mode 100644 index 00000000..053c330d --- /dev/null +++ b/include/m/m3d/m_anmvis.h @@ -0,0 +1,22 @@ +#ifndef M3D_M_ANMVIS_H +#define M3D_M_ANMVIS_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_fanm.h> + +namespace m3d { + +class anmVis_c : public fanm_c { +public: + virtual ~anmVis_c(); + + virtual int getType() const override; + + bool create(nw4r::g3d::ResMdl, nw4r::g3d::ResAnmVis, mAllocator_c *, u32 *); + void setAnm(m3d::bmdl_c &, nw4r::g3d::ResAnmVis, m3d::playMode_e); + void setFrmCtrlDefault(nw4r::g3d::ResAnmVis &, m3d::playMode_e); +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_banm.h b/include/m/m3d/m_banm.h new file mode 100644 index 00000000..35b1b896 --- /dev/null +++ b/include/m/m3d/m_banm.h @@ -0,0 +1,38 @@ +#ifndef M3D_M_BANM_H +#define M3D_M_BANM_H + +#include <egg/core/eggFrmHeap.h> +#include <m/m_allocator.h> +#include <nw4r/g3d/g3d_anmobj.h> + +namespace m3d { + +class banm_c { +public: + banm_c() : mpAnmObj(nullptr), mpFrameHeap(nullptr) {} + virtual ~banm_c(); + + virtual int getType() const = 0; + virtual void remove(); + virtual void play(); + + bool createAllocator(mAllocator_c *alloc, u32 *pSize); + bool IsBound() const; + f32 getFrame() const; + void setFrameOnly(f32); + f32 getRate() const; + void setRate(f32); + + inline nw4r::g3d::AnmObj *getAnimObj() const { + return mpAnmObj; + } + +protected: + nw4r::g3d::AnmObj *mpAnmObj; + EGG::FrmHeap *mpFrameHeap; + mAllocator_c mAllocator; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_bline.h b/include/m/m3d/m_bline.h new file mode 100644 index 00000000..d47f269c --- /dev/null +++ b/include/m/m3d/m_bline.h @@ -0,0 +1,85 @@ +#ifndef M3D_BLINE_H +#define M3D_BLINE_H + +#include <egg/gfx/eggTexture.h> +#include <m/m3d/m_proc.h> +#include <m/m_math.h> +#include <nw4r/ut/ut_Color.h> + +namespace m3d { + +// The Actual line +class bline_c { +public: + bline_c() : mpPathArr(0), mpVtxPosArr(0), mpVtxNrmArr(0), mpVtxTexArr(0), mFlags(0) {} + // This is mainly a Guess, When the array is created, it has both a ctor/dtor + struct VtxPos { + mVec3_c pos1; + mVec3_c pos2; + }; + struct Vec3u8 { + u8 x, y, z; + }; + // This is mainly a Guess, When the array is created, it has only a ctor + struct VtxNrm { + union { + struct { + Vec3u8 nrm1; + Vec3u8 nrm2; + }; + EGG::Vector3s nrm_u16; // There is a short by short copy later + }; + }; + // This is mainly a Guess, When the array is created, it doesnt use the array alloc + struct VtxTex { + f32 tex; + }; + + /* 0x00 */ u8 field_0x00[0x8]; + + bool create(EGG::Heap *pHeap, u16 numPts, f32 width, f32 repeat, const nw4r::ut::Color &color); + void update(mVec3_c *startPos); + void remove(); + void draw(); + + // vt at 0x08 + virtual ~bline_c(); + + /* 0x0C */ f32 mWidth; // could be a scale too + /* 0x10 */ nw4r::ut::Color mColor; + /* 0x14 */ mVec3_c *mpPathArr; + /* 0x18 */ VtxPos *mpVtxPosArr; + /* 0x1C */ VtxNrm *mpVtxNrmArr; + /* 0x20 */ VtxTex *mpVtxTexArr; + /* 0x24 */ f32 mTexRepeat; // Higher value causes the texture to repeat more often + /* 0x28 */ u16 mPathNum; // Guess + /* 0x2A */ u16 mVtxNum; // Guess + /* 0x2C */ u16 field_0x2C; + /* 0x2E */ u8 mFlags; + /* 0x2F u8 _pad; */ +}; + +class blineMat_c : public proc_c { +public: + virtual ~blineMat_c(); + virtual void remove() override; + virtual void drawOpa() override; + virtual void drawXlu() override; + virtual void setupGX(bool bTransparent); + + bool create(mAllocator_c *pAllocator, int numLines, u16 numLinePts, f32 width, f32 repeat, nw4r::ut::Color &color, + EGG::ResTIMG *pTex, bool); + void update(); + bline_c *getLine(u16 idx); + + /* 0x1C */ mAllocator_c mAllocator; + /* 0x34 */ EGG::ResTIMG *mpTex; + /* 0x38 */ nw4r::ut::List mLines; + /* 0x44 */ bline_c *mpLineArr; + /* 0x48 */ short mLineArrNum; + /* 0x4A */ bool field_0x4A; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_bmdl.h b/include/m/m3d/m_bmdl.h new file mode 100644 index 00000000..aa692b29 --- /dev/null +++ b/include/m/m3d/m_bmdl.h @@ -0,0 +1,48 @@ +#ifndef M3D_M_BMDL_H +#define M3D_M_BMDL_H + +#include <m/m3d/m_banm.h> +#include <m/m3d/m_scnleaf.h> +#include <m/m_math.h> +#include <nw4r/g3d/g3d_scnmdlsmpl.h> + +namespace m3d { + +class bmdl_c : public scnLeaf_c { +public: + bmdl_c() : mpCurrentAnm(nullptr) {} + virtual ~bmdl_c(); + + virtual int getType() const override; + virtual void remove() override; + virtual void setAnm(banm_c &anm); + virtual void play(); + + int getMatID(const char *name) const; + int getNodeID(const char *name) const; + bool getNodeWorldMtx(u32 p1, nw4r::math::MTX34 *out) const; + bool getNodeWorldMtxMultVecZero(u32 p1, nw4r::math::VEC3 &out) const; + bool getNodeWorldMtxMultVec(u32, nw4r::math::VEC3 &, nw4r::math::VEC3 &) const; + nw4r::g3d::ResMdl getResMdl() const; + nw4r::g3d::ResMat getResMat(u32 index) const; + + void removeAnm(nw4r::g3d::ScnMdlSimple::AnmObjType); + nw4r::g3d::AnmObj *getAnmObj(nw4r::g3d::ScnMdlSimple::AnmObjType) const; + void setTevColor(u32, GXTevRegID, GXColor, bool); + void setTevColorAll(GXTevRegID, GXColor, bool); + void setTevKColor(u32, GXTevKColorID, GXColor, bool); + void setTevKColorAll(GXTevKColorID, GXColor, bool); + void setBlendModeAll(GXBlendMode, GXBlendFactor, GXBlendFactor, GXLogicOp, bool bMarkDirty); + void setCullMode(u32 matId, GXCullMode cullMode, bool bMarkDirty); + void setCullModeAll(GXCullMode cullMode, bool bMarkDirty); + void setMatVisible(u32 matId, bool bVisble); + int setMatTexture(char *name, GXTexObj *texObj, bool copy, void *unk, int, int); + bool getBounds(mVec3_c *min, mVec3_c *max); + +private: + banm_c *mpCurrentAnm; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_calc_ratio.h b/include/m/m3d/m_calc_ratio.h new file mode 100644 index 00000000..ee850bc9 --- /dev/null +++ b/include/m/m3d/m_calc_ratio.h @@ -0,0 +1,49 @@ +#ifndef M3D_M_CALC_RATIO_H +#define M3D_M_CALC_RATIO_H + +#include <egg/core/eggFrmHeap.h> +#include <m/m_allocator.h> + +namespace m3d { + +class calcRatio_c { +public: + calcRatio_c(); + virtual ~calcRatio_c(); + + void remove(); + void reset(); + void offUpdate(); + void set(f32); + void calc(); + bool isEnd() const; + + f32 get0x10() const { + return mf4; + } + + f32 get0x14() const { + return mf5; + } + + bool is0x18() const { + return mb1; + } + + bool is0x19() const { + return mb2; + } + +private: + /* 0x04 */ f32 mf1; + /* 0x08 */ f32 mf2; + /* 0x0C */ f32 mf3; + /* 0x10 */ f32 mf4; + /* 0x14 */ f32 mf5; + /* 0x18 */ bool mb1; + /* 0x19 */ bool mb2; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_fanm.h b/include/m/m3d/m_fanm.h new file mode 100644 index 00000000..1dc0d9f2 --- /dev/null +++ b/include/m/m3d/m_fanm.h @@ -0,0 +1,58 @@ +#ifndef M3D_M_FANM_H +#define M3D_M_FANM_H + +#include <m/m3d/m_banm.h> + +namespace m3d { + +enum playMode_e { + PLAY_MODE_0, + PLAY_MODE_1, + PLAY_MODE_2, + PLAY_MODE_3, + PLAY_MODE_4, +}; + +class fanm_c : public banm_c { +public: + fanm_c(); + virtual ~fanm_c(); + + virtual int getType() const = 0; + virtual void play(); + + void set(f32, playMode_e, f32, f32); + void set2(f32, playMode_e, f32, f32, f32); + void setFrame(f32); + void setFrameOnly(f32); + bool isStop() const; + bool checkFrame(f32) const; + bool unk_802EAE70() const; + + inline void setPlayState(playMode_e state) { + mPlayState = state; + } + + inline f32 getEndFrame() { + return mEndFrame; + } + + // Something about this is wrong + inline void setStartFrame(f32 f) { + mEndFrame = f; + } + + inline f32 getStartFrame() { + return mStartFrame; + } + +private: + f32 mEndFrame; + f32 mStartFrame; + f32 mCurrentFrame; + u8 mPlayState; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_mdl.h b/include/m/m3d/m_mdl.h new file mode 100644 index 00000000..82b475e8 --- /dev/null +++ b/include/m/m3d/m_mdl.h @@ -0,0 +1,76 @@ +#ifndef M3D_M_MDL_H +#define M3D_M_MDL_H + +#include <m/m3d/m_banm.h> +#include <m/m3d/m_calc_ratio.h> +#include <m/m3d/m_smdl.h> +#include <nw4r/g3d/g3d_anmchr.h> +#include <nw4r/g3d/g3d_calcworld.h> +#include <nw4r/g3d/g3d_resmdl.h> + +namespace m3d { + +class callback_c { +public: + virtual ~callback_c() {} + virtual void timingA(u32, nw4r::g3d::ChrAnmResult *, nw4r::g3d::ResMdl) {} + virtual void timingB(u32, nw4r::g3d::WorldMtxManip *, nw4r::g3d::ResMdl) {} + virtual void timingC(nw4r::math::MTX34 *, nw4r::g3d::ResMdl) {} +}; + +class mdl_c : public smdl_c { +public: + class mdlCallback_c : public nw4r::g3d::ICalcWorldCallback { + public: + mdlCallback_c(); + virtual ~mdlCallback_c(); + + bool create(nw4r::g3d::ResMdl, mAllocator_c *, u32 *); + + virtual void ExecCallbackA(nw4r::g3d::ChrAnmResult *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *); + virtual void ExecCallbackB(nw4r::g3d::WorldMtxManip *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *); + virtual void ExecCallbackC(nw4r::math::MTX34 *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *); + + void remove(); + void setBlendFrame(f32); + void calcBlend(); + + mAllocator_c *getAllocator() { + return mpAlloc; + } + + void setBaseCallback(callback_c *cb) { + mpBaseCallback = cb; + } + + private: + /* 0x04 */ calcRatio_c mCalcRatio; + /* 0x20 */ int mNumNode; + /* 0x24 */ nw4r::g3d::ChrAnmResult *mpNodes; + /* 0x28 */ callback_c *mpBaseCallback; + /* 0x2C */ mAllocator_c *mpAlloc; + }; + + mdl_c(); + virtual ~mdl_c(); + + bool create(nw4r::g3d::ResMdl, mAllocator_c *, u32, int, u32 *); + bool create(nw4r::g3d::ResMdl, mdlCallback_c *cb, mAllocator_c *, u32, int, u32 *); + + virtual void remove(); + + void setCallback(callback_c *cb); + void play(); + void setAnm(banm_c &); + void setAnm(banm_c &, f32); + +private: + /** If we allocated the callback ourselves, this is what we need to free */ + mdlCallback_c *mpOwnedCallback; + /** The actual callback to use */ + mdlCallback_c *mpCallback; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_proc.h b/include/m/m3d/m_proc.h new file mode 100644 index 00000000..47fc4c84 --- /dev/null +++ b/include/m/m3d/m_proc.h @@ -0,0 +1,21 @@ +#ifndef M_M3D_PROC_H +#define M_M3D_PROC_H + +#include <common.h> +#include <m/m3d/m_scnleaf.h> + +namespace m3d { + +class proc_c : public scnLeaf_c { +public: + virtual ~proc_c(); + virtual int getType() const override; + bool create(mAllocator_c *, u32 *); + + virtual void drawOpa(); + virtual void drawXlu(); +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_scnleaf.h b/include/m/m3d/m_scnleaf.h new file mode 100644 index 00000000..18e9db9c --- /dev/null +++ b/include/m/m3d/m_scnleaf.h @@ -0,0 +1,58 @@ +#ifndef M3D_M_SCNLEAF_H +#define M3D_M_SCNLEAF_H + +#include <egg/core/eggDisposer.h> +#include <m/m_allocator.h> +#include <nw4r/g3d/g3d_scnobj.h> + +namespace m3d { + +// NON-OFFICIAL +enum ScnLeafType_e { + SCN_LEAF_MODEL = 0, + SCN_LEAF_PROC = 2, +}; + +class UnkClass { +public: + UnkClass() {} +}; + +class scnLeaf_c : UnkClass, EGG::Disposer { +public: + scnLeaf_c(); + virtual ~scnLeaf_c(); + virtual int getType() const = 0; + virtual void remove(); + virtual int entry(); + + void setOption(u32 flag, u32 set); + void setScale(f32, f32, f32); + void setScale(const nw4r::math::VEC3 &); + void getScale(nw4r::math::VEC3 *) const; + + void setLocalMtx(const nw4r::math::MTX34 *); + void getLocalMtx(nw4r::math::MTX34 *) const; + const nw4r::math::MTX34 *getLocalMtx() const; + void getWorldMtx(nw4r::math::MTX34 *) const; + void getViewMtx(nw4r::math::MTX34 *) const; + + void setCallback(nw4r::g3d::IScnObjCallback *cb); + nw4r::g3d::IScnObjCallback *swapCallback(nw4r::g3d::IScnObjCallback *cb); + + void enableCallbackTiming(nw4r::g3d::ScnObj::Timing); + void enableCallbackOp(nw4r::g3d::ScnObj::ExecOp); + + void calc(bool); + void calcVtx(bool); + void calcView(void *, bool); + + void setPriorityDraw(int, int); + +protected: + nw4r::g3d::ScnLeaf *mpScnLeaf; +}; + +} // namespace m3d + +#endif diff --git a/include/m/m3d/m_smdl.h b/include/m/m3d/m_smdl.h new file mode 100644 index 00000000..e55f759a --- /dev/null +++ b/include/m/m3d/m_smdl.h @@ -0,0 +1,25 @@ +#ifndef M3D_M_SMDL_H +#define M3D_M_SMDL_H + +#include <m/m3d/m_bmdl.h> +#include <m/m3d/m_scnleaf.h> +#include <nw4r/g3d/g3d_resmdl.h> + +class UnkClass2 {}; + +namespace m3d { + +class smdl_c : public bmdl_c, UnkClass2 { +public: + smdl_c(); + virtual ~smdl_c(); + + bool create(nw4r::g3d::ResMdl mdl, mAllocator_c *alloc, u32 bufferOption, int nView, u32 *pSize); + bool create(nw4r::g3d::ResMdl mdl, mAllocator_c *alloc, u32 bufferOption) { + return create(mdl, alloc, bufferOption, 1, nullptr); + } +}; + +} // namespace m3d + +#endif diff --git a/include/m/m_allocator.h b/include/m/m_allocator.h index e4f2a175..4391ad0e 100644 --- a/include/m/m_allocator.h +++ b/include/m/m_allocator.h @@ -26,6 +26,8 @@ public: s32 adjustExpHeap(); bool createNewTempFrmHeap(s32 size, EGG::Heap *newHeap, char *heapName, s32 align, u32 unk); void adjustFrmHeapRestoreCurrent(); - static void *allocOnHeap(u32 size, mHeapAllocator_c *allocator); }; + +void *operator new[](size_t size, mAllocator_c *); + #endif diff --git a/include/m/m_mtx.h b/include/m/m_mtx.h index ee60b72d..879e62cf 100644 --- a/include/m/m_mtx.h +++ b/include/m/m_mtx.h @@ -8,6 +8,8 @@ #include "nw4r/nw4r_types.h" #include <common.h> +#pragma push +#pragma warning off(10402) class mMtx_c { public: mMtx_c(){}; @@ -38,10 +40,15 @@ public: /* 802f1c40 */ void rot(int, int); // does some werrd operation to rotate the matrix /* 802f1e60 */ bool quatRelated(); + operator nw4r::math::MTX34 *() { + return &nw4rm; + } + public: union { EGG::Matrix34f mat; f32 m[3][4]; + nw4r::math::MTX34 nw4rm; struct { f32 xx, xy, xz, xw; f32 yx, yy, yz, yw; @@ -53,4 +60,6 @@ public: static mMtx_c Identity; }; +#pragma pop + #endif diff --git a/include/m/m_video.h b/include/m/m_video.h new file mode 100644 index 00000000..5a0e382b --- /dev/null +++ b/include/m/m_video.h @@ -0,0 +1,17 @@ +#ifndef M_VIDEO_H +#define M_VIDEO_H + +#include <egg/core/eggVideo.h> + +namespace mVideo { + +// 0x80065590 +void create(); + +extern EGG::Video *m_video; + +extern f32 l_fbAspect; + +} // namespace mVideo + +#endif diff --git a/include/nw4r/g3d/g3d_3dsmax.h b/include/nw4r/g3d/g3d_3dsmax.h index 56c56453..220e4d09 100644 --- a/include/nw4r/g3d/g3d_3dsmax.h +++ b/include/nw4r/g3d/g3d_3dsmax.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_3DSMAX_H #define NW4R_G3D_3DSMAX_H #include "common.h" -#include "g3d_anmtexsrt.h" +#include "nw4r/g3d/g3d_anmtexsrt.h" +#include "nw4r/math.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_anmcamera.h b/include/nw4r/g3d/g3d_anmcamera.h index 972ed03e..7a33f1dd 100644 --- a/include/nw4r/g3d/g3d_anmcamera.h +++ b/include/nw4r/g3d/g3d_anmcamera.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_ANMCAMERA_H #define NW4R_G3D_ANMCAMERA_H #include "common.h" -#include "math_types.h" +#include "nw4r/math/math_types.h" #include <rvl/GX.h> diff --git a/include/nw4r/g3d/g3d_anmchr.h b/include/nw4r/g3d/g3d_anmchr.h index 577bd8ff..49cc40c8 100644 --- a/include/nw4r/g3d/g3d_anmchr.h +++ b/include/nw4r/g3d/g3d_anmchr.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_ANMCHR_H #define NW4R_G3D_ANMCHR_H #include "common.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/math/math_types.h" namespace nw4r { namespace g3d { @@ -12,13 +13,80 @@ struct ChrAnmResult { math::MTX34 mMtx; // at 0x1C }; -struct AnmObjChr {}; +class AnmObjChrRes; -struct AnmObjChrNode {}; +class AnmObjChr : public AnmObj { +public: -struct AnmObjChrBlend {}; + enum BindOption {}; + + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + virtual ChrAnmResult *GetResult(ChrAnmResult *, u32); // at 0x38 + virtual void Attach(int, AnmObjChrRes*); // at 0x3C + virtual void Detach(int); // at 0x40 + virtual void DetachAll(); // at 0x44 + virtual void SetWeight(int, f32); // at 0x48 + virtual f32 GetWeight(int) const; // at 0x4C + virtual void Bind(ResMdl, u32, BindOption) = 0; // at 0x50 + virtual void Release(ResMdl, u32, BindOption) = 0; // at 0x54 + +private: + UNKWORD field_0x10; + UNKWORD field_0x14; + +protected: + NW4R_G3D_TYPE_OBJ_DECL(AnmObjChr); +}; + +class AnmObjChrNode : public AnmObjChr { +public: + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + inline int Size() { + return mNodeArraySize; + } + + AnmObjChrRes *GetNode(int i) { + return mpNodes[i]; + } + +private: + int mNodeArraySize; + AnmObjChrRes **mpNodes; + +protected: + NW4R_G3D_TYPE_OBJ_DECL(AnmObjChrNode); +}; + +class AnmObjChrBlend : public AnmObjChrNode { +public: + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjChrBlend *Construct(MEMAllocator*, u32*, ResMdl, int); + +protected: + NW4R_G3D_TYPE_OBJ_DECL(AnmObjChrBlend); +}; + +class AnmObjChrRes : public AnmObjChr, public FrameCtrl { +public: + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjChrRes *Construct(MEMAllocator*, u32*, ResAnmChr, ResMdl, bool); + +protected: + NW4R_G3D_TYPE_OBJ_DECL(AnmObjChrRes); +}; -struct AnmObjChrRes {}; } // namespace g3d } // namespace nw4r diff --git a/include/nw4r/g3d/g3d_anmclr.h b/include/nw4r/g3d/g3d_anmclr.h index 6a009f19..892abe70 100644 --- a/include/nw4r/g3d/g3d_anmclr.h +++ b/include/nw4r/g3d/g3d_anmclr.h @@ -1,6 +1,8 @@ #ifndef NW4R_G3D_ANMCLR_H #define NW4R_G3D_ANMCLR_H #include "common.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/g3d/g3d_resanmclr.h" namespace nw4r { namespace g3d { @@ -11,6 +13,73 @@ struct ClrAnmResult { u32 COLORS_0x4[ANM_COUNT]; UNKWORD WORDS_0x30[ANM_COUNT]; }; + +class AnmObjMatClrRes; + +class AnmObjMatClr : public AnmObj { +public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + virtual ClrAnmResult *GetResult(); // at 0x38 + virtual void Attach(s32, AnmObjMatClrRes *res); // at 0x3C + virtual void Detach(s32); // at 0x40 + +private: + int mChildrenArraySize; + u16 *mpChildrenArray; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjMatClr); +}; + +class AnmObjMatClrNode : public AnmObjMatClr { +public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + inline int Size() { + return mNodeArraySize; + } + + AnmObjMatClrRes *GetNode(int i) { + return mpNodes[i]; + } + +private: + int mNodeArraySize; + AnmObjMatClrRes **mpNodes; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjMatClrNode); +}; + +class AnmObjMatClrRes : public AnmObjMatClr, public FrameCtrl { +public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjMatClrRes *Construct(MEMAllocator *, u32 *, ResAnmClr, ResMdl, bool); + +private: + ResAnmClr mRes; + TexSrtAnmResult *mpResultCache; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjMatClrRes); +}; + +class AnmObjMatClrOverride : public AnmObjMatClrNode { +public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjMatClrOverride *Construct(MEMAllocator *, u32 *, ResMdl, int); + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjMatClrOverride); +}; + } // namespace g3d } // namespace nw4r diff --git a/include/nw4r/g3d/g3d_anmobj.h b/include/nw4r/g3d/g3d_anmobj.h index 421223a0..7fb62f1e 100644 --- a/include/nw4r/g3d/g3d_anmobj.h +++ b/include/nw4r/g3d/g3d_anmobj.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_ANMOBJ_H #define NW4R_G3D_ANMOBJ_H #include "common.h" -#include "g3d_obj.h" -#include "g3d_rescommon.h" -#include "g3d_resmdl.h" +#include "nw4r/g3d/g3d_obj.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/g3d/g3d_resmdl.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_anmscn.h b/include/nw4r/g3d/g3d_anmscn.h index f32f99f4..050c64eb 100644 --- a/include/nw4r/g3d/g3d_anmscn.h +++ b/include/nw4r/g3d/g3d_anmscn.h @@ -1,10 +1,10 @@ #ifndef NW4R_G3D_ANMSCN_H #define NW4R_G3D_ANMSCN_H #include "common.h" -#include "g3d_camera.h" -#include "g3d_fog.h" -#include "g3d_light.h" -#include "g3d_obj.h" +#include "nw4r/g3d/g3d_camera.h" +#include "nw4r/g3d/g3d_fog.h" +#include "nw4r/g3d/g3d_light.h" +#include "nw4r/g3d/g3d_obj.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_anmshp.h b/include/nw4r/g3d/g3d_anmshp.h new file mode 100644 index 00000000..e5d798c9 --- /dev/null +++ b/include/nw4r/g3d/g3d_anmshp.h @@ -0,0 +1,99 @@ +#ifndef NW4R_G3D_ANMSHP_H +#define NW4R_G3D_ANMSHP_H +#include "common.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/g3d/g3d_resanmshp.h" + +// This header is based on the SS ghidra, the TypeNames in the binary, +// and an assumed symmetry to AnmObjVis. Everything about it could be wrong. + +namespace nw4r { +namespace g3d { + +class AnmObjShpRes; + +class AnmObjShp : public AnmObj { +public: + AnmObjShp(MEMAllocator *, u16 *, int); + virtual bool IsDerivedFrom(TypeObj other) const // at 0x8 + { + return (other == GetTypeObjStatic()) ? true : AnmObj::IsDerivedFrom(other); + } + virtual void G3dProc(u32, u32, void *); // at 0xC + virtual ~AnmObjShp() {} // at 0x10 + virtual const TypeObj GetTypeObj() const // at 0x14 + { + return TypeObj(TYPE_NAME); + } + virtual const char *GetTypeName() const // at 0x18 + { + return GetTypeObj().GetTypeName(); + } + virtual void SetFrame(f32) = 0; // at 0x1C + virtual f32 GetFrame() const = 0; // at 0x20 + virtual void UpdateFrame() = 0; // at 0x24 + virtual void SetUpdateRate(f32) = 0; // at 0x28 + virtual f32 GetUpdateRate() const = 0; // at 0x2C + virtual bool Bind(ResMdl) = 0; // at 0x30 + virtual void Release(); // at 0x34 + virtual bool GetResult(u32) = 0; // at 0x38 + virtual AnmObjShpRes *Attach(int, AnmObjShpRes *); // at 0x3C + virtual AnmObjShpRes *Detach(int); // at 0x40 + + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + bool TestDefined(u32 idx) const; + bool TestExistence(u32 idx) const; + void DetachAll(); + +protected: + static const int MAX_RESOURCES = 4; + + int mNumBinds; // at 0x10 + u16 *mBinds; // at 0x14 + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjShp); +}; + +class AnmObjShpRes : public AnmObjShp, public FrameCtrl { +public: + AnmObjShpRes(MEMAllocator *, ResAnmShp, u16 *, int); + + virtual bool IsDerivedFrom(TypeObj other) const // at 0x8 + { + return (other == GetTypeObjStatic()) ? true : AnmObjShp::IsDerivedFrom(other); + } + virtual ~AnmObjShpRes() {} // at 0x10 + virtual const TypeObj GetTypeObj() const // at 0x14 + { + return TypeObj(TYPE_NAME); + } + virtual const char *GetTypeName() const // at 0x18 + { + return GetTypeObj().GetTypeName(); + } + virtual void SetFrame(f32); // at 0x1C + virtual f32 GetFrame() const; // at 0x20 + virtual void UpdateFrame(); // at 0x24 + virtual void SetUpdateRate(f32); // at 0x28 + virtual f32 GetUpdateRate() const; // at 0x2C + virtual bool Bind(ResMdl); // at 0x30 + virtual bool GetResult(u32); // at 0x38 + + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjShpRes *Construct(MEMAllocator *, u32 *, ResAnmShp, ResMdl, int); + +private: + ResAnmShp mResAnmShp; // at 0x2C + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjShpRes); +}; +} // namespace g3d +} // namespace nw4r + +#endif diff --git a/include/nw4r/g3d/g3d_anmtexpat.h b/include/nw4r/g3d/g3d_anmtexpat.h index 434a10f7..9506d745 100644 --- a/include/nw4r/g3d/g3d_anmtexpat.h +++ b/include/nw4r/g3d/g3d_anmtexpat.h @@ -1,6 +1,8 @@ #ifndef NW4R_G3D_ANMTEXPAT_H #define NW4R_G3D_ANMTEXPAT_H -#include "g3d_restex.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/g3d/g3d_restex.h" +#include "nw4r/g3d/g3d_resanmtexpat.h" namespace nw4r { @@ -18,7 +20,75 @@ namespace nw4r ResTex mTexs[ANM_COUNT]; // at 0x4 ResPltt mPltts[ANM_COUNT]; // at 0x24 }; + + class AnmObjTexPatRes; + + class AnmObjTexPat : public AnmObj { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + virtual TexPatAnmResult *GetResult(); // at 0x38 + virtual void Attach(s32, AnmObjTexPatRes *res); // at 0x3C + virtual void Detach(s32); // at 0x40 + + private: + int mChildrenArraySize; + u16 *mpChildrenArray; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexPat); + }; + + class AnmObjTexPatNode : public AnmObjTexPat { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + + inline int Size() { + return mNodeArraySize; + } + + AnmObjTexPatRes *GetNode(int i) { + return mpNodes[i]; + } + + private: + int mNodeArraySize; + AnmObjTexPatRes **mpNodes; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexPatNode); + }; + + class AnmObjTexPatRes : public AnmObjTexPat, public FrameCtrl { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + + static AnmObjTexPatRes *Construct(MEMAllocator*, u32*, ResAnmTexPat, ResMdl, bool); + private: + ResAnmTexPat mRes; + TexPatAnmResult *mpResultCache; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexPatRes); + }; + + class AnmObjTexPatOverride : public AnmObjTexPatNode { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjTexPatOverride *Construct(MEMAllocator*, u32*, ResMdl, int); + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexPatOverride); + }; + } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_anmtexsrt.h b/include/nw4r/g3d/g3d_anmtexsrt.h index 55c286aa..21576b6a 100644 --- a/include/nw4r/g3d/g3d_anmtexsrt.h +++ b/include/nw4r/g3d/g3d_anmtexsrt.h @@ -1,11 +1,81 @@ #ifndef NW4R_G3D_ANMTEXSRT_H #define NW4R_G3D_ANMTEXSRT_H -#include "g3d_restex.h" +#include "nw4r/g3d/g3d_restex.h" +#include "nw4r/g3d/g3d_resanmtexsrt.h" namespace nw4r { namespace g3d { + + class AnmObjTexSrtRes; + struct TexSrtAnmResult; + + class AnmObjTexSrt : public AnmObj { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + virtual TexSrtAnmResult *GetResult(); // at 0x38 + virtual void Attach(s32, AnmObjTexSrtRes *res); // at 0x3C + virtual void Detach(s32); // at 0x40 + + private: + int mChildrenArraySize; + u16 *mpChildrenArray; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexSrt); + }; + + class AnmObjTexSrtNode : public AnmObjTexSrt { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + + inline int Size() { + return mNodeArraySize; + } + + AnmObjTexSrtRes *GetNode(int i) { + return mpNodes[i]; + } + + private: + int mNodeArraySize; + AnmObjTexSrtRes **mpNodes; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexSrtNode); + }; + + class AnmObjTexSrtRes : public AnmObjTexSrt, public FrameCtrl { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + + static AnmObjTexSrtRes *Construct(MEMAllocator*, u32*, ResAnmTexSrt, ResMdl, bool); + private: + ResAnmTexSrt mRes; + TexSrtAnmResult *mpResultCache; + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexSrtRes); + }; + + class AnmObjTexSrtOverride : public AnmObjTexSrtNode { + public: + static const G3dObj::TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } + + static AnmObjTexSrtOverride *Construct(MEMAllocator*, u32*, ResMdl, int); + + NW4R_G3D_TYPE_OBJ_DECL(AnmObjTexSrtOverride); + }; + struct TexSrtTypedef { enum TexMatrixMode @@ -44,4 +114,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_anmvis.h b/include/nw4r/g3d/g3d_anmvis.h index 26bffd4d..54d54e34 100644 --- a/include/nw4r/g3d/g3d_anmvis.h +++ b/include/nw4r/g3d/g3d_anmvis.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_ANMVIS_H #define NW4R_G3D_ANMVIS_H #include "common.h" -#include "g3d_anmobj.h" -#include "g3d_resanmvis.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/g3d/g3d_resanmvis.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_basic.h b/include/nw4r/g3d/g3d_basic.h index e80b3ed3..672796d9 100644 --- a/include/nw4r/g3d/g3d_basic.h +++ b/include/nw4r/g3d/g3d_basic.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_BASIC_H #define NW4R_G3D_BASIC_H -#include "math_types.h" -#include "g3d_anmchr.h" +#include "nw4r/math/math_types.h" +#include "nw4r/g3d/g3d_anmchr.h" namespace nw4r { @@ -45,4 +45,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_calcview.h b/include/nw4r/g3d/g3d_calcview.h index 8cb3a7c5..3c9a43cf 100644 --- a/include/nw4r/g3d/g3d_calcview.h +++ b/include/nw4r/g3d/g3d_calcview.h @@ -1,6 +1,7 @@ #ifndef NW4R_G3D_CALC_VIEW_H #define NW4R_G3D_CALC_VIEW_H #include "common.h" +#include "nw4r/math.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_calcworld.h b/include/nw4r/g3d/g3d_calcworld.h index f4968c2f..7c9ef69d 100644 --- a/include/nw4r/g3d/g3d_calcworld.h +++ b/include/nw4r/g3d/g3d_calcworld.h @@ -1,9 +1,39 @@ #ifndef NW4R_G3D_CALC_WORLD_H #define NW4R_G3D_CALC_WORLD_H #include "common.h" +#include "nw4r/math.h" namespace nw4r { namespace g3d { + +struct FuncObjCalcWorld { +private: + u8 UNK_0x00[0x06]; + /** 0x06 */ u16 mNodeId; + +public: + u32 GetNodeId() const { + return mNodeId; + } + + void SetNodeId(u32 n) { + mNodeId = n; + } +}; + +class WorldMtxManip {}; + +// Name from ketteiban +class ICalcWorldCallback { +public: + virtual ~ICalcWorldCallback() {} + + virtual void ExecCallbackA(nw4r::g3d::ChrAnmResult *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *) {} + virtual void ExecCallbackB(nw4r::g3d::WorldMtxManip *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *) {} + virtual void ExecCallbackC(nw4r::math::MTX34 *, nw4r::g3d::ResMdl, nw4r::g3d::FuncObjCalcWorld *) {} +}; + + void CalcWorld(math::MTX34 *, u32 *, const u8 *, const math::MTX34 *, ResMdl, AnmObjChr *, FuncObjCalcWorld *, u32); void CalcWorld(math::MTX34 *, u32 *, const u8 *, const math::MTX34 *, ResMdl, AnmObjChr *, FuncObjCalcWorld *); diff --git a/include/nw4r/g3d/g3d_camera.h b/include/nw4r/g3d/g3d_camera.h index e5c58271..9ac3ebb2 100644 --- a/include/nw4r/g3d/g3d_camera.h +++ b/include/nw4r/g3d/g3d_camera.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_CAMERA_H #define NW4R_G3D_CAMERA_H #include "common.h" -#include "g3d_rescommon.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math/math_types.h" #include <rvl/MTX.h> diff --git a/include/nw4r/g3d/g3d_dcc.h b/include/nw4r/g3d/g3d_dcc.h index 56a009d8..0c83c1f0 100644 --- a/include/nw4r/g3d/g3d_dcc.h +++ b/include/nw4r/g3d/g3d_dcc.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_DCC_H #define NW4R_G3D_DCC_H #include "common.h" -#include "g3d_anmtexsrt.h" +#include "nw4r/math.h" +#include "nw4r/g3d/g3d_anmtexsrt.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_draw.h b/include/nw4r/g3d/g3d_draw.h index 0d0956d7..3501607e 100644 --- a/include/nw4r/g3d/g3d_draw.h +++ b/include/nw4r/g3d/g3d_draw.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_DRAW_H #define NW4R_G3D_DRAW_H #include "common.h" -#include "g3d_resmdl.h" +#include "nw4r/g3d/g3d_resmdl.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_draw1mat1shp.h b/include/nw4r/g3d/g3d_draw1mat1shp.h index b442c9d1..694b8974 100644 --- a/include/nw4r/g3d/g3d_draw1mat1shp.h +++ b/include/nw4r/g3d/g3d_draw1mat1shp.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_DRAW1_MAT1_SHP_H #define NW4R_G3D_DRAW1_MAT1_SHP_H #include "common.h" -#include "g3d_resmat.h" -#include "g3d_resshp.h" +#include "nw4r/g3d/g3d_resmat.h" +#include "nw4r/g3d/g3d_resshp.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_fog.h b/include/nw4r/g3d/g3d_fog.h index 0c1932a7..c5e953aa 100644 --- a/include/nw4r/g3d/g3d_fog.h +++ b/include/nw4r/g3d/g3d_fog.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_FOG_H #define NW4R_G3D_FOG_H #include "common.h" -#include "g3d_rescommon.h" -#include "math_types.h" -#include "ut_Color.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math/math_types.h" +#include "nw4r/ut/ut_Color.h" #include <rvl/GX.h> diff --git a/include/nw4r/g3d/g3d_gpu.h b/include/nw4r/g3d/g3d_gpu.h index 693af719..2db74bd5 100644 --- a/include/nw4r/g3d/g3d_gpu.h +++ b/include/nw4r/g3d/g3d_gpu.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_GPU_H #define NW4R_G3D_GPU_H #include "common.h" -#include "g3d_rescommon.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math/math_types.h" #include <rvl/GX.h> diff --git a/include/nw4r/g3d/g3d_init.h b/include/nw4r/g3d/g3d_init.h index d6e9718a..9f52d5f1 100644 --- a/include/nw4r/g3d/g3d_init.h +++ b/include/nw4r/g3d/g3d_init.h @@ -5,12 +5,6 @@ namespace nw4r { namespace g3d { -inline void InitFastCast() { - OSInitFastCast(); - OSSetGQR6(7, 5); - OSSetGQR7(7, 8); -} - void G3dInit(bool); void G3dReset(); } // namespace g3d diff --git a/include/nw4r/g3d/g3d_light.h b/include/nw4r/g3d/g3d_light.h index a989dcf6..051688f6 100644 --- a/include/nw4r/g3d/g3d_light.h +++ b/include/nw4r/g3d/g3d_light.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_LIGHT_H #define NW4R_G3D_LIGHT_H #include "common.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math.h" #include <rvl/GX.h> diff --git a/include/nw4r/g3d/g3d_maya.h b/include/nw4r/g3d/g3d_maya.h index ab10b53f..4e344bb9 100644 --- a/include/nw4r/g3d/g3d_maya.h +++ b/include/nw4r/g3d/g3d_maya.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_MAYA_H #define NW4R_G3D_MAYA_H #include "common.h" -#include "g3d_anmtexsrt.h" +#include "nw4r/g3d/g3d_anmtexsrt.h" +#include "nw4r/math.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_obj.h b/include/nw4r/g3d/g3d_obj.h index 6f596a11..68b03706 100644 --- a/include/nw4r/g3d/g3d_obj.h +++ b/include/nw4r/g3d/g3d_obj.h @@ -90,6 +90,7 @@ public: } void Destroy(); + void DetachFromParent(); G3dObj(MEMAllocator *pAllocator, G3dObj *pParent) : mAllocator(pAllocator), mParent(pParent) {} @@ -115,7 +116,10 @@ public: template <typename T> static T *DynamicCast(G3dObj *obj) { - return (obj != NULL && obj->IsDerivedFrom(T::GetTypeObjStatic())) ? static_cast<T *>(obj) : NULL; + if (obj != nullptr && obj->IsDerivedFrom(T::GetTypeObjStatic())) { + return static_cast<T *>(obj); + } + return nullptr; } private: diff --git a/include/nw4r/g3d/g3d_resanmcamera.h b/include/nw4r/g3d/g3d_resanmcamera.h index 0b1eb409..3dc8a33b 100644 --- a/include/nw4r/g3d/g3d_resanmcamera.h +++ b/include/nw4r/g3d/g3d_resanmcamera.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_RESANMCAMERA_H #define NW4R_G3D_RESANMCAMERA_H #include "common.h" -#include "g3d_anmcamera.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_anmcamera.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_resanmchr.h b/include/nw4r/g3d/g3d_resanmchr.h index fd6696f9..76e08a34 100644 --- a/include/nw4r/g3d/g3d_resanmchr.h +++ b/include/nw4r/g3d/g3d_resanmchr.h @@ -1,13 +1,18 @@ #ifndef NW4R_G3D_RESANMCHR_H #define NW4R_G3D_RESANMCHR_H #include "common.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { namespace g3d { struct ResAnmChrData { char UNK_0x0[0x8]; u32 mRevision; // at 0x8 + char UNK_0xC[0x4]; + s32 mMatDictOffset; // at 0x10 + char UNK_0x14[0x0C]; + u16 mNumFrames; // at 0x20 + AnmPolicy mAnmPolicy; // at 0x24 }; struct ResAnmChr { @@ -20,6 +25,16 @@ struct ResAnmChr { inline bool CheckRevision() const { return mAnmChr.ref().mRevision == REVISION; } + + AnmPolicy GetAnmPolicy() const + { + return mAnmChr.ref().mAnmPolicy; + } + + int GetNumFrame() const + { + return mAnmChr.ref().mNumFrames; + } }; } // namespace g3d } // namespace nw4r diff --git a/include/nw4r/g3d/g3d_resanmclr.h b/include/nw4r/g3d/g3d_resanmclr.h index a92ad053..78feba26 100644 --- a/include/nw4r/g3d/g3d_resanmclr.h +++ b/include/nw4r/g3d/g3d_resanmclr.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_RESANMCLR_H #define NW4R_G3D_RESANMCLR_H -#include "g3d_resdict.h" -#include "g3d_resanm.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/g3d/g3d_resanm.h" +#include "nw4r/g3d/g3d_anmclr.h" namespace nw4r { @@ -32,6 +33,9 @@ namespace nw4r char UNK_0xC[0x4]; s32 mMatDictOffset; // at 0x10 ResAnmClrInfoData mInfo; // at 0x14 + char UNK_0x1E[0x2]; + u16 mNumFrames; // at 0x20 + AnmPolicy mAnmPolicy; // at 0x24 }; struct ResAnmClr @@ -54,6 +58,16 @@ namespace nw4r { return ref().mRevision == REVISION; } + + AnmPolicy GetAnmPolicy() const + { + return ref().mAnmPolicy; + } + + int GetNumFrame() const + { + return ref().mNumFrames; + } inline const ResAnmClrMatData * GetMatAnm(u32 i) const { @@ -65,4 +79,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_resanmfog.h b/include/nw4r/g3d/g3d_resanmfog.h index 4cc933cc..77443159 100644 --- a/include/nw4r/g3d/g3d_resanmfog.h +++ b/include/nw4r/g3d/g3d_resanmfog.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_RESANMFOG_H #define NW4R_G3D_RESANMFOG_H #include "common.h" -#include "g3d_anmfog.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_anmfog.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_resanmscn.h b/include/nw4r/g3d/g3d_resanmscn.h index 5983b256..3f7af493 100644 --- a/include/nw4r/g3d/g3d_resanmscn.h +++ b/include/nw4r/g3d/g3d_resanmscn.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_RESANMSCN_H #define NW4R_G3D_RESANMSCN_H #include "common.h" -#include "g3d_resanmcamera.h" -#include "g3d_resanmfog.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_resanmcamera.h" +#include "nw4r/g3d/g3d_resanmfog.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_resanmshp.h b/include/nw4r/g3d/g3d_resanmshp.h index 58c3452b..332065da 100644 --- a/include/nw4r/g3d/g3d_resanmshp.h +++ b/include/nw4r/g3d/g3d_resanmshp.h @@ -1,13 +1,17 @@ #ifndef NW4R_G3D_RESANMSHP_H #define NW4R_G3D_RESANMSHP_H #include "common.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_anmobj.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { namespace g3d { struct ResAnmShpData { char UNK_0x0[0x8]; u32 mRevision; // at 0x8 + char UNK_0xC[0x24 - 0xC]; + u16 mNumFrames; // at 0x24 + AnmPolicy mAnmPolicy; // at 0x28 }; struct ResAnmShp { @@ -20,6 +24,14 @@ struct ResAnmShp { inline bool CheckRevision() const { return mAnmShp.ref().mRevision == REVISION; } + + AnmPolicy GetAnmPolicy() const { + return mAnmShp.ref().mAnmPolicy; + } + + int GetNumFrame() const { + return mAnmShp.ref().mNumFrames; + } }; } // namespace g3d } // namespace nw4r diff --git a/include/nw4r/g3d/g3d_resanmtexpat.h b/include/nw4r/g3d/g3d_resanmtexpat.h index e06dfe9c..d7fac863 100644 --- a/include/nw4r/g3d/g3d_resanmtexpat.h +++ b/include/nw4r/g3d/g3d_resanmtexpat.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_RESANMTEXPAT_H #define NW4R_G3D_RESANMTEXPAT_H -#include "g3d_resdict.h" -#include "g3d_resanm.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/g3d/g3d_resfile.h" +#include "nw4r/g3d/g3d_resanm.h" namespace nw4r { @@ -51,6 +52,8 @@ namespace nw4r char UNK_0x24[0xC]; u16 mTexCount; // at 0x30 u16 mPlttCount; // at 0x32 + char UNK_0x34[0x4]; + AnmPolicy mAnmPolicy; // at 0x38 }; struct ResAnmTexPat @@ -78,6 +81,16 @@ namespace nw4r { return static_cast<const ResAnmTexPatMatData *>(mAnmTexPat.ofs_to_obj<ResDic>(ref().mMatDictOffset)[i]); } + + AnmPolicy GetAnmPolicy() const + { + return ref().mAnmPolicy; + } + + int GetNumFrame() const + { + return ref().mTexCount; + } void GetAnmResult(TexPatAnmResult *, u32, float) const; @@ -87,4 +100,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_resanmtexsrt.h b/include/nw4r/g3d/g3d_resanmtexsrt.h index 563a0e00..e8a4e9f6 100644 --- a/include/nw4r/g3d/g3d_resanmtexsrt.h +++ b/include/nw4r/g3d/g3d_resanmtexsrt.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_RESANMTEXSRT_H #define NW4R_G3D_RESANMTEXSRT_H -#include "g3d_resanm.h" -#include "g3d_resdict.h" +#include "nw4r/g3d/g3d_resanm.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/g3d/g3d_anmtexsrt.h" namespace nw4r { @@ -27,6 +28,10 @@ namespace nw4r u32 mRevision; // at 0x8 char UNK_0xC[0x4]; s32 mMatDictOffset; // at 0x10 + char UNK_0x14[0x0C]; + u16 mNumFrames; // at 0x20 + UNKWORD UNK_0x24; + AnmPolicy mAnmPolicy; // at 0x28 }; struct ResAnmTexSrt @@ -54,10 +59,20 @@ namespace nw4r { return static_cast<const ResAnmTexSrtMatData *>(mAnmTexSrt.ofs_to_obj<ResDic>(ref().mMatDictOffset)[i]); } + + AnmPolicy GetAnmPolicy() const + { + return ref().mAnmPolicy; + } + + int GetNumFrame() const + { + return ref().mNumFrames; + } void GetAnmResult(TexSrtAnmResult *, u32, float) const; }; } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_resanmvis.h b/include/nw4r/g3d/g3d_resanmvis.h index 82c28ea1..89bbbd44 100644 --- a/include/nw4r/g3d/g3d_resanmvis.h +++ b/include/nw4r/g3d/g3d_resanmvis.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_RESANMVIS_H #define NW4R_G3D_RESANMVIS_H -#include "g3d_resdict.h" -#include "g3d_resanm.h" -#include "g3d_anmobj.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/g3d/g3d_resanm.h" +#include "nw4r/g3d/g3d_anmobj.h" namespace nw4r { @@ -10,10 +10,10 @@ namespace nw4r { struct ResAnmVisInfoData { - char UNK_0x0[0x8]; - u16 mNumFrames; // at 0x1C + char UNK_0x0[0xC]; + u16 mNumFrames; // at 0x20 u16 mNumNodes; - AnmPolicy mAnmPolicy; // at 0x20 + AnmPolicy mAnmPolicy; // at 0x24 }; struct ResAnmVisNodeData @@ -79,4 +79,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_resdict.h b/include/nw4r/g3d/g3d_resdict.h index 07ecc2e7..9c29db73 100644 --- a/include/nw4r/g3d/g3d_resdict.h +++ b/include/nw4r/g3d/g3d_resdict.h @@ -1,31 +1,31 @@ #ifndef NW4R_G3D_RESDICT_H #define NW4R_G3D_RESDICT_H #include "common.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_rescommon.h" #include <string.h> namespace nw4r { namespace g3d { -struct ResDicEntry { - u16 INT_0x0; // at 0x0 - u16 INT_0x2; // at 0x2 - u16 unk_index; // at 0x4 - u16 unk_index2; // at 0x6 - u32 INT_0x8; // at 0x8 - u32 INT_0xC; // at 0xC +struct ResDicNodeData { + u16 ref; // at 0x0 + u16 flag; // at 0x2 + u16 idxLeft; // at 0x4 + u16 idxRight; // at 0x6 + u32 ofsString; // at 0x8 + u32 ofsData; // at 0xC }; struct ResDicData { - u32 mSize; // at 0x0 - u32 mNumData; // at 0x4 - ResDicEntry mEntries[]; // 0x8 + u32 size; // at 0x0 + u32 numData; // at 0x4 + ResDicNodeData data[1]; // 0x8 }; struct ResDic { ResCommon<ResDicData> mDict; - ResDicEntry *Get(ResName) const; - ResDicEntry *Get(const char *, u32) const; + ResDicNodeData *Get(ResName) const; + ResDicNodeData *Get(const char *, u32) const; void *operator[](const char *) const; void *operator[](ResName) const; s32 GetIndex(ResName) const; @@ -34,7 +34,7 @@ struct ResDic { inline void *operator[](int i) const { if (mDict.IsValid()) { - return (void *)mDict.ofs_to_ptr<void>(mDict.ref().mEntries[i + 1].INT_0xC); + return (void *)mDict.ofs_to_ptr<void>(mDict.ref().data[i + 1].ofsData); } return NULL; @@ -42,7 +42,7 @@ struct ResDic { inline u32 GetNumData() const { if (mDict.IsValid()) { - return mDict.ref().mNumData; + return mDict.ref().numData; } return 0; diff --git a/include/nw4r/g3d/g3d_resfile.h b/include/nw4r/g3d/g3d_resfile.h index 597fec6c..9a8c51cd 100644 --- a/include/nw4r/g3d/g3d_resfile.h +++ b/include/nw4r/g3d/g3d_resfile.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_RESFILE_H #define NW4R_G3D_RESFILE_H #include "common.h" -#include "g3d_rescommon.h" -#include "g3d_resdict.h" -#include "ut_binaryFileFormat.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/ut/ut_binaryFileFormat.h" namespace nw4r { namespace g3d { @@ -18,6 +18,9 @@ struct ResFileData { struct ResFile { ResCommon<ResFileData> mFile; // at 0x0 + ResFile(): mFile((void*)nullptr) {} + ResFile(void *ptr): mFile(ptr) {} + inline ResFileData &ref() const { return mFile.ref(); } diff --git a/include/nw4r/g3d/g3d_resmat.h b/include/nw4r/g3d/g3d_resmat.h index 1c5a6358..7c26d9e9 100644 --- a/include/nw4r/g3d/g3d_resmat.h +++ b/include/nw4r/g3d/g3d_resmat.h @@ -1,21 +1,63 @@ #ifndef NW4R_G3D_RESMAT_H #define NW4R_G3D_RESMAT_H #include "common.h" -#include "g3d_rescommon.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math/math_types.h" #include <rvl/GX.h> - namespace nw4r { namespace g3d { -struct ResMatTexCoordGenData {}; -struct ResMatTexCoordGen { - ResCommon<ResMatTexCoordGenData> mTexGen; // at 0x0 +struct ResTevColorDL { + union { + struct { + u8 tevColor[3][20]; // offset 0x0, size 0x3C + u8 _0[4]; // offset 0x3C, size 0x4 + u8 tevKColor[4][10]; // offset 0x40, size 0x28 + u8 _1[24]; // offset 0x68, size 0x18 + } dl; + u8 data[128]; + }; +}; + +struct ResMatTevColor : public ResCommon<ResTevColorDL> { + ResMatTevColor(void *vptr) : ResCommon<ResTevColorDL>(vptr) {} + void DCStore(bool sync); + void CallDisplayList(bool bSync) const; + ResMatTevColor CopyTo(void *p) const; + void GXGetTevColor(GXTevRegID id, GXColor *color); + void GXSetTevColor(GXTevRegID id, GXColor color); + void GXSetTevKColor(GXTevKColorID id, GXColor color); +}; + +struct ResPixDL { + union { + struct { + unsigned char alphaCompare[5]; // offset 0x0, size 0x5 + unsigned char zMode[5]; // offset 0x5, size 0x5 + unsigned char blendMode[10]; // offset 0xA, size 0xA + unsigned char setDstAlpha[5]; // offset 0x14, size 0x5 + unsigned char _[7]; // offset 0x19, size 0x7 + } dl; // offset 0x0, size 0x20 + unsigned char data[32]; // offset 0x0, size 0x20 + }; +}; - inline ResMatTexCoordGen(void *vptr) : mTexGen(vptr) {} +struct ResMatPix : public ResCommon<ResPixDL> { + ResMatPix(void *vptr) : ResCommon(vptr) {} + void DCStore(bool sync); + void CallDisplayList(bool bSync) const; + ResMatPix CopyTo(void *p) const; + + void GXSetBlendMode(GXBlendMode, GXBlendFactor, GXBlendFactor, GXLogicOp); +}; + +struct ResTexCoordGenDL {}; + +struct ResMatTexCoordGen : public ResCommon<ResTexCoordGenDL> { + inline ResMatTexCoordGen(void *vptr) : ResCommon(vptr) {} bool IsValid() const { - return mTexGen.IsValid(); + return ResCommon::IsValid(); } bool GXGetTexCoordGen2(GXTexCoordID, GXTexGenType *, GXTexGenSrc *, u8 *, u32 *); @@ -23,15 +65,18 @@ struct ResMatTexCoordGen { void DCStore(bool); }; -struct ResTexSrtData {}; - -struct ResTexSrt { - ResCommon<ResTexSrtData> mTexSrt; // at 0x0 +struct ResTexSrtData { + union { + struct { + unsigned char texCoordGen[8][18]; // offset 0x0, size 0x90 + unsigned char _[16]; // offset 0x90, size 0x10 + } dl; // offset 0x0, size 0xA0 + unsigned char data[160]; // offset 0x0, size 0xA0 + }; +}; - inline ResTexSrt(void *vptr) : mTexSrt(vptr) {} - bool IsValid() const { - return mTexSrt.IsValid(); - } +struct ResTexSrt : public ResCommon<ResTexSrtData> { + inline ResTexSrt(void *vptr) : ResCommon(vptr) {} void SetMapMode(u32, u32, int, int); }; @@ -52,32 +97,71 @@ struct ResTexPlttInfo { }; struct ResMatDLData { - char UNK_0x0[0xE0]; - ResMatTexCoordGenData texCoordGenData; // at 0xE0 + ResPixDL dlPix; // offset 0x0, size 0x20 + ResTevColorDL dlTevColor; // offset 0x20, size 0x80 + /* ResIndMtxAndScaleDL */ u8 dlIndMtxAndScale[0x40]; // offset 0xA0, size 0x40 + ResTexCoordGenDL dlTexCoordGen; // offset 0xE0, size 0xA0 +}; + +struct ResGenModeData { + u8 nTexGens; // offset 0x0, size 0x1 + u8 nChans; // offset 0x1, size 0x1 + u8 nTevs; // offset 0x2, size 0x1 + u8 nInds; // offset 0x3, size 0x1 + GXCullMode cullMode; // offset 0x4, size 0x4 +}; + +struct ResGenMode : public ResCommon<ResGenModeData> { + ResGenMode(void *vptr) : ResCommon(vptr) {} + void DCStore(bool sync); + ResGenMode CopyTo(void *p) const; + GXCullMode GXGetCullMode(); + u8 GXGetNumIndStages() const; + u8 GXGetNumTevStages() const; + u8 GXGetNumChans() const; + u8 GXGetNumTexGens() const; + void GXSetCullMode(GXCullMode); }; struct ResMatData { - char UNK_0x0[0x38]; - u32 resMatDLOfs; // at 0x38 - char UNK_0x3C[0x1A4 - 0x3C]; - ResTexSrtData texSrtData; // at 0x1A4 + u32 size; // offset 0x0, size 0x4 + s32 toResMdlData; // offset 0x4, size 0x4 + s32 name; // offset 0x8, size 0x4 + u32 id; // offset 0xC, size 0x4 + u32 flag; // offset 0x10, size 0x + ResGenModeData genMode; // offset 0x14, size 0x8 + /* ResMatMiscData */ u8 misc[0xC]; // offset 0x1C, size 0xC + s32 toResTevData; // offset 0x28, size 0x4 + u32 numResTexPlttInfo; // offset 0x2C, size 0x4 + s32 toResTexPlttInfo; // offset 0x30, size 0x4 + s32 toResMatFurData; // offset 0x34, size 0x4 + u32 toResUserData; // offset 0x38, size 0x4 + u32 toResMatDLData; // offset 0x3C, size 0x4 + /* ResTexObjData */ u8 texObjData[0x104]; // offset 0x40, size 0x104 + /* ResTlutObjData */ u8 tlutObjData[0x64]; // offset 0x144, size 0x64 + ResTexSrtData texSrtData; // offset 0x1A8, size 0x248 + /* ResChanData */ u8 chan[0x20]; // offset 0x3F0, size 0x28 }; -struct ResMat { - ResCommon<ResMatData> mMat; +struct ResMat : public ResCommon<ResMatData> { + ResMatTevColor GetResMatTevColor() { + return ResMatTevColor(&ofs_to_ptr<ResMatDLData>(ref().toResMatDLData)->dlTevColor); + } - inline ResMat(void *vptr) : mMat(vptr) {} - bool IsValid() const { - return mMat.IsValid(); + ResMatPix GetResMatPix() { + return ResMatPix(&ofs_to_ptr<ResMatDLData>(ref().toResMatDLData)->dlPix); + } + + ResGenMode GetResGenMode() { + return ResGenMode(&ref().genMode); } ResTexSrt GetResTexSrt() { - return ResTexSrt(&mMat.ref().texSrtData); + return ResTexSrt(&ref().texSrtData); } ResMatTexCoordGen GetResMatTexCoordGen() { - ResMatDLData *dlData = mMat.ofs_to_ptr<ResMatDLData>(mMat.ref().resMatDLOfs); - return ResMatTexCoordGen(&dlData->texCoordGenData); + return ResMatTexCoordGen(&ofs_to_ptr<ResMatDLData>(ref().toResMatDLData)->dlTexCoordGen); } bool Bind(ResFile); diff --git a/include/nw4r/g3d/g3d_resmdl.h b/include/nw4r/g3d/g3d_resmdl.h index bf865abf..6a7b4c4f 100644 --- a/include/nw4r/g3d/g3d_resmdl.h +++ b/include/nw4r/g3d/g3d_resmdl.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_RESMDL_H #define NW4R_G3D_RESMDL_H #include "common.h" -#include "g3d_rescommon.h" -#include "g3d_resdict.h" -#include "g3d_resnode.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/g3d/g3d_resdict.h" +#include "nw4r/g3d/g3d_resnode.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_resnode.h b/include/nw4r/g3d/g3d_resnode.h index 4e080c9d..67506985 100644 --- a/include/nw4r/g3d/g3d_resnode.h +++ b/include/nw4r/g3d/g3d_resnode.h @@ -1,12 +1,14 @@ #ifndef NW4R_G3D_RESNODE_H #define NW4R_G3D_RESNODE_H #include "common.h" -#include "g3d_anmchr.h" -#include "g3d_rescommon.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/math/math_types.h" namespace nw4r { namespace g3d { + +class ChrAnmResult; + struct ResNodeData { u32 INT_0x0; s32 INT_0x4; diff --git a/include/nw4r/g3d/g3d_resshp.h b/include/nw4r/g3d/g3d_resshp.h index 55cd6f29..eadb88f6 100644 --- a/include/nw4r/g3d/g3d_resshp.h +++ b/include/nw4r/g3d/g3d_resshp.h @@ -1,8 +1,8 @@ #ifndef NW4R_G3D_RESSHP_H #define NW4R_G3D_RESSHP_H -#include "g3d_rescommon.h" -#include "g3d_resmdl.h" -#include "g3d_resvtx.h" +#include "nw4r/g3d/g3d_rescommon.h" +#include "nw4r/g3d/g3d_resmdl.h" +#include "nw4r/g3d/g3d_resvtx.h" #include <GXAttr.h>#include "common.h" diff --git a/include/nw4r/g3d/g3d_restev.h b/include/nw4r/g3d/g3d_restev.h index 14c158ad..9146c1fd 100644 --- a/include/nw4r/g3d/g3d_restev.h +++ b/include/nw4r/g3d/g3d_restev.h @@ -2,8 +2,8 @@ #define NW4R_G3D_RESTEV_H #include <GXTev.h> #include <GXTexture.h> -#include "g3d_cpu.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_cpu.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { @@ -58,4 +58,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_restex.h b/include/nw4r/g3d/g3d_restex.h index 9d85d355..1f9b6596 100644 --- a/include/nw4r/g3d/g3d_restex.h +++ b/include/nw4r/g3d/g3d_restex.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_RESTEX_H #define NW4R_G3D_RESTEX_H #include "common.h" -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_rescommon.h" #include <rvl/GX.h> diff --git a/include/nw4r/g3d/g3d_resvtx.h b/include/nw4r/g3d/g3d_resvtx.h index 717aa0e4..448eaedd 100644 --- a/include/nw4r/g3d/g3d_resvtx.h +++ b/include/nw4r/g3d/g3d_resvtx.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_RESVTX_H #define NW4R_G3D_RESVTX_H #include <GXAttr.h> -#include "g3d_rescommon.h" +#include "nw4r/g3d/g3d_rescommon.h" namespace nw4r { @@ -155,4 +155,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/g3d/g3d_scnmdl.h b/include/nw4r/g3d/g3d_scnmdl.h index 5f1cb9e9..d453a01e 100644 --- a/include/nw4r/g3d/g3d_scnmdl.h +++ b/include/nw4r/g3d/g3d_scnmdl.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_SCN_MDL_H #define NW4R_G3D_SCN_MDL_H #include "common.h" -#include "g3d_draw.h" -#include "g3d_resmat.h" -#include "g3d_scnmdlsmpl.h" +#include "nw4r/g3d/g3d_draw.h" +#include "nw4r/g3d/g3d_resmat.h" +#include "nw4r/g3d/g3d_scnmdlsmpl.h" namespace nw4r { namespace g3d { @@ -12,13 +12,20 @@ public: class CopiedMatAccess { public: CopiedMatAccess(ScnMdl *, u32); - ResTexSrt GetResTexSrtEx(); + ResTexSrt GetResTexSrtEx(bool); + ResMatPix GetResMatPix(bool); + ResMatTevColor GetResMatTevColor(bool); + ResGenMode GetResGenMode(bool); private: - char UNK_0x0[0x2C]; + char UNK_0x0[0x34]; }; public: + virtual bool SetAnmObj(AnmObj *p, AnmObjType type) override; + + static ScnMdl *Construct(MEMAllocator *, unsigned long *, nw4r::g3d::ResMdl, u32 bufferOption, int); + static const G3dObj::TypeObj GetTypeObjStatic() { return TypeObj(TYPE_NAME); } diff --git a/include/nw4r/g3d/g3d_scnmdl1mat1shp.h b/include/nw4r/g3d/g3d_scnmdl1mat1shp.h index 5e3d3dc9..ddbf561e 100644 --- a/include/nw4r/g3d/g3d_scnmdl1mat1shp.h +++ b/include/nw4r/g3d/g3d_scnmdl1mat1shp.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_SCN_MDL1_MAT1_SHP_H #define NW4R_G3D_SCN_MDL1_MAT1_SHP_H #include "common.h" -#include "g3d_resmat.h" -#include "g3d_resshp.h" -#include "g3d_scnobj.h" +#include "nw4r/g3d/g3d_resmat.h" +#include "nw4r/g3d/g3d_resshp.h" +#include "nw4r/g3d/g3d_scnobj.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_scnmdlsmpl.h b/include/nw4r/g3d/g3d_scnmdlsmpl.h index 00ab12a0..342845da 100644 --- a/include/nw4r/g3d/g3d_scnmdlsmpl.h +++ b/include/nw4r/g3d/g3d_scnmdlsmpl.h @@ -1,8 +1,10 @@ #ifndef NW4R_G3D_SCN_MDL_SIMPLE_H #define NW4R_G3D_SCN_MDL_SIMPLE_H #include "common.h" -#include "g3d_resmdl.h" -#include "g3d_scnobj.h" +#include "nw4r/g3d/g3d_calcworld.h" +#include "nw4r/g3d/g3d_resmdl.h" +#include "nw4r/g3d/g3d_scnobj.h" +#include "nw4r/math/math_types.h" namespace nw4r { namespace g3d { @@ -15,13 +17,31 @@ public: BYTE_CODE_DRAW_XLU, }; + enum AnmObjType { + ANMOBJTYPE_CHR = 0, + ANMOBJTYPE_VIS = 1, + ANMOBJTYPE_MATCLR = 2, + ANMOBJTYPE_TEXPAT = 3, + ANMOBJTYPE_TEXSRT = 4, + ANMOBJTYPE_SHP = 5, + ANMOBJTYPE_NOT_SPECIFIED = 6, + ANMOBJTYPE_VTX = 5, + }; + public: ScnMdlSimple(MEMAllocator *, ResMdl, math::MTX34 *, u32 *, math::MTX34 *, math::MTX33 *, math::MTX34 *, int, int); + static ScnMdlSimple *Construct(MEMAllocator *, unsigned long *, nw4r::g3d::ResMdl, int); + + bool GetScnMtxPos(math::MTX34 *pOut, ScnObjMtxType tp, u32 nodeID) const; + virtual bool IsDerivedFrom(TypeObj other) const // at 0x8 { return (other == GetTypeObjStatic()) ? true : ScnLeaf::IsDerivedFrom(other); } + static const TypeObj GetTypeObjStatic() { + return TypeObj(TYPE_NAME); + } virtual void G3dProc(u32, u32, void *); // at 0xC virtual ~ScnMdlSimple(); // at 0x10 virtual const TypeObj GetTypeObj() const // at 0x14 @@ -33,7 +53,14 @@ public: return GetTypeObj().GetTypeName(); } + virtual bool SetAnmObj(AnmObj *p, AnmObjType type); + virtual bool RemoveAnmObj(AnmObj *p); + virtual bool RemoveAnmObj(AnmObjType type); + virtual AnmObj *GetAnmObj(AnmObjType type); + virtual AnmObj *GetAnmObj(AnmObjType type) const; + const u8 *GetByteCode(ByteCodeType) const; + void EnableScnMdlCallbackTiming(Timing); const ResMdl GetResMdl() const { return mResMdl; @@ -53,6 +80,10 @@ public: return mNumViewMtx; } + void SetCalcWorldCallback(ICalcWorldCallback *cb) { + mpCalcWorldCallback = cb; + } + private: ResMdl mResMdl; // at 0xE8 math::MTX34 *mWldMatrixArray; // at 0xEC @@ -68,6 +99,8 @@ private: void *mByteCodeMix; // at 0x10C void *mByteCodeDrawOpa; // at 0x110 void *mByteCodeDrawXlu; // at 0x114 + UNKWORD WORD_0x118; + ICalcWorldCallback *mpCalcWorldCallback; // at 0x11C NW4R_G3D_TYPE_OBJ_DECL(ScnMdlSimple); }; diff --git a/include/nw4r/g3d/g3d_scnobj.h b/include/nw4r/g3d/g3d_scnobj.h index f10a037e..b40ffbb5 100644 --- a/include/nw4r/g3d/g3d_scnobj.h +++ b/include/nw4r/g3d/g3d_scnobj.h @@ -1,9 +1,9 @@ #ifndef NW4R_G3D_SCNOBJ_H #define NW4R_G3D_SCNOBJ_H #include "common.h" -#include "g3d_obj.h" -#include "math_geometry.h" -#include "math_types.h" +#include "nw4r/g3d/g3d_obj.h" +#include "nw4r/math/math_geometry.h" +#include "nw4r/math/math_types.h" namespace nw4r { namespace g3d { @@ -23,25 +23,25 @@ public: enum ForEachResult { FOREACH_RESULT_0, FOREACH_RESULT_1 }; enum ScnObjFlag { - FLAG_1 = 0x1, - FLAG_2 = 0x2, - FLAG_4 = 0x4, - FLAG_8 = 0x8, - FLAG_10 = 0x10, - FLAG_20 = 0x20, - FLAG_40 = 0x40, - FLAG_80 = 0x80, - FLAG_10000000 = 0x10000000, - FLAG_20000000 = 0x20000000, - FLAG_40000000 = 0x40000000, - FLAG_80000000 = 0x80000000, - - FLAG_60 = FLAG_40 | FLAG_20 + SCNOBJFLAG_DISABLE_CALC_WORLD = 1, + SCNOBJFLAG_DISABLE_CALC_MAT = 2, + SCNOBJFLAG_DISABLE_CALC_VTX = 4, + SCNOBJFLAG_DISABLE_CALC_VIEW = 8, + SCNOBJFLAG_DISABLE_GATHER_SCNOBJ = 16, + SCNOBJFLAG_DISABLE_DRAW_OPA = 32, + SCNOBJFLAG_DISABLE_DRAW_XLU = 64, + SCNOBJFLAG_DISABLE_UPDATEFRAME = 128, + SCNOBJFLAG_IGNORE_ANMCHR_TRANS = 256, + SCNOBJFLAG_ENABLE_CULLING = 268435456, + SCNOBJFLAG_NOT_GATHER_DRAW_OPA = 536870912, + SCNOBJFLAG_NOT_GATHER_DRAW_XLU = 1073741824, + SCNOBJFLAG_MTX_LOCAL_IDENTITY = -2147483648, + SCNOBJFLAG_DISABLE_DRAW = 96, }; - enum ScnObjMtxType { MTX_TYPE_0, MTX_TYPE_WORLD, MTX_TYPE_VIEW, MTX_TYPE_MAX }; + enum ScnObjMtxType { MTX_TYPE_LOCAL, MTX_TYPE_WORLD, MTX_TYPE_VIEW, MTX_TYPE_MAX }; - enum Timing { TIMING_1 = 0x1, TIMING_2 = 0x2, TIMING_4 = 0x4 }; + enum Timing { TIMING_1 = 0x1, TIMING_2 = 0x2, TIMING_4 = 0x4, TIMING_ALL = 0x7 }; enum ExecOp { EXEC_OP_1 = 0x1, EXEC_OP_2 = 0x2, EXEC_OP_4 = 0x4 }; @@ -88,6 +88,13 @@ public: void EnableScnObjCallbackExecOp(ExecOp); bool SetBoundingVolume(ScnObjBoundingVolumeType, const math::AABB *); bool GetBoundingVolume(ScnObjBoundingVolumeType, math::AABB *) const; + void SetCallback(IScnObjCallback *cb) { + mCallback = cb; + } + + IScnObjCallback *GetScnObjCallback() { + return mCallback; + } const math::MTX34 *GetMtxPtr(ScnObjMtxType type) const { return &mMatrices[type]; @@ -202,6 +209,22 @@ public: ScaleProperty GetScaleProperty() const; void DefG3dProcScnLeaf(u32, u32, void *); + inline void SetScale(f32 x, f32 y, f32 z) { + mScale.x = x; + mScale.y = y; + mScale.z = z; + } + + inline void SetScale(const math::VEC3 &scale) { + mScale = scale; + } + + inline void GetScale(math::VEC3 *scale) const { + if (scale) { + *scale = mScale; + } + } + private: math::VEC3 mScale; @@ -235,6 +258,10 @@ public: return TypeObj(TYPE_NAME); } + bool PushBack(ScnObj *obj) { + return Insert(Size(), obj); + } + bool Empty() const { return mSize == 0; } @@ -263,8 +290,6 @@ public: void ScnGroup_G3DPROC_CALC_VIEW(u32, const math::MTX34 *); void DefG3dProcScnGroup(u32, u32, void *); - bool PushBack(ScnObj *); - ScnObj **mObjects; // at 0xDC u32 mCapacity; // at 0xE0 u32 mSize; // at 0xE4 diff --git a/include/nw4r/g3d/g3d_scnproc.h b/include/nw4r/g3d/g3d_scnproc.h index 45aa86b6..c9d75a1d 100644 --- a/include/nw4r/g3d/g3d_scnproc.h +++ b/include/nw4r/g3d/g3d_scnproc.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_SCNPROC_H #define NW4R_G3D_SCNPROC_H #include "common.h" -#include "g3d_scnobj.h" +#include "nw4r/g3d/g3d_scnobj.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/g3d/g3d_scnrfl.h b/include/nw4r/g3d/g3d_scnrfl.h index cca91279..a5e30e44 100644 --- a/include/nw4r/g3d/g3d_scnrfl.h +++ b/include/nw4r/g3d/g3d_scnrfl.h @@ -1,7 +1,7 @@ #ifndef NW4R_G3D_SCNRFL_H #define NW4R_G3D_SCNRFL_H #include "common.h" -#include "g3d_scnleaf.h" +#include "nw4r/g3d/g3d_scnobj.h" #include <RFL/RFL_MiddleDatabase.h> #include <RFL/RFL_Model.h> diff --git a/include/nw4r/g3d/g3d_scnroot.h b/include/nw4r/g3d/g3d_scnroot.h index bfd9a9b3..c1e14298 100644 --- a/include/nw4r/g3d/g3d_scnroot.h +++ b/include/nw4r/g3d/g3d_scnroot.h @@ -1,9 +1,10 @@ #ifndef NW4R_G3D_SCNROOT_H #define NW4R_G3D_SCNROOT_H #include "common.h" -#include "g3d_camera.h" -#include "g3d_fog.h" -#include "g3d_scnobj.h" +#include "nw4r/g3d/g3d_camera.h" +#include "nw4r/g3d/g3d_fog.h" +#include "nw4r/g3d/g3d_light.h" +#include "nw4r/g3d/g3d_scnobj.h" namespace nw4r { namespace g3d { @@ -14,6 +15,9 @@ public: void SetCurrentCamera(int); Fog GetFog(int); + static ScnRoot *Construct(MEMAllocator *pHeap, u32 *pSize, u32 maxNumChildren, u32 maxNumScnObj, u32 numLightObj, + u32 numLightSet); + void UpdateFrame(); void CalcWorld(); void CalcMaterial(); @@ -28,11 +32,17 @@ public: return mCameraId; } + inline LightSetting *getLightSetting() { + return &mLightSetting; + } + private: UNKWORD WORD_0xE8; UNKWORD WORD_0xEC; UNKWORD WORD_0xF0; - u8 mCameraId; + /* 0x00F4 */ u8 mCameraId; + u8 unk1[0x2878 - 0x00F8]; + /* 0x2878 */ LightSetting mLightSetting; }; } // namespace g3d } // namespace nw4r diff --git a/include/nw4r/g3d/g3d_state.h b/include/nw4r/g3d/g3d_state.h index 0f16769f..d299b6ec 100644 --- a/include/nw4r/g3d/g3d_state.h +++ b/include/nw4r/g3d/g3d_state.h @@ -1,6 +1,7 @@ #ifndef NW4R_G3D_STATE_H #define NW4R_G3D_STATE_H #include "common.h" +#include "nw4r/math.h" #include <rvl/GX.h> namespace nw4r { @@ -12,6 +13,9 @@ void SetViewPosNrmMtxArray(const math::MTX34 *, const math::MTX33 *, const math: void SetRenderModeObj(const GXRenderModeObj &); GXRenderModeObj &GetRenderModeObj(); +void LoadLightSet(int idx_lightset, u32 *mask_diff_color /* r1+0xC */, u32 *mask_diff_alpha, u32 *mask_spec_color, + u32 *mask_spec_alpha, AmbLightObj *amb); + void Invalidate(u32); } // namespace G3DState } // namespace g3d diff --git a/include/nw4r/g3d/g3d_xsi.h b/include/nw4r/g3d/g3d_xsi.h index fb812e49..a993df96 100644 --- a/include/nw4r/g3d/g3d_xsi.h +++ b/include/nw4r/g3d/g3d_xsi.h @@ -1,7 +1,8 @@ #ifndef NW4R_G3D_XSI_H #define NW4R_G3D_XSI_H #include "common.h" -#include "g3d_anmtexsrt.h" +#include "nw4r/math.h" +#include "nw4r/g3d/g3d_anmtexsrt.h" namespace nw4r { namespace g3d { diff --git a/include/nw4r/snd/snd_Sound3DActor.h b/include/nw4r/snd/snd_Sound3DActor.h index 977eab1b..7cc15cc2 100644 --- a/include/nw4r/snd/snd_Sound3DActor.h +++ b/include/nw4r/snd/snd_Sound3DActor.h @@ -2,7 +2,7 @@ #define NW4R_SND_SOUND_3D_ACTOR_H #include "snd_BasicSound.h" #include "snd_SoundActor.h" -#include "math_types.h" +#include "nw4r/math/math_types.h" namespace nw4r { @@ -37,4 +37,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/nw4r/snd/snd_Sound3DListener.h b/include/nw4r/snd/snd_Sound3DListener.h index 4e12f717..b770f6d4 100644 --- a/include/nw4r/snd/snd_Sound3DListener.h +++ b/include/nw4r/snd/snd_Sound3DListener.h @@ -1,7 +1,7 @@ #ifndef NW4R_SND_SOUND_3D_LISTENER_H #define NW4R_SND_SOUND_3D_LISTENER_H #include "common.h" -#include "math_types.h" +#include "nw4r/math/math_types.h" namespace nw4r { namespace snd { diff --git a/include/nw4r/snd/snd_Sound3DManager.h b/include/nw4r/snd/snd_Sound3DManager.h index 432c30df..529a471f 100644 --- a/include/nw4r/snd/snd_Sound3DManager.h +++ b/include/nw4r/snd/snd_Sound3DManager.h @@ -4,7 +4,7 @@ #include "snd_SoundArchive.h" #include "snd_SoundActor.h" #include "snd_InstancePool.h" -#include "math_types.h" +#include "nw4r/math/math_types.h" namespace nw4r { @@ -50,4 +50,4 @@ namespace nw4r } } -#endif
\ No newline at end of file +#endif diff --git a/include/s/README.txt b/include/s/README.txt index 00e8279e..53c6cb63 100644 --- a/include/s/README.txt +++ b/include/s/README.txt @@ -16,3 +16,9 @@ In order for vtable ordering to match, some classes had to be extracted to a new S_StateMethod_c's destructors calls back into another destructors. sStateMethodIf_c follows the example of the other abstract interface classes and provides this dtor. + +## operator== / != return BOOL instead of bool + +We're observing a lot of word-to-bool casts in code after these +operators are invoked, and while there are ways to force the conversion, +this seems the most reasonable. diff --git a/include/s/s_StateID.hpp b/include/s/s_StateID.hpp index 422d9143..4c2ee84f 100644 --- a/include/s/s_StateID.hpp +++ b/include/s/s_StateID.hpp @@ -27,8 +27,8 @@ public: virtual bool isNull() const; virtual bool isEqual(const sStateIDIf_c &other) const; - virtual bool operator==(const sStateIDIf_c &other) const; - virtual bool operator!=(const sStateIDIf_c &other) const; + virtual BOOL operator==(const sStateIDIf_c &other) const; + virtual BOOL operator!=(const sStateIDIf_c &other) const; virtual bool isSameName(const char *name) const; virtual const char *name() const; diff --git a/include/s/s_StateInterfaces.hpp b/include/s/s_StateInterfaces.hpp index 8e28f44c..92101b2c 100644 --- a/include/s/s_StateInterfaces.hpp +++ b/include/s/s_StateInterfaces.hpp @@ -23,8 +23,8 @@ public: virtual bool isNull() const = 0; ///< Returns whether this is a null state. virtual bool isEqual(const sStateIDIf_c &other) const = 0; ///< Returns whether both states have the same number. - virtual bool operator==(const sStateIDIf_c &other) const = 0; ///< Overloaded equality operator, using ::isEqual. - virtual bool operator!=(const sStateIDIf_c &other) const = 0; ///< Overloaded inequality operator, using ::isEqual. + virtual BOOL operator==(const sStateIDIf_c &other) const = 0; ///< Overloaded equality operator, using ::isEqual. + virtual BOOL operator!=(const sStateIDIf_c &other) const = 0; ///< Overloaded inequality operator, using ::isEqual. virtual bool isSameName(const char *name) const = 0; ///< Returns whether this state ID is called @p name. virtual const char *name() const = 0; ///< Returns the name of this state ID. diff --git a/include/s/s_StateMgr.hpp b/include/s/s_StateMgr.hpp index c043eb71..09f5f217 100644 --- a/include/s/s_StateMgr.hpp +++ b/include/s/s_StateMgr.hpp @@ -35,6 +35,11 @@ public: virtual const sStateIDIf_c *getStateID() const { return mMethod.getStateID(); } virtual const sStateIDIf_c *getOldStateID() const { return mMethod.getOldStateID(); } + // SS addition + bool isState(const sStateIDIf_c& other) { + return *getStateID() == other; + } + private: Check mCheck; Factory<T> mFactory; diff --git a/include/toBeSorted/arc_managers/current_stage_arc_manager.h b/include/toBeSorted/arc_managers/current_stage_arc_manager.h index f4f11ce5..26194c8d 100644 --- a/include/toBeSorted/arc_managers/current_stage_arc_manager.h +++ b/include/toBeSorted/arc_managers/current_stage_arc_manager.h @@ -6,15 +6,10 @@ #include <sized_string.h> class CurrentStageArcManager { +public: CurrentStageArcManager(); virtual ~CurrentStageArcManager(); - SizedString<32> mStageName; - SizedString<32> mCurrentLoadingStageArcName; - SizedString<32> mStageExtraLayerArcName; - - dRawArcTable_c mArcTable; - static CurrentStageArcManager *sInstance; static bool create(EGG::Heap *heap); @@ -36,6 +31,13 @@ class CurrentStageArcManager { const char *getRoomArcDirectory(int room) const; static EGG::ExpHeap *getHeap(); + +private: + SizedString<32> mStageName; + SizedString<32> mCurrentLoadingStageArcName; + SizedString<32> mStageExtraLayerArcName; + + dRawArcTable_c mArcTable; }; #endif diff --git a/include/toBeSorted/scgame.h b/include/toBeSorted/scgame.h index 229c0e7a..32e9538b 100644 --- a/include/toBeSorted/scgame.h +++ b/include/toBeSorted/scgame.h @@ -4,7 +4,7 @@ #include <common.h> struct SpawnInfo { - /* 0x00 */ char stageName[32]; + /* 0x00 */ char stageName[32]; // Probably SizedString<32> /* 0x20 */ s16 transitionFadeFrames; /* 0x22 */ s8 room; /* 0x23 */ s8 layer; |