mirror/tww
1
0
Fork 0
mirror of https://github.com/zeldaret/tww.git synced 2026-08-19 05:22:39 -04:00
Code Issues Packages Projects Releases Wiki Activity

JPAField start

Browse Source
This commit is contained in:
Jasper St. Pierre
2023-11-11 16:09:23 -08:00
parent d19b7859e9
commit fef715c69b
10 changed files with 363 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/JSystem/JParticle/JPABaseShape.cpp
+10 -19
View File
@@ -90,40 +90,31 @@ static void dummy() {
}
/* 80257248-80257508 .text __ct__15JPABaseShapeArcFPCUcP7JKRHeap */
JPABaseShapeArc::JPABaseShapeArc(const u8* pData, JKRHeap* pHeap) {
JPABaseShapeArc::JPABaseShapeArc(const u8* data, JKRHeap* pHeap) {
/* Nonmatching */
pBsd = (const JPABaseShapeData*) pData;
mColLoopOffset = -((u16)(pBsd->mFlags >> 11) & 1);
mTexLoopOffset = -((u16)(pBsd->mFlags >> 13) & 1);
pBsd = reinterpret_cast<const JPABaseShapeData*>(data+0x0C);
mColLoopOffset = -((pBsd->mFlags >> 11) & 0x01);
mTexLoopOffset = -((pBsd->mFlags >> 13) & 0x01);
bool bFlag2 = false;
if (!(pBsd->mFlags & 0x1000)) {
if (getType() == JPAType_Stripe || getType() == JPAType_StripeCross)
bFlag2 = true;
}
bool isEnableGlobalColAnm = (!(pBsd->mFlags & 0x1000) && (getType() == JPAType_Stripe || getType() == JPAType_StripeCross)) ? true : false;
bool isEnableGlobalTexAnm = (!(pBsd->mFlags & 0x4000) && (getType() == JPAType_Stripe || getType() == JPAType_StripeCross)) ? true : false;
mGlobalAnmFlags = isEnableGlobalColAnm << 1 | isEnableGlobalTexAnm << 0;
bool bFlag1 = false;
if (!(pBsd->mFlags & 0x4000)) {
if (getType() == JPAType_Stripe || getType() == JPAType_StripeCross)
bFlag1 = true;
}
mGlobalAnmFlags = bFlag2 << 1 | bFlag1 << 0;
if (isEnableTextureAnm() && getTextureAnmKeyNum() != 0)
mpTexAnmIdxArr = (const u8*)(pData + 0x60);
mpTexAnmIdxArr = (const u8*)(data + 0x60);
else
mpTexAnmIdxArr = NULL;
if (isEnablePrmAnm()) {
JUT_ASSERT(0x11f, pBsd->prmAnmKeyNum != 0);
mpPrmColorArr = makeColorTable((JPAColorRegAnmKey*)(pData + pBsd->mPrmAnimDataOffs), pBsd->prmAnmKeyNum, pBsd->mColorRegAnmMaxFrm, pHeap);
mpPrmColorArr = makeColorTable((JPAColorRegAnmKey*)(data + pBsd->mPrmAnimDataOffs), pBsd->prmAnmKeyNum, pBsd->mColorRegAnmMaxFrm, pHeap);
} else {
mpPrmColorArr = NULL;
}
if (isEnableEnvAnm()) {
JUT_ASSERT(0x127, pBsd->envAnmKeyNum != 0);
mpEnvColorArr = makeColorTable((JPAColorRegAnmKey*)(pData + pBsd->mEnvAnimDataOffs), pBsd->envAnmKeyNum, pBsd->mColorRegAnmMaxFrm, pHeap);
mpEnvColorArr = makeColorTable((JPAColorRegAnmKey*)(data + pBsd->mEnvAnimDataOffs), pBsd->envAnmKeyNum, pBsd->mColorRegAnmMaxFrm, pHeap);
} else {
mpEnvColorArr = NULL;
}
src/JSystem/JParticle/JPAEmitter.cpp
+94 -4
View File
@@ -4,8 +4,10 @@
//
#include "JSystem/JParticle/JPAEmitter.h"
#include "JSystem/JParticle/JPADynamicsBlock.h"
#include "JSystem/JParticle/JPAExtraShape.h"
#include "JSystem/JParticle/JPASweepShape.h"
#include "JSystem/JParticle/JPAKeyBlock.h"
#include "dolphin/mtx/mtx.h"
#include "dolphin/mtx/mtxvec.h"
@@ -58,8 +60,71 @@ void JPABaseEmitter::calcVolumeTorus() {
}
/* 8025CB54-8025D0B0 .text create__14JPABaseEmitterFP20JPADataBlockLinkInfo */
void JPABaseEmitter::create(JPADataBlockLinkInfo*) {
/* Nonmatching */
void JPABaseEmitter::create(JPADataBlockLinkInfo* info) {
mpDataLinkInfo = info;
JPADynamicsBlock * dyn = getEmitterDataBlockInfoPtr()->getDynamics();
dyn->getEmitterScl(mEmitterScale);
dyn->getEmitterTrs(mEmitterTranslation);
dyn->getEmitterRot(mEmitterRot);
mVolumeType = dyn->getVolumeType();
mRateStep = dyn->getRateStep();
mDivNumber = dyn->getDivNumber();
mRate = dyn->getRate();
mRateRndm = dyn->getRateRndm();
mMaxFrame = dyn->getMaxFrame();
mStartFrame = dyn->getStartFrame();
mVolumeSize = dyn->getVolumeSize();
mVolumeSweep = dyn->getVolumeSweep();
mVolumeMinRad = dyn->getVolumeMinRad();
mLifeTime = dyn->getLifeTime();
mLifeTimeRndm = dyn->getLifeTimeRndm();
mMoment = dyn->getMoment();
mMomentRndm = dyn->getMomentRndm();
mInitialVelRatio = dyn->getInitVelRatio();
mAccelRndm = dyn->getAccelRndm();
mAirResist = dyn->getAirResist();
mAirResistRndm = dyn->getAirResistRndm();
mInitialVelOmni = dyn->getInitVelOmni();
mInitialVelAxis = dyn->getInitVelAxis();
mInitialVelRndm = dyn->getInitVelRndm();
mInitialVelDir = dyn->getInitVelDir();
mAccel = dyn->getAccel();
dyn->getEmitterDir(mEmitterDir);
// This appears to be an attempt at a normalize, but it scales by the length instead (???)
mEmitterDir.normalize_broken();
mSpread = dyn->getSpread();
mDataFlag = dyn->getDataFlag();
mUseKeyFlag = dyn->getUseKeyFlag();
mFlags = JPAEmtrStts_FirstEmit | JPAEmtrStts_RateStepEmit;
MTXIdentity(mGlobalRotation);
mGlobalDynamicsScale.x = 1.0f;
mGlobalDynamicsScale.y = 1.0f;
mGlobalDynamicsScale.z = 1.0f;
mGlobalTranslation.zero();
mGlobalParticleScale.x = 1.0f;
mGlobalParticleScale.y = 1.0f;
mGlobalParticleScale.z = 1.0f;
mGlobalEnvColor.r = mGlobalEnvColor.g = mGlobalEnvColor.b = mGlobalEnvColor.a = 0xFF;
mGlobalPrmColor.r = mGlobalPrmColor.g = mGlobalPrmColor.b = mGlobalPrmColor.a = 0xFF;
mEmitCount = 0.0f;
mRateStepTimer = 0.0f;
mTick = 0.0f;
mTime = 0.0f;
mUserData = 0;
mRandomSeed.setSeed(emtrInfo.mRandom.get());
mFieldManager.initField(info, &emtrInfo);
switch (mVolumeType) {
case 0: mVolumeFunc = &JPABaseEmitter::calcVolumeCube; break;
case 1: mVolumeFunc = &JPABaseEmitter::calcVolumeSphere; break;
case 2: mVolumeFunc = &JPABaseEmitter::calcVolumeCylinder; break;
case 3: mVolumeFunc = &JPABaseEmitter::calcVolumeTorus; break;
case 4: mVolumeFunc = &JPABaseEmitter::calcVolumePoint; break;
case 5: mVolumeFunc = &JPABaseEmitter::calcVolumeCircle; break;
case 6: mVolumeFunc = &JPABaseEmitter::calcVolumeLine; break;
default: mVolumeFunc = NULL; break;
}
}
/* 8025D0B0-8025D294 .text calcEmitterInfo__14JPABaseEmitterFv */
@@ -94,7 +159,7 @@ void JPABaseEmitter::calcEmitterInfo() {
emtrInfo.mPublicScale.x = mGlobalDynamicsScale.x * 1.0f;
emtrInfo.mPublicScale.y = mGlobalDynamicsScale.y * 1.0f;
emtrInfo.mPublicScale.z = mGlobalDynamicsScale.z * 1.0f;
MTXMultVec(mtx, &mEmitterTranslation, emtrInfo.mEmitterGlobalCenter);
MTXMultVec(mtx, mEmitterTranslation, emtrInfo.mEmitterGlobalCenter);
}
/* 8025D294-8025D3C0 .text calc__14JPABaseEmitterFv */
@@ -210,6 +275,31 @@ void JPABaseEmitter::calcChild() {
/* 8025D8CC-8025DA90 .text calcKey__14JPABaseEmitterFv */
void JPABaseEmitter::calcKey() {
/* Nonmatching */
for (u32 i = 0; i < getEmitterDataBlockInfoPtr()->getKeyNum(); i++) {
JPAKeyBlock* key = getEmitterDataBlockInfoPtr()->getKey()[i];
f32 tick = mTick;
const f32* dataPtr = key->getKeyDataPtr();
u32 dataNum = key->getNumber();
if (key->isLoopEnable()) {
s32 tickMax = (s32)(dataPtr[(dataNum - 1) * 4]) + 1;
tick -= (s32)tick % (s32)tickMax;
}
f32 value = JPAGetKeyFrameValue(tick, dataNum, dataPtr);
switch (key->getID()) {
case 0: mRate = value; break;
case 1: mVolumeSize = value; break;
case 2: mVolumeSweep = value; break;
case 3: mVolumeMinRad = value; break;
case 4: mLifeTime = value; break;
case 5: mMoment = value; break;
case 6: mInitialVelOmni = value; break;
case 7: mInitialVelAxis = value; break;
case 8: mInitialVelDir = value; break;
case 9: mSpread = value; break;
case 10: mDraw.mScaleOut = value; break;
}
}
}
/* 8025DA90-8025DAD8 .text deleteParticle__14JPABaseEmitterFP15JPABaseParticleP26JSUList<15JPABaseParticle> */
@@ -286,7 +376,7 @@ void JPABaseEmitter::calcEmitterGlobalPosition(JGeometry::TVec3<float>& dst) {
mtx[0][3] = mGlobalTranslation.x;
mtx[1][3] = mGlobalTranslation.y;
mtx[2][3] = mGlobalTranslation.z;
MTXMultVec(mtx, &mEmitterTranslation, dst);
MTXMultVec(mtx, mEmitterTranslation, dst);
}
/* 8025DD5C-8025DDE8 .text calcgReRDirection__14JPABaseEmitterFv */
src/JSystem/JParticle/JPAEmitterLoader.cpp
+16 -11
View File
@@ -20,6 +20,8 @@
class JPAEmitterArchiveLoader_v10 {
public:
void load();
JPAEmitterResource* getEmitterResource() { return mpEmtrRes; }
JPATextureResource* getTextureResource() { return mpTexRes; }
public:
/* 0x00 */ JKRHeap* pHeap;
@@ -41,8 +43,8 @@ void JPAEmitterArchiveLoaderDataBase::load(const u8* data, JKRHeap* heap, JPAEmi
loader.mpEmtrRes = NULL;
loader.mpTexRes = NULL;
loader.load();
*dstEmtrRes = loader.mpEmtrRes;
*dstTexRes = loader.mpTexRes;
*dstEmtrRes = loader.getEmitterResource();
*dstTexRes = loader.getTextureResource();
} else {
JUT_WARN(201, "%s", "This is WRONG Version File\n");
}
@@ -65,7 +67,9 @@ void JPAEmitterArchiveLoader_v10::load() {
mpTexRes = new(pHeap, 0) JPATextureResource(header->texResNum, pHeap);
u32 offs = 0x20;
for (u32 i = 0; i < header->emtrResNum; i++) {
for (s32 i = 0; i < header->emtrResNum; i++) {
const u8* data = &pData[offs];
JPAEmitterData* pEmtrRes = new(pHeap, 0) JPAEmitterData();
JUT_ASSERT(234, pEmtrRes);
@@ -77,21 +81,22 @@ void JPAEmitterArchiveLoader_v10::load() {
JUT_ASSERT(243, pEmtrRes->pLinkInfoArray);
pEmtrRes->pLinkInfoArray[0] = pLinkInfo;
pLinkInfo->keyNum = pData[offs + 0x14];
pLinkInfo->keyNum = data[0x14];
pLinkInfo->keyBlocks = (JPAKeyBlock**) (pLinkInfo->keyNum != 0 ? new(pHeap, 0) JPAKeyBlockArc*[pLinkInfo->keyNum] : NULL);
JUT_ASSERT(250, pLinkInfo->keyBlocks || pLinkInfo->keyNum == 0);
pLinkInfo->fldNum = pData[offs + 0x15];
pLinkInfo->fldNum = data[0x15];
pLinkInfo->fldBlocks = (JPAFieldBlock**) (pLinkInfo->fldNum != 0 ? new(pHeap, 0) JPAFieldBlockArc*[pLinkInfo->fldNum] : NULL);
JUT_ASSERT(256, pLinkInfo->fldBlocks || pLinkInfo->fldNum == 0);
pLinkInfo->mTextureNum = pData[offs + 0x16];
pLinkInfo->mTextureNum = data[0x16];
pLinkInfo->texDataBase = NULL;
u32 fld_cntr = 0;
u32 key_cntr = 0;
u32 j = 0;
u32 blockOffs = offs + 0x20;
for (u32 j = 0; j < *((u32*)(pData + offs + 0x0C)); j++) {
for (; j < *((u32*)(data + 0x0C)); j++) {
const u8* block = (const u8*)(pData + blockOffs);
u32 size = ((u32*)block)[1];
switch (((u32*)block)[0]) {
@@ -133,15 +138,15 @@ void JPAEmitterArchiveLoader_v10::load() {
blockOffs += size;
}
mpEmtrRes->registration(pEmtrRes, *(u16*)(pData + 0x18));
getEmitterResource()->registration(pEmtrRes, *(u16*)(data + 0x18));
offs = blockOffs;
}
for (u32 i = 0; i < header->texResNum; i++) {
for (s32 i = 0; i < header->texResNum; i++) {
u32 size = *(u32*)(pData + offs + 0x04);
JPATextureArc * pTex = new(pHeap, 0) JPATextureArc(pData + offs);
JPATextureArc* pTex = new(pHeap, 0) JPATextureArc(pData + offs);
JUT_ASSERT(319, pTex);
mpTexRes->registration(pTex);
getTextureResource()->registration(pTex);
offs += size;
}
}
src/JSystem/JParticle/JPAField.cpp
+112 -96
View File
@@ -4,30 +4,81 @@
//
#include "JSystem/JParticle/JPAField.h"
#include "JSystem/JParticle/JPAEmitter.h"
#include "JSystem/JParticle/JPAParticle.h"
#include "JSystem/JParticle/JPAFieldBlock.h"
#include "JSystem/JUtility/JUTAssert.h"
JPAFieldContainer fc;
JPAEmitterInfo * JPAFieldData::pEmtrInfo;
/* 80259EE8-8025A0D8 .text loadFieldData__12JPABaseFieldFP12JPAFieldDataP13JPAFieldBlock */
void JPABaseField::loadFieldData(JPAFieldData*, JPAFieldBlock*) {
/* Nonmatching */
void JPABaseField::loadFieldData(JPAFieldData* data, JPAFieldBlock* block) {
data->mType = block->getType();
data->mID = block->getID();
data->mVelType = block->getVelType();
data->mCycle = block->getCycle();
data->mSttFlag = block->getSttFlag();
data->mMag = block->getMag();
data->mMagRndm = block->getMagRndm();
data->mMaxDist = block->getMaxDist();
block->getPos(data->mPos);
block->getDir(data->mDir);
data->mVal1 = block->getVal1();
data->mVal2 = block->getVal2();
data->mVal3 = block->getVal3();
data->mFadeIn = block->getFadeIn();
data->mFadeOut = block->getFadeOut();
data->mEnTime = block->getEnTime();
data->mDisTime = block->getDisTime();
if (!(data->mSttFlag & 0x10))
data->mDisTime = 1.0f;
data->mVel.zero();
}
/* 8025A0D8-8025A21C .text calcVel__12JPABaseFieldFP12JPAFieldDataP15JPABaseParticle */
void JPABaseField::calcVel(JPAFieldData*, JPABaseParticle*) {
/* Nonmatching */
void JPABaseField::calcVel(JPAFieldData* data, JPABaseParticle* ptcl) {
/* Nonmatching - copy of vel shouldn't be using PS */
JGeometry::TVec3<f32> vel = data->mVel;
if (!(ptcl->mStatus & 0x04)) {
f32 fadeAffect = calcFadeAffect(data, ptcl->mCurNormTime);
vel.scale(fadeAffect);
}
switch (data->mVelType) {
case 0: ptcl->mFieldAccel.add(vel); break;
case 1: ptcl->mBaseVel += vel; break;
case 2: ptcl->mFieldVel += vel; break;
}
}
/* 8025A21C-8025A2B0 .text calcFadeAffect__12JPABaseFieldFP12JPAFieldDataf */
void JPABaseField::calcFadeAffect(JPAFieldData*, float) {
f32 JPABaseField::calcFadeAffect(JPAFieldData* data, f32 t) {
/* Nonmatching */
}
/* 8025A2B0-8025A330 .text preCalc__12JPABaseFieldFP12JPAFieldData */
void JPABaseField::preCalc(JPAFieldData*) {
/* Nonmatching */
void JPABaseField::preCalc(JPAFieldData* data) {
data->mMaxDistSq = data->mMaxDist * data->mMaxDist;
data->mFadeOutRate = data->mDisTime - data->mFadeOut;
if (data->mFadeOutRate == 0.0f) {
data->mFadeOutRate = 1.0f;
} else {
data->mFadeOutRate = 1.0f / data->mFadeOutRate;
}
data->mFadeInRate = data->mFadeIn - data->mEnTime;
if (data->mFadeInRate == 0.0f) {
data->mFadeInRate = 1.0f;
} else {
data->mFadeInRate = 1.0f / data->mFadeInRate;
}
}
/* 8025A330-8025A344 .text isItinRange__12JPABaseFieldFP12JPAFieldDataf */
void JPABaseField::isItinRange(JPAFieldData*, float) {
/* Nonmatching */
bool JPABaseField::isItinRange(JPAFieldData* data, f32 v) {
return v < data->mMaxDistSq;
}
/* 8025A344-8025A3E4 .text preCalc__15JPAGravityFieldFP12JPAFieldData */
@@ -116,111 +167,76 @@ void JPASpinField::calc(JPAFieldData*, JPABaseParticle*) {
}
/* 8025B7F8-8025B960 .text initField__15JPAFieldManagerFP20JPADataBlockLinkInfoP14JPAEmitterInfo */
void JPAFieldManager::initField(JPADataBlockLinkInfo*, JPAEmitterInfo*) {
void JPAFieldManager::initField(JPADataBlockLinkInfo* dataInfo, JPAEmitterInfo* emtrInfo) {
/* Nonmatching */
u8 fieldNum = dataInfo->getFieldNum();
JPAFieldBlock** fieldBlock = dataInfo->getField();
for (u8 i = 0; i < fieldNum; i++) {
if (mVacList->getNumLinks() != 0) {
JPAFieldData* field = mVacList->getFirst()->getObject();
mVacList->remove(field->getLinkBufferPtr());
mList.append(field->getLinkBufferPtr());
switch (fieldBlock[i]->getType()) {
case 0: field->mpBaseField = &fc.mGravity; break;
case 1: field->mpBaseField = &fc.mAir; break;
case 2: field->mpBaseField = &fc.mMagnet; break;
case 3: field->mpBaseField = &fc.mNewton; break;
case 4: field->mpBaseField = &fc.mVortex; break;
case 5: field->mpBaseField = &fc.mConvection; break;
case 6: field->mpBaseField = &fc.mRandom; break;
case 7: field->mpBaseField = &fc.mDrag; break;
case 8: field->mpBaseField = &fc.mSpin; break;
default: break;
}
JPAFieldData::pEmtrInfo = emtrInfo;
field->mpBaseField->loadFieldData(field, fieldBlock[i]);
} else {
JUT_WARN(0x25c, "%s", "JPariticle::Entry Over!!! (Field Number)");
}
}
}
/* 8025B960-8025B9C0 .text init__15JPAFieldManagerFP15JPABaseParticle */
void JPAFieldManager::init(JPABaseParticle*) {
/* Nonmatching */
void JPAFieldManager::init(JPABaseParticle* ptcl) {
for (JSULink<JPAFieldData>* link = mList.getFirst(); link != NULL; link = link->getNext()) {
JPAFieldData* data = link->getObject();
data->mpBaseField->init(data, ptcl);
}
}
/* 8025B9C0-8025BA10 .text preCalc__15JPAFieldManagerFv */
void JPAFieldManager::preCalc() {
/* Nonmatching */
for (JSULink<JPAFieldData>* link = mList.getFirst(); link != NULL; link = link->getNext()) {
JPAFieldData* data = link->getObject();
data->mpBaseField->preCalc(data);
}
}
/* 8025BA10-8025BAD8 .text calc__15JPAFieldManagerFP15JPABaseParticle */
void JPAFieldManager::calc(JPABaseParticle*) {
void JPAFieldManager::calc(JPABaseParticle* ptcl) {
/* Nonmatching */
for (JSULink<JPAFieldData>* link = mList.getFirst(); link != NULL; link = link->getNext()) {
JPAFieldData* data = link->getObject();
data->mpBaseField->calc(data, ptcl);
// more to do here
}
}
/* 8025BAD8-8025BB20 .text deleteField__15JPAFieldManagerFP12JPAFieldData */
void JPAFieldManager::deleteField(JPAFieldData*) {
/* Nonmatching */
void JPAFieldManager::deleteField(JPAFieldData* data) {
mList.remove(data->getLinkBufferPtr());
mVacList->prepend(data->getLinkBufferPtr());
}
/* 8025BB20-8025BB74 .text deleteAllField__15JPAFieldManagerFv */
void JPAFieldManager::deleteAllField() {
/* Nonmatching */
}
/* 8025BB74-8025BB78 .text init__12JPABaseFieldFP12JPAFieldDataP15JPABaseParticle */
void JPABaseField::init(JPAFieldData*, JPABaseParticle*) {
/* Nonmatching */
}
/* 8025BB78-8025BB7C .text calc__12JPABaseFieldFP12JPAFieldDataP15JPABaseParticle */
void JPABaseField::calc(JPAFieldData*, JPABaseParticle*) {
/* Nonmatching */
}
/* 8025BB7C-8025BBD8 .text __dt__12JPASpinFieldFv */
JPASpinField::~JPASpinField() {
/* Nonmatching */
}
/* 8025BBD8-8025BBE0 .text isItinRange__12JPASpinFieldFP12JPAFieldDataf */
void JPASpinField::isItinRange(JPAFieldData*, float) {
/* Nonmatching */
}
/* 8025BBE0-8025BC3C .text __dt__12JPADragFieldFv */
JPADragField::~JPADragField() {
/* Nonmatching */
}
/* 8025BC3C-8025BC98 .text __dt__14JPARandomFieldFv */
JPARandomField::~JPARandomField() {
/* Nonmatching */
}
/* 8025BC98-8025BCF4 .text __dt__18JPAConvectionFieldFv */
JPAConvectionField::~JPAConvectionField() {
/* Nonmatching */
}
/* 8025BCF4-8025BCFC .text isItinRange__18JPAConvectionFieldFP12JPAFieldDataf */
void JPAConvectionField::isItinRange(JPAFieldData*, float) {
/* Nonmatching */
}
/* 8025BCFC-8025BD58 .text __dt__14JPAVortexFieldFv */
JPAVortexField::~JPAVortexField() {
/* Nonmatching */
}
/* 8025BD58-8025BD60 .text isItinRange__14JPAVortexFieldFP12JPAFieldDataf */
void JPAVortexField::isItinRange(JPAFieldData*, float) {
/* Nonmatching */
}
/* 8025BD60-8025BDBC .text __dt__14JPANewtonFieldFv */
JPANewtonField::~JPANewtonField() {
/* Nonmatching */
}
/* 8025BDBC-8025BE18 .text __dt__14JPAMagnetFieldFv */
JPAMagnetField::~JPAMagnetField() {
/* Nonmatching */
}
/* 8025BE18-8025BE74 .text __dt__11JPAAirFieldFv */
JPAAirField::~JPAAirField() {
/* Nonmatching */
}
/* 8025BE74-8025BED0 .text __dt__15JPAGravityFieldFv */
JPAGravityField::~JPAGravityField() {
/* Nonmatching */
}
/* 8025BED0-8025BF18 .text __dt__12JPABaseFieldFv */
JPABaseField::~JPABaseField() {
/* Nonmatching */
}
/* 8025BFC4-8025C128 .text __dt__17JPAFieldContainerFv */
JPAFieldContainer::~JPAFieldContainer() {
/* Nonmatching */
for (JSULink<JPAFieldData>* link = mList.getFirst(); link != NULL;) {
JSULink<JPAFieldData>* next = link->getNext();
JPAFieldData* data = link->getObject();
deleteField(data);
link = next;
}
}