diff options
Diffstat (limited to 'include')
33 files changed, 2332 insertions, 387 deletions
diff --git a/include/JSystem/J2DGraph/J2DAnimation.h b/include/JSystem/J2DGraph/J2DAnimation.h index 3c13cd5f26..8f79a04d04 100644 --- a/include/JSystem/J2DGraph/J2DAnimation.h +++ b/include/JSystem/J2DGraph/J2DAnimation.h @@ -1,6 +1,87 @@ #ifndef J2DANIMATION_H #define J2DANIMATION_H +#include "dolphin/gx/GXTexture.h" #include "dolphin/types.h" +struct J3DTransformInfo; +struct J3DTextureSRTInfo; +class J2DScreen; + +struct J2DAnmVtxColorKey { + /* 8030B704 */ void getColor(u8, u16, _GXColor*) const; + /* 8030CC20 */ ~J2DAnmVtxColorKey(); +}; + +struct J2DAnmVtxColorFull { + /* 8030B4C4 */ void getColor(u8, u16, _GXColor*) const; + /* 8030CC8C */ ~J2DAnmVtxColorFull(); +}; + +struct J2DAnmVisibilityFull { + /* 8030C048 */ void getVisibility(u16, u8*) const; +}; + +struct J2DAnmTransformKey { + /* 801959C0 */ ~J2DAnmTransformKey(); + /* 8030AAFC */ void calcTransform(f32, u16, J3DTransformInfo*) const; + /* 8030CD7C */ void getTransform(u16, J3DTransformInfo*) const; +}; + +struct J2DAnmTransformFull { + /* 8030A590 */ void getTransform(u16, J3DTransformInfo*) const; + /* 8030CDAC */ ~J2DAnmTransformFull(); +}; + +struct J2DAnmTextureSRTKey { + /* 80184274 */ ~J2DAnmTextureSRTKey(); + /* 8030B9F0 */ void calcTransform(f32, u16, J3DTextureSRTInfo*) const; + /* 8030BC60 */ void searchUpdateMaterialID(J2DScreen*); +}; + +struct J2DAnmTexPattern { + struct J2DAnmTexPatternTIMGPointer { + /* 8030CB2C */ J2DAnmTexPatternTIMGPointer(); + /* 8030CB3C */ ~J2DAnmTexPatternTIMGPointer(); + }; + + /* 8030BD10 */ void searchUpdateMaterialID(J2DScreen*); + /* 8030BEE8 */ void getTexNo(u16, u16*) const; + /* 8030BF9C */ void getResTIMG(u16) const; + /* 8030BFF0 */ void getPalette(u16) const; + /* 8030CB90 */ ~J2DAnmTexPattern(); +}; + +struct J2DAnmTevRegKey { + /* 801841EC */ ~J2DAnmTevRegKey(); + /* 8030C0F0 */ void getTevColorReg(u16, _GXColorS10*) const; + /* 8030C3B4 */ void getTevKonstReg(u16, _GXColor*) const; + /* 8030C678 */ void searchUpdateMaterialID(J2DScreen*); +}; + +struct J2DAnmColorKey { + /* 80239BE0 */ ~J2DAnmColorKey(); + /* 8030B200 */ void getColor(u16, _GXColor*) const; +}; + +struct J2DAnmColorFull { + /* 8030AFC8 */ void getColor(u16, _GXColor*) const; + /* 8030CCF8 */ ~J2DAnmColorFull(); +}; + +struct J2DAnmColor { + /* 801842FC */ ~J2DAnmColor(); + /* 802EB390 */ void getColor(u16, _GXColor*) const; + /* 8030AF24 */ void searchUpdateMaterialID(J2DScreen*); +}; + +struct J2DAnmBase { + /* 80053C94 */ ~J2DAnmBase(); + /* 800569B0 */ void searchUpdateMaterialID(J2DScreen*); +}; + +struct J2DAnmVtxColor {}; + +struct J2DAnmTransform {}; + #endif /* J2DANIMATION_H */ diff --git a/include/JSystem/J2DGraph/J2DGrafContext.h b/include/JSystem/J2DGraph/J2DGrafContext.h index de1fca9aaa..5a8d084bdc 100644 --- a/include/JSystem/J2DGraph/J2DGrafContext.h +++ b/include/JSystem/J2DGraph/J2DGrafContext.h @@ -1,6 +1,28 @@ #ifndef J2DGRAFCONTEXT_H #define J2DGRAFCONTEXT_H +#include "JSystem/JGeometry.h" +#include "JSystem/JUtility.h" #include "dolphin/types.h" +struct J2DGrafContext { + /* 802E8B08 */ J2DGrafContext(f32, f32, f32, f32); + /* 802E8BB4 */ void setPort(); + /* 802E8C44 */ void setup2D(); + /* 802E8E20 */ void setScissor(); + /* 802E90C0 */ void scissor(JGeometry::TBox2<f32> const&); + /* 802E90E4 */ void place(JGeometry::TBox2<f32> const&); + /* 802E961C */ void place(f32, f32, f32, f32); + /* 802E9118 */ void setColor(JUtility::TColor, JUtility::TColor, JUtility::TColor, + JUtility::TColor); + /* 802E9234 */ void setLineWidth(u8); + /* 802E9260 */ void fillBox(JGeometry::TBox2<f32> const&); + /* 802E9368 */ void drawFrame(JGeometry::TBox2<f32> const&); + /* 802E9488 */ void line(JGeometry::TVec2<f32>, JGeometry::TVec2<f32>); + /* 802E9564 */ void lineTo(JGeometry::TVec2<f32>); + /* 802E95D4 */ ~J2DGrafContext(); + /* 802E9664 */ bool getGrafType() const; + /* 802E966C */ void setLookat(); +}; + #endif /* J2DGRAFCONTEXT_H */ diff --git a/include/JSystem/J2DGraph/J2DManage.h b/include/JSystem/J2DGraph/J2DManage.h index b17c623296..6222e2139b 100644 --- a/include/JSystem/J2DGraph/J2DManage.h +++ b/include/JSystem/J2DGraph/J2DManage.h @@ -1,6 +1,18 @@ #ifndef J2DMANAGE_H #define J2DMANAGE_H +#include "JSystem/JSupport/JSUInputStream.h" #include "dolphin/types.h" +struct J2DResReference { + /* 8030CF10 */ void getResReference(u16) const; + /* 8030CF44 */ void getName(u16) const; +}; + +class J2DDataManage { +public: + /* 8030CE18 */ void get(char const*); + /* 8030CE7C */ void get(JSUInputStream*); +}; + #endif /* J2DMANAGE_H */ diff --git a/include/JSystem/J2DGraph/J2DMaterial.h b/include/JSystem/J2DGraph/J2DMaterial.h index 767753657c..065484c208 100644 --- a/include/JSystem/J2DGraph/J2DMaterial.h +++ b/include/JSystem/J2DGraph/J2DMaterial.h @@ -1,6 +1,25 @@ #ifndef J2DMATERIAL_H #define J2DMATERIAL_H +#include "JSystem/J2DGraph/J2DAnimation.h" #include "dolphin/types.h" +struct J2DMaterial { + struct J2DMaterialAnmPointer { + /* 802EA79C */ J2DMaterialAnmPointer(); + }; + + /* 802EA1AC */ J2DMaterial(); + /* 802EA2CC */ ~J2DMaterial(); + /* 802EA38C */ void setGX(); + /* 802EA410 */ void createTevBlock(int, bool); + /* 802EA5C4 */ void createIndBlock(int, bool); + /* 802EA84C */ void makeAnmPointer(); + /* 802EA94C */ void setAnimation(J2DAnmTextureSRTKey*); + /* 802EAA2C */ void setAnimation(J2DAnmTexPattern*); + /* 802EAB0C */ void setAnimation(J2DAnmTevRegKey*); + /* 802EA89C */ void setAnimation(J2DAnmColor*); + /* 802EAC78 */ void animation(); +}; + #endif /* J2DMATERIAL_H */ diff --git a/include/JSystem/J2DGraph/J2DPane.h b/include/JSystem/J2DGraph/J2DPane.h index aa1cd96a7e..093b44ff94 100644 --- a/include/JSystem/J2DGraph/J2DPane.h +++ b/include/JSystem/J2DGraph/J2DPane.h @@ -1,6 +1,135 @@ #ifndef J2DPANE_H #define J2DPANE_H +#include "JSystem/J2DGraph/J2DAnimation.h" +#include "JSystem/J2DGraph/J2DGrafContext.h" +#include "JSystem/JGeometry.h" +#include "JSystem/JKernel/JKRArchive.h" +#include "JSystem/JSupport/JSUList.h" +#include "JSystem/JSupport/JSURandomInputStream.h" +#include "JSystem/JUtility/JUTFont.h" +#include "JSystem/JUtility/JUTResFont.h" +#include "JSystem/JUtility/JUTTexture.h" +#include "dolphin/mtx/mtx.h" #include "dolphin/types.h" +class J2DScreen; + +enum J2DRotateAxis { + /* 0x78 */ ROTATE_X = 'x', + /* 0x79 */ ROTATE_Y = 'y', + /* 0x7A */ ROTATE_Z = 'z' +}; + +enum J2DBasePosition {}; + +class J2DPane { +public: + J2DPane(); + J2DPane(J2DPane*, bool, u64, const JGeometry::TBox2<f32>&); + J2DPane(u64, const JGeometry::TBox2<f32>&); + J2DPane(J2DPane* other, JSURandomInputStream* stream, u8 arg3); + virtual ~J2DPane(); + + /* 0x0c */ virtual s32 getTypeID() const; + /* 0x10 */ virtual void move(f32 x, f32 y); + /* 0x14 */ virtual void add(f32 x, f32 y); + /* 0x18 */ virtual void resize(f32 x, f32 y); + /* 0x1c */ virtual void setCullBack(bool cull); + /* 0x20 */ virtual void setCullBack(_GXCullMode cmode); + /* 0x24 */ virtual void setAlpha(u8); + /* 0x28 */ virtual bool setConnectParent(bool connected); + /* 0x2c */ virtual void calcMtx(); + /* 0x30 */ virtual void update(); + /* 0x34 */ virtual void drawSelf(f32 arg1, f32 arg2); + /* 0x38 */ virtual void drawSelf(f32 arg1, f32 arg2, Mtx* mtx); + /* 0x3c */ virtual const J2DPane* search(u64 tag); + /* 0x40 */ virtual const J2DPane* searchUserInfo(u64 tag); + /* 0x44 */ virtual void makeMatrix(f32, f32); + /* 0x48 */ virtual void makeMatrix(f32 a, f32 b, f32 c, f32 d); + /* 0x4c */ virtual bool isUsed(const ResTIMG* timg); + /* 0x50 */ virtual bool isUsed(const ResFONT* font); + /* 0x54 */ virtual void clearAnmTransform(); + /* 0x58 */ virtual void rewriteAlpha(); + /* 0x5c */ virtual void setAnimation(J2DAnmBase* anm); + /* 0x60 */ virtual void setAnimation(J2DAnmTransform* anm); + /* 0x64 */ virtual void setAnimation(J2DAnmColor* anm); + /* 0x68 */ virtual void setAnimation(J2DAnmTexPattern* anm); + /* 0x6c */ virtual void setAnimation(J2DAnmTextureSRTKey* anm); + /* 0x70 */ virtual void setAnimation(J2DAnmTevRegKey* anm); + /* 0x74 */ virtual void setAnimation(J2DAnmVisibilityFull* anm); + /* 0x78 */ virtual void setAnimation(J2DAnmVtxColor* anm); + /* 0x7c */ virtual const J2DAnmTransform* animationTransform(const J2DAnmTransform* transform); + /* 0x80 */ virtual void setVisibileAnimation(J2DAnmVisibilityFull* visibility); + /* 0x84 */ virtual void setAnimationVF(J2DAnmVisibilityFull* visibility); + /* 0x88 */ virtual void setVtxColorAnimation(J2DAnmVtxColor* vtx_color); + /* 0x8c */ virtual void setAnimationVC(J2DAnmVtxColor* vtx_color); + /* 0x90 */ virtual const J2DAnmTransform* animationPane(const J2DAnmTransform* transform); + + f32 getHeight() const { return mBounds.getHeight(); } + f32 getWidth() const { return mBounds.getWidth(); } + JSUTree<J2DPane>* getFirstChild() { return mPaneTree.getFirstChild(); } + const JSUTree<J2DPane>* getPaneTree() { return &mPaneTree; } + + void initiate(); + void initialize(J2DPane*, bool, u64, const JGeometry::TBox2<f32>&); + void initialize(u64 tag, const JGeometry::TBox2<f32>& dim); + void makePaneStream(J2DPane* other, JSURandomInputStream* stream); + void changeUseTrans(J2DPane* other); + bool appendChild(J2DPane* child); + bool insertChild(J2DPane* before, J2DPane* child); + void draw(f32 a1, f32 a2, const J2DGrafContext* ctx, bool a4, bool a5); + void place(const JGeometry::TBox2<f32>& dim); + JGeometry::TBox2<f32>& getBounds(); + void rotate(f32 offsetX, f32 offsetY, J2DRotateAxis axis, f32 angle); + void rotate(f32 angle); + void clip(const JGeometry::TBox2<f32>& bounds); + void setBasePosition(J2DBasePosition position); + void setInfluencedAlpha(bool arg1, bool arg2); + void getGlbVtx(u8 arg1) const; + const J2DPane* getFirstChildPane(); + const J2DPane* getNextChildPane(); + const J2DPane* getParentPane(); + void makePaneExStream(J2DPane* other, JSURandomInputStream* stream); + static s16 J2DCast_F32_to_S16(f32 value, u8 arg2); + void* getPointer(JSURandomInputStream* stream, u32 size, JKRArchive* archive); + void animationTransform(); + void updateTransform(const J2DAnmTransform* transform); + + static f32 static_mBounds[4]; + +public: + /* 0x04 */ u16 _4; + /* 0x06 */ u8 _6[2]; + /* 0x08 */ int id; + /* 0x0C */ u8 _c[4]; + /* 0x10 */ u64 mInfoTag; + /* 0x18 */ u64 mUserInfoTag; + /* 0x20 */ JGeometry::TBox2<f32> mBounds; + /* 0x30 */ JGeometry::TBox2<f32> mGlobalBounds; + /* 0x40 */ JGeometry::TBox2<f32> mClipRect; + /* 0x50 */ Mtx mPositionMtx; + /* 0x80 */ Mtx mGlobalMtx; + /* 0xB0 */ bool mVisible; + /* 0xB1 */ u8 mCullMode; + /* 0xB2 */ u8 mAlpha; + /* 0xB3 */ u8 mColorAlpha; + /* 0xB4 */ bool mIsInfluencedAlpha; + /* 0xB5 */ bool mConnected; + /* 0xB6 */ char mRotAxis; + /* 0xB7 */ u8 mBasePosition; + /* 0xB8 */ f32 mRotateX; + /* 0xBC */ f32 mRotateY; + /* 0xC0 */ f32 mRotateZ; + /* 0xC4 */ f32 mRotateOffsetX; + /* 0xC8 */ f32 mRotateOffsetY; + /* 0xCC */ f32 mScaleX; + /* 0xD0 */ f32 mScaleY; + /* 0xD4 */ f32 mTranslateX; + /* 0xD8 */ f32 mTranslateY; + /* 0xDC */ JSUTree<J2DPane> mPaneTree; + /* 0xF8 */ const J2DAnmTransform* mTransform; + /* 0xFC */ u32 _fc; +}; + #endif /* J2DPANE_H */ diff --git a/include/JSystem/J2DGraph/J2DPicture.h b/include/JSystem/J2DGraph/J2DPicture.h index 8eed8588ed..2dca4ac374 100644 --- a/include/JSystem/J2DGraph/J2DPicture.h +++ b/include/JSystem/J2DGraph/J2DPicture.h @@ -1,6 +1,114 @@ #ifndef J2DPICTURE_H #define J2DPICTURE_H +#include "JSystem/J2DGraph/J2DPane.h" +#include "JSystem/J2DGraph/J2DScreen.h" +#include "JSystem/JUtility/JUTTexture.h" #include "dolphin/types.h" +enum J2DMirror { + /* 0x0 */ MIRROR0, // temp, figure out later +}; + +enum J2DBinding { + /* 0xF */ BIND15 = 15, // temp, figure out later +}; + +class J2DPicture : public J2DPane { +public: + /* 802FCFF0 */ virtual ~J2DPicture(); + /* 802FF2E8 */ virtual s32 getTypeID() const; + /* 802FDB28 */ virtual void drawSelf(f32, f32); + /* 802FDB90 */ virtual void drawSelf(f32, f32, Mtx*); + /* 802FF09C */ virtual bool isUsed(ResTIMG const*); + /* 802FF63C */ virtual bool isUsed(ResFONT const*); + /* 802FF65C */ virtual void rewriteAlpha(); + /* 802FCCDC */ virtual void initiate(ResTIMG const*, ResTLUT const*); + /* 802FD098 */ virtual bool prepareTexture(u8); + /* 801BDD40 */ virtual void append(ResTIMG const*, f32); + /* 802FF238 */ virtual void append(ResTIMG const*, JUTPalette*, f32); + /* 80020338 */ virtual void append(char const*, f32); + /* 802FF2F0 */ virtual void append(char const*, JUTPalette*, f32); + /* 802FF208 */ virtual void append(JUTTexture*, f32); + /* 802FF3E0 */ virtual void prepend(ResTIMG const*, f32); + /* 802FF3B0 */ virtual void prepend(ResTIMG const*, JUTPalette*, f32); + /* 802FF380 */ virtual void prepend(char const*, f32); + /* 802FF350 */ virtual void prepend(char const*, JUTPalette*, f32); + /* 802FF320 */ virtual void prepend(JUTTexture*, f32); + /* 801BDD70 */ virtual void insert(ResTIMG const*, u8, f32); + /* 802FD168 */ virtual void insert(ResTIMG const*, JUTPalette*, u8, f32); + /* 80020368 */ virtual void insert(char const*, u8, f32); + /* 802FD4B4 */ virtual void insert(char const*, JUTPalette*, u8, f32); + /* 802FD524 */ virtual void insert(JUTTexture*, u8, f32); + /* 802FD6F4 */ virtual int remove(u8); + /* 802FF410 */ virtual int remove(); + /* 802FD814 */ virtual void remove(JUTTexture*); + /* 802FF4E0 */ virtual void draw(f32, f32, bool, bool, bool); + /* 802FF448 */ virtual void draw(f32, f32, u8, bool, bool, bool); + /* 802FDC70 */ virtual void draw(f32, f32, f32, f32, bool, bool, bool); + /* 802FF588 */ virtual void drawOut(f32, f32, f32, f32, f32, f32); + /* 802FF524 */ virtual void drawOut(f32, f32, f32, f32, f32, f32, f32, f32); + /* 802FDF88 */ virtual void drawOut(JGeometry::TBox2<f32> const&, JGeometry::TBox2<f32> const&); + /* 802FF29C */ virtual void load(_GXTexMapID, u8); + /* 802FF268 */ virtual void load(u8); + /* 800202CC */ virtual void setBlendRatio(f32, f32); + /* 802FEA74 */ virtual void setBlendColorRatio(f32, f32); + /* 802FEA9C */ virtual void setBlendAlphaRatio(f32, f32); + /* 802FD874 */ virtual void changeTexture(ResTIMG const*, u8); + /* 802FD964 */ virtual void changeTexture(char const*, u8); + /* 802FD9BC */ virtual void changeTexture(ResTIMG const*, u8, JUTPalette*); + /* 802FDAC8 */ virtual void changeTexture(char const*, u8, JUTPalette*); + /* 800539DC */ virtual void getTexture(u8) const; + /* 802FF634 */ virtual u8 getTextureCount() const; + /* 80053C6C */ virtual void setBlack(JUtility::TColor); + /* 80053C44 */ virtual void setWhite(JUtility::TColor); + /* 8018BEE0 */ virtual void setBlackWhite(JUtility::TColor, JUtility::TColor); + /* 801DFA4C */ virtual void getBlack() const; + /* 801DFA40 */ virtual void getWhite() const; + /* 8025603C */ virtual bool getMaterial() const; + /* 802FDBFC */ virtual void drawFullSet(f32, f32, f32, f32, Mtx*); + /* 802FE380 */ virtual void drawTexCoord(f32, f32, f32, f32, s16, s16, s16, s16, s16, s16, s16, + s16, Mtx*); + /* 802FF100 */ virtual void getUsableTlut(u8); + + /* 802FC800 */ J2DPicture(u64, JGeometry::TBox2<f32> const&, ResTIMG const*, ResTLUT const*); + /* 802FC708 */ J2DPicture(ResTIMG const*); + /* 802FC118 */ J2DPicture(J2DPane*, JSURandomInputStream*, JKRArchive*); + /* 802FC050 */ J2DPicture(); + /* 802FC1D4 */ J2DPicture(J2DPane*, JSURandomInputStream*, J2DMaterial*); + /* 802FC8E8 */ void private_readStream(J2DPane*, JSURandomInputStream*, JKRArchive*); + /* 802FCD70 */ void private_initiate(ResTIMG const*, ResTLUT const*); + /* 802FCE9C */ void initinfo(); + /* 802FE5D0 */ void setTevMode(); + /* 802FEA60 */ static void swap(f32&, f32&); + /* 802FEAC4 */ void setBlendKonstColor(); + /* 802FEB94 */ void setBlendKonstAlpha(); + /* 802FEC64 */ void getNewColor(JUtility::TColor*); + /* 802FED84 */ void setTexCoord(JGeometry::TVec2<s16>*, JUTTexture const*, J2DBinding, + J2DMirror, bool); + /* 802FED44 */ void setTexCoord(JUTTexture const*, J2DBinding, J2DMirror, bool); + /* 802FF1D0 */ u8 getTlutID(ResTIMG const*, u8); + + void setCornerColor(JUtility::TColor c0, JUtility::TColor c1, JUtility::TColor c2, + JUtility::TColor c3) { + mCornerColor[0] = c0; + mCornerColor[1] = c1; + mCornerColor[2] = c2; + mCornerColor[3] = c3; + } + +private: + /* 0x100 */ JUTTexture* mTexture[2]; + /* 0x108 */ u8 mTextureCount; + /* 0x109 */ u8 field_0x109; + /* 0x10A */ JGeometry::TVec2<s16> field_0x10a[4]; + /* 0x11C */ f32 field_0x11c[4]; + /* 0x12C */ JUTPalette* field_0x12c; + /* 0x130 */ JUtility::TColor mWhite; + /* 0x134 */ JUtility::TColor mBlack; + /* 0x138 */ JUtility::TColor mCornerColor[4]; + /* 0x148 */ JUtility::TColor field_0x148; + /* 0x14C */ JUtility::TColor field_0x14c; +}; + #endif /* J2DPICTURE_H */ diff --git a/include/JSystem/J2DGraph/J2DScreen.h b/include/JSystem/J2DGraph/J2DScreen.h index ef3e43079d..27f5c55161 100644 --- a/include/JSystem/J2DGraph/J2DScreen.h +++ b/include/JSystem/J2DGraph/J2DScreen.h @@ -1,6 +1,64 @@ #ifndef J2DSCREEN_H #define J2DSCREEN_H +#include "JSystem/J2DGraph/J2DManage.h" +#include "JSystem/J2DGraph/J2DMaterial.h" +#include "JSystem/J2DGraph/J2DPane.h" +#include "JSystem/JUtility/JUTNameTab.h" #include "dolphin/types.h" +struct J2DScrnBlockHeader {}; + +class J2DScreen : public J2DPane { +public: + /* 802F8540 */ virtual ~J2DScreen(); + /* 802F9A18 */ virtual s32 getTypeID() const; + /* 802F9A20 */ virtual void calcMtx(); + /* 802F9120 */ virtual void drawSelf(f32, f32, Mtx*); + /* 802F90A0 */ virtual const J2DPane* search(u64); + /* 802F90E0 */ virtual const J2DPane* searchUserInfo(u64); + /* 802F9600 */ virtual bool isUsed(ResTIMG const*); + /* 802F9620 */ virtual bool isUsed(ResFONT const*); + /* 80053BA0 */ virtual void clearAnmTransform(); + /* 802F9704 */ virtual void setAnimation(J2DAnmColor*); + /* 80192414 */ virtual void setAnimation(J2DAnmTransform*); + /* 802F9798 */ virtual void setAnimation(J2DAnmTextureSRTKey*); + /* 802F99A8 */ virtual void setAnimation(J2DAnmVtxColor*); + /* 802F9838 */ virtual void setAnimation(J2DAnmTexPattern*); + /* 802F99C8 */ virtual void setAnimation(J2DAnmVisibilityFull*); + /* 802F98CC */ virtual void setAnimation(J2DAnmTevRegKey*); + /* 802F9A54 */ virtual void setAnimation(J2DAnmBase*); + /* 802F9A74 */ virtual void setAnimationVF(J2DAnmVisibilityFull*); + /* 802F9A78 */ virtual void setAnimationVC(J2DAnmVtxColor*); + /* 802F99E8 */ virtual void createPane(J2DScrnBlockHeader const&, JSURandomInputStream*, + J2DPane*, u32); + /* 802F8B98 */ virtual void createPane(J2DScrnBlockHeader const&, JSURandomInputStream*, + J2DPane*, u32, JKRArchive*); + + /* 802F8498 */ J2DScreen(); + /* 802F85A8 */ void clean(); + /* 802F8648 */ void setPriority(char const*, u32, JKRArchive*); + /* 802F8748 */ bool setPriority(JSURandomInputStream*, u32, JKRArchive*); + /* 802F8778 */ bool private_set(JSURandomInputStream*, u32, JKRArchive*); + /* 802F8834 */ bool checkSignature(JSURandomInputStream*); + /* 802F8894 */ void getScreenInformation(JSURandomInputStream*); + /* 802F8990 */ void makeHierarchyPanes(J2DPane*, JSURandomInputStream*, u32, JKRArchive*); + /* 802F8ED4 */ void draw(f32, f32, J2DGrafContext const*); + /* 802F9280 */ void getResReference(JSURandomInputStream*, u32); + /* 802F937C */ void createMaterial(JSURandomInputStream*, u32, JKRArchive*); + /* 802F9640 */ static void* getNameResource(char const*); + /* 802F9690 */ void animation(); + + static J2DDataManage* mDataManage; + +private: + /* 0x100 */ bool mScissor; + /* 0x102 */ u16 mMaterialNum; + /* 0x104 */ J2DMaterial* mMaterials; + /* 0x108 */ J2DResReference* field_0x108; + /* 0x10C */ J2DResReference* field_0x10c; + /* 0x110 */ JUTNameTab* mNameTable; + /* 0x114 */ u32 field_0x114; +}; + #endif /* J2DSCREEN_H */ diff --git a/include/JSystem/J2DGraph/J2DTextBox.h b/include/JSystem/J2DGraph/J2DTextBox.h index 90e31c1877..d58cfe1669 100644 --- a/include/JSystem/J2DGraph/J2DTextBox.h +++ b/include/JSystem/J2DGraph/J2DTextBox.h @@ -1,6 +1,72 @@ #ifndef J2DTEXTBOX_H #define J2DTEXTBOX_H +#include "JSystem/J2DGraph/J2DMaterial.h" +#include "JSystem/J2DGraph/J2DPane.h" #include "dolphin/types.h" +enum J2DTextBoxVBinding { + /* 0x0 */ VBIND_CENTER, + /* 0x1 */ VBIND_BOTTOM, + /* 0x2 */ VBIND_TOP +}; + +enum J2DTextBoxHBinding { + /* 0x0 */ HBIND_CENTER, + /* 0x1 */ HBIND_RIGHT, + /* 0x2 */ HBIND_LEFT +}; + +class J2DTextBox : public J2DPane { +public: + /* 803001E0 */ virtual ~J2DTextBox(); + /* 80300C68 */ virtual s32 getTypeID() const; + /* 80300AF8 */ virtual void resize(f32, f32); + /* 80300870 */ virtual bool setConnectParent(bool); + /* 80300950 */ virtual void drawSelf(f32, f32, Mtx*); + /* 803008E8 */ virtual void drawSelf(f32, f32); + /* 80300C70 */ virtual bool isUsed(ResTIMG const*); + /* 80300BFC */ virtual bool isUsed(ResFONT const*); + /* 80300C90 */ virtual void rewriteAlpha(); + /* 80300490 */ virtual void draw(f32, f32, f32, J2DTextBoxHBinding); + /* 803002E8 */ virtual void draw(f32, f32); + /* 80300278 */ virtual void setFont(JUTFont*); + /* 8021C7F4 */ virtual void getFont() const; + /* 80254408 */ virtual void setBlack(JUtility::TColor); + /* 80186C84 */ virtual void setWhite(JUtility::TColor); + /* 8019230C */ virtual void setBlackWhite(JUtility::TColor, JUtility::TColor); + /* 801DFA34 */ virtual void getBlack() const; + /* 801DFA28 */ virtual void getWhite() const; + /* 8025602C */ virtual bool getMaterial() const; + + /* 802FFBC4 */ J2DTextBox(u64, JGeometry::TBox2<f32> const&, ResFONT const*, char const*, s16, + J2DTextBoxHBinding, J2DTextBoxVBinding); + /* 802FF6D8 */ J2DTextBox(J2DPane*, JSURandomInputStream*, JKRArchive*); + /* 802FF75C */ J2DTextBox(J2DPane*, JSURandomInputStream*, u32, J2DMaterial*); + /* 802FF660 */ J2DTextBox(); + /* 802FFC58 */ void initiate(ResFONT const*, char const*, s16, J2DTextBoxHBinding, + J2DTextBoxVBinding); + /* 802FFE88 */ void private_readStream(J2DPane*, JSURandomInputStream*, JKRArchive*); + /* 80300658 */ char* getStringPtr() const; + /* 8030074C */ s32 setString(s16, char const*, ...); + /* 80300660 */ s32 setString(char const*, ...); + +private: + /* 0x0100 */ JUTFont* mFont; + /* 0x0104 */ JUtility::TColor mCharColor; + /* 0x0108 */ JUtility::TColor mGradientColor; + /* 0x010C */ f32 field_0x10c; + /* 0x0110 */ f32 field_0x110; + /* 0x0114 */ f32 mCharSpacing; + /* 0x0118 */ f32 mLineSpacing; + /* 0x011C */ f32 field_0x11c; + /* 0x0120 */ f32 field_0x120; + /* 0x0124 */ char* mStringPtr; + /* 0x0128 */ JUtility::TColor mWhiteColor; + /* 0x012C */ JUtility::TColor mBlackColor; + /* 0x0130 */ u8 mFlags; + /* 0x0131 */ bool mTextFontOwned; + /* 0x0132 */ s16 mStringLength; +}; + #endif /* J2DTEXTBOX_H */ diff --git a/include/JSystem/JAudio2/JAISoundInfo.h b/include/JSystem/JAudio2/JAISoundInfo.h index f6938f3e8a..795d674969 100644 --- a/include/JSystem/JAudio2/JAISoundInfo.h +++ b/include/JSystem/JAudio2/JAISoundInfo.h @@ -3,4 +3,9 @@ #include "dolphin/types.h" +struct JAISoundInfo { + /* 802A2D34 */ JAISoundInfo(bool); + /* 802A2D50 */ ~JAISoundInfo(); +}; + #endif /* JAISOUNDINFO_H */ diff --git a/include/JSystem/JAudio2/JASAudioReseter.h b/include/JSystem/JAudio2/JASAudioReseter.h index b9bf1b0921..c842115b09 100644 --- a/include/JSystem/JAudio2/JASAudioReseter.h +++ b/include/JSystem/JAudio2/JASAudioReseter.h @@ -3,4 +3,19 @@ #include "dolphin/types.h" +struct JASAudioReseter { + /* 8029D0B4 */ JASAudioReseter(); + /* 8029D0FC */ ~JASAudioReseter(); + /* 8029D138 */ void start(u32, bool); + /* 8029D1D4 */ void resume(); + /* 8029D1F8 */ void checkDone() const; + /* 8029D200 */ void calc(); + /* 8029D2D4 */ void callback(void*); + + /* 0x0 */ u32 field_0x0; + /* 0x4 */ f32 mDSPLevel; + /* 0x8 */ s32 mIsDone; + /* 0xC */ bool field_0xc; +}; // Size: 0x10 + #endif /* JASAUDIORESETER_H */ diff --git a/include/JSystem/JAudio2/JASGadget.h b/include/JSystem/JAudio2/JASGadget.h new file mode 100644 index 0000000000..6edcf6961a --- /dev/null +++ b/include/JSystem/JAudio2/JASGadget.h @@ -0,0 +1,14 @@ +#ifndef JASGADGET_H +#define JASGADGET_H + +#include "dolphin/types.h" + +template <class T> +class JASGlobalInstance { +public: + // T* getInstance() { return sInstance; } + + // static T* sInstance; +}; + +#endif /* JASGADGET_H */ diff --git a/include/JSystem/JParticle/JPAParticle.h b/include/JSystem/JParticle/JPAParticle.h index 01887531c1..23821622c7 100644 --- a/include/JSystem/JParticle/JPAParticle.h +++ b/include/JSystem/JParticle/JPAParticle.h @@ -1,12 +1,13 @@ #ifndef JPAPARTICLE_H #define JPAPARTICLE_H +#include "dolphin/gx/GX.h" #include "dolphin/types.h" class JPABaseParticle; -struct _GXTexMapID {}; struct JPABaseEmitter { + /* 8027EC60 */ void deleteAllParticle(); /* 8027EB60 */ void createChild(JPABaseParticle*); /* 8027EA40 */ void createParticle(); /* 8027EF30 */ void getCurrentCreateNumber() const; diff --git a/include/JSystem/JUtility.h b/include/JSystem/JUtility.h new file mode 100644 index 0000000000..c72bceccca --- /dev/null +++ b/include/JSystem/JUtility.h @@ -0,0 +1,30 @@ +#ifndef JUTILITY_H +#define JUTILITY_H + +#include "dolphin/gx/GXTexture.h" +#include "dolphin/types.h" + +namespace JUtility { + +struct TColor : _GXColor { + TColor() { set(-1); } + + TColor(u32 raw) { *(u32*)&r = raw; } + + void set(u32 col) { *(u32*)&r = col; } + void set(u8 oR, u8 oG, u8 oB, u8 oA) { + r = oR; + g = oG; + b = oB; + a = oA; + } + + u32 toUInt32() const { return *(u32*)&r; } + + operator u32() const { return toUInt32(); } + void operator=(const TColor& rhs) { ((_GXColor*)this)->operator=(rhs); } +}; + +} // namespace JUtility + +#endif /* JUTILITY_H */
\ No newline at end of file diff --git a/include/JSystem/JUtility/JUTFont.h b/include/JSystem/JUtility/JUTFont.h index 640143a768..b000764382 100644 --- a/include/JSystem/JUtility/JUTFont.h +++ b/include/JSystem/JUtility/JUTFont.h @@ -1,46 +1,82 @@ #ifndef JUTFONT_H #define JUTFONT_H +#include "JSystem/JUtility.h" #include "dolphin/gx/GX.h" #include "dolphin/types.h" -namespace JUtility { +struct ResFONT { + struct INF1 { + /* 0x00 */ u32 magic; + /* 0x04 */ u32 size; + /* 0x08 */ u16 fontType; + /* 0x0A */ u16 ascent; + /* 0x0C */ u16 descent; + /* 0x0E */ u16 width; + /* 0x10 */ u16 leading; + /* 0x12 */ u16 defaultCode; + }; -struct TColor : _GXColor { - TColor() { set(-1); } + struct WID1 { + /* 0x00 */ u32 magic; + /* 0x04 */ u32 size; + /* 0x08 */ u16 startCode; + /* 0x0A */ u16 endCode; + }; - TColor(u32 raw) { *(u32*)&r = raw; } + struct MAP1 { + /* 0x00 */ u32 magic; + /* 0x04 */ u32 size; + /* 0x08 */ u16 mappingMethod; + /* 0x0A */ u16 startCode; + /* 0x0C */ u16 endCode; + /* 0x0E */ u16 numEntries; + }; - void set(u32 col) { *(u32*)&r = col; } + struct GLY1 { + /* 0x00 */ u32 magic; + /* 0x04 */ u32 size; + /* 0x08 */ u16 startCode; + /* 0x0A */ u16 endCode; + /* 0x0C */ u16 cellWidth; + /* 0x0E */ u16 cellHeight; + /* 0x10 */ u32 textureSize; + /* 0x14 */ u16 textureFormat; + /* 0x16 */ u16 numRows; + /* 0x18 */ u16 numColumns; + /* 0x1A */ u16 textureWidth; + /* 0x1C */ u16 textureHeight; + }; - u32 toUInt32() const { return *(u32*)&r; } - - operator u32() const { return toUInt32(); } - void operator=(const TColor& rhs) { ((_GXColor*)this)->operator=(rhs); } + /* 0x00 */ u64 magic; + /* 0x08 */ u32 filesize; + /* 0x0C */ u32 numBlocks; + /* 0x10 */ u8 padding[0x10]; }; -} // namespace JUtility - class JUTFont { public: JUTFont(); virtual ~JUTFont() {} - struct TWidth {}; + struct TWidth { + u8 field_0x0; + u8 field_0x1; + }; - /* 0x0c */ virtual void setGX() = 0; + /* 0x0C */ virtual void setGX() = 0; /* 0x10 */ virtual void setGX(JUtility::TColor col1, JUtility::TColor col2); /* 0x14 */ virtual f32 drawChar_scale(f32 a1, f32 a2, f32 a3, f32 a4, int a5, bool a6) = 0; /* 0x18 */ virtual u16 getLeading() const = 0; - /* 0x1c */ virtual u16 getAscent() const = 0; + /* 0x1C */ virtual u16 getAscent() const = 0; /* 0x20 */ virtual u16 getDescent() const = 0; - /* 0x24 */ virtual u32 getHeight() const = 0; - /* 0x28 */ virtual u32 getWidth() const = 0; - /* 0x2c */ virtual void getWidthEntry(int i_no, TWidth* width) const; - /* 0x30 */ virtual u32 getCellWidth() const; - /* 0x34 */ virtual u32 getCellHeight() const; - /* 0x38 */ virtual u32 getFontType() const = 0; - /* 0x3c */ virtual void getResFont() const = 0; + /* 0x24 */ virtual u16 getHeight() const = 0; + /* 0x28 */ virtual u16 getWidth() const = 0; + /* 0x2C */ virtual void getWidthEntry(int i_no, TWidth* width) const; + /* 0x30 */ virtual u16 getCellWidth() const; + /* 0x34 */ virtual u16 getCellHeight() const; + /* 0x38 */ virtual u16 getFontType() const = 0; + /* 0x3C */ virtual ResFONT* getResFont() const = 0; /* 0x40 */ virtual bool isLeadByte(int a1) const = 0; static bool isLeadByte_1Byte(int b); @@ -52,14 +88,13 @@ public: void setGradColor(JUtility::TColor col1, JUtility::TColor col2); f32 drawString_size_scale(f32 a1, f32 a2, f32 a3, f32 a4, const char* a5, u32 usz, bool a7); - u8 unk4; - bool unk5; - int unk8; - JUtility::TColor mColor1; - JUtility::TColor mColor2; - JUtility::TColor mColor3; - JUtility::TColor mColor4; - int unk1C; + /* 0x04 */ bool mValid; + /* 0x05 */ bool mFixed; + /* 0x08 */ int mFixedWidth; + /* 0x0C */ JUtility::TColor mColor1; + /* 0x10 */ JUtility::TColor mColor2; + /* 0x14 */ JUtility::TColor mColor3; + /* 0x18 */ JUtility::TColor mColor4; }; #endif /* JUTFONT_H */ diff --git a/include/JSystem/JUtility/JUTNameTab.h b/include/JSystem/JUtility/JUTNameTab.h index ff0e7860e8..7f9d62dfde 100644 --- a/include/JSystem/JUtility/JUTNameTab.h +++ b/include/JSystem/JUtility/JUTNameTab.h @@ -26,6 +26,7 @@ public: s32 getIndex(char const*) const; const char* getName(u16 index) const; u16 calcKeyCode(char const* pName) const; + const ResNTAB* getResNameTable() const { return mpNameTable; } private: const ResNTAB* mpNameTable; diff --git a/include/JSystem/JUtility/JUTPalette.h b/include/JSystem/JUtility/JUTPalette.h index 64ef0ce53c..5de6c98ae6 100644 --- a/include/JSystem/JUtility/JUTPalette.h +++ b/include/JSystem/JUtility/JUTPalette.h @@ -1,6 +1,59 @@ #ifndef JUTPALETTE_H #define JUTPALETTE_H +#include "dolphin/gx/GX.h" #include "dolphin/types.h" +enum JUTTransparency { UNK0, UNK1 }; + +enum _GXTlut { + /* 0x00 */ GX_TLUT0, + /* 0x01 */ GX_TLUT1, + /* 0x02 */ GX_TLUT2, + /* 0x03 */ GX_TLUT3, + /* 0x04 */ GX_TLUT4, + /* 0x05 */ GX_TLUT5, + /* 0x06 */ GX_TLUT6, + /* 0x07 */ GX_TLUT7, + /* 0x08 */ GX_TLUT8, + /* 0x09 */ GX_TLUT9, + /* 0x0A */ GX_TLUT10, + /* 0x0B */ GX_TLUT11, + /* 0x0C */ GX_TLUT12, + /* 0x0D */ GX_TLUT13, + /* 0x0E */ GX_TLUT14, + /* 0x0F */ GX_TLUT15, + /* 0x10 */ GX_BIGTLUT0, + /* 0x11 */ GX_BIGTLUT1, + /* 0x12 */ GX_BIGTLUT2, + /* 0x13 */ GX_BIGTLUT3, +}; + +enum _GXTlutFmt { + /* 0x00 */ UNK, +}; + +struct ResTLUT { + u8 format; + u8 transparency; + u16 numColors; +}; + +class JUTPalette { +public: + /* 802DE890 */ void storeTLUT(_GXTlut, ResTLUT*); + /* 802DE91C */ void storeTLUT(_GXTlut, _GXTlutFmt, JUTTransparency, u16, void*); + /* 802DE95C */ bool load(); + + u8 getTlutName() const { return mTlutName; } + +private: + /* 0x00 */ _GXTlutObj mTlutObj; + /* 0x0C */ u8 mTlutName; + /* 0x0D */ u8 mFormat; + /* 0x10 */ ResTLUT* mColorTable; + /* 0x14 */ u16 mNumColors; + /* 0x16 */ u8 mTransparency; +}; + #endif /* JUTPALETTE_H */ diff --git a/include/JSystem/JUtility/JUTResFont.h b/include/JSystem/JUtility/JUTResFont.h index 848933805a..cf0398abd3 100644 --- a/include/JSystem/JUtility/JUTResFont.h +++ b/include/JSystem/JUtility/JUTResFont.h @@ -1,6 +1,65 @@ #ifndef JUTRESFONT_H #define JUTRESFONT_H +#include "JSystem/JKernel/JKRHeap.h" +#include "JSystem/JUtility/JUTFont.h" #include "dolphin/types.h" +class JUTResFont : public JUTFont { +public: + /* 802DF000 */ virtual ~JUTResFont(); + /* 802DF48C */ virtual void setGX(); + /* 802DF584 */ virtual void setGX(JUtility::TColor, JUtility::TColor); + /* 802DF7C4 */ virtual f32 drawChar_scale(f32, f32, f32, f32, int, bool); + /* 802DDFEC */ virtual u16 getLeading() const; + /* 802DE004 */ virtual u16 getAscent() const; + /* 802DE010 */ virtual u16 getDescent() const; + /* 802DE01C */ virtual u16 getHeight() const; + /* 802DDFF8 */ virtual u16 getWidth() const; + /* 802DFC64 */ virtual void getWidthEntry(int, JUTFont::TWidth*) const; + /* 802DFD0C */ virtual u16 getCellWidth() const; + /* 802DFD58 */ virtual u16 getCellHeight() const; + /* 802DDFE0 */ virtual u16 getFontType() const; + /* 802DDFD8 */ virtual ResFONT* getResFont() const; + /* 802DFDA4 */ virtual bool isLeadByte(int) const; + /* 802DFF60 */ virtual void loadImage(int, _GXTexMapID); + /* 802DF344 */ virtual void setBlock(); + + /* 802DEF94 */ JUTResFont(ResFONT const*, JKRHeap*); + /* 802DEF48 */ JUTResFont(); + /* 802DF08C */ void deleteMemBlocks_ResFont(); + /* 802DF0B0 */ void initialize_state(); + /* 802DF0DC */ bool initiate(ResFONT const*, JKRHeap*); + /* 802DF13C */ bool protected_initiate(ResFONT const*, JKRHeap*); + /* 802DF248 */ void countBlock(); + /* 802DFBE8 */ void loadFont(int, _GXTexMapID, JUTFont::TWidth*); + /* 802DFDD8 */ int getFontCode(int) const; + /* 802E00C4 */ void convertSjis(int, u16*) const; + + inline void delete_and_initialize() { + deleteMemBlocks_ResFont(); + initialize_state(); + } + + static void* const saoAboutEncoding_[3]; + + // some types uncertain, may need to be fixed + /* 0x1C */ void* field_0x1c; + /* 0x20 */ void* field_0x20; + /* 0x24 */ _GXTexObj field_0x24; + /* 0x44 */ int field_0x44; + /* 0x48 */ const ResFONT* mResFont; + /* 0x4C */ ResFONT::INF1* mInf1Ptr; + /* 0x50 */ void* field_0x50; + /* 0x54 */ ResFONT::WID1* mWid1Ptr; + /* 0x58 */ ResFONT::GLY1* mGly1Ptr; + /* 0x5C */ ResFONT::MAP1* mMap1Ptr; + /* 0x60 */ u16 mWid1BlockNum; + /* 0x62 */ u16 mGly1BlockNum; + /* 0x64 */ u16 mMap1BlockNum; + /* 0x66 */ u16 field_0x66; + /* 0x68 */ u16 field_0x68; + /* 0x6C */ void* field_0x6c; +}; + #endif /* JUTRESFONT_H */ diff --git a/include/JSystem/JUtility/JUTTexture.h b/include/JSystem/JUtility/JUTTexture.h index ad657caffb..113cdf923c 100644 --- a/include/JSystem/JUtility/JUTTexture.h +++ b/include/JSystem/JUtility/JUTTexture.h @@ -1,33 +1,74 @@ #ifndef JUTTEXTURE_H #define JUTTEXTURE_H +#include "JSystem/JUtility/JUTPalette.h" #include "dolphin/types.h" struct ResTIMG { /* Acts as the header to image data. Usually texture data immediately follows it, so any pointer arithmetic to go past the end of this structure is so that a variable sized allocated buffer can be accessed. */ - u8 texture_format; - bool is_alpha_enabled; - u16 texture_width; - u16 texture_height; - u8 wrap_s; - u8 wrap_t; - bool is_palettes_enabled; - u8 palette_format; - u16 palette_count; - u32 palette_offset; - bool is_mip_map_enabled; - bool do_edge_lod; - bool bias_clamp; - u8 max_anisotropy; - u8 min_filter; - u8 mag_filter; - u8 min_lod; - u8 max_lod; - u8 num_mipmaps; + u8 format; + bool alphaEnabled; + u16 width; + u16 height; + u8 wrapS; + u8 wrapT; + bool palettesEnabled; + u8 paletteFormat; + u16 paletteCount; + u32 paletteOffset; + bool mipmapEnabled; + bool doEdgeLOD; + bool biasClamp; + u8 maxAnisotropy; + u8 minFilter; + u8 magFilter; + u8 minLOD; + u8 maxLOD; + u8 mipmapCount; u8 unknown; - u16 lod_bias; - u32 texture_data_offset; + s16 LODBias; + u32 texDataOffset; +}; + +class JUTTexture { +public: + JUTTexture() { + setCaptureFlag(false); + mEmbPalette = NULL; + mTexInfo = NULL; + } + ~JUTTexture(); + void storeTIMG(ResTIMG const*, JUTPalette*, _GXTlut); + void storeTIMG(ResTIMG const*, u8); + void storeTIMG(ResTIMG const*, JUTPalette*); + void attachPalette(JUTPalette*); + void init(); + void initTexObj(_GXTlut); + void initTexObj(); + void load(_GXTexMapID); + + const ResTIMG* getTexInfo() const { return mTexInfo; } + void setCaptureFlag(bool flag) { mFlags &= 2 | flag; } + u8 getCaptureFlag() const { return mFlags & 1; } + u8 getEmbPaletteDelFlag() const { return mFlags & 2; } + +private: + /* 0x00 */ _GXTexObj mTexObj; + /* 0x20 */ const ResTIMG* mTexInfo; + /* 0x24 */ void* mTexData; + /* 0x28 */ JUTPalette* mEmbPalette; + /* 0x2C */ JUTPalette* field_0x2c; + /* 0x30 */ u8 mWrapS; + /* 0x31 */ u8 mWrapT; + /* 0x32 */ u8 mMinFilter; + /* 0x33 */ u8 mMagFilter; + /* 0x34 */ s16 mMinLOD; + /* 0x36 */ s16 mMaxLOD; + /* 0x38 */ s16 mLODBias; + /* 0x3A */ u8 mTlutName; + /* 0x3B */ u8 mFlags; + /* 0x3C */ void* field_0x3c; }; #endif /* JUTTEXTURE_H */ diff --git a/include/SSystem/SComponent/c_sxyz.h b/include/SSystem/SComponent/c_sxyz.h index 61843437ef..ad1bf45b45 100644 --- a/include/SSystem/SComponent/c_sxyz.h +++ b/include/SSystem/SComponent/c_sxyz.h @@ -5,6 +5,12 @@ struct SVec { s16 x, y, z; + + void set(s16 oX, s16 oY, s16 oZ) { + x = oX; + y = oY; + z = oZ; + } }; class csXyz : public SVec { public: diff --git a/include/Z2AudioLib/Z2AudioMgr.h b/include/Z2AudioLib/Z2AudioMgr.h index 212d5f94c4..f804cd58d1 100644 --- a/include/Z2AudioLib/Z2AudioMgr.h +++ b/include/Z2AudioLib/Z2AudioMgr.h @@ -2,11 +2,13 @@ #define Z2AUDIOMGR_H #include "JSystem/JAudio2/JAISound.h" +#include "JSystem/JAudio2/JASAudioReseter.h" #include "JSystem/JKernel/JKRArchive.h" #include "JSystem/JKernel/JKRSolidHeap.h" #include "Z2AudioLib/Z2SceneMgr.h" #include "Z2AudioLib/Z2SeMgr.h" #include "Z2AudioLib/Z2SeqMgr.h" +#include "Z2AudioLib/Z2SoundObjMgr.h" #include "Z2AudioLib/Z2SoundStarter.h" #include "Z2AudioLib/Z2StatusMgr.h" #include "dolphin/types.h" @@ -30,8 +32,8 @@ private: /* 0x03D0 */ Z2SeqMgr mSeqMgr; /* 0x04A4 */ Z2SceneMgr mSceneMgr; /* 0x04C4 */ Z2StatusMgr mStatusMgr; - /* 0x04F4 */ // Z2SoundObjMgr mSoundObjMgr; - /* 0x051C */ // JASAudioReseter mAudioReseter; + /* 0x04F4 */ Z2SoundObjMgr mSoundObjMgr; + /* 0x051C */ JASAudioReseter mAudioReseter; /* 0x052C */ Z2SoundStarter mSoundStarter; /* 0x0530 */ // Z2SoundMgr mSoundMgr; /* 0x0D40 */ // JAISoundInfo mSoundInfo; diff --git a/include/Z2AudioLib/Z2Creature.h b/include/Z2AudioLib/Z2Creature.h index 8bd14a7d87..3cea0e6b23 100644 --- a/include/Z2AudioLib/Z2Creature.h +++ b/include/Z2AudioLib/Z2Creature.h @@ -96,6 +96,10 @@ private: class Z2CreatureRide { public: + Z2CreatureRide(); + ~Z2CreatureRide(); + void deleteObject(); + void init(Vec*, Vec*, u8, u8); void setLinkRiding(bool); private: diff --git a/include/Z2AudioLib/Z2EnvSeMgr.h b/include/Z2AudioLib/Z2EnvSeMgr.h index 844bf871f0..a926878fc7 100644 --- a/include/Z2AudioLib/Z2EnvSeMgr.h +++ b/include/Z2AudioLib/Z2EnvSeMgr.h @@ -1,6 +1,47 @@ #ifndef Z2ENVSEMGR_H #define Z2ENVSEMGR_H +#include "dolphin/mtx/mtxvec.h" #include "dolphin/types.h" +struct Z2EnvSeMgr { + /* 802C611C */ Z2EnvSeMgr(); + /* 802C6540 */ ~Z2EnvSeMgr(); + /* 802C66B0 */ void framework(); + /* 802C6998 */ void resetScene(); + /* 802C699C */ void resetSceneInner(); + /* 802C6AC0 */ void initSceneEnvSe(s32, s8, f32); + /* 802C6C1C */ void playSceneEnvSe(); + /* 802C6C84 */ void initStaticEnvSe(u8, u8, u8, u8, Vec*); + /* 802C70C8 */ void startStaticEnvSe(s8); + /* 802C780C */ void registWindowPos(Vec*); + /* 802C7830 */ void startRainSe(s32, s8); + /* 802C7CF4 */ void startNearThunderSe(s8); + /* 802C7E68 */ void startFarThunderSe(Vec*, s8); + /* 802C7FB4 */ void setSnowPower(s8); + /* 802C7FBC */ void initStrongWindSe(); + /* 802C7FC8 */ void setWindDirection(Vec*); + /* 802C800C */ void startStrongWindSe(s8); + /* 802C80F8 */ void initRiverSe(u8, u8, u8, u8); + /* 802C8234 */ void registRiverSePos(Vec*); + /* 802C8258 */ void setHyrulSewerOpen(bool); + /* 802C8300 */ void startRiverSe(s8); + /* 802C8730 */ void initFallSe(u8, u8, u8, u8); + /* 802C886C */ void registFallSePos(Vec*); + /* 802C8890 */ void startFallSe(s8); + /* 802C8A90 */ void initEtcSe(u8, u8, u8, u8); + /* 802C8C24 */ void registEtcSePos(Vec*); + /* 802C8C48 */ void startEtcSe(s8); + /* 802C92C8 */ void registWolfSmellSePos(Vec*); + /* 802C92EC */ void startFogWipeTrigger(Vec*); + /* 802C93A0 */ void setFogWipeWidth(f32); + /* 802C93E4 */ void getFogDensity(); + /* 802C9400 */ void startFogSe(); + /* 802C950C */ void initLv3WaterSe(u8, u8, u8, u8); + /* 802C9F58 */ void registLv3WaterSePos(u8, Vec*); + /* 802CA794 */ void startLv3WaterSe(s8); + + u8 field_0x0[780]; +}; + #endif /* Z2ENVSEMGR_H */ diff --git a/include/Z2AudioLib/Z2SceneMgr.h b/include/Z2AudioLib/Z2SceneMgr.h index ec67d7326a..dfb77c2aed 100644 --- a/include/Z2AudioLib/Z2SceneMgr.h +++ b/include/Z2AudioLib/Z2SceneMgr.h @@ -28,6 +28,8 @@ public: void loadSeWave(u32); void loadBgmWave(u32); + bool isSceneExist() { return sceneExist; } + private: /* 0x00 */ long BGM_ID; /* 0x04 */ int sceneNum; diff --git a/include/d/a/d_a_alink.h b/include/d/a/d_a_alink.h index 726d58950c..d2b0c5dc92 100644 --- a/include/d/a/d_a_alink.h +++ b/include/d/a/d_a_alink.h @@ -307,7 +307,7 @@ public: /* 8009D87C */ bool getE3Zhint(); /* 8009D884 */ char* getAlinkArcName(); /* 8009DA60 */ static bool checkStageName(char const*); - /* 8009DA98 */ void tgHitCallback(fopAc_ac_c*, dCcD_GObjInf*, dCcD_GObjInf*); + /* 8009DA98 */ static void tgHitCallback(fopAc_ac_c*, dCcD_GObjInf*, dCcD_GObjInf*); /* 8009DB64 */ void coHitCallback(fopAc_ac_c*, dCcD_GObjInf*); /* 8009DC6C */ void setMatrixWorldAxisRot(f32 (*)[4], s16, s16, s16, int, cXyz const*); /* 8009DD90 */ void jointControll(int); diff --git a/include/d/com/d_com_inf_game.h b/include/d/com/d_com_inf_game.h index 70a50b7c5c..814364f39f 100644 --- a/include/d/com/d_com_inf_game.h +++ b/include/d/com/d_com_inf_game.h @@ -110,6 +110,8 @@ public: void setSelectItem(int idx, u8 itemId) { mSelectItem[idx] = itemId; } + void setSelectEquip(int idx, u8 item_id) { mSelectEquip[idx] = item_id; } + u8 getSelectItem(int idx) { return mSelectItem[idx]; } void setZStatus(u8 status, u8 flag) { @@ -161,6 +163,7 @@ public: inline JKRHeap* getExpHeap2D() { return mExpHeap2D; } inline dEvent_manager_c& getEvtManager() { return mEvtManager; } inline dAttention_c& getAttention() { return mAttention; } + JKRArchive* getMsgDtArchive(int idx) { return mMsgDtArchive[idx]; } public: /* 0x00000 */ dBgS mDBgS; @@ -453,6 +456,9 @@ int dComIfGp_checkEmptySubHeap2D(); int dComIfGp_searchUseSubHeap2D(int); void dComIfGs_setLastWarpMarkItemData(const char*, cXyz, s16, s8, u8, u8); u16 dComIfGs_getMaxLifeGauge(); +void dComIfGs_setWarpMarkFlag(u8); +void dComIfGs_setSelectEquipSword(u8); +void dComIfGs_setSelectEquipShield(u8); inline void dComIfGp_setRStatus(u8 status, u8 flag) { g_dComIfG_gameInfo.play.setRStatus(status, flag); @@ -937,4 +943,36 @@ inline void dComIfGs_addBottleNum(u8 param_0, s16 param_1) { g_dComIfG_gameInfo.info.getPlayer().getItemRecord().addBottleNum(param_0, param_1); } +inline void dComIfGs_resetLastWarpAcceptStage() { + g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().resetWarpAcceptStage(); +} + +inline void dComIfGp_setSelectEquipClothes(u8 i_clothId) { + g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_CLOTHING, i_clothId); +} + +inline void dComIfGp_setSelectEquipSword(u8 i_swordId) { + g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_SWORD, i_swordId); +} + +inline void dComIfGp_setSelectEquipShield(u8 i_shieldId) { + g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_SHIELD, i_shieldId); +} + +inline void dComIfGs_offItemFirstBit(u8 param_0) { + g_dComIfG_gameInfo.info.getPlayer().getGetItem().offFirstBit(param_0); +} + +inline BOOL dComIfGs_isLetterGetFlag(int param_0) { + return g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().isLetterGetFlag(param_0); +} + +inline JKRArchive* dComIfGp_getMsgDtArchive(int idx) { + return g_dComIfG_gameInfo.play.getMsgDtArchive(idx); +} + +inline u8 dComIfGs_getArrowNum() { + return g_dComIfG_gameInfo.info.getPlayer().getItemRecord().getArrowNum(); +} + #endif /* D_COM_D_COM_INF_GAME_H */ diff --git a/include/d/kankyo/d_kankyo.h b/include/d/kankyo/d_kankyo.h index a54f18f9d7..166b9633a9 100644 --- a/include/d/kankyo/d_kankyo.h +++ b/include/d/kankyo/d_kankyo.h @@ -1,10 +1,15 @@ #ifndef D_KANKYO_D_KANKYO_H #define D_KANKYO_D_KANKYO_H +#include "JSystem/J3DGraphAnimator/J3DModelData.h" +#include "JSystem/J3DGraphBase/J3DPacket.h" #include "JSystem/J3DGraphBase/J3DStruct.h" +#include "JSystem/JParticle/JPAParticle.h" +#include "SSystem/SComponent/c_sxyz.h" #include "SSystem/SComponent/c_xyz.h" #include "dolphin/gx/GXTexture.h" #include "dolphin/types.h" +#include "m_Do/m_Do_ext.h" struct LIGHT_INFLUENCE { /* 800CFC7C */ ~LIGHT_INFLUENCE(); @@ -26,6 +31,85 @@ struct WIND_INFLUENCE { /* 0x29 */ u8 field_0x29; }; +struct WIND_INF_ENTITY { + /* 8019F4B8 */ ~WIND_INF_ENTITY(); + /* 8019F4F4 */ WIND_INF_ENTITY(); + + /* 0x00 */ u8 field_0x0[0x10]; + /* 0x10 */ WIND_INFLUENCE field_0x10; +}; // Size: 0x3C + +struct EFLIGHT_PROC { + /* 0x00 */ u8 field_0x0; + /* 0x01 */ u8 field_0x1; + /* 0x04 */ int field_0x4; + /* 0x08 */ LIGHT_INFLUENCE field_0x8; +}; + +struct SND_INFLUENCE { + /* 0x00 */ cXyz field_0x0; + /* 0x0C */ int field_0xc; + /* 0x10 */ int field_0x10; + /* 0x14 */ u32 field_0x14; +}; + +struct DALKMIST_INFLUENCE { + /* 0x00 */ u8 field_0x0[0x10]; +}; + +struct DUNGEON_LIGHT { + /* 8019F478 */ ~DUNGEON_LIGHT(); + /* 8019F4B4 */ DUNGEON_LIGHT(); + + /* 0x00 */ cXyz field_0x0; + /* 0x0C */ u8 field_0xc[0x20]; + /* 0x2C */ // LIGHT_INFLUENCE field_0x2c; this breaks ctor for some reason + u8 field_0x2c[0x20]; +}; // Size: 0x4C + +struct BOSS_LIGHT { + /* 8019F438 */ ~BOSS_LIGHT(); + /* 8019F474 */ BOSS_LIGHT(); + + /* 0x00 */ cXyz field_0x0; + /* 0x0C */ int field_0xc; + /* 0x10 */ int field_0x10; + /* 0x14 */ int field_0x14; + /* 0x18 */ int field_0x18; + /* 0x1C */ int field_0x1c; + /* 0x20 */ int field_0x20; + /* 0x24 */ u8 field_0x24; + /* 0x25 */ u8 field_0x25; + /* 0x26 */ u8 field_0x26; +}; // Size: 0x28 + +struct GB_WIND_INFLUENCE { + /* 0x00 */ cXyz pos; + /* 0x0C */ int field_0xc; + /* 0x10 */ f32 pow; +}; + +struct EF_THUNDER { + /* 0x00 */ u8 field_0x0; + /* 0x01 */ u8 field_0x1; + /* 0x02 */ u8 field_0x2; + /* 0x04 */ int field_0x4; + /* 0x08 */ f32 field_0x8; + /* 0x0C */ f32 field_0xc; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; + /* 0x1C */ f32 field_0x1c; + /* 0x20 */ u8 field_0x20[4]; + /* 0x24 */ LIGHT_INFLUENCE field_0x24; +}; + +struct GB_MAPLE_COL_CHANGE { + /* 8019F400 */ GB_MAPLE_COL_CHANGE(); + + /* 0x00 */ J3DLightObj field_0x0; +}; // Size: 0x74 + class dKy_tevstr_c { public: private: @@ -63,6 +147,516 @@ private: STATIC_ASSERT(sizeof(dKy_tevstr_c) == 0x388); +class dKankyo_sun_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_sun_Packet(); + +private: + /* 0x10 */ cXyz field_0x10[2]; +}; + +class dKankyo_sunlenz_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_sunlenz_Packet(); + +private: + /* 0x10 */ u8 field_0x10[0x14]; + /* 0x24 */ cXyz field_0x24[8]; +}; + +struct RAIN_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ u8 field_0x1c[0x1c]; +}; // Size: 0x38 + +class dKankyo_rain_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_rain_Packet(); + +private: + /* 0x10 */ u8 field_0x10[8]; + /* 0x18 */ RAIN_EFF field_0x18[250]; +}; + +struct SNOW_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ u8 field_0x1c[0x1c]; +}; // Size: 0x38 + +class dKankyo_snow_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_snow_Packet(); + +private: + /* 0x10 */ u8 field_0x10[4]; + /* 0x14 */ SNOW_EFF field_0x14[500]; +}; + +struct STAR_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ u8 field_0x1c[0x18]; +}; // Size: 0x34 + +class dKankyo_star_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_star_Packet(); + +private: + /* 0x10 */ u8 field_0x10[4]; + /* 0x14 */ STAR_EFF field_0x14[1]; +}; + +struct HOUSI_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ cXyz field_0x1c; + /* 0x28 */ u8 field_0x28[0x28]; +}; // Size: 0x50 + +class dKankyo_housi_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_housi_Packet(); + +private: + /* 0x10 */ u8 field_0x10[0x10]; + /* 0x20 */ HOUSI_EFF field_0x18[300]; +}; + +struct CLOUD_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ cXyz field_0x1c; + /* 0x28 */ u8 field_0x28[0x10]; +}; // Size: 0x38 + +class dKankyo_cloud_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_cloud_Packet(); + +private: + /* 0x10 */ u8 field_0x10[8]; + /* 0x18 */ CLOUD_EFF field_0x18[50]; +}; + +struct VRKUMO_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ u8 field_0x1c[0x10]; +}; // Size: 0x2C + +class dKankyo_vrkumo_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_vrkumo_Packet(); + +private: + /* 0x10 */ u8 field_0x10[0x10]; + /* 0x20 */ VRKUMO_EFF field_0x18[100]; +}; + +// might be fake +class dKankyo_shstar_Packet : public J3DPacket {}; + +struct ODOUR_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ u8 field_0x1c[0x14]; +}; // Size: 0x30 + +class dKankyo_odour_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_odour_Packet(); + +private: + /* 0x10 */ u8 field_0x10[4]; + /* 0x14 */ ODOUR_EFF field_0x18[2000]; +}; + +struct MUD_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ cXyz field_0x1c; + /* 0x28 */ u8 field_0x28[0x20]; +}; // Size: 0x48 + +class dKankyo_mud_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_mud_Packet(); + +private: + /* 0x10 */ u8 field_0x10[8]; + /* 0x18 */ MUD_EFF field_0x18[100]; +}; + +struct EVIL_EFF { + /* 0x00 */ u8 field_0x0[4]; + /* 0x04 */ cXyz field_0x04; + /* 0x10 */ cXyz field_0x10; + /* 0x1C */ csXyz field_0x1c; + /* 0x22 */ u8 field_0x22[0x22]; +}; // Size: 0x44 + +class dKankyo_evil_Packet : public J3DPacket { +public: + virtual void draw(); + virtual ~dKankyo_evil_Packet(); + +private: + /* 0x10 */ u8 field_0x10[8]; + /* 0x18 */ EVIL_EFF field_0x18[2000]; +}; + +struct GXFogAdjTable { + u16 field_0x0[10]; +}; + +class fopAc_ac_c; + +class dScnKy_env_light_c { +public: + /* 8019F2E8 */ dScnKy_env_light_c(); + /* 8019F4FC */ void setDaytime(); + /* 8019F788 */ void setSunpos(); + /* 8019FA08 */ f32 getDaytime(); + /* 8019FBCC */ void getDarkDaytime(); + /* 8019FBD4 */ void setLight_palno_get(u8*, u8*, u8*, u8*, u8*, u8*, u8*, u8*, f32*, int*, int*, + f32*, u8*); + /* 801A040C */ void setLight(); + /* 801A133C */ void setLight_bg(dKy_tevstr_c*, _GXColorS10*, _GXColorS10*, f32*, f32*); + /* 801A16C0 */ void setLight_actor(dKy_tevstr_c*, _GXColorS10*, f32*, f32*); + /* 801A1D64 */ void settingTevStruct_colget_actor(cXyz*, dKy_tevstr_c*, _GXColorS10*, + _GXColorS10*, f32*, f32*); + /* 801A1F58 */ void settingTevStruct_colget_player(dKy_tevstr_c*); + /* 801A2128 */ void settingTevStruct_plightcol_plus(cXyz*, dKy_tevstr_c*, _GXColorS10, + _GXColorS10, u8); + /* 801A37C4 */ void settingTevStruct(int, cXyz*, dKy_tevstr_c*); + /* 801A441C */ void setLightTevColorType(J3DModelData*, dKy_tevstr_c*); + /* 801A4DA0 */ void setLightTevColorType_MAJI(J3DModelData*, dKy_tevstr_c*); + /* 801A4E90 */ void CalcTevColor(); + /* 801A4F24 */ void Sndpos(); + /* 801A4F64 */ void Eflight_flush_proc(); + /* 801A516C */ void SetBaseLight(); + /* 801A5288 */ void exeKankyo(); + /* 801A56DC */ void drawKankyo(); + + /* 801ADBBC */ virtual ~dScnKy_env_light_c(); + +public: + /* 0x0000 */ // vtable + /* 0x0004 */ void* field_0x4; + /* 0x0008 */ void* field_0x8; + /* 0x000C */ void* field_0xc; + /* 0x0010 */ void* field_0x10; + /* 0x0014 */ void* field_0x14; + /* 0x0018 */ LIGHT_INFLUENCE field_0x18; + /* 0x0038 */ LIGHT_INFLUENCE field_0x38[30]; + /* 0x03F8 */ LIGHT_INFLUENCE* mPLight[100]; + /* 0x0588 */ LIGHT_INFLUENCE* mEfPLight[5]; + /* 0x059C */ u8 field_0x59c[400]; + /* 0x072C */ int field_0x72c[5]; + /* 0x0740 */ LIGHT_INFLUENCE field_0x740; + /* 0x0760 */ u8 field_0x760[4]; + /* 0x0764 */ LIGHT_INFLUENCE mBGpartsActiveLight[2]; + /* 0x07A4 */ EFLIGHT_PROC field_0x7a4; + /* 0x07CC */ void* stagPlightInfo; // might be part of EFLIGHT_PROC + /* 0x07D0 */ WIND_INFLUENCE* mPntWind[30]; + /* 0x0848 */ WIND_INF_ENTITY field_0x848[5]; + /* 0x0974 */ SND_INFLUENCE mSound; + /* 0x098C */ u8 field_0x98c; + /* 0x0990 */ DALKMIST_INFLUENCE* mDalkmistInf[10]; + /* 0x09B8 */ DUNGEON_LIGHT field_0x9b8[8]; + /* 0x0C18 */ BOSS_LIGHT field_0x0c18[8]; + /* 0x0D58 */ BOSS_LIGHT field_0x0d58[6]; + /* 0x0E48 */ GB_WIND_INFLUENCE field_0xe48; + /* 0x0E5C */ f32 custom_windpower; + /* 0x0E60 */ f32 field_0xe60; + /* 0x0E64 */ u16 field_0xe64; + /* 0x0E66 */ u16 field_0xe66; + /* 0x0E68 */ s16 field_0xe68; + /* 0x0E6A */ s16 field_0xe6a; + /* 0x0E6C */ u8 field_0xe6c; + /* 0x0E6D */ u8 field_0xe6d; + /* 0x0E6E */ u8 field_0xe6e; // E5C - E6E might all be part of GB_WIND_INFLUENCE + /* 0x0E6F */ u8 field_0xe6f; + /* 0x0E70 */ u8 field_0xe70; + /* 0x0E74 */ dKankyo_sun_Packet* field_0xe74; + /* 0x0E78 */ dKankyo_sunlenz_Packet* field_0xe78; + /* 0x0E7C */ u8 field_0xe7c; + /* 0x0E80 */ int mRainCheck; + /* 0x0E84 */ dKankyo_rain_Packet* field_0xe84; + /* 0x0E88 */ u8 field_0xe88; + /* 0x0E8C */ int field_0xe8c; + /* 0x0E90 */ u8 field_0xe90; + /* 0x0E91 */ u8 field_0xe91; + /* 0x0E92 */ u8 field_0xe92; + /* 0x0E94 */ dKankyo_snow_Packet* field_0xe94; + /* 0x0E98 */ u8 field_0xe98; + /* 0x0E9C */ int field_0xe9c; + /* 0x0EA0 */ f32 field_0xea0; + /* 0x0EA4 */ dKankyo_star_Packet* field_0xea4; + /* 0x0EA8 */ u8 field_0xea8; + /* 0x0EA9 */ u8 field_0xea9; + /* 0x0EAC */ int field_0xeac; + /* 0x0EB0 */ dKankyo_housi_Packet* field_0xeb0; + /* 0x0EB4 */ u8 field_0xeb4; + /* 0x0EB5 */ u8 field_0xeb5; + /* 0x0EB8 */ int field_0xeb8; + /* 0x0EBC */ f32 field_0xebc; + /* 0x0EC0 */ dKankyo_cloud_Packet* field_0xec0; + /* 0x0EC4 */ u8 field_0xec4; + /* 0x0EC8 */ int field_0xec8; + /* 0x0ECC */ f32 field_0xecc; + /* 0x0ED0 */ dKankyo_vrkumo_Packet* field_0xed0; + /* 0x0ED4 */ EF_THUNDER field_0xef4; + /* 0x0F18 */ u8 field_0xf18[4]; + /* 0x0F1C */ dKankyo_shstar_Packet* field_0xf1c; + /* 0x0F20 */ u8 field_0xf20; + /* 0x0F21 */ u8 field_0xf21; + /* 0x0F24 */ int field_0xf24; + /* 0x0F28 */ dKankyo_odour_Packet* field_0xf28; + /* 0x0F2C */ u8 field_0xf2c; + /* 0x0F30 */ J3DModel* field_0xf30; + /* 0x0F34 */ f32 field_0xf34; + /* 0x0F38 */ int field_0xf38; + /* 0x0F3C */ u8 field_0xf3c; + /* 0x0F3D */ u8 field_0xf3d; + /* 0x0F40 */ f32 field_0xf40; + /* 0x0F44 */ JPABaseEmitter* field_0xf44; + /* 0x0F48 */ JPABaseEmitter* field_0xf48; + /* 0x0F4C */ JPABaseEmitter* field_0xf4c; + /* 0x0F50 */ GB_MAPLE_COL_CHANGE field_0xf50[2]; + /* 0x1038 */ u8 field_0x1038; + /* 0x103C */ int field_0x103c; + /* 0x1040 */ u8 field_0x1040[4]; + /* 0x1044 */ u8 field_0x1044; + /* 0x1048 */ int field_0x1048; + /* 0x104C */ dKankyo_mud_Packet* field_0x104c; + /* 0x1050 */ u8 field_0x1050; + /* 0x1051 */ u8 field_0x1051; + /* 0x1054 */ int field_0x1054; + /* 0x1058 */ dKankyo_evil_Packet* field_0x1058; + /* 0x105C */ mDoExt_btkAnm* field_0x105c; + /* 0x1060 */ fopAc_ac_c* field_0x1060; + /* 0x1064 */ f32 field_0x1064; + /* 0x1068 */ f32 field_0x1068; + /* 0x106C */ f32 field_0x106c; + /* 0x1070 */ cXyz field_0x1070; + /* 0x107C */ cXyz mPLightNearPos; + /* 0x1088 */ cXyz field_0x1088; + /* 0x1094 */ cXyz field_0x1094; + /* 0x10A0 */ cXyz field_0x10a0; + /* 0x10AC */ GXFogAdjTable field_0x10ac; + /* 0x10C0 */ u16 field_0x10c0; + /* 0x10C2 */ u16 field_0x10c2; + /* 0x10C4 */ u16 field_0x10c4; + /* 0x10C6 */ u16 field_0x10c6; + /* 0x10C8 */ u16 field_0x10c8; + /* 0x10CA */ u16 field_0x10ca; + /* 0x10CC */ u16 field_0x10cc; + /* 0x10CE */ u16 field_0x10ce; + /* 0x10D0 */ u16 field_0x10d0; + /* 0x10D2 */ u16 field_0x10d2; + /* 0x10D4 */ u16 field_0x10d4; + /* 0x10D6 */ u16 field_0x10d6; + /* 0x10D8 */ u16 field_0x10d8; + /* 0x10DA */ u16 field_0x10da; + /* 0x10DC */ u16 field_0x10dc; + /* 0x10DE */ u16 field_0x10de; + /* 0x10E0 */ u16 field_0x10e0; + /* 0x10E2 */ u16 field_0x10e2; + /* 0x10E4 */ u16 field_0x10e4; + /* 0x10E6 */ u16 field_0x10e6; + /* 0x10E8 */ u16 field_0x10e8; + /* 0x10EA */ u16 field_0x10ea; + /* 0x10EC */ u16 field_0x10ec; + /* 0x10EE */ u16 field_0x10ee; + /* 0x10F0 */ s16 field_0x10f0; + /* 0x10F2 */ s16 field_0x10f2; + /* 0x10F4 */ s16 field_0x10f4; + /* 0x10F6 */ s16 field_0x10f6; + /* 0x10F8 */ s16 field_0x10f8; + /* 0x10FA */ s16 field_0x10fa; + /* 0x10FC */ s16 field_0x10fc; + /* 0x10FE */ s16 field_0x10fe; + /* 0x1100 */ _GXColorS10 field_0x1100; + /* 0x1108 */ _GXColorS10 field_0x1108; + /* 0x1110 */ s16 field_0x1110; + /* 0x1112 */ s16 field_0x1112; + /* 0x1114 */ s16 field_0x1114; + /* 0x1116 */ s16 field_0x1116; + /* 0x1118 */ s16 field_0x1118; + /* 0x111A */ s16 field_0x111a; + /* 0x111C */ s16 field_0x111c; + /* 0x111E */ s16 field_0x111e; + /* 0x1120 */ s16 field_0x1120; + /* 0x1122 */ s16 field_0x1122; + /* 0x1124 */ s16 field_0x1124; + /* 0x1126 */ s16 field_0x1126; + /* 0x1128 */ _GXColorS10 field_0x1128; + /* 0x1130 */ u8 field_0x1130[0x28]; + /* 0x1158 */ _GXColorS10 field_0x1158; + /* 0x1160 */ s16 field_0x1160; + /* 0x1162 */ s16 field_0x1162; + /* 0x1164 */ s16 field_0x1164; + /* 0x1166 */ u8 field_0x1166[10]; + /* 0x1170 */ s16 field_0x1170; + /* 0x1172 */ s16 field_0x1172; + /* 0x1174 */ s16 field_0x1174; + /* 0x1176 */ u8 field_0x1176[10]; + /* 0x1180 */ s16 field_0x1180; + /* 0x1182 */ s16 field_0x1182; + /* 0x1184 */ s16 field_0x1184; + /* 0x1186 */ u8 field_0x1186[10]; + /* 0x1190 */ s16 field_0x1190; + /* 0x1192 */ s16 field_0x1192; + /* 0x1194 */ s16 field_0x1194; + /* 0x1196 */ u8 field_0x1196[10]; + /* 0x11A0 */ s16 field_0x11a0; + /* 0x11A2 */ s16 field_0x11a2; + /* 0x11A4 */ s16 field_0x11a4; + /* 0x11A6 */ u8 field_0x11a6[10]; + /* 0x11B0 */ s16 field_0x11b0; + /* 0x11B2 */ s16 field_0x11b2; + /* 0x11B4 */ s16 field_0x11b4; + /* 0x11B6 */ s16 field_0x11b6; + /* 0x11B8 */ s16 field_0x11b8; + /* 0x11BA */ s16 field_0x11ba; + /* 0x11BC */ s16 field_0x11bc; + /* 0x11BE */ u8 field_0x11be[2]; + /* 0x11C0 */ s16 field_0x11c0; + /* 0x11C2 */ s16 field_0x11c2; + /* 0x11C4 */ s16 field_0x11c4; + /* 0x11C8 */ f32 field_0x11c8; + /* 0x11CC */ f32 field_0x11cc; + /* 0x11D0 */ f32 field_0x11d0; + /* 0x11D4 */ f32 field_0x11d4; + /* 0x11D8 */ f32 field_0x11d8; + /* 0x11DC */ f32 field_0x11dc; + /* 0x11E0 */ f32 field_0x11e0; + /* 0x11E4 */ f32 field_0x11e4; + /* 0x11E8 */ f32 field_0x11e8; + /* 0x11EC */ f32 field_0x11ec; + /* 0x11F0 */ f32 field_0x11f0; + /* 0x11F4 */ f32 field_0x11f4; + /* 0x11F8 */ f32 field_0x11f8; + /* 0x11FC */ f32 field_0x11fc; + /* 0x1200 */ f32 field_0x1200; + /* 0x1204 */ f32 field_0x1204; + /* 0x1208 */ f32 field_0x1208; + /* 0x120C */ f32 field_0x120c; + /* 0x1210 */ f32 field_0x1210; + /* 0x1214 */ f32 mAllcolRatio; + /* 0x1218 */ f32 mActcolRatio; + /* 0x121C */ f32 mBgcolRatio; + /* 0x1220 */ f32 mFogcolRatio; + /* 0x1224 */ f32 mVrboxSoracolRatio; + /* 0x1228 */ f32 mVrboxKumocolRatio; + /* 0x122C */ f32 field_0x122c; + /* 0x1230 */ f32 field_0x1230; + /* 0x1234 */ f32 field_0x1234; + /* 0x1238 */ f32 field_0x1238; + /* 0x123C */ f32 field_0x123c; + /* 0x1240 */ f32 field_0x1240; + /* 0x1244 */ f32 mDaytime; + /* 0x1248 */ f32 mNexttime; + /* 0x124C */ f32 field_0x124c; + /* 0x1250 */ f32 mDarkDaytime; + /* 0x1254 */ f32 field_0x1254; + /* 0x1258 */ f32 field_0x1258; + /* 0x125C */ f32 field_0x125c; + /* 0x1260 */ f32 field_0x1260; + /* 0x1264 */ f32 field_0x1264; + /* 0x1268 */ f32 field_0x1268; + /* 0x126C */ f32 field_0x126c; + /* 0x1270 */ f32 field_0x1270; + /* 0x1274 */ f32 field_0x1274; + /* 0x1278 */ f32 field_0x1278; + /* 0x127C */ f32 field_0x127c; + /* 0x1280 */ int field_0x1280; + /* 0x1284 */ u8 field_0x1284[4]; + /* 0x1288 */ int field_0x1288; + /* 0x128C */ u8 field_0x128c[12]; + /* 0x1298 */ int field_0x1298; + /* 0x129C */ int field_0x129c; + /* 0x12A0 */ int field_0x12a0; + /* 0x12A4 */ int field_0x12a4; + /* 0x12A8 */ int field_0x12a8; + /* 0x12AC */ u8 field_0x12ac[4]; + /* 0x12B0 */ int field_0x12b0; + /* 0x12B4 */ int field_0x12b4; + /* 0x12B8 */ u8 field_0x12b8[4]; + /* 0x12BC */ u16 field_0x12bc; + /* 0x12BE */ u16 field_0x12be; + /* 0x12C0 */ u16 field_0x12c0; + /* 0x12C2 */ u8 field_0x12c2; + /* 0x12C3 */ u8 field_0x12c3; + /* 0x12C4 */ u8 field_0x12c4; + /* 0x12C5 */ u8 field_0x12c5; + /* 0x12C6 */ u8 field_0x12c6; + /* 0x12C7 */ u8 field_0x12c7; + /* 0x12C8 */ u8 field_0x12c8; + /* 0x12C9 */ u8 field_0x12c9; + /* 0x12CA */ u8 field_0x12ca; + /* 0x12CB */ u8 field_0x12cb; + /* 0x12CC */ u8 field_0x12cc; + /* 0x12CD */ u8 field_0x12cd; + /* 0x12CE */ u8 field_0x12ce; + /* 0x12CF */ u8 field_0x12cf; + /* 0x12D0 */ u8 field_0x12d0; + /* 0x12D1 */ u8 mItemGetCol_chg; + /* 0x12D2 */ u8 field_0x12d2; + /* 0x12D3 */ u8 field_0x12d3; + /* 0x12D4 */ u8 field_0x12d4; + /* 0x12D5 */ u8 field_0x12d5; + /* 0x12D6 */ u8 field_0x12d6; + /* 0x12D7 */ u8 mShadowMode; + /* 0x12D8 */ u8 mCameraInWater; + /* 0x12DC */ void* field_0x12dc; + /* 0x12E0 */ void* field_0x12e0; + /* 0x12E4 */ void* field_0x12e4; + /* 0x12E8 */ void* field_0x12e8; + /* 0x12EC */ void* field_0x12ec; + /* 0x12F0 */ void* field_0x12f0; + /* 0x12F4 */ void* field_0x12f4; + /* 0x12F8 */ u8 field_0x12f8; + /* 0x12F9 */ u8 field_0x12f9; + /* 0x12FA */ u8 field_0x12fa; + /* 0x12FB */ u8 field_0x12fb; + /* 0x12FC */ u8 field_0x12fc; + /* 0x12FD */ u8 mDarktimeWeek; + /* 0x12FE */ u8 field_0x12fe; + /* 0x1300 */ u16 field_0x1300; + /* 0x1302 */ u16 field_0x1302; + /* 0x1304 */ f32 field_0x1304; + /* 0x1308 */ u8 field_0x1308; + /* 0x1309 */ u8 field_0x1309; + /* 0x130A */ u8 field_0x130a; + /* 0x130B */ u8 field_0x130b; + /* 0x130C */ u8 field_0x130c; +}; // Size: 0x1310 + +STATIC_ASSERT(sizeof(dScnKy_env_light_c) == 4880); + BOOL dKy_darkworld_stage_check(char const*, int); #endif /* D_KANKYO_D_KANKYO_H */ diff --git a/include/d/meter/d_meter2_info.h b/include/d/meter/d_meter2_info.h index c058da0d98..686bd99c69 100644 --- a/include/d/meter/d_meter2_info.h +++ b/include/d/meter/d_meter2_info.h @@ -5,19 +5,19 @@ #include "d/d_resorce.h" #include "d/menu/d_menu_window.h" #include "d/msg/d_msg_flow.h" +#include "d/pane/d_pane_class.h" #include "dolphin/types.h" #include "f_op/f_op_actor.h" -//#include "JSystem/JUtility/JUTFont.h" struct dMsgObject_c { - /* 802384C4 */ void setLetterNameID(u16); + /* 802384C4 */ static void setLetterNameID(u16); /* 802379AC */ void setKillMessageFlag(); /* 8023822C */ void getStatus(); }; class dMeterMap_c { public: - /* 8020D900 */ bool isMapOpenCheck(); + /* 8020D900 */ static bool isMapOpenCheck(); /* 8020D650 */ void isEnableDispMapAndMapDispSizeTypeNo(); /* 8020D874 */ void setDispPosInsideFlg_SE_On(); /* 8020D8BC */ void setDispPosOutsideFlg_SE_On(); @@ -31,18 +31,26 @@ struct J2DTextBox { /* 8021C7F4 */ void getFont() const; }; -struct JUTFont {}; +struct dMenu_LetterData { + u16 mSubject; + u16 mName; + u16 mText; + u16 mEventFlag; +}; struct dMenu_Letter { - static u8 letter_data[512]; + static u16 getLetterSubject(int idx) { return letter_data[idx].mSubject; } + static u16 getLetterName(int idx) { return letter_data[idx].mName; } + static u16 getLetterText(int idx) { return letter_data[idx].mText; } + static u16 getLetterEventFlag(int idx) { return letter_data[idx].mEventFlag; } + + static dMenu_LetterData letter_data[64]; }; struct dItem_data { static void* item_resource[1530]; }; -struct CPaneMgr {}; - class dMw_c; class dMeter2_c { @@ -65,7 +73,7 @@ public: dMeter2Info_c(); virtual ~dMeter2Info_c(); void init(void); - void setFloatingMessage(u16, s16, bool); + int setFloatingMessage(u16, s16, bool); void setFloatingFlow(u16, s16, bool); int isFloatingMessageVisible(void); int decFloatingMessageTimer(void); @@ -115,8 +123,7 @@ public: private: /* 0x04 */ u8 unk4[4]; - /* 0x08 */ u32 unk8; - /* 0x0C */ u32 unk12; + /* 0x08 */ u64 unk8; /* 0x10 */ void* mMsgResource; /* 0x14 */ void* mStageMsgResource; /* 0x18 */ void* mMsgUnitResource; @@ -161,26 +168,27 @@ private: /* 0xBA */ u8 unk186; /* 0xBB */ u8 mMaxCount; /* 0xBC */ u8 mNowCount; - /* 0xBD */ u8 mShopTalkFlag; + /* 0xBD */ bool mShopTalkFlag; /* 0xBE */ u8 unk190; /* 0xBF */ u8 mMapStatus; /* 0xC0 */ u8 mWarpStatus; /* 0xC1 */ u8 mPauseStatus; /* 0xC2 */ u8 mGameOverType; /* 0xC3 */ u8 mInsectSelectType; - /* 0xC4 */ u32 unk196; - /* 0xC8 */ u32 unk200; + /* 0xC4 */ u8 unk196[4]; + /* 0xC8 */ u8 unk200[4]; /* 0xCC */ u8 unk204; - /* 0xCD */ u8 unk205; - /* 0xCE */ u8 unk206; - /* 0xCF */ u8 unk207; - /* 0xD0 */ f64 unk208; - /* 0xD8 */ u8 unk216; - /* 0xD9 */ u8 unk217; - /* 0xDA */ u8 unk218; - /* 0xDB */ u8 unk219; + /* 0xCD */ u8 unk205; // arrow num + /* 0xCE */ u8 unk206; // item 1 + /* 0xCF */ u8 unk207; // item 2 + /* 0xD0 */ u8 unk208[4]; + /* 0xD4 */ u8 unk212[4]; + /* 0xD8 */ u8 unk216; // bomb num + /* 0xD9 */ u8 unk217; // arrow num? + /* 0xDA */ u8 unk218; // item 1? + /* 0xDB */ u8 unk219; // item 2 /* 0xDC */ u8 mRentalBombBag; - /* 0xDD */ u8 mMiniGameItemSetFlag; + /* 0xDD */ u8 mMiniGameItemSetFlag; // 1: rented in game, 3: rented not in game /* 0xDE */ u8 mMiniGameCount; /* 0xDF */ u8 mCollectCursorPosX; /* 0xE0 */ u8 mCollectCursorPosY; @@ -191,7 +199,7 @@ private: /* 0xE7 */ u8 unk231; /* 0xE8 */ u8 mItemExplainWindowStatus; /* 0xE9 */ char mSaveStageName[8]; - /* 0xF1 */ u8 mFloatingMessageWakuVisible; + /* 0xF1 */ bool mFloatingMessageWakuVisible; /* 0xF2 */ u8 mMapDrugFlag; /* 0xF3 */ u8 unk243[5]; }; diff --git a/include/d/meter/d_meter_HIO.h b/include/d/meter/d_meter_HIO.h index a7cbb3418c..b7a0313b69 100644 --- a/include/d/meter/d_meter_HIO.h +++ b/include/d/meter/d_meter_HIO.h @@ -1,6 +1,54 @@ #ifndef D_METER_D_METER_HIO_H #define D_METER_D_METER_HIO_H +#include "JSystem/JUtility.h" +#include "SSystem/SComponent/c_Xyz.h" +#include "SSystem/SComponent/c_sXyz.h" #include "dolphin/types.h" +class dMeter_drawCollectHIO_c { +public: + dMeter_drawCollectHIO_c(); + virtual ~dMeter_drawCollectHIO_c(); + +private: + /* 0x00 */ // vtable + /* 0x04 */ u8 field_0x04[4]; + /* 0x08 */ f32 mItemScaleSmall; + /* 0x0C */ f32 mItemScaleLarge; + /* 0x10 */ f32 mSaveOptionItemScaleSmall; + /* 0x14 */ f32 mSaveOptionItemScaleLarge; + /* 0x18 */ f32 mBlueFuzzPosX; + /* 0x1C */ f32 mBlueFuzzPosY; + /* 0x20 */ f32 mBlueFuzzScale; + /* 0x24 */ f32 mBlueFuzzAlpha; + /* 0x28 */ cXyz mMaskMirrorPos; + /* 0x34 */ f32 mMaskMirrorScale; + /* 0x38 */ f32 mMaskMirrorAnimation; + /* 0x3C */ f32 mHeartVesselPosX; + /* 0x40 */ f32 mHeartVesselPosY; + /* 0x44 */ f32 mHeartVesselScale; + /* 0x48 */ f32 mAButtonPosX; + /* 0x4C */ f32 mAButtonPosY; + /* 0x50 */ f32 mAButtonScale; + /* 0x54 */ f32 mBButtonPosX; + /* 0x58 */ f32 mBButtonPosY; + /* 0x5C */ f32 mBButtonScale; + /* 0x60 */ f32 mAButtonTextPosX; + /* 0x64 */ f32 mAButtonTextPosY; + /* 0x68 */ f32 mAButtonTextScale; + /* 0x6C */ f32 mBButtonTextPosX; + /* 0x70 */ f32 mBButtonTextPosY; + /* 0x74 */ f32 mBButtonTextScale; + /* 0x78 */ JUtility::TColor mBasBlack[2]; // ht_n_bas, h_kaz_n + /* 0x80 */ JUtility::TColor mBasWhite[2]; // same as above + /* 0x88 */ f32 mHeartPiecePosX; + /* 0x8C */ f32 mHeartPiecePosY; + /* 0x90 */ f32 mHeartPieceScale; + /* 0x94 */ csXyz mMaskMirrorAngle; + /* 0x9A */ bool field_0x9a; + /* 0x9B */ bool mColorDebugON; + /* 0x9C */ bool mButtonDebugON; +}; // Size = 0xA0 + #endif /* D_METER_D_METER_HIO_H */ diff --git a/include/d/msg/d_msg_flow.h b/include/d/msg/d_msg_flow.h index 30e1ae2625..f387463e3e 100644 --- a/include/d/msg/d_msg_flow.h +++ b/include/d/msg/d_msg_flow.h @@ -4,9 +4,15 @@ #include "dolphin/types.h" #include "f_op/f_op_actor.h" -struct mesg_flow_node_branch {}; +struct mesg_flow_node_branch { + /* 0x00 */ int field_0x0; + /* 0x04 */ u16 param; +}; -struct mesg_flow_node_event {}; +struct mesg_flow_node_event { + /* 0x00 */ int field_0x0; + /* 0x04 */ u8 param; +}; struct mesg_flow_node {}; @@ -34,9 +40,9 @@ public: /* 8024AD54 */ void branchNodeProc(fopAc_ac_c*, fopAc_ac_c**); /* 8024ADEC */ void eventNodeProc(fopAc_ac_c*, fopAc_ac_c**); /* 8024AFF8 */ void nodeProc(fopAc_ac_c*, fopAc_ac_c**); - /* 8024B0F0 */ void getParam(u16*, u16*, u8*); + /* 8024B0F0 */ int getParam(u16*, u16*, u8*); /* 8024B108 */ void getParam(u8*, u8*); - /* 8024B130 */ void getParam(u8*); + /* 8024B130 */ int getParam(u8*); /* 8024B138 */ void query001(mesg_flow_node_branch*, fopAc_ac_c*, int); /* 8024B180 */ void query002(mesg_flow_node_branch*, fopAc_ac_c*, int); /* 8024B208 */ void query003(mesg_flow_node_branch*, fopAc_ac_c*, int); @@ -90,11 +96,11 @@ public: /* 8024C340 */ void query051(mesg_flow_node_branch*, fopAc_ac_c*, int); /* 8024C3A0 */ void query052(mesg_flow_node_branch*, fopAc_ac_c*, int); /* 8024C3D4 */ void query053(mesg_flow_node_branch*, fopAc_ac_c*, int); - /* 8024C3FC */ void event000(mesg_flow_node_event*, fopAc_ac_c*); - /* 8024C488 */ void event001(mesg_flow_node_event*, fopAc_ac_c*); - /* 8024C514 */ void event002(mesg_flow_node_event*, fopAc_ac_c*); - /* 8024C550 */ void event003(mesg_flow_node_event*, fopAc_ac_c*); - /* 8024C590 */ void event004(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C3FC */ int event000(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C488 */ int event001(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C514 */ int event002(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C550 */ int event003(mesg_flow_node_event*, fopAc_ac_c*); + /* 8024C590 */ int event004(mesg_flow_node_event*, fopAc_ac_c*); /* 8024C5F0 */ void event005(mesg_flow_node_event*, fopAc_ac_c*); /* 8024C654 */ void event006(mesg_flow_node_event*, fopAc_ac_c*); /* 8024C694 */ void event007(mesg_flow_node_event*, fopAc_ac_c*); diff --git a/include/d/pane/d_pane_class.h b/include/d/pane/d_pane_class.h index 3a02e0bed0..8a0cc7c06e 100644 --- a/include/d/pane/d_pane_class.h +++ b/include/d/pane/d_pane_class.h @@ -1,6 +1,50 @@ #ifndef D_PANE_D_PANE_CLASS_H #define D_PANE_D_PANE_CLASS_H +#include "d/pane/d_pane_class_alpha.h" #include "dolphin/types.h" +class CPaneMgr : public CPaneMgrAlpha { +public: + /* 80253A18 */ virtual ~CPaneMgr(); + /* 80253AB4 */ virtual void setAlpha(u8); + + /* 80253984 */ CPaneMgr(J2DScreen*, u64, u8, JKRExpHeap*); + /* 80253930 */ CPaneMgr(); + /* 80253B2C */ void reinit(); + /* 80253C08 */ void initiate(J2DPane*, JKRExpHeap*); + /* 80254018 */ void childPaneGetSize(J2DPane*); + /* 80254134 */ void childPaneSetSize(J2DPane*, f32, f32); + /* 802542E8 */ void getGlobalPosX(); + /* 80254364 */ void getGlobalPosY(); + /* 80254458 */ void setBlackWhite(JUtility::TColor, JUtility::TColor); + /* 802545B0 */ void paneTrans(f32, f32); + /* 80254638 */ void paneScale(f32, f32); + /* 802547CC */ void scaleAnime(s16, f32, f32, u8); + /* 802548BC */ void colorAnime(s16, JUtility::TColor, JUtility::TColor, JUtility::TColor, + JUtility::TColor, u8); + /* 80254C90 */ void getGlobalVtx(J2DPane*, f32 (*)[3][4], u8, bool, s16); + /* 80254EBC */ void getGlobalVtxCenter(J2DPane*, bool, s16); + /* 80254FB8 */ void getBounds(J2DPane*); + +private: + /* 0x1C */ void* field_0x1c; + /* 0x20 */ void* field_0x20; + /* 0x24 */ JGeometry::TVec2<f32> mInitPos; + /* 0x2C */ JGeometry::TVec2<f32> mGlobalPos; + /* 0x34 */ JGeometry::TVec2<f32> mInitSize; + /* 0x3C */ JGeometry::TVec2<f32> mInitScale; + /* 0x44 */ JGeometry::TVec2<f32> field_0x44; + /* 0x4C */ f32 field_0x4c; + /* 0x50 */ JGeometry::TVec2<f32> field_0x50; + /* 0x58 */ JUtility::TColor mInitWhite; + /* 0x5C */ JUtility::TColor mInitBlack; + /* 0x60 */ s16 field_0x60; + /* 0x62 */ s16 field_0x62; + /* 0x64 */ s16 mScaleAnime; + /* 0x66 */ s16 field_0x66; + /* 0x68 */ s16 field_0x68; + /* 0x6A */ s16 mColorAnime; +}; + #endif /* D_PANE_D_PANE_CLASS_H */ diff --git a/include/d/pane/d_pane_class_alpha.h b/include/d/pane/d_pane_class_alpha.h index ae3f3d7ca5..6fcadd7b2b 100644 --- a/include/d/pane/d_pane_class_alpha.h +++ b/include/d/pane/d_pane_class_alpha.h @@ -1,6 +1,49 @@ #ifndef D_PANE_D_PANE_CLASS_ALPHA_H #define D_PANE_D_PANE_CLASS_ALPHA_H +#include "JSystem/J2DGraph/J2DScreen.h" +#include "JSystem/JKernel/JKRExpHeap.h" #include "dolphin/types.h" +struct CPaneMgrAlphaMorf { + /* 80255C68 */ CPaneMgrAlphaMorf(J2DScreen*, u64, u8, JKRExpHeap*); + /* 80255CAC */ ~CPaneMgrAlphaMorf(); + /* 80255D48 */ void initiateAlphaMorf(); + /* 80255DD0 */ void setBackupAlpha(); + /* 80255E28 */ void setAlphaMorfRate(f32); + /* 80255E98 */ void childPaneBackupAlpha(J2DPane*); + /* 80255F28 */ void childPaneSetAlphaMorf(J2DPane*, f32); +}; + +class CPaneMgrAlpha { +public: + /* 8025546C */ virtual ~CPaneMgrAlpha(); + /* 80255758 */ virtual void setAlpha(u8); + + /* 802553EC */ CPaneMgrAlpha(); + /* 802553FC */ CPaneMgrAlpha(J2DScreen*, u64, u8, JKRExpHeap*); + /* 802554E0 */ void initiateAlpha(J2DPane*, JKRExpHeap*); + /* 802555C8 */ void show(); + /* 80255608 */ void hide(); + /* 8025564C */ void isVisible(); + /* 80255658 */ void rateCalc(s16, s16, u8); + /* 802557D0 */ void setAlphaRate(f32); + /* 80255828 */ void getAlphaRate(); + /* 80255878 */ void alphaAnime(s16, u8, u8, u8); + /* 80255964 */ void alphaAnimeLoop(s16, u8, u8, u8); + /* 80255A60 */ void childPaneCount(J2DPane*); + /* 80255ACC */ void childPaneGetAlpha(J2DPane*); + /* 80255B5C */ void childPaneSetAlpha(J2DPane*, u8); + +private: + /* 0x04 */ J2DPane* mPanePtr; + /* 0x08 */ JKRHeap* heap; + /* 0x0C */ void* field_0x0c; + /* 0x10 */ int field_0x10; + /* 0x14 */ s16 mChildPaneCount; + /* 0x16 */ s16 mAlphaTimer; + /* 0x18 */ u8 mInitAlpha; + /* 0x19 */ u8 mFlags; +}; + #endif /* D_PANE_D_PANE_CLASS_ALPHA_H */ diff --git a/include/d/save/d_save.h b/include/d/save/d_save.h index e6cfc1e681..cf0cdeef5d 100644 --- a/include/d/save/d_save.h +++ b/include/d/save/d_save.h @@ -22,310 +22,335 @@ #define ITEM_ZONE_MAX 0x20 #define ITEM_ONE_ZONE_MAX 0x10 -enum Wallets { WALLET, BIG_WALLET, GIANT_WALLET }; +enum Wallets { + /* 0x0 */ WALLET, + /* 0x1 */ BIG_WALLET, + /* 0x2 */ GIANT_WALLET +}; enum ItemSlots { - SLOT_0, - SLOT_1, - SLOT_2, - SLOT_3, - SLOT_4, - SLOT_5, - SLOT_6, - SLOT_7, - SLOT_8, - SLOT_9, - SLOT_10, - SLOT_11, - SLOT_12, - SLOT_13, - SLOT_14, - SLOT_15, - SLOT_16, - SLOT_17, - SLOT_18, - SLOT_19, - SLOT_20, - SLOT_21, - SLOT_22, - SLOT_23 + /* 0x00 */ SLOT_0, + /* 0x01 */ SLOT_1, + /* 0x02 */ SLOT_2, + /* 0x03 */ SLOT_3, + /* 0x04 */ SLOT_4, + /* 0x05 */ SLOT_5, + /* 0x06 */ SLOT_6, + /* 0x07 */ SLOT_7, + /* 0x08 */ SLOT_8, + /* 0x09 */ SLOT_9, + /* 0x0A */ SLOT_10, + /* 0x0B */ SLOT_11, + /* 0x0C */ SLOT_12, + /* 0x0D */ SLOT_13, + /* 0x0E */ SLOT_14, + /* 0x0F */ SLOT_15, + /* 0x10 */ SLOT_16, + /* 0x11 */ SLOT_17, + /* 0x12 */ SLOT_18, + /* 0x13 */ SLOT_19, + /* 0x14 */ SLOT_20, + /* 0x15 */ SLOT_21, + /* 0x16 */ SLOT_22, + /* 0x17 */ SLOT_23 }; enum ItemTable { - HEART, - GREEN_RUPEE, - BLUE_RUPEE, - YELLOW_RUPEE, - RED_RUPEE, - PURPLE_RUPEE, - ORANGE_RUPEE, - SILVER_RUPEE, - S_MAGIC, - L_MAGIC, - BOMB_5, - BOMB_10, - BOMB_20, - BOMB_30, - ARROW_10, - ARROW_20, - ARROW_30, - ARROW_1, - PACHINKO_SHOT, - noentry1, - noentry2, - noentry3, - WATER_BOMB_5, - WATER_BOMB_10, - WATER_BOMB_20, - WATER_BOMB_30, - BOMB_INSECT_5, - BOMB_INSECT_10, - BOMB_INSECT_20, - BOMB_INSECT_30, - RECOVERY_FAILY, - TRIPLE_HEART, - SMALL_KEY, - KAKERA_HEART, - UTAWA_HEART, - MAP, - COMPUS, - DUNGEON_EXIT, - BOSS_KEY, - DUNGEON_BACK, - SWORD, - MASTER_SWORD, - WOOD_SHIELD, - SHIELD, - HYLIA_SHIELD, - TKS_LETTER, - WEARS_CASUAL, - WEAR_KOKIRI, - ARMOR, - WEAR_ZORA, - MAGIC_LV1, - DUNGEON_EXIT_2, - WALLET_LV1, - WALLET_LV2, - WALLET_LV3, - noentry4, - noentry5, - noentry6, - noentry7, - noentry8, - noentry9, - ZORAS_JEWEL, - HAWK_EYE, - WOOD_STICK, - BOOMERANG, - SPINNER, - IRONBALL, - BOW, - HOOKSHOT, - HVY_BOOTS, - COPY_ROD, - W_HOOKSHOT, - KANTERA, - LIGHT_SWORD, - FISHING_ROD_1, - PACHINKO, - COPY_ROD_2, - noentry10, - noentry11, - BOMB_BAG_LV2, - BOMB_BAG_LV1, - BOMB_IN_BAG, - noentry12, - LIGHT_ARROW, - ARROW_LV1, - ARROW_LV2, - ARROW_LV3, - noentry13, - LURE_ROD, - BOMB_ARROW, - HAWK_ARROW, - BEE_ROD, - JEWEL_ROD, - WORM_ROD, - JEWEL_BEE_ROD, - JEWEL_WORM_ROD, - EMPTY_BOTTLE, - RED_BOTTLE, - GREEN_BOTTLE, - BLUE_BOTTLE, - MILK_BOTTLE, - HALF_MILK_BOTTLE, - OIL_BOTTLE, - WATER_BOTTLE, - OIL_BOTTLE_2, - RED_BOTTLE_2, - UGLY_SOUP, - HOT_SPRING, - FAIRY, - HOT_SPRING_2, - OIL2, - OIL, - NORMAL_BOMB, - WATER_BOMB, - POKE_BOMB, - FAIRY_DROP, - WORM, - DROP_BOTTLE, - BEE_CHILD, - CHUCHU_RARE, - CHUCHU_RED, - CHUCHU_BLUE, - CHUCHU_GREEN, - CHUCHU_YELLOW, - CHUCHU_PURPLE, - LV1_SOUP, - LV2_SOUP, - LV3_SOUP, - LETTER, - BILL, - WOOD_STATUE, - IRIAS_PENDANT, - HORSE_FLUTE, - noentry14, - noentry15, - noentry16, - noentry17, - noentry18, - noentry19, - noentry20, - noentry21, - noentry22, - noentry23, - noentry24, - RAFRELS_MEMO, - ASHS_SCRIBBLING, - noentry25, - noentry26, - noentry27, - noentry28, - noentry29, - noentry30, - noentry31, - noentry32, - noentry33, - noentry34, - CHUCHU_YELLOW2, - OIL_BOTTLE3, - SHOP_BEE_CHILD, - CHUCHU_BLACK, - LIGHT_DROP, - DROP_CONTAINER, - DROP_CONTAINER02, - DROP_CONTAINER03, - FILLED_CONTAINER, - MIRROR_PIECE_2, - MIRROR_PIECE_3, - MIRROR_PIECE_4, - noentry35, - noentry36, - noentry37, - noentry38, - noentry39, - noentry40, - noentry41, - noentry42, - SMELL_YELIA_POUCH, - SMELL_PUMPKIN, - SMELL_POH, - SMELL_FISH, - SMELL_CHILDREN, - SMELL_MEDICINE, - noentry43, - noentry44, - noentry45, - noentry46, - noentry47, - noentry48, - noentry49, - noentry50, - noentry51, - noentry52, - M_BEETLE, - F_BEETLE, - M_BUTTERFLY, - F_BUTTERFLY, - M_STAG_BEETLE, - F_STAG_BEETLE, - M_GRASSHOPPER, - F_GRASSHOPPER, - M_NANAFUSHI, - F_NANAFUSHI, - M_DANGOMUSHI, - F_DANGOMUSHI, - M_MANTIS, - F_MANTIS, - M_LADYBUG, - F_LADYBUG, - M_SNAIL, - F_SNAIL, - M_DRAGONFLY, - F_DRAGONFLY, - M_ANT, - F_ANT, - M_MAYFLY, - F_MAYFLY, - noentry53, - noentry54, - noentry55, - noentry56, - noentry57, - noentry58, - noentry59, - noentry60, - POU_SPIRIT, - noentry61, - noentry62, - noentry63, - noentry64, - noentry65, - noentry66, - noentry67, - noentry68, - ANCIENT_DOCUMENT, - AIR_LETTER, - ANCIENT_DOCUMENT2, - LV7_DUNGEON_EXIT, - LINKS_SAVINGS, - SMALL_KEY2, - POU_FIRE1, - POU_FIRE2, - POU_FIRE3, - POU_FIRE4, - BOSSRIDER_KEY, - TOMATO_PUREE, - TASTE, - LV5_BOSS_KEY, - SURFBOARD, - KANTERA2, - L2_KEY_PIECES1, - L2_KEY_PIECES2, - L2_KEY_PIECES3, - KEY_OF_CARAVAN, - LV2_BOSS_KEY, - KEY_OF_FILONE, - NO_ITEM + /* 0x00 */ HEART, + /* 0x01 */ GREEN_RUPEE, + /* 0x02 */ BLUE_RUPEE, + /* 0x03 */ YELLOW_RUPEE, + /* 0x04 */ RED_RUPEE, + /* 0x05 */ PURPLE_RUPEE, + /* 0x06 */ ORANGE_RUPEE, + /* 0x07 */ SILVER_RUPEE, + /* 0x08 */ S_MAGIC, + /* 0x09 */ L_MAGIC, + /* 0x0A */ BOMB_5, + /* 0x0B */ BOMB_10, + /* 0x0C */ BOMB_20, + /* 0x0D */ BOMB_30, + /* 0x0E */ ARROW_10, + /* 0x0F */ ARROW_20, + /* 0x10 */ ARROW_30, + /* 0x11 */ ARROW_1, + /* 0x12 */ PACHINKO_SHOT, + /* 0x13 */ noentry1, + /* 0x14 */ noentry2, + /* 0x15 */ noentry3, + /* 0x16 */ WATER_BOMB_5, + /* 0x17 */ WATER_BOMB_10, + /* 0x18 */ WATER_BOMB_20, + /* 0x19 */ WATER_BOMB_30, + /* 0x1A */ BOMB_INSECT_5, + /* 0x1B */ BOMB_INSECT_10, + /* 0x1C */ BOMB_INSECT_20, + /* 0x1D */ BOMB_INSECT_30, + /* 0x1E */ RECOVERY_FAILY, + /* 0x1F */ TRIPLE_HEART, + /* 0x20 */ SMALL_KEY, + /* 0x21 */ KAKERA_HEART, + /* 0x22 */ UTAWA_HEART, + /* 0x23 */ MAP, + /* 0x24 */ COMPUS, + /* 0x25 */ DUNGEON_EXIT, + /* 0x26 */ BOSS_KEY, + /* 0x27 */ DUNGEON_BACK, + /* 0x28 */ SWORD, + /* 0x29 */ MASTER_SWORD, + /* 0x2A */ WOOD_SHIELD, + /* 0x2B */ SHIELD, + /* 0x2C */ HYLIA_SHIELD, + /* 0x2D */ TKS_LETTER, + /* 0x2E */ WEARS_CASUAL, + /* 0x2F */ WEAR_KOKIRI, + /* 0x30 */ ARMOR, + /* 0x31 */ WEAR_ZORA, + /* 0x32 */ MAGIC_LV1, + /* 0x33 */ DUNGEON_EXIT_2, + /* 0x34 */ WALLET_LV1, + /* 0x35 */ WALLET_LV2, + /* 0x36 */ WALLET_LV3, + /* 0x37 */ noentry4, + /* 0x38 */ noentry5, + /* 0x39 */ noentry6, + /* 0x3A */ noentry7, + /* 0x3B */ noentry8, + /* 0x3C */ noentry9, + /* 0x3D */ ZORAS_JEWEL, + /* 0x3E */ HAWK_EYE, + /* 0x3F */ WOOD_STICK, + /* 0x40 */ BOOMERANG, + /* 0x41 */ SPINNER, + /* 0x42 */ IRONBALL, + /* 0x43 */ BOW, + /* 0x44 */ HOOKSHOT, + /* 0x45 */ HVY_BOOTS, + /* 0x46 */ COPY_ROD, + /* 0x47 */ W_HOOKSHOT, + /* 0x48 */ KANTERA, + /* 0x49 */ LIGHT_SWORD, + /* 0x4A */ FISHING_ROD_1, + /* 0x4B */ PACHINKO, + /* 0x4C */ COPY_ROD_2, + /* 0x4D */ noentry10, + /* 0x4E */ noentry11, + /* 0x4F */ BOMB_BAG_LV2, + /* 0x50 */ BOMB_BAG_LV1, + /* 0x51 */ BOMB_IN_BAG, + /* 0x52 */ noentry12, + /* 0x53 */ LIGHT_ARROW, + /* 0x54 */ ARROW_LV1, + /* 0x55 */ ARROW_LV2, + /* 0x56 */ ARROW_LV3, + /* 0x57 */ noentry13, + /* 0x58 */ LURE_ROD, + /* 0x59 */ BOMB_ARROW, + /* 0x5A */ HAWK_ARROW, + /* 0x5B */ BEE_ROD, + /* 0x5C */ JEWEL_ROD, + /* 0x5D */ WORM_ROD, + /* 0x5E */ JEWEL_BEE_ROD, + /* 0x5F */ JEWEL_WORM_ROD, + /* 0x60 */ EMPTY_BOTTLE, + /* 0x61 */ RED_BOTTLE, + /* 0x62 */ GREEN_BOTTLE, + /* 0x63 */ BLUE_BOTTLE, + /* 0x64 */ MILK_BOTTLE, + /* 0x65 */ HALF_MILK_BOTTLE, + /* 0x66 */ OIL_BOTTLE, + /* 0x67 */ WATER_BOTTLE, + /* 0x68 */ OIL_BOTTLE_2, + /* 0x69 */ RED_BOTTLE_2, + /* 0x6A */ UGLY_SOUP, + /* 0x6B */ HOT_SPRING, + /* 0x6C */ FAIRY, + /* 0x6D */ HOT_SPRING_2, + /* 0x6E */ OIL2, + /* 0x6F */ OIL, + /* 0x70 */ NORMAL_BOMB, + /* 0x71 */ WATER_BOMB, + /* 0x72 */ POKE_BOMB, + /* 0x73 */ FAIRY_DROP, + /* 0x74 */ WORM, + /* 0x75 */ DROP_BOTTLE, + /* 0x76 */ BEE_CHILD, + /* 0x77 */ CHUCHU_RARE, + /* 0x78 */ CHUCHU_RED, + /* 0x79 */ CHUCHU_BLUE, + /* 0x7A */ CHUCHU_GREEN, + /* 0x7B */ CHUCHU_YELLOW, + /* 0x7C */ CHUCHU_PURPLE, + /* 0x7D */ LV1_SOUP, + /* 0x7E */ LV2_SOUP, + /* 0x7F */ LV3_SOUP, + /* 0x80 */ LETTER, + /* 0x81 */ BILL, + /* 0x82 */ WOOD_STATUE, + /* 0x83 */ IRIAS_PENDANT, + /* 0x84 */ HORSE_FLUTE, + /* 0x85 */ noentry14, + /* 0x86 */ noentry15, + /* 0x87 */ noentry16, + /* 0x88 */ noentry17, + /* 0x89 */ noentry18, + /* 0x8A */ noentry19, + /* 0x8B */ noentry20, + /* 0x8C */ noentry21, + /* 0x8D */ noentry22, + /* 0x8E */ noentry23, + /* 0x8F */ noentry24, + /* 0x90 */ RAFRELS_MEMO, + /* 0x91 */ ASHS_SCRIBBLING, + /* 0x92 */ noentry25, + /* 0x93 */ noentry26, + /* 0x94 */ noentry27, + /* 0x95 */ noentry28, + /* 0x96 */ noentry29, + /* 0x97 */ noentry30, + /* 0x98 */ noentry31, + /* 0x99 */ noentry32, + /* 0x9A */ noentry33, + /* 0x9B */ noentry34, + /* 0x9C */ CHUCHU_YELLOW2, + /* 0x9D */ OIL_BOTTLE3, + /* 0x9E */ SHOP_BEE_CHILD, + /* 0x9F */ CHUCHU_BLACK, + /* 0xA0 */ LIGHT_DROP, + /* 0xA1 */ DROP_CONTAINER, + /* 0xA2 */ DROP_CONTAINER02, + /* 0xA3 */ DROP_CONTAINER03, + /* 0xA4 */ FILLED_CONTAINER, + /* 0xA5 */ MIRROR_PIECE_2, + /* 0xA6 */ MIRROR_PIECE_3, + /* 0xA7 */ MIRROR_PIECE_4, + /* 0xA8 */ noentry35, + /* 0xA9 */ noentry36, + /* 0xAA */ noentry37, + /* 0xAB */ noentry38, + /* 0xAC */ noentry39, + /* 0xAD */ noentry40, + /* 0xAE */ noentry41, + /* 0xAF */ noentry42, + /* 0xB0 */ SMELL_YELIA_POUCH, + /* 0xB1 */ SMELL_PUMPKIN, + /* 0xB2 */ SMELL_POH, + /* 0xB3 */ SMELL_FISH, + /* 0xB4 */ SMELL_CHILDREN, + /* 0xB5 */ SMELL_MEDICINE, + /* 0xB6 */ noentry43, + /* 0xB7 */ noentry44, + /* 0xB8 */ noentry45, + /* 0xB9 */ noentry46, + /* 0xBA */ noentry47, + /* 0xBB */ noentry48, + /* 0xBC */ noentry49, + /* 0xBD */ noentry50, + /* 0xBE */ noentry51, + /* 0xBF */ noentry52, + /* 0xC0 */ M_BEETLE, + /* 0xC1 */ F_BEETLE, + /* 0xC2 */ M_BUTTERFLY, + /* 0xC3 */ F_BUTTERFLY, + /* 0xC4 */ M_STAG_BEETLE, + /* 0xC5 */ F_STAG_BEETLE, + /* 0xC6 */ M_GRASSHOPPER, + /* 0xC7 */ F_GRASSHOPPER, + /* 0xC8 */ M_NANAFUSHI, + /* 0xC9 */ F_NANAFUSHI, + /* 0xCA */ M_DANGOMUSHI, + /* 0xCB */ F_DANGOMUSHI, + /* 0xCC */ M_MANTIS, + /* 0xCD */ F_MANTIS, + /* 0xCE */ M_LADYBUG, + /* 0xCF */ F_LADYBUG, + /* 0xD0 */ M_SNAIL, + /* 0xD1 */ F_SNAIL, + /* 0xD2 */ M_DRAGONFLY, + /* 0xD3 */ F_DRAGONFLY, + /* 0xD4 */ M_ANT, + /* 0xD5 */ F_ANT, + /* 0xD6 */ M_MAYFLY, + /* 0xD7 */ F_MAYFLY, + /* 0xD8 */ noentry53, + /* 0xD9 */ noentry54, + /* 0xDA */ noentry55, + /* 0xDB */ noentry56, + /* 0xDC */ noentry57, + /* 0xDD */ noentry58, + /* 0xDE */ noentry59, + /* 0xDF */ noentry60, + /* 0xE0 */ POU_SPIRIT, + /* 0xE1 */ noentry61, + /* 0xE2 */ noentry62, + /* 0xE3 */ noentry63, + /* 0xE4 */ noentry64, + /* 0xE5 */ noentry65, + /* 0xE6 */ noentry66, + /* 0xE7 */ noentry67, + /* 0xE8 */ noentry68, + /* 0xE9 */ ANCIENT_DOCUMENT, + /* 0xEA */ AIR_LETTER, + /* 0xEB */ ANCIENT_DOCUMENT2, + /* 0xEC */ LV7_DUNGEON_EXIT, + /* 0xED */ LINKS_SAVINGS, + /* 0xEE */ SMALL_KEY2, + /* 0xEF */ POU_FIRE1, + /* 0xF0 */ POU_FIRE2, + /* 0xF1 */ POU_FIRE3, + /* 0xF2 */ POU_FIRE4, + /* 0xF3 */ BOSSRIDER_KEY, + /* 0xF4 */ TOMATO_PUREE, + /* 0xF5 */ TASTE, + /* 0xF6 */ LV5_BOSS_KEY, + /* 0xF7 */ SURFBOARD, + /* 0xF8 */ KANTERA2, + /* 0xF9 */ L2_KEY_PIECES1, + /* 0xFA */ L2_KEY_PIECES2, + /* 0xFB */ L2_KEY_PIECES3, + /* 0xFC */ KEY_OF_CARAVAN, + /* 0xFD */ LV2_BOSS_KEY, + /* 0xFE */ KEY_OF_FILONE, + /* 0xFF */ NO_ITEM }; -enum CollectItem { COLLECT_CLOTHING, COLLECT_SWORD, COLLECT_SHIELD, COLLECT_SMELL, B_BUTTON_ITEM }; +enum CollectItem { + /* 0x0 */ COLLECT_CLOTHING, + /* 0x1 */ COLLECT_SWORD, + /* 0x2 */ COLLECT_SHIELD, + /* 0x3 */ COLLECT_SMELL, + /* 0x4 */ B_BUTTON_ITEM +}; enum Swords { - COLLECT_ORDON_SWORD, - COLLECT_MASTER_SWORD, - COLLECT_WOODEN_SWORD, - COLLECT_LIGHT_SWORD + /* 0x0 */ COLLECT_ORDON_SWORD, + /* 0x1 */ COLLECT_MASTER_SWORD, + /* 0x2 */ COLLECT_WOODEN_SWORD, + /* 0x3 */ COLLECT_LIGHT_SWORD }; -enum Shields { COLLECT_WOODEN_SHIELD, COLLECT_ORDON_SHIELD, COLLECT_HYLIAN_SHIELD }; +enum Shields { + /* 0x0 */ COLLECT_WOODEN_SHIELD, + /* 0x1 */ COLLECT_ORDON_SHIELD, + /* 0x2 */ COLLECT_HYLIAN_SHIELD +}; -enum Armors { KOKIRI_CLOTHES_FLAG }; +enum Clothes { + /* 0x0 */ KOKIRI_CLOTHES_FLAG +}; -enum LightDropStages { FARON_VESSEL, ELDIN_VESSEL, LANAYRU_VESSEL }; +enum LightDropStages { + /* 0x0 */ FARON_VESSEL, + /* 0x1 */ ELDIN_VESSEL, + /* 0x2 */ LANAYRU_VESSEL +}; -enum ItemMax { ARROW_MAX, NORMAL_BOMB_MAX, WATER_BOMB_MAX, POKE_BOMB_MAX = 6 }; +enum ItemMax { + /* 0x0 */ ARROW_MAX, + /* 0x1 */ NORMAL_BOMB_MAX, + /* 0x2 */ WATER_BOMB_MAX, + /* 0x6 */ POKE_BOMB_MAX = 6 +}; class dSv_player_status_a_c { public: @@ -451,6 +476,7 @@ public: s16 getAngleY() { return mAngleY; } s8 getRoomNo() { return mRoomNo; } char getWarpAcceptStage() { return mWarpAcceptStage; } + void resetWarpAcceptStage() { mWarpAcceptStage = -1; } private: /* 0x00 */ cXyz mPos; @@ -514,6 +540,7 @@ public: u8 addBottleNum(u8, s16); u8 getBottleNum(u8) const; + u8 getArrowNum() const { return mArrowNum; } void setArrowNum(u8 amount) { mArrowNum = amount; } u8 getPachinkoNum() const { return mPachinkoNum; } void setPachinkoNum(u8 num) { mPachinkoNum = num; } @@ -680,6 +707,7 @@ public: dSv_light_drop_c& getLightDrop() { return mLightDrop; } dSv_player_get_item_c& getGetItem() { return mGetItem; } dSv_player_config_c& getConfig() { return mConfig; } + dSv_letter_info_c& getLetterInfo() { return mLetterInfo; } private: /* 0x000 */ dSv_player_status_a_c mPlayerStatusA; @@ -704,14 +732,14 @@ private: class dSv_memBit_c { public: enum { - MAP, - COMPASS, - BOSS_KEY, - STAGE_BOSS_ENEMY, - STAGE_LIFE, - STAGE_BOSS_DEMO, - OOCCOO_NOTE, - STAGE_BOSS_ENEMY_2 + /* 0x0 */ MAP, + /* 0x1 */ COMPASS, + /* 0x2 */ BOSS_KEY, + /* 0x3 */ STAGE_BOSS_ENEMY, + /* 0x4 */ STAGE_LIFE, + /* 0x5 */ STAGE_BOSS_DEMO, + /* 0x6 */ OOCCOO_NOTE, + /* 0x7 */ STAGE_BOSS_ENEMY_2 }; void init(); diff --git a/include/dolphin/gx/GX.h b/include/dolphin/gx/GX.h index ad2d4d99ed..c890624114 100644 --- a/include/dolphin/gx/GX.h +++ b/include/dolphin/gx/GX.h @@ -28,6 +28,262 @@ typedef enum _GXTexMapID { GX_MAX_TEXMAP = 8 } GXTexMapID; +typedef enum _GXTevStageID { + /* 0x0 */ GX_TEVSTAGE0, + /* 0x1 */ GX_TEVSTAGE1, + /* 0x2 */ GX_TEVSTAGE2, + /* 0x3 */ GX_TEVSTAGE3, + /* 0x4 */ GX_TEVSTAGE4, + /* 0x5 */ GX_TEVSTAGE5, + /* 0x6 */ GX_TEVSTAGE6, + /* 0x7 */ GX_TEVSTAGE7, + /* 0x8 */ GX_TEVSTAGE8, + /* 0x9 */ GX_TEVSTAGE9, + /* 0xA */ GX_TEVSTAGE10, + /* 0xB */ GX_TEVSTAGE11, + /* 0xC */ GX_TEVSTAGE12, + /* 0xD */ GX_TEVSTAGE13, + /* 0xE */ GX_TEVSTAGE14, + /* 0xF */ GX_TEVSTAGE15, +} GXTevStageID; + +typedef enum _GXTexCoordID { + /* 0x00 */ GX_TEXCOORD0, + /* 0x01 */ GX_TEXCOORD1, + /* 0x02 */ GX_TEXCOORD2, + /* 0x03 */ GX_TEXCOORD3, + /* 0x04 */ GX_TEXCOORD4, + /* 0x05 */ GX_TEXCOORD5, + /* 0x06 */ GX_TEXCOORD6, + /* 0x07 */ GX_TEXCOORD7, + /* 0xFF */ GX_TEXCOORD_NULL = 255, +} GXTexCoordID; + +typedef enum _GXChannelID { + /* 0x00 */ GX_COLOR0, + /* 0x01 */ GX_COLOR1, + /* 0x02 */ GX_ALPHA0, + /* 0x03 */ GX_ALPHA1, + /* 0x04 */ GX_COLOR0A0, + /* 0x05 */ GX_COLOR1A1, + /* 0x06 */ GX_COLOR_ZERO, + /* 0x07 */ GX_ALPHA_BUMP, + /* 0x08 */ GX_ALPHA_BUMPN, + /* 0xFF */ GX_COLOR_NULL = 255, +} GXChannelID; + +typedef enum _GXColorSrc { + /* 0x0 */ GX_SRC_REG, + /* 0x1 */ GX_SRC_VTX, +} GXColorSrc; + +typedef enum _GXLightID { + /* 0x00 */ GX_LIGHT0, + /* 0x02 */ GX_LIGHT1 = 0x2, + /* 0x04 */ GX_LIGHT2 = 0x4, + /* 0x08 */ GX_LIGHT3 = 0x8, + /* 0x10 */ GX_LIGHT4 = 0x10, + /* 0x20 */ GX_LIGHT5 = 0x20, + /* 0x40 */ GX_LIGHT6 = 0x40, + /* 0x80 */ GX_LIGHT7 = 0x80, +} GXLightID; + +typedef enum _GXDiffuseFn { + /* 0x0 */ GX_DF_NONE, + /* 0x1 */ GX_DF_SIGN, + /* 0x2 */ GX_DF_CLAMP, +} GXDiffuseFn; + +typedef enum _GXAttnFn { + /* 0x0 */ GX_AF_SPEC, + /* 0x1 */ GX_AF_SPOT, + /* 0x2 */ GX_AF_NONE, +} GXAttnFn; + +typedef enum _GXTevMode { + /* 0x0 */ GX_MODULATE, + /* 0x1 */ GX_DECAL, + /* 0x2 */ GX_BLEND, + /* 0x3 */ GX_REPLACE, + /* 0x4 */ GX_PASSCLR, +} GXTevMode; + +typedef enum _GXBlendMode { + /* 0x0 */ GX_BM_NONE, + /* 0x1 */ GX_BM_BLEND, + /* 0x2 */ GX_BM_LOGIC, + /* 0x3 */ GX_BM_SUBTRACT, +} GXBlendMode; + +typedef enum _GXBlendFactor { + /* 0x0 */ GX_BL_ZERO, + /* 0x1 */ GX_BL_ONE, + /* 0x2 */ GX_BL_SRC_COLOR, + /* 0x3 */ GX_BL_INV_SRC_COLOR, + /* 0x4 */ GX_BL_SRC_ALPHA, + /* 0x5 */ GX_BL_INV_SRC_ALPHA, + /* 0x6 */ GX_BL_DST_ALPHA, + /* 0x7 */ GX_BL_INV_DST_ALPHA, +} GXBlendFactor; + +typedef enum _GXLogicOp { + /* 0x0 */ GX_LO_CLEAR, + /* 0x1 */ GX_LO_AND, + /* 0x2 */ GX_LO_REV_AND, + /* 0x3 */ GX_LO_COPY, + /* 0x4 */ GX_LO_INV_AND, + /* 0x5 */ GX_LO_NOOP, + /* 0x6 */ GX_LO_XOR, + /* 0x7 */ GX_LO_OP, + /* 0x8 */ GX_LO_NOR, + /* 0x9 */ GX_LO_EQUIV, + /* 0xA */ GX_LO_INV, + /* 0xB */ GX_LO_REV_OR, + /* 0xC */ GX_LO_INV_COPY, + /* 0xD */ GX_LO_INV_OR, + /* 0xE */ GX_LO_NAND, + /* 0xF */ GX_LO_SET, +} GXLogicOp; + +typedef enum _GXVtxFmt { + /* 0x0 */ GX_VTXFMT0, + /* 0x1 */ GX_VTXFMT1, + /* 0x2 */ GX_VTXFMT2, + /* 0x3 */ GX_VTXFMT3, + /* 0x4 */ GX_VTXFMT4, + /* 0x5 */ GX_VTXFMT5, + /* 0x6 */ GX_VTXFMT6, + /* 0x7 */ GX_VTXFMT7, +} GXVtxFmt; + +typedef enum _GXAttr { + /* 0x00 */ GX_VA_PTNMTXIDX, + /* 0x01 */ GX_VA_TEX0MTXIDX, + /* 0x02 */ GX_VA_TEX1MTXIDX, + /* 0x03 */ GX_VA_TEX2MTXIDX, + /* 0x04 */ GX_VA_TEX3MTXIDX, + /* 0x05 */ GX_VA_TEX4MTXIDX, + /* 0x06 */ GX_VA_TEX5MTXIDX, + /* 0x07 */ GX_VA_TEX6MTXIDX, + /* 0x08 */ GX_VA_TEX7MTXIDX, + /* 0x09 */ GX_VA_POS, + /* 0x0A */ GX_VA_NRM, + /* 0x0B */ GX_VA_CLR0, + /* 0x0C */ GX_VA_CLR1, + /* 0x0D */ GX_VA_TEX0, + /* 0x0E */ GX_VA_TEX1, + /* 0x0F */ GX_VA_TEX2, + /* 0x10 */ GX_VA_TEX3, + /* 0x11 */ GX_VA_TEX4, + /* 0x12 */ GX_VA_TEX5, + /* 0x13 */ GX_VA_TEX6, + /* 0x14 */ GX_VA_TEX7, + /* 0x15 */ GX_POS_MTX_ARRAY, + /* 0x16 */ GX_NRM_MTX_ARRAY, + /* 0x17 */ GX_TEX_MTX_ARRAY, + /* 0x18 */ GX_LIGHT_ARRAY, + /* 0x19 */ GX_VA_NBT, + /* 0x1A */ GX_VA_MAX_ATTR, + /* 0xFF */ GX_VA_NULL = 255, +} GXAttr; + +typedef enum _GXCompCnt { + /* 0x0 */ GX_TEX_S, + /* 0x0 */ GX_NRM_XYZ = 0, + /* 0x0 */ GX_CLR_RGB = 0, + /* 0x0 */ GX_POS_XY = 0, + /* 0x1 */ GX_TEX_ST = 1, + /* 0x1 */ GX_NRM_NBT = 1, + /* 0x1 */ GX_CLR_RGBA = 1, + /* 0x1 */ GX_POS_XYZ = 1, + /* 0x2 */ GX_NRM_NBT3, +} GXCompCnt; + +typedef enum _GXCompType { + /* 0x0 */ GX_U8, + /* 0x0 */ GX_RGB565 = 0, + /* 0x1 */ GX_S8, + /* 0x1 */ GX_RGB8 = 1, + /* 0x2 */ GX_RGBX8, + /* 0x2 */ GX_U16 = 2, + /* 0x3 */ GX_S16, + /* 0x3 */ GX_RGBA4 = 3, + /* 0x4 */ GX_RGBA6, + /* 0x4 */ GX_F32 = 4, + /* 0x5 */ GX_RGBA8, +} GXCompType; + +typedef enum _GXAttrType { + /* 0x0 */ GX_NONE, + /* 0x1 */ GX_DIRECT, + /* 0x2 */ GX_INDEX8, + /* 0x3 */ GX_INDEX16, +} GXAttrType; + +typedef enum _GXTevOp { + /* 0x0 */ GX_TEV_ADD, + /* 0x1 */ GX_TEV_SUB, + /* 0x8 */ GX_TEV_COMP_R8_GT = 8, + /* 0x9 */ GX_TEV_COMP_R8_EQ, + /* 0xA */ GX_TEV_COMP_GR16_GT, + /* 0xB */ GX_TEV_COMP_GR16_EQ, + /* 0xC */ GX_TEV_COMP_BGR24_GT, + /* 0xD */ GX_TEV_COMP_BGR24_EQ, + /* 0xE */ GX_TEV_COMP_A8_GT, + /* 0xE */ GX_TEV_COMP_RGB8_GT = 14, + /* 0xF */ GX_TEV_COMP_RGB8_EQ, + /* 0xF */ GX_TEV_COMP_A8_EQ = 15, +} GXTevOp; + +typedef enum _GXTevBias { + /* 0x0 */ GX_TB_ZERO, + /* 0x1 */ GX_TB_ADDHALF, + /* 0x2 */ GX_TB_SUBHALF, +} GXTevBias; + +typedef enum _GXTevColorArg { + /* 0x0 */ GX_CC_CPREV, + /* 0x1 */ GX_CC_APREV, + /* 0x2 */ GX_CC_C0, + /* 0x3 */ GX_CC_A0, + /* 0x4 */ GX_CC_C1, + /* 0x5 */ GX_CC_A1, + /* 0x6 */ GX_CC_C2, + /* 0x7 */ GX_CC_A2, + /* 0x8 */ GX_CC_TEXC, + /* 0x9 */ GX_CC_TEXA, + /* 0xA */ GX_CC_RASC, + /* 0xB */ GX_CC_RASA, + /* 0xC */ GX_CC_ONE, + /* 0xD */ GX_CC_HALF, + /* 0xE */ GX_CC_KONST, + /* 0xF */ GX_CC_ZERO, +} GXTevColorArg; + +typedef enum _GXTevScale { + /* 0x0 */ GX_CS_SCALE_1, + /* 0x1 */ GX_CS_SCALE_2, + /* 0x2 */ GX_CS_SCALE_4, + /* 0x3 */ GX_CS_DIVIDE_2, +} GXTevScale; + +typedef enum _GXTevRegID { + /* 0x0 */ GX_TEVPREV, + /* 0x1 */ GX_TEVREG0, + /* 0x2 */ GX_TEVREG1, + /* 0x3 */ GX_TEVREG2, +} GXTevRegID; + +typedef enum _GXTevAlphaArg { + /* 0x0 */ GX_CA_APREV, + /* 0x1 */ GX_CA_A0, + /* 0x2 */ GX_CA_A1, + /* 0x3 */ GX_CA_A2, + /* 0x4 */ GX_CA_TEXA, + /* 0x5 */ GX_CA_TEXB, + /* 0x6 */ GX_CA_ZERO, +} GXTevAlphaArg; + struct GXRenderModeObj { s32 vi_tv_mode; u16 fb_width; @@ -44,6 +300,25 @@ struct GXRenderModeObj { u8 vfilter[7]; }; +struct _GXTexObj { + u32 texture_filter; + u32 texture_lod; + u32 texture_size; + u32 texture_address; + u32 user_data; + u32 texture_format; + u32 tlut_name; + u16 texture_time_count; + u8 texture_tile_type; + u8 texture_flags; +}; + +struct _GXTlutObj { + u32 format; + u32 address; + u32 numEntries; +}; + typedef enum GXTexFmt8 { /* 8-bit version of GXTexFmt for use in structures */ GX_CTF_A8 = 39, GX_CTF_B8 = 42, @@ -72,12 +347,46 @@ typedef enum GXTexFmt8 { /* 8-bit version of GXTexFmt for use in structures */ GX_TF_Z8 = 17 } GXTexFmt8; +typedef enum GXTexFmt { + _GX_TF_I4, + _GX_TF_I8, + _GX_TF_IA4, + _GX_TF_IA8, + _GX_TF_RGB565, + _GX_TF_TGB5A3, + _GX_TF_RGBA8, + _GX_TF_CMPR = 14, + _GX_TF_Z8 = 17, + _GX_TF_Z16 = 19, + _GX_TF_Z24X8 = 22, + _GX_CTF_R4 = 32, + _GX_CTF_RA4 = 34, + _GX_CTF_RA8, + _GX_CTF_YUVA8 = 38, + _GX_CTF_A8, + _GX_CTF_R8, + _GX_CTF_G8, + _GX_CTF_B8, + _GX_CTF_RG8, + _GX_CTF_GB8, + _GX_CTF_Z4 = 48, + _GX_CTF_Z8M = 57, + _GX_CTF_Z8L, + _GX_CTF_Z16L = 60 +} GXTexFmt; + typedef enum GXTexWrapMode8 { /* Same as GXTexWrapMode, but as 1 byte for use inside structures */ GX_CLAMP = 0, GX_MIRROR = 2, GX_REPEAT = 1 } GXTexWrapMode8; +typedef enum GXTexWrapMode { + _GX_CLAMP, + _GX_REPEAT, + _GX_MIRROR, +} GXTexWrapMode; + typedef enum GXTexFilter8 { /* Same as GXTexFilter, but as 1 byte for use within structures that store the value as a byte */ GX_LINEAR = 1, @@ -88,14 +397,37 @@ typedef enum GXTexFilter8 { /* Same as GXTexFilter, but as 1 byte for use within GX_NEAR_MIP_NEAR = 2 } GXTexFilter8; +typedef enum GXTexFilter { + _GX_NEAR, + _GX_LINEAR, + _GX_NEAR_MIP_NEAR, + _GX_LIN_MIP_NEAR, + _GX_NEAR_MIP_LIN, + _GX_LIN_MIP_LIN, +} GXTexFilter; + +typedef enum GXAnisotropy { + GX_ANISO_1, + GX_ANISO_2, + GX_ANISO_4, +} GXAnisotropy; + +typedef enum GXTlutFmt { + GX_TL_IA8, + GX_TL_RGB565, + GX_TL_RGB5A3, +} GXTlutFmt; + extern "C" { f32 GXGetYScaleFactor(u16 efb_height, u16 xfb_height); u16 GXGetNumXfbLines(u32 efb_height, f32 y_scale); void GXBegin(u8, u8, u16); -void GXLoadTexObj(u32*, s32); -void GXInitTexObjLOD(f32, f32, f32, u32*, s32, s32, u32, u8, u32); -void GXInitTexObj(u32*, u32, u32, u32, u32, u32, u8); +void GXLoadTexObj(_GXTexObj*, _GXTexMapID); +void GXInitTexObjLOD(_GXTexObj, GXTexFilter, GXTexFilter, f32, f32, f32, s32, s32, GXAnisotropy); +void GXInitTexObj(_GXTexObj, void*, u16, u16, GXTexFmt, GXTexWrapMode, GXTexWrapMode, s32); +void GXInitTlutObj(_GXTlutObj*, void*, GXTlutFmt, u16); +void GXLoadTlut(_GXTlutObj*, u32); void GXSetNumChans(u32); void GXSetNumTevStages(u32); |