From de811bc95e770282d535fccdd5a2d5b1d47db1dc Mon Sep 17 00:00:00 2001 From: Jcw87 Date: Tue, 19 Dec 2023 02:54:59 -0800 Subject: [PATCH] JParticle --- configure.py | 2 +- include/JSystem/JParticle/JPABaseShape.h | 20 +- include/JSystem/JParticle/JPADraw.h | 76 +-- include/JSystem/JParticle/JPADrawSetupTev.h | 18 + include/JSystem/JParticle/JPADrawVisitor.h | 523 ++++++++++++++++++++ include/JSystem/JParticle/JPAExtraShape.h | 12 +- include/JSystem/JParticle/JPASweepShape.h | 4 +- src/JSystem/JParticle/JPADraw.cpp | 446 +++++++++++++++-- src/JSystem/JParticle/JPADrawSetupTev.cpp | 60 ++- src/JSystem/JParticle/JPADrawVisitor.cpp | 374 +------------- 10 files changed, 1068 insertions(+), 467 deletions(-) create mode 100644 include/JSystem/JParticle/JPADrawSetupTev.h create mode 100644 include/JSystem/JParticle/JPADrawVisitor.h diff --git a/configure.py b/configure.py index 9be2d776e..3135b07fc 100644 --- a/configure.py +++ b/configure.py @@ -576,7 +576,7 @@ config.libs = [ Object(NonMatching, "JSystem/JParticle/JPAEmitterManager.cpp"), Object(NonMatching, "JSystem/JParticle/JPADrawVisitor.cpp"), Object(NonMatching, "JSystem/JParticle/JPADraw.cpp"), - Object(NonMatching, "JSystem/JParticle/JPADrawSetupTev.cpp"), + Object(Matching, "JSystem/JParticle/JPADrawSetupTev.cpp"), ], ), JSystemLib( diff --git a/include/JSystem/JParticle/JPABaseShape.h b/include/JSystem/JParticle/JPABaseShape.h index 4683e2d08..738c2cfc4 100644 --- a/include/JSystem/JParticle/JPABaseShape.h +++ b/include/JSystem/JParticle/JPABaseShape.h @@ -52,12 +52,12 @@ public: virtual GXAlphaOp getAlphaCmpOp() = 0; virtual u8 getAlphaCmpRef0() = 0; virtual u8 getAlphaCmpRef1() = 0; - virtual BOOL isEnableAnmTone() = 0; - virtual BOOL isEnableProjection() = 0; + virtual u32 isEnableAnmTone() = 0; + virtual u32 isEnableProjection() = 0; virtual BOOL isClipOn() = 0; virtual BOOL isEnableTextureAnm() = 0; virtual BOOL textureIsEmpty() = 0; - virtual u32 getTextureAnmType() = 0; + virtual u8 getTextureAnmType() = 0; virtual u8 getTextureAnmKeyNum() = 0; virtual u8 getTextureIndex() = 0; virtual u8 getTextureIndex(u8 idx) = 0; @@ -69,9 +69,9 @@ public: virtual GXColor getEnvColor() = 0; virtual GXColor getPrmColor(s16) = 0; virtual GXColor getEnvColor(s16) = 0; - virtual u32 getColorRegAnmType() = 0; + virtual u8 getColorRegAnmType() = 0; virtual u32 getColorRegAnmMaxFrm() = 0; - virtual BOOL isEnableTexScrollAnm() = 0; + virtual u32 isEnableTexScrollAnm() = 0; virtual f32 getTilingX() = 0; virtual f32 getTilingY() = 0; virtual f32 getTexStaticTransX() = 0; @@ -160,12 +160,12 @@ public: virtual GXAlphaOp getAlphaCmpOp() { return stAlphaOp[(pBsd->mAlphaFlags >> 3) & 0x03]; } virtual u8 getAlphaCmpRef0() { return pBsd->mAlphaCmpRef0; } virtual u8 getAlphaCmpRef1() { return pBsd->mAlphaCmpRef1; } - virtual BOOL isEnableAnmTone() { return pBsd->mFlags & 0x80000; } - virtual BOOL isEnableProjection() { return pBsd->mFlags & 0x100000; } + virtual u32 isEnableAnmTone() { return pBsd->mFlags & 0x80000; } + virtual u32 isEnableProjection() { return pBsd->mFlags & 0x100000; } virtual BOOL isClipOn() { return pBsd->mFlags & 0x800000; } virtual BOOL isEnableTextureAnm() { return pBsd->mTextureFlags & 0x01; } virtual BOOL textureIsEmpty() { return !(pBsd->mTextureFlags & 0x02); } - virtual u32 getTextureAnmType() { return (pBsd->mTextureFlags >> 2) & 0x07; } + virtual u8 getTextureAnmType() { return (pBsd->mTextureFlags >> 2) & 0x07; } virtual u8 getTextureAnmKeyNum() { return pBsd->mTextureAnmKeyNum; } virtual u8 getTextureIndex() { return pBsd->mTextureIndex; } virtual u8 getTextureIndex(u8 idx) { return mpTexAnmIdxArr[idx]; } @@ -177,9 +177,9 @@ public: virtual GXColor getEnvColor() { return pBsd->mEnvColor; } virtual GXColor getPrmColor(s16 idx) { return mpPrmColorArr[idx]; } virtual GXColor getEnvColor(s16 idx) { return mpEnvColorArr[idx]; } - virtual u32 getColorRegAnmType() { return (pBsd->mColorFlags >> 4) & 0x07; } + virtual u8 getColorRegAnmType() { return (pBsd->mColorFlags >> 4) & 0x07; } virtual u32 getColorRegAnmMaxFrm() { return pBsd->mColorRegAnmMaxFrm; } - virtual BOOL isEnableTexScrollAnm() { return pBsd->mFlags & 0x1000000; } + virtual u32 isEnableTexScrollAnm() { return pBsd->mFlags & 0x1000000; } virtual f32 getTilingX() { return pBsd->mTilingX; } virtual f32 getTilingY() { return pBsd->mTilingY; } virtual f32 getTexStaticTransX() { return pBsd->mTexStaticTransX; } diff --git a/include/JSystem/JParticle/JPADraw.h b/include/JSystem/JParticle/JPADraw.h index aa3e4956e..267de7a67 100644 --- a/include/JSystem/JParticle/JPADraw.h +++ b/include/JSystem/JParticle/JPADraw.h @@ -1,50 +1,54 @@ #ifndef JPADRAW_H #define JPADRAW_H -#include "dolphin/types.h" +#include "JSystem/JGeometry.h" +#include "JSystem/JParticle/JPADrawVisitor.h" +#include "JSystem/JParticle/JPADrawSetupTev.h" #include "dolphin/gx/GXStruct.h" #include "dolphin/gx/GXEnum.h" #include "dolphin/mtx/mtx.h" +#include "global.h" -class JPABaseShape; -class JPAExtraShape; -class JPASweepShape; -class JPAExTexShape; -class JPATextureResource; -class JPABaseEmitter; -class JPABaseParticle; -struct JSUPtrList; - -class JPADraw; -class JPADrawExecEmitterVisitor; -class JPADrawExecParticleVisitor; -class JPADrawClipBoard; -class JPADrawVisitorContainer; - -class JPADrawContext { +class JPADrawClipBoard { public: - /* 0x00 */ JPABaseEmitter* pbe; - /* 0x04 */ JPABaseShape* pbsp; - /* 0x08 */ JPAExtraShape* pesp; - /* 0x0C */ JPASweepShape* pssp; - /* 0x10 */ JPAExTexShape* petx; - /* 0x14 */ JPADraw* mpDraw; - /* 0x18 */ JSUPtrList* mpActiveParticles; - /* 0x1C */ JPATextureResource* mpTextureResource; - /* 0x20 */ u16* pTexIdx; + JPADrawClipBoard() {} + ~JPADrawClipBoard() {} - static JPADrawClipBoard* pcb; + JPADrawSetupTev field_0x0; + f32 field_0x4; + f32 field_0x8; + f32 field_0xc; + f32 field_0x10; + JGeometry::TVec2 field_0x14[4]; + MtxP field_0x34; + f32 field_0x38; + f32 field_0x3c; + f32 field_0x40; + f32 field_0x44; + f32 field_0x48; + f32 field_0x4c; + f32 field_0x50; + f32 field_0x54; + f32 field_0x58; + f32 field_0x5c; + f32 field_0x60; + f32 field_0x64; + Mtx field_0x68; + GXColor field_0x98; + GXColor field_0x9c; + void* field_0xa0; + u8 field_0xa4[0xb4 - 0xa4]; }; class JPADraw { public: struct JPADrawVisitorDefFlags { - /* 0x00 */ u32 mbIsEnableDrawParent; - /* 0x04 */ u32 mbHasPrmAnm; - /* 0x08 */ u32 mbHasEnvAnm; - /* 0x0C */ u32 mbIsStripe; - /* 0x10 */ u32 mbIsPointOrLine; - /* 0x04 */ u32 mbIsEnableAlpha; + /* 0x00 */ BOOL mbIsEnableDrawParent; + /* 0x04 */ BOOL mbHasPrmAnm; + /* 0x08 */ BOOL mbHasEnvAnm; + /* 0x0C */ BOOL mbIsStripe; + /* 0x10 */ BOOL mbIsPointOrLine; + /* 0x14 */ BOOL mbIsEnableAlpha; }; bool initialize(JPABaseEmitter*, JPATextureResource*); @@ -73,11 +77,11 @@ public: /* 0x00 */ JPADrawExecEmitterVisitor* mpExecEmtrVis[1]; /* 0x04 */ JPADrawExecEmitterVisitor* mpExecEmtrPVis[5]; /* 0x18 */ JPADrawExecEmitterVisitor* mpExecEmtrCVis[3]; - /* 0x24 */ JPADrawExecParticleVisitor* mpCalcEmtrVis[4]; + /* 0x24 */ JPADrawCalcEmitterVisitor* mpCalcEmtrVis[4]; /* 0x34 */ JPADrawExecParticleVisitor* mpExecPtclVis[5]; - /* 0x48 */ JPADrawExecParticleVisitor* mpCalcPtclVis[10]; + /* 0x48 */ JPADrawCalcParticleVisitor* mpCalcPtclVis[10]; /* 0x70 */ JPADrawExecParticleVisitor* mpExecChldVis[4]; - /* 0x80 */ JPADrawExecParticleVisitor* mpCalcChldVis[2]; + /* 0x80 */ JPADrawCalcParticleVisitor* mpCalcChldVis[2]; /* 0x88 */ u8 execEmtrVisNum; /* 0x89 */ u8 execEmtrPVisNum; /* 0x8A */ u8 execEmtrCVisNum; diff --git a/include/JSystem/JParticle/JPADrawSetupTev.h b/include/JSystem/JParticle/JPADrawSetupTev.h new file mode 100644 index 000000000..0294ce26d --- /dev/null +++ b/include/JSystem/JParticle/JPADrawSetupTev.h @@ -0,0 +1,18 @@ +#ifndef JPADRAWSETUPTEV_H +#define JPADRAWSETUPTEV_H + +#include "dolphin/types.h" + +class JPABaseShape; +class JPAExTexShape; + +class JPADrawSetupTev { +public: + void setupTev(JPABaseShape* param_1, JPAExTexShape* param_2); + + u8 field_0x0; + u8 field_0x1; + u8 field_0x2; +}; + +#endif /* JPADRAWSETUPTEV_H */ diff --git a/include/JSystem/JParticle/JPADrawVisitor.h b/include/JSystem/JParticle/JPADrawVisitor.h new file mode 100644 index 000000000..dcb4b044f --- /dev/null +++ b/include/JSystem/JParticle/JPADrawVisitor.h @@ -0,0 +1,523 @@ +#ifndef JPADRAWVISITOR_H +#define JPADRAWVISITOR_H + +#include "JSystem/JSupport/JSUList.h" +#include "dolphin/types.h" + +class JPABaseEmitter; +class JPABaseParticle; +class JPABaseShape; +class JPAExTexShape; +class JPAExtraShape; +class JPASweepShape; +class JPADraw; +class JPADrawClipBoard; +class JPATextureResource; + +class JPADrawContext { +public: + /* 0x00 */ JPABaseEmitter* pbe; + /* 0x04 */ JPABaseShape* pbsp; + /* 0x08 */ JPAExtraShape* pesp; + /* 0x0C */ JPASweepShape* pssp; + /* 0x10 */ JPAExTexShape* petx; + /* 0x14 */ JPADraw* mpDraw; + /* 0x18 */ JSUList* mpActiveParticles; + /* 0x1C */ JPATextureResource* mpTextureResource; + /* 0x20 */ u16* pTexIdx; + + static JPADrawClipBoard* pcb; +}; + +class JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecEmitterVisitor() {} + virtual void exec(const JPADrawContext* pDC) = 0; +}; + +class JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecParticleVisitor() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2) = 0; +}; + +class JPADrawExecGenPrjMtx : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecGenPrjMtx() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecGenPrjTexMtx : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecGenPrjTexMtx() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecGenTexMtx0 : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecGenTexMtx0() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecGenIdtMtx : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecGenIdtMtx() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecSetTexMtx : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecSetTexMtx() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecSetPointSize : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecSetPointSize() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecSetLineWidth : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecSetLineWidth() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRegisterColorEmitterPE : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecRegisterColorEmitterPE() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecRegisterColorEmitterP : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecRegisterColorEmitterP() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecRegisterColorEmitterE : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecRegisterColorEmitterE() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecRegisterColorChildPE : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecRegisterColorChildPE() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecRegisterPrmColorAnm : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRegisterPrmColorAnm() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRegisterPrmAlphaAnm : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRegisterPrmAlphaAnm() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRegisterEnvColorAnm : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRegisterEnvColorAnm() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRegisterPrmCEnv : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRegisterPrmCEnv() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRegisterPrmAEnv : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRegisterPrmAEnv() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecLoadDefaultTexture : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecLoadDefaultTexture() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecLoadTexture : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecLoadTexture() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecLoadExTex : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecLoadExTex() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecBillBoard : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecBillBoard() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotBillBoard : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotBillBoard() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecYBillBoard : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecYBillBoard() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotYBillBoard : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotYBillBoard() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecDirectional : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecDirectional() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotDirectional : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotDirectional() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecDirectionalCross : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecDirectionalCross() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotDirectionalCross : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotDirectionalCross() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecDirBillBoard : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecDirBillBoard() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotation : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotation() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecRotationCross : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecRotationCross() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecPoint : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecPoint() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecLine : public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecLine() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawExecStripe : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecStripe() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecStripeCross : public JPADrawExecEmitterVisitor { +public: + virtual ~JPADrawExecStripeCross() {} + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawExecCallBack : public JPADrawExecEmitterVisitor, public JPADrawExecParticleVisitor { +public: + virtual ~JPADrawExecCallBack() {} + virtual void exec(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void exec(const JPADrawContext* pDC); +}; + +class JPADrawCalcEmitterVisitor { +public: + virtual ~JPADrawCalcEmitterVisitor() {} + virtual void calc(const JPADrawContext* pDC) = 0; +}; + +class JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcParticleVisitor() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2) = 0; +}; + +class JPADrawCalcScaleX : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleX() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleXBySpeed : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleXBySpeed() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleY : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleY() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleYBySpeed : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleYBySpeed() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleCopyX2Y : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleCopyX2Y() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleAnmTimingNormal : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleAnmTimingNormal() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleAnmTimingRepeatX : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleAnmTimingRepeatX() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleAnmTimingRepeatY : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleAnmTimingRepeatY() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleAnmTimingReverseX : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleAnmTimingReverseX() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcScaleAnmTimingReverseY : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcScaleAnmTimingReverseY() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcColorPrm : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorPrm() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorEnv : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorEnv() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorCopyFromEmitter : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorCopyFromEmitter() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcColorAnmFrameNormal : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorAnmFrameNormal() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorAnmFrameRepeat : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorAnmFrameRepeat() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorAnmFrameReverse : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorAnmFrameReverse() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorAnmFrameMerge : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorAnmFrameMerge() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcColorAnmFrameRandom : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcColorAnmFrameRandom() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcAlpha : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcAlpha() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcAlphaFlickNrmSin : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcAlphaFlickNrmSin() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcAlphaFlickAddSin : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcAlphaFlickAddSin() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcAlphaFlickMultSin : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcAlphaFlickMultSin() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcTextureAnmIndexNormal : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcTextureAnmIndexNormal() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcTextureAnmIndexRepeat : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcTextureAnmIndexRepeat() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcTextureAnmIndexReverse : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcTextureAnmIndexReverse() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcTextureAnmIndexMerge : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcTextureAnmIndexMerge() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcTextureAnmIndexRandom : public JPADrawCalcEmitterVisitor, public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcTextureAnmIndexRandom() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); + virtual void calc(const JPADrawContext* pDC); +}; + +class JPADrawCalcChildAlphaOut : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcChildAlphaOut() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawCalcChildScaleOut : public JPADrawCalcParticleVisitor { +public: + virtual ~JPADrawCalcChildScaleOut() {} + virtual void calc(const JPADrawContext* pDC, JPABaseParticle* param_2); +}; + +class JPADrawVisitorContainer { +public: + JPADrawExecGenPrjMtx field_0x0; + JPADrawExecGenPrjTexMtx field_0x4; + JPADrawExecGenTexMtx0 field_0x8; + JPADrawExecGenIdtMtx field_0xc; + JPADrawExecSetTexMtx field_0x10; + JPADrawExecSetPointSize field_0x18; + JPADrawExecSetLineWidth field_0x1c; + JPADrawExecRegisterColorEmitterPE field_0x20; + JPADrawExecRegisterColorEmitterP field_0x24; + JPADrawExecRegisterColorEmitterE field_0x28; + JPADrawExecRegisterColorChildPE field_0x2c; + JPADrawExecRegisterPrmColorAnm field_0x30; + JPADrawExecRegisterPrmAlphaAnm field_0x34; + JPADrawExecRegisterEnvColorAnm field_0x38; + JPADrawExecRegisterPrmCEnv field_0x3c; + JPADrawExecRegisterPrmAEnv field_0x40; + JPADrawExecLoadDefaultTexture field_0x44; + JPADrawExecLoadTexture field_0x48; + JPADrawExecLoadExTex field_0x50; + JPADrawExecBillBoard field_0x54; + JPADrawExecRotBillBoard field_0x58; + JPADrawExecYBillBoard field_0x5c; + JPADrawExecRotYBillBoard field_0x60; + JPADrawExecDirectional field_0x64; + JPADrawExecRotDirectional field_0x68; + JPADrawExecDirectionalCross field_0x6c; + JPADrawExecRotDirectionalCross field_0x70; + JPADrawExecDirBillBoard field_0x74; + JPADrawExecRotation field_0x78; + JPADrawExecRotationCross field_0x7c; + JPADrawExecPoint field_0x80; + JPADrawExecLine field_0x84; + JPADrawExecStripe field_0x88; + JPADrawExecStripeCross field_0x8c; + JPADrawExecCallBack field_0x90; + JPADrawCalcScaleX field_0x98; + JPADrawCalcScaleXBySpeed field_0x9c; + JPADrawCalcScaleY field_0xa0; + JPADrawCalcScaleYBySpeed field_0xa4; + JPADrawCalcScaleCopyX2Y field_0xa8; + JPADrawCalcScaleAnmTimingNormal field_0xac; + JPADrawCalcScaleAnmTimingRepeatX field_0xb0; + JPADrawCalcScaleAnmTimingRepeatY field_0xb4; + JPADrawCalcScaleAnmTimingReverseX field_0xb8; + JPADrawCalcScaleAnmTimingReverseY field_0xbc; + JPADrawCalcColorPrm field_0xc0; + JPADrawCalcColorEnv field_0xc8; + JPADrawCalcColorCopyFromEmitter field_0xd0; + JPADrawCalcColorAnmFrameNormal field_0xd4; + JPADrawCalcColorAnmFrameRepeat field_0xdc; + JPADrawCalcColorAnmFrameReverse field_0xe4; + JPADrawCalcColorAnmFrameMerge field_0xec; + JPADrawCalcColorAnmFrameRandom field_0xf4; + JPADrawCalcAlpha field_0xfc; + JPADrawCalcAlphaFlickNrmSin field_0x100; + JPADrawCalcAlphaFlickAddSin field_0x104; + JPADrawCalcAlphaFlickMultSin field_0x108; + JPADrawCalcTextureAnmIndexNormal field_0x10c; + JPADrawCalcTextureAnmIndexRepeat field_0x114; + JPADrawCalcTextureAnmIndexReverse field_0x11c; + JPADrawCalcTextureAnmIndexMerge field_0x124; + JPADrawCalcTextureAnmIndexRandom field_0x12c; + JPADrawCalcChildAlphaOut field_0x134; + JPADrawCalcChildScaleOut field_0x138; +}; + +#endif /* JPADRAWVISITOR_H */ diff --git a/include/JSystem/JParticle/JPAExtraShape.h b/include/JSystem/JParticle/JPAExtraShape.h index 668872330..093a97c79 100644 --- a/include/JSystem/JParticle/JPAExtraShape.h +++ b/include/JSystem/JParticle/JPAExtraShape.h @@ -44,8 +44,8 @@ public: virtual f32 getScaleOutTiming() = 0; virtual f32 getScaleInValueX() = 0; virtual f32 getScaleInValueY() = 0; - virtual u32 getAnmTypeX() = 0; - virtual u32 getAnmTypeY() = 0; + virtual u8 getAnmTypeX() = 0; + virtual u8 getAnmTypeY() = 0; virtual u32 getAnmCycleX() = 0; virtual u32 getAnmCycleY() = 0; virtual f32 getIncreaseRateX() = 0; @@ -61,7 +61,7 @@ public: virtual f32 getAlphaOutTiming() = 0; virtual f32 getAlphaInValue() = 0; virtual f32 getAlphaBaseValue() = 0; - virtual u32 getAlphaWaveType() = 0; + virtual u8 getAlphaWaveType() = 0; virtual f32 getAlphaWaveParam1() = 0; virtual f32 getAlphaWaveParam2() = 0; virtual f32 getAlphaWaveParam3() = 0; @@ -90,8 +90,8 @@ public: virtual f32 getScaleOutTiming() { return mpData->mScaleOutTiming; } virtual f32 getScaleInValueX() { return mpData->mScaleInValueX; } virtual f32 getScaleInValueY() { return mpData->mScaleInValueY; } - virtual u32 getAnmTypeX() { return (mpData->mFlag >> 18) & 0x01; } - virtual u32 getAnmTypeY() { return (mpData->mFlag >> 19) & 0x01; } + virtual u8 getAnmTypeX() { return (mpData->mFlag >> 18) & 0x01; } + virtual u8 getAnmTypeY() { return (mpData->mFlag >> 19) & 0x01; } virtual u32 getAnmCycleX() { return mpData->mAnmCycleX; } virtual u32 getAnmCycleY() { return mpData->mAnmCycleY; } virtual f32 getIncreaseRateX() { return mIncreaseRateX; } @@ -107,7 +107,7 @@ public: virtual f32 getAlphaOutTiming() { return mpData->mAlphaOutTiming; } virtual f32 getAlphaInValue() { return mpData->mAlphaInValue; } virtual f32 getAlphaBaseValue() { return mpData->mAlphaBaseValue; } - virtual u32 getAlphaWaveType() { return (mpData->mFlag >> 2) & 0x03; } + virtual u8 getAlphaWaveType() { return (mpData->mFlag >> 2) & 0x03; } virtual f32 getAlphaWaveParam1() { return mpData->mAlphaWaveParam1; } virtual f32 getAlphaWaveParam2() { return mpData->mAlphaWaveParam2; } virtual f32 getAlphaWaveParam3() { return mpData->mAlphaWaveParam3; } diff --git a/include/JSystem/JParticle/JPASweepShape.h b/include/JSystem/JParticle/JPASweepShape.h index fe5291f2c..05ccc8b52 100644 --- a/include/JSystem/JParticle/JPASweepShape.h +++ b/include/JSystem/JParticle/JPASweepShape.h @@ -29,7 +29,7 @@ struct JPASweepShapeData { class JPASweepShape { public: virtual ~JPASweepShape() {}; - virtual u32 getType() = 0; + virtual u8 getType() = 0; virtual u32 getDirType() = 0; virtual u32 getRotType() = 0; virtual u32 getBasePlaneType() = 0; @@ -68,7 +68,7 @@ class JPASweepShapeArc : public JPASweepShape { public: JPASweepShapeArc(const u8*); virtual ~JPASweepShapeArc() {}; - virtual u32 getType() { return (mpData->mFlag >> 0) & 0x0F; } + virtual u8 getType() { return (mpData->mFlag >> 0) & 0x0F; } virtual u32 getDirType() { return (mpData->mFlag >> 4) & 0x07; } virtual u32 getRotType() { return (mpData->mFlag >> 7) & 0x07; } virtual u32 getBasePlaneType() { return (mpData->mFlag >> 10) & 0x01; } diff --git a/src/JSystem/JParticle/JPADraw.cpp b/src/JSystem/JParticle/JPADraw.cpp index 28b5f2e66..da41b52e7 100644 --- a/src/JSystem/JParticle/JPADraw.cpp +++ b/src/JSystem/JParticle/JPADraw.cpp @@ -11,23 +11,11 @@ #include "JSystem/JUtility/JUTAssert.h" #include "dolphin/types.h" -class JPADrawClipBoard { -public: - ~JPADrawClipBoard(); -}; - -class JPADrawVisitorContainer { -public: - JPADrawVisitorContainer(); - ~JPADrawVisitorContainer(); -}; - JPADrawVisitorContainer JPADraw::vc; JPADrawClipBoard JPADraw::cb; /* 80267F40-80268634 .text initialize__7JPADrawFP14JPABaseEmitterP18JPATextureResource */ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) { - /* Nonmatching */ JPADrawContext::pcb = &cb; dc.pbe = emtr; dc.pbsp = dc.pbe->getEmitterDataBlockInfoPtr()->getBaseShape(); @@ -85,7 +73,7 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) { mpCalcChldVis[i] = NULL; JPADrawVisitorDefFlags flags; - flags.mbIsEnableDrawParent = dc.pssp != NULL && dc.pssp->isEnableDrawParent(); + flags.mbIsEnableDrawParent = dc.pssp == NULL || dc.pssp->isEnableDrawParent(); flags.mbHasPrmAnm = dc.pbsp->isEnablePrm() && dc.pbsp->isEnablePrmAnm(); flags.mbHasEnvAnm = dc.pbsp->isEnableEnv() && dc.pbsp->isEnableEnvAnm(); flags.mbIsStripe = dc.pbsp->getType() == JPABaseShape::JPAType_Stripe || dc.pbsp->getType() == JPABaseShape::JPAType_StripeCross; @@ -94,8 +82,10 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) { setDrawExecVisitorsBeforeCB(flags); - // TODO: setup visitor container - // mpExecEmtrPVis[execEmtrVisNum++] = vc.something; + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x90; + mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x90; + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x90; + mpExecChldVis[execChldVisNum++] = &vc.field_0x90; setDrawExecVisitorsAfterCB(flags); setDrawCalcVisitors(flags); @@ -112,8 +102,41 @@ bool JPADraw::initialize(JPABaseEmitter* emtr, JPATextureResource* texRes) { } /* 80268634-802688D4 .text draw__7JPADrawFPA4_f */ -void JPADraw::draw(float(*)[4]) { - /* Nonmatching */ +void JPADraw::draw(MtxP param_1) { + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0); + GXSetCurrentMtx(0); + GXSetNumChans(0); + GXSetTevDirect(GX_TEVSTAGE0); + GXSetTevDirect(GX_TEVSTAGE1); + GXSetTevDirect(GX_TEVSTAGE2); + GXSetCoPlanar(GX_DISABLE); + GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, 0, GX_DF_NONE, GX_AF_NONE); + GXSetChanCtrl(GX_COLOR1A1, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, 0, GX_DF_NONE, GX_AF_NONE); + GXSetBlendMode(dc.pbsp->getBlendMode1(), dc.pbsp->getSrcBlendFactor1(), + dc.pbsp->getDstBlendFactor1(), dc.pbsp->getBlendOp1()); + cb.field_0x98 = dc.pbe->mGlobalPrmColor; + cb.field_0x9c = dc.pbe->mGlobalEnvColor; + cb.field_0x34 = param_1; + cb.field_0x0.setupTev(dc.pbsp, dc.petx); + for (int i = 0; i < execEmtrVisNum; i++) { + mpExecEmtrVis[i]->exec(&dc); + } + if (dc.pbsp->isEnableAnmTone()) { + zDraw(); + } + field_0xc2 &= 0xfe; + if (dc.pbsp->getChildOrder() && dc.pssp) { + drawChild(); + } + drawParticle(); + if (!dc.pbsp->getChildOrder() && dc.pssp) { + drawChild(); + } + GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0); } /* 802688D4-80268940 .text calc__7JPADrawFv */ @@ -150,18 +173,381 @@ bool JPADraw::loadTexture(u8 tex_no, GXTexMapID texMap) { } /* 80269358-80269C08 .text setDrawExecVisitorsBeforeCB__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */ -void JPADraw::setDrawExecVisitorsBeforeCB(const JPADraw::JPADrawVisitorDefFlags&) { +void JPADraw::setDrawExecVisitorsBeforeCB(const JPADraw::JPADrawVisitorDefFlags& param_1) { /* Nonmatching */ + if (dc.petx) { + mpExecEmtrVis[execEmtrVisNum++] = &vc.field_0x50; + } + if (param_1.mbIsPointOrLine) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0xc; + } else if (dc.pbsp->isEnableProjection()) { + if (dc.pbsp->isEnableTexScrollAnm()) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x4; + } else { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x0; + } + } else if (dc.pbsp->isEnableTexScrollAnm()) { + if (param_1.mbIsStripe) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x10; + } else { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x8; + } + } else { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0xc; + } + + if (dc.pbsp->isEnableGlobalColAnm()) { + if (param_1.mbIsStripe || param_1.mbIsEnableAlpha == 0) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x20; + } else if (param_1.mbIsEnableAlpha) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x28; + } + } else if ((!dc.pbsp->isEnablePrm() || !dc.pbsp->isEnablePrmAnm()) && param_1.mbIsEnableAlpha == 0) { + if (!dc.pbsp->isEnableEnv() || !dc.pbsp->isEnableEnvAnm()) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x20; + } else { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x24; + } + } else if (!dc.pbsp->isEnableEnv() || !dc.pbsp->isEnableEnvAnm()) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x28; + } + if (!dc.pbsp->textureIsEmpty() && (!dc.pbsp->isEnableTextureAnm() || dc.pbsp->isEnableGlobalTexAnm())) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x48; + } else if (dc.pbsp->textureIsEmpty()) { + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x44; + } + if (dc.pssp && !dc.pssp->isEnableAlphaOut() && !dc.pssp->isInheritedAlpha() && !dc.pssp->isInheritedRGB()) { + mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x2c; + } + if (!dc.pbsp->isEnableGlobalColAnm()) { + if (param_1.mbHasPrmAnm) { + if (param_1.mbHasEnvAnm) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x3c; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x30; + } + } else if (param_1.mbIsEnableAlpha) { + if (param_1.mbHasEnvAnm) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x40; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x34; + } + } else if (param_1.mbHasEnvAnm) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x38; + } + + } else if (param_1.mbIsEnableAlpha && !param_1.mbIsStripe) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x34; + } + if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() && !dc.pbsp->isEnableGlobalTexAnm()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x48; + } + switch (dc.pbsp->getType()) { + case 0: + if (dc.pesp && dc.pesp->isEnableScale()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x18; + } + break; + case 1: + if (dc.pesp && dc.pesp->isEnableScale()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x1c; + } + break; + case 5: + case 6: + break; + case 7: + case 8: + case 9: + case 10: + if (dc.pbsp->isEnableTexScrollAnm() && !dc.pbsp->isEnableProjection()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x10; + } + break; + } + if (dc.pssp) { + if (dc.pssp->isEnableAlphaOut() || dc.pssp->isInheritedAlpha() || dc.pssp->isInheritedRGB()) { + mpExecChldVis[execChldVisNum++] = &vc.field_0x3c; + } + switch (dc.pssp->getType()) { + case 0: + mpExecChldVis[execChldVisNum++] = &vc.field_0x18; + break; + case 1: + mpExecChldVis[execChldVisNum++] = &vc.field_0x1c; + break; + } + } } /* 80269C08-8026A2EC .text setDrawExecVisitorsAfterCB__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */ -void JPADraw::setDrawExecVisitorsAfterCB(const JPADraw::JPADrawVisitorDefFlags&) { - /* Nonmatching */ +void JPADraw::setDrawExecVisitorsAfterCB(const JPADraw::JPADrawVisitorDefFlags& param_1) { + if (param_1.mbIsEnableDrawParent) { + switch (dc.pbsp->getType()) { + case 0: + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x80; + break; + case 1: + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x84; + break; + case 2: + if (dc.pesp && dc.pesp->isEnableRotate()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x58; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x54; + } + break; + case 3: + if (dc.pesp && dc.pesp->isEnableRotate()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x68; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x64; + } + break; + case 4: + if (dc.pesp && dc.pesp->isEnableRotate()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x70; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x6c; + } + break; + case 10: + if (dc.pesp && dc.pesp->isEnableRotate()) { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x60; + } else { + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x5c; + } + break; + case 7: + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x78; + break; + case 8: + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x7c; + break; + case 9: + mpExecPtclVis[execPtclVisNum++] = &vc.field_0x74; + break; + case 5: + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x88; + break; + case 6: + mpExecEmtrPVis[execEmtrPVisNum++] = &vc.field_0x8c; + break; + } + } + if (dc.pssp) { + switch (dc.pssp->getType()) { + case 0: + mpExecChldVis[execChldVisNum++] = &vc.field_0x80; + break; + case 1: + mpExecChldVis[execChldVisNum++] = &vc.field_0x84; + break; + case 2: + if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) { + mpExecChldVis[execChldVisNum++] = &vc.field_0x58; + } else { + mpExecChldVis[execChldVisNum++] = &vc.field_0x54; + } + break; + case 3: + if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) { + mpExecChldVis[execChldVisNum++] = &vc.field_0x68; + } else { + mpExecChldVis[execChldVisNum++] = &vc.field_0x64; + } + break; + case 4: + if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) { + mpExecChldVis[execChldVisNum++] = &vc.field_0x70; + } else { + mpExecChldVis[execChldVisNum++] = &vc.field_0x6c; + } + break; + case 10: + if ((dc.pesp && dc.pesp->isEnableRotate()) || dc.pssp->isEnableRotate()) { + mpExecChldVis[execChldVisNum++] = &vc.field_0x60; + } else { + mpExecChldVis[execChldVisNum++] = &vc.field_0x5c; + } + break; + case 7: + mpExecChldVis[execChldVisNum++] = &vc.field_0x78; + break; + case 8: + mpExecChldVis[execChldVisNum++] = &vc.field_0x7c; + break; + case 9: + mpExecChldVis[execChldVisNum++] = &vc.field_0x74; + break; + case 5: + mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x88; + break; + case 6: + mpExecEmtrCVis[execEmtrCVisNum++] = &vc.field_0x8c; + break; + } + } } /* 8026A2EC-8026ADB0 .text setDrawCalcVisitors__7JPADrawFRCQ27JPADraw22JPADrawVisitorDefFlags */ -void JPADraw::setDrawCalcVisitors(const JPADraw::JPADrawVisitorDefFlags&) { - /* Nonmatching */ +void JPADraw::setDrawCalcVisitors(const JPADraw::JPADrawVisitorDefFlags& param_1) { + if (dc.pbsp->isEnableGlobalColAnm() && (param_1.mbHasPrmAnm || param_1.mbHasEnvAnm)) { + switch (dc.pbsp->getColorRegAnmType()) { + case 0: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xd4; + break; + case 1: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xdc; + break; + case 2: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xe4; + break; + case 3: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xec; + break; + case 4: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xf4; + break; + } + if (param_1.mbHasPrmAnm) { + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xc0; + } + if (param_1.mbHasEnvAnm) { + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0xc8; + } + } + if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() && + dc.pbsp->isEnableGlobalTexAnm()) + { + switch (dc.pbsp->getTextureAnmType()) { + case 0: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x10c; + break; + case 1: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x114; + break; + case 2: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x11c; + break; + case 3: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x124; + break; + case 4: + mpCalcEmtrVis[calcEmtrVisNum++] = &vc.field_0x12c; + break; + } + } + if (dc.pesp && dc.pesp->isEnableScale()) { + if (dc.pesp->isEnableScaleAnmX()) { + if (dc.pesp->getAnmTypeX()) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb8; + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb0; + } + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xac; + } + if (dc.pesp->isEnableScaleBySpeedX() && dc.pbsp->getType() != 1) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x9c; + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x98; + } + if (dc.pbsp->getType() != 0) { + if (!dc.pesp->isDiffXY()) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa8; + } else { + if (dc.pesp->isEnableScaleAnmY()) { + if (dc.pesp->getAnmTypeY()) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xbc; + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xb4; + } + } else if (dc.pesp->isEnableScaleAnmX()) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xac; + } + if (dc.pesp->isEnableScaleBySpeedY()) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa4; + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xa0; + } + } + } + } + if (!dc.pbsp->isEnableGlobalColAnm()) { + if (param_1.mbHasPrmAnm || param_1.mbHasEnvAnm) { + switch (dc.pbsp->getColorRegAnmType()) { + case 0: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xd4; + break; + case 1: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xdc; + break; + case 2: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xe4; + break; + case 3: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xec; + break; + case 4: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xf4; + break; + } + if (param_1.mbHasPrmAnm) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xc0; + } + if (param_1.mbHasEnvAnm) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xc8; + } + } + } else { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xd0; + } + if (param_1.mbIsEnableAlpha && !param_1.mbIsStripe) { + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0xfc; + if (dc.pesp->isEnableSinWave()) { + switch (dc.pesp->getAlphaWaveType()) { + case 0: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x100; + break; + case 1: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x104; + break; + case 2: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x108; + break; + } + } + } + if (!dc.pbsp->textureIsEmpty() && dc.pbsp->isEnableTextureAnm() && + !dc.pbsp->isEnableGlobalTexAnm()) + { + switch (dc.pbsp->getTextureAnmType()) { + case 0: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x10c; + break; + case 1: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x114; + break; + case 2: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x11c; + break; + case 3: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x124; + break; + case 4: + mpCalcPtclVis[calcPtclVisNum++] = &vc.field_0x12c; + break; + } + } + if (dc.pssp) { + if (dc.pssp->isEnableAlphaOut()) { + mpCalcChldVis[calcChldVisNum++] = &vc.field_0x134; + } + if (dc.pssp->isEnableScaleOut()) { + mpCalcChldVis[calcChldVisNum++] = &vc.field_0x138; + } + } } /* 8026ADB0-8026B3DC .text setParticleClipBoard__7JPADrawFv */ @@ -186,7 +572,6 @@ void JPADraw::drawChild() { /* 8026BF88-8026C024 .text zDraw__7JPADrawFv */ void JPADraw::zDraw() { - /* Nonmatching */ field_0xc2 |= 0x01; if (dc.pbsp->getChildOrder() && dc.pssp != NULL) zDrawChild(); @@ -209,18 +594,3 @@ void JPADraw::zDrawChild() { void JPADraw::loadYBBMtx(float(*)[4]) { /* Nonmatching */ } - -/* 8026C6C0-8026C6FC .text __dt__16JPADrawClipBoardFv */ -JPADrawClipBoard::~JPADrawClipBoard() { - /* Nonmatching */ -} - -/* 8026C700-8026D2E0 .text __dt__23JPADrawVisitorContainerFv */ -JPADrawVisitorContainer::~JPADrawVisitorContainer() { - /* Nonmatching */ -} - -/* 8026D2E0-8026D7B8 .text __ct__23JPADrawVisitorContainerFv */ -JPADrawVisitorContainer::JPADrawVisitorContainer() { - /* Nonmatching */ -} diff --git a/src/JSystem/JParticle/JPADrawSetupTev.cpp b/src/JSystem/JParticle/JPADrawSetupTev.cpp index 25ae2c23e..393a24d69 100644 --- a/src/JSystem/JParticle/JPADrawSetupTev.cpp +++ b/src/JSystem/JParticle/JPADrawSetupTev.cpp @@ -4,9 +4,63 @@ // #include "JSystem/JParticle/JPADrawSetupTev.h" -#include "dolphin/types.h" +#include "JSystem/JParticle/JPABaseShape.h" +#include "JSystem/JParticle/JPAExTexShape.h" +#include "dolphin/gx/GX.h" /* 8026D7B8-8026DBBC .text setupTev__15JPADrawSetupTevFP12JPABaseShapeP13JPAExTexShape */ -void JPADrawSetupTev::setupTev(JPABaseShape*, JPAExTexShape*) { - /* Nonmatching */ +void JPADrawSetupTev::setupTev(JPABaseShape* param_1, JPAExTexShape* param_2) { + field_0x1 = 1; + field_0x0 = 1; + field_0x2 = 0; + GXTevColorArg* tevColorArg = param_1->getTevColorArg(); + GXTevAlphaArg* tevAlphaArg = param_1->getTevAlphaArg(); + GXSetTevColorIn(GX_TEVSTAGE0, tevColorArg[0], tevColorArg[1], tevColorArg[2], tevColorArg[3]); + GXSetTevAlphaIn(GX_TEVSTAGE0, tevAlphaArg[0], tevAlphaArg[1], tevAlphaArg[2], tevAlphaArg[3]); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL); + if (param_2) { + GXTevStageID stage = GX_TEVSTAGE1; + GXTexCoordID coord = GX_TEXCOORD1; + switch (param_2->getIndTexMode()) { + case 1: + GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP5); + GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); + GXSetIndTexMtx(GX_ITM_0, (f32*)param_2->getIndTexMtx(), param_2->getExpScale()); + GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, param_2->getIndTexMtxID(), GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, GX_ITBA_OFF); + field_0x2++; + field_0x1++; + coord = GX_TEXCOORD2; + break; + case 2: + GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP5); + GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1); + GXSetIndTexMtx(GX_ITM_0, (f32*)param_2->getIndTexMtx(), param_2->getExpScale()); + GXSetTevIndirect(GX_TEVSTAGE1, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, param_2->getIndTexMtxID(), GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, GX_ITBA_OFF); + GXSetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD2, GX_TEXMAP6, GX_COLOR_NULL); + GXSetTevColorIn(GX_TEVSTAGE1, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_TEXA); + GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_APREV); + GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + field_0x0++; + field_0x1 += 2; + field_0x2++; + stage = GX_TEVSTAGE2; + coord = GX_TEXCOORD3; + break; + } + if (param_2->isEnableSecondTex()) { + GXSetTevOrder(stage, coord, GX_TEXMAP7, GX_COLOR_NULL); + GXSetTevColorIn(stage, GX_CC_ZERO, GX_CC_TEXC, GX_CC_CPREV, GX_CC_ZERO); + GXSetTevAlphaIn(stage, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO); + GXSetTevColorOp(stage, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + GXSetTevAlphaOp(stage, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV); + field_0x0++; + field_0x1++; + } + } + GXSetNumTexGens(field_0x1); + GXSetNumTevStages(field_0x0); + GXSetNumIndStages(field_0x2); } diff --git a/src/JSystem/JParticle/JPADrawVisitor.cpp b/src/JSystem/JParticle/JPADrawVisitor.cpp index ca5c0c56d..6c3793045 100644 --- a/src/JSystem/JParticle/JPADrawVisitor.cpp +++ b/src/JSystem/JParticle/JPADrawVisitor.cpp @@ -4,7 +4,9 @@ // #include "JSystem/JParticle/JPADrawVisitor.h" -#include "dolphin/types.h" +#include "JSystem/JGeometry.h" + +JPADrawClipBoard* JPADrawContext::pcb; /* 8025F960-8025FBE4 .text exec__20JPADrawExecLoadExTexFPC14JPADrawContext */ void JPADrawExecLoadExTex::exec(const JPADrawContext*) { @@ -470,373 +472,3 @@ void JPADrawCalcChildAlphaOut::calc(const JPADrawContext*, JPABaseParticle*) { void JPADrawCalcChildScaleOut::calc(const JPADrawContext*, JPABaseParticle*) { /* Nonmatching */ } - -/* 80266450-802664AC .text __dt__24JPADrawCalcChildScaleOutFv */ -JPADrawCalcChildScaleOut::~JPADrawCalcChildScaleOut() { - /* Nonmatching */ -} - -/* 802664AC-802664F4 .text __dt__26JPADrawCalcParticleVisitorFv */ -JPADrawCalcParticleVisitor::~JPADrawCalcParticleVisitor() { - /* Nonmatching */ -} - -/* 802664F4-80266550 .text __dt__24JPADrawCalcChildAlphaOutFv */ -JPADrawCalcChildAlphaOut::~JPADrawCalcChildAlphaOut() { - /* Nonmatching */ -} - -/* 80266550-802665AC .text __dt__28JPADrawCalcAlphaFlickMultSinFv */ -JPADrawCalcAlphaFlickMultSin::~JPADrawCalcAlphaFlickMultSin() { - /* Nonmatching */ -} - -/* 802665AC-80266608 .text __dt__27JPADrawCalcAlphaFlickAddSinFv */ -JPADrawCalcAlphaFlickAddSin::~JPADrawCalcAlphaFlickAddSin() { - /* Nonmatching */ -} - -/* 80266608-80266664 .text __dt__27JPADrawCalcAlphaFlickNrmSinFv */ -JPADrawCalcAlphaFlickNrmSin::~JPADrawCalcAlphaFlickNrmSin() { - /* Nonmatching */ -} - -/* 80266664-802666C0 .text __dt__16JPADrawCalcAlphaFv */ -JPADrawCalcAlpha::~JPADrawCalcAlpha() { - /* Nonmatching */ -} - -/* 802666C0-8026671C .text __dt__31JPADrawCalcColorCopyFromEmitterFv */ -JPADrawCalcColorCopyFromEmitter::~JPADrawCalcColorCopyFromEmitter() { - /* Nonmatching */ -} - -/* 8026671C-80266778 .text __dt__33JPADrawCalcScaleAnmTimingReverseYFv */ -JPADrawCalcScaleAnmTimingReverseY::~JPADrawCalcScaleAnmTimingReverseY() { - /* Nonmatching */ -} - -/* 80266778-802667D4 .text __dt__33JPADrawCalcScaleAnmTimingReverseXFv */ -JPADrawCalcScaleAnmTimingReverseX::~JPADrawCalcScaleAnmTimingReverseX() { - /* Nonmatching */ -} - -/* 802667D4-80266830 .text __dt__32JPADrawCalcScaleAnmTimingRepeatYFv */ -JPADrawCalcScaleAnmTimingRepeatY::~JPADrawCalcScaleAnmTimingRepeatY() { - /* Nonmatching */ -} - -/* 80266830-8026688C .text __dt__32JPADrawCalcScaleAnmTimingRepeatXFv */ -JPADrawCalcScaleAnmTimingRepeatX::~JPADrawCalcScaleAnmTimingRepeatX() { - /* Nonmatching */ -} - -/* 8026688C-802668E8 .text __dt__31JPADrawCalcScaleAnmTimingNormalFv */ -JPADrawCalcScaleAnmTimingNormal::~JPADrawCalcScaleAnmTimingNormal() { - /* Nonmatching */ -} - -/* 802668E8-80266944 .text __dt__23JPADrawCalcScaleCopyX2YFv */ -JPADrawCalcScaleCopyX2Y::~JPADrawCalcScaleCopyX2Y() { - /* Nonmatching */ -} - -/* 80266944-802669A0 .text __dt__24JPADrawCalcScaleYBySpeedFv */ -JPADrawCalcScaleYBySpeed::~JPADrawCalcScaleYBySpeed() { - /* Nonmatching */ -} - -/* 802669A0-802669FC .text __dt__24JPADrawCalcScaleXBySpeedFv */ -JPADrawCalcScaleXBySpeed::~JPADrawCalcScaleXBySpeed() { - /* Nonmatching */ -} - -/* 802669FC-80266A58 .text __dt__17JPADrawCalcScaleYFv */ -JPADrawCalcScaleY::~JPADrawCalcScaleY() { - /* Nonmatching */ -} - -/* 80266A58-80266AB4 .text __dt__17JPADrawCalcScaleXFv */ -JPADrawCalcScaleX::~JPADrawCalcScaleX() { - /* Nonmatching */ -} - -/* 80266AB4-80266B30 .text __dt__19JPADrawExecCallBackFv */ -JPADrawExecCallBack::~JPADrawExecCallBack() { - /* Nonmatching */ -} - -/* 80266B30-80266B78 .text __dt__25JPADrawExecEmitterVisitorFv */ -JPADrawExecEmitterVisitor::~JPADrawExecEmitterVisitor() { - /* Nonmatching */ -} - -/* 80266B78-80266BC0 .text __dt__26JPADrawExecParticleVisitorFv */ -JPADrawExecParticleVisitor::~JPADrawExecParticleVisitor() { - /* Nonmatching */ -} - -/* 80266BC0-80266C3C .text __dt__32JPADrawCalcTextureAnmIndexRandomFv */ -JPADrawCalcTextureAnmIndexRandom::~JPADrawCalcTextureAnmIndexRandom() { - /* Nonmatching */ -} - -/* 80266C3C-80266C84 .text __dt__25JPADrawCalcEmitterVisitorFv */ -JPADrawCalcEmitterVisitor::~JPADrawCalcEmitterVisitor() { - /* Nonmatching */ -} - -/* 80266C84-80266D00 .text __dt__31JPADrawCalcTextureAnmIndexMergeFv */ -JPADrawCalcTextureAnmIndexMerge::~JPADrawCalcTextureAnmIndexMerge() { - /* Nonmatching */ -} - -/* 80266D00-80266D7C .text __dt__33JPADrawCalcTextureAnmIndexReverseFv */ -JPADrawCalcTextureAnmIndexReverse::~JPADrawCalcTextureAnmIndexReverse() { - /* Nonmatching */ -} - -/* 80266D7C-80266DF8 .text __dt__32JPADrawCalcTextureAnmIndexRepeatFv */ -JPADrawCalcTextureAnmIndexRepeat::~JPADrawCalcTextureAnmIndexRepeat() { - /* Nonmatching */ -} - -/* 80266DF8-80266E74 .text __dt__32JPADrawCalcTextureAnmIndexNormalFv */ -JPADrawCalcTextureAnmIndexNormal::~JPADrawCalcTextureAnmIndexNormal() { - /* Nonmatching */ -} - -/* 80266E74-80266EF0 .text __dt__30JPADrawCalcColorAnmFrameRandomFv */ -JPADrawCalcColorAnmFrameRandom::~JPADrawCalcColorAnmFrameRandom() { - /* Nonmatching */ -} - -/* 80266EF0-80266F6C .text __dt__29JPADrawCalcColorAnmFrameMergeFv */ -JPADrawCalcColorAnmFrameMerge::~JPADrawCalcColorAnmFrameMerge() { - /* Nonmatching */ -} - -/* 80266F6C-80266FE8 .text __dt__31JPADrawCalcColorAnmFrameReverseFv */ -JPADrawCalcColorAnmFrameReverse::~JPADrawCalcColorAnmFrameReverse() { - /* Nonmatching */ -} - -/* 80266FE8-80267064 .text __dt__30JPADrawCalcColorAnmFrameRepeatFv */ -JPADrawCalcColorAnmFrameRepeat::~JPADrawCalcColorAnmFrameRepeat() { - /* Nonmatching */ -} - -/* 80267064-802670E0 .text __dt__30JPADrawCalcColorAnmFrameNormalFv */ -JPADrawCalcColorAnmFrameNormal::~JPADrawCalcColorAnmFrameNormal() { - /* Nonmatching */ -} - -/* 802670E0-8026715C .text __dt__19JPADrawCalcColorEnvFv */ -JPADrawCalcColorEnv::~JPADrawCalcColorEnv() { - /* Nonmatching */ -} - -/* 8026715C-802671D8 .text __dt__19JPADrawCalcColorPrmFv */ -JPADrawCalcColorPrm::~JPADrawCalcColorPrm() { - /* Nonmatching */ -} - -/* 802671D8-80267234 .text __dt__31JPADrawExecRegisterColorChildPEFv */ -JPADrawExecRegisterColorChildPE::~JPADrawExecRegisterColorChildPE() { - /* Nonmatching */ -} - -/* 80267234-80267290 .text __dt__32JPADrawExecRegisterColorEmitterEFv */ -JPADrawExecRegisterColorEmitterE::~JPADrawExecRegisterColorEmitterE() { - /* Nonmatching */ -} - -/* 80267290-802672EC .text __dt__32JPADrawExecRegisterColorEmitterPFv */ -JPADrawExecRegisterColorEmitterP::~JPADrawExecRegisterColorEmitterP() { - /* Nonmatching */ -} - -/* 802672EC-80267348 .text __dt__33JPADrawExecRegisterColorEmitterPEFv */ -JPADrawExecRegisterColorEmitterPE::~JPADrawExecRegisterColorEmitterPE() { - /* Nonmatching */ -} - -/* 80267348-802673A4 .text __dt__22JPADrawExecStripeCrossFv */ -JPADrawExecStripeCross::~JPADrawExecStripeCross() { - /* Nonmatching */ -} - -/* 802673A4-80267400 .text __dt__17JPADrawExecStripeFv */ -JPADrawExecStripe::~JPADrawExecStripe() { - /* Nonmatching */ -} - -/* 80267400-8026745C .text __dt__15JPADrawExecLineFv */ -JPADrawExecLine::~JPADrawExecLine() { - /* Nonmatching */ -} - -/* 8026745C-802674B8 .text __dt__16JPADrawExecPointFv */ -JPADrawExecPoint::~JPADrawExecPoint() { - /* Nonmatching */ -} - -/* 802674B8-80267514 .text __dt__24JPADrawExecRotationCrossFv */ -JPADrawExecRotationCross::~JPADrawExecRotationCross() { - /* Nonmatching */ -} - -/* 80267514-80267570 .text __dt__19JPADrawExecRotationFv */ -JPADrawExecRotation::~JPADrawExecRotation() { - /* Nonmatching */ -} - -/* 80267570-802675CC .text __dt__23JPADrawExecDirBillBoardFv */ -JPADrawExecDirBillBoard::~JPADrawExecDirBillBoard() { - /* Nonmatching */ -} - -/* 802675CC-80267628 .text __dt__30JPADrawExecRotDirectionalCrossFv */ -JPADrawExecRotDirectionalCross::~JPADrawExecRotDirectionalCross() { - /* Nonmatching */ -} - -/* 80267628-80267684 .text __dt__27JPADrawExecDirectionalCrossFv */ -JPADrawExecDirectionalCross::~JPADrawExecDirectionalCross() { - /* Nonmatching */ -} - -/* 80267684-802676E0 .text __dt__25JPADrawExecRotDirectionalFv */ -JPADrawExecRotDirectional::~JPADrawExecRotDirectional() { - /* Nonmatching */ -} - -/* 802676E0-8026773C .text __dt__22JPADrawExecDirectionalFv */ -JPADrawExecDirectional::~JPADrawExecDirectional() { - /* Nonmatching */ -} - -/* 8026773C-80267798 .text __dt__24JPADrawExecRotYBillBoardFv */ -JPADrawExecRotYBillBoard::~JPADrawExecRotYBillBoard() { - /* Nonmatching */ -} - -/* 80267798-802677F4 .text __dt__21JPADrawExecYBillBoardFv */ -JPADrawExecYBillBoard::~JPADrawExecYBillBoard() { - /* Nonmatching */ -} - -/* 802677F4-80267850 .text __dt__23JPADrawExecRotBillBoardFv */ -JPADrawExecRotBillBoard::~JPADrawExecRotBillBoard() { - /* Nonmatching */ -} - -/* 80267850-802678AC .text __dt__20JPADrawExecBillBoardFv */ -JPADrawExecBillBoard::~JPADrawExecBillBoard() { - /* Nonmatching */ -} - -/* 802678AC-80267908 .text __dt__26JPADrawExecRegisterPrmAEnvFv */ -JPADrawExecRegisterPrmAEnv::~JPADrawExecRegisterPrmAEnv() { - /* Nonmatching */ -} - -/* 80267908-80267964 .text __dt__26JPADrawExecRegisterPrmCEnvFv */ -JPADrawExecRegisterPrmCEnv::~JPADrawExecRegisterPrmCEnv() { - /* Nonmatching */ -} - -/* 80267964-802679C0 .text __dt__30JPADrawExecRegisterEnvColorAnmFv */ -JPADrawExecRegisterEnvColorAnm::~JPADrawExecRegisterEnvColorAnm() { - /* Nonmatching */ -} - -/* 802679C0-80267A1C .text __dt__30JPADrawExecRegisterPrmAlphaAnmFv */ -JPADrawExecRegisterPrmAlphaAnm::~JPADrawExecRegisterPrmAlphaAnm() { - /* Nonmatching */ -} - -/* 80267A1C-80267A78 .text __dt__30JPADrawExecRegisterPrmColorAnmFv */ -JPADrawExecRegisterPrmColorAnm::~JPADrawExecRegisterPrmColorAnm() { - /* Nonmatching */ -} - -/* 80267A78-80267AD4 .text __dt__23JPADrawExecSetLineWidthFv */ -JPADrawExecSetLineWidth::~JPADrawExecSetLineWidth() { - /* Nonmatching */ -} - -/* 80267AD4-80267B30 .text __dt__23JPADrawExecSetPointSizeFv */ -JPADrawExecSetPointSize::~JPADrawExecSetPointSize() { - /* Nonmatching */ -} - -/* 80267B30-80267BAC .text __dt__22JPADrawExecLoadTextureFv */ -JPADrawExecLoadTexture::~JPADrawExecLoadTexture() { - /* Nonmatching */ -} - -/* 80267BAC-80267C08 .text __dt__29JPADrawExecLoadDefaultTextureFv */ -JPADrawExecLoadDefaultTexture::~JPADrawExecLoadDefaultTexture() { - /* Nonmatching */ -} - -/* 80267C08-80267C84 .text __dt__20JPADrawExecSetTexMtxFv */ -JPADrawExecSetTexMtx::~JPADrawExecSetTexMtx() { - /* Nonmatching */ -} - -/* 80267C84-80267CE0 .text __dt__20JPADrawExecGenIdtMtxFv */ -JPADrawExecGenIdtMtx::~JPADrawExecGenIdtMtx() { - /* Nonmatching */ -} - -/* 80267CE0-80267D3C .text __dt__21JPADrawExecGenTexMtx0Fv */ -JPADrawExecGenTexMtx0::~JPADrawExecGenTexMtx0() { - /* Nonmatching */ -} - -/* 80267D3C-80267D98 .text __dt__23JPADrawExecGenPrjTexMtxFv */ -JPADrawExecGenPrjTexMtx::~JPADrawExecGenPrjTexMtx() { - /* Nonmatching */ -} - -/* 80267D98-80267DF4 .text __dt__20JPADrawExecGenPrjMtxFv */ -JPADrawExecGenPrjMtx::~JPADrawExecGenPrjMtx() { - /* Nonmatching */ -} - -/* 80267DF4-80267E50 .text __dt__20JPADrawExecLoadExTexFv */ -JPADrawExecLoadExTex::~JPADrawExecLoadExTex() { - /* Nonmatching */ -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -