falso
/
tp
mirror of https://github.com/zeldaret/tp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

JParticle mostly done (#2235)

This commit is contained in:
Caroline Madsen 2024-11-03 13:39:41 -05:00 committed by GitHub
parent 499d4dfe74
commit 63abf9f6d2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 2138 additions and 1469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
configure.py
View File

@ -680,7 +680,7 @@ config.libs = [
"JParticle",
[
Object(Matching, "JSystem/JParticle/JPAResourceManager.cpp"),
Object(NonMatching, "JSystem/JParticle/JPAResource.cpp"),
Object(Equivalent, "JSystem/JParticle/JPAResource.cpp"),
Object(Matching, "JSystem/JParticle/JPABaseShape.cpp"),
Object(Matching, "JSystem/JParticle/JPAExtraShape.cpp"),
Object(Matching, "JSystem/JParticle/JPAChildShape.cpp"),
@ -689,8 +689,8 @@ config.libs = [
Object(NonMatching, "JSystem/JParticle/JPAFieldBlock.cpp"),
Object(Matching, "JSystem/JParticle/JPAKeyBlock.cpp"),
Object(Matching, "JSystem/JParticle/JPATexture.cpp"),
Object(NonMatching, "JSystem/JParticle/JPAResourceLoader.cpp"),
Object(NonMatching, "JSystem/JParticle/JPAEmitterManager.cpp"),
Object(Matching, "JSystem/JParticle/JPAResourceLoader.cpp"),
Object(Equivalent, "JSystem/JParticle/JPAEmitterManager.cpp"),
Object(Matching, "JSystem/JParticle/JPAEmitter.cpp"),
Object(NonMatching, "JSystem/JParticle/JPAParticle.cpp"),
Object(Matching, "JSystem/JParticle/JPAMath.cpp"),

119
include/JSystem/JGeometry.h
View File

@ -3,9 +3,54 @@
#include "dolphin/mtx/vec.h"
#include "math.h"
#include "JSystem/JMath/JMath.h"
namespace JGeometry {
template<typename T>
struct TUtil {
static inline T clamp(T v, T min, T max) {
if (v < min) {
return min;
}
if (v > max) {
return max;
}
return v;
}
};
template<>
struct TUtil<f32> {
static inline f32 clamp(f32 v, f32 min, f32 max) {
if (v < min) {
return min;
}
if (v > max) {
return max;
}
return v;
}
static inline f32 epsilon() { return 32.0f * FLT_EPSILON; }
static inline f32 PI() { return 3.1415927f; }
static inline f32 inv_sqrt(f32 x) {
if (x <= 0.0f) {
return x;
}
f32 root = __frsqrte(x);
return 0.5f * root * (3.0f - x * (root * root));
}
};
template<>
struct TUtil<double> {
static inline double epsilon() { return 32.0f * FLT_EPSILON; }
static inline double one() { return 1.0; }
static inline double atan2(double x, double y) { return atan2(x, y); }
static inline double asin(double x) { return asin(x); }
static inline double halfPI() { return 1.5707963267948966; }
};
template <typename T>
struct TVec3 {
T x;
@ -155,6 +200,10 @@ struct TVec3<f32> : public Vec {
};
}
inline void mul(const TVec3<f32>& a) {
mul(*this, a);
}
inline TVec3<f32>& operator=(const Vec& b) {
setTVec3f(&b.x, &this->x);
return *this;
@ -250,6 +299,10 @@ struct TVec3<f32> : public Vec {
};
}
void scaleAdd(register f32 sc, const TVec3<f32>& a, const TVec3<f32>& b) {
JMAVECScaleAdd(&a, &b, this, sc);
}
void negateInternal(TVec3<f32>* dst) {
register f32* rdst = &dst->x;
const register f32* src = &x;
@ -286,7 +339,7 @@ struct TVec3<f32> : public Vec {
}
void setLength(f32 len) {
f32 sq = squared();
f32 sq = squared();
if (sq <= FLT_EPSILON * 32.0f) {
return;
}
@ -299,21 +352,33 @@ struct TVec3<f32> : public Vec {
scale(norm * len);
}
f32 setLength(const TVec3<f32>& other, f32 len) {
f32 sq = other.squared();
if (sq <= TUtil<f32>::epsilon()) {
zero();
return 0.0f;
}
f32 inv_norm = TUtil<f32>::inv_sqrt(sq);
scale(inv_norm * len, other);
return inv_norm * sq;
}
f32 dot(const TVec3<f32>& other) const {
register const f32* pThis = &x;
register const f32* pOther = &other.x;
register f32 otherReg;
register f32 thisyz;
register f32 res;
register f32 thisyz;
register f32 otheryz;
register f32 otherxy;
register f32 thisxy;
asm {
psq_l thisyz, 4(pThis), 0, 0
psq_l otherReg, 4(pOther), 0, 0
ps_mul thisyz, thisyz, otherReg
psq_l otheryz, 4(pOther), 0, 0
ps_mul thisyz, thisyz, otheryz
psq_l thisxy, 0(pThis), 0, 0
psq_l otherReg, 0(pOther), 0, 0
ps_madd res, thisxy, otherReg, thisyz
ps_sum0 res, res, thisyz, thisyz
psq_l otherxy, 0(pOther), 0, 0
ps_madd otheryz, thisxy, otherxy, thisyz
ps_sum0 res, otheryz, thisyz, thisyz
};
return res;
}
@ -448,44 +513,6 @@ struct TBox2 : TBox<TVec2<T> > {
void set(f32 x0, f32 y0, f32 x1, f32 y1) { i.set(x0, y0); f.set(x1, y1); }
};
template<typename T>
struct TUtil {
static inline T clamp(T v, T min, T max) {
if (v < min) {
return min;
}
if (v > max) {
return max;
}
return v;
}
};
template<>
struct TUtil<f32> {
static inline f32 epsilon() { return 32.0f * FLT_EPSILON; }
static inline f32 PI() { return 3.1415927f; }
static inline f32 clamp(f32 v, f32 min, f32 max) {
if (v < min) {
return min;
}
if (v > max) {
return max;
}
return v;
}
};
template<>
struct TUtil<double> {
static inline double epsilon() { return 32.0f * FLT_EPSILON; }
static inline double one() { return 1.0; }
static inline double atan2(double x, double y) { return atan2(x, y); }
static inline double asin(double x) { return asin(x); }
static inline double halfPI() { return 1.5707963267948966; }
};
// clang-format on
} // namespace JGeometry

4
include/JSystem/JMath/JMath.h
View File

@ -6,7 +6,9 @@
void JMAMTXApplyScale(const Mtx, Mtx, f32, f32, f32);
void JMAEulerToQuat(s16 param_0, s16 param_1, s16 param_2, Quaternion* param_3);
void JMAQuatLerp(const Quaternion*, const Quaternion*, f32, Quaternion*);
void JMAFastVECNormalize(register const Vec* src, register Vec* dst);
void JMAFastVECNormalize(register const Vec* src, register Vec* dst);
void JMAVECScaleAdd(register const Vec* vec1, register const Vec* vec2, register Vec* dst,
register f32 scale);
inline int JMAAbs(int value) {
return (value >> 0x1f ^ value) - (value >> 0x1f);

82
include/JSystem/JParticle/JPABaseShape.h
View File

@ -4,6 +4,7 @@
#include "dolphin/gx/GXStruct.h"
class JPAEmitterWorkData;
class JPABaseParticle;
class JKRHeap;
/**
@ -78,21 +79,21 @@ public:
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) & 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 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 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); }
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; }
@ -100,7 +101,7 @@ public:
void getEnvClr(GXColor* dst) { *dst = mpData->mClrEnv; }
void getEnvClr(s16 idx, GXColor* dst) { *dst = mpEnvClrAnmTbl[idx]; }
bool isTexAnm() const { return !!(mpData->mTexFlg & 0x01); }
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]; }
@ -111,6 +112,7 @@ public:
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() { return mpData->mAnmRndm; }
f32 getIncTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[5]; }
f32 getInitTransX() const { return ((f32*)mpTexCrdMtxAnmTbl)[0]; }
@ -141,4 +143,68 @@ struct JPAClrAnmKeyData {
/* 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 */

42
include/JSystem/JParticle/JPAChildShape.h
View File

@ -3,6 +3,9 @@
#include "dolphin/gx/GXStruct.h"
class JPAEmitterWorkData;
class JPABaseParticle;
/**
* @ingroup jsystem-jparticle
*
@ -41,11 +44,46 @@ class JPAChildShape {
public:
/* 8027B038 */ JPAChildShape(u8 const*);
void getPrmClr(GXColor* dst) { *dst = mpData->mPrmClr; }
void getEnvClr(GXColor* dst) { *dst = mpData->mEnvClr; }
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 */

3
include/JSystem/JParticle/JPADynamicsBlock.h
View File

@ -96,7 +96,10 @@ public:
f32 getInitVelDir() { return mpData->mInitialVelDir; }
f32 getInitVelDirSp() { return mpData->mSpread; }
f32 getInitVelRndm() { return mpData->mInitialVelRndm; }
f32 getInitVelRatio() { return mpData->mInitialVelRatio; }
f32 getAirRes() { return mpData->mAirResist; }
f32 getLifeTimeRndm() { return mpData->mLifeTimeRndm; }
f32 getMomentRndm() { return mpData->mMoment; }
public:
/* 0x00 */ const JPADynamicsBlockData* mpData;

14
include/JSystem/JParticle/JPAEmitter.h
View File

@ -47,10 +47,10 @@ struct JPAEmitterWorkData {
/* 0x1B4 */ Mtx mPrjMtx;
/* 0x1E4 */ JPAList<JPABaseParticle>* mpAlivePtcl;
/* 0x1E8 */ JPANode<JPABaseParticle>* mpCurNode;
/* 0x1EC */ u32 mVolumeAngleNum;
/* 0x1F0 */ u32 mVolumeAngleMax;
/* 0x1F4 */ u32 mVolumeX;
/* 0x1F8 */ u32 mDivNumber;
/* 0x1EC */ s32 mVolumeAngleNum;
/* 0x1F0 */ s32 mVolumeAngleMax;
/* 0x1F4 */ s32 mVolumeX;
/* 0x1F8 */ s32 mDivNumber;
/* 0x1FC */ f32 mScaleAnm;
/* 0x200 */ u32 mDirType;
/* 0x204 */ u32 mRotType;
@ -93,8 +93,8 @@ enum {
*/
class JPABaseEmitter {
public:
/* 8027E5EC */ ~JPABaseEmitter();
/* 8027E64C */ JPABaseEmitter();
/* 8027E5EC */ ~JPABaseEmitter() {}
/* 8027E64C */ JPABaseEmitter() : mLink(this) {}
/* 8027E6EC */ void init(JPAEmitterManager*, JPAResource*);
/* 8027EDD4 */ bool processTillStartFrame();
/* 8027EE14 */ bool processTermination();
@ -223,7 +223,7 @@ public:
/* 0x44 */ f32 mRndmDirSpeed;
/* 0x48 */ f32 mAirResist;
/* 0x4C */ JGeometry::TVec3<s16> mLocalRot;
/* 0x52 */ u16 mLifeTime;
/* 0x52 */ s16 mLifeTime;
/* 0x54 */ u16 mVolumeSize;
/* 0x56 */ u8 mRateStep;
/* 0x58 */ JSULink<JPABaseEmitter> mLink;

6
include/JSystem/JParticle/JPAExTexShape.h
View File

@ -3,6 +3,8 @@
#include "dolphin/types.h"
class JPAEmitterWorkData;
/**
* @ingroup jsystem-jparticle
*
@ -28,7 +30,7 @@ public:
/* 8027B13C */ JPAExTexShape(u8 const*);
const f32* getIndTexMtx() const { return &mpData->mIndTexMtx[0][0]; }
s32 getExpScale() const { return mpData->mExpScale; }
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); }
@ -38,4 +40,6 @@ public:
const JPAExTexShapeData* mpData;
};
void JPALoadExTex(JPAEmitterWorkData*);
#endif /* JPAEXTEXSHAPE_H */

31
include/JSystem/JParticle/JPAExtraShape.h
View File

@ -3,6 +3,9 @@
#include "dolphin/types.h"
class JPAEmitterWorkData;
class JPABaseParticle;
/**
* @ingroup jsystem-jparticle
*
@ -52,6 +55,7 @@ public:
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; }
@ -60,7 +64,13 @@ public:
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; }
@ -68,6 +78,16 @@ public:
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;
@ -78,4 +98,15 @@ private:
/* 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 */

168
include/JSystem/JParticle/JPAFieldBlock.h
View File

@ -1,6 +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() { return mpData->mMagRndm; }
f32 getVal1() { 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() { 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 */

4
include/JSystem/JParticle/JPAKeyBlock.h
View File

@ -9,7 +9,9 @@
*/
struct JPAKeyBlock {
/* 8027D730 */ JPAKeyBlock(u8 const*);
/* 8027D740 */ void calc(f32);
/* 8027D740 */ f32 calc(f32);
u8 getID() { return mDataStart[8]; }
const u8* mDataStart;
const f32* field_0x4;

38
include/JSystem/JParticle/JPAList.h
View File

@ -1,6 +1,8 @@
#ifndef JPALIST_H
#define JPALIST_H
#include "dolphin/types.h"
/**
* @ingroup jsystem-jparticle
*
@ -15,9 +17,10 @@ struct JPANode {
JPANode<T>* getPrev() { return mpPrev; }
JPANode<T>* getNext() { return mpNext; }
T* getObject() { return &mData; }
JPANode<T>* mpPrev;
JPANode<T>* mpNext;
T mData;
/* 0x00 */ JPANode<T>* mpPrev;
/* 0x04 */ JPANode<T>* mpNext;
/* 0x08 */ T mData;
};
/**
@ -26,9 +29,9 @@ struct JPANode {
*/
template <class T>
struct JPAList {
JPANode<T>* mpFirst;
JPANode<T>* mpLast;
u32 mNum;
/* 0x00 */ JPANode<T>* mpFirst;
/* 0x04 */ JPANode<T>* mpLast;
/* 0x08 */ u32 mNum;
JPAList() : mpFirst(NULL), mpLast(NULL), mNum() {}
@ -104,6 +107,27 @@ struct JPAList {
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
#endif

20
include/JSystem/JParticle/JPAParticle.h
View File

@ -2,11 +2,8 @@
#define JPAPARTICLE_H
#include "dolphin/gx/GXStruct.h"
#include "JSystem/JGeometry.h"
#include "JSystem/JParticle/JPAList.h"
class JKRHeap;
class JPABaseEmitter;
class JPABaseParticle;
@ -24,9 +21,9 @@ class JPABaseParticle {
public:
/* 8027EFEC */ void init_p(JPAEmitterWorkData*);
/* 8027F8C8 */ void init_c(JPAEmitterWorkData*, JPABaseParticle*);
/* 8027FFD0 */ void calc_p(JPAEmitterWorkData*);
/* 80280260 */ void calc_c(JPAEmitterWorkData*);
/* 802804C8 */ void canCreateChild(JPAEmitterWorkData*);
/* 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; }
@ -39,6 +36,7 @@ public:
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); }
@ -50,9 +48,9 @@ public:
/* 0x0C */ JGeometry::TVec3<f32> mLocalPosition;
/* 0x18 */ JGeometry::TVec3<f32> mOffsetPosition;
/* 0x24 */ JGeometry::TVec3<f32> mVelocity;
/* 0x30 */ Vec mVelType1;
/* 0x3C */ Vec mVelType0;
/* 0x48 */ Vec mVelType2;
/* 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;
@ -63,10 +61,10 @@ public:
/* 0x78 */ u32 field_0x78;
/* 0x7C */ u32 mStatus;
/* 0x80 */ s16 mAge;
/* 0x82 */ u16 mLifeTime;
/* 0x82 */ s16 mLifeTime;
/* 0x84 */ f32 mTime;
/* 0x88 */ u16 mRotateAngle;
/* 0x8A */ u16 mRotateSpeed;
/* 0x8A */ s16 mRotateSpeed;
/* 0x8C */ GXColor mPrmClr;
/* 0x90 */ GXColor mEnvClr;
/* 0x94 */ u8 mTexAnmIdx;

7
include/JSystem/JParticle/JPARandom.h
View File

@ -1,6 +1,8 @@
#ifndef JPARANDOM_H
#define JPARANDOM_H
#include "dolphin/types.h"
/**
* @ingroup jsystem-jparticle
*
@ -27,8 +29,7 @@ public:
}
f32 get_rndm_zh() {
f32 f = get_rndm_f();
return f - 0.5f;
return get_rndm_f() - 0.5f;
}
s16 get_rndm_ss() { return (s16)(get_rndm_u() >> 16); }
@ -37,4 +38,4 @@ public:
u32 mSeed;
};
#endif
#endif

16
include/JSystem/JParticle/JPAResource.h
View File

@ -47,13 +47,15 @@ public:
u16 getUsrIdx() const { return mUsrIdx; }
public:
/* 0x00 */ void** mpCalcEmitterFuncList;
/* 0x04 */ void** mpDrawEmitterFuncList;
/* 0x08 */ void** mpDrawEmitterChildFuncList;
/* 0x0C */ void** mpCalcParticleFuncList;
/* 0x10 */ void** mpDrawParticleFuncList;
/* 0x14 */ void** mpCalcParticleChildFuncList;
/* 0x18 */ void** mpDrawParticleChildFuncList;
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;

10
include/JSystem/JParticle/JPAResourceLoader.h
View File

@ -1,4 +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 */

4
include/dolphin/mtx/vec.h
View File

@ -42,8 +42,8 @@ inline void C_VECAdd(register const Vec* a, register const Vec* b, register Vec*
asm {
psq_l axy, 0(a), 0, 0
psq_l bxy, 0(b), 0, 0
ps_add axy, axy, bxy
psq_st axy, 0(ab), 0, 0
ps_add bxy, axy, bxy
psq_st bxy, 0(ab), 0, 0
psq_l az, 8(a), 1, 0
psq_l bz, 8(b), 1, 0
ps_add sumz, az, bz

3
src/JSystem/JParticle/JPABaseShape.cpp
View File

@ -148,7 +148,6 @@ void JPARegistEnv(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
*/
void JPACalcClrIdxNormal(JPAEmitterWorkData* work) {
JPABaseShape* bsp = work->mpRes->getBsp();
// can't get the extsh to appear in the right spot...
s16 keyFrame;
if (work->mpEmtr->mTick < bsp->getClrAnmMaxFrm()) {
keyFrame = work->mpEmtr->mTick;
@ -1447,4 +1446,4 @@ void JPABaseShape::setGX(JPAEmitterWorkData* work) const {
GXSetTevDirect(GX_TEVSTAGE0);
GXSetTevDirect(GX_TEVSTAGE1);
GXSetZCompLoc(getZCompLoc());
}
}

15
src/JSystem/JParticle/JPAChildShape.cpp
View File

@ -9,18 +9,6 @@
#include "dolphin/gx.h"
#include "dolphin/os.h"
//
// Types:
//
//
// Forward References:
//
//
// Declarations:
//
/* 8027AEBC-8027AFDC 2757FC 0120+00 0/0 1/1 0/0 .text JPARegistChildPrmEnv__FP18JPAEmitterWorkData
*/
void JPARegistChildPrmEnv(JPAEmitterWorkData* work) {
@ -50,7 +38,6 @@ void JPACalcChildAlphaOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
/* 8027B008-8027B038 275948 0030+00 0/0 1/1 0/0 .text
* JPACalcChildScaleOut__FP18JPAEmitterWorkDataP15JPABaseParticle */
void JPACalcChildScaleOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
// literal
ptcl->mParticleScaleX = ptcl->mScaleOut * (1.0f - ptcl->mTime);
ptcl->mParticleScaleY = ptcl->mAlphaWaveRandom * (1.0f - ptcl->mTime);
}
@ -58,4 +45,4 @@ void JPACalcChildScaleOut(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
/* 8027B038-8027B040 -00001 0008+00 0/0 0/0 0/0 .text __ct__13JPAChildShapeFPCUc */
JPAChildShape::JPAChildShape(u8 const* pData) {
mpData = (JPAChildShapeData*)pData;
}
}

153
src/JSystem/JParticle/JPADynamicsBlock.cpp
View File

@ -4,57 +4,8 @@
//
#include "JSystem/JParticle/JPADynamicsBlock.h"
#include "JSystem/JMath/JMATrigonometric.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "dol2asm.h"
//
// Types:
//
//
// Forward References:
//
extern "C" static void JPAVolumePoint(JPAEmitterWorkData*);
extern "C" static void JPAVolumeLine(JPAEmitterWorkData*);
extern "C" static void JPAVolumeCircle(JPAEmitterWorkData*);
extern "C" static void JPAVolumeCube(JPAEmitterWorkData*);
extern "C" static void JPAVolumeSphere(JPAEmitterWorkData*);
extern "C" static void JPAVolumeCylinder(JPAEmitterWorkData*);
extern "C" static void JPAVolumeTorus(JPAEmitterWorkData*);
extern "C" void __ct__16JPADynamicsBlockFPCUc();
extern "C" void init__16JPADynamicsBlockFv();
extern "C" void create__16JPADynamicsBlockFP18JPAEmitterWorkData();
//
// External References:
//
extern "C" void createParticle__14JPABaseEmitterFv();
extern "C" u8 sincosTable___5JMath[65536];
//
// Declarations:
//
/* ############################################################################################## */
/* 80455310-80455314 003910 0004+00 7/7 0/0 0/0 .sdata2 @2287 */
SECTION_SDATA2 static u8 lit_2287[4] = {
0x00,
0x00,
0x00,
0x00,
};
/* 80455314-80455318 003914 0004+00 7/7 0/0 0/0 .sdata2 @2288 */
SECTION_SDATA2 static f32 lit_2288 = 1.0f;
/* 80455318-80455320 003918 0004+04 3/3 0/0 0/0 .sdata2 @2289 */
SECTION_SDATA2 static f32 lit_2289[1 + 1 /* padding */] = {
0.5f,
/* padding */
0.0f,
};
/* 8027B144-8027B220 275A84 00DC+00 1/1 0/0 0/0 .text JPAVolumePoint__FP18JPAEmitterWorkData */
void JPAVolumePoint(JPAEmitterWorkData* work) {
@ -64,12 +15,6 @@ void JPAVolumePoint(JPAEmitterWorkData* work) {
work->mVelAxis.set(work->mVelOmni.x, 0.0f, work->mVelOmni.z);
}
/* ############################################################################################## */
/* 80455320-80455328 003920 0008+00 6/6 0/0 0/0 .sdata2 @2321 */
SECTION_SDATA2 static f64 lit_2321 = 4503601774854144.0 /* cast s32 to float */;
/* 8027B220-8027B33C 275B60 011C+00 1/1 0/0 0/0 .text JPAVolumeLine */
void JPAVolumeLine(JPAEmitterWorkData* work) {
if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) {
@ -85,17 +30,13 @@ void JPAVolumeLine(JPAEmitterWorkData* work) {
work->mVelAxis.set(0.0f, 0.0f, work->mVolumePos.z);
}
/* 8027B33C-8027B4E8 275C7C 01AC+00 1/1 0/0 0/0 .text JPAVolumeCircle */
// regalloc. Could be issue with mul asm implementations
#ifdef NONMATCHING
// NONMATCHING regalloc. Could be issue with mul asm implementations
void JPAVolumeCircle(JPAEmitterWorkData* work) {
s16 thetai;
f32 theta;
f32 distance;
f32 sizeXZ;
f32 temp;
if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) {
theta = (s16)((work->mVolumeEmitIdx << 16) / work->mEmitCount);
thetai = theta * work->mVolumeSweep;
@ -116,14 +57,6 @@ void JPAVolumeCircle(JPAEmitterWorkData* work) {
work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z);
}
#else
static void JPAVolumeCircle(JPAEmitterWorkData* param_0) {
// NONMATCHING
}
#endif
/* 8027B4E8-8027B5F0 275E28 0108+00 1/1 0/0 0/0 .text JPAVolumeCube */
void JPAVolumeCube(JPAEmitterWorkData* work) {
work->mVolumePos.set(work->mpEmtr->get_r_zh() * work->mVolumeSize,
@ -133,32 +66,64 @@ void JPAVolumeCube(JPAEmitterWorkData* work) {
work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z);
}
/* ############################################################################################## */
/* 80455328-80455330 003928 0004+04 1/1 0/0 0/0 .sdata2 @2501 */
SECTION_SDATA2 static f32 lit_2501[1 + 1 /* padding */] = {
32768.0f,
/* padding */
0.0f,
};
/* 80455330-80455338 003930 0008+00 1/1 0/0 0/0 .sdata2 @2503 */
SECTION_SDATA2 static f64 lit_2503 = 4503599627370496.0 /* cast u32 to float */;
/* 8027B5F0-8027B87C 275F30 028C+00 1/1 0/0 0/0 .text JPAVolumeSphere__FP18JPAEmitterWorkData */
static void JPAVolumeSphere(JPAEmitterWorkData* param_0) {
// NONMATCHING
static void JPAVolumeSphere(JPAEmitterWorkData* work) {
s16 phi, theta;
if (work->mpEmtr->checkFlag(JPADynFlag_FixedInterval)) {
phi = (u16)(work->mVolumeX * 0x8000 / (work->mDivNumber - 1) + 0x4000);
f32 tmp = (u16)(work->mVolumeAngleNum * 0x10000 / (work->mVolumeAngleMax - 1));
theta = tmp * work->mVolumeSweep + 0x8000;
work->mVolumeAngleNum++;
if (work->mVolumeAngleNum == work->mVolumeAngleMax) {
work->mVolumeAngleNum = 0;
work->mVolumeX++;
if (work->mVolumeX * 2 < work->mDivNumber) {
work->mVolumeAngleMax = work->mVolumeAngleMax != 1 ?
work->mVolumeAngleMax + 4 : work->mVolumeAngleMax + 3;
} else {
work->mVolumeAngleMax = work->mVolumeAngleMax != 4 ? work->mVolumeAngleMax - 4 : 1;
}
}
} else {
phi = work->mpEmtr->get_r_ss() >> 1;
theta = work->mVolumeSweep * work->mpEmtr->get_r_ss();
}
f32 rnd = work->mpEmtr->get_r_f();
if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) {
rnd = 1.0f - rnd * rnd * rnd;
}
f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad));
work->mVolumePos.set(rad * JMASCos(phi) * JMASSin(theta), -rad * JMASSin(phi),
rad * JMASCos(phi) * JMASCos(theta));
work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl);
work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z);
}
/* 8027B87C-8027B9F8 2761BC 017C+00 1/1 0/0 0/0 .text JPAVolumeCylinder__FP18JPAEmitterWorkData */
static void JPAVolumeCylinder(JPAEmitterWorkData* param_0) {
// NONMATCHING
static void JPAVolumeCylinder(JPAEmitterWorkData* work) {
s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss();
f32 rnd = work->mpEmtr->get_r_f();
if (work->mpEmtr->checkFlag(JPADynFlag_FixedDensity)) {
rnd = 1.0f - rnd * rnd;
}
f32 rad = work->mVolumeSize * (work->mVolumeMinRad + rnd * (1.0f - work->mVolumeMinRad));
work->mVolumePos.set(rad * JMASSin(theta), work->mVolumeSize * work->mpEmtr->get_r_zp(),
rad * JMASCos(theta));
work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl);
work->mVelAxis.set(work->mVolumePos.x, 0.0f, work->mVolumePos.z);
}
/* 8027B9F8-8027BB18 276338 0120+00 1/1 0/0 0/0 .text JPAVolumeTorus__FP18JPAEmitterWorkData */
static void JPAVolumeTorus(JPAEmitterWorkData* param_0) {
// NONMATCHING
static void JPAVolumeTorus(JPAEmitterWorkData* work) {
s16 theta = work->mVolumeSweep * work->mpEmtr->get_r_ss();
s16 phi = work->mpEmtr->get_r_ss();
f32 rad = work->mVolumeSize * work->mVolumeMinRad;
work->mVelAxis.set(rad * JMASSin(theta) * JMASCos(phi), rad * JMASSin(phi),
rad * JMASCos(theta) * JMASCos(phi));
work->mVolumePos.set(work->mVelAxis.x + work->mVolumeSize * JMASSin(theta), work->mVelAxis.y,
work->mVelAxis.z + work->mVolumeSize * JMASCos(theta));
work->mVelOmni.mul(work->mVolumePos, work->mGlobalScl);
}
/* 8027BB18-8027BB4C 276458 0034+00 0/0 1/1 0/0 .text __ct__16JPADynamicsBlockFPCUc */
@ -206,10 +171,6 @@ void JPADynamicsBlock::init() {
/* 8027BBE8-8027BDEC 276528 0204+00 0/0 1/1 0/0 .text
* create__16JPADynamicsBlockFP18JPAEmitterWorkData */
#ifdef NONMATCHING
// literal only
void JPADynamicsBlock::create(JPAEmitterWorkData* work) {
if (work->mpEmtr->checkStatus(JPAEmtrStts_RateStepEmit)) {
s32 emitCount;
@ -263,11 +224,3 @@ void JPADynamicsBlock::create(JPAEmitterWorkData* work) {
work->mpEmtr->clearStatus(JPAEmtrStts_FirstEmit);
}
#else
void JPADynamicsBlock::create(JPAEmitterWorkData* param_0) {
// NONMATCHING
}
#endif

98
src/JSystem/JParticle/JPAEmitterManager.cpp
View File

@ -4,72 +4,14 @@
//
#include "JSystem/JParticle/JPAEmitterManager.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "JSystem/JParticle/JPAParticle.h"
#include "JSystem/JParticle/JPAResourceManager.h"
#include "dolphin/gx.h"
//
// Types:
//
//
// Forward References:
//
extern "C" void __ct__17JPAEmitterManagerFUlUlP7JKRHeapUcUc();
extern "C" void func_8027DEBC();
extern "C" void calc__17JPAEmitterManagerFUc();
extern "C" void draw__17JPAEmitterManagerFPC11JPADrawInfoUc();
extern "C" void forceDeleteAllEmitter__17JPAEmitterManagerFv();
extern "C" void forceDeleteGroupEmitter__17JPAEmitterManagerFUc();
extern "C" void forceDeleteEmitter__17JPAEmitterManagerFP14JPABaseEmitter();
extern "C" void entryResourceManager__17JPAEmitterManagerFP18JPAResourceManagerUc();
extern "C" void clearResourceManager__17JPAEmitterManagerFUc();
extern "C" void calcYBBCam__17JPAEmitterManagerFv();
extern "C" void func_8027E51C(void* _this);
extern "C" void func_8027E54C(void* _this);
extern "C" void func_8027E588(void* _this);
extern "C" void func_8027E598(void* _this);
extern "C" void __dt__14JPABaseEmitterFv();
extern "C" void __ct__14JPABaseEmitterFv();
//
// External References:
//
extern "C" void getResource__18JPAResourceManagerCFUs();
extern "C" void calc__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter();
extern "C" void draw__11JPAResourceFP18JPAEmitterWorkDataP14JPABaseEmitter();
extern "C" void init__14JPABaseEmitterFP17JPAEmitterManagerP11JPAResource();
extern "C" void deleteAllParticle__14JPABaseEmitterFv();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void* __nwa__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __ct__10JSUPtrLinkFPv();
extern "C" void __dt__10JSUPtrLinkFv();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void __construct_new_array();
extern "C" void _savegpr_24();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
extern "C" void _savegpr_29();
extern "C" void _restgpr_24();
extern "C" void _restgpr_26();
extern "C" void _restgpr_27();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* 8027DCA0-8027DEBC 2785E0 021C+00 0/0 1/1 0/0 .text __ct__17JPAEmitterManagerFUlUlP7JKRHeapUcUc
*/
// template ctors are at the end of the TU for some reason
#ifdef NONMATCHING
JPAEmitterManager::JPAEmitterManager(u32 ptclMax, u32 emtrMax, JKRHeap* pHeap, u8 grpMax,
u8 resMax) {
mEmtrMax = emtrMax;
@ -93,12 +35,6 @@ JPAEmitterManager::JPAEmitterManager(u32 ptclMax, u32 emtrMax, JKRHeap* pHeap, u
mpWorkData = new (pHeap, 0) JPAEmitterWorkData();
}
#else
JPAEmitterManager::JPAEmitterManager(u32 param_0, u32 param_1, JKRHeap* param_2, u8 param_3,
u8 param_4) {
// NONMATCHING
}
#endif
/* 8027DEBC-8027DFA0 2787FC 00E4+00 0/0 3/3 0/0 .text
* createSimpleEmitterID__17JPAEmitterManagerFRCQ29JGeometry8TVec3<f>UsUcUcP18JPAEmitterCallBackP19JPAParticleCallBack
@ -222,8 +158,6 @@ void JPAEmitterManager::clearResourceManager(u8 resMgrID) {
mpResMgrAry[resMgrID] = NULL;
}
/* ############################################################################################## */
/* 8027E3F4-8027E51C 278D34 0128+00 1/1 0/0 0/0 .text calcYBBCam__17JPAEmitterManagerFv
*/
void JPAEmitterManager::calcYBBCam() {
@ -243,31 +177,3 @@ void JPAEmitterManager::calcYBBCam() {
mpWorkData->mYBBCamMtx[2][2] = v.y;
mpWorkData->mYBBCamMtx[2][3] = mpWorkData->mPosCamMtx[2][3];
}
/* 8027E51C-8027E54C 278E5C 0030+00 1/1 0/0 0/0 .text __ct__25JSUList<14JPABaseEmitter>Fv
*/
extern "C" void func_8027E51C(void* _this) {
// NONMATCHING
}
/* 8027E54C-8027E588 278E8C 003C+00 1/1 0/0 0/0 .text __dt__26JPANode<15JPABaseParticle>Fv */
extern "C" void func_8027E54C(void* _this) {
// NONMATCHING
}
/* 8027E588-8027E598 278EC8 0010+00 1/1 0/0 0/0 .text __ct__26JPANode<15JPABaseParticle>Fv */
extern "C" void func_8027E588(void* _this) {
// NONMATCHING
}
/* 8027E598-8027E5EC 278ED8 0054+00 1/1 0/0 0/0 .text __dt__25JSUList<14JPABaseEmitter>Fv
*/
extern "C" void func_8027E598(void* _this) {
// NONMATCHING
}
/* 8027E5EC-8027E64C 278F2C 0060+00 1/1 0/0 0/0 .text __dt__14JPABaseEmitterFv */
JPABaseEmitter::~JPABaseEmitter() {}
/* 8027E64C-8027E6A4 278F8C 0058+00 1/1 0/0 0/0 .text __ct__14JPABaseEmitterFv */
JPABaseEmitter::JPABaseEmitter() : mLink(this) {}

7
src/JSystem/JParticle/JPAExtraShape.cpp
View File

@ -8,11 +8,6 @@
#include "JSystem/JParticle/JPAParticle.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "dolphin/os.h"
#include "dolphin/types.h"
//
// Types:
//
/* 8027A918-8027A990 275258 0078+00 0/0 1/1 0/0 .text
* JPACalcScaleX__FP18JPAEmitterWorkDataP15JPABaseParticle */
@ -154,4 +149,4 @@ void JPAExtraShape::init() {
} else {
mScaleDecRateX = mScaleDecRateY = 1.0f;
}
}
}

572
src/JSystem/JParticle/JPAFieldBlock.cpp
View File

@ -4,443 +4,299 @@
//
#include "JSystem/JParticle/JPAFieldBlock.h"
#include "dol2asm.h"
//
// Types:
//
struct JPAEmitterWorkData {};
struct JKRHeap {};
struct JPAFieldBlock {
/* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*);
/* 8027D0C0 */ void init(JKRHeap*);
};
struct JPABaseParticle {};
struct JPAFieldVortex {
/* 8027C56C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C674 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D564 */ ~JPAFieldVortex();
};
struct JPAFieldSpin {
/* 8027CE64 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027CFA8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D3F4 */ ~JPAFieldSpin();
};
struct JPAFieldRandom {
/* 8027CCCC */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D4AC */ ~JPAFieldRandom();
};
struct JPAFieldNewton {
/* 8027C36C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C3E0 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D5C0 */ ~JPAFieldNewton();
};
struct JPAFieldMagnet {
/* 8027C24C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C29C */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D61C */ ~JPAFieldMagnet();
};
struct JPAFieldGravity {
/* 8027BFB4 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C054 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D6D4 */ ~JPAFieldGravity();
};
struct JPAFieldDrag {
/* 8027CDE4 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D450 */ ~JPAFieldDrag();
};
struct JPAFieldConvection {
/* 8027C814 */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027CA94 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D508 */ ~JPAFieldConvection();
};
struct JPAFieldBase {
/* 80276A8C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027BDEC */ void calcAffect(JPAFieldBlock*, JPABaseParticle*);
/* 8027BF18 */ void calcFadeAffect(JPAFieldBlock*, f32) const;
/* 8027D3AC */ ~JPAFieldBase();
};
struct JPAFieldAir {
/* 8027C07C */ void prepare(JPAEmitterWorkData*, JPAFieldBlock*);
/* 8027C1B8 */ void calc(JPAEmitterWorkData*, JPAFieldBlock*, JPABaseParticle*);
/* 8027D678 */ ~JPAFieldAir();
};
//
// Forward References:
//
extern "C" void calcAffect__12JPAFieldBaseFP13JPAFieldBlockP15JPABaseParticle();
extern "C" void calcFadeAffect__12JPAFieldBaseCFP13JPAFieldBlockf();
extern "C" void prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void
calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle();
extern "C" void __ct__13JPAFieldBlockFPCUcP7JKRHeap();
extern "C" void init__13JPAFieldBlockFP7JKRHeap();
extern "C" void __dt__12JPAFieldBaseFv();
extern "C" void __dt__12JPAFieldSpinFv();
extern "C" void __dt__12JPAFieldDragFv();
extern "C" void __dt__14JPAFieldRandomFv();
extern "C" void __dt__18JPAFieldConvectionFv();
extern "C" void __dt__14JPAFieldVortexFv();
extern "C" void __dt__14JPAFieldNewtonFv();
extern "C" void __dt__14JPAFieldMagnetFv();
extern "C" void __dt__11JPAFieldAirFv();
extern "C" void __dt__15JPAFieldGravityFv();
//
// External References:
//
extern "C" void prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void PSMTXRotAxisRad();
extern "C" void PSMTXMultVecSR();
extern "C" void PSVECMag();
extern "C" void PSVECCrossProduct();
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
extern "C" extern u32 __float_epsilon;
//
// Declarations:
//
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "JSystem/JParticle/JPAParticle.h"
/* 8027BDEC-8027BF18 27672C 012C+00 8/8 0/0 0/0 .text
* calcAffect__12JPAFieldBaseFP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldBase::calcAffect(JPAFieldBlock* param_0, JPABaseParticle* param_1) {
// NONMATCHING
void JPAFieldBase::calcAffect(JPAFieldBlock* block, JPABaseParticle* ptcl) {
JGeometry::TVec3<f32> vec = mAccel;
if (!ptcl->checkStatus(4) && block->checkStatus(0x78)) {
vec.scale(calcFadeAffect(block, ptcl->mTime));
}
switch (block->getAddType()) {
case 0:
ptcl->mVelType0.add(vec);
break;
case 1:
ptcl->mVelType1.add(vec);
break;
case 2:
ptcl->mVelType2.add(vec);
break;
}
}
/* ############################################################################################## */
/* 80455338-8045533C 003938 0004+00 6/6 0/0 0/0 .sdata2 @2353 */
SECTION_SDATA2 static f32 lit_2353 = 1.0f;
/* 8045533C-80455340 00393C 0004+00 11/11 0/0 0/0 .sdata2 @2354 */
SECTION_SDATA2 static u8 lit_2354[4] = {
0x00,
0x00,
0x00,
0x00,
};
/* 8027BF18-8027BFB4 276858 009C+00 2/2 0/0 0/0 .text
* calcFadeAffect__12JPAFieldBaseCFP13JPAFieldBlockf */
void JPAFieldBase::calcFadeAffect(JPAFieldBlock* param_0, f32 param_1) const {
// NONMATCHING
f32 JPAFieldBase::calcFadeAffect(JPAFieldBlock* block, f32 time) const {
f32 fade = 1.0f;
if ((block->checkStatus(8) && time < block->getEnTime())
|| (block->checkStatus(0x10) && time >= block->getDisTime()))
{
fade = 0.0f;
} else if (block->checkStatus(0x40) && time >= block->getFadeOutTime()) {
fade = (block->getDisTime() - time) * block->getFadeOutRate();
} else if (block->checkStatus(0x20) && time < block->getFadeInTime()) {
fade = (time - block->getEnTime()) * block->getFadeInRate();
}
return fade;
}
/* 8027BFB4-8027C054 2768F4 00A0+00 1/0 0/0 0/0 .text
* prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldGravity::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldGravity::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
if (block->checkStatus(2)) {
mAccel.scale(block->getMag(), block->getDir());
} else {
MTXMultVecSR(work->mRotationMtx, &block->getDir(), &mAccel);
mAccel.scale(block->getMag());
}
}
/* 8027C054-8027C07C 276994 0028+00 1/0 0/0 0/0 .text
* calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldGravity::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldGravity::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
calcAffect(block, ptcl);
}
/* ############################################################################################## */
/* 80455340-80455344 003940 0004+00 8/8 0/0 0/0 .sdata2 @2459 */
SECTION_SDATA2 static f32 lit_2459 = 32.0f;
/* 80455344-80455348 003944 0004+00 9/9 0/0 0/0 .sdata2 @2460 */
SECTION_SDATA2 static f32 lit_2460 = 0.5f;
/* 80455348-8045534C 003948 0004+00 8/8 0/0 0/0 .sdata2 @2461 */
SECTION_SDATA2 static f32 lit_2461 = 3.0f;
/* 8027C07C-8027C1B8 2769BC 013C+00 1/0 0/0 0/0 .text
* prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldAir::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldAir::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
JGeometry::TVec3<f32> vec;
vec.normalize(block->getDir());
if (block->checkStatus(2)) {
mAccel.scale(block->getMag(), vec);
} else {
MTXMultVecSR(work->mRotationMtx, vec, mAccel);
mAccel.scale(block->getMag());
}
}
/* 8027C1B8-8027C24C 276AF8 0094+00 1/0 0/0 0/0 .text
* calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldAir::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldAir::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
calcAffect(block, ptcl);
if (block->checkStatus(4)) {
f32 len = ptcl->mVelType1.length();
if (len > block->getMagRndm()) {
ptcl->mVelType1.scale(block->getMagRndm() / len);
}
}
}
/* 8027C24C-8027C29C 276B8C 0050+00 1/0 0/0 0/0 .text
* prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldMagnet::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldMagnet::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
mDir.sub(block->getPos(), work->mEmitterPos);
MTXMultVecSR(work->mRotationMtx, &mDir, &mDir);
}
/* 8027C29C-8027C36C 276BDC 00D0+00 1/0 0/0 0/0 .text
* calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldMagnet::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldMagnet::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
mAccel.sub(mDir, ptcl->mLocalPosition);
mAccel.setLength(block->getMag());
calcAffect(block, ptcl);
}
/* 8027C36C-8027C3E0 276CAC 0074+00 1/0 0/0 0/0 .text
* prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldNewton::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldNewton::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
mDir.sub(block->getPos(), work->mEmitterPos);
MTXMultVecSR(work->mRotationMtx, &mDir, &mDir);
mCutoff = block->getVal1() * block->getVal1();
}
/* ############################################################################################## */
/* 8045534C-80455350 00394C 0004+00 1/1 0/0 0/0 .sdata2 @2656 */
SECTION_SDATA2 static f32 lit_2656 = 10.0f;
/* 8027C3E0-8027C56C 276D20 018C+00 1/0 0/0 0/0 .text
* calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldNewton::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldNewton::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
mAccel.sub(mDir, ptcl->mLocalPosition);
f32 len_sq = mAccel.squared();
if (len_sq > mCutoff) {
mAccel.setLength(mCutoff * (block->getMag() * 10.0f) / len_sq);
} else {
mAccel.setLength(block->getMag() * 10.0f);
}
calcAffect(block, ptcl);
}
/* 8027C56C-8027C674 276EAC 0108+00 1/0 0/0 0/0 .text
* prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldVortex::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldVortex::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
MTXMultVecSR(work->mGlobalRot, &block->getDir(), &field_0x10);
field_0x10.normalize();
field_0x1c = block->getPos().z * block->getPos().z;
field_0x20 = 1.0f / field_0x1c;
}
/* 8027C674-8027C814 276FB4 01A0+00 1/0 0/0 0/0 .text
* calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldVortex::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
// NONMATCHING regalloc. may need to rewrite dot in a way that doesn't break Z2Audience::calcPitchDoppler_
void JPAFieldVortex::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
JGeometry::TVec3<f32> vec;
vec.scale(field_0x10.dot(ptcl->mLocalPosition), field_0x10);
vec.sub(ptcl->mLocalPosition, vec);
f32 mag = vec.squared();
if (mag > field_0x1c) {
mag = block->getMagRndm();
} else {
mag *= field_0x20;
mag = (1.0f - mag) * block->getMag() + mag * block->getMagRndm();
}
vec.normalize();
mAccel.cross(vec, field_0x10);
mAccel.scale(mag);
calcAffect(block, ptcl);
}
/* 8027C814-8027CA94 277154 0280+00 1/0 0/0 0/0 .text
* prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldConvection::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldConvection::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
JGeometry::TVec3<f32> vec1, vec2;
vec2.cross(block->getPos(), block->getDir());
vec1.cross(block->getDir(), vec2);
MTXMultVecSR(work->mGlobalRot, &vec1, &field_0x10);
MTXMultVecSR(work->mGlobalRot, &block->getDir(), field_0x1c);
MTXMultVecSR(work->mGlobalRot, &vec2, &field_0x28);
field_0x10.normalize();
field_0x1c.normalize();
field_0x28.normalize();
}
/* 8027CA94-8027CCCC 2773D4 0238+00 1/0 0/0 0/0 .text
* calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldConvection::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
// NONMATCHING regalloc problems with TVec3 inlines
void JPAFieldConvection::calc(JPAEmitterWorkData* work, JPAFieldBlock* block,
JPABaseParticle* ptcl) {
JGeometry::TVec3<f32> vec1, vec2, vec3;
vec1.scale(field_0x10.dot(ptcl->mLocalPosition), field_0x10);
vec3.scale(field_0x28.dot(ptcl->mLocalPosition), field_0x28);
vec1.add(vec3);
vec1.setLength(vec1, block->getVal1());
vec2.sub(ptcl->mLocalPosition, vec1);
vec3.cross(field_0x1c, vec1);
mAccel.cross(vec3, vec2);
mAccel.setLength(block->getMag());
calcAffect(block, ptcl);
}
/* 8027CCCC-8027CDE4 27760C 0118+00 1/0 0/0 0/0 .text
* calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldRandom::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
// NONMATCHING missing clrlwi
void JPAFieldRandom::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
if (ptcl->mAge == 0 || (block->getCycle() != 0 && ptcl->mAge % block->getCycle() == 0)) {
JPABaseEmitter* emtr = work->mpEmtr;
mAccel.set(emtr->get_r_zh(), emtr->get_r_zh(), emtr->get_r_zh());
mAccel.scale(block->getMag());
calcAffect(block, ptcl);
}
}
/* 8027CDE4-8027CE64 277724 0080+00 1/0 0/0 0/0 .text
* calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldDrag::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldDrag::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
if (!ptcl->checkStatus(4)) {
f32 fade = calcFadeAffect(block, ptcl->mTime);
ptcl->mDrag *= 1.0f - fade * (1.0f - block->getMag());
} else {
ptcl->mDrag *= block->getMag();
}
}
/* 8027CE64-8027CFA8 2777A4 0144+00 1/0 0/0 0/0 .text
* prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldSpin::prepare(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1) {
// NONMATCHING
void JPAFieldSpin::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
JGeometry::TVec3<f32> axis;
MTXMultVecSR(work->mGlobalRot, &block->getDir(), &axis);
axis.normalize();
Mtx mtx;
MTXRotAxisRad(mtx, &axis, block->getMag());
field_0x10.set(mtx[0][0], mtx[1][0], mtx[2][0]);
field_0x1c.set(mtx[0][1], mtx[1][1], mtx[2][1]);
field_0x28.set(mtx[0][2], mtx[1][2], mtx[2][2]);
}
/* 8027CFA8-8027D088 2778E8 00E0+00 1/0 0/0 0/0 .text
* calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle */
void JPAFieldSpin::calc(JPAEmitterWorkData* param_0, JPAFieldBlock* param_1,
JPABaseParticle* param_2) {
// NONMATCHING
void JPAFieldSpin::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABaseParticle* ptcl) {
Mtx mtx;
mtx[0][0] = field_0x10.x;
mtx[1][0] = field_0x10.y;
mtx[2][0] = field_0x10.z;
mtx[0][1] = field_0x1c.x;
mtx[1][1] = field_0x1c.y;
mtx[2][1] = field_0x1c.z;
mtx[0][2] = field_0x28.x;
mtx[1][2] = field_0x28.y;
mtx[2][2] = field_0x28.z;
mtx[0][3] = mtx[1][3] = mtx[2][3] = 0.0f;
Vec vec;
MTXMultVecSR(mtx, &ptcl->mLocalPosition, &vec);
mAccel.set(vec.x - ptcl->mLocalPosition.x, vec.y - ptcl->mLocalPosition.y,
vec.z - ptcl->mLocalPosition.z);
calcAffect(block, ptcl);
}
/* 8027D088-8027D0C0 2779C8 0038+00 0/0 1/1 0/0 .text __ct__13JPAFieldBlockFPCUcP7JKRHeap
*/
JPAFieldBlock::JPAFieldBlock(u8 const* param_0, JKRHeap* param_1) {
// NONMATCHING
JPAFieldBlock::JPAFieldBlock(u8 const* data, JKRHeap* heap)
: mpData((const JPAFieldBlockData*)data) {
init(heap);
}
/* ############################################################################################## */
/* 803C44A8-803C44CC -00001 0024+00 1/1 0/0 0/0 .data @3259 */
SECTION_DATA static void* lit_3259[9] = {
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0xFC),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x130),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x164),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x198),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x1CC),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x200),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x234),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x268),
(void*)(((char*)init__13JPAFieldBlockFP7JKRHeap) + 0x29C),
};
/* 803C44CC-803C44E0 0215EC 0014+00 11/11 0/0 0/0 .data __vt__12JPAFieldBase */
SECTION_DATA extern void* __vt__12JPAFieldBase[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__12JPAFieldBaseFv,
(void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)NULL,
};
/* 803C44E0-803C44F4 021600 0014+00 2/2 0/0 0/0 .data __vt__12JPAFieldSpin */
SECTION_DATA extern void* __vt__12JPAFieldSpin[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__12JPAFieldSpinFv,
(void*)prepare__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__12JPAFieldSpinFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C44F4-803C4508 021614 0014+00 2/2 0/0 0/0 .data __vt__12JPAFieldDrag */
SECTION_DATA extern void* __vt__12JPAFieldDrag[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__12JPAFieldDragFv,
(void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__12JPAFieldDragFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C4508-803C451C 021628 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldRandom */
SECTION_DATA extern void* __vt__14JPAFieldRandom[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__14JPAFieldRandomFv,
(void*)prepare__12JPAFieldBaseFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__14JPAFieldRandomFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C451C-803C4530 02163C 0014+00 2/2 0/0 0/0 .data __vt__18JPAFieldConvection */
SECTION_DATA extern void* __vt__18JPAFieldConvection[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__18JPAFieldConvectionFv,
(void*)prepare__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__18JPAFieldConvectionFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C4530-803C4544 021650 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldVortex */
SECTION_DATA extern void* __vt__14JPAFieldVortex[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__14JPAFieldVortexFv,
(void*)prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C4544-803C4558 021664 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldNewton */
SECTION_DATA extern void* __vt__14JPAFieldNewton[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__14JPAFieldNewtonFv,
(void*)prepare__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__14JPAFieldNewtonFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C4558-803C456C 021678 0014+00 2/2 0/0 0/0 .data __vt__14JPAFieldMagnet */
SECTION_DATA extern void* __vt__14JPAFieldMagnet[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__14JPAFieldMagnetFv,
(void*)prepare__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__14JPAFieldMagnetFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C456C-803C4580 02168C 0014+00 2/2 0/0 0/0 .data __vt__11JPAFieldAir */
SECTION_DATA extern void* __vt__11JPAFieldAir[5] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__11JPAFieldAirFv,
(void*)prepare__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__11JPAFieldAirFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
};
/* 803C4580-803C4598 0216A0 0014+04 2/2 0/0 0/0 .data __vt__15JPAFieldGravity */
SECTION_DATA extern void* __vt__15JPAFieldGravity[5 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__15JPAFieldGravityFv,
(void*)prepare__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlock,
(void*)calc__15JPAFieldGravityFP18JPAEmitterWorkDataP13JPAFieldBlockP15JPABaseParticle,
/* padding */
NULL,
};
/* 8027D0C0-8027D3AC 277A00 02EC+00 2/1 0/0 0/0 .text init__13JPAFieldBlockFP7JKRHeap */
void JPAFieldBlock::init(JKRHeap* param_0) {
// NONMATCHING
}
void JPAFieldBlock::init(JKRHeap* heap) {
mFadeInRate = getFadeInTime() - getEnTime();
if (mFadeInRate == 0.0f) {
mFadeInRate = 1.0f;
} else {
mFadeInRate = 1.0f / mFadeInRate;
}
/* 8027D3AC-8027D3F4 277CEC 0048+00 1/0 0/0 0/0 .text __dt__12JPAFieldBaseFv */
JPAFieldBase::~JPAFieldBase() {
// NONMATCHING
}
mFadeOutRate = getDisTime() - getFadeOutTime();
if (mFadeOutRate == 0.0f) {
mFadeOutRate = 1.0f;
} else {
mFadeOutRate = 1.0f / mFadeOutRate;
}
/* 8027D3F4-8027D450 277D34 005C+00 1/0 0/0 0/0 .text __dt__12JPAFieldSpinFv */
JPAFieldSpin::~JPAFieldSpin() {
// NONMATCHING
}
getPosOrig(&mPos);
getDirOrig(&mDir);
mMag = getMagOrig();
/* 8027D450-8027D4AC 277D90 005C+00 1/0 0/0 0/0 .text __dt__12JPAFieldDragFv */
JPAFieldDrag::~JPAFieldDrag() {
// NONMATCHING
switch (getType()) {
case FIELD_GRAVITY:
mpField = new (heap, 0) JPAFieldGravity();
break;
case FIELD_AIR:
mpField = new (heap, 0) JPAFieldAir();
break;
case FIELD_MAGNET:
mpField = new (heap, 0) JPAFieldMagnet();
break;
case FIELD_NEWTON:
mpField = new (heap, 0) JPAFieldNewton();
break;
case FIELD_VORTEX:
mpField = new (heap, 0) JPAFieldVortex();
break;
case FIELD_RANDOM:
mpField = new (heap, 0) JPAFieldRandom();
break;
case FIELD_DRAG:
mpField = new (heap, 0) JPAFieldDrag();
break;
case FIELD_CONVECTION:
mpField = new (heap, 0) JPAFieldConvection();
break;
case FIELD_SPIN:
mpField = new (heap, 0) JPAFieldSpin();
break;
default:
mpField = NULL;
break;
}
}
/* 8027D4AC-8027D508 277DEC 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldRandomFv */
JPAFieldRandom::~JPAFieldRandom() {
// NONMATCHING
}
/* 8027D508-8027D564 277E48 005C+00 1/0 0/0 0/0 .text __dt__18JPAFieldConvectionFv */
JPAFieldConvection::~JPAFieldConvection() {
// NONMATCHING
}
/* 8027D564-8027D5C0 277EA4 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldVortexFv */
JPAFieldVortex::~JPAFieldVortex() {
// NONMATCHING
}
/* 8027D5C0-8027D61C 277F00 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldNewtonFv */
JPAFieldNewton::~JPAFieldNewton() {
// NONMATCHING
}
/* 8027D61C-8027D678 277F5C 005C+00 1/0 0/0 0/0 .text __dt__14JPAFieldMagnetFv */
JPAFieldMagnet::~JPAFieldMagnet() {
// NONMATCHING
}
/* 8027D678-8027D6D4 277FB8 005C+00 1/0 0/0 0/0 .text __dt__11JPAFieldAirFv */
JPAFieldAir::~JPAFieldAir() {
// NONMATCHING
}
/* 8027D6D4-8027D730 278014 005C+00 1/0 0/0 0/0 .text __dt__15JPAFieldGravityFv */
JPAFieldGravity::~JPAFieldGravity() {
// NONMATCHING
}

24
src/JSystem/JParticle/JPAKeyBlock.cpp
View File

@ -6,22 +6,6 @@
#include "JSystem/JParticle/JPAKeyBlock.h"
#include "JSystem/JParticle/JPAMath.h"
//
// Types:
//
//
// Forward References:
//
//
// External References:
//
//
// Declarations:
//
/* 8027D730-8027D740 278070 0010+00 0/0 1/1 0/0 .text __ct__11JPAKeyBlockFPCUc */
JPAKeyBlock::JPAKeyBlock(const u8* data)
: mDataStart(data)
@ -29,15 +13,13 @@ JPAKeyBlock::JPAKeyBlock(const u8* data)
{
}
/* ############################################################################################## */
/* 8027D740-8027D7D4 278080 0094+00 0/0 1/1 0/0 .text calc__11JPAKeyBlockFf */
void JPAKeyBlock::calc(float p1) {
f32 JPAKeyBlock::calc(float p1) {
if (mDataStart[0xB] != '\0') {
int v1 = (int)field_0x4[(mDataStart[9] - 1) * 4] + 1;
// p1 -= (v1 * ((int)p1 / v1));
int v2 = ((int)p1 / v1);
p1 = p1 - (v2 * v1);
}
JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4);
}
return JPACalcKeyAnmValue(p1, mDataStart[9], field_0x4);
}

379
src/JSystem/JParticle/JPAParticle.cpp
View File

@ -4,127 +4,332 @@
//
#include "JSystem/JParticle/JPAParticle.h"
#include "JSystem/JParticle/JPABaseShape.h"
#include "JSystem/JParticle/JPAChildShape.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "JSystem/JParticle/JPAEmitterManager.h"
#include "dol2asm.h"
//
// Forward References:
//
extern "C" void __dt__19JPAParticleCallBackFv();
extern "C" void init_p__15JPABaseParticleFP18JPAEmitterWorkData();
extern "C" void init_c__15JPABaseParticleFP18JPAEmitterWorkDataP15JPABaseParticle();
extern "C" void calc_p__15JPABaseParticleFP18JPAEmitterWorkData();
extern "C" void calc_c__15JPABaseParticleFP18JPAEmitterWorkData();
extern "C" void canCreateChild__15JPABaseParticleFP18JPAEmitterWorkData();
extern "C" void getWidth__15JPABaseParticleCFPC14JPABaseEmitter();
extern "C" void getHeight__15JPABaseParticleCFPC14JPABaseEmitter();
//
// External References:
//
extern "C" void calc_p__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle();
extern "C" void calc_c__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle();
extern "C" void calcField__11JPAResourceFP18JPAEmitterWorkDataP15JPABaseParticle();
extern "C" void createChild__14JPABaseEmitterFP15JPABaseParticle();
extern "C" void JPAGetYZRotateMtx__FssPA4_f();
extern "C" void __dl__FPv();
extern "C" void JMAVECScaleAdd__FPC3VecPC3VecP3Vecf();
extern "C" void _savegpr_26();
extern "C" void _savegpr_29();
extern "C" void _restgpr_26();
extern "C" void _restgpr_29();
extern "C" extern void* __vt__19JPAParticleCallBack[5];
//
// Declarations:
//
#include "JSystem/JParticle/JPAExtraShape.h"
/* 8027EFA4-8027EFEC 2798E4 0048+00 0/0 11/11 1/1 .text __dt__19JPAParticleCallBackFv */
JPAParticleCallBack::~JPAParticleCallBack() {
// NONMATCHING
/* empty function */
}
/* ############################################################################################## */
/* 80455388-8045538C 003988 0004+00 2/2 0/0 0/0 .sdata2 @2565 */
SECTION_SDATA2 static f32 lit_2565 = 1.0f;
/* 8045538C-80455390 00398C 0004+00 4/4 0/0 0/0 .sdata2 @2566 */
SECTION_SDATA2 static u8 lit_2566[4] = {
0x00,
0x00,
0x00,
0x00,
};
/* 80455390-80455394 003990 0004+00 2/2 0/0 0/0 .sdata2 @2567 */
SECTION_SDATA2 static f32 lit_2567 = 32.0f;
/* 80455394-80455398 003994 0004+00 2/2 0/0 0/0 .sdata2 @2568 */
SECTION_SDATA2 static f32 lit_2568 = 0.5f;
/* 80455398-8045539C 003998 0004+00 2/2 0/0 0/0 .sdata2 @2569 */
SECTION_SDATA2 static f32 lit_2569 = 3.0f;
/* 8045539C-804553A0 00399C 0004+00 1/1 0/0 0/0 .sdata2 @2570 */
SECTION_SDATA2 static f32 lit_2570 = 32768.0f;
/* 804553A0-804553A8 0039A0 0008+00 4/4 0/0 0/0 .sdata2 @2572 */
SECTION_SDATA2 static f64 lit_2572 = 4503601774854144.0 /* cast s32 to float */;
/* 804553A8-804553B0 0039A8 0008+00 2/2 0/0 0/0 .sdata2 @2574 */
SECTION_SDATA2 static f64 lit_2574 = 4503599627370496.0 /* cast u32 to float */;
/* 8027EFEC-8027F8C8 27992C 08DC+00 0/0 1/1 0/0 .text
* init_p__15JPABaseParticleFP18JPAEmitterWorkData */
void JPABaseParticle::init_p(JPAEmitterWorkData* param_0) {
// NONMATCHING
// NONMATCHING a couple problems, likely issues with setLength and get_r_ss
void JPABaseParticle::init_p(JPAEmitterWorkData* work) {
JPABaseEmitter* emtr = work->mpEmtr;
JPAExtraShape* esp = work->mpRes->getEsp();
JPABaseShape* bsp = work->mpRes->getBsp();
JPADynamicsBlock* dyn = work->mpRes->getDyn();
mAge = -1;
mLifeTime = (1.0f - dyn->getLifeTimeRndm() * emtr->get_r_f()) * emtr->mLifeTime;
mTime = 0.0f;
initStatus(0);
MTXMultVecSR(work->mGlobalSR, &work->mVolumePos, &mLocalPosition);
if (emtr->checkFlag(8)) {
setStatus(0x20);
}
mOffsetPosition.set(work->mGlobalPos);
mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x,
mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y,
mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z);
JGeometry::TVec3<f32> velOmni;
if (emtr->mAwayFromCenterSpeed) {
velOmni.setLength(work->mVelOmni, emtr->mAwayFromCenterSpeed);
} else {
velOmni.zero();
}
JGeometry::TVec3<f32> velAxis;
if (emtr->mAwayFromAxisSpeed) {
velAxis.setLength(work->mVelAxis, emtr->mAwayFromAxisSpeed);
} else {
velAxis.zero();
}
JGeometry::TVec3<f32> velDir;
if (emtr->mDirSpeed) {
Mtx mtx;
s16 angleY = emtr->get_r_ss();
s16 angleZ = emtr->get_r_zp() * 0x8000 * emtr->mSpread;
JPAGetYZRotateMtx(angleY, angleZ, mtx);
MTXConcat(work->mDirectionMtx, mtx, mtx);
velDir.set(emtr->mDirSpeed * mtx[0][2],
emtr->mDirSpeed * mtx[1][2],
emtr->mDirSpeed * mtx[2][2]);
} else {
velDir.zero();
}
JGeometry::TVec3<f32> velRndm;
if (emtr->mRndmDirSpeed) {
velRndm.set(emtr->mRndmDirSpeed * emtr->get_r_zh(),
emtr->mRndmDirSpeed * emtr->get_r_zh(),
emtr->mRndmDirSpeed * emtr->get_r_zh());
} else {
velRndm.zero();
}
f32 ratio = emtr->get_r_zp() * dyn->getInitVelRatio() + 1.0f;
mVelType1.set(ratio * (velOmni.x + velAxis.x + velDir.x + velRndm.x),
ratio * (velOmni.y + velAxis.y + velDir.y + velRndm.y),
ratio * (velOmni.z + velAxis.z + velDir.z + velRndm.z));
if (emtr->checkFlag(4)) {
mVelType1.mul(emtr->mLocalScl);
}
MTXMultVecSR(work->mGlobalRot, &mVelType1, &mVelType1);
mVelType0.zero();
mMoment = 1.0f - dyn->getMomentRndm() * emtr->get_r_f();
mDrag = 1.0f;
field_0x78 = 0;
mBaseAxis.set(work->mGlobalRot[0][1], work->mGlobalRot[1][1], work->mGlobalRot[2][1]);
mPrmClr = emtr->mPrmClr;
mEnvClr = emtr->mEnvClr;
mAnmRandom = emtr->get_r_f() * bsp->getLoopOfstValue();
if (esp != NULL && esp->isEnableScaleAnm()) {
f32 scale = emtr->mScaleOut * (emtr->get_r_zp() * esp->getScaleRndm() + 1.0f);
mParticleScaleX = mParticleScaleY = mScaleOut = scale;
} else {
mParticleScaleX = mParticleScaleY = mScaleOut = emtr->mScaleOut;
}
mPrmColorAlphaAnm = 0xff;
if (esp != NULL && esp->isEnableAlphaFlick()) {
mAlphaWaveRandom = emtr->get_r_zp() * esp->getAlphaFreqRndm() + 1.0f;
} else {
mAlphaWaveRandom = 1.0f;
}
if (esp != NULL) {
if (esp->isEnableRotateAnm()) {
mRotateAngle = esp->getRotateInitAngle() + esp->getRotateRndmAngle() * emtr->get_r_zh();
mRotateSpeed = esp->getRotateInitSpeed() *
(esp->getRotateRndmSpeed() * emtr->get_r_zp() + 1.0f);
mRotateSpeed = emtr->get_r_zp() < esp->getRotateDirection() ?
mRotateSpeed : (s16)-mRotateSpeed;
} else {
mRotateAngle = 0;
mRotateSpeed = 0;
}
} else {
mRotateAngle = 0;
mRotateSpeed = 0;
}
}
/* 8027F8C8-8027FFD0 27A208 0708+00 0/0 1/1 0/0 .text
* init_c__15JPABaseParticleFP18JPAEmitterWorkDataP15JPABaseParticle */
void JPABaseParticle::init_c(JPAEmitterWorkData* param_0, JPABaseParticle* param_1) {
// NONMATCHING
void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent) {
JPABaseEmitter* emtr = work->mpEmtr;
JPAChildShape* csp = work->mpRes->getCsp();
mAge = -1;
mLifeTime = csp->getLife();
mTime = 0.0f;
initStatus(4);
mLocalPosition.set(parent->mLocalPosition);
f32 pos_rndm = csp->getPosRndm();
if (pos_rndm != 0.0f) {
JGeometry::TVec3<f32> rnd(emtr->get_r_zh(), emtr->get_r_zh(), emtr->get_r_zh());
rnd.setLength(pos_rndm * emtr->get_r_f());
mLocalPosition.add(rnd);
}
if (emtr->checkFlag(0x10)) {
setStatus(0x20);
}
mOffsetPosition.set(parent->mOffsetPosition);
f32 base_speed = csp->getBaseVel() * (csp->getBaseVelRndm() * emtr->get_r_zp() + 1.0f);
JGeometry::TVec3<f32> base_vel(emtr->get_r_zp(), emtr->get_r_zp(), emtr->get_r_zp());
base_vel.setLength(base_speed);
mVelType1.scaleAdd(csp->getVelInhRate(), parent->mVelType1, base_vel);
mVelType0.scale(csp->getVelInhRate(), parent->mVelType2);
mMoment = parent->mMoment;
if (csp->isFieldAffected()) {
mDrag = parent->mDrag;
} else {
setStatus(0x40);
mDrag = 1.0f;
}
field_0x78 = parent->field_0x78;
mVelType2.set(mVelType0);
f32 ratio = mMoment * mDrag;
mVelocity.set(ratio * (mVelType1.x + mVelType2.x),
ratio * (mVelType1.y + mVelType2.y),
ratio * (mVelType1.z + mVelType2.z));
mBaseAxis.set(parent->mBaseAxis);
if (csp->isScaleInherited()) {
mParticleScaleX = mScaleOut = parent->mParticleScaleX * csp->getScaleInhRate();
mParticleScaleY = mAlphaWaveRandom = parent->mParticleScaleY * csp->getScaleInhRate();
} else {
mParticleScaleX = mScaleOut = mParticleScaleY = mAlphaWaveRandom = 1.0f;
}
if (csp->isColorInherited()) {
mPrmClr.r = parent->mPrmClr.r * csp->getColorInhRate();
mPrmClr.g = parent->mPrmClr.g * csp->getColorInhRate();
mPrmClr.b = parent->mPrmClr.b * csp->getColorInhRate();
mEnvClr.r = parent->mEnvClr.r * csp->getColorInhRate();
mEnvClr.g = parent->mEnvClr.g * csp->getColorInhRate();
mEnvClr.b = parent->mEnvClr.b * csp->getColorInhRate();
} else {
csp->getPrmClr(&mPrmClr);
csp->getEnvClr(&mEnvClr);
}
mPrmColorAlphaAnm = 0xff;
if (csp->isAlphaInherited()) {
mPrmClr.a = COLOR_MULTI(parent->mPrmClr.a, parent->mPrmColorAlphaAnm)
* csp->getAlphaInhRate();
} else {
mPrmClr.a = csp->getPrmAlpha();
}
mRotateAngle = parent->mRotateAngle;
if (csp->isRotateOn()) {
mRotateSpeed = csp->getRotInitSpeed();
} else {
mRotateSpeed = 0;
}
mTexAnmIdx = 0;
}
/* 8027FFD0-80280260 27A910 0290+00 0/0 1/1 0/0 .text
* calc_p__15JPABaseParticleFP18JPAEmitterWorkData */
void JPABaseParticle::calc_p(JPAEmitterWorkData* param_0) {
// NONMATCHING
bool JPABaseParticle::calc_p(JPAEmitterWorkData* work) {
if (++mAge >= mLifeTime) {
return true;
}
mTime = (f32)mAge / (f32)mLifeTime;
if (checkStatus(0x20)) {
mOffsetPosition.set(work->mGlobalPos);
}
mVelType2.zero();
if (!checkStatus(0x40)) {
work->mpRes->calcField(work, this);
}
mVelType2.add(mVelType0);
mVelType1.scale(work->mpEmtr->mAirResist);
f32 ratio = mMoment * mDrag;
mVelocity.set(ratio * (mVelType1.x + mVelType2.x),
ratio * (mVelType1.y + mVelType2.y),
ratio * (mVelType1.z + mVelType2.z));
if (work->mpEmtr->mpPtclCallBack != NULL) {
work->mpEmtr->mpPtclCallBack->execute(work->mpEmtr, this);
}
if (checkStatus(2)) {
return true;
}
work->mpRes->calc_p(work, this);
mRotateAngle += mRotateSpeed;
if (work->mpRes->getCsp() != NULL && canCreateChild(work)) {
for (int i = work->mpRes->getCsp()->getRate(); i > 0; i--) {
work->mpEmtr->createChild(this);
}
}
mLocalPosition.add(mVelocity);
mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x,
mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y,
mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z);
return false;
}
/* 80280260-802804C8 27ABA0 0268+00 0/0 1/1 0/0 .text
* calc_c__15JPABaseParticleFP18JPAEmitterWorkData */
void JPABaseParticle::calc_c(JPAEmitterWorkData* param_0) {
// NONMATCHING
bool JPABaseParticle::calc_c(JPAEmitterWorkData* work) {
if (++mAge >= mLifeTime) {
return true;
}
mTime = (f32)mAge / (f32)mLifeTime;
if (mAge != 0) {
if (checkStatus(0x20)) {
mOffsetPosition.set(work->mGlobalPos);
}
mVelType1.y -= work->mpRes->getCsp()->getGravity();
mVelType2.zero();
if (!checkStatus(0x40)) {
work->mpRes->calcField(work, this);
}
mVelType2.add(mVelType0);
mVelType1.scale(work->mpEmtr->mAirResist);
f32 ratio = mMoment * mDrag;
mVelocity.set(ratio * (mVelType1.x + mVelType2.x),
ratio * (mVelType1.y + mVelType2.y),
ratio * (mVelType1.z + mVelType2.z));
}
if (work->mpEmtr->mpPtclCallBack != NULL) {
work->mpEmtr->mpPtclCallBack->execute(work->mpEmtr, this);
}
if (checkStatus(2)) {
return true;
}
work->mpRes->calc_c(work, this);
mRotateAngle += mRotateSpeed;
mLocalPosition.add(mVelocity);
mPosition.set(mOffsetPosition.x + mLocalPosition.x * work->mPublicScale.x,
mOffsetPosition.y + mLocalPosition.y * work->mPublicScale.y,
mOffsetPosition.z + mLocalPosition.z * work->mPublicScale.z);
return false;
}
/* 802804C8-80280548 27AE08 0080+00 1/1 0/0 0/0 .text
* canCreateChild__15JPABaseParticleFP18JPAEmitterWorkData */
void JPABaseParticle::canCreateChild(JPAEmitterWorkData* param_0) {
// NONMATCHING
bool JPABaseParticle::canCreateChild(JPAEmitterWorkData* work) {
JPAChildShape* csp = work->mpRes->getCsp();
bool ret = false;
int time = mAge - (int)((mLifeTime - 1) * csp->getTiming());
if (time >= 0 && time % (csp->getStep() + 1) == 0) {
ret = true;
}
return ret;
}
/* ############################################################################################## */
/* 804553B0-804553B8 0039B0 0004+04 2/2 0/0 0/0 .sdata2 @3010 */
SECTION_SDATA2 static f32 lit_3010[1 + 1 /* padding */] = {
2.0f,
/* padding */
0.0f,
};
/* 80280548-80280568 27AE88 0020+00 0/0 3/3 0/0 .text
* getWidth__15JPABaseParticleCFPC14JPABaseEmitter */
f32 JPABaseParticle::getWidth(JPABaseEmitter const* emtr) const {
f32 scale = lit_3010[0] * mParticleScaleX;
f32 scale = 2.0f * mParticleScaleX;
return scale * emtr->mpEmtrMgr->mpWorkData->mGlobalPtclScl.x;
}
/* 80280568-80280588 27AEA8 0020+00 0/0 3/3 0/0 .text
* getHeight__15JPABaseParticleCFPC14JPABaseEmitter */
f32 JPABaseParticle::getHeight(JPABaseEmitter const* emtr) const {
f32 scale = lit_3010[0] * mParticleScaleY;
f32 scale = 2.0f * mParticleScaleY;
return scale * emtr->mpEmtrMgr->mpWorkData->mGlobalPtclScl.y;
}
}

1599
src/JSystem/JParticle/JPAResource.cpp
View File

File diff suppressed because it is too large Load Diff

176
src/JSystem/JParticle/JPAResourceLoader.cpp
View File

@ -4,93 +4,103 @@
//
#include "JSystem/JParticle/JPAResourceLoader.h"
#include "dolphin/types.h"
//
// Types:
//
struct JPATexture {
/* 8027D7D4 */ JPATexture(u8 const*);
};
struct JKRHeap {};
struct JPAResource {
/* 80274010 */ JPAResource();
/* 80274080 */ void init(JKRHeap*);
};
struct JPAResourceManager {
/* 80273F8C */ void registRes(JPAResource*);
/* 80273FAC */ void registTex(JPATexture*);
};
struct JPAResourceLoader {
/* 8027D8A0 */ JPAResourceLoader(u8 const*, JPAResourceManager*);
/* 8027D8E0 */ void load_jpc(u8 const*, JPAResourceManager*);
};
struct JPAKeyBlock {
/* 8027D730 */ JPAKeyBlock(u8 const*);
};
struct JPAFieldBlock {
/* 8027D088 */ JPAFieldBlock(u8 const*, JKRHeap*);
};
struct JPAExtraShape {
/* 8027AD88 */ JPAExtraShape(u8 const*);
};
struct JPADynamicsBlock {
/* 8027BB18 */ JPADynamicsBlock(u8 const*);
};
struct JPABaseShape {
/* 8027A6DC */ JPABaseShape(u8 const*, JKRHeap*);
};
//
// Forward References:
//
extern "C" void __ct__17JPAResourceLoaderFPCUcP18JPAResourceManager();
extern "C" void load_jpc__17JPAResourceLoaderFPCUcP18JPAResourceManager();
//
// External References:
//
extern "C" void registRes__18JPAResourceManagerFP11JPAResource();
extern "C" void registTex__18JPAResourceManagerFP10JPATexture();
extern "C" void __ct__11JPAResourceFv();
extern "C" void init__11JPAResourceFP7JKRHeap();
extern "C" void __ct__12JPABaseShapeFPCUcP7JKRHeap();
extern "C" void __ct__13JPAExtraShapeFPCUc();
extern "C" void __ct__13JPAChildShapeFPCUc();
extern "C" void __ct__13JPAExTexShapeFPCUc();
extern "C" void __ct__16JPADynamicsBlockFPCUc();
extern "C" void __ct__13JPAFieldBlockFPCUcP7JKRHeap();
extern "C" void __ct__11JPAKeyBlockFPCUc();
extern "C" void __ct__10JPATextureFPCUc();
extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void* __nwa__FUlP7JKRHeapi();
extern "C" void _savegpr_18();
extern "C" void _restgpr_18();
//
// Declarations:
//
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JParticle/JPABaseShape.h"
#include "JSystem/JParticle/JPAChildShape.h"
#include "JSystem/JParticle/JPADynamicsBlock.h"
#include "JSystem/JParticle/JPAExTexShape.h"
#include "JSystem/JParticle/JPAExtraShape.h"
#include "JSystem/JParticle/JPAFieldBlock.h"
#include "JSystem/JParticle/JPAKeyBlock.h"
#include "JSystem/JParticle/JPAResource.h"
#include "JSystem/JParticle/JPAResourceManager.h"
/* 8027D8A0-8027D8E0 2781E0 0040+00 0/0 1/1 0/0 .text
* __ct__17JPAResourceLoaderFPCUcP18JPAResourceManager */
JPAResourceLoader::JPAResourceLoader(u8 const* param_0, JPAResourceManager* param_1) {
// NONMATCHING
JPAResourceLoader::JPAResourceLoader(u8 const* data, JPAResourceManager* mgr) {
if (*(u32*)(data + 4) == '2-10') {
load_jpc(data, mgr);
}
}
struct JPAResourceHeader {
/* 0x0 */ u16 mUsrIdx;
/* 0x2 */ u16 mBlockNum;
/* 0x4 */ u8 mFieldBlockNum;
/* 0x5 */ u8 mKeyBlockNum;
/* 0x6 */ u8 mTDB1Num;
};
/* 8027D8E0-8027DCA0 278220 03C0+00 1/1 0/0 0/0 .text
* load_jpc__17JPAResourceLoaderFPCUcP18JPAResourceManager */
void JPAResourceLoader::load_jpc(u8 const* param_0, JPAResourceManager* param_1) {
// NONMATCHING
}
void JPAResourceLoader::load_jpc(u8 const* data, JPAResourceManager* mgr) {
JKRHeap* heap = mgr->mpHeap;
mgr->mResMax = *(u16*)(data + 8);
mgr->mTexMax = *(u16*)(data + 0xA);
mgr->mpResArr = new (heap, 0) JPAResource*[mgr->mResMax];
mgr->mpTexArr = new (heap, 0) JPATexture*[mgr->mTexMax];
u32 offset = 0x10;
for (int i = 0; i < *(u16*)(data + 8); i++) {
JPAResourceHeader* header = (JPAResourceHeader*)(data + offset);
JPAResource* res = new (heap, 0) JPAResource();
res->mFieldBlockNum = header->mFieldBlockNum;
res->mpFieldBlocks = res->mFieldBlockNum != 0 ?
new (heap, 0) JPAFieldBlock*[res->mFieldBlockNum] : NULL;
res->mKeyBlockNum = header->mKeyBlockNum;
res->mpKeyBlocks = res->mKeyBlockNum != 0 ?
new (heap, 0) JPAKeyBlock*[res->mKeyBlockNum] : NULL;
res->mTDB1Num = header->mTDB1Num;
res->mpTDB1 = NULL;
res->mUsrIdx = header->mUsrIdx;
offset += 8;
u32 field_idx = 0;
u32 key_idx = 0;
for (int j = 0; j < header->mBlockNum; j++) {
u32 magic = *(u32*)(data + offset);
u32 size = *(u32*)(data + offset + 4);
switch (magic) {
case 'FLD1':
res->mpFieldBlocks[field_idx] = new (heap, 0) JPAFieldBlock(data + offset, heap);
field_idx++;
break;
case 'KFA1':
res->mpKeyBlocks[key_idx] = new (heap, 0) JPAKeyBlock(data + offset);
key_idx++;
break;
case 'BEM1':
res->mpDynamicsBlock = new (heap, 0) JPADynamicsBlock(data + offset);
break;
case 'BSP1':
res->mpBaseShape = new (heap, 0) JPABaseShape(data + offset, heap);
break;
case 'ESP1':
res->mpExtraShape = new (heap, 0) JPAExtraShape(data + offset);
break;
case 'SSP1':
res->mpChildShape = new (heap, 0) JPAChildShape(data + offset);
break;
case 'ETX1':
res->mpExTexShape = new (heap, 0) JPAExTexShape(data + offset);
break;
case 'TDB1':
res->mpTDB1 = (const u16*)(data + offset + 8);
break;
}
offset += size;
}
res->init(heap);
mgr->registRes(res);
}
offset = *(u32*)(data + 0xC);
for (int i = 0; i < *(u16*)(data + 0xA); i++) {
u32 size = *(u32*)(data + offset + 4);
JPATexture* tex = new (heap, 0) JPATexture(data + offset);
mgr->registTex(tex);
offset += size;
}
}

7
src/d/actor/d_a_ep.cpp
View File

@ -148,10 +148,6 @@ struct _GXTexObj {};
struct LIGHT_INFLUENCE {};
struct JMath {
static u8 sincosTable_[65536];
};
struct J3DUClipper {
/* 8027378C */ void calcViewFrustum();
};
@ -286,7 +282,6 @@ extern "C" void MtxPosition__FP4cXyzP4cXyz();
extern "C" void calcViewFrustum__11J3DUClipperFv();
extern "C" void seStart__7Z2SeMgrF10JAISoundIDPC3VecUlScffffUc();
extern "C" void __dl__FPv();
extern "C" void PSMTXCopy();
extern "C" void __construct_array();
extern "C" void _savegpr_22();
extern "C" void _savegpr_25();
@ -1170,4 +1165,4 @@ static void func_8046AFB4() {
// NONMATCHING
}
/* 8046B0D0-8046B0D0 00010C 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
/* 8046B0D0-8046B0D0 00010C 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */