mirror/ss
1
0
Fork 0
mirror of https://github.com/zeldaret/ss synced 2026-09-01 09:32:58 -04:00
Code Issues Packages Projects Releases Wiki Activity

Initial import of JParticle + JSUList from TP

Browse Source
This commit is contained in:
robojumper
2025-04-27 07:13:47 +02:00
parent 5df26c52fc
commit c1a0264e6a
43 changed files with 7711 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/JSystem/JParticle/JPABaseShape.h
+210
View File
@@ -0,0 +1,210 @@
#ifndef JPABASESHAPE_H
#define JPABASESHAPE_H
#include <dolphin/gx.h>
class JPAEmitterWorkData;
class JPABaseParticle;
class JKRHeap;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPABaseShapeData {
// Common header.
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ s16 mClrPrmAnmOffset;
/* 0x0E */ s16 mClrEnvAnmOffset;
/* 0x10 */ f32 mBaseSizeX;
/* 0x14 */ f32 mBaseSizeY;
/* 0x18 */ u16 mBlendModeCfg;
/* 0x1A */ u8 mAlphaCompareCfg;
/* 0x1B */ u8 mAlphaRef0;
/* 0x1C */ u8 mAlphaRef1;
/* 0x1D */ u8 mZModeCfg;
/* 0x1E */ u8 mTexFlg;
/* 0x1F */ u8 mTexAnmNum;
/* 0x20 */ u8 mTexIdx;
/* 0x21 */ u8 mClrFlg;
/* 0x22 */ u8 mClrPrmKeyNum;
/* 0x23 */ u8 mClrEnvKeyNum;
/* 0x24 */ s16 mClrAnmFrmMax;
/* 0x26 */ GXColor mClrPrm;
/* 0x2A */ GXColor mClrEnv;
/* 0x2E */ u8 mAnmRndm;
/* 0x2F */ u8 mClrAnmRndmMask;
/* 0x30 */ u8 mTexAnmRndmMask;
};
/**
* @ingroup jsystem-jparticle
*
*/
struct JPABaseShape {
public:
/* 8027A6DC */ JPABaseShape(u8 const*, JKRHeap*);
/* 8027A7E8 */ void setGX(JPAEmitterWorkData*) const;
static GXBlendMode st_bm[3];
static GXBlendFactor st_bf[10];
static GXLogicOp st_lo[16];
static GXCompare st_c[8];
static GXAlphaOp st_ao[4];
static GXTevColorArg st_ca[6][4];
static GXTevAlphaArg st_aa[2][4];
GXBlendMode getBlendMode() const { return st_bm[mpData->mBlendModeCfg & 0x03]; }
GXBlendFactor getBlendSrc() const { return st_bf[(mpData->mBlendModeCfg >> 2) & 0x0F]; }
GXBlendFactor getBlendDst() const { return st_bf[(mpData->mBlendModeCfg >> 6) & 0x0F]; }
GXLogicOp getLogicOp() const { return st_lo[(mpData->mBlendModeCfg >> 10) & 0x0F]; }
GXBool getZCompLoc() const { return (GXBool)((mpData->mZModeCfg >> 5) & 0x01); }
GXBool getZEnable() const { return (GXBool)(mpData->mZModeCfg & 0x01); }
GXCompare getZCmp() const { return st_c[(mpData->mZModeCfg >> 1) & 0x07]; }
GXBool getZUpd() const { return (GXBool)((mpData->mZModeCfg >> 4) & 0x01); }
GXCompare getAlphaCmp0() const { return st_c[mpData->mAlphaCompareCfg & 0x07]; }
u8 getAlphaRef0() const { return mpData->mAlphaRef0; }
GXAlphaOp getAlphaOp() const { return st_ao[(mpData->mAlphaCompareCfg >> 3) & 0x03]; }
GXCompare getAlphaCmp1() const { return st_c[(mpData->mAlphaCompareCfg >> 5) & 0x07]; }
u8 getAlphaRef1() const { return mpData->mAlphaRef1; }
const GXTevColorArg* getTevColorArg() const { return st_ca[(mpData->mFlags >> 0x0F) & 0x07]; }
const GXTevAlphaArg* getTevAlphaArg() const { return st_aa[(mpData->mFlags >> 0x12) & 0x01]; }
u32 getType() const { return (mpData->mFlags >> 0) & 0x0F; }
u32 getDirType() const { return (mpData->mFlags >> 4) & 0x07; }
u32 getRotType() const { return (mpData->mFlags >> 7) & 0x07; }
u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 0x01; }
u32 getTilingS() const { return (mpData->mFlags >> 25) & 0x01; }
u32 getTilingT() const { return (mpData->mFlags >> 26) & 0x01; }
BOOL isGlblClrAnm() const { return mpData->mFlags & 0x00001000; }
BOOL isGlblTexAnm() const { return mpData->mFlags & 0x00004000; }
BOOL isPrjTex() const { return mpData->mFlags & 0x00100000; }
bool isDrawFwdAhead() const { return !!(mpData->mFlags & 0x00200000); }
bool isDrawPrntAhead() const { return !!(mpData->mFlags & 0x00400000); }
bool isClipOn() const { return !!(mpData->mFlags & 0x00800000); }
BOOL isTexCrdAnm() const { return mpData->mFlags & 0x01000000; }
bool isNoDrawParent() const { return !!(mpData->mFlags & 0x08000000); }
bool isNoDrawChild() const { return !!(mpData->mFlags & 0x10000000); }
BOOL isPrmAnm() const { return mpData->mClrFlg & 0x02; }
BOOL isEnvAnm() const { return mpData->mClrFlg & 0x08; }
u8 getClrAnmType() const { return (mpData->mClrFlg >> 4) & 0x07; }
s16 getClrAnmMaxFrm() const { return mpData->mClrAnmFrmMax; }
void getPrmClr(GXColor* dst) { *dst = mpData->mClrPrm; }
void getPrmClr(s16 idx, GXColor* dst) { *dst = mpPrmClrAnmTbl[idx]; }
void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; }
void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; }
BOOL isTexAnm() const { return mpData->mTexFlg & 0x01; }
u8 getTexAnmType() const { return (mpData->mTexFlg >> 2) & 0x07; }
u32 getTexIdx() const { return mpData->mTexIdx; }
u8 getTexIdx(u8 idx) const { return mpTexIdxAnimTbl[idx]; }
f32 getBaseSizeX() const { return mpData->mBaseSizeX; }
f32 getBaseSizeY() const { return mpData->mBaseSizeY; }
u8 getClrLoopOfstMask() const { return mpData->mClrAnmRndmMask; }
u32 getClrLoopOfst(u32 param_1) const { return getClrLoopOfstMask() & param_1; }
u8 getTexLoopOfstMask() const { return mpData->mTexAnmRndmMask; }
u32 getTexLoopOfst(u8 param_1) const { return getTexLoopOfstMask() & param_1; }
u8 getLoopOfstValue() const { return mpData->mAnmRndm; }
f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; }
f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; }
f32 getIncTransY() const { return ((f32*)mpTexCrdMtxAnmTbl)[6]; }
f32 getInitTransY() const { return ((f32*)mpTexCrdMtxAnmTbl)[1]; }
f32 getIncScaleX() const { return ((f32*)mpTexCrdMtxAnmTbl)[7]; }
f32 getInitScaleX() const { return ((f32*)mpTexCrdMtxAnmTbl)[2]; }
f32 getIncScaleY() const { return ((f32*)mpTexCrdMtxAnmTbl)[8]; }
f32 getInitScaleY() const { return ((f32*)mpTexCrdMtxAnmTbl)[3]; }
f32 getIncRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[9]; }
f32 getInitRot() const { return ((f32*)mpTexCrdMtxAnmTbl)[4]; }
u8 getTexAnmKeyNum() const { return mpData->mTexAnmNum; }
public:
/* 0x00 */ const JPABaseShapeData* mpData;
/* 0x04 */ const void* mpTexCrdMtxAnmTbl;
/* 0x08 */ const u8* mpTexIdxAnimTbl;
/* 0x0C */ GXColor* mpPrmClrAnmTbl;
/* 0x10 */ GXColor* mpEnvClrAnmTbl;
};
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAClrAnmKeyData {
/* 0x0 */ s16 index;
/* 0x2 */ GXColor color;
};
void JPACalcTexIdxNormal(JPAEmitterWorkData*);
void JPACalcTexIdxRepeat(JPAEmitterWorkData*);
void JPACalcTexIdxReverse(JPAEmitterWorkData*);
void JPACalcTexIdxMerge(JPAEmitterWorkData*);
void JPACalcTexIdxRandom(JPAEmitterWorkData*);
void JPACalcPrm(JPAEmitterWorkData*);
void JPACalcEnv(JPAEmitterWorkData*);
void JPACalcClrIdxNormal(JPAEmitterWorkData*);
void JPACalcClrIdxRepeat(JPAEmitterWorkData*);
void JPACalcClrIdxReverse(JPAEmitterWorkData*);
void JPACalcClrIdxMerge(JPAEmitterWorkData*);
void JPACalcClrIdxRandom(JPAEmitterWorkData*);
void JPACalcTexIdxNormal(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcTexIdxRepeat(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcTexIdxReverse(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcTexIdxMerge(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcTexIdxRandom(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcPrm(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcEnv(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcClrIdxNormal(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcClrIdxRepeat(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcClrIdxReverse(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcClrIdxMerge(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcClrIdxRandom(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcColorCopy(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawStripe(JPAEmitterWorkData*);
void JPADrawStripeX(JPAEmitterWorkData*);
void JPADrawEmitterCallBackB(JPAEmitterWorkData*);
void JPALoadTex(JPAEmitterWorkData*);
void JPALoadTexAnm(JPAEmitterWorkData*);
void JPAGenTexCrdMtxIdt(JPAEmitterWorkData*);
void JPAGenCalcTexCrdMtxAnm(JPAEmitterWorkData*);
void JPAGenTexCrdMtxAnm(JPAEmitterWorkData*);
void JPAGenTexCrdMtxPrj(JPAEmitterWorkData*);
void JPALoadPosMtxCam(JPAEmitterWorkData*);
void JPASetLineWidth(JPAEmitterWorkData*);
void JPASetPointSize(JPAEmitterWorkData*);
void JPARegistPrm(JPAEmitterWorkData*);
void JPARegistEnv(JPAEmitterWorkData*);
void JPARegistPrmEnv(JPAEmitterWorkData*);
void JPADrawPoint(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawLine(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawRotBillboard(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawBillboard(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawRotDirection(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawDirection(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawRotation(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawDBillboard(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawRotYBillboard(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawYBillboard(JPAEmitterWorkData*, JPABaseParticle*);
void JPADrawParticleCallBack(JPAEmitterWorkData*, JPABaseParticle*);
void JPALoadTexAnm(JPAEmitterWorkData*, JPABaseParticle*);
void JPASetPointSize(JPAEmitterWorkData*, JPABaseParticle*);
void JPASetLineWidth(JPAEmitterWorkData*, JPABaseParticle*);
void JPALoadCalcTexCrdMtxAnm(JPAEmitterWorkData*, JPABaseParticle*);
void JPARegistAlpha(JPAEmitterWorkData*, JPABaseParticle*);
void JPARegistEnv(JPAEmitterWorkData*, JPABaseParticle*);
void JPARegistAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);
void JPARegistPrmAlpha(JPAEmitterWorkData*, JPABaseParticle*);
void JPARegistPrmAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);
#endif /* JPABASESHAPE_H */
include/JSystem/JParticle/JPAChildShape.h
+89
View File
@@ -0,0 +1,89 @@
#ifndef JPACHILDSHAPE_H
#define JPACHILDSHAPE_H
#include <dolphin/gx.h>
class JPAEmitterWorkData;
class JPABaseParticle;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAChildShapeData {
// Common header.
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ f32 mPosRndm;
/* 0x10 */ f32 mBaseVel;
/* 0x14 */ f32 mBaseVelRndm;
/* 0x18 */ f32 mVelInfRate;
/* 0x1C */ f32 mGravity;
/* 0x20 */ f32 mScaleX;
/* 0x24 */ f32 mScaleY;
/* 0x28 */ f32 mInheritScale;
/* 0x2C */ f32 mInheritAlpha;
/* 0x30 */ f32 mInheritRGB;
/* 0x34 */ GXColor mPrmClr;
/* 0x38 */ GXColor mEnvClr;
/* 0x3C */ f32 mTiming;
/* 0x40 */ s16 mLife;
/* 0x42 */ s16 mRate;
/* 0x44 */ u8 mStep;
/* 0x45 */ u8 mTexIdx;
/* 0x46 */ s16 mRotSpeed;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPAChildShape {
public:
/* 8027B038 */ JPAChildShape(u8 const*);
f32 getPosRndm() const { return mpData->mPosRndm; }
f32 getBaseVel() const { return mpData->mBaseVel; }
f32 getBaseVelRndm() const { return mpData->mBaseVelRndm; }
f32 getVelInhRate() const { return mpData->mVelInfRate; }
f32 getGravity() const { return mpData->mGravity; }
f32 getScaleX() const { return mpData->mScaleX; }
f32 getScaleY() const { return mpData->mScaleY; }
f32 getScaleInhRate() const { return mpData->mInheritScale; }
f32 getAlphaInhRate() const { return mpData->mInheritAlpha; }
f32 getColorInhRate() const { return mpData->mInheritRGB; }
void getPrmClr(GXColor* dst) const { *dst = mpData->mPrmClr; }
u8 getPrmAlpha() const { return mpData->mPrmClr.a; }
void getEnvClr(GXColor* dst) const { *dst = mpData->mEnvClr; }
f32 getTiming() const { return mpData->mTiming; }
s16 getLife() const { return mpData->mLife; }
s16 getRate() const { return mpData->mRate; }
u8 getStep() const { return mpData->mStep; }
u8 getTexIdx() const { return mpData->mTexIdx; }
s16 getRotInitSpeed() const { return mpData->mRotSpeed; }
u32 getType() const { return mpData->mFlags & 0xF; }
u32 getDirType() const { return (mpData->mFlags >> 4) & 7; }
u32 getRotType() const { return (mpData->mFlags >> 7) & 7; }
u32 getBasePlaneType() const { return (mpData->mFlags >> 10) & 1; }
BOOL isScaleInherited() const { return mpData->mFlags & 0x10000; }
BOOL isAlphaInherited() const { return mpData->mFlags & 0x20000; }
BOOL isColorInherited() const { return mpData->mFlags & 0x40000; }
BOOL isClipOn() const { return mpData->mFlags & 0x100000; }
BOOL isFieldAffected() const { return mpData->mFlags & 0x200000; }
BOOL isScaleOutOn() const { return mpData->mFlags & 0x400000; }
BOOL isAlphaOutOn() const { return mpData->mFlags & 0x800000; }
BOOL isRotateOn() const { return mpData->mFlags & 0x1000000; }
public:
/* 0x00 */ const JPAChildShapeData* mpData;
};
void JPARegistChildPrmEnv(JPAEmitterWorkData*);
void JPACalcChildAlphaOut(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcChildScaleOut(JPAEmitterWorkData*, JPABaseParticle*);
#endif /* JPACHILDSHAPE_H */
include/JSystem/JParticle/JPADrawInfo.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef JPADRAWINFO_H
#define JPADRAWINFO_H
#include "dolphin/mtx.h"
/**
* @ingroup jsystem-jparticle
*
*/
class JPADrawInfo {
public:
JPADrawInfo(Mtx param_0, f32 fovY, f32 aspect) {
MTXCopy(param_0, mCamMtx);
C_MTXLightPerspective(mPrjMtx, fovY, aspect, 0.5f, -0.5f, 0.5f, 0.5f);
}
JPADrawInfo(Mtx param_0, f32 top, f32 bottom, f32 left, f32 right) {
MTXCopy(param_0, mCamMtx);
C_MTXLightOrtho(mPrjMtx, top, bottom, left, right, 0.5f, 0.5f, 0.5f, 0.5f);
}
Mtx mCamMtx;
Mtx mPrjMtx;
void getCamMtx(Mtx dst) const { MTXCopy(mCamMtx, dst); }
void getPrjMtx(Mtx dst) const { MTXCopy(mPrjMtx, dst); }
};
#endif
include/JSystem/JParticle/JPADynamicsBlock.h
+109
View File
@@ -0,0 +1,109 @@
#ifndef JPADYNAMICSBLOCK_H
#define JPADYNAMICSBLOCK_H
#include "JSystem/JGeometry.h"
#include "dolphin/types.h"
class JPAEmitterWorkData;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPADynamicsBlockData {
// Common header.
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ u32 mResUserWork;
/* 0x10 */ JGeometry::TVec3<f32> mEmitterScl;
/* 0x1C */ JGeometry::TVec3<f32> mEmitterTrs;
/* 0x28 */ JGeometry::TVec3<f32> mEmitterDir;
/* 0x34 */ f32 mInitialVelOmni;
/* 0x38 */ f32 mInitialVelAxis;
/* 0x3C */ f32 mInitialVelRndm;
/* 0x40 */ f32 mInitialVelDir;
/* 0x44 */ f32 mSpread;
/* 0x48 */ f32 mInitialVelRatio;
/* 0x4C */ f32 mRate;
/* 0x50 */ f32 mRateRndm;
/* 0x54 */ f32 mLifeTimeRndm;
/* 0x58 */ f32 mVolumeSweep;
/* 0x5C */ f32 mVolumeMinRad;
/* 0x60 */ f32 mAirResist;
/* 0x64 */ f32 mMoment;
/* 0x68 */ JGeometry::TVec3<s16> mEmitterRot;
/* 0x6E */ s16 mMaxFrame;
/* 0x70 */ s16 mStartFrame;
/* 0x72 */ s16 mLifeTime;
/* 0x74 */ u16 mVolumeSize;
/* 0x76 */ u16 mDivNumber;
/* 0x78 */ u8 mRateStep;
/* 0x7C */ u32 field_0x7c;
};
typedef void (*JPADynamicsCalcVolumeFunc)(JPAEmitterWorkData*);
enum {
JPADynFlag_FixedDensity = 0x01,
JPADynFlag_FixedInterval = 0x02,
JPADynFlag_InheritScale = 0x04,
JPADynFlag_FollowEmtr = 0x08,
JPADynFlag_FollowEmtrChld = 0x10,
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPADynamicsBlock {
public:
/* 8027BB18 */ JPADynamicsBlock(u8 const*);
/* 8027BB4C */ void init();
/* 8027BBE8 */ void create(JPAEmitterWorkData*);
void calc(JPAEmitterWorkData* work) { mpCalcVolumeFunc(work); }
s16 getStartFrame() const { return mpData->mStartFrame; }
u32 getResUserWork() const { return mpData->mResUserWork; }
u32 getFlag() const { return mpData->mFlags; }
u32 getVolumeType() const { return (mpData->mFlags >> 8) & 0x07; }
u16 getDivNumber() const { return mpData->mDivNumber; }
f32 getRateRndm() const { return mpData->mRateRndm; }
void getEmitterScl(JGeometry::TVec3<f32>* vec) const {
vec->set(mpData->mEmitterScl.x, mpData->mEmitterScl.y, mpData->mEmitterScl.z);
}
void getEmitterTrs(JGeometry::TVec3<f32>* vec) const {
vec->set(mpData->mEmitterTrs.x, mpData->mEmitterTrs.y, mpData->mEmitterTrs.z);
}
void getEmitterDir(JGeometry::TVec3<f32>* vec) const {
vec->set(mpData->mEmitterDir.x, mpData->mEmitterDir.y, mpData->mEmitterDir.z);
}
void getEmitterRot(JGeometry::TVec3<s16>* vec) const {
vec->set(mpData->mEmitterRot.x, mpData->mEmitterRot.y, mpData->mEmitterRot.z);
}
s16 getMaxFrame() { return mpData->mMaxFrame; }
s16 getLifetime() { return mpData->mLifeTime; }
u16 getVolumeSize() { return mpData->mVolumeSize; }
f32 getRate() { return mpData->mRate; }
u8 getRateStep() { return mpData->mRateStep; }
f32 getVolumeSweep() { return mpData->mVolumeSweep; }
f32 getVolumeMinRad() { return mpData->mVolumeMinRad; }
f32 getInitVelOmni() { return mpData->mInitialVelOmni; }
f32 getInitVelAxis() { return mpData->mInitialVelAxis; }
f32 getInitVelDir() { return mpData->mInitialVelDir; }
f32 getInitVelDirSp() { return mpData->mSpread; }
f32 getInitVelRndm() { return mpData->mInitialVelRndm; }
f32 getInitVelRatio() const { return mpData->mInitialVelRatio; }
f32 getAirRes() { return mpData->mAirResist; }
f32 getLifetimeRndm() const { return mpData->mLifeTimeRndm; }
f32 getMomentRndm() const { return mpData->mMoment; }
public:
/* 0x00 */ const JPADynamicsBlockData* mpData;
/* 0x04 */ JPADynamicsCalcVolumeFunc mpCalcVolumeFunc;
};
#endif /* JPADYNAMICSBLOCK_H */
include/JSystem/JParticle/JPAEmitter.h
+272
View File
@@ -0,0 +1,272 @@
#ifndef JPAEMITTER_H
#define JPAEMITTER_H
#include <dolphin/gx.h>
#include "JSystem/JParticle/JPAResource.h"
#include "JSystem/JParticle/JPAList.h"
#include "JSystem/JParticle/JPARandom.h"
#include "JSystem/JParticle/JPAMath.h"
#include "JSystem/JParticle/JPADynamicsBlock.h"
#include "JSystem/JSupport/JSUList.h"
class JPAResourceManager;
class JPABaseEmitter;
class JPAEmitterManager;
class JPAParticleCallBack;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAEmitterWorkData {
struct JPAVolumeCalcData {
/* 0x00 */ JGeometry::TVec3<f32> mVolumePos;
/* 0x0C */ JGeometry::TVec3<f32> mVelOmni;
/* 0x18 */ JGeometry::TVec3<f32> mVelAxis;
};
JPAEmitterWorkData() : mRndm(0) {}
/* 0x00 */ JPABaseEmitter* mpEmtr;
/* 0x04 */ JPAResource* mpRes;
/* 0x08 */ JPAResourceManager* mpResMgr;
/* 0x0C */ JPARandom mRndm;
/* 0x10 */ JPAVolumeCalcData mVolumeCalcData;
/* 0x34 */ f32 mVolumeSize;
/* 0x38 */ f32 mVolumeMinRad;
/* 0x3C */ f32 mVolumeSweep;
/* 0x40 */ s32 mEmitCount;
/* 0x44 */ s32 mVolumeEmitIdx;
/* 0x48 */ Mtx mDirectionMtx;
/* 0x78 */ Mtx mRotationMtx;
/* 0xA8 */ Mtx mGlobalRot;
/* 0xD8 */ Mtx mGlobalSR;
/* 0x108 */ JGeometry::TVec3<f32> mEmitterPos;
/* 0x114 */ JGeometry::TVec3<f32> mGlobalScl;
/* 0x120 */ JGeometry::TVec3<f32> mGlobalEmtrDir;
/* 0x12C */ JGeometry::TVec3<f32> mPublicScale;
/* 0x138 */ JGeometry::TVec3<f32> mGlobalPos;
/* 0x144 */ JGeometry::TVec2<f32> mGlobalPtclScl;
/* 0x14C */ JGeometry::TVec2<f32> mPivot;
/* 0x154 */ Mtx mYBBCamMtx;
/* 0x184 */ Mtx mPosCamMtx;
/* 0x1B4 */ Mtx mPrjMtx;
/* 0x1E4 */ JPAList<JPABaseParticle>* mpAlivePtcl;
/* 0x1E8 */ JPANode<JPABaseParticle>* mpCurNode;
/* 0x1EC */ s32 mVolumeAngleNum;
/* 0x1F0 */ s32 mVolumeAngleMax;
/* 0x1F4 */ s32 mVolumeX;
/* 0x1F8 */ s32 mDivNumber;
/* 0x1FC */ f32 mScaleAnm;
/* 0x200 */ u32 mDirType;
/* 0x204 */ u32 mRotType;
/* 0x208 */ u32 mPlaneType;
/* 0x20C */ u32 mDLType;
/* 0x210 */ u32 mPrjType;
/* 0x214 */ s16 mClrKeyFrame;
/* 0x216 */ u8 mDrawCount;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPAEmitterCallBack {
public:
virtual ~JPAEmitterCallBack() = 0;
/* 80050368 */ virtual void execute(JPABaseEmitter*) {}
/* 80050374 */ virtual void executeAfter(JPABaseEmitter*) {}
/* 8005036C */ virtual void draw(JPABaseEmitter*) {}
/* 80050370 */ virtual void drawAfter(JPABaseEmitter*) {}
/* 8027E6A4 */ //~JPAEmitterCallBack();
};
enum {
JPAEmtrStts_StopEmit = 0x01,
JPAEmtrStts_StopCalc = 0x02,
JPAEmtrStts_StopDraw = 0x04,
JPAEmtrStts_EnableDeleteEmitter = 0x08,
JPAEmtrStts_FirstEmit = 0x10,
JPAEmtrStts_RateStepEmit = 0x20,
JPAEmtrStts_Immortal = 0x40,
JPAEmtrStts_Delete = 0x100,
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPABaseEmitter {
public:
/* 8027E5EC */ ~JPABaseEmitter() {}
/* 8027E64C */ JPABaseEmitter() : mLink(this), mRndm(0) {}
/* 8027E6EC */ void init(JPAEmitterManager*, JPAResource*);
/* 8027EDD4 */ bool processTillStartFrame();
/* 8027EE14 */ bool processTermination();
/* 8027EEB0 */ void calcEmitterGlobalPosition(JGeometry::TVec3<f32>*) const;
/* 8027EC60 */ void deleteAllParticle();
/* 8027EB60 */ JPABaseParticle* createChild(JPABaseParticle*);
/* 8027EA40 */ JPABaseParticle* createParticle();
/* 8027EF30 */ u32 getCurrentCreateNumber() const;
/* 8027EF40 */ u8 getDrawCount() const;
/* 8027EF50 */ bool loadTexture(u8, GXTexMapID);
void initStatus(u32 status) { mStatus = status; }
void setStatus(u32 status) { mStatus |= status; }
void clearStatus(u32 status) { mStatus &= ~status; }
u32 checkStatus(u32 status) const { return (mStatus & status); }
bool checkFlag(u32 flag) const { return !!(mpRes->getDyn()->getFlag() & flag); }
u8 getResourceManagerID() const { return mResMgrID; }
u8 getGroupID() const { return mGroupID; }
u8 getDrawTimes() const { return mDrawTimes; }
void setRate(f32 rate) { mRate = rate; }
void setDirectionalSpeed(f32 i_speed) { mDirSpeed = i_speed; }
void setRandomDirectionSpeed(f32 i_speed) { mRndmDirSpeed = i_speed; }
void setEmitterCallBackPtr(JPAEmitterCallBack* ptr) { mpEmtrCallBack = ptr; }
void setGlobalRTMatrix(const Mtx m) { JPASetRMtxTVecfromMtx(m, mGlobalRot, &mGlobalTrs); }
void setGlobalSRTMatrix(const Mtx m) {
JPASetRMtxSTVecfromMtx(m, mGlobalRot, &mGlobalScl, &mGlobalTrs);
// set is actually used here in debug
mGlobalPScl.x = mGlobalScl.x;
mGlobalPScl.y = mGlobalScl.y;
}
void setGlobalTranslation(f32 x, f32 y, f32 z) { mGlobalTrs.set(x, y, z); }
void setGlobalTranslation(const JGeometry::TVec3<f32>& trs) { mGlobalTrs.set(trs); }
void getLocalTranslation(JGeometry::TVec3<f32>& vec) { vec.set(mLocalTrs); }
void setGlobalRotation(const JGeometry::TVec3<s16>& rot) {
JPAGetXYZRotateMtx(rot.x, rot.y, rot.z, mGlobalRot);
}
void getGlobalTranslation(JGeometry::TVec3<f32>* out) const { out->set(mGlobalTrs); }
void setGlobalDynamicsScale(const JGeometry::TVec3<f32>& i_scale) { mGlobalScl.set(i_scale); }
void setGlobalAlpha(u8 alpha) { mGlobalPrmClr.a = alpha; }
u8 getGlobalAlpha() { return mGlobalPrmClr.a; }
void getGlobalPrmColor(GXColor& color) { color = mGlobalPrmClr; }
void setGlobalPrmColor(u8 r, u8 g, u8 b) { mGlobalPrmClr.r = r; mGlobalPrmClr.g = g; mGlobalPrmClr.b = b; }
void setGlobalEnvColor(u8 r, u8 g, u8 b) { mGlobalEnvClr.r = r; mGlobalEnvClr.g = g; mGlobalEnvClr.b = b; }
void setVolumeSize(u16 size) { mVolumeSize = size; }
void setLifeTime(s16 lifetime) { mLifeTime = lifetime; }
void setAwayFromCenterSpeed(f32 i_speed) { mAwayFromCenterSpeed = i_speed; }
void setAwayFromAxisSpeed(f32 i_speed) { mAwayFromAxisSpeed = i_speed; }
void setSpread(f32 i_spread) { mSpread = i_spread; }
void setLocalTranslation(const JGeometry::TVec3<f32>& i_trans) { mLocalTrs.set(i_trans); }
void setLocalRotation(const JGeometry::TVec3<s16>& i_rot) { mLocalRot.set(i_rot.x * 0.005493248f, i_rot.y * 0.005493248f, i_rot.z * 0.005493248f); }
void setRateStep(u8 i_step) { mRateStep = i_step; }
void setGlobalParticleHeightScale(f32 height) {
mGlobalPScl.y = height;
}
void setGlobalParticleScale(const JGeometry::TVec3<f32>& scale) {
mGlobalPScl.set(scale.x, scale.y);
}
void setGlobalParticleScale(f32 scaleX, f32 scaleY) {
mGlobalPScl.set(scaleX, scaleY);
}
void getGlobalParticleScale(JGeometry::TVec3<f32>& scale) {
scale.set(mGlobalPScl.x, mGlobalPScl.y, 1.0f);
}
void setGlobalScale(const JGeometry::TVec3<f32>& scale) {
mGlobalScl.set(scale);
mGlobalPScl.set(scale.x ,scale.y);
}
void setGlobalSRTMatrix(const MtxP matrix) {
JPASetRMtxSTVecfromMtx(matrix, mGlobalRot, &mGlobalScl, &mGlobalTrs);
mGlobalPScl.set(mGlobalScl.x, mGlobalScl.y);
}
void setDirection(const JGeometry::TVec3<f32>& direction) {
mLocalDir.set(direction);
}
void setLocalScale(const JGeometry::TVec3<f32>& scale) {
mLocalScl.set(scale);
}
f32 get_r_f() { return mRndm.get_rndm_f(); }
f32 get_r_zp() { return mRndm.get_rndm_zp(); }
f32 get_r_zh() { return mRndm.get_rndm_zh(); }
s16 get_r_ss() { return mRndm.get_rndm_ss(); }
void stopCreateParticle() { setStatus(JPAEmtrStts_StopEmit); }
void playCreateParticle() { clearStatus(JPAEmtrStts_StopEmit); }
void becomeImmortalEmitter() { setStatus(JPAEmtrStts_Immortal); }
void becomeContinuousParticle() { mMaxFrame = 0; }
void becomeDeleteEmitter() { setStatus(JPAEmtrStts_Delete); }
void becomeInvalidEmitter() {
stopCreateParticle();
mMaxFrame = 1;
}
void quitImmortalEmitter() { clearStatus(JPAEmtrStts_Immortal); }
void stopCalcEmitter() { setStatus(JPAEmtrStts_StopCalc); }
void playCalcEmitter() { clearStatus(JPAEmtrStts_StopCalc); }
void stopDrawParticle() { setStatus(JPAEmtrStts_StopDraw); }
void playDrawParticle() { clearStatus(JPAEmtrStts_StopDraw); }
u32 getUserWork() { return mpUserWork; }
void setUserWork(u32 userWork) { mpUserWork = userWork; }
u32 getParticleNumber() {
return mAlivePtclBase.getNum() + mAlivePtclChld.getNum();
}
bool isEnableDeleteEmitter() {
return checkStatus(JPAEmtrStts_EnableDeleteEmitter) && getParticleNumber() == 0;
}
void setDrawTimes(u8 drawTimes) { mDrawTimes = drawTimes; }
void setParticleCallBackPtr(JPAParticleCallBack* cb) { mpPtclCallBack = cb; }
JPAParticleCallBack* getParticleCallBackPtr() { return mpPtclCallBack; }
JPAEmitterCallBack* getEmitterCallBackPtr() const { return mpEmtrCallBack; }
u32 getAge() const { return mTick; }
public:
/* 0x00 */ JGeometry::TVec3<f32> mLocalScl;
/* 0x0C */ JGeometry::TVec3<f32> mLocalTrs;
/* 0x18 */ JGeometry::TVec3<f32> mLocalDir;
/* 0x24 */ s32 mMaxFrame;
/* 0x28 */ f32 mRate;
/* 0x2C */ f32 mVolumeSweep;
/* 0x30 */ f32 mVolumeMinRad;
/* 0x34 */ f32 mAwayFromCenterSpeed;
/* 0x38 */ f32 mAwayFromAxisSpeed;
/* 0x3C */ f32 mDirSpeed;
/* 0x40 */ f32 mSpread;
/* 0x44 */ f32 mRndmDirSpeed;
/* 0x48 */ f32 mAirResist;
/* 0x4C */ JGeometry::TVec3<s16> mLocalRot;
/* 0x52 */ s16 mLifeTime;
/* 0x54 */ u16 mVolumeSize;
/* 0x56 */ u8 mRateStep;
/* 0x58 */ JSULink<JPABaseEmitter> mLink;
/* 0x68 */ Mtx mGlobalRot;
/* 0x98 */ JGeometry::TVec3<f32> mGlobalScl;
/* 0xA4 */ JGeometry::TVec3<f32> mGlobalTrs;
/* 0xB0 */ JGeometry::TVec2<f32> mGlobalPScl;
/* 0xB8 */ GXColor mGlobalPrmClr;
/* 0xBC */ GXColor mGlobalEnvClr;
/* 0xC0 */ s32 mpUserWork;
/* 0xC4 */ JPARandom mRndm;
/* 0xC8 */ JPAList<JPABaseParticle> mAlivePtclBase;
/* 0xD4 */ JPAList<JPABaseParticle> mAlivePtclChld;
/* 0xE0 */ JPAList<JPABaseParticle>* mpPtclPool;
/* 0xE4 */ JPAEmitterManager* mpEmtrMgr;
/* 0xE8 */ JPAResource* mpRes;
/* 0xEC */ JPAEmitterCallBack* mpEmtrCallBack;
/* 0xF0 */ JPAParticleCallBack* mpPtclCallBack;
/* 0xF4 */ volatile u32 mStatus;
/* 0xF8 */ f32 mEmitCount;
/* 0xFC */ f32 mScaleOut;
/* 0x100 */ u32 mTick;
/* 0x104 */ s16 mWaitTime;
/* 0x106 */ s16 mRateStepTimer;
/* 0x108 */ GXColor mPrmClr;
/* 0x10C */ GXColor mEnvClr;
/* 0x110 */ u8 mDrawTimes;
/* 0x111 */ u8 mTexAnmIdx;
/* 0x112 */ u8 mGroupID;
/* 0x113 */ u8 mResMgrID;
};
enum {
JPAPtclStts_Invisible = 0x08,
};
#endif /* JPAEMITTER_H */
include/JSystem/JParticle/JPAEmitterManager.h
+49
View File
@@ -0,0 +1,49 @@
#ifndef JPAEMITTERMANAGER_H
#define JPAEMITTERMANAGER_H
#include "dolphin/types.h"
#include "JSystem/JParticle/JPAList.h"
#include "JSystem/JParticle/JPADrawInfo.h"
#include "JSystem/JSupport/JSUList.h"
#include "JSystem/JGeometry.h"
class JPAEmitterCallBack;
class JPAParticleCallBack;
class JPABaseEmitter;
class JPAResourceManager;
class JPABaseParticle;
class JKRHeap;
struct JPAEmitterWorkData;
/**
* @ingroup jsystem-jparticle
*
*/
class JPAEmitterManager {
public:
/* 8027DCA0 */ JPAEmitterManager(u32, u32, JKRHeap*, u8, u8);
/* 8027DEBC */ JPABaseEmitter* createSimpleEmitterID(JGeometry::TVec3<f32> const&, u16, u8, u8,
JPAEmitterCallBack*, JPAParticleCallBack*);
/* 8027DFA0 */ void calc(u8);
/* 8027E028 */ void draw(JPADrawInfo const*, u8);
/* 8027E220 */ void forceDeleteAllEmitter();
/* 8027E278 */ void forceDeleteGroupEmitter(u8);
/* 8027E2D8 */ void forceDeleteEmitter(JPABaseEmitter*);
/* 8027E344 */ void entryResourceManager(JPAResourceManager*, u8);
/* 8027E354 */ void clearResourceManager(u8);
/* 8027E3F4 */ void calcYBBCam();
JPAResourceManager* getResourceManager(u16 idx) { return pResMgrAry[idx]; }
public:
/* 0x00 */ JSUList<JPABaseEmitter>* pEmtrUseList;
/* 0x04 */ JSUList<JPABaseEmitter> mFreeEmtrList;
/* 0x10 */ JPAList<JPABaseParticle> mPtclPool;
/* 0x1C */ JPAResourceManager** pResMgrAry;
/* 0x20 */ JPAEmitterWorkData* pWd;
/* 0x24 */ u32 emtrNum;
/* 0x28 */ u32 ptclNum;
/* 0x2C */ u8 gidMax;
/* 0x2D */ u8 ridMax;
};
#endif /* JPAEMITTERMANAGER_H */
include/JSystem/JParticle/JPAExTexShape.h
+45
View File
@@ -0,0 +1,45 @@
#ifndef JPAEXTEXSHAPE_H
#define JPAEXTEXSHAPE_H
#include "dolphin/types.h"
class JPAEmitterWorkData;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAExTexShapeData {
// Common header.
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ f32 mIndTexMtx[2][3];
/* 0x24 */ s8 mExpScale;
/* 0x25 */ s8 mIndTexIdx;
/* 0x26 */ s8 mSecTexIdx;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPAExTexShape {
public:
/* 8027B13C */ JPAExTexShape(u8 const*);
const f32* getIndTexMtx() const { return &mpData->mIndTexMtx[0][0]; }
s8 getExpScale() const { return mpData->mExpScale; }
u8 getIndTexIdx() const { return mpData->mIndTexIdx; }
u8 getSecTexIdx() const { return mpData->mSecTexIdx; }
bool isUseIndirect() const { return !!(mpData->mFlags & 0x01); }
bool isUseSecTex() const { return !!(mpData->mFlags & 0x0100); }
public:
const JPAExTexShapeData* mpData;
};
void JPALoadExTex(JPAEmitterWorkData*);
#endif /* JPAEXTEXSHAPE_H */
include/JSystem/JParticle/JPAExtraShape.h
+112
View File
@@ -0,0 +1,112 @@
#ifndef JPAEXTRASHAPE_H
#define JPAEXTRASHAPE_H
#include "dolphin/types.h"
class JPAEmitterWorkData;
class JPABaseParticle;
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAExtraShapeData {
// Common header.
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ f32 mScaleInTiming;
/* 0x10 */ f32 mScaleOutTiming;
/* 0x14 */ f32 mScaleInValueX;
/* 0x18 */ f32 mScaleOutValueX;
/* 0x1C */ f32 mScaleInValueY;
/* 0x20 */ f32 mScaleOutValueY;
/* 0x24 */ f32 mScaleOutRandom;
/* 0x28 */ s16 mScaleAnmCycleX;
/* 0x2A */ s16 mScaleAnmCycleY;
/* 0x2C */ f32 mAlphaInTiming;
/* 0x30 */ f32 mAlphaOutTiming;
/* 0x34 */ f32 mAlphaInValue;
/* 0x38 */ f32 mAlphaBaseValue;
/* 0x3C */ f32 mAlphaOutValue;
/* 0x40 */ f32 mAlphaWaveFrequency;
/* 0x44 */ f32 mAlphaWaveRandom;
/* 0x48 */ f32 mAlphaWaveAmplitude;
/* 0x4C */ f32 mRotateAngle;
/* 0x50 */ f32 mRotateAngleRandom;
/* 0x54 */ f32 mRotateSpeed;
/* 0x58 */ f32 mRotateSpeedRandom;
/* 0x5C */ f32 mRotateDirection;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPAExtraShape {
public:
/* 8027AD88 */ JPAExtraShape(u8 const*);
/* 8027ADBC */ void init();
f32 getScaleInTiming() const { return mpData->mScaleInTiming; }
f32 getScaleOutTiming() const { return mpData->mScaleOutTiming; }
f32 getScaleInValueX() const { return mpData->mScaleInValueX; }
f32 getScaleInValueY() const { return mpData->mScaleInValueY; }
f32 getScaleOutValueX() const { return mpData->mScaleOutValueX; }
f32 getScaleOutValueY() const { return mpData->mScaleOutValueY; }
f32 getScaleRndm() const { return mpData->mScaleOutRandom; }
s16 getScaleAnmCycleX() const { return mpData->mScaleAnmCycleX; }
s16 getScaleAnmCycleY() const { return mpData->mScaleAnmCycleY; }
f32 getAlphaInTiming() const { return mpData->mAlphaInTiming; }
f32 getAlphaOutTiming() const { return mpData->mAlphaOutTiming; }
f32 getAlphaInValue() const { return mpData->mAlphaInValue; }
f32 getAlphaOutValue() const { return mpData->mAlphaOutValue; }
f32 getAlphaBaseValue() const { return mpData->mAlphaBaseValue; }
f32 getAlphaFreq() const { return mpData->mAlphaWaveFrequency; }
f32 getAlphaFreqRndm() const { return mpData->mAlphaWaveRandom; }
f32 getAlphaAmp() const { return mpData->mAlphaWaveAmplitude; }
f32 getRotateInitAngle() const { return mpData->mRotateAngle; }
f32 getRotateRndmAngle() const { return mpData->mRotateAngleRandom; }
f32 getRotateInitSpeed() const { return mpData->mRotateSpeed; }
f32 getRotateRndmSpeed() const { return mpData->mRotateSpeedRandom; }
f32 getRotateDirection() const { return mpData->mRotateDirection; }
f32 getScaleIncRateX() const { return mScaleIncRateX; }
f32 getScaleDecRateX() const { return mScaleDecRateX; }
f32 getScaleIncRateY() const { return mScaleIncRateY; }
f32 getScaleDecRateY() const { return mScaleDecRateY; }
f32 getAlphaIncRate() const { return mAlphaIncRate; }
f32 getAlphaDecRate() const { return mAlphaDecRate; }
BOOL isEnableScaleAnm() const { return mpData->mFlags & 1; }
BOOL isScaleXYDiff() const { return mpData->mFlags & 2; }
u32 getScaleAnmTypeX() const { return (mpData->mFlags >> 8) & 3; }
u32 getScaleAnmTypeY() const { return (mpData->mFlags >> 10) & 3; }
u32 getScaleCenterX() const { return (mpData->mFlags >> 12) & 3; }
u32 getScaleCenterY() const { return (mpData->mFlags >> 14) & 3; }
BOOL isEnableAlphaAnm() const { return mpData->mFlags & 0x10000; }
BOOL isEnableAlphaFlick() const { return mpData->mFlags & 0x20000; }
BOOL isEnableRotateAnm() const { return mpData->mFlags & 0x1000000; }
private:
/* 0x00 */ const JPAExtraShapeData* mpData;
/* 0x04 */ f32 mAlphaIncRate;
/* 0x08 */ f32 mAlphaDecRate;
/* 0x0C */ f32 mScaleIncRateX;
/* 0x10 */ f32 mScaleIncRateY;
/* 0x14 */ f32 mScaleDecRateX;
/* 0x18 */ f32 mScaleDecRateY;
};
void JPACalcAlphaFlickAnm(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcAlphaAnm(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleX(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleY(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleCopy(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleAnmNormal(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleAnmRepeatX(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleAnmReverseX(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleAnmRepeatY(JPAEmitterWorkData*, JPABaseParticle*);
void JPACalcScaleAnmReverseY(JPAEmitterWorkData*, JPABaseParticle*);
#endif /* JPAEXTRASHAPE_H */
include/JSystem/JParticle/JPAFieldBlock.h
+174
View File
@@ -0,0 +1,174 @@
#ifndef JPAFIELDBLOCK_H
#define JPAFIELDBLOCK_H
#include "JSystem/JGeometry.h"
#include "dolphin/types.h"
class JKRHeap;
class JPAEmitterWorkData;
class JPABaseParticle;
class JPAFieldBlock;
class JPAFieldBase {
public:
/* 8027BDEC */ void calcAffect(JPAFieldBlock*, JPABaseParticle*);
/* 8027BF18 */ f32 calcFadeAffect(JPAFieldBlock*, f32) const;
/* 8027D3AC */ virtual ~JPAFieldBase() {}
/* 80276A8C */ virtual void prepare(JPAEmitterWorkData*, JPAFieldBlock*) {}
virtual void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*) = 0;
/* 0x04 */ JGeometry::TVec3<f32> mAccel;
};
class JPAFieldVortex : public JPAFieldBase {
public:
/* 8027C56C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C674 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D564 */ ~JPAFieldVortex() {}
/* 0x10 */ JGeometry::TVec3<f32> field_0x10;
/* 0x1C */ f32 field_0x1c;
/* 0x20 */ f32 field_0x20;
};
class JPAFieldSpin : public JPAFieldBase {
public:
/* 8027CE64 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027CFA8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D3F4 */ ~JPAFieldSpin() {}
/* 0x10 */ JGeometry::TVec3<f32> field_0x10;
/* 0x1C */ JGeometry::TVec3<f32> field_0x1c;
/* 0x28 */ JGeometry::TVec3<f32> field_0x28;
};
class JPAFieldRandom : public JPAFieldBase {
public:
/* 8027CCCC */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D4AC */ ~JPAFieldRandom() {}
};
class JPAFieldNewton : public JPAFieldBase {
public:
/* 8027C36C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C3E0 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D5C0 */ ~JPAFieldNewton() {}
/* 0x10 */ JGeometry::TVec3<f32> mDir;
/* 0x1C */ f32 mCutoff;
};
class JPAFieldMagnet : public JPAFieldBase {
public:
/* 8027C24C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C29C */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D61C */ ~JPAFieldMagnet() {}
/* 0x10 */ JGeometry::TVec3<f32> mDir;
};
class JPAFieldGravity : public JPAFieldBase {
public:
/* 8027BFB4 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C054 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D6D4 */ ~JPAFieldGravity() {}
};
class JPAFieldDrag : public JPAFieldBase {
public:
/* 8027CDE4 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D450 */ ~JPAFieldDrag() {}
};
class JPAFieldConvection : public JPAFieldBase {
public:
/* 8027C814 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027CA94 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D508 */ ~JPAFieldConvection() {}
/* 0x10 */ JGeometry::TVec3<f32> field_0x10;
/* 0x1C */ JGeometry::TVec3<f32> field_0x1c;
/* 0x28 */ JGeometry::TVec3<f32> field_0x28;
};
class JPAFieldAir : public JPAFieldBase {
public:
/* 8027C07C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C1B8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D678 */ ~JPAFieldAir() {}
};
// unknown name
class JPAFieldBlockData {
public:
/* 0x00 */ u8 mMagic[4];
/* 0x04 */ u32 mSize;
/* 0x08 */ u32 mFlags;
/* 0x0C */ JGeometry::TVec3<f32> mPos;
/* 0x18 */ JGeometry::TVec3<f32> mDir;
/* 0x24 */ f32 mMag;
/* 0x28 */ f32 mMagRndm;
/* 0x2C */ f32 mVal1;
/* 0x30 */ f32 mFadeInTime;
/* 0x34 */ f32 mFadeOutTime;
/* 0x38 */ f32 mEnTime;
/* 0x3C */ f32 mDisTime;
/* 0x40 */ u8 mCycle;
};
class JPAFieldBlock {
public:
/* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*);
/* 8027D0C0 */ void init(JKRHeap*);
u32 getType() { return mpData->mFlags & 0xF; }
u32 getAddType() { return (mpData->mFlags >> 8) & 3; }
u32 getSttFlag() { return mpData->mFlags >> 16; }
bool checkStatus(u16 flag) { return flag & getSttFlag(); }
f32 getMagRndm() const { return mpData->mMagRndm; }
f32 getVal1() const { return mpData->mVal1; }
f32 getFadeInTime() { return mpData->mFadeInTime; }
f32 getFadeOutTime() { return mpData->mFadeOutTime; }
f32 getEnTime() { return mpData->mEnTime; }
f32 getDisTime() { return mpData->mDisTime; }
u8 getCycle() { return mpData->mCycle; }
f32 getFadeInRate() { return mFadeInRate; }
f32 getFadeOutRate() { return mFadeOutRate; }
JGeometry::TVec3<f32>& getPos() { return mPos; }
JGeometry::TVec3<f32>& getDir() { return mDir; }
f32 getMag() const { return mMag; }
void getPosOrig(JGeometry::TVec3<f32>* pos) { pos->set(mpData->mPos); }
void getDirOrig(JGeometry::TVec3<f32>* dir) { dir->set(mpData->mDir); }
f32 getMagOrig() { return mpData->mMag; }
void initOpParam() {
getPosOrig(&mPos);
getDirOrig(&mDir);
mMag = getMagOrig();
}
void prepare(JPAEmitterWorkData* work) { mpField->prepare(work, this); }
void calc(JPAEmitterWorkData* work, JPABaseParticle* ptcl) { mpField->calc(work, this, ptcl); }
private:
/* 0x00 */ const JPAFieldBlockData* mpData;
/* 0x04 */ JPAFieldBase* mpField;
/* 0x08 */ f32 mFadeInRate;
/* 0x0C */ f32 mFadeOutRate;
/* 0x10 */ JGeometry::TVec3<f32> mPos;
/* 0x1C */ JGeometry::TVec3<f32> mDir;
/* 0x28 */ f32 mMag;
enum Type {
/* 0x0 */ FIELD_GRAVITY,
/* 0x1 */ FIELD_AIR,
/* 0x2 */ FIELD_MAGNET,
/* 0x3 */ FIELD_NEWTON,
/* 0x4 */ FIELD_VORTEX,
/* 0x5 */ FIELD_RANDOM,
/* 0x6 */ FIELD_DRAG,
/* 0x7 */ FIELD_CONVECTION,
/* 0x8 */ FIELD_SPIN,
};
};
#endif /* JPAFIELDBLOCK_H */
include/JSystem/JParticle/JPAKeyBlock.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef JPAKEYBLOCK_H
#define JPAKEYBLOCK_H
#include "dolphin/types.h"
/**
* @ingroup jsystem-jparticle
*
*/
struct JPAKeyBlock {
/* 8027D730 */ JPAKeyBlock(u8 const*);
/* 8027D740 */ f32 calc(f32);
u8 getID() { return mDataStart[8]; }
const u8* mDataStart;
const f32* field_0x4;
};
#endif /* JPAKEYBLOCK_H */
include/JSystem/JParticle/JPAList.h
+131
View File
@@ -0,0 +1,131 @@
#ifndef JPALIST_H
#define JPALIST_H
#include "dolphin/types.h"
/**
* @ingroup jsystem-jparticle
*
*/
template <class T>
struct JPANode {
JPANode() : mpPrev(NULL), mpNext(NULL) {
}
~JPANode() {}
JPANode<T>* getPrev() { return mpPrev; }
JPANode<T>* getNext() { return mpNext; }
T* getObject() { return &mData; }
/* 0x00 */ JPANode<T>* mpPrev;
/* 0x04 */ JPANode<T>* mpNext;
/* 0x08 */ T mData;
};
/**
* @ingroup jsystem-jparticle
*
*/
template <class T>
struct JPAList {
/* 0x00 */ JPANode<T>* mpFirst;
/* 0x04 */ JPANode<T>* mpLast;
/* 0x08 */ u32 mNum;
JPAList() : mpFirst(NULL), mpLast(NULL), mNum() {}
~JPAList() {}
JPANode<T>* getEnd() { return NULL; }
JPANode<T>* getFirst() const { return mpFirst; }
JPANode<T>* getLast() const { return mpLast; }
u32 getNum() const { return mNum; }
void push_front(JPANode<T>* node) {
if (mpFirst != NULL) {
node->mpPrev = NULL;
node->mpNext = mpFirst;
mpFirst->mpPrev = node;
mpFirst = node;
} else {
mpLast = node;
mpFirst = node;
node->mpPrev = NULL;
node->mpNext = NULL;
}
mNum++;
}
void push_back(JPANode<T>* node) {
if (mpLast != NULL) {
node->mpPrev = mpLast;
node->mpNext = NULL;
mpLast->mpNext = node;
mpLast = node;
} else {
mpFirst = node;
mpLast = node;
node->mpNext = node->mpPrev = NULL;
}
mNum++;
}
JPANode<T>* pop_front() {
JPANode<T>* ret = NULL;
if (mNum == 1) {
ret = mpFirst;
mpLast = NULL;
mpFirst = NULL;
mNum--;
} else if (mNum) {
ret = mpFirst;
ret->mpNext->mpPrev = NULL;
mpFirst = ret->mpNext;
mNum--;
}
return ret;
}
JPANode<T>* pop_back() {
JPANode<T>* ret = NULL;
if (mNum == 1) {
ret = mpLast;
mpLast = NULL;
mpFirst = NULL;
mNum--;
} else if (mNum) {
ret = mpLast;
ret->mpPrev->mpNext = NULL;
mpLast = ret->mpPrev;
mNum--;
}
return ret;
}
JPANode<T>* erase(JPANode<T>* node) {
if (node->mpNext != NULL && node->mpPrev != NULL) {
node->mpPrev->mpNext = node->mpNext;
node->mpNext->mpPrev = node->mpPrev;
mNum--;
} else if (node->mpNext != NULL) {
node->mpNext->mpPrev = NULL;
mpFirst = node->mpNext;
mNum--;
} else if (node->mpPrev != NULL) {
node->mpPrev->mpNext = NULL;
mpLast = node->mpPrev;
mNum--;
} else {
mpLast = NULL;
mpFirst = NULL;
mNum--;
}
return node;
}
};
#endif
include/JSystem/JParticle/JPAMath.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef JPAMATH_H
#define JPAMATH_H
#include "dolphin/mtx.h"
#include "JSystem/JGeometry.h"
void JPAGetDirMtx(JGeometry::TVec3<f32> const& param_0, f32 (*param_1)[4]);
void JPAGetYZRotateMtx(s16 angleY, s16 angleZ, f32 (*param_2)[4]);
void JPAGetXYZRotateMtx(s16 x, s16 y, s16 z, Mtx dst);
void JPASetRMtxTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4],
JGeometry::TVec3<f32>* param_2);
f32 JPACalcKeyAnmValue(f32 param_0, u16 param_1, f32 const* param_2);
void JPASetRMtxSTVecfromMtx(f32 const (*param_0)[4], f32 (*param_1)[4],
JGeometry::TVec3<f32>* param_2, JGeometry::TVec3<f32>* param_3);
#endif /* JPAMATH_H */
include/JSystem/JParticle/JPAParticle.h
+93
View File
@@ -0,0 +1,93 @@
#ifndef JPAPARTICLE_H
#define JPAPARTICLE_H
#include <dolphin/gx.h>
#include "JSystem/JGeometry.h"
class JKRHeap;
class JPABaseEmitter;
class JPABaseParticle;
class JPAEmitterCallBack;
class JPAEmitterManager;
class JPAParticleCallBack;
class JPAResourceManager;
struct JPAEmitterWorkData;
/**
* @ingroup jsystem-jparticle
*
*/
class JPABaseParticle {
public:
~JPABaseParticle() {}
/* 8027EFEC */ void init_p(JPAEmitterWorkData*);
/* 8027F8C8 */ void init_c(JPAEmitterWorkData*, JPABaseParticle*);
/* 8027FFD0 */ bool calc_p(JPAEmitterWorkData*);
/* 80280260 */ bool calc_c(JPAEmitterWorkData*);
/* 802804C8 */ bool canCreateChild(JPAEmitterWorkData*);
/* 80280548 */ f32 getWidth(JPABaseEmitter const*) const;
/* 80280568 */ f32 getHeight(JPABaseEmitter const*) const;
int getAge() { return mAge; }
void setOffsetPosition(const JGeometry::TVec3<f32>& pos) { mOffsetPosition.set(pos); }
void setOffsetPosition(f32 x, f32 y, f32 z) { mOffsetPosition.set(x, y, z); }
void getOffsetPosition(JGeometry::TVec3<f32>& pos) { pos.set(mOffsetPosition); }
u16 getRotateAngle() const { return mRotateAngle; }
void getGlobalPosition(JGeometry::TVec3<f32>& pos) const { pos.set(mPosition); }
f32 getParticleScaleX() const { return mParticleScaleX; }
f32 getParticleScaleY() const { return mParticleScaleY; }
void setStatus(u32 flag) { mStatus |= flag; }
u32 checkStatus(u32 flag) { return mStatus & flag; }
void initStatus(u32 status) { mStatus = status; }
void setInvisibleParticleFlag() { setStatus(8); }
void setDeleteParticleFlag() { setStatus(2); }
void getVelVec(JGeometry::TVec3<f32>& vec) const { vec.set(mVelocity); }
void getLocalPosition(JGeometry::TVec3<f32>& vec) const { vec.set(mLocalPosition); }
void getBaseAxis(JGeometry::TVec3<f32>& vec) const { vec.set(mBaseAxis); }
public:
/* 0x00 */ JGeometry::TVec3<f32> mPosition;
/* 0x0C */ JGeometry::TVec3<f32> mLocalPosition;
/* 0x18 */ JGeometry::TVec3<f32> mOffsetPosition;
/* 0x24 */ JGeometry::TVec3<f32> mVelocity;
/* 0x30 */ JGeometry::TVec3<f32> mVelType1;
/* 0x3C */ JGeometry::TVec3<f32> mVelType0;
/* 0x48 */ JGeometry::TVec3<f32> mVelType2;
/* 0x54 */ JGeometry::TVec3<f32> mBaseAxis;
/* 0x60 */ f32 mParticleScaleX;
/* 0x64 */ f32 mParticleScaleY;
/* 0x68 */ f32 mScaleOut;
/* 0x6C */ f32 mAlphaWaveRandom;
/* 0x70 */ f32 mMoment;
/* 0x74 */ f32 mDrag;
/* 0x78 */ u32 field_0x78;
/* 0x7C */ u32 mStatus;
/* 0x80 */ s16 mAge;
/* 0x82 */ s16 mLifeTime;
/* 0x84 */ f32 mTime;
/* 0x88 */ u16 mRotateAngle;
/* 0x8A */ s16 mRotateSpeed;
/* 0x8C */ GXColor mPrmClr;
/* 0x90 */ GXColor mEnvClr;
/* 0x94 */ u8 mTexAnmIdx;
/* 0x95 */ u8 mAnmRandom;
/* 0x96 */ u8 mPrmColorAlphaAnm;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPAParticleCallBack {
public:
JPAParticleCallBack() {}
virtual ~JPAParticleCallBack() = 0;
virtual void execute(JPABaseEmitter*, JPABaseParticle*) {}
virtual void draw(JPABaseEmitter*, JPABaseParticle*) {}
};
// not sure where this belongs
static inline u32 COLOR_MULTI(u32 a, u32 b) {
return ((a * (b + 1)) * 0x10000) >> 24;
}
#endif /* JPAPARTICLE_H */
include/JSystem/JParticle/JPARandom.h
+43
View File
@@ -0,0 +1,43 @@
#ifndef JPARANDOM_H
#define JPARANDOM_H
#include "dolphin/types.h"
/**
* @ingroup jsystem-jparticle
*
*/
struct JPARandom {
public:
JPARandom() { mSeed = 0; }
JPARandom(u32 seed) { mSeed = seed; }
~JPARandom() {}
void set_seed(u32 seed) { mSeed = seed; }
u32 get_rndm_u() { return mSeed = mSeed * 0x19660du + 0x3c6ef35fu; }
f32 get_rndm_f() {
union {
u32 u;
f32 f;
} a;
a.u = ((get_rndm_u() >> 9) | 0x3f800000);
return a.f - 1.0f;
}
f32 get_rndm_zp() {
f32 f = get_rndm_f();
return (f + f) - 1.0f;
}
f32 get_rndm_zh() {
return get_rndm_f() - 0.5f;
}
s16 get_rndm_ss() { return (s16)(get_rndm_u() >> 16); }
public:
u32 mSeed;
};
#endif
include/JSystem/JParticle/JPAResource.h
+81
View File
@@ -0,0 +1,81 @@
#ifndef JPARESOURCE_H
#define JPARESOURCE_H
#include "dolphin/types.h"
class JKRHeap;
class JPAEmitterWorkData;
class JPABaseEmitter;
class JPABaseParticle;
class JPABaseShape;
class JPAExtraShape;
class JPAChildShape;
class JPAExTexShape;
class JPADynamicsBlock;
class JPAFieldBlock;
class JPAKeyBlock;
/**
* @ingroup jsystem-jparticle
*
*/
class JPAResource {
public:
/* 80274010 */ JPAResource();
/* 80274080 */ void init(JKRHeap*);
/* 802755E8 */ bool calc(JPAEmitterWorkData*, JPABaseEmitter*);
/* 80275A94 */ void draw(JPAEmitterWorkData*, JPABaseEmitter*);
/* 80275B74 */ void drawP(JPAEmitterWorkData*);
/* 80275EB0 */ void drawC(JPAEmitterWorkData*);
/* 802761A8 */ void setPTev();
/* 8027642C */ void setCTev(JPAEmitterWorkData*);
/* 8027658C */ void calc_p(JPAEmitterWorkData*, JPABaseParticle*);
/* 80276608 */ void calc_c(JPAEmitterWorkData*, JPABaseParticle*);
/* 80276684 */ void calcField(JPAEmitterWorkData*, JPABaseParticle*);
/* 80276700 */ void calcKey(JPAEmitterWorkData*);
/* 80276840 */ void calcWorkData_c(JPAEmitterWorkData*);
/* 80276A0C */ void calcWorkData_d(JPAEmitterWorkData*);
JPABaseShape* getBsp() const { return mpBaseShape; }
JPAExtraShape* getEsp() const { return mpExtraShape; }
JPAChildShape* getCsp() const { return mpChildShape; }
JPAExTexShape* getEts() const { return mpExTexShape; }
JPADynamicsBlock* getDyn() const { return mpDynamicsBlock; }
u32 getTexIdx(u32 idx) const { return mpTDB1[idx]; }
u16 getUsrIdx() const { return mUsrIdx; }
public:
typedef void (*EmitterFunc)(JPAEmitterWorkData*);
typedef void (*ParticleFunc)(JPAEmitterWorkData*, JPABaseParticle*);
/* 0x00 */ EmitterFunc* mpCalcEmitterFuncList;
/* 0x04 */ EmitterFunc* mpDrawEmitterFuncList;
/* 0x08 */ EmitterFunc* mpDrawEmitterChildFuncList;
/* 0x0C */ ParticleFunc* mpCalcParticleFuncList;
/* 0x10 */ ParticleFunc* mpDrawParticleFuncList;
/* 0x14 */ ParticleFunc* mpCalcParticleChildFuncList;
/* 0x18 */ ParticleFunc* mpDrawParticleChildFuncList;
/* 0x1C */ JPABaseShape* mpBaseShape;
/* 0x20 */ JPAExtraShape* mpExtraShape;
/* 0x24 */ JPAChildShape* mpChildShape;
/* 0x28 */ JPAExTexShape* mpExTexShape;
/* 0x2C */ JPADynamicsBlock* mpDynamicsBlock;
/* 0x30 */ JPAFieldBlock** mpFieldBlocks;
/* 0x34 */ JPAKeyBlock** mpKeyBlocks;
/* 0x38 */ u16 const* mpTDB1;
/* 0x3C */ u16 mUsrIdx;
/* 0x3E */ u8 mFieldBlockNum;
/* 0x3F */ u8 mKeyBlockNum;
/* 0x40 */ u8 mTDB1Num;
/* 0x41 */ u8 mpCalcEmitterFuncListNum;
/* 0x42 */ u8 mpDrawEmitterFuncListNum;
/* 0x43 */ u8 mpDrawEmitterChildFuncListNum;
/* 0x44 */ u8 mpCalcParticleFuncListNum;
/* 0x45 */ u8 mpDrawParticleFuncListNum;
/* 0x46 */ u8 mpCalcParticleChildFuncListNum;
/* 0x47 */ u8 mpDrawParticleChildFuncListNum;
};
#endif /* JPARESOURCE_H */
include/JSystem/JParticle/JPAResourceLoader.h
+14
View File
@@ -0,0 +1,14 @@
#ifndef JPARESOURCELOADER_H
#define JPARESOURCELOADER_H
#include "dolphin/types.h"
class JPAResourceManager;
class JPAResourceLoader {
public:
/* 8027D8A0 */ JPAResourceLoader(u8 const*, JPAResourceManager*);
/* 8027D8E0 */ void load_jpc(u8 const*, JPAResourceManager*);
};
#endif /* JPARESOURCELOADER_H */
include/JSystem/JParticle/JPAResourceManager.h
+36
View File
@@ -0,0 +1,36 @@
#ifndef JPARESOURCEMANAGER_H
#define JPARESOURCEMANAGER_H
#include "JSystem/JParticle/JPATexture.h"
class JKRHeap;
class JPAResource;
struct ResTIMG;
/**
* @ingroup jsystem-jparticle
*
*/
class JPAResourceManager {
public:
/* 80273E10 */ JPAResourceManager(void const*, JKRHeap*);
/* 80273E68 */ JPAResource* getResource(u16) const;
/* 80273EA8 */ bool checkUserIndexDuplication(u16) const;
/* 80273EEC */ const ResTIMG* swapTexture(ResTIMG const*, char const*);
/* 80273F8C */ void registRes(JPAResource*);
/* 80273FAC */ void registTex(JPATexture*);
/* 80273FCC */ u32 getResUserWork(u16) const;
void load(u16 idx, GXTexMapID texMapID) { mpTexArr[idx]->load(texMapID); }
public:
/* 0x00 */ JKRHeap* mpHeap;
/* 0x04 */ JPAResource** mpResArr;
/* 0x08 */ JPATexture** mpTexArr;
/* 0x0C */ u16 mResMax;
/* 0x0E */ u16 mResNum;
/* 0x10 */ u16 mTexMax;
/* 0x12 */ u16 mTexNum;
};
#endif /* JPARESOURCEMANAGER_H */
include/JSystem/JParticle/JPATexture.h
+36
View File
@@ -0,0 +1,36 @@
#ifndef JPATEXTURE_H
#define JPATEXTURE_H
#include "JSystem/JUtility/JUTTexture.h"
/**
* @ingroup jsystem-jparticle
*
*/
struct JPATextureData {
// Probably magic / size / flags up top here, but they're unused.
/* 0x00 */ char field_0x00[0x0C];
/* 0x0C */ char mName[0x14];
/* 0x20 */ ResTIMG mResTIMG;
};
/**
* @ingroup jsystem-jparticle
*
*/
class JPATexture {
public:
JPATexture(u8 const*);
virtual ~JPATexture();
void load(GXTexMapID texMapID) { mTexture.load(texMapID); }
JUTTexture* getJUTTexture() { return &mTexture; }
const char* getName() const { return mpData->mName; }
public:
JUTTexture mTexture;
const JPATextureData* mpData;
};
#endif /* JPATEXTURE_H */