mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-08-08 10:34:08 -04:00
Code Issues Packages Projects Releases Wiki Activity

j2d / map_path work, d_drawlist / d_attention cleanup (#208)

Browse Source 
* work on fop actor / actor mng, daalink, d_a_obj_item

* d_a_title mostly decompiled

* daalink / d_event / JMessage / dmsg_out_font work

* msg_scrn_base / msg_scrn_boss

* some work on mDo machine, d_menu_save, d_tresure, and various

* remove asm

* progress

* finish d_menu_save / d_pane_class_alpha / d_pane_class / rename some data

* rename more data

* remove asm / progress

* match all of d_pane_class

* fixes / some dKankyo doc

* bunch of j2d work. d_drawlist / d_attention cleanup

* progress / asm

* cleanup wip

* decompile JStage

* setup some more JStudio structs

* set up d_demo classes

* some d_demo work

* cleanup dolphin os stuff

* some initial dEvent documentation

* some At collision documentation

* match JUTConsole::doDraw

* dbgs work / split up some of d_a_alink into .inc files

* d_a_alink_spinner work
This commit is contained in:
TakaRikka
2022-08-30 14:22:17 -07:00
committed by GitHub
parent bc30d007e1
commit f8979749e3
613 changed files with 30182 additions and 40087 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/J2DGraph/J2DAnmLoader_nonmatching.cpp
+290 -284
View File
@@ -18,73 +18,74 @@
/* 80308A6C-80309290 3033AC 0824+00 0/0 26/26 2/2 .text load__20J2DAnmLoaderDataBaseFPCv
*/
void* J2DAnmLoaderDataBase::load(void const* param_0) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)param_0;
void* J2DAnmLoaderDataBase::load(void const* p_data) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)p_data;
if (hdr == NULL) {
return NULL;
} else if (hdr->mMagic == 'J3D1') {
switch (hdr->mType) {
case 'bck1': {
J2DAnmKeyLoader_v15 loader;
loader._4 = new J2DAnmTransformKey();
return loader.load(param_0);
loader.mpResource = new J2DAnmTransformKey();
return loader.load(p_data);
break;
}
case 'bpk1': {
J2DAnmKeyLoader_v15 loader;
loader._4 = new J2DAnmColorKey();
return loader.load(param_0);
loader.mpResource = new J2DAnmColorKey();
return loader.load(p_data);
break;
}
case 'blk1':
return NULL;
case 'btk1': {
J2DAnmKeyLoader_v15 loader;
loader._4 = new J2DAnmTextureSRTKey();
return loader.load(param_0);
loader.mpResource = new J2DAnmTextureSRTKey();
return loader.load(p_data);
break;
}
case 'brk1': {
J2DAnmKeyLoader_v15 loader;
loader._4 = new J2DAnmTevRegKey();
return loader.load(param_0);
loader.mpResource = new J2DAnmTevRegKey();
return loader.load(p_data);
break;
}
case 'bxk1': {
J2DAnmKeyLoader_v15 loader;
loader._4 = new J2DAnmVtxColorKey();
return loader.load(param_0);
loader.mpResource = new J2DAnmVtxColorKey();
return loader.load(p_data);
break;
}
case 'bca1': {
J2DAnmFullLoader_v15 loader;
loader._4 = new J2DAnmTransformFull();
return loader.load(param_0);
loader.mpResource = new J2DAnmTransformFull();
return loader.load(p_data);
break;
}
case 'bpa1': {
J2DAnmFullLoader_v15 loader;
loader._4 = new J2DAnmColorFull();
return loader.load(param_0);
loader.mpResource = new J2DAnmColorFull();
return loader.load(p_data);
break;
}
case 'btp1': {
J2DAnmFullLoader_v15 loader;
loader._4 = new J2DAnmTexPattern();
return loader.load(param_0);
loader.mpResource = new J2DAnmTexPattern();
return loader.load(p_data);
}
case 'bva1': {
J2DAnmFullLoader_v15 loader;
loader._4 = new J2DAnmVisibilityFull();
return loader.load(param_0);
loader.mpResource = new J2DAnmVisibilityFull();
return loader.load(p_data);
break;
}
case 'bla1':
return NULL;
case 'bxa1': {
J2DAnmFullLoader_v15 loader;
loader._4 = new J2DAnmVtxColorFull();
return loader.load(param_0);
loader.mpResource = new J2DAnmVtxColorFull();
return loader.load(p_data);
}
}
return NULL;
@@ -100,63 +101,66 @@ J2DAnmKeyLoader_v15::J2DAnmKeyLoader_v15() {}
J2DAnmKeyLoader_v15::~J2DAnmKeyLoader_v15() {}
/* 80309308-80309414 303C48 010C+00 2/1 0/0 0/0 .text load__19J2DAnmKeyLoader_v15FPCv */
void* J2DAnmKeyLoader_v15::load(void const* param_0) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)param_0;
void* J2DAnmKeyLoader_v15::load(void const* p_data) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)p_data;
const J3DAnmDataBlockHeader* dataPtr = &hdr->mFirst;
for (s32 i = 0; i < hdr->mCount; i++) {
switch (dataPtr->mType) {
case 'ANK1':
this->readAnmTransform((J3DAnmTransformKeyData*)dataPtr);
readAnmTransform((J3DAnmTransformKeyData*)dataPtr);
break;
case 'PAK1':
this->readAnmColor((J3DAnmColorKeyData*)dataPtr);
readAnmColor((J3DAnmColorKeyData*)dataPtr);
break;
case 'TTK1':
this->readAnmTextureSRT((J3DAnmTextureSRTKeyData*)dataPtr);
readAnmTextureSRT((J3DAnmTextureSRTKeyData*)dataPtr);
break;
case 'VCK1':
this->readAnmVtxColor((J3DAnmVtxColorKeyData*)dataPtr);
readAnmVtxColor((J3DAnmVtxColorKeyData*)dataPtr);
break;
case 'TRK1':
this->readAnmTevReg((J3DAnmTevRegKeyData*)dataPtr);
readAnmTevReg((J3DAnmTevRegKeyData*)dataPtr);
break;
}
dataPtr = (J3DAnmDataBlockHeader*)((s32)dataPtr + dataPtr->mNextOffset);
}
return _4;
return mpResource;
}
/* 80309414-80309570 303D54 015C+00 1/0 0/0 0/0 .text
* setResource__19J2DAnmKeyLoader_v15FP10J2DAnmBasePCv */
void J2DAnmKeyLoader_v15::setResource(J2DAnmBase* pAnm, void const* param_1) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)param_1;
void J2DAnmKeyLoader_v15::setResource(J2DAnmBase* p_anm, void const* p_data) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)p_data;
const J3DAnmDataBlockHeader* dataPtr = &hdr->mFirst;
for (s32 i = 0; i < hdr->mCount; i++) {
switch (dataPtr->mType) {
case 'ANK1':
if (pAnm->getKind() == KIND_TRANSFORM) {
this->setAnmTransform((J2DAnmTransformKey*)pAnm, (J3DAnmTransformKeyData*)dataPtr);
if (p_anm->getKind() == KIND_TRANSFORM) {
setAnmTransform((J2DAnmTransformKey*)p_anm, (J3DAnmTransformKeyData*)dataPtr);
}
break;
case 'PAK1':
if (pAnm->getKind() == KIND_COLOR) {
this->setAnmColor((J2DAnmColorKey*)pAnm, (J3DAnmColorKeyData*)dataPtr);
if (p_anm->getKind() == KIND_COLOR) {
setAnmColor((J2DAnmColorKey*)p_anm, (J3DAnmColorKeyData*)dataPtr);
}
break;
case 'TTK1':
if (pAnm->getKind() == KIND_TEXTURE_SRT) {
this->setAnmTextureSRT((J2DAnmTextureSRTKey*)pAnm,
if (p_anm->getKind() == KIND_TEXTURE_SRT) {
setAnmTextureSRT((J2DAnmTextureSRTKey*)p_anm,
(J3DAnmTextureSRTKeyData*)dataPtr);
}
break;
case 'TRK1':
if (pAnm->getKind() == KIND_TEV_REG) {
this->setAnmTevReg((J2DAnmTevRegKey*)pAnm, (J3DAnmTevRegKeyData*)dataPtr);
if (p_anm->getKind() == KIND_TEV_REG) {
setAnmTevReg((J2DAnmTevRegKey*)p_anm, (J3DAnmTevRegKeyData*)dataPtr);
}
break;
case 'VCK1':
if (pAnm->getKind() == KIND_VTX_COLOR) {
this->setAnmVtxColor((J2DAnmVtxColorKey*)pAnm, (J3DAnmVtxColorKeyData*)dataPtr);
if (p_anm->getKind() == KIND_VTX_COLOR) {
setAnmVtxColor((J2DAnmVtxColorKey*)p_anm, (J3DAnmVtxColorKeyData*)dataPtr);
}
break;
}
@@ -166,202 +170,204 @@ void J2DAnmKeyLoader_v15::setResource(J2DAnmBase* pAnm, void const* param_1) {
/* 80309570-80309598 303EB0 0028+00 1/1 0/0 0/0 .text
* readAnmTransform__19J2DAnmKeyLoader_v15FPC22J3DAnmTransformKeyData */
void J2DAnmKeyLoader_v15::readAnmTransform(J3DAnmTransformKeyData const* pData) {
this->setAnmTransform((J2DAnmTransformKey*)_4, pData);
void J2DAnmKeyLoader_v15::readAnmTransform(J3DAnmTransformKeyData const* p_data) {
setAnmTransform((J2DAnmTransformKey*)mpResource, p_data);
}
/* 80309598-80309634 303ED8 009C+00 2/2 0/0 0/0 .text
* setAnmTransform__19J2DAnmKeyLoader_v15FP18J2DAnmTransformKeyPC22J3DAnmTransformKeyData */
void J2DAnmKeyLoader_v15::setAnmTransform(J2DAnmTransformKey* param_0,
J3DAnmTransformKeyData const* param_1) {
param_0->field_0x22 = param_1->_C;
param_0->mFrameMax = param_1->mFrameMax;
param_0->field_0x4 = param_1->_8;
param_0->field_0x24 = param_1->_9;
param_0->mFrame = 0;
param_0->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(param_1, (void*)param_1->mTableOffset);
param_0->mScaleValues = JSUConvertOffsetToPtr<f32>(param_1, (void*)param_1->mScaleOffset);
param_0->mRotationValues = JSUConvertOffsetToPtr<s16>(param_1, (void*)param_1->mRotationOffset);
param_0->mTranslateValues =
JSUConvertOffsetToPtr<f32>(param_1, (void*)param_1->mTranslateOffset);
void J2DAnmKeyLoader_v15::setAnmTransform(J2DAnmTransformKey* p_anm,
J3DAnmTransformKeyData const* p_data) {
p_anm->field_0x22 = p_data->_C;
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->_8;
p_anm->field_0x24 = p_data->_9;
p_anm->mFrame = 0;
p_anm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mScaleValues = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mScaleOffset);
p_anm->mRotationValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mRotationOffset);
p_anm->mTranslateValues =
JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mTranslateOffset);
}
/* 80309634-8030965C 303F74 0028+00 1/1 0/0 0/0 .text
* readAnmTextureSRT__19J2DAnmKeyLoader_v15FPC23J3DAnmTextureSRTKeyData */
void J2DAnmKeyLoader_v15::readAnmTextureSRT(J3DAnmTextureSRTKeyData const* param_0) {
this->setAnmTextureSRT((J2DAnmTextureSRTKey*)_4, param_0);
void J2DAnmKeyLoader_v15::readAnmTextureSRT(J3DAnmTextureSRTKeyData const* p_data) {
setAnmTextureSRT((J2DAnmTextureSRTKey*)mpResource, p_data);
}
/* 8030965C-80309848 303F9C 01EC+00 2/2 0/0 0/0 .text
* setAnmTextureSRT__19J2DAnmKeyLoader_v15FP19J2DAnmTextureSRTKeyPC23J3DAnmTextureSRTKeyData */
void J2DAnmKeyLoader_v15::setAnmTextureSRT(J2DAnmTextureSRTKey* pAnm,
J3DAnmTextureSRTKeyData const* pData) {
pAnm->mUpdateMaterialNum = pData->field_0xc;
pAnm->mFrameMax = pData->field_0xa;
pAnm->field_0x4 = pData->field_0x8;
pAnm->field_0x10 = pData->field_0x9;
pAnm->mFrame = 0;
pAnm->mUpdateMaterialNum = pData->field_0xc;
pAnm->field_0x1a = pData->field_0xe;
pAnm->field_0x1c = pData->field_0x10;
pAnm->field_0x1e = pData->field_0x12;
pAnm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(pData, (void*)pData->mTableOffset);
pAnm->mUpdateMaterialID = JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mUpdateMatIDOffset);
pAnm->field_0x34.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mNameTab1Offset));
pAnm->mUpdateTexMtxID = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mUpdateTexMtxIDOffset);
pAnm->field_0x44 = JSUConvertOffsetToPtr<Vec>(pData, (void*)pData->unkOffset);
pAnm->mScaleValues = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->mScaleValOffset);
pAnm->mRotationValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mRotValOffset);
pAnm->mTranslationValues = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->mTransValOffset);
if (pData->mNameTab2Offset != 0) {
pAnm->field_0x68.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mNameTab2Offset));
void J2DAnmKeyLoader_v15::setAnmTextureSRT(J2DAnmTextureSRTKey* p_anm,
J3DAnmTextureSRTKeyData const* p_data) {
p_anm->mUpdateMaterialNum = p_data->field_0xc;
p_anm->mFrameMax = p_data->field_0xa;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->field_0x10 = p_data->field_0x9;
p_anm->mFrame = 0;
p_anm->mUpdateMaterialNum = p_data->field_0xc;
p_anm->field_0x1a = p_data->field_0xe;
p_anm->field_0x1c = p_data->field_0x10;
p_anm->field_0x1e = p_data->field_0x12;
p_anm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mUpdateMaterialID = JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mUpdateMatIDOffset);
p_anm->field_0x34.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mNameTab1Offset));
p_anm->mUpdateTexMtxID = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mUpdateTexMtxIDOffset);
p_anm->field_0x44 = JSUConvertOffsetToPtr<Vec>(p_data, (void*)p_data->unkOffset);
p_anm->mScaleValues = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mScaleValOffset);
p_anm->mRotationValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mRotValOffset);
p_anm->mTranslationValues = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mTransValOffset);
if (p_data->mNameTab2Offset != 0) {
p_anm->field_0x68.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mNameTab2Offset));
}
pAnm->field_0x4e = pData->field_0x34;
pAnm->field_0x48 = pData->field_0x36;
pAnm->field_0x4a = pData->field_0x38;
pAnm->field_0x4c = pData->field_0x3a;
pAnm->field_0x5c =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(pData, (void*)pData->mInfoTable2Offset);
pAnm->field_0x64 = JSUConvertOffsetToPtr<u16>(pData, (void*)pData->field_0x40);
pAnm->field_0x60 = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->field_0x48);
pAnm->field_0x78 = JSUConvertOffsetToPtr<Vec>(pData, (void*)pData->field_0x48);
pAnm->field_0x50 = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->field_0x50);
pAnm->field_0x54 = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->field_0x54);
pAnm->field_0x58 = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->field_0x58);
switch (pData->field_0x5c) {
p_anm->field_0x4e = p_data->field_0x34;
p_anm->field_0x48 = p_data->field_0x36;
p_anm->field_0x4a = p_data->field_0x38;
p_anm->field_0x4c = p_data->field_0x3a;
p_anm->field_0x5c =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(p_data, (void*)p_data->mInfoTable2Offset);
p_anm->field_0x64 = JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->field_0x40);
p_anm->field_0x60 = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->field_0x48);
p_anm->field_0x78 = JSUConvertOffsetToPtr<Vec>(p_data, (void*)p_data->field_0x48);
p_anm->field_0x50 = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->field_0x50);
p_anm->field_0x54 = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->field_0x54);
p_anm->field_0x58 = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->field_0x58);
switch (p_data->field_0x5c) {
case 0:
pAnm->field_0x7c = 0;
p_anm->field_0x7c = 0;
break;
case 1:
pAnm->field_0x7c = 1;
p_anm->field_0x7c = 1;
break;
default:
pAnm->field_0x7c = 0;
p_anm->field_0x7c = 0;
break;
}
}
/* 80309848-80309870 304188 0028+00 1/1 0/0 0/0 .text
* readAnmColor__19J2DAnmKeyLoader_v15FPC18J3DAnmColorKeyData */
void J2DAnmKeyLoader_v15::readAnmColor(J3DAnmColorKeyData const* pData) {
this->setAnmColor((J2DAnmColorKey*)_4, pData);
void J2DAnmKeyLoader_v15::readAnmColor(J3DAnmColorKeyData const* p_data) {
setAnmColor((J2DAnmColorKey*)mpResource, p_data);
}
/* 80309870-8030995C 3041B0 00EC+00 2/2 0/0 0/0 .text
* setAnmColor__19J2DAnmKeyLoader_v15FP14J2DAnmColorKeyPC18J3DAnmColorKeyData */
void J2DAnmKeyLoader_v15::setAnmColor(J2DAnmColorKey* pAnm, J3DAnmColorKeyData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mUpdateMaterialNum = pData->mUpdateMaterialNum;
pAnm->field_0x10 = pData->field_0x10;
pAnm->field_0x12 = pData->field_0x12;
pAnm->field_0x14 = pData->field_0x14;
pAnm->field_0x16 = pData->field_0x16;
pAnm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(pData, (void*)pData->mTableOffset);
pAnm->mRValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mRValOffset);
pAnm->mGValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mGValOffset);
pAnm->mBValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mBValOffset);
pAnm->mAValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mAValOffset);
pAnm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mUpdateMaterialIDOffset);
pAnm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mNameTabOffset));
void J2DAnmKeyLoader_v15::setAnmColor(J2DAnmColorKey* p_anm, J3DAnmColorKeyData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mUpdateMaterialNum = p_data->mUpdateMaterialNum;
p_anm->field_0x10 = p_data->field_0x10;
p_anm->field_0x12 = p_data->field_0x12;
p_anm->field_0x14 = p_data->field_0x14;
p_anm->field_0x16 = p_data->field_0x16;
p_anm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mRValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mRValOffset);
p_anm->mGValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mGValOffset);
p_anm->mBValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mBValOffset);
p_anm->mAValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mAValOffset);
p_anm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mUpdateMaterialIDOffset);
p_anm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mNameTabOffset));
}
/* 8030995C-80309984 30429C 0028+00 1/1 0/0 0/0 .text
* readAnmVtxColor__19J2DAnmKeyLoader_v15FPC21J3DAnmVtxColorKeyData */
void J2DAnmKeyLoader_v15::readAnmVtxColor(J3DAnmVtxColorKeyData const* pData) {
this->setAnmVtxColor((J2DAnmVtxColorKey*)_4, pData);
void J2DAnmKeyLoader_v15::readAnmVtxColor(J3DAnmVtxColorKeyData const* p_data) {
setAnmVtxColor((J2DAnmVtxColorKey*)mpResource, p_data);
}
/* 80309984-80309A80 3042C4 00FC+00 2/2 0/0 0/0 .text
* setAnmVtxColor__19J2DAnmKeyLoader_v15FP17J2DAnmVtxColorKeyPC21J3DAnmVtxColorKeyData */
void J2DAnmKeyLoader_v15::setAnmVtxColor(J2DAnmVtxColorKey* pAnm,
J3DAnmVtxColorKeyData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mAnmTableNum[0] = pData->mAnmTableNum[0];
pAnm->mAnmTableNum[1] = pData->mAnmTableNum[1];
pAnm->mInfoTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(pData, (void*)pData->mTableOffsets[0]);
pAnm->mInfoTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(pData, (void*)pData->mTableOffsets[1]);
pAnm->mVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
pData, (void*)pData->mVtxColoIndexDataOffset[0]);
pAnm->mVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
pData, (void*)pData->mVtxColoIndexDataOffset[1]);
pAnm->mVtxColorIndexPointer[0] =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mVtxColoIndexPointerOffset[0]);
pAnm->mVtxColorIndexPointer[1] =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mVtxColoIndexPointerOffset[1]);
pAnm->mRValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mRValOffset);
pAnm->mGValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mGValOffset);
pAnm->mBValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mBValOffset);
pAnm->mAValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mAValOffset);
void J2DAnmKeyLoader_v15::setAnmVtxColor(J2DAnmVtxColorKey* p_anm,
J3DAnmVtxColorKeyData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mAnmTableNum[0] = p_data->mAnmTableNum[0];
p_anm->mAnmTableNum[1] = p_data->mAnmTableNum[1];
p_anm->mInfoTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(p_data, (void*)p_data->mTableOffsets[0]);
p_anm->mInfoTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(p_data, (void*)p_data->mTableOffsets[1]);
p_anm->mVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
p_data, (void*)p_data->mVtxColoIndexDataOffset[0]);
p_anm->mVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
p_data, (void*)p_data->mVtxColoIndexDataOffset[1]);
p_anm->mVtxColorIndexPointer[0] =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mVtxColoIndexPointerOffset[0]);
p_anm->mVtxColorIndexPointer[1] =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mVtxColoIndexPointerOffset[1]);
p_anm->mRValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mRValOffset);
p_anm->mGValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mGValOffset);
p_anm->mBValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mBValOffset);
p_anm->mAValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mAValOffset);
}
/* 80309A80-80309B8C 3043C0 010C+00 2/1 0/0 0/0 .text load__20J2DAnmFullLoader_v15FPCv */
void* J2DAnmFullLoader_v15::load(void const* param_0) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)param_0;
void* J2DAnmFullLoader_v15::load(void const* p_data) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)p_data;
const J3DAnmDataBlockHeader* dataPtr = &hdr->mFirst;
for (s32 i = 0; i < hdr->mCount; i++) {
switch (dataPtr->mType) {
case 'ANF1':
this->readAnmTransform((J3DAnmTransformFullData*)dataPtr);
readAnmTransform((J3DAnmTransformFullData*)dataPtr);
break;
case 'PAF1':
this->readAnmColor((J3DAnmColorFullData*)dataPtr);
readAnmColor((J3DAnmColorFullData*)dataPtr);
break;
case 'TPT1':
this->readAnmTexPattern((J3DAnmTexPatternFullData*)dataPtr);
readAnmTexPattern((J3DAnmTexPatternFullData*)dataPtr);
break;
case 'VAF1':
this->readAnmVisibility((J3DAnmVisibilityFullData*)dataPtr);
readAnmVisibility((J3DAnmVisibilityFullData*)dataPtr);
break;
case 'VCF1':
this->readAnmVtxColor((J3DAnmVtxColorFullData*)dataPtr);
readAnmVtxColor((J3DAnmVtxColorFullData*)dataPtr);
break;
}
dataPtr = (J3DAnmDataBlockHeader*)((s32)dataPtr + dataPtr->mNextOffset);
}
return _4;
return mpResource;
}
/* 80309B8C-80309CE8 3044CC 015C+00 1/0 0/0 0/0 .text
* setResource__20J2DAnmFullLoader_v15FP10J2DAnmBasePCv */
void J2DAnmFullLoader_v15::setResource(J2DAnmBase* pAnm, void const* pData) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)pData;
void J2DAnmFullLoader_v15::setResource(J2DAnmBase* p_anm, void const* p_data) {
const J3DAnmDataHeader* hdr = (const J3DAnmDataHeader*)p_data;
const J3DAnmDataBlockHeader* dataPtr = &hdr->mFirst;
for (s32 i = 0; i < hdr->mCount; i++) {
switch (dataPtr->mType) {
case 'ANF1':
if (pAnm->getKind() == KIND_TRANSFORM)
this->setAnmTransform((J2DAnmTransformFull*)pAnm,
if (p_anm->getKind() == KIND_TRANSFORM)
setAnmTransform((J2DAnmTransformFull*)p_anm,
(J3DAnmTransformFullData*)dataPtr);
break;
case 'PAF1':
if (pAnm->getKind() == KIND_COLOR)
this->setAnmColor((J2DAnmColorFull*)pAnm, (J3DAnmColorFullData*)dataPtr);
if (p_anm->getKind() == KIND_COLOR)
setAnmColor((J2DAnmColorFull*)p_anm, (J3DAnmColorFullData*)dataPtr);
break;
case 'TPT1':
if (pAnm->getKind() == KIND_TEX_PATTERN)
this->setAnmTexPattern((J2DAnmTexPattern*)pAnm, (J3DAnmTexPatternFullData*)dataPtr);
if (p_anm->getKind() == KIND_TEX_PATTERN)
setAnmTexPattern((J2DAnmTexPattern*)p_anm, (J3DAnmTexPatternFullData*)dataPtr);
break;
case 'VAF1':
if (pAnm->getKind() == KIND_VISIBILITY)
this->setAnmVisibility((J2DAnmVisibilityFull*)pAnm,
if (p_anm->getKind() == KIND_VISIBILITY)
setAnmVisibility((J2DAnmVisibilityFull*)p_anm,
(J3DAnmVisibilityFullData*)dataPtr);
break;
case 'VCF1':
if (pAnm->getKind() == KIND_VTX_COLOR)
this->setAnmVtxColor((J2DAnmVtxColorFull*)pAnm, (J3DAnmVtxColorFullData*)dataPtr);
if (p_anm->getKind() == KIND_VTX_COLOR)
setAnmVtxColor((J2DAnmVtxColorFull*)p_anm, (J3DAnmVtxColorFullData*)dataPtr);
break;
}
dataPtr = (J3DAnmDataBlockHeader*)((s32)dataPtr + dataPtr->mNextOffset);
@@ -376,169 +382,169 @@ J2DAnmFullLoader_v15::~J2DAnmFullLoader_v15() {}
/* 80309D60-80309D88 3046A0 0028+00 1/1 0/0 0/0 .text
* readAnmTransform__20J2DAnmFullLoader_v15FPC23J3DAnmTransformFullData */
void J2DAnmFullLoader_v15::readAnmTransform(J3DAnmTransformFullData const* pData) {
this->setAnmTransform((J2DAnmTransformFull*)_4, pData);
void J2DAnmFullLoader_v15::readAnmTransform(J3DAnmTransformFullData const* p_data) {
setAnmTransform((J2DAnmTransformFull*)mpResource, p_data);
}
/* 80309D88-80309E1C 3046C8 0094+00 2/2 0/0 0/0 .text
* setAnmTransform__20J2DAnmFullLoader_v15FP19J2DAnmTransformFullPC23J3DAnmTransformFullData */
void J2DAnmFullLoader_v15::setAnmTransform(J2DAnmTransformFull* pAnm,
J3DAnmTransformFullData const* pData) {
pAnm->field_0x22 = pData->field_0xc;
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mTableInfo =
JSUConvertOffsetToPtr<J3DAnmTransformFullTable>(pData, (void*)pData->mTableOffset);
pAnm->mScaleValues = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->mScaleValOffset);
pAnm->mRotationValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mRotValOffset);
pAnm->mTranslateValues = JSUConvertOffsetToPtr<f32>(pData, (void*)pData->mTransValOffset);
void J2DAnmFullLoader_v15::setAnmTransform(J2DAnmTransformFull* p_anm,
J3DAnmTransformFullData const* p_data) {
p_anm->field_0x22 = p_data->field_0xc;
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mTableInfo =
JSUConvertOffsetToPtr<J3DAnmTransformFullTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mScaleValues = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mScaleValOffset);
p_anm->mRotationValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mRotValOffset);
p_anm->mTranslateValues = JSUConvertOffsetToPtr<f32>(p_data, (void*)p_data->mTransValOffset);
}
/* 80309E1C-80309E44 30475C 0028+00 1/1 0/0 0/0 .text
* readAnmColor__20J2DAnmFullLoader_v15FPC19J3DAnmColorFullData */
void J2DAnmFullLoader_v15::readAnmColor(J3DAnmColorFullData const* pData) {
this->setAnmColor((J2DAnmColorFull*)_4, pData);
void J2DAnmFullLoader_v15::readAnmColor(J3DAnmColorFullData const* p_data) {
setAnmColor((J2DAnmColorFull*)mpResource, p_data);
}
/* 80309E44-80309F10 304784 00CC+00 2/2 0/0 0/0 .text
* setAnmColor__20J2DAnmFullLoader_v15FP15J2DAnmColorFullPC19J3DAnmColorFullData */
void J2DAnmFullLoader_v15::setAnmColor(J2DAnmColorFull* pAnm, J3DAnmColorFullData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mUpdateMaterialNum = pData->mUpdateMaterialNum;
pAnm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(pData, (void*)pData->mTableOffset);
pAnm->mRValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mRValuesOffset);
pAnm->mGValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mGValuesOffset);
pAnm->mBValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mBValuesOffset);
pAnm->mAValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mAValuesOffset);
pAnm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mUpdateMaterialIDOffset);
pAnm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mNameTabOffset));
void J2DAnmFullLoader_v15::setAnmColor(J2DAnmColorFull* p_anm, J3DAnmColorFullData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mUpdateMaterialNum = p_data->mUpdateMaterialNum;
p_anm->mInfoTable =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mRValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mRValuesOffset);
p_anm->mGValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mGValuesOffset);
p_anm->mBValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mBValuesOffset);
p_anm->mAValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mAValuesOffset);
p_anm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mUpdateMaterialIDOffset);
p_anm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mNameTabOffset));
}
/* 80309F10-80309F38 304850 0028+00 1/1 0/0 0/0 .text
* readAnmTexPattern__20J2DAnmFullLoader_v15FPC24J3DAnmTexPatternFullData */
void J2DAnmFullLoader_v15::readAnmTexPattern(J3DAnmTexPatternFullData const* pData) {
this->setAnmTexPattern((J2DAnmTexPattern*)_4, pData);
void J2DAnmFullLoader_v15::readAnmTexPattern(J3DAnmTexPatternFullData const* p_data) {
setAnmTexPattern((J2DAnmTexPattern*)mpResource, p_data);
}
/* 80309F38-80309FDC 304878 00A4+00 2/2 0/0 0/0 .text
* setAnmTexPattern__20J2DAnmFullLoader_v15FP16J2DAnmTexPatternPC24J3DAnmTexPatternFullData */
void J2DAnmFullLoader_v15::setAnmTexPattern(J2DAnmTexPattern* pAnm,
J3DAnmTexPatternFullData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mUpdateMaterialNum = pData->field_0xc;
pAnm->field_0x18 = pData->field_0xe;
pAnm->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTexPatternFullTable>(pData, (void*)pData->mTableOffset);
pAnm->mValues = JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mValuesOffset);
pAnm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mUpdateMaterialIDOffset);
pAnm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mNameTabOffset));
void J2DAnmFullLoader_v15::setAnmTexPattern(J2DAnmTexPattern* p_anm,
J3DAnmTexPatternFullData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mUpdateMaterialNum = p_data->field_0xc;
p_anm->field_0x18 = p_data->field_0xe;
p_anm->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTexPatternFullTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mValues = JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mValuesOffset);
p_anm->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mUpdateMaterialIDOffset);
p_anm->field_0x20.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mNameTabOffset));
}
/* 80309FDC-8030A004 30491C 0028+00 1/1 0/0 0/0 .text
* readAnmTevReg__19J2DAnmKeyLoader_v15FPC19J3DAnmTevRegKeyData */
void J2DAnmKeyLoader_v15::readAnmTevReg(J3DAnmTevRegKeyData const* pData) {
this->setAnmTevReg((J2DAnmTevRegKey*)_4, pData);
void J2DAnmKeyLoader_v15::readAnmTevReg(J3DAnmTevRegKeyData const* p_data) {
setAnmTevReg((J2DAnmTevRegKey*)mpResource, p_data);
}
/* 8030A004-8030A190 304944 018C+00 2/2 0/0 0/0 .text
* setAnmTevReg__19J2DAnmKeyLoader_v15FP15J2DAnmTevRegKeyPC19J3DAnmTevRegKeyData */
void J2DAnmKeyLoader_v15::setAnmTevReg(J2DAnmTevRegKey* pAnm, J3DAnmTevRegKeyData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mCRegUpdateMaterialNum = pData->mCRegUpdateMaterialNum;
pAnm->mAnmCRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmCRegKeyTable>(pData, (void*)pData->mCRegTableOffset);
pAnm->mCRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mCRegUpdateMaterialIDOffset);
pAnm->mCRegNameTab.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mCRegNameTabOffset));
pAnm->mKRegUpdateMaterialNum = pData->mKRegUpdateMaterialNum;
pAnm->mAnmKRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmKRegKeyTable>(pData, (void*)pData->mKRegTableOffset);
pAnm->mKRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mKRegUpdateMaterialIDOffset);
pAnm->mKRegNameTab.setResource(
JSUConvertOffsetToPtr<ResNTAB>(pData, (void*)pData->mKRegNameTabOffset));
pAnm->field_0x14 = pData->field_0x10;
pAnm->field_0x16 = pData->field_0x12;
pAnm->field_0x18 = pData->field_0x14;
pAnm->field_0x1a = pData->field_0x16;
pAnm->mCRValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mCRValuesOffset);
pAnm->mCGValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mCGValuesOffset);
pAnm->mCBValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mCBValuesOffset);
pAnm->mCAValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mCAValuesOffset);
pAnm->field_0x1c = pData->field_0x18;
pAnm->field_0x1e = pData->field_0x1a;
pAnm->field_0x20 = pData->field_0x1c;
pAnm->field_0x22 = pData->field_0x1e;
pAnm->mKRValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mKRValuesOffset);
pAnm->mKGValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mKGValuesOffset);
pAnm->mKBValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mKBValuesOffset);
pAnm->mKAValues = JSUConvertOffsetToPtr<s16>(pData, (void*)pData->mKAValuesOffset);
void J2DAnmKeyLoader_v15::setAnmTevReg(J2DAnmTevRegKey* p_anm, J3DAnmTevRegKeyData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mCRegUpdateMaterialNum = p_data->mCRegUpdateMaterialNum;
p_anm->mAnmCRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmCRegKeyTable>(p_data, (void*)p_data->mCRegTableOffset);
p_anm->mCRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mCRegUpdateMaterialIDOffset);
p_anm->mCRegNameTab.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mCRegNameTabOffset));
p_anm->mKRegUpdateMaterialNum = p_data->mKRegUpdateMaterialNum;
p_anm->mAnmKRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmKRegKeyTable>(p_data, (void*)p_data->mKRegTableOffset);
p_anm->mKRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mKRegUpdateMaterialIDOffset);
p_anm->mKRegNameTab.setResource(
JSUConvertOffsetToPtr<ResNTAB>(p_data, (void*)p_data->mKRegNameTabOffset));
p_anm->field_0x14 = p_data->field_0x10;
p_anm->field_0x16 = p_data->field_0x12;
p_anm->field_0x18 = p_data->field_0x14;
p_anm->field_0x1a = p_data->field_0x16;
p_anm->mCRValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mCRValuesOffset);
p_anm->mCGValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mCGValuesOffset);
p_anm->mCBValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mCBValuesOffset);
p_anm->mCAValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mCAValuesOffset);
p_anm->field_0x1c = p_data->field_0x18;
p_anm->field_0x1e = p_data->field_0x1a;
p_anm->field_0x20 = p_data->field_0x1c;
p_anm->field_0x22 = p_data->field_0x1e;
p_anm->mKRValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mKRValuesOffset);
p_anm->mKGValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mKGValuesOffset);
p_anm->mKBValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mKBValuesOffset);
p_anm->mKAValues = JSUConvertOffsetToPtr<s16>(p_data, (void*)p_data->mKAValuesOffset);
}
/* 8030A190-8030A1B8 304AD0 0028+00 1/1 0/0 0/0 .text
* readAnmVisibility__20J2DAnmFullLoader_v15FPC24J3DAnmVisibilityFullData */
void J2DAnmFullLoader_v15::readAnmVisibility(J3DAnmVisibilityFullData const* pData) {
this->setAnmVisibility((J2DAnmVisibilityFull*)_4, pData);
void J2DAnmFullLoader_v15::readAnmVisibility(J3DAnmVisibilityFullData const* p_data) {
setAnmVisibility((J2DAnmVisibilityFull*)mpResource, p_data);
}
/* 8030A1B8-8030A234 304AF8 007C+00 2/2 0/0 0/0 .text
* setAnmVisibility__20J2DAnmFullLoader_v15FP20J2DAnmVisibilityFullPC24J3DAnmVisibilityFullData */
void J2DAnmFullLoader_v15::setAnmVisibility(J2DAnmVisibilityFull* pAnm,
J3DAnmVisibilityFullData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->field_0x10 = pData->field_0xc;
pAnm->field_0x12 = pData->field_0xe;
pAnm->mTable =
JSUConvertOffsetToPtr<J3DAnmVisibilityFullTable>(pData, (void*)pData->mTableOffset);
pAnm->mValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mValuesOffset);
void J2DAnmFullLoader_v15::setAnmVisibility(J2DAnmVisibilityFull* p_anm,
J3DAnmVisibilityFullData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->field_0x10 = p_data->field_0xc;
p_anm->field_0x12 = p_data->field_0xe;
p_anm->mTable =
JSUConvertOffsetToPtr<J3DAnmVisibilityFullTable>(p_data, (void*)p_data->mTableOffset);
p_anm->mValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mValuesOffset);
}
/* 8030A234-8030A25C 304B74 0028+00 1/1 0/0 0/0 .text
* readAnmVtxColor__20J2DAnmFullLoader_v15FPC22J3DAnmVtxColorFullData */
void J2DAnmFullLoader_v15::readAnmVtxColor(J3DAnmVtxColorFullData const* pData) {
this->setAnmVtxColor((J2DAnmVtxColorFull*)_4, pData);
void J2DAnmFullLoader_v15::readAnmVtxColor(J3DAnmVtxColorFullData const* p_data) {
setAnmVtxColor((J2DAnmVtxColorFull*)mpResource, p_data);
}
/* 8030A25C-8030A358 304B9C 00FC+00 2/2 0/0 0/0 .text
* setAnmVtxColor__20J2DAnmFullLoader_v15FP18J2DAnmVtxColorFullPC22J3DAnmVtxColorFullData */
void J2DAnmFullLoader_v15::setAnmVtxColor(J2DAnmVtxColorFull* pAnm,
J3DAnmVtxColorFullData const* pData) {
pAnm->mFrameMax = pData->mFrameMax;
pAnm->field_0x4 = pData->field_0x8;
pAnm->mFrame = 0;
pAnm->mAnmTableNum[0] = pData->mAnmTableNum[0];
pAnm->mAnmTableNum[1] = pData->mAnmTableNum[1];
pAnm->mInfoTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(pData, (void*)pData->mTableOffsets[0]);
pAnm->mInfoTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(pData, (void*)pData->mTableOffsets[1]);
pAnm->mVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
pData, (void*)pData->mVtxColorIndexDataOffsets[0]);
pAnm->mVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
pData, (void*)pData->mVtxColorIndexDataOffsets[1]);
pAnm->mVtxColorIndexPointer[0] =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mVtxColorIndexPointerOffsets[0]);
pAnm->mVtxColorIndexPointer[1] =
JSUConvertOffsetToPtr<u16>(pData, (void*)pData->mVtxColorIndexPointerOffsets[1]);
pAnm->mRValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mRValuesOffset);
pAnm->mGValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mGValuesOffset);
pAnm->mBValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mBValuesOffset);
pAnm->mAValues = JSUConvertOffsetToPtr<u8>(pData, (void*)pData->mAValuesOffset);
void J2DAnmFullLoader_v15::setAnmVtxColor(J2DAnmVtxColorFull* p_anm,
J3DAnmVtxColorFullData const* p_data) {
p_anm->mFrameMax = p_data->mFrameMax;
p_anm->field_0x4 = p_data->field_0x8;
p_anm->mFrame = 0;
p_anm->mAnmTableNum[0] = p_data->mAnmTableNum[0];
p_anm->mAnmTableNum[1] = p_data->mAnmTableNum[1];
p_anm->mInfoTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(p_data, (void*)p_data->mTableOffsets[0]);
p_anm->mInfoTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(p_data, (void*)p_data->mTableOffsets[1]);
p_anm->mVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
p_data, (void*)p_data->mVtxColorIndexDataOffsets[0]);
p_anm->mVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
p_data, (void*)p_data->mVtxColorIndexDataOffsets[1]);
p_anm->mVtxColorIndexPointer[0] =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mVtxColorIndexPointerOffsets[0]);
p_anm->mVtxColorIndexPointer[1] =
JSUConvertOffsetToPtr<u16>(p_data, (void*)p_data->mVtxColorIndexPointerOffsets[1]);
p_anm->mRValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mRValuesOffset);
p_anm->mGValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mGValuesOffset);
p_anm->mBValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mBValuesOffset);
p_anm->mAValues = JSUConvertOffsetToPtr<u8>(p_data, (void*)p_data->mAValuesOffset);
}
/* 8030A358-8030A3B4 304C98 005C+00 1/0 0/0 0/0 .text __dt__14J2DAnmVtxColorFv */
libs/JSystem/J2DGraph/J2DGrafContext.cpp
+3 -3
View File
@@ -171,7 +171,7 @@ void J2DGrafContext::fillBox(JGeometry::TBox2<f32> const& box) {
GXColor1u32(mColorBL);
GXPosition3f32(box.i.x, box.f.y, 0);
GXColor1u32(mColorBR);
GXEnd();
i_GXEnd();
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
}
@@ -193,7 +193,7 @@ void J2DGrafContext::drawFrame(JGeometry::TBox2<f32> const& box) {
GXColor1u32(mColorBR);
GXPosition3f32(box.i.x, box.i.y, 0);
GXColor1u32(mColorTL);
GXEnd();
i_GXEnd();
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
}
@@ -209,7 +209,7 @@ void J2DGrafContext::line(JGeometry::TVec2<f32> start, JGeometry::TVec2<f32> end
GXColor1u32(mColorTL);
GXPosition3f32(end.x, end.y, 0);
GXColor1u32(mColorBR);
GXEnd();
i_GXEnd();
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
}
libs/JSystem/J2DGraph/J2DManage.cpp
+6 -4
View File
@@ -26,6 +26,7 @@ void* J2DDataManage::get(char const* name) {
void* J2DDataManage::get(JSUInputStream* inputStream) {
inputStream->skip(1);
u8 nameLen = inputStream->readU8();
if (nameLen == 0) {
return NULL;
} else {
@@ -45,18 +46,18 @@ s8* J2DResReference::getResReference(u16 idx) const {
}
}
/* ############################################################################################## */
/* 804349C0-80434AC8 0616E0 0101+07 1/1 0/0 0/0 .bss p_name$494 */
static char p_name[257];
/* 8030CF44-8030D098 307884 0154+00 0/0 2/2 0/0 .text getName__15J2DResReferenceCFUs */
char* J2DResReference::getName(u16 idx) const {
static char p_name[257];
s8* resRef = this->getResReference(idx);
if (resRef == NULL) {
p_name[0] = 0;
return p_name;
} else {
s8 first = resRef[0];
switch (first) {
case 2:
case 3:
@@ -72,6 +73,7 @@ char* J2DResReference::getName(u16 idx) const {
break;
}
}
s32 i = 0;
pos++;
for (; pos < resRef[1] + 2; i++, pos++) {
libs/JSystem/J2DGraph/J2DMatBlock.cpp
+1490 -1506
View File
File diff suppressed because it is too large Load Diff
libs/JSystem/J2DGraph/J2DMaterial.cpp
+5 -3
View File
@@ -456,7 +456,8 @@ asm J2DColorBlock::~J2DColorBlock() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm J2DIndBlock::~J2DIndBlock() {
// asm J2DIndBlock::~J2DIndBlock() {
extern "C" asm void __dt__11J2DIndBlockFv() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DMaterial/__dt__11J2DIndBlockFv.s"
}
@@ -466,7 +467,8 @@ asm J2DIndBlock::~J2DIndBlock() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm J2DTevBlock::~J2DTevBlock() {
// asm J2DTevBlock::~J2DTevBlock() {
extern "C" asm void __dt__11J2DTevBlockFv() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DMaterial/__dt__11J2DTevBlockFv.s"
}
@@ -508,7 +510,7 @@ extern "C" void setGX__15J2DIndBlockNullFv() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DIndBlockNull::getType() {
asm u32 J2DIndBlockNull::getType() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DMaterial/getType__15J2DIndBlockNullFv.s"
}
libs/JSystem/J2DGraph/J2DPane.cpp
+260 -217
View File
@@ -12,14 +12,10 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Declarations:
//
/* 802F5BF8-802F5CB8 2F0538 00C0+00 0/0 10/10 0/0 .text __ct__7J2DPaneFv */
J2DPane::J2DPane() : mBounds(), mGlobalBounds(), mClipRect(), mPaneTree(this) {
mTransform = NULL;
id = 'PAN1';
mKind = 'PAN1';
mVisible = true;
mInfoTag = 0;
mUserInfoTag = 0;
@@ -31,15 +27,15 @@ J2DPane::J2DPane() : mBounds(), mGlobalBounds(), mClipRect(), mPaneTree(this) {
/* 802F5CB8-802F5D40 2F05F8 0088+00 3/3 0/0 0/0 .text initiate__7J2DPaneFv */
void J2DPane::initiate() {
_4 = -1;
field_0x4 = -1;
mRotateOffsetY = mRotateOffsetX = mRotateZ = mRotateY = mRotateX = 0;
mBasePosition = 0;
mRotAxis = ROTATE_Z;
mScaleY = mScaleX = 1;
mCullMode = GX_CULL_NONE;
mAlpha = 0xFF;
mAlpha = 255;
mIsInfluencedAlpha = true;
mColorAlpha = 0xFF;
mColorAlpha = 255;
mConnected = false;
calcMtx();
@@ -47,44 +43,45 @@ void J2DPane::initiate() {
/* 802F5D40-802F5DD0 2F0680 0090+00 0/0 1/1 0/0 .text
* __ct__7J2DPaneFP7J2DPanebUxRCQ29JGeometry8TBox2<f> */
J2DPane::J2DPane(J2DPane* param_0, bool param_1, u64 tag, JGeometry::TBox2<f32> const& box)
J2DPane::J2DPane(J2DPane* p_pane, bool visible, u64 tag, JGeometry::TBox2<f32> const& bounds)
: mBounds(), mGlobalBounds(), mClipRect(), mPaneTree(this) {
mTransform = NULL;
this->initialize(param_0, param_1, tag, box);
initialize(p_pane, visible, tag, bounds);
}
/* 802F5DD0-802F5E88 2F0710 00B8+00 1/1 0/0 0/0 .text
* initialize__7J2DPaneFP7J2DPanebUxRCQ29JGeometry8TBox2<f> */
void J2DPane::initialize(J2DPane* pane, bool visible, u64 infoTag,
JGeometry::TBox2<f32> const& box) {
id = 'PAN1';
void J2DPane::initialize(J2DPane* p_pane, bool visible, u64 infoTag,
JGeometry::TBox2<f32> const& bounds) {
mKind = 'PAN1';
mVisible = visible;
mInfoTag = infoTag;
mUserInfoTag = 0;
mBounds.set(box);
if (pane != NULL) {
pane->mPaneTree.appendChild(&this->mPaneTree);
mBounds.set(bounds);
if (p_pane != NULL) {
p_pane->mPaneTree.appendChild(&mPaneTree);
}
this->initiate();
this->changeUseTrans(pane);
this->calcMtx();
initiate();
changeUseTrans(p_pane);
calcMtx();
}
/* 802F5E88-802F5F08 2F07C8 0080+00 0/0 3/3 0/0 .text __ct__7J2DPaneFUxRCQ29JGeometry8TBox2<f> */
J2DPane::J2DPane(u64 infoTag, JGeometry::TBox2<f32> const& box)
J2DPane::J2DPane(u64 infoTag, JGeometry::TBox2<f32> const& bounds)
: mBounds(), mGlobalBounds(), mClipRect(), mPaneTree(this) {
mTransform = NULL;
this->initialize(infoTag, box);
initialize(infoTag, bounds);
}
/* 802F5F08-802F5F9C 2F0848 0094+00 1/1 0/0 0/0 .text
* initialize__7J2DPaneFUxRCQ29JGeometry8TBox2<f> */
void J2DPane::initialize(u64 tag, const JGeometry::TBox2<f32>& dim) {
id = 'PAN1';
void J2DPane::initialize(u64 tag, const JGeometry::TBox2<f32>& bounds) {
mKind = 'PAN1';
mVisible = true;
mInfoTag = tag;
mUserInfoTag = 0;
mBounds.set(dim);
mBounds.set(bounds);
initiate();
changeUseTrans(NULL);
calcMtx();
@@ -92,83 +89,93 @@ void J2DPane::initialize(u64 tag, const JGeometry::TBox2<f32>& dim) {
/* 802F5F9C-802F60C4 2F08DC 0128+00 0/0 1/1 0/0 .text
* __ct__7J2DPaneFP7J2DPaneP20JSURandomInputStreamUc */
J2DPane::J2DPane(J2DPane* pane, JSURandomInputStream* inputStream, u8 isEx) : mPaneTree(this) {
J2DPane::J2DPane(J2DPane* p_pane, JSURandomInputStream* p_stream, u8 isEx) : mPaneTree(this) {
mTransform = NULL;
if (isEx == 0) {
s32 position = inputStream->getPosition();
s32 buf[2];
inputStream->read(&buf, sizeof(buf));
id = buf[0];
position += buf[1];
this->makePaneStream(pane, inputStream);
inputStream->seek(position, JSUStreamSeekFrom_SET);
if (!isEx) {
s32 position = p_stream->getPosition();
J2DPaneHeader header;
p_stream->read(&header, sizeof(header));
mKind = header.mKind;
position += header.mSize;
makePaneStream(p_pane, p_stream);
p_stream->seek(position, JSUStreamSeekFrom_SET);
} else {
s32 position = inputStream->getPosition();
s32 buf[2];
inputStream->peek(&buf, sizeof(buf));
id = buf[0];
position += buf[1];
this->makePaneExStream(pane, inputStream);
inputStream->seek(position, JSUStreamSeekFrom_SET);
s32 position = p_stream->getPosition();
J2DPaneHeader header;
p_stream->peek(&header, sizeof(header));
mKind = header.mKind;
position += header.mSize;
makePaneExStream(p_pane, p_stream);
p_stream->seek(position, JSUStreamSeekFrom_SET);
}
}
/* 802F60C4-802F63F8 2F0A04 0334+00 1/1 3/3 0/0 .text
* makePaneStream__7J2DPaneFP7J2DPaneP20JSURandomInputStream */
void J2DPane::makePaneStream(J2DPane* pane, JSURandomInputStream* inputStream) {
void J2DPane::makePaneStream(J2DPane* p_pane, JSURandomInputStream* p_stream) {
u8 unk;
inputStream->read(&unk, 1);
inputStream->read(&mVisible, 1);
inputStream->skip(2);
mInfoTag = inputStream->read32b();
f32 x0 = inputStream->readS16();
f32 y0 = inputStream->readS16();
f32 x1 = x0 + inputStream->readS16();
f32 y1 = y0 + inputStream->readS16();
p_stream->read(&unk, 1);
p_stream->read(&mVisible, 1);
p_stream->skip(2);
mInfoTag = p_stream->read32b();
f32 x0 = p_stream->readS16();
f32 y0 = p_stream->readS16();
f32 x1 = x0 + p_stream->readS16();
f32 y1 = y0 + p_stream->readS16();
mBounds.set(x0, y0, x1, y1);
unk -= 6;
mRotateX = 0;
mRotateY = 0;
mRotateZ = 0;
if (unk != 0) {
mRotateZ = inputStream->readU16();
mRotateZ = p_stream->readU16();
unk--;
}
if (unk != 0) {
mBasePosition = inputStream->readU8();
mBasePosition = p_stream->readU8();
unk--;
} else {
mBasePosition = 0;
}
mRotAxis = ROTATE_Z;
mAlpha = 0xFF;
mAlpha = 255;
if (unk != 0) {
mAlpha = inputStream->readU8();
mAlpha = p_stream->readU8();
unk--;
}
mIsInfluencedAlpha = true;
if (unk != 0) {
mIsInfluencedAlpha = inputStream->readU8();
mIsInfluencedAlpha = p_stream->readU8();
unk--;
}
inputStream->align(4);
if (pane != NULL) {
pane->mPaneTree.appendChild(&this->mPaneTree);
p_stream->align(4);
if (p_pane != NULL) {
p_pane->mPaneTree.appendChild(&mPaneTree);
}
mCullMode = GX_CULL_NONE;
mColorAlpha = 0xFF;
mColorAlpha = 255;
mConnected = false;
_4 = 0xFFFF;
field_0x4 = 0xFFFF;
mScaleX = 1;
mScaleY = 1;
mUserInfoTag = 0;
this->changeUseTrans(pane);
this->calcMtx();
changeUseTrans(p_pane);
calcMtx();
}
/* 802F63F8-802F658C 2F0D38 0194+00 4/4 0/0 0/0 .text changeUseTrans__7J2DPaneFP7J2DPane
*/
void J2DPane::changeUseTrans(J2DPane* pane) {
void J2DPane::changeUseTrans(J2DPane* p_pane) {
f32 xOffset = 0;
f32 yOffset = 0;
if (mBasePosition % 3 == 1) {
@@ -176,27 +183,34 @@ void J2DPane::changeUseTrans(J2DPane* pane) {
} else if (mBasePosition % 3 == 2) {
xOffset = mBounds.getWidth();
}
if (mBasePosition / 3 == 1) {
yOffset = mBounds.getHeight() / 2;
} else if (mBasePosition / 3 == 2) {
yOffset = mBounds.getHeight();
}
mTranslateX = mBounds.i.x + xOffset;
mTranslateY = mBounds.i.y + yOffset;
mRotateOffsetX = xOffset;
mRotateOffsetY = yOffset;
f32 f1 = -mTranslateX;
f32 f2 = -mTranslateY;
mBounds.addPos(f1, f2);
if (pane != NULL) {
u8 otherBasePos = pane->mBasePosition;
f32 width = pane->getWidth();
f32 height = pane->getHeight();
f32 addX = -mTranslateX;
f32 addY = -mTranslateY;
mBounds.addPos(addX, addY);
if (p_pane != NULL) {
u8 otherBasePos = p_pane->mBasePosition;
f32 width = p_pane->getWidth();
f32 height = p_pane->getHeight();
if (otherBasePos % 3 == 1) {
mTranslateX -= width / 2;
} else if (otherBasePos % 3 == 2) {
mTranslateX -= width;
}
if (otherBasePos / 3 == 1) {
mTranslateY -= height / 2;
} else if (otherBasePos / 3 == 2) {
@@ -215,97 +229,107 @@ J2DPane::~J2DPane() {
}
/* 802F666C-802F6714 2F0FAC 00A8+00 0/0 2/2 0/0 .text appendChild__7J2DPaneFP7J2DPane */
bool J2DPane::appendChild(J2DPane* pChild) {
if (pChild == NULL)
bool J2DPane::appendChild(J2DPane* p_child) {
if (p_child == NULL)
return false;
const J2DPane* parent = pChild->getParentPane();
bool result = mPaneTree.appendChild(&pChild->mPaneTree);
const J2DPane* parent = p_child->getParentPane();
bool result = mPaneTree.appendChild(&p_child->mPaneTree);
if (result && parent == NULL) {
pChild->add(mBounds.i.x, mBounds.i.y);
pChild->calcMtx();
p_child->add(mBounds.i.x, mBounds.i.y);
p_child->calcMtx();
}
return result;
}
/* 802F6714-802F67E0 2F1054 00CC+00 0/0 1/1 0/0 .text insertChild__7J2DPaneFP7J2DPaneP7J2DPane */
bool J2DPane::insertChild(J2DPane* before, J2DPane* child) {
if (child == NULL)
bool J2DPane::insertChild(J2DPane* p_prev, J2DPane* p_child) {
if (p_child == NULL)
return false;
const J2DPane* parent = child->getParentPane();
const J2DPane* parent = p_child->getParentPane();
bool result =
mPaneTree.insertChild(before != NULL ? &before->mPaneTree : NULL, &child->mPaneTree);
mPaneTree.insertChild(p_prev != NULL ? &p_prev->mPaneTree : NULL, &p_child->mPaneTree);
if (result && parent == NULL) {
child->add(mBounds.i.x, mBounds.i.y);
child->calcMtx();
p_child->add(mBounds.i.x, mBounds.i.y);
p_child->calcMtx();
}
return result;
}
/* 802F67E0-802F6D18 2F1120 0538+00 0/0 1/1 0/0 .text draw__7J2DPaneFffPC14J2DGrafContextbb */
void J2DPane::draw(f32 x, f32 y, J2DGrafContext const* grafCtx, bool isOrthoGraf, bool param_4) {
void J2DPane::draw(f32 x, f32 y, J2DGrafContext const* p_grafCtx, bool isOrthoGraf, bool param_4) {
bool unkBool = param_4 && mVisible;
if (grafCtx->getGrafType() != 1) {
if (p_grafCtx->getGrafType() != 1) {
isOrthoGraf = false;
}
JSUTree<J2DPane>* parentTree = mPaneTree.getParent();
J2DPane* parent = NULL;
if (parentTree != NULL) {
parent = parentTree->getObject();
}
if (mBounds.isValid()) {
mGlobalBounds = mBounds;
f32 tX = mTranslateX;
f32 tY = mTranslateY;
mGlobalBounds.addPos(tX, tY);
f32 addX = mTranslateX;
f32 addY = mTranslateY;
mGlobalBounds.addPos(addX, addY);
if (unkBool) {
mClipRect = mBounds;
this->rewriteAlpha();
rewriteAlpha();
}
if (parent != NULL) {
f32 width = parent->mGlobalBounds.i.x - parent->mBounds.i.x;
f32 height = parent->mGlobalBounds.i.y - parent->mBounds.i.y;
mGlobalBounds.addPos(width, height);
PSMTXConcat(parent->mGlobalMtx, this->mPositionMtx, this->mGlobalMtx);
PSMTXConcat(parent->mGlobalMtx, mPositionMtx, mGlobalMtx);
if (unkBool) {
if (isOrthoGraf) {
mClipRect = mGlobalBounds;
mClipRect.intersect(parent->mClipRect);
}
mColorAlpha = mAlpha;
if (mIsInfluencedAlpha) {
mColorAlpha = (mAlpha * parent->mColorAlpha) / 0xFF;
mColorAlpha = (mAlpha * parent->mColorAlpha) / 255;
}
}
} else {
mGlobalBounds.addPos(x, y);
this->makeMatrix(mTranslateX + x, mTranslateY + y);
makeMatrix(mTranslateX + x, mTranslateY + y);
PSMTXCopy(mPositionMtx, mGlobalMtx);
mClipRect = mGlobalBounds;
mColorAlpha = mAlpha;
}
JGeometry::TBox2<f32> scissorBounds(0, 0, 0, 0);
if (unkBool && isOrthoGraf) {
((J2DOrthoGraph*)grafCtx)->scissorBounds(&scissorBounds, &mClipRect);
((J2DOrthoGraph*)p_grafCtx)->scissorBounds(&scissorBounds, &mClipRect);
}
if (unkBool && (mClipRect.isValid() || !isOrthoGraf)) {
J2DGrafContext tmpGraf(*grafCtx);
J2DGrafContext tmpGraf(*p_grafCtx);
if (isOrthoGraf) {
tmpGraf.scissor(scissorBounds);
tmpGraf.setScissor();
}
GXSetCullMode((GXCullMode)mCullMode);
this->drawSelf(x, y, &tmpGraf.mPosMtx);
drawSelf(x, y, &tmpGraf.mPosMtx);
}
JSUTreeIterator<J2DPane> iter;
for (iter = mPaneTree.getFirstChild(); iter != mPaneTree.getEndChild(); ++iter) {
iter.getObject()->draw(0, 0, grafCtx, isOrthoGraf, unkBool);
iter.getObject()->draw(0, 0, p_grafCtx, isOrthoGraf, unkBool);
}
}
}
@@ -313,6 +337,7 @@ void J2DPane::draw(f32 x, f32 y, J2DGrafContext const* grafCtx, bool isOrthoGraf
/* 802F6D18-802F6F60 2F1658 0248+00 2/2 4/4 0/0 .text place__7J2DPaneFRCQ29JGeometry8TBox2<f> */
void J2DPane::place(JGeometry::TBox2<f32> const& box) {
JGeometry::TBox2<f32> tmpBox;
if (mBounds.i.x == 0) {
tmpBox.i.x = 0;
tmpBox.f.x = box.getWidth();
@@ -326,6 +351,7 @@ void J2DPane::place(JGeometry::TBox2<f32> const& box) {
tmpBox.f.x = box.getWidth() / 2;
mTranslateX = (box.i.x + box.f.x) / 2;
}
if (mBounds.i.y == 0) {
tmpBox.i.y = 0;
tmpBox.f.y = box.getHeight();
@@ -339,23 +365,24 @@ void J2DPane::place(JGeometry::TBox2<f32> const& box) {
tmpBox.f.y = box.getHeight() / 2;
mTranslateY = (box.i.y + box.f.y) / 2;
}
f32 xOff = tmpBox.i.x - mBounds.i.x;
f32 yOff = tmpBox.i.y - mBounds.i.y;
for (J2DPane* childPane = this->getFirstChildPane(); childPane != NULL;
childPane = childPane->getNextChildPane()) {
childPane->mTranslateX += xOff;
childPane->mTranslateY += yOff;
for (J2DPane* child = getFirstChildPane(); child != NULL; child = child->getNextChildPane()) {
child->mTranslateX += xOff;
child->mTranslateY += yOff;
if (xOff != 0 || yOff != 0) {
childPane->calcMtx();
child->calcMtx();
}
}
mBounds = tmpBox;
J2DPane* parent = this->getParentPane();
J2DPane* parent = getParentPane();
if (parent != NULL) {
mTranslateX += parent->mBounds.i.x;
mTranslateY += parent->mBounds.i.y;
}
this->calcMtx();
calcMtx();
}
/* 802F6F60-802F6FB4 2F18A0 0054+00 1/0 7/0 0/0 .text move__7J2DPaneFff */
@@ -438,8 +465,8 @@ void J2DPane::rotate(f32 angle) {
}
/* 802F7264-802F72E0 2F1BA4 007C+00 0/0 2/2 0/0 .text clip__7J2DPaneFRCQ29JGeometry8TBox2<f> */
void J2DPane::clip(JGeometry::TBox2<f32> const& box) {
JGeometry::TBox2<f32> boxA(box);
void J2DPane::clip(JGeometry::TBox2<f32> const& bounds) {
JGeometry::TBox2<f32> boxA(bounds);
JGeometry::TBox2<f32> boxB(mGlobalBounds);
boxA.addPos(boxB.i);
mClipRect.intersect(boxA);
@@ -476,20 +503,20 @@ J2DPane* J2DPane::searchUserInfo(u64 tag) {
}
/* 802F7430-802F74B8 2F1D70 0088+00 1/0 7/7 0/0 .text isUsed__7J2DPaneFPC7ResTIMG */
bool J2DPane::isUsed(const ResTIMG* timg) {
bool J2DPane::isUsed(const ResTIMG* p_timg) {
JSUTreeIterator<J2DPane> iter;
for (iter = mPaneTree.getFirstChild(); iter != mPaneTree.getEndChild(); ++iter) {
if (iter.getObject()->isUsed(timg))
if (iter.getObject()->isUsed(p_timg))
return true;
}
return false;
}
/* 802F74B8-802F7540 2F1DF8 0088+00 1/0 7/7 0/0 .text isUsed__7J2DPaneFPC7ResFONT */
bool J2DPane::isUsed(const ResFONT* font) {
bool J2DPane::isUsed(const ResFONT* p_font) {
JSUTreeIterator<J2DPane> iter;
for (iter = mPaneTree.getFirstChild(); iter != mPaneTree.getEndChild(); ++iter) {
if (iter.getObject()->isUsed(font))
if (iter.getObject()->isUsed(p_font))
return true;
}
return false;
@@ -501,9 +528,9 @@ void J2DPane::makeMatrix(f32 param_0, f32 param_1, f32 param_2, f32 param_3) {
f32 tmpY = mRotateOffsetY - param_3;
Mtx rotX, rotY, rotZ, rotMtx, mtx, tmp;
PSMTXTrans(mtx, -tmpX, -tmpY, 0);
PSMTXRotRad(rotX, 'x', 0.01745329238474369f * mRotateX);
PSMTXRotRad(rotY, 'y', 0.01745329238474369f * mRotateY);
PSMTXRotRad(rotZ, 'z', 0.01745329238474369f * -mRotateZ);
PSMTXRotRad(rotX, 'x', DEG_TO_RAD(mRotateX));
PSMTXRotRad(rotY, 'y', DEG_TO_RAD(mRotateY));
PSMTXRotRad(rotZ, 'z', DEG_TO_RAD(-mRotateZ));
PSMTXConcat(rotZ, rotX, tmp);
PSMTXConcat(rotY, tmp, rotMtx);
PSMTXScaleApply(mtx, mPositionMtx, mScaleX, mScaleY, 1);
@@ -513,7 +540,7 @@ void J2DPane::makeMatrix(f32 param_0, f32 param_1, f32 param_2, f32 param_3) {
/* 802F7680-802F76F8 2F1FC0 0078+00 1/0 7/3 0/0 .text setCullBack__7J2DPaneF11_GXCullMode
*/
void J2DPane::setCullBack(_GXCullMode mode) {
void J2DPane::setCullBack(GXCullMode mode) {
mCullMode = mode;
JSUTreeIterator<J2DPane> iter;
@@ -551,10 +578,11 @@ void J2DPane::setBasePosition(J2DBasePosition position) {
}
/* 802F77D0-802F79A8 2F2110 01D8+00 0/0 1/1 0/0 .text setInfluencedAlpha__7J2DPaneFbb */
void J2DPane::setInfluencedAlpha(bool param_0, bool param_1) {
if (param_1 && mIsInfluencedAlpha != param_0) {
J2DPane* parent = this->getParentPane();
void J2DPane::setInfluencedAlpha(bool influencedAlpha, bool param_1) {
if (param_1 && mIsInfluencedAlpha != influencedAlpha) {
J2DPane* parent = getParentPane();
u8 alpha = 255;
for (; parent != NULL; parent = parent->getParentPane()) {
if (parent->getAlpha() == 0) {
alpha = 0;
@@ -565,24 +593,27 @@ void J2DPane::setInfluencedAlpha(bool param_0, bool param_1) {
break;
}
}
if (param_0) {
if (influencedAlpha) {
if (alpha == 0) {
this->setAlpha(0);
setAlpha(0);
} else {
f32 fAlpha = ((f32)mAlpha) / alpha * 255;
u8 alpha;
if (fAlpha > 255) {
alpha = 255;
} else {
alpha = fAlpha;
}
this->setAlpha(alpha);
setAlpha(alpha);
}
} else {
this->setAlpha((f32)(alpha * mAlpha) / 255);
setAlpha((f32)(alpha * mAlpha) / 255);
}
}
mIsInfluencedAlpha = param_0;
mIsInfluencedAlpha = influencedAlpha;
}
/* 802F79A8-802F7A8C 2F22E8 00E4+00 0/0 3/3 0/0 .text getGlbVtx__7J2DPaneCFUc */
@@ -600,11 +631,13 @@ JGeometry::TVec3<f32> J2DPane::getGlbVtx(u8 param_0) const {
} else {
x = mBounds.i.x;
}
if (param_0 & 2) {
y = mBounds.f.y;
} else {
y = mBounds.i.y;
}
out.x = x * mGlobalMtx[0][0] + y * mGlobalMtx[0][1] + mGlobalMtx[0][3];
out.y = x * mGlobalMtx[1][0] + y * mGlobalMtx[1][1] + mGlobalMtx[1][3];
out.z = x * mGlobalMtx[2][0] + y * mGlobalMtx[2][1] + mGlobalMtx[2][3];
@@ -636,70 +669,78 @@ J2DPane* J2DPane::getParentPane() {
return getPaneTree()->getParent()->getObject();
}
struct J2DPaneInit { /* name unknown */
u8 field_0x0[10];
u16 field_0xa;
u8 isVisible;
u8 mBasePosition;
// padding
u64 mInfoTag;
u64 mUserInfoTag;
f32 rotationOffsetX;
f32 rotationOffsetY;
f32 scaleX;
f32 scaleY;
f32 rotXDegrees;
f32 rotYDegrees;
f32 rotZDegrees;
f32 translateX;
f32 translateY;
u8 field_0x44[4];
};
/* name unknown */
struct J2DPaneInfo {
/* 0x00 */ u32 mKind;
/* 0x04 */ u32 mSize;
/* 0x08 */ u16 field_0x8;
/* 0x0A */ u16 field_0xa;
/* 0x0B */ u8 mVisible;
/* 0x0C */ u8 mBasePosition;
/* 0x10 */ u64 mInfoTag;
/* 0x18 */ u64 mUserInfoTag;
/* 0x20 */ f32 mRotOffsetX;
/* 0x24 */ f32 mRotOffsetY;
/* 0x28 */ f32 mScaleX;
/* 0x2C */ f32 mScaleY;
/* 0x30 */ f32 mRotateX;
/* 0x34 */ f32 mRotateY;
/* 0x38 */ f32 mRotateZ;
/* 0x3C */ f32 mTranslateX;
/* 0x40 */ f32 mTranslateY;
}; // Size: 0x48
/* 802F7B18-802F7D00 2F2458 01E8+00 1/1 6/6 0/0 .text
* makePaneExStream__7J2DPaneFP7J2DPaneP20JSURandomInputStream */
void J2DPane::makePaneExStream(J2DPane* parent, JSURandomInputStream* stream) {
stream->getPosition();
J2DPaneInit data;
stream->read(&data, sizeof(data));
_4 = data.field_0xa;
mVisible = !!data.isVisible;
void J2DPane::makePaneExStream(J2DPane* p_parent, JSURandomInputStream* p_stream) {
p_stream->getPosition();
J2DPaneInfo data;
p_stream->read(&data, sizeof(data));
field_0x4 = data.field_0xa;
mVisible = !!data.mVisible;
mInfoTag = data.mInfoTag;
mUserInfoTag = data.mUserInfoTag;
mScaleX = data.scaleX;
mScaleY = data.scaleY;
mRotateX = data.rotXDegrees;
mRotateY = data.rotYDegrees;
mRotateZ = data.rotZDegrees;
mTranslateX = data.translateX;
mTranslateY = data.translateY;
mScaleX = data.mScaleX;
mScaleY = data.mScaleY;
mRotateX = data.mRotateX;
mRotateY = data.mRotateY;
mRotateZ = data.mRotateZ;
mTranslateX = data.mTranslateX;
mTranslateY = data.mTranslateY;
mRotAxis = ROTATE_Z;
if (data.mBasePosition % 3 == 0) {
mRotateOffsetX = 0;
} else if (data.mBasePosition % 3 == 1) {
mRotateOffsetX = data.rotationOffsetX / 2;
mRotateOffsetX = data.mRotOffsetX / 2;
} else {
mRotateOffsetX = data.rotationOffsetX;
mRotateOffsetX = data.mRotOffsetX;
}
if (data.mBasePosition / 3 == 0) {
mRotateOffsetY = 0;
} else if (data.mBasePosition / 3 == 1) {
mRotateOffsetY = data.rotationOffsetY / 2;
mRotateOffsetY = data.mRotOffsetY / 2;
} else {
mRotateOffsetY = data.rotationOffsetY;
mRotateOffsetY = data.mRotOffsetY;
}
mBounds.set(-mRotateOffsetX, -mRotateOffsetY, data.rotationOffsetX - mRotateOffsetX,
data.rotationOffsetY - mRotateOffsetY);
mBounds.set(-mRotateOffsetX, -mRotateOffsetY, data.mRotOffsetX - mRotateOffsetX,
data.mRotOffsetY - mRotateOffsetY);
mBasePosition = data.mBasePosition;
mAlpha = 255;
mIsInfluencedAlpha = false;
if (parent != NULL) {
parent->mPaneTree.appendChild(&this->mPaneTree);
if (p_parent != NULL) {
p_parent->mPaneTree.appendChild(&mPaneTree);
}
mCullMode = GX_CULL_NONE;
mColorAlpha = 255;
mConnected = false;
this->calcMtx();
calcMtx();
}
/* 802F7D00-802F7DB8 2F2640 00B8+00 0/0 1/1 0/0 .text J2DCast_F32_to_S16__7J2DPaneFfUc */
@@ -729,71 +770,73 @@ s16 J2DPane::J2DCast_F32_to_S16(f32 value, u8 arg2) {
/* 802F7DB8-802F7EF4 2F26F8 013C+00 0/0 3/3 0/0 .text
* getPointer__7J2DPaneFP20JSURandomInputStreamUlP10JKRArchive */
void* J2DPane::getPointer(JSURandomInputStream* inputStream, u32 param_1, JKRArchive* archive) {
void* J2DPane::getPointer(JSURandomInputStream* p_stream, u32 param_1, JKRArchive* p_archive) {
JUTResReference resRef;
void* result;
if (archive == NULL) {
void* pointer;
if (p_archive == NULL) {
if (J2DScreen::getDataManage() == NULL) {
result = resRef.getResource(inputStream, param_1, NULL);
pointer = resRef.getResource(p_stream, param_1, NULL);
} else {
s32 prevPos = inputStream->getPosition();
result = resRef.getResource(inputStream, param_1, NULL);
if (result == 0) {
inputStream->seek(prevPos, JSUStreamSeekFrom_SET);
result = J2DScreen::getDataManage()->get(inputStream);
s32 prevPos = p_stream->getPosition();
pointer = resRef.getResource(p_stream, param_1, NULL);
if (pointer == NULL) {
p_stream->seek(prevPos, JSUStreamSeekFrom_SET);
pointer = J2DScreen::getDataManage()->get(p_stream);
}
}
} else {
s32 prevPos = inputStream->getPosition();
result = resRef.getResource(inputStream, param_1, archive);
if (result == NULL) {
inputStream->seek(prevPos, JSUStreamSeekFrom_SET);
result = resRef.getResource(inputStream, param_1, NULL);
s32 prevPos = p_stream->getPosition();
pointer = resRef.getResource(p_stream, param_1, p_archive);
if (pointer == NULL) {
p_stream->seek(prevPos, JSUStreamSeekFrom_SET);
pointer = resRef.getResource(p_stream, param_1, NULL);
}
if (result == NULL) {
if (pointer == NULL) {
if (J2DScreen::getDataManage() != NULL) {
inputStream->seek(prevPos, JSUStreamSeekFrom_SET);
result = J2DScreen::getDataManage()->get(inputStream);
p_stream->seek(prevPos, JSUStreamSeekFrom_SET);
pointer = J2DScreen::getDataManage()->get(p_stream);
}
}
}
return result;
return pointer;
}
/* 802F7EF4-802F7FC4 2F2834 00D0+00 2/0 7/4 0/0 .text setAnimation__7J2DPaneFP10J2DAnmBase */
void J2DPane::setAnimation(J2DAnmBase* anm) {
if (anm != NULL) {
switch (anm->getKind()) {
void J2DPane::setAnimation(J2DAnmBase* p_anm) {
if (p_anm != NULL) {
switch (p_anm->getKind()) {
default:
break;
case 0:
setAnimation(static_cast<J2DAnmTransform*>(anm));
case KIND_TRANSFORM:
setAnimation(static_cast<J2DAnmTransform*>(p_anm));
break;
case 1:
setAnimation(static_cast<J2DAnmColor*>(anm));
case KIND_COLOR:
setAnimation(static_cast<J2DAnmColor*>(p_anm));
break;
case 7:
setAnimation(static_cast<J2DAnmVtxColor*>(anm));
case KIND_VTX_COLOR:
setAnimation(static_cast<J2DAnmVtxColor*>(p_anm));
break;
case 4:
setAnimation(static_cast<J2DAnmTextureSRTKey*>(anm));
case KIND_TEXTURE_SRT:
setAnimation(static_cast<J2DAnmTextureSRTKey*>(p_anm));
break;
case 2:
setAnimation(static_cast<J2DAnmTexPattern*>(anm));
case KIND_TEX_PATTERN:
setAnimation(static_cast<J2DAnmTexPattern*>(p_anm));
break;
case 6:
setAnimation(static_cast<J2DAnmVisibilityFull*>(anm));
case KIND_VISIBILITY:
setAnimation(static_cast<J2DAnmVisibilityFull*>(p_anm));
break;
case 5:
setAnimation(static_cast<J2DAnmTevRegKey*>(anm));
case KIND_TEV_REG:
setAnimation(static_cast<J2DAnmTevRegKey*>(p_anm));
break;
}
}
}
/* 802F7FC4-802F7FCC -00001 0008+00 0/0 0/0 0/0 .text setAnimation__7J2DPaneFP15J2DAnmTransform */
void J2DPane::setAnimation(J2DAnmTransform* anm) {
mTransform = anm;
void J2DPane::setAnimation(J2DAnmTransform* p_anm) {
mTransform = p_anm;
}
/* 802F7FCC-802F8004 2F290C 0038+00 0/0 57/57 0/0 .text animationTransform__7J2DPaneFv */
@@ -815,8 +858,8 @@ void J2DPane::clearAnmTransform() {
/* 802F8080-802F8118 2F29C0 0098+00 1/0 7/0 0/0 .text
* animationTransform__7J2DPaneFPC15J2DAnmTransform */
const J2DAnmTransform* J2DPane::animationTransform(const J2DAnmTransform* transform) {
const J2DAnmTransform* p = transform;
const J2DAnmTransform* J2DPane::animationTransform(const J2DAnmTransform* p_transform) {
const J2DAnmTransform* p = p_transform;
if (mTransform != NULL)
p = mTransform;
@@ -831,30 +874,30 @@ const J2DAnmTransform* J2DPane::animationTransform(const J2DAnmTransform* transf
/* 802F8118-802F81A0 2F2A58 0088+00 1/0 8/1 0/0 .text
* setVisibileAnimation__7J2DPaneFP20J2DAnmVisibilityFull */
void J2DPane::setVisibileAnimation(J2DAnmVisibilityFull* visibility) {
setAnimationVF(visibility);
void J2DPane::setVisibileAnimation(J2DAnmVisibilityFull* p_visibility) {
setAnimationVF(p_visibility);
JSUTreeIterator<J2DPane> iter;
for (iter = mPaneTree.getFirstChild(); iter != mPaneTree.getEndChild(); ++iter) {
iter.getObject()->setVisibileAnimation(visibility);
iter.getObject()->setVisibileAnimation(p_visibility);
}
}
/* 802F81A0-802F8228 2F2AE0 0088+00 1/0 8/1 0/0 .text
* setVtxColorAnimation__7J2DPaneFP14J2DAnmVtxColor */
void J2DPane::setVtxColorAnimation(J2DAnmVtxColor* vtx_color) {
setAnimationVC(vtx_color);
void J2DPane::setVtxColorAnimation(J2DAnmVtxColor* p_vtxColor) {
setAnimationVC(p_vtxColor);
JSUTreeIterator<J2DPane> iter;
for (iter = mPaneTree.getFirstChild(); iter != mPaneTree.getEndChild(); ++iter) {
iter.getObject()->setVtxColorAnimation(vtx_color);
iter.getObject()->setVtxColorAnimation(p_vtxColor);
}
}
/* 802F8228-802F82C0 2F2B68 0098+00 1/0 7/3 0/0 .text animationPane__7J2DPaneFPC15J2DAnmTransform
*/
const J2DAnmTransform* J2DPane::animationPane(const J2DAnmTransform* transform) {
const J2DAnmTransform* p = transform;
const J2DAnmTransform* J2DPane::animationPane(const J2DAnmTransform* p_transform) {
const J2DAnmTransform* p = p_transform;
if (mTransform != NULL)
p = mTransform;
@@ -869,10 +912,10 @@ const J2DAnmTransform* J2DPane::animationPane(const J2DAnmTransform* transform)
/* 802F82C0-802F83C8 2F2C00 0108+00 2/2 0/0 0/0 .text
* updateTransform__7J2DPaneFPC15J2DAnmTransform */
void J2DPane::updateTransform(J2DAnmTransform const* anmTransform) {
if (_4 != 0xFFFF && anmTransform != NULL) {
void J2DPane::updateTransform(J2DAnmTransform const* p_anmTransform) {
if (field_0x4 != 0xFFFF && p_anmTransform != NULL) {
J3DTransformInfo info;
anmTransform->getTransform(_4, &info);
p_anmTransform->getTransform(field_0x4, &info);
mScaleX = info.mScale.x;
mScaleY = info.mScale.z;
mRotateX = (u16)info.mRotation.x * 360.0f / 65535.0f;
@@ -880,12 +923,12 @@ void J2DPane::updateTransform(J2DAnmTransform const* anmTransform) {
mRotateZ = (u16)info.mRotation.y * 360.0f / 65535.0f;
mTranslateX = info.mTranslate.x;
mTranslateY = info.mTranslate.z;
this->calcMtx();
calcMtx();
}
}
/* 802F83C8-802F83CC 2F2D08 0004+00 1/0 0/0 0/0 .text drawSelf__7J2DPaneFffPA3_A4_f */
void J2DPane::drawSelf(f32 param_0, f32 param_1, f32 (*param_2)[3][4]) {
void J2DPane::drawSelf(f32, f32, f32 (*)[3][4]) {
/* empty function */
}
@@ -896,14 +939,14 @@ void J2DPane::rewriteAlpha() {
/* 802F83D0-802F83FC 2F2D10 002C+00 1/0 6/0 0/0 .text
* setAnimationVF__7J2DPaneFP20J2DAnmVisibilityFull */
void J2DPane::setAnimationVF(J2DAnmVisibilityFull* visibility) {
setAnimation(visibility);
void J2DPane::setAnimationVF(J2DAnmVisibilityFull* p_visibility) {
setAnimation(p_visibility);
}
/* 802F83FC-802F8428 2F2D3C 002C+00 1/0 6/0 0/0 .text setAnimationVC__7J2DPaneFP14J2DAnmVtxColor
*/
void J2DPane::setAnimationVC(J2DAnmVtxColor* vtx_color) {
setAnimation(vtx_color);
void J2DPane::setAnimationVC(J2DAnmVtxColor* p_vtxColor) {
setAnimation(p_vtxColor);
}
/* 802F8428-802F8464 2F2D68 003C+00 1/0 4/0 0/0 .text setCullBack__7J2DPaneFb */
@@ -930,6 +973,6 @@ void J2DPane::update() {
}
/* 802F8478-802F847C 2F2DB8 0004+00 1/0 1/0 0/0 .text drawSelf__7J2DPaneFff */
void J2DPane::drawSelf(f32 param_0, f32 param_1) {
void J2DPane::drawSelf(f32, f32) {
/* empty function */
}
libs/JSystem/J2DGraph/J2DPicture.cpp
+152 -2
View File
@@ -274,6 +274,13 @@ asm J2DPicture::J2DPicture() {
/* 802FC118-802FC1D4 2F6A58 00BC+00 0/0 1/1 0/0 .text
* __ct__10J2DPictureFP7J2DPaneP20JSURandomInputStreamP10JKRArchive */
#ifdef NONMATCHING
J2DPicture::J2DPicture(J2DPane* p_pane, JSURandomInputStream* p_stream, JKRArchive* p_archive)
: field_0x10a(), field_0x12c(NULL), mWhite(), mBlack(), mCornerColor(), field_0x148(),
field_0x14c() {
private_readStream(p_pane, p_stream, p_archive);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -282,6 +289,7 @@ asm J2DPicture::J2DPicture(J2DPane* param_0, JSURandomInputStream* param_1, JKRA
#include "asm/JSystem/J2DGraph/J2DPicture/__ct__10J2DPictureFP7J2DPaneP20JSURandomInputStreamP10JKRArchive.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80456260-80456268 004860 0008+00 1/1 0/0 0/0 .sdata2 @1739 */
@@ -289,6 +297,111 @@ SECTION_SDATA2 static f64 lit_1739 = 4503599627370496.0 /* cast u32 to float */;
/* 802FC1D4-802FC708 2F6B14 0534+00 0/0 1/1 0/0 .text
* __ct__10J2DPictureFP7J2DPaneP20JSURandomInputStreamP11J2DMaterial */
#ifdef NONMATCHING
J2DPicture::J2DPicture(J2DPane* p_pane, JSURandomInputStream* p_stream, J2DMaterial* p_material)
: field_0x10a(), mPalette(NULL), mWhite(), mBlack(), mCornerColor(), field_0x148(),
field_0x14c() {
int position = p_stream->getPosition();
J2DPicHeader header;
p_stream->read(&header, sizeof(header));
mKind = 'PIC1';
int position2 = p_stream->getPosition();
J2DPaneHeader panHeader;
p_stream->peek(&panHeader, sizeof(panHeader));
p_pane->makePaneExStream(p_pane, p_stream);
p_stream->seek(position2 + panHeader.mSize, JSUStreamSeekFrom_SET);
J2DScrnBlockPictureParameter picInfo;
p_stream->read(&picInfo, sizeof(picInfo));
u16 matNum = picInfo.field_0x4;
for (int i = 0; i < 4; i++) {
field_0x10a[i] = picInfo.field_0x10[i];
mCornerColor[i] = picInfo.mCornerColor[i];
}
p_stream->seek(position + header.mSize, JSUStreamSeekFrom_SET);
J2DMaterial* material = NULL;
if (matNum != 0xFFFF) {
material = &p_material[matNum];
}
mAlpha = 255;
if (material != NULL) {
mAlpha = material->getColorBlock()->getMatColor(0)->a;
}
mBlack = JUtility::TColor(0);
mWhite = JUtility::TColor(0xFFFFFFFF);
mTextureCount = 0;
if (material != NULL && material->getTevBlock() != NULL) {
u8 texgenNum = material->getTexGenBlock()->getTexGenNum();
u32 stageNum = material->getTevBlock()->getTevStageNum();
if ((texgenNum == 1 && stageNum != 1) || (texgenNum != 1 && (int)stageNum != texgenNum + 1)) {
J2DGXColorS10* color0p = material->getTevBlock()->getTevColor(0);
GXColorS10 color0;
color0.r = color0p->r;
color0.g = color0p->g;
color0.b = color0p->b;
color0.a = color0p->a;
J2DGXColorS10* color1p = material->getTevBlock()->getTevColor(1);
GXColorS10 color1;
color1.r = color1p->r;
color1.g = color1p->g;
color1.b = color1p->b;
color1.a = color1p->a;
mBlack = JUtility::TColor(((u8)color0.r << 0x18) | ((u8)color0.g << 0x10) |
((u8)color0.b << 8) | (u8)color0.a);
mWhite = JUtility::TColor(((u8)color1.r << 0x18) | ((u8)color1.g << 0x10) |
((u8)color1.b << 8) | (u8)color1.a);
}
if (texgenNum <= 2) {
texgenNum = 2;
}
mTextureCount = texgenNum;
}
field_0x109 = 0;
for (u32 i = 0; i < 2; i++) {
mTexture[i] = NULL;
if (material != NULL && material->getTevBlock() != NULL) {
JUTTexture* tex = material->getTevBlock()->getTexture(i);
if (tex != NULL) {
mTexture[i] = tex;
field_0x109 |= (1 << i);
}
}
}
if (material != NULL && material->getTevBlock() != NULL) {
material->getTevBlock()->setUndeleteFlag(0xF0);
}
mPalette = NULL;
JUtility::TColor color(0xFFFFFFFF);
JUtility::TColor alpha(0xFFFFFFFF);
if (material != NULL && material->getTevBlock() != NULL) {
color = *material->getTevBlock()->getTevKColor(3);
alpha = *material->getTevBlock()->getTevKColor(1);
}
setBlendColorRatio(color.a, color.b);
setBlendAlphaRatio(alpha.a, alpha.b);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -297,12 +410,31 @@ asm J2DPicture::J2DPicture(J2DPane* param_0, JSURandomInputStream* param_1, J2DM
#include "asm/JSystem/J2DGraph/J2DPicture/__ct__10J2DPictureFP7J2DPaneP20JSURandomInputStreamP11J2DMaterial.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80456268-8045626C 004868 0004+00 9/9 0/0 0/0 .sdata2 @1767 */
SECTION_SDATA2 static f32 lit_1767 = 1.0f;
/* 802FC708-802FC800 2F7048 00F8+00 0/0 20/20 1/1 .text __ct__10J2DPictureFPC7ResTIMG */
#ifdef NONMATCHING
J2DPicture::J2DPicture(ResTIMG const* p_timg)
: field_0x10a(), mWhite(), mBlack(), mCornerColor(), field_0x148(),
field_0x14c() {
for (int i = 0; i < 2; i++) {
mTexture[i] = NULL;
}
field_0x109 = 0;
mTextureCount = 0;
if (p_timg != NULL) {
append(p_timg, 1.0f);
}
mPalette = NULL;
initinfo();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -311,9 +443,26 @@ asm J2DPicture::J2DPicture(ResTIMG const* param_0) {
#include "asm/JSystem/J2DGraph/J2DPicture/__ct__10J2DPictureFPC7ResTIMG.s"
}
#pragma pop
#endif
/* 802FC800-802FC8E8 2F7140 00E8+00 0/0 5/5 0/0 .text
* __ct__10J2DPictureFUxRCQ29JGeometry8TBox2<f>PC7ResTIMGPC7ResTLUT */
#ifdef NONMATCHING
J2DPicture::J2DPicture(u64 tag, JGeometry::TBox2<f32> const& bounds,
ResTIMG const* p_timg, ResTLUT const* p_tlut)
: J2DPane(tag, bounds), field_0x10a(), mPalette(NULL), mWhite(), mBlack(), mCornerColor(), field_0x148(),
field_0x14c() {
for (int i = 0; i < 2; i++) {
mTexture[i] = NULL;
}
field_0x109 = 0;
mTextureCount = 0;
private_initiate(p_timg, p_tlut);
initinfo();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -323,6 +472,7 @@ asm J2DPicture::J2DPicture(u64 param_0, JGeometry::TBox2<f32> const& param_1,
#include "asm/JSystem/J2DGraph/J2DPicture/func_802FC800.s"
}
#pragma pop
#endif
/* 802FC8E8-802FCCDC 2F7228 03F4+00 1/1 0/0 0/0 .text
* private_readStream__10J2DPictureFP7J2DPaneP20JSURandomInputStreamP10JKRArchive */
@@ -374,7 +524,7 @@ asm void J2DPicture::private_initiate(ResTIMG const* param_0, ResTLUT const* par
// matches with real literal
#ifdef NONMATCHING
void J2DPicture::initinfo() {
id = 'PIC1';
mKind = 'PIC1';
setTexCoord(NULL, BIND15, MIRROR0, false);
setBlendRatio(lit_1767, lit_1767);
@@ -400,7 +550,7 @@ J2DPicture::~J2DPicture() {
delete mTexture[i];
}
}
delete field_0x12c;
delete mPalette;
}
/* 802FD098-802FD168 2F79D8 00D0+00 1/0 0/0 0/0 .text prepareTexture__10J2DPictureFUc */
libs/JSystem/J2DGraph/J2DScreen.cpp
+110 -121
View File
@@ -210,7 +210,7 @@ SECTION_SDATA2 static f32 lit_1563[1 + 1 /* padding */] = {
#ifdef NONMATCHING
J2DScreen::J2DScreen()
: J2DPane(NULL, true, 'root', JGeometry::TBox2<f32>(0.0f, 0.0f, 0.0f, 0.0f)), mColor() {
_4 = -1;
field_0x4 = -1;
mScissor = false;
mMaterialNum = 0;
mMaterials = NULL;
@@ -255,61 +255,50 @@ void J2DScreen::clean() {
/* 802F8648-802F8748 2F2F88 0100+00 0/0 58/58 4/4 .text setPriority__9J2DScreenFPCcUlP10JKRArchive
*/
#ifdef NONMATCHING
bool J2DScreen::setPriority(char const* resName, u32 param_1, JKRArchive* archive) {
if (archive == NULL) {
bool J2DScreen::setPriority(char const* resName, u32 param_1, JKRArchive* p_archive) {
if (p_archive == NULL) {
return false;
}
void* res = JKRFileLoader::getGlbResource(resName, archive);
void* res = JKRFileLoader::getGlbResource(resName, p_archive);
if (res != NULL) {
u32 size = archive->getExpandedResSize(res);
u32 size = p_archive->getExpandedResSize(res);
JSUMemoryInputStream stream(res, size);
return setPriority(&stream, param_1, archive);
return setPriority(&stream, param_1, p_archive);
}
return false;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool J2DScreen::setPriority(char const* param_0, u32 param_1, JKRArchive* param_2) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DScreen/setPriority__9J2DScreenFPCcUlP10JKRArchive.s"
}
#pragma pop
#endif
/* 802F8748-802F8778 2F3088 0030+00 1/1 1/1 0/0 .text
* setPriority__9J2DScreenFP20JSURandomInputStreamUlP10JKRArchive */
bool J2DScreen::setPriority(JSURandomInputStream* stream, u32 param_1, JKRArchive* archive) {
if (archive == NULL) {
bool J2DScreen::setPriority(JSURandomInputStream* p_stream, u32 param_1, JKRArchive* p_archive) {
if (p_archive == NULL) {
return false;
} else {
return private_set(stream, param_1, archive);
return private_set(p_stream, param_1, p_archive);
}
}
/* 802F8778-802F8834 2F30B8 00BC+00 1/1 0/0 0/0 .text
* private_set__9J2DScreenFP20JSURandomInputStreamUlP10JKRArchive */
bool J2DScreen::private_set(JSURandomInputStream* stream, u32 param_1, JKRArchive* archive) {
if (!checkSignature(stream)) {
bool J2DScreen::private_set(JSURandomInputStream* p_stream, u32 param_1, JKRArchive* p_archive) {
if (!checkSignature(p_stream)) {
return false;
}
if (!getScreenInformation(stream)) {
if (!getScreenInformation(p_stream)) {
return false;
}
bool make_end = makeHierarchyPanes(this, stream, param_1, archive) != 2;
bool make_end = makeHierarchyPanes(this, p_stream, param_1, p_archive) != 2;
if (!(param_1 & 0x1F0000)) {
clean();
}
if (make_end) {
return stream->isGood();
return p_stream->isGood();
}
return false;
@@ -317,9 +306,9 @@ bool J2DScreen::private_set(JSURandomInputStream* stream, u32 param_1, JKRArchiv
/* 802F8834-802F8894 2F3174 0060+00 1/1 0/0 0/0 .text
* checkSignature__9J2DScreenFP20JSURandomInputStream */
bool J2DScreen::checkSignature(JSURandomInputStream* stream) {
bool J2DScreen::checkSignature(JSURandomInputStream* p_stream) {
J2DScrnHeader header;
stream->read(&header, 32);
p_stream->read(&header, sizeof(J2DScrnHeader));
if (header.mTag != 'SCRN' || (header.mType != 'blo1' && header.mType != 'blo2')) {
return false;
@@ -330,9 +319,9 @@ bool J2DScreen::checkSignature(JSURandomInputStream* stream) {
/* 802F8894-802F8990 2F31D4 00FC+00 1/1 0/0 0/0 .text
* getScreenInformation__9J2DScreenFP20JSURandomInputStream */
bool J2DScreen::getScreenInformation(JSURandomInputStream* stream) {
bool J2DScreen::getScreenInformation(JSURandomInputStream* p_stream) {
J2DScrnInfoHeader info;
stream->read(&info, sizeof(J2DScrnInfoHeader));
p_stream->read(&info, sizeof(J2DScrnInfoHeader));
if (info.mTag != 'INF1') {
return false;
@@ -346,7 +335,7 @@ bool J2DScreen::getScreenInformation(JSURandomInputStream* stream) {
mColor = color;
if (info.mSize > 0x10) {
stream->skip(info.mSize - 0x10);
p_stream->skip(info.mSize - 0x10);
}
return true;
@@ -355,32 +344,32 @@ bool J2DScreen::getScreenInformation(JSURandomInputStream* stream) {
/* 802F8990-802F8B98 2F32D0 0208+00 1/1 0/0 0/0 .text
* makeHierarchyPanes__9J2DScreenFP7J2DPaneP20JSURandomInputStreamUlP10JKRArchive */
// goto can probably be replaced
s32 J2DScreen::makeHierarchyPanes(J2DPane* basePane, JSURandomInputStream* stream, u32 param_2,
JKRArchive* archive) {
s32 J2DScreen::makeHierarchyPanes(J2DPane* p_basePane, JSURandomInputStream* p_stream, u32 param_2,
JKRArchive* p_archive) {
J2DScrnBlockHeader header;
J2DPane* next_pane = basePane;
J2DPane* next_pane = p_basePane;
do {
loop:
stream->peek(&header, sizeof(J2DScrnBlockHeader));
p_stream->peek(&header, sizeof(J2DScrnBlockHeader));
switch (header.mTag) {
case 'EXT1':
stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
p_stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
return 1;
case 'BGN1':
stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
p_stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
int ret = makeHierarchyPanes(next_pane, stream, param_2, archive);
int ret = makeHierarchyPanes(next_pane, p_stream, param_2, p_archive);
if (ret == 0) {
goto loop;
}
return ret;
case 'END1':
stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
p_stream->seek(header.mSize, JSUStreamSeekFrom_CUR);
return 0;
case 'TEX1':
J2DResReference* texRes = getResReference(stream, param_2);
J2DResReference* texRes = getResReference(p_stream, param_2);
mTexRes = texRes;
if (texRes != NULL) {
@@ -388,7 +377,7 @@ s32 J2DScreen::makeHierarchyPanes(J2DPane* basePane, JSURandomInputStream* strea
}
return 2;
case 'FNT1':
J2DResReference* fntRes = getResReference(stream, param_2);
J2DResReference* fntRes = getResReference(p_stream, param_2);
mFontRes = fntRes;
if (fntRes != NULL) {
@@ -396,16 +385,16 @@ s32 J2DScreen::makeHierarchyPanes(J2DPane* basePane, JSURandomInputStream* strea
}
return 2;
case 'MAT1':
if (createMaterial(stream, param_2, archive)) {
if (createMaterial(p_stream, param_2, p_archive)) {
goto loop;
}
return 2;
}
if (archive == NULL) {
next_pane = createPane(header, stream, basePane, param_2);
if (p_archive == NULL) {
next_pane = createPane(header, p_stream, p_basePane, param_2);
} else {
next_pane = createPane(header, stream, basePane, param_2, archive);
next_pane = createPane(header, p_stream, p_basePane, param_2, p_archive);
}
} while (next_pane != NULL);
@@ -414,54 +403,54 @@ s32 J2DScreen::makeHierarchyPanes(J2DPane* basePane, JSURandomInputStream* strea
/* 802F8B98-802F8ED4 2F34D8 033C+00 1/0 0/0 0/0 .text
* createPane__9J2DScreenFRC18J2DScrnBlockHeaderP20JSURandomInputStreamP7J2DPaneUlP10JKRArchive */
J2DPane* J2DScreen::createPane(J2DScrnBlockHeader const& header, JSURandomInputStream* stream,
J2DPane* basePane, u32 param_3, JKRArchive* archive) {
J2DPane* J2DScreen::createPane(J2DScrnBlockHeader const& header, JSURandomInputStream* p_stream,
J2DPane* p_basePane, u32 param_3, JKRArchive* p_archive) {
J2DPane* newPane;
switch (header.mTag) {
case 'PAN1':
newPane = new J2DPane(basePane, stream, 0);
newPane = new J2DPane(p_basePane, p_stream, 0);
break;
case 'WIN1':
newPane = new J2DWindow(basePane, stream, archive);
newPane = new J2DWindow(p_basePane, p_stream, p_archive);
break;
case 'PIC1':
newPane = new J2DPicture(basePane, stream, archive);
newPane = new J2DPicture(p_basePane, p_stream, p_archive);
break;
case 'TBX1':
newPane = new J2DTextBox(basePane, stream, archive);
newPane = new J2DTextBox(p_basePane, p_stream, p_archive);
break;
case 'PAN2':
newPane = new J2DPane(basePane, stream, 1);
newPane = new J2DPane(p_basePane, p_stream, 1);
break;
case 'WIN2':
if (param_3 & 0x1F0000) {
newPane = new J2DWindowEx(basePane, stream, param_3, mMaterials);
newPane = new J2DWindowEx(p_basePane, p_stream, param_3, mMaterials);
break;
}
newPane = new J2DWindow(basePane, stream, mMaterials);
newPane = new J2DWindow(p_basePane, p_stream, mMaterials);
break;
case 'PIC2':
if (param_3 & 0x1F0000) {
newPane = new J2DPictureEx(basePane, stream, param_3, mMaterials);
newPane = new J2DPictureEx(p_basePane, p_stream, param_3, mMaterials);
break;
}
newPane = new J2DPicture(basePane, stream, mMaterials);
newPane = new J2DPicture(p_basePane, p_stream, mMaterials);
break;
case 'TBX2':
if (param_3 & 0x1F0000) {
newPane = new J2DTextBoxEx(basePane, stream, param_3, mMaterials);
newPane = new J2DTextBoxEx(p_basePane, p_stream, param_3, mMaterials);
break;
}
newPane = new J2DTextBox(basePane, stream, param_3, mMaterials);
newPane = new J2DTextBox(p_basePane, p_stream, param_3, mMaterials);
break;
default:
s32 position = stream->getPosition();
s32 position = p_stream->getPosition();
s32 size = header.mSize;
s32 start = size + position;
newPane = new J2DPane(basePane, stream, 0);
stream->seek(start, JSUStreamSeekFrom_SET);
newPane = new J2DPane(p_basePane, p_stream, 0);
p_stream->seek(start, JSUStreamSeekFrom_SET);
break;
}
@@ -478,7 +467,7 @@ SECTION_SDATA2 static f32 lit_1830 = 1.0f;
/* 802F8ED4-802F90A0 2F3814 01CC+00 0/0 51/51 4/4 .text draw__9J2DScreenFffPC14J2DGrafContext */
// matches with literals
#ifdef NONMATCHING
void J2DScreen::draw(f32 param_0, f32 param_1, J2DGrafContext const* grafCtx) {
void J2DScreen::draw(f32 x, f32 y, J2DGrafContext const* grafCtx) {
u32 x, y, width, height;
if (mScissor) {
@@ -486,11 +475,11 @@ void J2DScreen::draw(f32 param_0, f32 param_1, J2DGrafContext const* grafCtx) {
}
if (grafCtx != NULL) {
J2DPane::draw(param_0, param_1, grafCtx, mScissor, true);
J2DPane::draw(x, y, grafCtx, mScissor, true);
} else {
J2DOrthoGraph ortho(0.0f, 0.0f, 640.0f, 480.0f, -1.0f, 1.0f);
ortho.setPort();
J2DPane::draw(param_0, param_1, &ortho, mScissor, true);
J2DPane::draw(x, y, &ortho, mScissor, true);
}
if (mScissor) {
@@ -543,15 +532,15 @@ J2DPane* J2DScreen::searchUserInfo(u64 tag) {
}
/* 802F9120-802F9280 2F3A60 0160+00 1/0 0/0 0/0 .text drawSelf__9J2DScreenFffPA3_A4_f */
// close. issues with color
// matches with literals
#ifdef NONMATCHING
void J2DScreen::drawSelf(f32 param_0, f32 param_1, Mtx* param_2) {
JUtility::TColor color(mColor);
u8 alpha = (color.a * mAlpha) / 255;
if (alpha != 0) {
JUtility::TColor color2((u32)alpha);
color = color2;
JUtility::TColor sp8(alpha | ((u32)color & 0xFFFFFF00));
color = sp8;
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
@@ -570,7 +559,7 @@ void J2DScreen::drawSelf(f32 param_0, f32 param_1, Mtx* param_2) {
GXColor1u32(color);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
GXEnd();
i_GXEnd();
}
}
#else
@@ -588,15 +577,15 @@ asm void J2DScreen::drawSelf(f32 param_0, f32 param_1, Mtx* param_2) {
* getResReference__9J2DScreenFP20JSURandomInputStreamUl */
// small regalloc
#ifdef NONMATCHING
J2DResReference* J2DScreen::getResReference(JSURandomInputStream* stream, u32 param_1) {
s32 position = stream->getPosition();
stream->skip(4);
J2DResReference* J2DScreen::getResReference(JSURandomInputStream* p_stream, u32 param_1) {
s32 position = p_stream->getPosition();
p_stream->skip(4);
s32 start, end;
start = stream->readS32();
stream->skip(4);
end = stream->readS32();
stream->seek(position + end, JSUStreamSeekFrom_SET);
start = p_stream->readS32();
p_stream->skip(4);
end = p_stream->readS32();
p_stream->seek(position + end, JSUStreamSeekFrom_SET);
s32 size = end - start;
@@ -608,7 +597,7 @@ J2DResReference* J2DScreen::getResReference(JSURandomInputStream* stream, u32 pa
}
if (buffer != NULL) {
stream->read(buffer, size);
p_stream->read(buffer, size);
}
return (J2DResReference*)buffer;
@@ -628,14 +617,14 @@ asm J2DResReference* J2DScreen::getResReference(JSURandomInputStream* param_0, u
* createMaterial__9J2DScreenFP20JSURandomInputStreamUlP10JKRArchive */
// nametab section has issues
#ifdef NONMATCHING
bool J2DScreen::createMaterial(JSURandomInputStream* stream, u32 param_1, JKRArchive* archive) {
s32 position = stream->getPosition();
bool J2DScreen::createMaterial(JSURandomInputStream* p_stream, u32 param_1, JKRArchive* p_archive) {
s32 position = p_stream->getPosition();
J2DScrnBlockHeader header;
stream->read(&header, 8);
mMaterialNum = stream->readU16();
p_stream->read(&header, 8);
mMaterialNum = p_stream->readU16();
stream->skip(2);
p_stream->skip(2);
if (param_1 & 0x1F0000) {
mMaterials = new J2DMaterial[mMaterialNum];
@@ -645,12 +634,12 @@ bool J2DScreen::createMaterial(JSURandomInputStream* stream, u32 param_1, JKRArc
u8* buffer = new (-4) u8[header.mSize];
if (mMaterials != NULL && buffer != NULL) {
stream->seek(position, JSUStreamSeekFrom_SET);
stream->read(buffer, header.mSize);
p_stream->seek(position, JSUStreamSeekFrom_SET);
p_stream->read(buffer, header.mSize);
J2DMaterialFactory factory(*(J2DMaterialBlock*)buffer);
for (u16 i = 0; i < mMaterialNum; i++) {
factory.create(&mMaterials[i], i, param_1, mTexRes, mFontRes, archive);
factory.create(&mMaterials[i], i, param_1, mTexRes, mFontRes, p_archive);
}
if (param_1 & 0x1F0000) {
@@ -699,13 +688,13 @@ asm bool J2DScreen::createMaterial(JSURandomInputStream* param_0, u32 param_1,
#endif
/* 802F9600-802F9620 2F3F40 0020+00 1/0 0/0 0/0 .text isUsed__9J2DScreenFPC7ResTIMG */
bool J2DScreen::isUsed(ResTIMG const* img) {
return J2DPane::isUsed(img);
bool J2DScreen::isUsed(ResTIMG const* p_timg) {
return J2DPane::isUsed(p_timg);
}
/* 802F9620-802F9640 2F3F60 0020+00 1/0 0/0 0/0 .text isUsed__9J2DScreenFPC7ResFONT */
bool J2DScreen::isUsed(ResFONT const* font) {
return J2DPane::isUsed(font);
bool J2DScreen::isUsed(ResFONT const* p_font) {
return J2DPane::isUsed(p_font);
}
/* ############################################################################################## */
@@ -733,85 +722,85 @@ void J2DScreen::animation() {
}
/* 802F9704-802F9798 2F4044 0094+00 1/0 0/0 0/0 .text setAnimation__9J2DScreenFP11J2DAnmColor */
void J2DScreen::setAnimation(J2DAnmColor* anmColor) {
anmColor->searchUpdateMaterialID(this);
u16 matNum = anmColor->getUpdateMaterialNum();
void J2DScreen::setAnimation(J2DAnmColor* p_anmColor) {
p_anmColor->searchUpdateMaterialID(this);
u16 matNum = p_anmColor->getUpdateMaterialNum();
for (u16 i = 0; i < matNum; i++) {
u16 matID = anmColor->getUpdateMaterialID(i);
u16 matID = p_anmColor->getUpdateMaterialID(i);
if (matID < mMaterialNum) {
mMaterials[matID].setAnimation(anmColor);
mMaterials[matID].setAnimation(p_anmColor);
}
}
}
/* 802F9798-802F9838 2F40D8 00A0+00 1/0 0/0 0/0 .text
* setAnimation__9J2DScreenFP19J2DAnmTextureSRTKey */
void J2DScreen::setAnimation(J2DAnmTextureSRTKey* anmSRTKey) {
anmSRTKey->searchUpdateMaterialID(this);
u16 matNum = anmSRTKey->getUpdateMaterialNum();
void J2DScreen::setAnimation(J2DAnmTextureSRTKey* p_anmSRTKey) {
p_anmSRTKey->searchUpdateMaterialID(this);
u16 matNum = p_anmSRTKey->getUpdateMaterialNum();
for (u16 i = 0; i < matNum; i++) {
u16 matID = anmSRTKey->getUpdateMaterialID(i);
u16 matID = p_anmSRTKey->getUpdateMaterialID(i);
if (matID < mMaterialNum) {
mMaterials[matID].setAnimation(anmSRTKey);
mMaterials[matID].setAnimation(p_anmSRTKey);
}
}
}
/* 802F9838-802F98CC 2F4178 0094+00 1/0 0/0 0/0 .text setAnimation__9J2DScreenFP16J2DAnmTexPattern
*/
void J2DScreen::setAnimation(J2DAnmTexPattern* anmPattern) {
anmPattern->searchUpdateMaterialID(this);
u16 matNum = anmPattern->getUpdateMaterialNum();
void J2DScreen::setAnimation(J2DAnmTexPattern* p_anmPattern) {
p_anmPattern->searchUpdateMaterialID(this);
u16 matNum = p_anmPattern->getUpdateMaterialNum();
for (u16 i = 0; i < matNum; i++) {
u16 matID = anmPattern->getUpdateMaterialID(i);
u16 matID = p_anmPattern->getUpdateMaterialID(i);
if (matID < mMaterialNum) {
mMaterials[matID].setAnimation(anmPattern);
mMaterials[matID].setAnimation(p_anmPattern);
}
}
}
/* 802F98CC-802F99A8 2F420C 00DC+00 1/0 0/0 0/0 .text setAnimation__9J2DScreenFP15J2DAnmTevRegKey
*/
void J2DScreen::setAnimation(J2DAnmTevRegKey* anmRegKey) {
anmRegKey->searchUpdateMaterialID(this);
void J2DScreen::setAnimation(J2DAnmTevRegKey* p_anmRegKey) {
p_anmRegKey->searchUpdateMaterialID(this);
u16 cMatNum = anmRegKey->getCRegUpdateMaterialNum();
u16 cMatNum = p_anmRegKey->getCRegUpdateMaterialNum();
for (u16 i = 0; i < cMatNum; i++) {
u16 matID = anmRegKey->getCRegUpdateMaterialID(i);
u16 matID = p_anmRegKey->getCRegUpdateMaterialID(i);
if (matID < mMaterialNum) {
mMaterials[matID].setAnimation(anmRegKey);
mMaterials[matID].setAnimation(p_anmRegKey);
}
}
u16 kMatNum = anmRegKey->getKRegUpdateMaterialNum();
u16 kMatNum = p_anmRegKey->getKRegUpdateMaterialNum();
for (u16 i = 0; i < kMatNum; i++) {
u16 matID = anmRegKey->getKRegUpdateMaterialID(i);
u16 matID = p_anmRegKey->getKRegUpdateMaterialID(i);
if (matID < mMaterialNum) {
mMaterials[matID].setAnimation(anmRegKey);
mMaterials[matID].setAnimation(p_anmRegKey);
}
}
}
/* 802F99A8-802F99C8 2F42E8 0020+00 1/0 0/0 0/0 .text setAnimation__9J2DScreenFP14J2DAnmVtxColor
*/
void J2DScreen::setAnimation(J2DAnmVtxColor* anmVtxColor) {
J2DPane::setVtxColorAnimation(anmVtxColor);
void J2DScreen::setAnimation(J2DAnmVtxColor* p_anmVtxColor) {
J2DPane::setVtxColorAnimation(p_anmVtxColor);
}
/* 802F99C8-802F99E8 2F4308 0020+00 1/0 0/0 0/0 .text
* setAnimation__9J2DScreenFP20J2DAnmVisibilityFull */
void J2DScreen::setAnimation(J2DAnmVisibilityFull* anmVisibility) {
J2DPane::setVisibileAnimation(anmVisibility);
void J2DScreen::setAnimation(J2DAnmVisibilityFull* p_anmVisibility) {
J2DPane::setVisibileAnimation(p_anmVisibility);
}
/* 802F99E8-802F9A18 2F4328 0030+00 1/0 0/0 0/0 .text
* createPane__9J2DScreenFRC18J2DScrnBlockHeaderP20JSURandomInputStreamP7J2DPaneUl */
J2DPane* J2DScreen::createPane(J2DScrnBlockHeader const& header, JSURandomInputStream* stream,
J2DPane* basePane, u32 param_3) {
return createPane(header, stream, basePane, param_3, NULL);
J2DPane* J2DScreen::createPane(J2DScrnBlockHeader const& header, JSURandomInputStream* p_stream,
J2DPane* p_basePane, u32 param_3) {
return createPane(header, p_stream, p_basePane, param_3, NULL);
}
/* 802F9A18-802F9A20 2F4358 0008+00 1/0 0/0 0/0 .text getTypeID__9J2DScreenCFv */
@@ -825,18 +814,18 @@ void J2DScreen::calcMtx() {
}
/* 802F9A54-802F9A74 2F4394 0020+00 1/0 0/0 0/0 .text setAnimation__9J2DScreenFP10J2DAnmBase */
void J2DScreen::setAnimation(J2DAnmBase* anm) {
J2DPane::setAnimation(anm);
void J2DScreen::setAnimation(J2DAnmBase* p_anm) {
J2DPane::setAnimation(p_anm);
}
/* 802F9A74-802F9A78 2F43B4 0004+00 1/0 0/0 0/0 .text
* setAnimationVF__9J2DScreenFP20J2DAnmVisibilityFull */
void J2DScreen::setAnimationVF(J2DAnmVisibilityFull* param_0) {
void J2DScreen::setAnimationVF(J2DAnmVisibilityFull*) {
/* empty function */
}
/* 802F9A78-802F9A7C 2F43B8 0004+00 1/0 0/0 0/0 .text setAnimationVC__9J2DScreenFP14J2DAnmVtxColor
*/
void J2DScreen::setAnimationVC(J2DAnmVtxColor* param_0) {
void J2DScreen::setAnimationVC(J2DAnmVtxColor*) {
/* empty function */
}
libs/JSystem/J2DGraph/J2DTextBox.cpp
+359 -308
View File
@@ -9,285 +9,334 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void __ct__10J2DTextBoxFv();
extern "C" void __ct__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamP10JKRArchive();
extern "C" void __ct__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamUlP11J2DMaterial();
extern "C" void func_802FFBC4();
extern "C" void initiate__10J2DTextBoxFPC7ResFONTPCcs18J2DTextBoxHBinding18J2DTextBoxVBinding();
extern "C" void private_readStream__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamP10JKRArchive();
extern "C" void __dt__10J2DTextBoxFv();
extern "C" void setFont__10J2DTextBoxFP7JUTFont();
extern "C" void draw__10J2DTextBoxFff();
extern "C" void draw__10J2DTextBoxFfff18J2DTextBoxHBinding();
extern "C" void getStringPtr__10J2DTextBoxCFv();
extern "C" void setString__10J2DTextBoxFPCce();
extern "C" void setString__10J2DTextBoxFsPCce();
extern "C" void setConnectParent__10J2DTextBoxFb();
extern "C" void drawSelf__10J2DTextBoxFff();
extern "C" void drawSelf__10J2DTextBoxFffPA3_A4_f();
extern "C" void resize__10J2DTextBoxFff();
extern "C" void isUsed__10J2DTextBoxFPC7ResFONT();
extern "C" s32 getTypeID__10J2DTextBoxCFv();
extern "C" void isUsed__10J2DTextBoxFPC7ResTIMG();
extern "C" void rewriteAlpha__10J2DTextBoxFv();
extern "C" extern char const* const J2DTextBox__stringBase0;
//
// External References:
//
extern "C" void setAlpha__7J2DPaneFUc();
extern "C" void calcMtx__7J2DPaneFv();
extern "C" void makeMatrix__7J2DPaneFff();
extern "C" void setAnimation__7J2DPaneFP15J2DAnmTevRegKey();
extern "C" void setAnimation__7J2DPaneFP11J2DAnmColor();
extern "C" void setWhite__10J2DTextBoxFQ28JUtility6TColor();
extern "C" void setAnimation__7J2DPaneFP19J2DAnmTextureSRTKey();
extern "C" void setBlackWhite__10J2DTextBoxFQ28JUtility6TColorQ28JUtility6TColor();
extern "C" void getWhite__10J2DTextBoxCFv();
extern "C" void getBlack__10J2DTextBoxCFv();
extern "C" void getFont__10J2DTextBoxCFv();
extern "C" void setBlack__10J2DTextBoxFQ28JUtility6TColor();
extern "C" void setAnimation__7J2DPaneFP14J2DAnmVtxColor();
extern "C" void setAnimation__7J2DPaneFP20J2DAnmVisibilityFull();
extern "C" void setAnimation__7J2DPaneFP16J2DAnmTexPattern();
extern "C" bool getMaterial__10J2DTextBoxCFv();
extern "C" void* __nw__FUl();
extern "C" void* __nwa__FUl();
extern "C" void __dl__FPv();
extern "C" void __dla__FPv();
extern "C" void read__14JSUInputStreamFPvl();
extern "C" void peek__20JSURandomInputStreamFPvl();
extern "C" void seek__20JSURandomInputStreamFl17JSUStreamSeekFrom();
extern "C" void __ct__10JUTResFontFPC7ResFONTP7JKRHeap();
extern "C" void
__ct__8J2DPrintFP7JUTFontffQ28JUtility6TColorQ28JUtility6TColorQ28JUtility6TColorQ28JUtility6TColor();
extern "C" void __dt__8J2DPrintFv();
extern "C" void locate__8J2DPrintFff();
extern "C" void print__8J2DPrintFffUcPCce();
extern "C" void printReturn__8J2DPrintFPCcff18J2DTextBoxHBinding18J2DTextBoxVBindingffUc();
extern "C" void __ct__7J2DPaneFv();
extern "C" void func_802F5E88();
extern "C" void makePaneStream__7J2DPaneFP7J2DPaneP20JSURandomInputStream();
extern "C" void __dt__7J2DPaneFv();
extern "C" void move__7J2DPaneFff();
extern "C" void add__7J2DPaneFff();
extern "C" void resize__7J2DPaneFff();
extern "C" void search__7J2DPaneFUx();
extern "C" void searchUserInfo__7J2DPaneFUx();
extern "C" void isUsed__7J2DPaneFPC7ResTIMG();
extern "C" void isUsed__7J2DPaneFPC7ResFONT();
extern "C" void makeMatrix__7J2DPaneFffff();
extern "C" void setCullBack__7J2DPaneF11_GXCullMode();
extern "C" void makePaneExStream__7J2DPaneFP7J2DPaneP20JSURandomInputStream();
extern "C" void getPointer__7J2DPaneFP20JSURandomInputStreamUlP10JKRArchive();
extern "C" void setAnimation__7J2DPaneFP10J2DAnmBase();
extern "C" void setAnimation__7J2DPaneFP15J2DAnmTransform();
extern "C" void clearAnmTransform__7J2DPaneFv();
extern "C" void animationTransform__7J2DPaneFPC15J2DAnmTransform();
extern "C" void setVisibileAnimation__7J2DPaneFP20J2DAnmVisibilityFull();
extern "C" void setVtxColorAnimation__7J2DPaneFP14J2DAnmVtxColor();
extern "C" void animationPane__7J2DPaneFPC15J2DAnmTransform();
extern "C" void setAnimationVF__7J2DPaneFP20J2DAnmVisibilityFull();
extern "C" void setAnimationVC__7J2DPaneFP14J2DAnmVtxColor();
extern "C" void setCullBack__7J2DPaneFb();
extern "C" void update__7J2DPaneFv();
extern "C" void _savegpr_25();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_25();
extern "C" void _restgpr_26();
extern "C" void _restgpr_27();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
//
// Declarations:
//
/* ############################################################################################## */
/* 803CD328-803CD3E8 02A448 00BC+04 5/5 0/0 0/0 .data __vt__10J2DTextBox */
SECTION_DATA extern void* __vt__10J2DTextBox[47 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__10J2DTextBoxFv,
(void*)getTypeID__10J2DTextBoxCFv,
(void*)move__7J2DPaneFff,
(void*)add__7J2DPaneFff,
(void*)resize__10J2DTextBoxFff,
(void*)setCullBack__7J2DPaneFb,
(void*)setCullBack__7J2DPaneF11_GXCullMode,
(void*)setAlpha__7J2DPaneFUc,
(void*)setConnectParent__10J2DTextBoxFb,
(void*)calcMtx__7J2DPaneFv,
(void*)update__7J2DPaneFv,
(void*)drawSelf__10J2DTextBoxFff,
(void*)drawSelf__10J2DTextBoxFffPA3_A4_f,
(void*)search__7J2DPaneFUx,
(void*)searchUserInfo__7J2DPaneFUx,
(void*)makeMatrix__7J2DPaneFff,
(void*)makeMatrix__7J2DPaneFffff,
(void*)isUsed__10J2DTextBoxFPC7ResTIMG,
(void*)isUsed__10J2DTextBoxFPC7ResFONT,
(void*)clearAnmTransform__7J2DPaneFv,
(void*)rewriteAlpha__10J2DTextBoxFv,
(void*)setAnimation__7J2DPaneFP10J2DAnmBase,
(void*)setAnimation__7J2DPaneFP15J2DAnmTransform,
(void*)setAnimation__7J2DPaneFP11J2DAnmColor,
(void*)setAnimation__7J2DPaneFP16J2DAnmTexPattern,
(void*)setAnimation__7J2DPaneFP19J2DAnmTextureSRTKey,
(void*)setAnimation__7J2DPaneFP15J2DAnmTevRegKey,
(void*)setAnimation__7J2DPaneFP20J2DAnmVisibilityFull,
(void*)setAnimation__7J2DPaneFP14J2DAnmVtxColor,
(void*)animationTransform__7J2DPaneFPC15J2DAnmTransform,
(void*)setVisibileAnimation__7J2DPaneFP20J2DAnmVisibilityFull,
(void*)setAnimationVF__7J2DPaneFP20J2DAnmVisibilityFull,
(void*)setVtxColorAnimation__7J2DPaneFP14J2DAnmVtxColor,
(void*)setAnimationVC__7J2DPaneFP14J2DAnmVtxColor,
(void*)animationPane__7J2DPaneFPC15J2DAnmTransform,
(void*)draw__10J2DTextBoxFff,
(void*)draw__10J2DTextBoxFfff18J2DTextBoxHBinding,
(void*)setFont__10J2DTextBoxFP7JUTFont,
(void*)getFont__10J2DTextBoxCFv,
(void*)setBlack__10J2DTextBoxFQ28JUtility6TColor,
(void*)setWhite__10J2DTextBoxFQ28JUtility6TColor,
(void*)setBlackWhite__10J2DTextBoxFQ28JUtility6TColorQ28JUtility6TColor,
(void*)getBlack__10J2DTextBoxCFv,
(void*)getWhite__10J2DTextBoxCFv,
(void*)getMaterial__10J2DTextBoxCFv,
/* padding */
NULL,
};
/* 802FF660-802FF6D8 2F9FA0 0078+00 0/0 1/1 0/0 .text __ct__10J2DTextBoxFv */
J2DTextBox::J2DTextBox()
: mFont(NULL), mCharColor(), mGradientColor(), mStringPtr(NULL), mWhiteColor(), mBlackColor() {
initiate(NULL, 0, 0, HBIND_LEFT, VBIND_TOP);
initiate(NULL, NULL, 0, HBIND_LEFT, VBIND_TOP);
}
/* 802FF6D8-802FF75C 2FA018 0084+00 0/0 1/1 0/0 .text
* __ct__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamP10JKRArchive */
J2DTextBox::J2DTextBox(J2DPane* param_0, JSURandomInputStream* param_1, JKRArchive* param_2)
J2DTextBox::J2DTextBox(J2DPane* p_pane, JSURandomInputStream* p_stream, JKRArchive* p_archive)
: mFont(NULL), mCharColor(), mGradientColor(), mStringPtr(NULL), mWhiteColor(), mBlackColor() {
private_readStream(param_0, param_1, param_2);
private_readStream(p_pane, p_stream, p_archive);
}
/* ############################################################################################## */
/* 80456280-80456288 004880 0004+04 6/6 0/0 0/0 .sdata2 @1660 */
SECTION_SDATA2 static f32 lit_1660[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
/* 80456288-80456290 004888 0008+00 3/3 0/0 0/0 .sdata2 @1662 */
SECTION_SDATA2 static f64 lit_1662 = 4503601774854144.0 /* cast s32 to float */;
/* 80456290-80456298 004890 0008+00 2/2 0/0 0/0 .sdata2 @1665 */
SECTION_SDATA2 static f64 lit_1665 = 4503599627370496.0 /* cast u32 to float */;
/* 802FF75C-802FFBC4 2FA09C 0468+00 0/0 1/1 0/0 .text
* __ct__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamUlP11J2DMaterial */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm J2DTextBox::J2DTextBox(J2DPane* param_0, JSURandomInputStream* param_1, u32 param_2,
J2DMaterial* param_3) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/__ct__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamUlP11J2DMaterial.s"
J2DTextBox::J2DTextBox(J2DPane* p_pane, JSURandomInputStream* p_stream, u32 param_2,
J2DMaterial* p_material)
: mFont(NULL), mCharColor(), mGradientColor(), mStringPtr(NULL), mWhiteColor(), mBlackColor() {
J2DTextBoxInfo info;
int startPos = p_stream->getPosition();
J2DTbxBlockHeader header;
p_stream->read(&header, 8);
mKind = 'TBX1';
int panHeaderPos = p_stream->getPosition();
J2DTbxBlockHeader panHeader;
p_stream->peek(&panHeader, 8);
makePaneExStream(p_pane, p_stream);
p_stream->seek(panHeaderPos + panHeader.mSize, JSUStreamSeekFrom_SET);
p_stream->read(&info, 0x20);
J2DMaterial* mat = NULL;
if (info.mMaterialNum != 0xFFFF) {
mat = &p_material[info.mMaterialNum];
if (mat != NULL) {
if (mat->getTevBlock() != NULL) {
JUTFont* font = mat->getTevBlock()->getFont();
if (font != NULL) {
mFont = font;
mat->getTevBlock()->setFontUndeleteFlag();
}
}
mAlpha = mat->getColorBlock()->getMatColor(0)->a;
}
}
mCharSpacing = info.mCharSpace;
mLineSpacing = info.mLineSpace;
mFontSizeX = info.mFontSizeX;
mFontSizeY = info.mFontSizeY;
mFlags = (info.mHBind << 2) | info.mVBind;
mCharColor = JUtility::TColor(info.mCharColor);
mGradientColor = JUtility::TColor(info.mGradColor);
setConnectParent(info.mConnected);
u16 strLength = 0;
if (!(param_2 & 0x2000000)) {
strLength = info.field_0x1c;
if ((s16)info.field_0x1c == -1) {
strLength = info.field_0x1e + 1;
}
}
mStringLength = 0;
mStringPtr = NULL;
if (strLength != 0) {
mStringPtr = new char[strLength];
}
if (mStringPtr != NULL) {
mStringLength = strLength;
int temp_r0 = (u16)strLength - 1;
u16 var_r26_2 = info.field_0x1e;
if (temp_r0 < var_r26_2) {
var_r26_2 = (u16)temp_r0;
}
p_stream->peek(mStringPtr, var_r26_2);
mStringPtr[var_r26_2] = 0;
}
p_stream->skip(info.field_0x1e);
p_stream->seek(startPos + header.mSize, JSUStreamSeekFrom_SET);
mBlackColor = JUtility::TColor(0);
mWhiteColor = JUtility::TColor(0xFFFFFFFF);
if (mat != NULL && mat->getTevBlock() != NULL) {
if (mat->getTevBlock()->getTevStageNum() != 1) {
J2DGXColorS10* color0p = mat->getTevBlock()->getTevColor(0);
GXColorS10 color0;
color0.r = color0p->r;
color0.g = color0p->g;
color0.b = color0p->b;
color0.a = color0p->a;
J2DGXColorS10* color1p = mat->getTevBlock()->getTevColor(1);
GXColorS10 color1;
color1.r = color1p->r;
color1.g = color1p->g;
color1.b = color1p->b;
color1.a = color1p->a;
mBlackColor = JUtility::TColor(((u8)color0.r << 0x18) | ((u8)color0.g << 0x10) |
((u8)color0.b << 8) | (u8)color0.a);
mWhiteColor = JUtility::TColor(((u8)color1.r << 0x18) | ((u8)color1.g << 0x10) |
((u8)color1.b << 8) | (u8)color1.a);
}
}
field_0x10c = 0.0f;
field_0x110 = 0.0f;
mTextFontOwned = true;
}
#pragma pop
/* 802FFBC4-802FFC58 2FA504 0094+00 0/0 1/1 0/0 .text
* __ct__10J2DTextBoxFUxRCQ29JGeometry8TBox2<f>PC7ResFONTPCcs18J2DTextBoxHBinding18J2DTextBoxVBinding
*/
J2DTextBox::J2DTextBox(u64 param_0, JGeometry::TBox2<f32> const& param_1, ResFONT const* param_2,
char const* param_3, s16 param_4, J2DTextBoxHBinding param_5,
J2DTextBoxVBinding param_6)
: J2DPane(param_0, param_1), mFont(NULL), mCharColor(), mGradientColor(), mStringPtr(NULL),
J2DTextBox::J2DTextBox(u64 tag, JGeometry::TBox2<f32> const& bounds, ResFONT const* p_font,
char const* string, s16 strLength, J2DTextBoxHBinding hBind,
J2DTextBoxVBinding vBind)
: J2DPane(tag, bounds), mFont(NULL), mCharColor(), mGradientColor(), mStringPtr(NULL),
mWhiteColor(), mBlackColor() {
initiate(param_2, param_3, param_4, param_5, param_6);
initiate(p_font, string, strLength, hBind, vBind);
}
/* 802FFC58-802FFE88 2FA598 0230+00 2/2 1/0 0/0 .text
* initiate__10J2DTextBoxFPC7ResFONTPCcs18J2DTextBoxHBinding18J2DTextBoxVBinding */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::initiate(ResFONT const* param_0, char const* param_1, s16 param_2,
J2DTextBoxHBinding param_3, J2DTextBoxVBinding param_4) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/initiate__10J2DTextBoxFPC7ResFONTPCcs18J2DTextBoxHBinding18J2DTextBoxVBinding.s"
void J2DTextBox::initiate(ResFONT const* p_font, char const* string, s16 length,
J2DTextBoxHBinding hBind, J2DTextBoxVBinding vBind) {
if (p_font != NULL) {
mFont = new JUTResFont(p_font, NULL);
}
mCharColor.set(0xFFFFFFFF);
mGradientColor.set(0xFFFFFFFF);
mBlackColor = JUtility::TColor(0);
mWhiteColor = JUtility::TColor(0xFFFFFFFF);
mFlags = (hBind << 2) | vBind;
mStringLength = 0;
mStringPtr = NULL;
if (string != NULL && length != 0) {
u32 len = strlen(string);
u16 stringLen = length;
if (length == -1) {
if (len >= 0xFFFF) {
len = 0xFFFF - 1;
}
stringLen = len + 1;
}
mStringPtr = new char[stringLen];
if (stringLen != 0 && mStringPtr != NULL) {
strncpy(mStringPtr, string, stringLen - 1);
mStringPtr[stringLen - 1] = 0;
mStringLength = stringLen;
}
}
field_0x10c = 0.0f;
field_0x110 = 0.0f;
mCharSpacing = 0.0f;
if (mFont == NULL) {
mLineSpacing = 0.0f;
mFontSizeX = 0.0f;
mFontSizeY = 0.0f;
} else {
mLineSpacing = mFont->getLeading();
mFontSizeX = mFont->getWidth();
mFontSizeY = mFont->getHeight();
}
mKind = 'TBX1';
mTextFontOwned = true;
}
#pragma pop
/* 802FFE88-803001E0 2FA7C8 0358+00 1/1 0/0 0/0 .text
* private_readStream__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamP10JKRArchive */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::private_readStream(J2DPane* param_0, JSURandomInputStream* param_1,
JKRArchive* param_2) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/private_readStream__10J2DTextBoxFP7J2DPaneP20JSURandomInputStreamP10JKRArchive.s"
void J2DTextBox::private_readStream(J2DPane* p_pane, JSURandomInputStream* p_stream,
JKRArchive* p_archive) {
int position = p_stream->getPosition();
J2DTbxBlockHeader header;
p_stream->read(&header, 8);
mKind = header.mTag;
makePaneStream(p_pane, p_stream);
u8 spA = p_stream->readU8();
ResFONT* fontPtr = (ResFONT*)getPointer(p_stream, 'FONT', p_archive);
if (fontPtr != NULL) {
mFont = new JUTResFont(fontPtr, NULL);
}
mCharColor.set(p_stream->read32b());
mGradientColor.set(p_stream->read32b());
mFlags = p_stream->read8b();
mCharSpacing = p_stream->readS16();
mLineSpacing = p_stream->readS16();
mFontSizeX = p_stream->read16b();
mFontSizeY = p_stream->read16b();
s16 stringLen = p_stream->read16b();
mStringPtr = new char[stringLen + 1];
if (mStringPtr != NULL) {
p_stream->read(mStringPtr, stringLen);
mStringPtr[stringLen] = 0;
mStringLength = stringLen + 1;
} else {
p_stream->skip(stringLen);
mStringLength = 0;
}
spA -= 10;
if (spA != 0) {
u8 sp8 = p_stream->read8b();
if (sp8 != 0) {
setConnectParent(true);
}
spA--;
}
mBlackColor = JUtility::TColor(0);
mWhiteColor = JUtility::TColor(0xFFFFFFFF);
if (spA != 0) {
mBlackColor.set(p_stream->read32b());
spA--;
}
if (spA != 0) {
mWhiteColor.set(p_stream->read32b());
}
field_0x10c = 0.0f;
field_0x110 = 0.0f;
p_stream->seek(position + header.mSize, JSUStreamSeekFrom_SET);
mTextFontOwned = true;
}
#pragma pop
/* 803001E0-80300278 2FAB20 0098+00 1/0 2/2 0/0 .text __dt__10J2DTextBoxFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
// asm J2DTextBox::~J2DTextBox() {
extern "C" asm void __dt__10J2DTextBoxFv() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/__dt__10J2DTextBoxFv.s"
J2DTextBox::~J2DTextBox() {
if (mTextFontOwned) {
delete mFont;
}
delete[] mStringPtr;
}
#pragma pop
/* 80300278-803002E8 2FABB8 0070+00 1/0 0/0 0/0 .text setFont__10J2DTextBoxFP7JUTFont */
void J2DTextBox::setFont(JUTFont* pFont) {
if (pFont) {
void J2DTextBox::setFont(JUTFont* p_font) {
if (p_font) {
if (mTextFontOwned) {
delete mFont;
}
mFont = pFont;
mFont = p_font;
mTextFontOwned = false;
}
}
/* ############################################################################################## */
/* 803A1C58-803A1C58 02E2B8 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_803A1C58 = "%s";
#pragma pop
/* 803002E8-80300490 2FAC28 01A8+00 1/0 0/0 0/0 .text draw__10J2DTextBoxFff */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::draw(f32 param_0, f32 param_1) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/draw__10J2DTextBoxFff.s"
void J2DTextBox::draw(f32 posX, f32 posY) {
Mtx m;
if (isVisible()) {
J2DPrint print(mFont, mCharSpacing, mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize(mFontSizeX, mFontSizeY);
makeMatrix(posX, posY, 0.0f, 0.0f);
GXLoadPosMtxImm(mPositionMtx, GX_PNMTX0);
GXSetCurrentMtx(0);
GXSetNumIndStages(0);
for (int i = 0; i < 16; i++) {
GXSetTevDirect((GXTevStageID)i);
}
GXSetNumTexGens(1);
GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 60, GX_FALSE, 125);
if (mStringPtr != NULL) {
print.print(0.0f, 0.0f, mAlpha, "%s", mStringPtr);
}
PSMTXIdentity(m);
GXLoadPosMtxImm(m, 0);
}
}
#pragma pop
/* 80300490-80300658 2FADD0 01C8+00 1/0 1/1 0/0 .text draw__10J2DTextBoxFfff18J2DTextBoxHBinding
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::draw(f32 param_0, f32 param_1, f32 param_2, J2DTextBoxHBinding param_3) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/draw__10J2DTextBoxFfff18J2DTextBoxHBinding.s"
void J2DTextBox::draw(f32 posX, f32 posY, f32 param_2, J2DTextBoxHBinding hBind) {
Mtx m;
if (isVisible()) {
J2DPrint print(mFont, mCharSpacing, mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize(mFontSizeX, mFontSizeY);
makeMatrix(posX, posY, 0.0f, 0.0f);
GXLoadPosMtxImm(mPositionMtx, GX_PNMTX0);
GXSetCurrentMtx(0);
GXSetNumIndStages(0);
for (int i = 0; i < 16; i++) {
GXSetTevDirect((GXTevStageID)i);
}
GXSetNumTexGens(1);
GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 60, GX_FALSE, 125);
if (mStringPtr != NULL) {
print.printReturn(mStringPtr, param_2, 0.0f, hBind, VBIND_TOP, 0.0f, -mFontSizeY,
mAlpha);
}
PSMTXIdentity(m);
GXLoadPosMtxImm(m, 0);
}
}
#pragma pop
/* 80300658-80300660 2FAF98 0008+00 0/0 62/62 2/2 .text getStringPtr__10J2DTextBoxCFv */
char* J2DTextBox::getStringPtr() const {
@@ -295,9 +344,10 @@ char* J2DTextBox::getStringPtr() const {
}
/* 80300660-8030074C 2FAFA0 00EC+00 0/0 6/6 0/0 .text setString__10J2DTextBoxFPCce */
// missing block of instructions before delete[]
#ifdef NONMATCHING
s32 J2DTextBox::setString(char const* string, ...) {
va_list args;
va_start(args, string);
delete[] mStringPtr;
u32 len = strlen(string);
@@ -314,115 +364,116 @@ s32 J2DTextBox::setString(char const* string, ...) {
mStringLength = len + 1;
strcpy(mStringPtr, string);
}
va_end(args);
return len;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm s32 J2DTextBox::setString(char const* param_0, ...) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/setString__10J2DTextBoxFPCce.s"
}
#pragma pop
#endif
/* 8030074C-80300870 2FB08C 0124+00 0/0 41/41 2/2 .text setString__10J2DTextBoxFsPCce */
#ifdef NONMATCHING
s32 J2DTextBox::setString(s16 param_0, char const* string, ...) {
s32 J2DTextBox::setString(s16 length, char const* string, ...) {
va_list args;
va_start(args, string);
delete[] mStringPtr;
mStringPtr = NULL;
u32 len = strlen(string);
u16 stringLen = length;
if (param_0 == -1) {
if (length == -1) {
if (len >= 0xFFFF) {
len = 0xFFFF - 1;
}
param_0 = len + 1;
stringLen = len + 1;
}
mStringLength = 0;
if (param_0 != 0) {
char* tmp = new char[param_0];
mStringPtr = tmp;
if (stringLen != 0) {
mStringPtr = new char[stringLen];
}
if (mStringPtr) {
strncpy(mStringPtr, string, param_0 - 1);
mStringPtr[param_0 - 1] = 0;
mStringLength = param_0;
if (mStringPtr != NULL) {
strncpy(mStringPtr, string, stringLen - 1);
mStringPtr[stringLen - 1] = 0;
mStringLength = stringLen;
}
va_end(args);
return len;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm s32 J2DTextBox::setString(s16 param_0, char const* param_1, ...) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/setString__10J2DTextBoxFsPCce.s"
}
#pragma pop
#endif
/* 80300870-803008E8 2FB1B0 0078+00 1/0 1/0 0/0 .text setConnectParent__10J2DTextBoxFb */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool J2DTextBox::setConnectParent(bool param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/setConnectParent__10J2DTextBoxFb.s"
bool J2DTextBox::setConnectParent(bool connected) {
if (getPaneTree()->getParent() == NULL) {
return false;
}
if ((u16)getPaneTree()->getParent()->getObject()->getTypeID() != 0x11) {
return false;
}
mConnected = connected;
return connected;
}
#pragma pop
/* 803008E8-80300950 2FB228 0068+00 1/0 1/0 0/0 .text drawSelf__10J2DTextBoxFff */
void J2DTextBox::drawSelf(f32 param_0, f32 param_1) {
Mtx tmp;
PSMTXIdentity(tmp);
Mtx identity;
PSMTXIdentity(identity);
drawSelf(param_0, param_1, &tmp);
drawSelf(param_0, param_1, &identity);
}
/* ############################################################################################## */
/* 80456298-804562A0 004898 0004+04 1/1 0/0 0/0 .sdata2 @2049 */
SECTION_SDATA2 static f32 lit_2049[1 + 1 /* padding */] = {
9.999999747378752e-05f,
/* padding */
0.0f,
};
/* 80300950-80300AF8 2FB290 01A8+00 1/0 0/0 0/0 .text drawSelf__10J2DTextBoxFffPA3_A4_f
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::drawSelf(f32 param_0, f32 param_1, f32 (*param_2)[3][4]) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/drawSelf__10J2DTextBoxFffPA3_A4_f.s"
void J2DTextBox::drawSelf(f32 param_0, f32 param_1, Mtx* p_mtx) {
Mtx m;
J2DPrint print(mFont, mCharSpacing, mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize(mFontSizeX, mFontSizeY);
PSMTXConcat(*p_mtx, mGlobalMtx, m);
GXLoadPosMtxImm(m, GX_PNMTX0);
GXSetNumIndStages(0);
for (int i = 0; i < 16; i++) {
GXSetTevDirect((GXTevStageID)i);
}
GXSetNumTexGens(1);
GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 60, GX_FALSE, 125);
print.locate(param_0 + mBounds.i.x, param_1 + mBounds.i.y);
if (mStringPtr != NULL) {
print.printReturn(mStringPtr, mBounds.getWidth() + 0.0001f, mBounds.getHeight(),
getHBinding(), getVBinding(), field_0x10c, field_0x110, mColorAlpha);
}
}
#pragma pop
/* 80300AF8-80300BFC 2FB438 0104+00 1/0 1/0 0/0 .text resize__10J2DTextBoxFff */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBox::resize(f32 param_0, f32 param_1) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/resize__10J2DTextBoxFff.s"
void J2DTextBox::resize(f32 x, f32 y) {
if (mConnected && getPaneTree() != NULL && getPaneTree()->getParent() != NULL) {
J2DPane* obj = getPaneTree()->getParent()->getObject();
if ((u16)obj->getTypeID() == 0x11) {
f32 obj_x = obj->getWidth() + (x - getWidth());
f32 obj_y = obj->getHeight() + (y - getHeight());
obj->resize(obj_x, obj_y);
return;
}
}
J2DPane::resize(x, y);
}
#pragma pop
/* 80300BFC-80300C68 2FB53C 006C+00 1/0 0/0 0/0 .text isUsed__10J2DTextBoxFPC7ResFONT */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool J2DTextBox::isUsed(ResFONT const* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBox/isUsed__10J2DTextBoxFPC7ResFONT.s"
bool J2DTextBox::isUsed(ResFONT const* p_font) {
if (mFont != NULL && mFont->getResFont() == p_font) {
return true;
}
return J2DPane::isUsed(p_font);
}
#pragma pop
/* 80300C68-80300C70 2FB5A8 0008+00 1/0 1/0 0/0 .text getTypeID__10J2DTextBoxCFv */
s32 J2DTextBox::getTypeID() const {
@@ -430,8 +481,8 @@ s32 J2DTextBox::getTypeID() const {
}
/* 80300C70-80300C90 2FB5B0 0020+00 1/0 0/0 0/0 .text isUsed__10J2DTextBoxFPC7ResTIMG */
bool J2DTextBox::isUsed(ResTIMG const* param_0) {
return J2DPane::isUsed(param_0);
bool J2DTextBox::isUsed(ResTIMG const* p_timg) {
return J2DPane::isUsed(p_timg);
}
/* 80300C90-80300C94 2FB5D0 0004+00 1/0 0/0 0/0 .text rewriteAlpha__10J2DTextBoxFv */
libs/JSystem/J2DGraph/J2DTextBoxEx.cpp
+370 -234
View File
@@ -102,165 +102,270 @@ extern "C" void _restgpr_28();
// Declarations:
//
/* ############################################################################################## */
/* 803CD608-803CD6C8 02A728 00BC+04 2/2 0/0 0/0 .data __vt__12J2DTextBoxEx */
SECTION_DATA extern void* __vt__12J2DTextBoxEx[47 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)__dt__12J2DTextBoxExFv,
(void*)getTypeID__10J2DTextBoxCFv,
(void*)move__7J2DPaneFff,
(void*)add__7J2DPaneFff,
(void*)resize__10J2DTextBoxFff,
(void*)setCullBack__12J2DTextBoxExFb,
(void*)setCullBack__12J2DTextBoxExF11_GXCullMode,
(void*)setAlpha__12J2DTextBoxExFUc,
(void*)setConnectParent__10J2DTextBoxFb,
(void*)calcMtx__7J2DPaneFv,
(void*)update__7J2DPaneFv,
(void*)drawSelf__10J2DTextBoxFff,
(void*)drawSelf__12J2DTextBoxExFffPA3_A4_f,
(void*)search__7J2DPaneFUx,
(void*)searchUserInfo__7J2DPaneFUx,
(void*)makeMatrix__7J2DPaneFff,
(void*)makeMatrix__7J2DPaneFffff,
(void*)isUsed__12J2DTextBoxExFPC7ResTIMG,
(void*)isUsed__12J2DTextBoxExFPC7ResFONT,
(void*)clearAnmTransform__7J2DPaneFv,
(void*)rewriteAlpha__12J2DTextBoxExFv,
(void*)setAnimation__12J2DTextBoxExFP10J2DAnmBase,
(void*)setAnimation__12J2DTextBoxExFP15J2DAnmTransform,
(void*)setAnimation__12J2DTextBoxExFP11J2DAnmColor,
(void*)setAnimation__12J2DTextBoxExFP16J2DAnmTexPattern,
(void*)setAnimation__12J2DTextBoxExFP19J2DAnmTextureSRTKey,
(void*)setAnimation__12J2DTextBoxExFP15J2DAnmTevRegKey,
(void*)setAnimation__12J2DTextBoxExFP20J2DAnmVisibilityFull,
(void*)setAnimation__12J2DTextBoxExFP14J2DAnmVtxColor,
(void*)animationTransform__7J2DPaneFPC15J2DAnmTransform,
(void*)setVisibileAnimation__7J2DPaneFP20J2DAnmVisibilityFull,
(void*)setAnimationVF__7J2DPaneFP20J2DAnmVisibilityFull,
(void*)setVtxColorAnimation__7J2DPaneFP14J2DAnmVtxColor,
(void*)setAnimationVC__7J2DPaneFP14J2DAnmVtxColor,
(void*)animationPane__12J2DTextBoxExFPC15J2DAnmTransform,
(void*)draw__12J2DTextBoxExFff,
(void*)draw__12J2DTextBoxExFfff18J2DTextBoxHBinding,
(void*)setFont__12J2DTextBoxExFP7JUTFont,
(void*)getFont__12J2DTextBoxExCFv,
(void*)setBlack__12J2DTextBoxExFQ28JUtility6TColor,
(void*)setWhite__12J2DTextBoxExFQ28JUtility6TColor,
(void*)setBlackWhite__12J2DTextBoxExFQ28JUtility6TColorQ28JUtility6TColor,
(void*)getBlack__12J2DTextBoxExCFv,
(void*)getWhite__12J2DTextBoxExCFv,
(void*)getMaterial__12J2DTextBoxExCFv,
/* padding */
NULL,
};
/* 804562D8-804562E0 0048D8 0004+04 4/4 0/0 0/0 .sdata2 @1534 */
SECTION_SDATA2 static f32 lit_1534[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
/* 804562E0-804562E8 0048E0 0008+00 2/2 0/0 0/0 .sdata2 @1536 */
SECTION_SDATA2 static f64 lit_1536 = 4503601774854144.0 /* cast s32 to float */;
/* 804562E8-804562F0 0048E8 0008+00 1/1 0/0 0/0 .sdata2 @1539 */
SECTION_SDATA2 static f64 lit_1539 = 4503599627370496.0 /* cast u32 to float */;
/* 803071E4-8030751C 301B24 0338+00 0/0 1/1 0/0 .text
* __ct__12J2DTextBoxExFP7J2DPaneP20JSURandomInputStreamUlP11J2DMaterial */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm J2DTextBoxEx::J2DTextBoxEx(J2DPane* param_0, JSURandomInputStream* param_1, u32 param_2,
J2DMaterial* param_3) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/__ct__12J2DTextBoxExFP7J2DPaneP20JSURandomInputStreamUlP11J2DMaterial.s"
J2DTextBoxEx::J2DTextBoxEx(J2DPane* p_pane, JSURandomInputStream* p_stream, u32 param_2,
J2DMaterial* p_material) {
J2DTextBoxInfo info;
mVisibilityAnm = NULL;
int startPos = p_stream->getPosition();
J2DTbxBlockHeader header;
p_stream->read(&header, 8);
mKind = header.mTag;
int panHeaderPos = p_stream->getPosition();
J2DTbxBlockHeader panHeader;
p_stream->peek(&panHeader, 8);
makePaneExStream(p_pane, p_stream);
p_stream->seek(panHeaderPos + panHeader.mSize, JSUStreamSeekFrom_SET);
p_stream->read(&info, 0x20);
field_0x13c = info.field_0x2;
field_0x13e = info.mMaterialNum;
mMaterial = NULL;
if (field_0x13e != 0xFFFF) {
mMaterial = &p_material[field_0x13e];
p_material[field_0x13e].field_0x4 = this;
rewriteAlpha();
if (mMaterial != NULL) {
if (mMaterial->getTevBlock() != NULL) {
mFont = mMaterial->getTevBlock()->getFont();
}
}
}
mCharSpacing = info.mCharSpace;
mLineSpacing = info.mLineSpace;
mFontSizeX = info.mFontSizeX;
mFontSizeY = info.mFontSizeY;
mFlags = (info.mHBind << 2) | info.mVBind;
mCharColor = JUtility::TColor(info.mCharColor);
mGradientColor = JUtility::TColor(info.mGradColor);
setConnectParent(info.mConnected);
u16 strLength = 0;
if (!(param_2 & 0x2000000)) {
strLength = info.field_0x1c;
if ((s16)info.field_0x1c == -1) {
strLength = info.field_0x1e + 1;
}
}
mStringLength = 0;
mStringPtr = NULL;
if (strLength != 0) {
mStringPtr = new char[strLength];
}
if (mStringPtr != NULL) {
mStringLength = strLength;
int temp_r0 = (u16)strLength - 1;
u16 var_r26_2 = info.field_0x1e;
if (temp_r0 < var_r26_2) {
var_r26_2 = (u16)temp_r0;
}
p_stream->peek(mStringPtr, var_r26_2);
mStringPtr[var_r26_2] = 0;
}
p_stream->skip(info.field_0x1e);
p_stream->seek(startPos + header.mSize, JSUStreamSeekFrom_SET);
field_0x10c = 0.0f;
field_0x110 = 0.0f;
mTextFontOwned = false;
field_0x140 = 0;
}
#pragma pop
/* 8030751C-803075AC 301E5C 0090+00 1/0 0/0 0/0 .text __dt__12J2DTextBoxExFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
extern "C" asm void __dt__12J2DTextBoxExFv() {
// asm J2DTextBoxEx::~J2DTextBoxEx() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/__dt__12J2DTextBoxExFv.s"
J2DTextBoxEx::~J2DTextBoxEx() {
if (field_0x140 != 0) {
delete mMaterial;
}
}
#pragma pop
/* ############################################################################################## */
/* 804562F0-804562F8 0048F0 0004+04 1/1 0/0 0/0 .sdata2 @1731 */
SECTION_SDATA2 static f32 lit_1731[1 + 1 /* padding */] = {
9.999999747378752e-05f,
/* padding */
0.0f,
};
/* 803075AC-803078AC 301EEC 0300+00 1/0 0/0 0/0 .text drawSelf__12J2DTextBoxExFffPA3_A4_f
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::drawSelf(f32 param_0, f32 param_1, f32 (*param_2)[3][4]) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/drawSelf__12J2DTextBoxExFffPA3_A4_f.s"
}
#pragma pop
void J2DTextBoxEx::drawSelf(f32 param_0, f32 param_1, Mtx* p_mtx) {
Mtx m;
/* ############################################################################################## */
/* 803A1DF0-803A1DF0 02E450 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_803A1DF0 = "%s";
/* @stringBase0 padding */
SECTION_DEAD static char const* const pad_803A1DF3 = "\0\0\0\0";
#pragma pop
JUTFont* font = NULL;
if (mMaterial != NULL && mMaterial->getTevBlock() != NULL) {
font = mMaterial->getTevBlock()->getFont();
}
J2DPrint print(font, (int)mCharSpacing, (int)mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize((int)mFontSizeX, (int)mFontSizeY);
if (mMaterial != NULL) {
mMaterial->setGX();
PSMTXConcat(*p_mtx, mGlobalMtx, m);
GXLoadPosMtxImm(m, GX_PNMTX0);
GXClearVtxDesc();
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
print.locate(param_0 + mBounds.i.x, param_1 + mBounds.i.y);
if (mMaterial->isVisible() && mStringPtr != NULL) {
u8 alpha = 255;
if (mMaterial->getColorBlock()->getColorChan(1)->getMatSrc() == 1) {
if (mMaterial->getMaterialAlphaCalc() == 1) {
alpha = mColorAlpha;
}
} else if (mIsInfluencedAlpha) {
GXSetChanMatColor(GX_ALPHA0, JUtility::TColor(mColorAlpha));
}
print.printReturn(mStringPtr, (int)(mBounds.getWidth() + 0.0001f), (int)mBounds.getHeight(),
getHBinding(), getVBinding(), field_0x10c, field_0x110, alpha);
}
}
}
/* 803078AC-80307AF0 3021EC 0244+00 1/0 0/0 0/0 .text draw__12J2DTextBoxExFff */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::draw(f32 param_0, f32 param_1) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/draw__12J2DTextBoxExFff.s"
void J2DTextBoxEx::draw(f32 posX, f32 posY) {
Mtx m;
if (isVisible()) {
JUTFont* font = NULL;
if (mMaterial != NULL && mMaterial->getTevBlock() != NULL) {
font = mMaterial->getTevBlock()->getFont();
}
J2DPrint print(font, mCharSpacing, mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize(mFontSizeX, mFontSizeY);
mColorAlpha = mAlpha;
if (mMaterial != NULL) {
mMaterial->setGX();
makeMatrix(posX, posY, 0.0f, 0.0f);
GXLoadPosMtxImm(mPositionMtx, GX_PNMTX0);
GXSetCurrentMtx(0);
if (!mMaterial->isVisible()) {
return;
}
GXClearVtxDesc();
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
if (mStringPtr != NULL) {
u8 alpha = 255;
if (mMaterial->getMaterialAlphaCalc() == 1) {
alpha = mColorAlpha;
}
print.print(0.0f, 0.0f, alpha, "%s", mStringPtr);
}
for (int i = 0; i < 4; i++) {
GXSetTevSwapModeTable((GXTevSwapSel)i, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
}
GXSetNumIndStages(0);
for (int i = 0; i < 16; i++) {
GXSetTevDirect((GXTevStageID)i);
}
PSMTXIdentity(m);
GXLoadPosMtxImm(m, 0);
}
}
}
#pragma pop
/* 80307AF0-80307D5C 302430 026C+00 1/0 0/0 0/0 .text draw__12J2DTextBoxExFfff18J2DTextBoxHBinding
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::draw(f32 param_0, f32 param_1, f32 param_2, J2DTextBoxHBinding param_3) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/draw__12J2DTextBoxExFfff18J2DTextBoxHBinding.s"
void J2DTextBoxEx::draw(f32 posX, f32 posY, f32 param_2, J2DTextBoxHBinding hBind) {
Mtx m;
if (isVisible()) {
JUTFont* font = NULL;
if (mMaterial != NULL && mMaterial->getTevBlock() != NULL) {
font = mMaterial->getTevBlock()->getFont();
}
J2DPrint print(font, mCharSpacing, mLineSpacing, mCharColor, mGradientColor, mBlackColor,
mWhiteColor);
print.setFontSize(mFontSizeX, mFontSizeY);
mColorAlpha = mAlpha;
if (mMaterial != NULL) {
mMaterial->setGX();
makeMatrix(posX, posY, 0.0f, 0.0f);
GXLoadPosMtxImm(mPositionMtx, GX_PNMTX0);
GXSetCurrentMtx(0);
if (!mMaterial->isVisible()) {
return;
}
GXClearVtxDesc();
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
if (mStringPtr != NULL) {
u8 alpha = 255;
if (mMaterial->getMaterialAlphaCalc() == 1) {
alpha = mColorAlpha;
}
print.printReturn(mStringPtr, param_2, 0.0f, hBind, VBIND_TOP, 0.0f, -mFontSizeY,
alpha);
}
for (int i = 0; i < 4; i++) {
GXSetTevSwapModeTable((GXTevSwapSel)i, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
}
GXSetNumIndStages(0);
for (int i = 0; i < 16; i++) {
GXSetTevDirect((GXTevStageID)i);
}
PSMTXIdentity(m);
GXLoadPosMtxImm(m, 0);
}
}
}
#pragma pop
/* 80307D5C-80307DC0 30269C 0064+00 1/0 0/0 0/0 .text setFont__12J2DTextBoxExFP7JUTFont
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setFont(JUTFont* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setFont__12J2DTextBoxExFP7JUTFont.s"
void J2DTextBoxEx::setFont(JUTFont* p_font) {
if (p_font != NULL && mMaterial != NULL && mMaterial->getTevBlock() != NULL) {
mMaterial->getTevBlock()->setFont(p_font);
mFont = p_font;
}
}
#pragma pop
/* 80307DC0-80307E0C 302700 004C+00 1/0 0/0 0/0 .text getFont__12J2DTextBoxExCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JUTFont* J2DTextBoxEx::getFont() const {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/getFont__12J2DTextBoxExCFv.s"
JUTFont* J2DTextBoxEx::getFont() const {
if (mMaterial != NULL && mMaterial->getTevBlock() != NULL) {
return mMaterial->getTevBlock()->getFont();
}
return NULL;
}
#pragma pop
/* 80307E0C-80307EF0 30274C 00E4+00 1/1 0/0 0/0 .text setTevOrder__12J2DTextBoxExFb */
#pragma push
@@ -273,14 +378,16 @@ asm void J2DTextBoxEx::setTevOrder(bool param_0) {
#pragma pop
/* 80307EF0-80307F94 302830 00A4+00 1/1 0/0 0/0 .text setTevStage__12J2DTextBoxExFb */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setTevStage(bool param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setTevStage__12J2DTextBoxExFb.s"
void J2DTextBoxEx::setTevStage(bool param_0) {
J2DTevStage* stage = mMaterial->getTevBlock()->getTevStage(0);
if (!param_0) {
setStage(stage, STAGE_0);
} else {
setStage(stage, STAGE_1);
setStage(mMaterial->getTevBlock()->getTevStage(1), STAGE_2);
}
}
#pragma pop
/* ############################################################################################## */
/* 803A1DB8-803A1DC4 02E418 000C+00 1/1 0/0 0/0 .rodata @1953 */
@@ -361,43 +468,90 @@ asm void J2DTextBoxEx::setStage(J2DTevStage* param_0, J2DTextBoxEx::stage_enum p
/* 8030823C-803082C4 302B7C 0088+00 1/0 0/0 0/0 .text setBlack__12J2DTextBoxExFQ28JUtility6TColor
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setBlack(JUtility::TColor param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setBlack__12J2DTextBoxExFQ28JUtility6TColor.s"
bool J2DTextBoxEx::setBlack(JUtility::TColor black) {
JUtility::TColor tevBlack;
JUtility::TColor tevWhite;
if (!getBlackWhite(&tevBlack, &tevWhite)) {
return false;
} else {
return setBlackWhite(black, tevWhite);
}
}
#pragma pop
/* 803082C4-8030834C 302C04 0088+00 1/0 0/0 0/0 .text setWhite__12J2DTextBoxExFQ28JUtility6TColor
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setWhite(JUtility::TColor param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setWhite__12J2DTextBoxExFQ28JUtility6TColor.s"
bool J2DTextBoxEx::setWhite(JUtility::TColor white) {
JUtility::TColor tevBlack;
JUtility::TColor tevWhite;
if (!getBlackWhite(&tevBlack, &tevWhite)) {
return false;
} else {
return setBlackWhite(tevBlack, white);
}
}
#pragma pop
/* 8030834C-803084CC 302C8C 0180+00 1/0 0/0 0/0 .text
* setBlackWhite__12J2DTextBoxExFQ28JUtility6TColorQ28JUtility6TColor */
#ifdef NONMATCHING
bool J2DTextBoxEx::setBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) {
if (mMaterial == NULL) {
return false;
}
if (mMaterial->getTevBlock() == NULL) {
return false;
}
if (!isSetBlackWhite(param_0, param_1)) {
return false;
}
bool bvar = false;
if (param_0 != 0 || param_1 != -1) {
bvar = true;
}
mMaterial->getTevBlock()->setTevStageNum(bvar ? 2 : 1);
setTevOrder(bvar);
setTevStage(bvar);
if (bvar) {
J2DGXColorS10 color0;
color0.r = param_0.r;
color0.g = param_0.g;
color0.b = param_0.b;
color0.a = param_0.a;
mMaterial->getTevBlock()->setTevColor(0, color0);
J2DGXColorS10 color1;
color1.r = param_1.r;
color1.g = param_1.g;
color1.b = param_1.b;
color1.a = param_1.a;
mMaterial->getTevBlock()->setTevColor(1, color1);
}
return true;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) {
asm bool J2DTextBoxEx::setBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setBlackWhite__12J2DTextBoxExFQ28JUtility6TColorQ28JUtility6TColor.s"
}
#pragma pop
#endif
/* 803084CC-80308668 302E0C 019C+00 4/4 0/0 0/0 .text
* getBlackWhite__12J2DTextBoxExCFPQ28JUtility6TColorPQ28JUtility6TColor */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::getBlackWhite(JUtility::TColor* param_0, JUtility::TColor* param_1) const {
asm bool J2DTextBoxEx::getBlackWhite(JUtility::TColor* param_0, JUtility::TColor* param_1) const {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/getBlackWhite__12J2DTextBoxExCFPQ28JUtility6TColorPQ28JUtility6TColor.s"
}
@@ -408,7 +562,7 @@ asm void J2DTextBoxEx::getBlackWhite(JUtility::TColor* param_0, JUtility::TColor
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::isSetBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) const {
asm bool J2DTextBoxEx::isSetBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) const {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/isSetBlackWhite__12J2DTextBoxExCFQ28JUtility6TColorQ28JUtility6TColor.s"
}
@@ -418,7 +572,7 @@ asm void J2DTextBoxEx::isSetBlackWhite(JUtility::TColor param_0, JUtility::TColo
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::getBlack() const {
asm JUtility::TColor J2DTextBoxEx::getBlack() const {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/getBlack__12J2DTextBoxExCFv.s"
}
@@ -428,101 +582,93 @@ asm void J2DTextBoxEx::getBlack() const {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::getWhite() const {
asm JUtility::TColor J2DTextBoxEx::getWhite() const {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/getWhite__12J2DTextBoxExCFv.s"
}
#pragma pop
/* 803087BC-803087DC 3030FC 0020+00 1/0 0/0 0/0 .text setAlpha__12J2DTextBoxExFUc */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAlpha(u8 param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAlpha__12J2DTextBoxExFUc.s"
void J2DTextBoxEx::setAlpha(u8 alpha) {
mAlpha = alpha;
if (mMaterial == NULL) {
return;
}
if (mMaterial->getColorBlock()->getMatColor(0) == NULL) {
return;
}
mMaterial->getColorBlock()->getMatColor(0)->a = alpha;
}
#pragma pop
/* 803087DC-80308810 30311C 0034+00 1/0 0/0 0/0 .text setCullBack__12J2DTextBoxExF11_GXCullMode */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setCullBack(_GXCullMode param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setCullBack__12J2DTextBoxExF11_GXCullMode.s"
void J2DTextBoxEx::setCullBack(GXCullMode mode) {
mCullMode = mode;
if (mMaterial != NULL) {
mMaterial->getColorBlock()->setCullMode(mode);
}
J2DPane::setCullBack(mode);
}
#pragma pop
/* 80308810-80308828 303150 0018+00 1/0 0/0 0/0 .text rewriteAlpha__12J2DTextBoxExFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::rewriteAlpha() {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/rewriteAlpha__12J2DTextBoxExFv.s"
void J2DTextBoxEx::rewriteAlpha() {
if (mMaterial == NULL) {
return;
}
mAlpha = mMaterial->getColorBlock()->getMatColor(0)->a;
}
#pragma pop
/* 80308828-803088B4 303168 008C+00 1/0 0/0 0/0 .text isUsed__12J2DTextBoxExFPC7ResFONT
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::isUsed(ResFONT const* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/isUsed__12J2DTextBoxExFPC7ResFONT.s"
bool J2DTextBoxEx::isUsed(ResFONT const* p_font) {
if (getFont() != NULL && getFont()->getResFont() == p_font) {
return true;
}
return J2DPane::isUsed(p_font);
}
#pragma pop
/* 803088B4-803088E0 3031F4 002C+00 1/0 0/0 0/0 .text setAnimation__12J2DTextBoxExFP11J2DAnmColor
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAnimation(J2DAnmColor* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAnimation__12J2DTextBoxExFP11J2DAnmColor.s"
void J2DTextBoxEx::setAnimation(J2DAnmColor* anm) {
if (mMaterial != NULL) {
mMaterial->setAnimation(anm);
}
}
#pragma pop
/* 803088E0-8030890C 303220 002C+00 1/0 0/0 0/0 .text
* setAnimation__12J2DTextBoxExFP19J2DAnmTextureSRTKey */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAnimation(J2DAnmTextureSRTKey* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAnimation__12J2DTextBoxExFP19J2DAnmTextureSRTKey.s"
void J2DTextBoxEx::setAnimation(J2DAnmTextureSRTKey* anm) {
if (mMaterial != NULL) {
mMaterial->setAnimation(anm);
}
}
#pragma pop
/* 8030890C-80308938 30324C 002C+00 1/0 0/0 0/0 .text
* setAnimation__12J2DTextBoxExFP16J2DAnmTexPattern */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAnimation(J2DAnmTexPattern* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAnimation__12J2DTextBoxExFP16J2DAnmTexPattern.s"
void J2DTextBoxEx::setAnimation(J2DAnmTexPattern* anm) {
if (mMaterial != NULL) {
mMaterial->setAnimation(anm);
}
}
#pragma pop
/* 80308938-80308964 303278 002C+00 1/0 0/0 0/0 .text
* setAnimation__12J2DTextBoxExFP15J2DAnmTevRegKey */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAnimation(J2DAnmTevRegKey* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAnimation__12J2DTextBoxExFP15J2DAnmTevRegKey.s"
void J2DTextBoxEx::setAnimation(J2DAnmTevRegKey* anm) {
if (mMaterial != NULL) {
mMaterial->setAnimation(anm);
}
}
#pragma pop
/* 80308964-8030896C -00001 0008+00 0/0 0/0 0/0 .text
* setAnimation__12J2DTextBoxExFP20J2DAnmVisibilityFull */
void J2DTextBoxEx::setAnimation(J2DAnmVisibilityFull* param_0) {
*(u32*)(((u8*)this) + 324) /* this->field_0x144 */ = (u32)(param_0);
void J2DTextBoxEx::setAnimation(J2DAnmVisibilityFull* anm) {
mVisibilityAnm = anm;
}
/* 8030896C-803089EC 3032AC 0080+00 1/0 0/0 0/0 .text
@@ -530,7 +676,7 @@ void J2DTextBoxEx::setAnimation(J2DAnmVisibilityFull* param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::animationPane(J2DAnmTransform const* param_0) {
asm const J2DAnmTransform* J2DTextBoxEx::animationPane(J2DAnmTransform const* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/animationPane__12J2DTextBoxExFPC15J2DAnmTransform.s"
}
@@ -548,14 +694,9 @@ asm void J2DTextBoxEx::setCullBack(bool param_0) {
/* 80308A28-80308A48 303368 0020+00 1/0 0/0 0/0 .text isUsed__12J2DTextBoxExFPC7ResTIMG
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::isUsed(ResTIMG const* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/isUsed__12J2DTextBoxExFPC7ResTIMG.s"
bool J2DTextBoxEx::isUsed(ResTIMG const* p_timg) {
return J2DPane::isUsed(p_timg);
}
#pragma pop
/* 80308A48-80308A4C 303388 0004+00 1/0 0/0 0/0 .text
* setAnimation__12J2DTextBoxExFP14J2DAnmVtxColor */
@@ -565,13 +706,8 @@ void J2DTextBoxEx::setAnimation(J2DAnmVtxColor* param_0) {
/* 80308A4C-80308A6C 30338C 0020+00 1/0 0/0 0/0 .text setAnimation__12J2DTextBoxExFP10J2DAnmBase
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J2DTextBoxEx::setAnimation(J2DAnmBase* param_0) {
nofralloc
#include "asm/JSystem/J2DGraph/J2DTextBoxEx/setAnimation__12J2DTextBoxExFP10J2DAnmBase.s"
void J2DTextBoxEx::setAnimation(J2DAnmBase* anm) {
J2DPane::setAnimation(anm);
}
#pragma pop
/* 803A1DF0-803A1DF0 02E450 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */