mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-08-22 06:44:53 -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 */
libs/JSystem/J3DGraphBase/J3DSys.cpp
+2 -2
View File
@@ -148,7 +148,7 @@ void J3DSys::drawInit() {
GXSetCurrentMtx(GX_PNMTX0);
GXSetCullMode(GX_CULL_BACK);
GXSetCoPlanar(GX_FALSE);
GXSetClipMode(GX_FALSE);
GXSetClipMode(GX_CLIP_ENABLE);
GXSetColorUpdate(GX_TRUE);
GXSetDither(GX_TRUE);
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_NOOP);
@@ -244,7 +244,7 @@ void J3DSys::drawInit() {
GXSetTevIndirect((GXTevStageID)i, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_NONE, GX_ITM_OFF,
GX_ITW_OFF, GX_ITW_OFF, GX_FALSE, GX_FALSE, GX_ITBA_OFF);
OSInitFastCast();
i_OSInitFastCast();
setTexCacheRegion(GX_TEXCACHE_32K);
}
libs/JSystem/JAudio2/JAISoundStarter.cpp
-21
View File
@@ -7,27 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JGeometry {
template <typename A1>
struct TVec3 {};
/* TVec3<f32> */
struct TVec3__template0 {};
};
struct JAISoundID {};
struct JAISoundHandle {};
struct JAISoundStarter {
/* 802A2F6C */ JAISoundStarter(bool);
/* 802A2F88 */ ~JAISoundStarter();
/* 802A2FEC */ void startLevelSound(JAISoundID, JAISoundHandle*, JGeometry::TVec3<f32> const*);
};
//
// Forward References:
//
libs/JSystem/JAudio2/JASTaskThread.cpp
-3
View File
@@ -39,9 +39,6 @@ extern "C" void* __nw__FUlP7JKRHeapi();
extern "C" void __dl__FPv();
extern "C" void __ct__9JKRThreadFP7JKRHeapUlii();
extern "C" void __dt__9JKRThreadFv();
extern "C" void OSInitThreadQueue();
extern "C" void OSSleepThread();
extern "C" void OSWakeupThread();
extern "C" void _savegpr_26();
extern "C" void _savegpr_27();
extern "C" void _savegpr_28();
libs/JSystem/JFramework/JFWDisplay.cpp
+2 -2
View File
@@ -560,7 +560,7 @@ void JFWDisplay::threadSleep(s64 time) {
s32 status = OSDisableInterrupts();
alarm.appendLink();
OSSetAlarm(&alarm, time, JFWThreadAlarmHandler);
OSSetAlarm(&alarm, time, (OSAlarmHandler*)JFWThreadAlarmHandler);
OSSuspendThread(alarm.getThread());
OSRestoreInterrupts(status);
}
@@ -681,7 +681,7 @@ static void JFWDrawDoneAlarm() {
s32 status = OSDisableInterrupts();
alarm.createAlarm();
alarm.appendLink();
OSSetAlarm(&alarm, 0.5 * (*(u32*)0x800000F8 / 4), JFWGXAbortAlarmHandler);
OSSetAlarm(&alarm, 0.5 * (*(u32*)0x800000F8 / 4), (OSAlarmHandler*)JFWGXAbortAlarmHandler);
GXDrawDone();
alarm.cancelAlarm();
alarm.removeLink();
libs/JSystem/JKernel/JKRAramArchive.cpp
+3 -3
View File
@@ -205,7 +205,7 @@ bool JKRAramArchive::open(s32 entryNum) {
mExpandedSize =
(s32*)JKRAllocFromHeap(mHeap, mArcInfoBlock->num_file_entries * 4, abs(align));
if (mExpandedSize == NULL) {
JKRFree(mArcInfoBlock);
i_JKRFree(mArcInfoBlock);
mMountMode = UNKNOWN_MOUNT_MODE;
goto end;
} else {
@@ -218,10 +218,10 @@ bool JKRAramArchive::open(s32 entryNum) {
mMountDirection == MOUNT_DIRECTION_HEAD ? JKRAramHeap::HEAD : JKRAramHeap::TAIL));
if (mBlock == NULL) {
if (mArcInfoBlock != NULL) {
JKRFree(mArcInfoBlock);
i_JKRFree(mArcInfoBlock);
}
if (mExpandedSize != NULL) {
JKRFree(mExpandedSize);
i_JKRFree(mExpandedSize);
}
mMountMode = UNKNOWN_MOUNT_MODE;
} else {
libs/JSystem/JKernel/JKRAramStream.cpp
+1 -1
View File
@@ -200,7 +200,7 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
}
if (command->mAllocatedTransferBuffer) {
JKRFree(buffer);
i_JKRFree(buffer);
command->mAllocatedTransferBuffer = false;
}
}
libs/JSystem/JKernel/JKRDvdArchive.cpp
+1 -1
View File
@@ -113,7 +113,7 @@ JKRDvdArchive::~JKRDvdArchive() {
}
if (mExpandedSize) {
JKRFree(mExpandedSize);
i_JKRFree(mExpandedSize);
mExpandedSize = NULL;
}
libs/JSystem/JKernel/JKRExpHeap.cpp
+2 -2
View File
@@ -97,12 +97,12 @@ extern "C" u8 mErrorHandler__7JKRHeap[4];
//
/* 802CEDB4-802CEE2C 2C96F4 0078+00 0/0 1/1 0/0 .text createRoot__10JKRExpHeapFib */
JKRExpHeap* JKRExpHeap::createRoot(int param_0, bool errorFlag) {
JKRExpHeap* JKRExpHeap::createRoot(int maxHeaps, bool errorFlag) {
JKRExpHeap* heap = NULL;
if (!sRootHeap) {
void* memory;
u32 memorySize;
initArena((char**)&memory, &memorySize, param_0);
initArena((char**)&memory, &memorySize, maxHeaps);
u8* start = (u8*)memory + ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
u32 alignedSize = memorySize - ALIGN_NEXT(sizeof(JKRExpHeap), 0x10);
heap = new (memory) JKRExpHeap(start, alignedSize, NULL, errorFlag);
libs/JSystem/JKernel/JKRHeap.cpp
+9 -9
View File
@@ -204,27 +204,27 @@ void* JKRHeap::mUserRamEnd;
u32 JKRHeap::mMemorySize;
/* 802CE378-802CE428 2C8CB8 00B0+00 0/0 1/1 0/0 .text initArena__7JKRHeapFPPcPUli */
bool JKRHeap::initArena(char** memory, u32* size, int param_3) {
bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
u32 ram_start;
u32 ram_end;
u32 ram;
void* ram;
u32 low = OSGetArenaLo();
u32 high = OSGetArenaHi();
void* low = OSGetArenaLo();
void* high = OSGetArenaHi();
if (low == high)
return false;
ram = OSInitAlloc(low, high, param_3);
ram_start = ALIGN_NEXT(ram, 0x20);
ram_end = ALIGN_PREV(high, 0x20);
ram = OSInitAlloc(low, high, maxHeaps);
ram_start = ALIGN_NEXT((u32)ram, 0x20);
ram_end = ALIGN_PREV((u32)high, 0x20);
GLOBAL_MEMORY* globalMemory = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
mCodeStart = globalMemory;
mCodeEnd = (void*)ram_start;
mUserRamStart = (void*)ram_start;
mUserRamEnd = (void*)ram_end;
mMemorySize = globalMemory->memory_size;
OSSetArenaLo(ram_end);
OSSetArenaHi(ram_end);
OSSetArenaLo((void*)ram_end);
OSSetArenaHi((void*)ram_end);
*memory = (char*)ram_start;
*size = ram_end - ram_start;
return true;
libs/JSystem/JKernel/JKRMemArchive.cpp
-1
View File
@@ -134,7 +134,6 @@ extern "C" void orderSync__9JKRDecompFPUcPUcUlUl();
extern "C" void prepend__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void DCInvalidateRange();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_28();
libs/JSystem/JKernel/JKRThread.cpp
+1 -1
View File
@@ -97,7 +97,7 @@ JKRThread::~JKRThread() {
JKRFreeToHeap(mHeap, mStackMemory);
JKRFreeToHeap(mHeap, mThreadRecord);
}
JKRFree(mMessages);
i_JKRFree(mMessages);
}
/* 802D1830-802D18A4 2CC170 0074+00 3/3 0/0 0/0 .text setCommon_mesgQueue__9JKRThreadFP7JKRHeapi
libs/JSystem/JParticle/JPABaseShape.cpp
+1 -1
View File
@@ -912,7 +912,7 @@ void JPADrawPoint(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
GXBegin(GX_POINTS, GX_VTXFMT1, 1);
GXPosition3f32(ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
GXTexCoord2f32(0.0f, 0.0f);
GXEnd();
i_GXEnd();
GXSetVtxDesc(GX_VA_POS, GX_INDEX8);
GXSetVtxDesc(GX_VA_TEX0, GX_INDEX8);
}
libs/JSystem/JStage/JSGActor.cpp
+23 -233
View File
@@ -1,160 +1,7 @@
//
// Generated By: dol2asm
// Translation Unit: JSGActor
//
#include "JSystem/JStage/JSGActor.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
struct JStage {
struct TActor {
/* 80280A48 */ ~TActor();
/* 80280AA8 */ s32 JSGFGetType() const;
/* 80280AB0 */ void JSGGetTranslation(Vec*) const;
/* 80280AB4 */ void JSGSetTranslation(Vec const&);
/* 80280AB8 */ void JSGGetScaling(Vec*) const;
/* 80280ABC */ void JSGSetScaling(Vec const&);
/* 80280AC0 */ void JSGGetRotation(Vec*) const;
/* 80280AC4 */ void JSGSetRotation(Vec const&);
/* 80280AC8 */ s32 JSGGetShape() const;
/* 80280AD0 */ void JSGSetShape(u32);
/* 80280AD4 */ s32 JSGGetAnimation() const;
/* 80280ADC */ void JSGSetAnimation(u32);
/* 80280AE0 */ void JSGGetAnimationFrame() const;
/* 80280AE8 */ void JSGSetAnimationFrame(f32);
/* 80280AEC */ void JSGGetAnimationFrameMax() const;
/* 80280AF4 */ void JSGGetAnimationTransition() const;
/* 80280AFC */ void JSGSetAnimationTransition(f32);
/* 80280B00 */ s32 JSGGetTextureAnimation() const;
/* 80280B08 */ void JSGSetTextureAnimation(u32);
/* 80280B0C */ void JSGGetTextureAnimationFrame() const;
/* 80280B14 */ void JSGSetTextureAnimationFrame(f32);
/* 80280B18 */ void JSGGetTextureAnimationFrameMax() const;
};
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage6TActorFv();
extern "C" s32 JSGFGetType__Q26JStage6TActorCFv();
extern "C" void JSGGetTranslation__Q26JStage6TActorCFP3Vec();
extern "C" void JSGSetTranslation__Q26JStage6TActorFRC3Vec();
extern "C" void JSGGetScaling__Q26JStage6TActorCFP3Vec();
extern "C" void JSGSetScaling__Q26JStage6TActorFRC3Vec();
extern "C" void JSGGetRotation__Q26JStage6TActorCFP3Vec();
extern "C" void JSGSetRotation__Q26JStage6TActorFRC3Vec();
extern "C" s32 JSGGetShape__Q26JStage6TActorCFv();
extern "C" void JSGSetShape__Q26JStage6TActorFUl();
extern "C" s32 JSGGetAnimation__Q26JStage6TActorCFv();
extern "C" void JSGSetAnimation__Q26JStage6TActorFUl();
extern "C" void JSGGetAnimationFrame__Q26JStage6TActorCFv();
extern "C" void JSGSetAnimationFrame__Q26JStage6TActorFf();
extern "C" void JSGGetAnimationFrameMax__Q26JStage6TActorCFv();
extern "C" void JSGGetAnimationTransition__Q26JStage6TActorCFv();
extern "C" void JSGSetAnimationTransition__Q26JStage6TActorFf();
extern "C" s32 JSGGetTextureAnimation__Q26JStage6TActorCFv();
extern "C" void JSGSetTextureAnimation__Q26JStage6TActorFUl();
extern "C" void JSGGetTextureAnimationFrame__Q26JStage6TActorCFv();
extern "C" void JSGSetTextureAnimationFrame__Q26JStage6TActorFf();
extern "C" void JSGGetTextureAnimationFrameMax__Q26JStage6TActorCFv();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 803C45A8-803C4638 0216C8 008C+04 1/1 1/1 0/0 .data __vt__Q26JStage6TActor */
SECTION_DATA extern void* __vt__Q26JStage6TActor[35 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage6TActorCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGGetTranslation__Q26JStage6TActorCFP3Vec,
(void*)JSGSetTranslation__Q26JStage6TActorFRC3Vec,
(void*)JSGGetScaling__Q26JStage6TActorCFP3Vec,
(void*)JSGSetScaling__Q26JStage6TActorFRC3Vec,
(void*)JSGGetRotation__Q26JStage6TActorCFP3Vec,
(void*)JSGSetRotation__Q26JStage6TActorFRC3Vec,
(void*)JSGGetShape__Q26JStage6TActorCFv,
(void*)JSGSetShape__Q26JStage6TActorFUl,
(void*)JSGGetAnimation__Q26JStage6TActorCFv,
(void*)JSGSetAnimation__Q26JStage6TActorFUl,
(void*)JSGGetAnimationFrame__Q26JStage6TActorCFv,
(void*)JSGSetAnimationFrame__Q26JStage6TActorFf,
(void*)JSGGetAnimationFrameMax__Q26JStage6TActorCFv,
(void*)JSGGetAnimationTransition__Q26JStage6TActorCFv,
(void*)JSGSetAnimationTransition__Q26JStage6TActorFf,
(void*)JSGGetTextureAnimation__Q26JStage6TActorCFv,
(void*)JSGSetTextureAnimation__Q26JStage6TActorFUl,
(void*)JSGGetTextureAnimationFrame__Q26JStage6TActorCFv,
(void*)JSGSetTextureAnimationFrame__Q26JStage6TActorFf,
(void*)JSGGetTextureAnimationFrameMax__Q26JStage6TActorCFv,
/* padding */
NULL,
};
/* 80280A48-80280AA8 27B388 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage6TActorFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TActor::~TActor() {
nofralloc
#include "asm/JSystem/JStage/JSGActor/__dt__Q26JStage6TActorFv.s"
}
#pragma pop
JStage::TActor::~TActor() {}
/* 80280AA8-80280AB0 27B3E8 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage6TActorCFv */
s32 JStage::TActor::JSGFGetType() const {
@@ -163,35 +10,23 @@ s32 JStage::TActor::JSGFGetType() const {
/* 80280AB0-80280AB4 27B3F0 0004+00 1/0 0/0 0/0 .text JSGGetTranslation__Q26JStage6TActorCFP3Vec
*/
void JStage::TActor::JSGGetTranslation(Vec* param_0) const {
/* empty function */
}
void JStage::TActor::JSGGetTranslation(Vec*) const {}
/* 80280AB4-80280AB8 27B3F4 0004+00 1/0 0/0 0/0 .text JSGSetTranslation__Q26JStage6TActorFRC3Vec
*/
void JStage::TActor::JSGSetTranslation(Vec const& param_0) {
/* empty function */
}
void JStage::TActor::JSGSetTranslation(Vec const&) {}
/* 80280AB8-80280ABC 27B3F8 0004+00 1/0 0/0 0/0 .text JSGGetScaling__Q26JStage6TActorCFP3Vec */
void JStage::TActor::JSGGetScaling(Vec* param_0) const {
/* empty function */
}
void JStage::TActor::JSGGetScaling(Vec*) const {}
/* 80280ABC-80280AC0 27B3FC 0004+00 1/0 0/0 0/0 .text JSGSetScaling__Q26JStage6TActorFRC3Vec */
void JStage::TActor::JSGSetScaling(Vec const& param_0) {
/* empty function */
}
void JStage::TActor::JSGSetScaling(Vec const&) {}
/* 80280AC0-80280AC4 27B400 0004+00 1/0 0/0 0/0 .text JSGGetRotation__Q26JStage6TActorCFP3Vec */
void JStage::TActor::JSGGetRotation(Vec* param_0) const {
/* empty function */
}
void JStage::TActor::JSGGetRotation(Vec*) const {}
/* 80280AC4-80280AC8 27B404 0004+00 1/0 0/0 0/0 .text JSGSetRotation__Q26JStage6TActorFRC3Vec */
void JStage::TActor::JSGSetRotation(Vec const& param_0) {
/* empty function */
}
void JStage::TActor::JSGSetRotation(Vec const&) {}
/* 80280AC8-80280AD0 27B408 0008+00 1/0 1/0 0/0 .text JSGGetShape__Q26JStage6TActorCFv */
s32 JStage::TActor::JSGGetShape() const {
@@ -199,9 +34,7 @@ s32 JStage::TActor::JSGGetShape() const {
}
/* 80280AD0-80280AD4 27B410 0004+00 1/0 0/0 0/0 .text JSGSetShape__Q26JStage6TActorFUl */
void JStage::TActor::JSGSetShape(u32 param_0) {
/* empty function */
}
void JStage::TActor::JSGSetShape(u32) {}
/* 80280AD4-80280ADC 27B414 0008+00 1/0 1/0 0/0 .text JSGGetAnimation__Q26JStage6TActorCFv */
s32 JStage::TActor::JSGGetAnimation() const {
@@ -209,60 +42,31 @@ s32 JStage::TActor::JSGGetAnimation() const {
}
/* 80280ADC-80280AE0 27B41C 0004+00 1/0 0/0 0/0 .text JSGSetAnimation__Q26JStage6TActorFUl */
void JStage::TActor::JSGSetAnimation(u32 param_0) {
/* empty function */
}
/* ############################################################################################## */
/* 804553C8-804553D0 0039C8 0004+04 5/5 0/0 0/0 .sdata2 @343 */
SECTION_SDATA2 static f32 lit_343[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
void JStage::TActor::JSGSetAnimation(u32) {}
/* 80280AE0-80280AE8 27B420 0008+00 1/0 1/0 0/0 .text JSGGetAnimationFrame__Q26JStage6TActorCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TActor::JSGGetAnimationFrame() const {
nofralloc
#include "asm/JSystem/JStage/JSGActor/JSGGetAnimationFrame__Q26JStage6TActorCFv.s"
f32 JStage::TActor::JSGGetAnimationFrame() const {
return 0.0f;
}
#pragma pop
/* 80280AE8-80280AEC 27B428 0004+00 1/0 0/0 0/0 .text JSGSetAnimationFrame__Q26JStage6TActorFf */
void JStage::TActor::JSGSetAnimationFrame(f32 param_0) {
/* empty function */
}
void JStage::TActor::JSGSetAnimationFrame(f32) {}
/* 80280AEC-80280AF4 27B42C 0008+00 1/0 0/0 0/0 .text JSGGetAnimationFrameMax__Q26JStage6TActorCFv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TActor::JSGGetAnimationFrameMax() const {
nofralloc
#include "asm/JSystem/JStage/JSGActor/JSGGetAnimationFrameMax__Q26JStage6TActorCFv.s"
f32 JStage::TActor::JSGGetAnimationFrameMax() const {
return 0.0f;
}
#pragma pop
/* 80280AF4-80280AFC 27B434 0008+00 1/0 1/0 0/0 .text
* JSGGetAnimationTransition__Q26JStage6TActorCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TActor::JSGGetAnimationTransition() const {
nofralloc
#include "asm/JSystem/JStage/JSGActor/JSGGetAnimationTransition__Q26JStage6TActorCFv.s"
f32 JStage::TActor::JSGGetAnimationTransition() const {
return 0.0f;
}
#pragma pop
/* 80280AFC-80280B00 27B43C 0004+00 1/0 0/0 0/0 .text
* JSGSetAnimationTransition__Q26JStage6TActorFf */
void JStage::TActor::JSGSetAnimationTransition(f32 param_0) {
/* empty function */
}
void JStage::TActor::JSGSetAnimationTransition(f32) {}
/* 80280B00-80280B08 27B440 0008+00 1/0 1/0 0/0 .text JSGGetTextureAnimation__Q26JStage6TActorCFv
*/
@@ -272,34 +76,20 @@ s32 JStage::TActor::JSGGetTextureAnimation() const {
/* 80280B08-80280B0C 27B448 0004+00 1/0 0/0 0/0 .text JSGSetTextureAnimation__Q26JStage6TActorFUl
*/
void JStage::TActor::JSGSetTextureAnimation(u32 param_0) {
/* empty function */
}
void JStage::TActor::JSGSetTextureAnimation(u32) {}
/* 80280B0C-80280B14 27B44C 0008+00 1/0 1/0 0/0 .text
* JSGGetTextureAnimationFrame__Q26JStage6TActorCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TActor::JSGGetTextureAnimationFrame() const {
nofralloc
#include "asm/JSystem/JStage/JSGActor/JSGGetTextureAnimationFrame__Q26JStage6TActorCFv.s"
f32 JStage::TActor::JSGGetTextureAnimationFrame() const {
return 0.0f;
}
#pragma pop
/* 80280B14-80280B18 27B454 0004+00 1/0 0/0 0/0 .text
* JSGSetTextureAnimationFrame__Q26JStage6TActorFf */
void JStage::TActor::JSGSetTextureAnimationFrame(f32 param_0) {
/* empty function */
}
void JStage::TActor::JSGSetTextureAnimationFrame(f32) {}
/* 80280B18-80280B20 27B458 0008+00 1/0 0/0 0/0 .text
* JSGGetTextureAnimationFrameMax__Q26JStage6TActorCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TActor::JSGGetTextureAnimationFrameMax() const {
nofralloc
#include "asm/JSystem/JStage/JSGActor/JSGGetTextureAnimationFrameMax__Q26JStage6TActorCFv.s"
f32 JStage::TActor::JSGGetTextureAnimationFrameMax() const {
return 0.0f;
}
#pragma pop
libs/JSystem/JStage/JSGAmbientLight.cpp
+4 -118
View File
@@ -1,132 +1,18 @@
//
// Generated By: dol2asm
// Translation Unit: JSGAmbientLight
//
#include "JSystem/JStage/JSGAmbientLight.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXColor {};
struct JStage {
struct TAmbientLight {
/* 80280B20 */ ~TAmbientLight();
/* 80280B80 */ s32 JSGFGetType() const;
/* 80280B88 */ void JSGGetColor() const;
/* 80280B9C */ void JSGSetColor(_GXColor);
};
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage13TAmbientLightFv();
extern "C" s32 JSGFGetType__Q26JStage13TAmbientLightCFv();
extern "C" void JSGGetColor__Q26JStage13TAmbientLightCFv();
extern "C" void JSGSetColor__Q26JStage13TAmbientLightF8_GXColor();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 803C4638-803C4680 021758 0044+04 1/1 1/1 0/0 .data __vt__Q26JStage13TAmbientLight */
SECTION_DATA extern void* __vt__Q26JStage13TAmbientLight[17 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage13TAmbientLightCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGGetColor__Q26JStage13TAmbientLightCFv,
(void*)JSGSetColor__Q26JStage13TAmbientLightF8_GXColor,
/* padding */
NULL,
};
/* 80280B20-80280B80 27B460 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage13TAmbientLightFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TAmbientLight::~TAmbientLight() {
nofralloc
#include "asm/JSystem/JStage/JSGAmbientLight/__dt__Q26JStage13TAmbientLightFv.s"
}
#pragma pop
JStage::TAmbientLight::~TAmbientLight() {}
/* 80280B80-80280B88 27B4C0 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage13TAmbientLightCFv */
s32 JStage::TAmbientLight::JSGFGetType() const {
return 4;
}
/* ############################################################################################## */
/* 804553D0-804553D8 0039D0 0004+04 1/1 0/0 0/0 .sdata2 @302 */
SECTION_SDATA2 static u32 lit_302[1 + 1 /* padding */] = {
0xFFFFFFFF,
/* padding */
0x00000000,
};
/* 80280B88-80280B9C 27B4C8 0014+00 1/0 1/0 0/0 .text JSGGetColor__Q26JStage13TAmbientLightCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TAmbientLight::JSGGetColor() const {
nofralloc
#include "asm/JSystem/JStage/JSGAmbientLight/JSGGetColor__Q26JStage13TAmbientLightCFv.s"
GXColor JStage::TAmbientLight::JSGGetColor() const {
return (GXColor){255, 255, 255, 255};
}
#pragma pop
/* 80280B9C-80280BA0 27B4DC 0004+00 1/0 0/0 0/0 .text
* JSGSetColor__Q26JStage13TAmbientLightF8_GXColor */
void JStage::TAmbientLight::JSGSetColor(_GXColor param_0) {
/* empty function */
}
void JStage::TAmbientLight::JSGSetColor(GXColor) {}
libs/JSystem/JStage/JSGCamera.cpp
+27 -253
View File
@@ -1,171 +1,8 @@
//
// Generated By: dol2asm
// Translation Unit: JSGCamera
//
#include "JSystem/JStage/JSGCamera.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
struct JStage {
struct TECameraProjection {};
struct TECameraView {};
struct TCamera {
/* 80280BA0 */ ~TCamera();
/* 80280C00 */ s32 JSGFGetType() const;
/* 80280C08 */ bool JSGGetProjectionType() const;
/* 80280C10 */ void JSGSetProjectionType(JStage::TECameraProjection);
/* 80280C14 */ void JSGGetProjectionNear() const;
/* 80280C1C */ void JSGSetProjectionNear(f32);
/* 80280C20 */ void JSGGetProjectionFar() const;
/* 80280C2C */ void JSGSetProjectionFar(f32);
/* 80280C30 */ void JSGGetProjectionFovy() const;
/* 80280C38 */ void JSGSetProjectionFovy(f32);
/* 80280C3C */ void JSGGetProjectionAspect() const;
/* 80280C44 */ void JSGSetProjectionAspect(f32);
/* 80280C48 */ void JSGGetProjectionField(f32*) const;
/* 80280C4C */ void JSGSetProjectionField(f32 const*);
/* 80280C50 */ bool JSGGetViewType() const;
/* 80280C58 */ void JSGSetViewType(JStage::TECameraView);
/* 80280C5C */ void JSGGetViewPosition(Vec*) const;
/* 80280C60 */ void JSGSetViewPosition(Vec const&);
/* 80280C64 */ void JSGGetViewUpVector(Vec*) const;
/* 80280C68 */ void JSGSetViewUpVector(Vec const&);
/* 80280C6C */ void JSGGetViewTargetPosition(Vec*) const;
/* 80280C70 */ void JSGSetViewTargetPosition(Vec const&);
/* 80280C74 */ void JSGGetViewRoll() const;
/* 80280C7C */ void JSGSetViewRoll(f32);
};
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage7TCameraFv();
extern "C" s32 JSGFGetType__Q26JStage7TCameraCFv();
extern "C" bool JSGGetProjectionType__Q26JStage7TCameraCFv();
extern "C" void JSGSetProjectionType__Q26JStage7TCameraFQ26JStage18TECameraProjection();
extern "C" void JSGGetProjectionNear__Q26JStage7TCameraCFv();
extern "C" void JSGSetProjectionNear__Q26JStage7TCameraFf();
extern "C" void JSGGetProjectionFar__Q26JStage7TCameraCFv();
extern "C" void JSGSetProjectionFar__Q26JStage7TCameraFf();
extern "C" void JSGGetProjectionFovy__Q26JStage7TCameraCFv();
extern "C" void JSGSetProjectionFovy__Q26JStage7TCameraFf();
extern "C" void JSGGetProjectionAspect__Q26JStage7TCameraCFv();
extern "C" void JSGSetProjectionAspect__Q26JStage7TCameraFf();
extern "C" void JSGGetProjectionField__Q26JStage7TCameraCFPf();
extern "C" void JSGSetProjectionField__Q26JStage7TCameraFPCf();
extern "C" bool JSGGetViewType__Q26JStage7TCameraCFv();
extern "C" void JSGSetViewType__Q26JStage7TCameraFQ26JStage12TECameraView();
extern "C" void JSGGetViewPosition__Q26JStage7TCameraCFP3Vec();
extern "C" void JSGSetViewPosition__Q26JStage7TCameraFRC3Vec();
extern "C" void JSGGetViewUpVector__Q26JStage7TCameraCFP3Vec();
extern "C" void JSGSetViewUpVector__Q26JStage7TCameraFRC3Vec();
extern "C" void JSGGetViewTargetPosition__Q26JStage7TCameraCFP3Vec();
extern "C" void JSGSetViewTargetPosition__Q26JStage7TCameraFRC3Vec();
extern "C" void JSGGetViewRoll__Q26JStage7TCameraCFv();
extern "C" void JSGSetViewRoll__Q26JStage7TCameraFf();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
extern "C" extern u32 __float_max;
//
// Declarations:
//
/* ############################################################################################## */
/* 803C4680-803C4718 0217A0 0094+04 1/1 1/1 0/0 .data __vt__Q26JStage7TCamera */
SECTION_DATA extern void* __vt__Q26JStage7TCamera[37 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage7TCameraCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGGetProjectionType__Q26JStage7TCameraCFv,
(void*)JSGSetProjectionType__Q26JStage7TCameraFQ26JStage18TECameraProjection,
(void*)JSGGetProjectionNear__Q26JStage7TCameraCFv,
(void*)JSGSetProjectionNear__Q26JStage7TCameraFf,
(void*)JSGGetProjectionFar__Q26JStage7TCameraCFv,
(void*)JSGSetProjectionFar__Q26JStage7TCameraFf,
(void*)JSGGetProjectionFovy__Q26JStage7TCameraCFv,
(void*)JSGSetProjectionFovy__Q26JStage7TCameraFf,
(void*)JSGGetProjectionAspect__Q26JStage7TCameraCFv,
(void*)JSGSetProjectionAspect__Q26JStage7TCameraFf,
(void*)JSGGetProjectionField__Q26JStage7TCameraCFPf,
(void*)JSGSetProjectionField__Q26JStage7TCameraFPCf,
(void*)JSGGetViewType__Q26JStage7TCameraCFv,
(void*)JSGSetViewType__Q26JStage7TCameraFQ26JStage12TECameraView,
(void*)JSGGetViewPosition__Q26JStage7TCameraCFP3Vec,
(void*)JSGSetViewPosition__Q26JStage7TCameraFRC3Vec,
(void*)JSGGetViewUpVector__Q26JStage7TCameraCFP3Vec,
(void*)JSGSetViewUpVector__Q26JStage7TCameraFRC3Vec,
(void*)JSGGetViewTargetPosition__Q26JStage7TCameraCFP3Vec,
(void*)JSGSetViewTargetPosition__Q26JStage7TCameraFRC3Vec,
(void*)JSGGetViewRoll__Q26JStage7TCameraCFv,
(void*)JSGSetViewRoll__Q26JStage7TCameraFf,
/* padding */
NULL,
};
#include "MSL_C/math.h"
/* 80280BA0-80280C00 27B4E0 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage7TCameraFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TCamera::~TCamera() {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/__dt__Q26JStage7TCameraFv.s"
}
#pragma pop
JStage::TCamera::~TCamera() {}
/* 80280C00-80280C08 27B540 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage7TCameraCFv
*/
@@ -181,93 +18,51 @@ bool JStage::TCamera::JSGGetProjectionType() const {
/* 80280C10-80280C14 27B550 0004+00 1/0 1/0 0/0 .text
* JSGSetProjectionType__Q26JStage7TCameraFQ26JStage18TECameraProjection */
void JStage::TCamera::JSGSetProjectionType(JStage::TECameraProjection param_0) {
/* empty function */
}
/* ############################################################################################## */
/* 804553D8-804553E0 0039D8 0004+04 4/4 0/0 0/0 .sdata2 @319 */
SECTION_SDATA2 static f32 lit_319[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
void JStage::TCamera::JSGSetProjectionType(JStage::TECameraProjection) {}
/* 80280C14-80280C1C 27B554 0008+00 1/0 0/0 0/0 .text JSGGetProjectionNear__Q26JStage7TCameraCFv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TCamera::JSGGetProjectionNear() const {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/JSGGetProjectionNear__Q26JStage7TCameraCFv.s"
f32 JStage::TCamera::JSGGetProjectionNear() const {
return 0.0f;
}
#pragma pop
/* 80280C1C-80280C20 27B55C 0004+00 1/0 0/0 0/0 .text JSGSetProjectionNear__Q26JStage7TCameraFf */
void JStage::TCamera::JSGSetProjectionNear(f32 param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetProjectionNear(f32) {}
/* 80280C20-80280C2C 27B560 000C+00 1/0 0/0 0/0 .text JSGGetProjectionFar__Q26JStage7TCameraCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TCamera::JSGGetProjectionFar() const {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/JSGGetProjectionFar__Q26JStage7TCameraCFv.s"
f32 JStage::TCamera::JSGGetProjectionFar() const {
return __float_max[0];
}
#pragma pop
/* 80280C2C-80280C30 27B56C 0004+00 1/0 0/0 0/0 .text JSGSetProjectionFar__Q26JStage7TCameraFf */
void JStage::TCamera::JSGSetProjectionFar(f32 param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetProjectionFar(f32) {}
/* 80280C30-80280C38 27B570 0008+00 1/0 0/0 0/0 .text JSGGetProjectionFovy__Q26JStage7TCameraCFv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TCamera::JSGGetProjectionFovy() const {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/JSGGetProjectionFovy__Q26JStage7TCameraCFv.s"
f32 JStage::TCamera::JSGGetProjectionFovy() const {
return 0.0f;
}
#pragma pop
/* 80280C38-80280C3C 27B578 0004+00 1/0 0/0 0/0 .text JSGSetProjectionFovy__Q26JStage7TCameraFf */
void JStage::TCamera::JSGSetProjectionFovy(f32 param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetProjectionFovy(f32) {}
/* 80280C3C-80280C44 27B57C 0008+00 1/0 0/0 0/0 .text JSGGetProjectionAspect__Q26JStage7TCameraCFv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TCamera::JSGGetProjectionAspect() const {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/JSGGetProjectionAspect__Q26JStage7TCameraCFv.s"
f32 JStage::TCamera::JSGGetProjectionAspect() const {
return 0.0f;
}
#pragma pop
/* 80280C44-80280C48 27B584 0004+00 1/0 0/0 0/0 .text JSGSetProjectionAspect__Q26JStage7TCameraFf
*/
void JStage::TCamera::JSGSetProjectionAspect(f32 param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetProjectionAspect(f32) {}
/* 80280C48-80280C4C 27B588 0004+00 1/0 1/0 0/0 .text JSGGetProjectionField__Q26JStage7TCameraCFPf
*/
void JStage::TCamera::JSGGetProjectionField(f32* param_0) const {
/* empty function */
}
void JStage::TCamera::JSGGetProjectionField(f32*) const {}
/* 80280C4C-80280C50 27B58C 0004+00 1/0 1/0 0/0 .text JSGSetProjectionField__Q26JStage7TCameraFPCf
*/
void JStage::TCamera::JSGSetProjectionField(f32 const* param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetProjectionField(f32 const*) {}
/* 80280C50-80280C58 27B590 0008+00 1/0 1/0 0/0 .text JSGGetViewType__Q26JStage7TCameraCFv */
bool JStage::TCamera::JSGGetViewType() const {
@@ -276,58 +71,37 @@ bool JStage::TCamera::JSGGetViewType() const {
/* 80280C58-80280C5C 27B598 0004+00 1/0 1/0 0/0 .text
* JSGSetViewType__Q26JStage7TCameraFQ26JStage12TECameraView */
void JStage::TCamera::JSGSetViewType(JStage::TECameraView param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetViewType(JStage::TECameraView) {}
/* 80280C5C-80280C60 27B59C 0004+00 1/0 0/0 0/0 .text JSGGetViewPosition__Q26JStage7TCameraCFP3Vec
*/
void JStage::TCamera::JSGGetViewPosition(Vec* param_0) const {
/* empty function */
}
void JStage::TCamera::JSGGetViewPosition(Vec*) const {}
/* 80280C60-80280C64 27B5A0 0004+00 1/0 0/0 0/0 .text JSGSetViewPosition__Q26JStage7TCameraFRC3Vec
*/
void JStage::TCamera::JSGSetViewPosition(Vec const& param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetViewPosition(Vec const&) {}
/* 80280C64-80280C68 27B5A4 0004+00 1/0 0/0 0/0 .text JSGGetViewUpVector__Q26JStage7TCameraCFP3Vec
*/
void JStage::TCamera::JSGGetViewUpVector(Vec* param_0) const {
/* empty function */
}
void JStage::TCamera::JSGGetViewUpVector(Vec*) const {}
/* 80280C68-80280C6C 27B5A8 0004+00 1/0 0/0 0/0 .text JSGSetViewUpVector__Q26JStage7TCameraFRC3Vec
*/
void JStage::TCamera::JSGSetViewUpVector(Vec const& param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetViewUpVector(Vec const&) {}
/* 80280C6C-80280C70 27B5AC 0004+00 1/0 0/0 0/0 .text
* JSGGetViewTargetPosition__Q26JStage7TCameraCFP3Vec */
void JStage::TCamera::JSGGetViewTargetPosition(Vec* param_0) const {
/* empty function */
}
void JStage::TCamera::JSGGetViewTargetPosition(Vec*) const {}
/* 80280C70-80280C74 27B5B0 0004+00 1/0 0/0 0/0 .text
* JSGSetViewTargetPosition__Q26JStage7TCameraFRC3Vec */
void JStage::TCamera::JSGSetViewTargetPosition(Vec const& param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetViewTargetPosition(Vec const&) {}
/* 80280C74-80280C7C 27B5B4 0008+00 1/0 0/0 0/0 .text JSGGetViewRoll__Q26JStage7TCameraCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TCamera::JSGGetViewRoll() const {
nofralloc
#include "asm/JSystem/JStage/JSGCamera/JSGGetViewRoll__Q26JStage7TCameraCFv.s"
f32 JStage::TCamera::JSGGetViewRoll() const {
return 0.0f;
}
#pragma pop
/* 80280C7C-80280C80 27B5BC 0004+00 1/0 0/0 0/0 .text JSGSetViewRoll__Q26JStage7TCameraFf
*/
void JStage::TCamera::JSGSetViewRoll(f32 param_0) {
/* empty function */
}
void JStage::TCamera::JSGSetViewRoll(f32) {}
libs/JSystem/JStage/JSGFog.cpp
+12 -167
View File
@@ -1,127 +1,8 @@
//
// Generated By: dol2asm
// Translation Unit: JSGFog
//
#include "JSystem/JStage/JSGFog.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXFogType {};
struct _GXColor {};
struct JStage {
struct TFog {
/* 80280C80 */ ~TFog();
/* 80280CE0 */ s32 JSGFGetType() const;
/* 80280CE8 */ bool JSGGetFogFunction() const;
/* 80280CF0 */ void JSGSetFogFunction(_GXFogType);
/* 80280CF4 */ void JSGGetStartZ() const;
/* 80280CFC */ void JSGSetStartZ(f32);
/* 80280D00 */ void JSGGetEndZ() const;
/* 80280D0C */ void JSGSetEndZ(f32);
/* 80280D10 */ void JSGGetColor() const;
/* 80280D24 */ void JSGSetColor(_GXColor);
};
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage4TFogFv();
extern "C" s32 JSGFGetType__Q26JStage4TFogCFv();
extern "C" bool JSGGetFogFunction__Q26JStage4TFogCFv();
extern "C" void JSGSetFogFunction__Q26JStage4TFogF10_GXFogType();
extern "C" void JSGGetStartZ__Q26JStage4TFogCFv();
extern "C" void JSGSetStartZ__Q26JStage4TFogFf();
extern "C" void JSGGetEndZ__Q26JStage4TFogCFv();
extern "C" void JSGSetEndZ__Q26JStage4TFogFf();
extern "C" void JSGGetColor__Q26JStage4TFogCFv();
extern "C" void JSGSetColor__Q26JStage4TFogF8_GXColor();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
extern "C" extern u32 __float_max;
//
// Declarations:
//
/* ############################################################################################## */
/* 803C4718-803C4778 021838 005C+04 1/1 1/1 0/0 .data __vt__Q26JStage4TFog */
SECTION_DATA extern void* __vt__Q26JStage4TFog[23 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage4TFogCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGGetFogFunction__Q26JStage4TFogCFv,
(void*)JSGSetFogFunction__Q26JStage4TFogF10_GXFogType,
(void*)JSGGetStartZ__Q26JStage4TFogCFv,
(void*)JSGSetStartZ__Q26JStage4TFogFf,
(void*)JSGGetEndZ__Q26JStage4TFogCFv,
(void*)JSGSetEndZ__Q26JStage4TFogFf,
(void*)JSGGetColor__Q26JStage4TFogCFv,
(void*)JSGSetColor__Q26JStage4TFogF8_GXColor,
/* padding */
NULL,
};
#include "MSL_C/math.h"
/* 80280C80-80280CE0 27B5C0 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage4TFogFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TFog::~TFog() {
nofralloc
#include "asm/JSystem/JStage/JSGFog/__dt__Q26JStage4TFogFv.s"
}
#pragma pop
JStage::TFog::~TFog() {}
/* 80280CE0-80280CE8 27B620 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage4TFogCFv */
s32 JStage::TFog::JSGFGetType() const {
@@ -135,64 +16,28 @@ bool JStage::TFog::JSGGetFogFunction() const {
/* 80280CF0-80280CF4 27B630 0004+00 1/0 0/0 0/0 .text
* JSGSetFogFunction__Q26JStage4TFogF10_GXFogType */
void JStage::TFog::JSGSetFogFunction(_GXFogType param_0) {
/* empty function */
}
/* ############################################################################################## */
/* 804553E0-804553E4 0039E0 0004+00 1/1 0/0 0/0 .sdata2 @319 */
SECTION_SDATA2 static u8 lit_319[4] = {
0x00,
0x00,
0x00,
0x00,
};
void JStage::TFog::JSGSetFogFunction(GXFogType) {}
/* 80280CF4-80280CFC 27B634 0008+00 1/0 1/0 0/0 .text JSGGetStartZ__Q26JStage4TFogCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TFog::JSGGetStartZ() const {
nofralloc
#include "asm/JSystem/JStage/JSGFog/JSGGetStartZ__Q26JStage4TFogCFv.s"
f32 JStage::TFog::JSGGetStartZ() const {
return 0.0f;
}
#pragma pop
/* 80280CFC-80280D00 27B63C 0004+00 1/0 0/0 0/0 .text JSGSetStartZ__Q26JStage4TFogFf */
void JStage::TFog::JSGSetStartZ(f32 param_0) {
/* empty function */
}
void JStage::TFog::JSGSetStartZ(f32) {}
/* 80280D00-80280D0C 27B640 000C+00 1/0 1/0 0/0 .text JSGGetEndZ__Q26JStage4TFogCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TFog::JSGGetEndZ() const {
nofralloc
#include "asm/JSystem/JStage/JSGFog/JSGGetEndZ__Q26JStage4TFogCFv.s"
f32 JStage::TFog::JSGGetEndZ() const {
return __float_max[0];
}
#pragma pop
/* 80280D0C-80280D10 27B64C 0004+00 1/0 0/0 0/0 .text JSGSetEndZ__Q26JStage4TFogFf */
void JStage::TFog::JSGSetEndZ(f32 param_0) {
/* empty function */
}
/* ############################################################################################## */
/* 804553E4-804553E8 0039E4 0004+00 1/1 0/0 0/0 .sdata2 @336 */
SECTION_SDATA2 static u32 lit_336 = 0xFFFFFFFF;
void JStage::TFog::JSGSetEndZ(f32) {}
/* 80280D10-80280D24 27B650 0014+00 1/0 1/0 0/0 .text JSGGetColor__Q26JStage4TFogCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TFog::JSGGetColor() const {
nofralloc
#include "asm/JSystem/JStage/JSGFog/JSGGetColor__Q26JStage4TFogCFv.s"
GXColor JStage::TFog::JSGGetColor() const {
return (GXColor){255, 255, 255, 255};
}
#pragma pop
/* 80280D24-80280D28 27B664 0004+00 1/0 0/0 0/0 .text JSGSetColor__Q26JStage4TFogF8_GXColor */
void JStage::TFog::JSGSetColor(_GXColor param_0) {
/* empty function */
}
void JStage::TFog::JSGSetColor(GXColor) {}
libs/JSystem/JStage/JSGLight.cpp
+13 -184
View File
@@ -1,144 +1,7 @@
//
// Generated By: dol2asm
// Translation Unit: JSGLight
//
#include "JSystem/JStage/JSGLight.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXSpotFn {};
struct _GXDistAttnFn {};
struct _GXColor {};
struct Vec {};
struct JStage {
struct TELight {};
struct TLight {
/* 80280D28 */ ~TLight();
/* 80280D88 */ s32 JSGFGetType() const;
/* 80280D90 */ bool JSGGetLightType() const;
/* 80280D98 */ void JSGSetLightType(JStage::TELight);
/* 80280D9C */ void JSGGetColor() const;
/* 80280DB0 */ void JSGSetColor(_GXColor);
/* 80280DB4 */ void JSGGetDistanceAttenuation(f32*, f32*, _GXDistAttnFn*) const;
/* 80280DB8 */ void JSGSetDistanceAttenuation(f32, f32, _GXDistAttnFn);
/* 80280DBC */ void JSGGetAngleAttenuation(f32*, _GXSpotFn*) const;
/* 80280DC0 */ void JSGSetAngleAttenuation(f32, _GXSpotFn);
/* 80280DC4 */ void JSGGetPosition(Vec*) const;
/* 80280DC8 */ void JSGSetPosition(Vec const&);
/* 80280DCC */ void JSGGetDirection(Vec*) const;
/* 80280DD0 */ void JSGSetDirection(Vec const&);
};
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage6TLightFv();
extern "C" s32 JSGFGetType__Q26JStage6TLightCFv();
extern "C" bool JSGGetLightType__Q26JStage6TLightCFv();
extern "C" void JSGSetLightType__Q26JStage6TLightFQ26JStage7TELight();
extern "C" void JSGGetColor__Q26JStage6TLightCFv();
extern "C" void JSGSetColor__Q26JStage6TLightF8_GXColor();
extern "C" void JSGGetDistanceAttenuation__Q26JStage6TLightCFPfPfP13_GXDistAttnFn();
extern "C" void JSGSetDistanceAttenuation__Q26JStage6TLightFff13_GXDistAttnFn();
extern "C" void JSGGetAngleAttenuation__Q26JStage6TLightCFPfP9_GXSpotFn();
extern "C" void JSGSetAngleAttenuation__Q26JStage6TLightFf9_GXSpotFn();
extern "C" void JSGGetPosition__Q26JStage6TLightCFP3Vec();
extern "C" void JSGSetPosition__Q26JStage6TLightFRC3Vec();
extern "C" void JSGGetDirection__Q26JStage6TLightCFP3Vec();
extern "C" void JSGSetDirection__Q26JStage6TLightFRC3Vec();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 803C4778-803C47E8 021898 006C+04 1/1 1/1 0/0 .data __vt__Q26JStage6TLight */
SECTION_DATA extern void* __vt__Q26JStage6TLight[27 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage6TLightCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGGetLightType__Q26JStage6TLightCFv,
(void*)JSGSetLightType__Q26JStage6TLightFQ26JStage7TELight,
(void*)JSGGetPosition__Q26JStage6TLightCFP3Vec,
(void*)JSGSetPosition__Q26JStage6TLightFRC3Vec,
(void*)JSGGetColor__Q26JStage6TLightCFv,
(void*)JSGSetColor__Q26JStage6TLightF8_GXColor,
(void*)JSGGetDistanceAttenuation__Q26JStage6TLightCFPfPfP13_GXDistAttnFn,
(void*)JSGSetDistanceAttenuation__Q26JStage6TLightFff13_GXDistAttnFn,
(void*)JSGGetAngleAttenuation__Q26JStage6TLightCFPfP9_GXSpotFn,
(void*)JSGSetAngleAttenuation__Q26JStage6TLightFf9_GXSpotFn,
(void*)JSGGetDirection__Q26JStage6TLightCFP3Vec,
(void*)JSGSetDirection__Q26JStage6TLightFRC3Vec,
/* padding */
NULL,
};
/* 80280D28-80280D88 27B668 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage6TLightFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TLight::~TLight() {
nofralloc
#include "asm/JSystem/JStage/JSGLight/__dt__Q26JStage6TLightFv.s"
}
#pragma pop
JStage::TLight::~TLight() {}
/* 80280D88-80280D90 27B6C8 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage6TLightCFv */
s32 JStage::TLight::JSGFGetType() const {
@@ -152,74 +15,40 @@ bool JStage::TLight::JSGGetLightType() const {
/* 80280D98-80280D9C 27B6D8 0004+00 1/0 0/0 0/0 .text
* JSGSetLightType__Q26JStage6TLightFQ26JStage7TELight */
void JStage::TLight::JSGSetLightType(JStage::TELight param_0) {
/* empty function */
}
/* ############################################################################################## */
/* 804553E8-804553F0 0039E8 0004+04 1/1 0/0 0/0 .sdata2 @311 */
SECTION_SDATA2 static u32 lit_311[1 + 1 /* padding */] = {
0xFFFFFFFF,
/* padding */
0x00000000,
};
void JStage::TLight::JSGSetLightType(JStage::TELight) {}
/* 80280D9C-80280DB0 27B6DC 0014+00 1/0 1/0 0/0 .text JSGGetColor__Q26JStage6TLightCFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TLight::JSGGetColor() const {
nofralloc
#include "asm/JSystem/JStage/JSGLight/JSGGetColor__Q26JStage6TLightCFv.s"
GXColor JStage::TLight::JSGGetColor() const {
return (GXColor){255, 255, 255, 255};
}
#pragma pop
/* 80280DB0-80280DB4 27B6F0 0004+00 1/0 0/0 0/0 .text JSGSetColor__Q26JStage6TLightF8_GXColor */
void JStage::TLight::JSGSetColor(_GXColor param_0) {
/* empty function */
}
void JStage::TLight::JSGSetColor(GXColor) {}
/* 80280DB4-80280DB8 27B6F4 0004+00 1/0 1/0 0/0 .text
* JSGGetDistanceAttenuation__Q26JStage6TLightCFPfPfP13_GXDistAttnFn */
void JStage::TLight::JSGGetDistanceAttenuation(f32* param_0, f32* param_1,
_GXDistAttnFn* param_2) const {
/* empty function */
}
void JStage::TLight::JSGGetDistanceAttenuation(f32*, f32*, GXDistAttnFn*) const {}
/* 80280DB8-80280DBC 27B6F8 0004+00 1/0 0/0 0/0 .text
* JSGSetDistanceAttenuation__Q26JStage6TLightFff13_GXDistAttnFn */
void JStage::TLight::JSGSetDistanceAttenuation(f32 param_0, f32 param_1, _GXDistAttnFn param_2) {
/* empty function */
}
void JStage::TLight::JSGSetDistanceAttenuation(f32, f32, GXDistAttnFn) {}
/* 80280DBC-80280DC0 27B6FC 0004+00 1/0 1/0 0/0 .text
* JSGGetAngleAttenuation__Q26JStage6TLightCFPfP9_GXSpotFn */
void JStage::TLight::JSGGetAngleAttenuation(f32* param_0, _GXSpotFn* param_1) const {
/* empty function */
}
void JStage::TLight::JSGGetAngleAttenuation(f32*, GXSpotFn*) const {}
/* 80280DC0-80280DC4 27B700 0004+00 1/0 0/0 0/0 .text
* JSGSetAngleAttenuation__Q26JStage6TLightFf9_GXSpotFn */
void JStage::TLight::JSGSetAngleAttenuation(f32 param_0, _GXSpotFn param_1) {
/* empty function */
}
void JStage::TLight::JSGSetAngleAttenuation(f32, GXSpotFn) {}
/* 80280DC4-80280DC8 27B704 0004+00 1/0 1/0 0/0 .text JSGGetPosition__Q26JStage6TLightCFP3Vec */
void JStage::TLight::JSGGetPosition(Vec* param_0) const {
/* empty function */
}
void JStage::TLight::JSGGetPosition(Vec*) const {}
/* 80280DC8-80280DCC 27B708 0004+00 1/0 0/0 0/0 .text JSGSetPosition__Q26JStage6TLightFRC3Vec */
void JStage::TLight::JSGSetPosition(Vec const& param_0) {
/* empty function */
}
void JStage::TLight::JSGSetPosition(Vec const&) {}
/* 80280DCC-80280DD0 27B70C 0004+00 1/0 1/0 0/0 .text JSGGetDirection__Q26JStage6TLightCFP3Vec */
void JStage::TLight::JSGGetDirection(Vec* param_0) const {
/* empty function */
}
void JStage::TLight::JSGGetDirection(Vec*) const {}
/* 80280DD0-80280DD4 27B710 0004+00 1/0 0/0 0/0 .text JSGSetDirection__Q26JStage6TLightFRC3Vec */
void JStage::TLight::JSGSetDirection(Vec const& param_0) {
/* empty function */
}
void JStage::TLight::JSGSetDirection(Vec const&) {}
libs/JSystem/JStage/JSGObject.cpp
+24 -120
View File
@@ -1,102 +1,17 @@
//
// Generated By: dol2asm
// Translation Unit: JSGObject
//
#include "JSystem/JStage/JSGObject.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JStage {
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
//
// External References:
//
extern "C" void __dl__FPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 803C47E8-803C4828 021908 003C+04 1/1 6/6 0/0 .data __vt__Q26JStage7TObject */
SECTION_DATA extern void* __vt__Q26JStage7TObject[15 + 1 /* padding */] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)NULL,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
/* padding */
NULL,
};
/* 80280DD4-80280E1C 27B714 0048+00 0/0 6/6 0/0 .text __dt__Q26JStage7TObjectFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TObject::~TObject() {
nofralloc
#include "asm/JSystem/JStage/JSGObject/__dt__Q26JStage7TObjectFv.s"
}
#pragma pop
JStage::TObject::~TObject() {}
/* 80280E1C-80280E24 27B75C 0008+00 1/0 12/0 0/0 .text JSGGetName__Q26JStage7TObjectCFv
*/
bool JStage::TObject::JSGGetName() const {
return false;
}
/* 80280E24-80280E28 27B764 0004+00 1/0 12/0 0/0 .text JSGUpdate__Q26JStage7TObjectFv */
void JStage::TObject::JSGUpdate() {
/* empty function */
}
void JStage::TObject::JSGUpdate() {}
/* 80280E28-80280E30 27B768 0008+00 1/0 12/0 0/0 .text JSGGetFlag__Q26JStage7TObjectCFv
*/
@@ -106,58 +21,47 @@ bool JStage::TObject::JSGGetFlag() const {
/* 80280E30-80280E34 27B770 0004+00 1/0 12/0 0/0 .text JSGSetFlag__Q26JStage7TObjectFUl
*/
void JStage::TObject::JSGSetFlag(u32 param_0) {
/* empty function */
}
void JStage::TObject::JSGSetFlag(u32) {}
/* 80280E34-80280E3C 27B774 0008+00 1/0 12/0 0/0 .text JSGGetData__Q26JStage7TObjectCFUlPvUl */
bool JStage::TObject::JSGGetData(u32 param_0, void* param_1, u32 param_2) const {
bool JStage::TObject::JSGGetData(u32, void*, u32) const {
return false;
}
/* 80280E3C-80280E40 27B77C 0004+00 1/0 11/0 0/0 .text JSGSetData__Q26JStage7TObjectFUlPCvUl */
void JStage::TObject::JSGSetData(u32 param_0, void const* param_1, u32 param_2) {
/* empty function */
}
void JStage::TObject::JSGSetData(u32, void const*, u32) {}
/* 80280E40-80280E44 27B780 0004+00 1/0 12/0 0/0 .text
* JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl */
void JStage::TObject::JSGGetParent(JStage::TObject** param_0, u32* param_1) const {
/* empty function */
}
void JStage::TObject::JSGGetParent(JStage::TObject**, u32*) const {}
/* 80280E44-80280E48 27B784 0004+00 1/0 12/0 0/0 .text
* JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl */
void JStage::TObject::JSGSetParent(JStage::TObject* param_0, u32 param_1) {
/* empty function */
}
void JStage::TObject::JSGSetParent(JStage::TObject*, u32) {}
/* 80280E48-80280E4C 27B788 0004+00 1/0 12/0 0/0 .text
* JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl */
void JStage::TObject::JSGSetRelation(bool param_0, JStage::TObject* param_1, u32 param_2) {
/* empty function */
}
void JStage::TObject::JSGSetRelation(bool, JStage::TObject*, u32) {}
/* 80280E4C-80280E54 27B78C 0008+00 1/0 11/0 0/0 .text JSGFindNodeID__Q26JStage7TObjectCFPCc */
s32 JStage::TObject::JSGFindNodeID(char const* param_0) const {
s32 JStage::TObject::JSGFindNodeID(char const*) const {
return -1;
}
/* ############################################################################################## */
/* 804553F0-804553F8 0039F0 0004+04 1/1 0/0 0/0 .sdata2 @338 */
SECTION_SDATA2 static f32 lit_338[1 + 1 /* padding */] = {
0.0f,
/* padding */
0.0f,
};
/* 80280E54-80280E90 27B794 003C+00 1/0 11/0 0/0 .text
* JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStage::TObject::JSGGetNodeTransformation(u32 param_0, f32 (*param_1)[4]) const {
nofralloc
#include "asm/JSystem/JStage/JSGObject/JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f.s"
int JStage::TObject::JSGGetNodeTransformation(u32, MtxP mtx) const {
mtx[0][0] = 0.0f;
mtx[0][1] = 0.0f;
mtx[0][2] = 0.0f;
mtx[0][3] = 0.0f;
mtx[1][0] = 0.0f;
mtx[1][1] = 0.0f;
mtx[1][2] = 0.0f;
mtx[1][3] = 0.0f;
mtx[2][0] = 0.0f;
mtx[2][1] = 0.0f;
mtx[2][2] = 0.0f;
mtx[2][3] = 0.0f;
return 0;
}
#pragma pop
libs/JSystem/JStage/JSGSystem.cpp
+8 -119
View File
@@ -1,145 +1,34 @@
//
// Generated By: dol2asm
// Translation Unit: JSGSystem
//
#include "JSystem/JStage/JSGSystem.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct JStage {
struct TObject {
/* 80280DD4 */ ~TObject();
/* 80280E1C */ bool JSGGetName() const;
/* 80280E24 */ void JSGUpdate();
/* 80280E28 */ bool JSGGetFlag() const;
/* 80280E30 */ void JSGSetFlag(u32);
/* 80280E34 */ bool JSGGetData(u32, void*, u32) const;
/* 80280E3C */ void JSGSetData(u32, void const*, u32);
/* 80280E40 */ void JSGGetParent(JStage::TObject**, u32*) const;
/* 80280E44 */ void JSGSetParent(JStage::TObject*, u32);
/* 80280E48 */ void JSGSetRelation(bool, JStage::TObject*, u32);
/* 80280E4C */ s32 JSGFindNodeID(char const*) const;
/* 80280E54 */ void JSGGetNodeTransformation(u32, f32 (*)[4]) const;
};
struct TEObject {};
struct TSystem {
/* 80280E90 */ ~TSystem();
/* 80280EF0 */ bool JSGFGetType() const;
/* 80280EF8 */ bool JSGFindObject(JStage::TObject**, char const*, JStage::TEObject) const;
/* 80280F00 */ bool JSGCreateObject(char const*, JStage::TEObject, u32);
/* 80280F08 */ void JSGDestroyObject(JStage::TObject*);
/* 80280F0C */ bool JSGGetSystemData(u32);
/* 80280F14 */ void JSGSetSystemData(u32, u32);
};
};
//
// Forward References:
//
extern "C" void __dt__Q26JStage7TSystemFv();
extern "C" bool JSGFGetType__Q26JStage7TSystemCFv();
extern "C" bool JSGFindObject__Q26JStage7TSystemCFPPQ26JStage7TObjectPCcQ26JStage8TEObject();
extern "C" bool JSGCreateObject__Q26JStage7TSystemFPCcQ26JStage8TEObjectUl();
extern "C" void JSGDestroyObject__Q26JStage7TSystemFPQ26JStage7TObject();
extern "C" bool JSGGetSystemData__Q26JStage7TSystemFUl();
extern "C" void JSGSetSystemData__Q26JStage7TSystemFUlUl();
//
// External References:
//
extern "C" void __dt__Q26JStage7TObjectFv();
extern "C" bool JSGGetName__Q26JStage7TObjectCFv();
extern "C" void JSGUpdate__Q26JStage7TObjectFv();
extern "C" bool JSGGetFlag__Q26JStage7TObjectCFv();
extern "C" void JSGSetFlag__Q26JStage7TObjectFUl();
extern "C" bool JSGGetData__Q26JStage7TObjectCFUlPvUl();
extern "C" void JSGSetData__Q26JStage7TObjectFUlPCvUl();
extern "C" void JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl();
extern "C" void JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl();
extern "C" void JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl();
extern "C" s32 JSGFindNodeID__Q26JStage7TObjectCFPCc();
extern "C" void JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f();
extern "C" void __dl__FPv();
//
// Declarations:
//
/* ############################################################################################## */
/* 803C4828-803C4878 021948 0050+00 1/1 1/1 0/0 .data __vt__Q26JStage7TSystem */
SECTION_DATA extern void* __vt__Q26JStage7TSystem[20] = {
(void*)NULL /* RTTI */,
(void*)NULL,
(void*)NULL,
(void*)JSGFGetType__Q26JStage7TSystemCFv,
(void*)JSGGetName__Q26JStage7TObjectCFv,
(void*)JSGUpdate__Q26JStage7TObjectFv,
(void*)JSGGetFlag__Q26JStage7TObjectCFv,
(void*)JSGSetFlag__Q26JStage7TObjectFUl,
(void*)JSGGetData__Q26JStage7TObjectCFUlPvUl,
(void*)JSGSetData__Q26JStage7TObjectFUlPCvUl,
(void*)JSGGetParent__Q26JStage7TObjectCFPPQ26JStage7TObjectPUl,
(void*)JSGSetParent__Q26JStage7TObjectFPQ26JStage7TObjectUl,
(void*)JSGSetRelation__Q26JStage7TObjectFbPQ26JStage7TObjectUl,
(void*)JSGFindNodeID__Q26JStage7TObjectCFPCc,
(void*)JSGGetNodeTransformation__Q26JStage7TObjectCFUlPA4_f,
(void*)JSGFindObject__Q26JStage7TSystemCFPPQ26JStage7TObjectPCcQ26JStage8TEObject,
(void*)JSGCreateObject__Q26JStage7TSystemFPCcQ26JStage8TEObjectUl,
(void*)JSGDestroyObject__Q26JStage7TSystemFPQ26JStage7TObject,
(void*)JSGGetSystemData__Q26JStage7TSystemFUl,
(void*)JSGSetSystemData__Q26JStage7TSystemFUlUl,
};
/* 80280E90-80280EF0 27B7D0 0060+00 0/0 1/1 0/0 .text __dt__Q26JStage7TSystemFv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStage::TSystem::~TSystem() {
nofralloc
#include "asm/JSystem/JStage/JSGSystem/__dt__Q26JStage7TSystemFv.s"
}
#pragma pop
JStage::TSystem::~TSystem() {}
/* 80280EF0-80280EF8 27B830 0008+00 1/0 1/0 0/0 .text JSGFGetType__Q26JStage7TSystemCFv
*/
bool JStage::TSystem::JSGFGetType() const {
return true;
s32 JStage::TSystem::JSGFGetType() const {
return 1;
}
/* 80280EF8-80280F00 27B838 0008+00 1/0 0/0 0/0 .text
* JSGFindObject__Q26JStage7TSystemCFPPQ26JStage7TObjectPCcQ26JStage8TEObject */
bool JStage::TSystem::JSGFindObject(JStage::TObject** param_0, char const* param_1,
JStage::TEObject param_2) const {
bool JStage::TSystem::JSGFindObject(JStage::TObject**, char const*, JStage::TEObject) const {
return true;
}
/* 80280F00-80280F08 27B840 0008+00 1/0 1/0 0/0 .text
* JSGCreateObject__Q26JStage7TSystemFPCcQ26JStage8TEObjectUl */
bool JStage::TSystem::JSGCreateObject(char const* param_0, JStage::TEObject param_1, u32 param_2) {
bool JStage::TSystem::JSGCreateObject(char const*, JStage::TEObject, u32) {
return false;
}
/* 80280F08-80280F0C 27B848 0004+00 1/0 1/0 0/0 .text
* JSGDestroyObject__Q26JStage7TSystemFPQ26JStage7TObject */
void JStage::TSystem::JSGDestroyObject(JStage::TObject* param_0) {
/* empty function */
}
void JStage::TSystem::JSGDestroyObject(JStage::TObject*) {}
/* 80280F0C-80280F14 27B84C 0008+00 1/0 1/0 0/0 .text JSGGetSystemData__Q26JStage7TSystemFUl */
bool JStage::TSystem::JSGGetSystemData(u32 param_0) {
bool JStage::TSystem::JSGGetSystemData(u32) {
return false;
}
/* 80280F14-80280F18 27B854 0004+00 1/0 1/0 0/0 .text JSGSetSystemData__Q26JStage7TSystemFUlUl */
void JStage::TSystem::JSGSetSystemData(u32 param_0, u32 param_1) {
/* empty function */
}
void JStage::TSystem::JSGSetSystemData(u32, u32) {}
libs/JSystem/JStudio/JStudio/ctb-data.cpp
+2 -39
View File
@@ -1,45 +1,8 @@
//
// Generated By: dol2asm
// Translation Unit: ctb-data
//
#include "JSystem/JStudio/JStudio/ctb-data.h"
#include "JSystem/JStudio/JStudio/ctb.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
namespace JStudio {
namespace ctb {
struct data {
static u32 ga4cSignature[1 + 1 /* padding */];
};
}; // namespace ctb
}; // namespace JStudio
//
// Forward References:
//
extern "C" u32 ga4cSignature__Q37JStudio3ctb4data[1 + 1 /* padding */];
//
// External References:
//
//
// Declarations:
//
/* ############################################################################################## */
/* 804553F8-80455400 0039F8 0004+04 0/0 1/1 0/0 .sdata2 ga4cSignature__Q37JStudio3ctb4data
*/
SECTION_SDATA2 u32 JStudio::ctb::data::ga4cSignature[1 + 1 /* padding */] = {
0x43544200,
/* padding */
0x00000000,
};
SECTION_SDATA2 u32 JStudio::ctb::data::ga4cSignature = 'CTB\0';
libs/JSystem/JStudio/JStudio/ctb.cpp
+14 -74
View File
@@ -4,7 +4,6 @@
//
#include "JSystem/JStudio/JStudio/ctb.h"
#include "JSystem/JGadget/binary.h"
#include "dol2asm.h"
#include "dolphin/types.h"
@@ -12,76 +11,13 @@
// Types:
//
namespace JStudio {
namespace ctb {
struct TObject {
/* 80280F18 */ ~TObject();
};
struct data {
struct TParse_TBlock {};
static u32 ga4cSignature[1 + 1 /* padding */];
};
struct TObject_TxyzRy {
/* 80280F60 */ TObject_TxyzRy(JStudio::ctb::data::TParse_TBlock const&);
/* 80280FBC */ bool getScheme() const;
/* 80281554 */ ~TObject_TxyzRy();
};
struct TControl {
/* 80280FC4 */ TControl();
/* 80280FF4 */ ~TControl();
/* 80281060 */ void appendObject(JStudio::ctb::TObject*);
/* 802810AC */ void removeObject(JStudio::ctb::TObject*);
/* 802810DC */ void destroyObject(JStudio::ctb::TObject*);
/* 8028112C */ void destroyObject_all();
/* 80281190 */ void getObject(void const*, u32);
/* 80281230 */ void getObject_index(u32);
};
struct TFactory {
/* 80281274 */ ~TFactory();
/* 802812BC */ void create(JStudio::ctb::data::TParse_TBlock const&);
/* 80281320 */ void destroy(JStudio::ctb::TObject*);
};
struct TParse {
/* 8028135C */ TParse(JStudio::ctb::TControl*);
/* 8028137C */ ~TParse();
/* 802813DC */ void parseHeader_next(void const**, u32*, u32);
/* 80281470 */ void parseBlock_next(void const**, u32*, u32);
};
}; // namespace ctb
namespace object {
struct TPRObject_ID_equal {};
struct TIDData {
/* 80288988 */ void isEqual(JStudio::object::TIDData const&, JStudio::object::TIDData const&);
};
}; // namespace object
}; // namespace JStudio
namespace JGadget {
template <typename A1, typename B1>
struct TLinkList {};
/* TLinkList<JStudio::ctb::TObject, 12> */
struct TLinkList__template0 {
struct iterator {};
};
}; // namespace JGadget
namespace std {
template <typename A1, typename B1>
void find_if(/* ... */);
/* 802815B4 */ /* std::find_if<JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator,
JStudio::object::TPRObject_ID_equal> */
void func_802815B4(void* _this, JGadget::TLinkList__template0::iterator,
JGadget::TLinkList__template0::iterator, JStudio::object::TPRObject_ID_equal);
void func_802815B4(void* _this, JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator,
JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator, JStudio::object::TPRObject_ID_equal);
}; // namespace std
//
@@ -107,8 +43,8 @@ extern "C" void __dt__Q37JStudio3ctb6TParseFv();
extern "C" void parseHeader_next__Q37JStudio3ctb6TParseFPPCvPUlUl();
extern "C" void parseBlock_next__Q37JStudio3ctb6TParseFPPCvPUlUl();
extern "C" void __dt__Q37JStudio3ctb14TObject_TxyzRyFv();
extern "C" void func_802815B4(void* _this, JGadget::TLinkList__template0::iterator,
JGadget::TLinkList__template0::iterator,
extern "C" void func_802815B4(void* _this, JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator,
JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator,
JStudio::object::TPRObject_ID_equal);
//
@@ -222,7 +158,8 @@ asm JStudio::ctb::TControl::TControl() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::ctb::TControl::~TControl() {
// asm JStudio::ctb::TControl::~TControl() {
extern "C" asm void __dt__Q37JStudio3ctb8TControlFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/ctb/__dt__Q37JStudio3ctb8TControlFv.s"
}
@@ -297,7 +234,8 @@ asm void JStudio::ctb::TControl::getObject_index(u32 param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::ctb::TFactory::~TFactory() {
// asm JStudio::ctb::TFactory::~TFactory() {
extern "C" asm void __dt__Q37JStudio3ctb8TFactoryFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/ctb/__dt__Q37JStudio3ctb8TFactoryFv.s"
}
@@ -340,7 +278,8 @@ asm JStudio::ctb::TParse::TParse(JStudio::ctb::TControl* param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::ctb::TParse::~TParse() {
// asm JStudio::ctb::TParse::~TParse() {
extern "C" asm void __dt__Q37JStudio3ctb6TParseFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/ctb/__dt__Q37JStudio3ctb6TParseFv.s"
}
@@ -372,7 +311,8 @@ asm void JStudio::ctb::TParse::parseBlock_next(void const** param_0, u32* param_
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::ctb::TObject_TxyzRy::~TObject_TxyzRy() {
// asm JStudio::ctb::TObject_TxyzRy::~TObject_TxyzRy() {
extern "C" asm void __dt__Q37JStudio3ctb14TObject_TxyzRyFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/ctb/__dt__Q37JStudio3ctb14TObject_TxyzRyFv.s"
}
@@ -384,8 +324,8 @@ asm JStudio::ctb::TObject_TxyzRy::~TObject_TxyzRy() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
extern "C" asm void func_802815B4(void* _this, JGadget::TLinkList__template0::iterator param_0,
JGadget::TLinkList__template0::iterator param_1,
extern "C" asm void func_802815B4(void* _this, JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator param_0,
JGadget::TLinkList<JStudio::ctb::TObject, 12>::iterator param_1,
JStudio::object::TPRObject_ID_equal param_2) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/ctb/func_802815B4.s"
libs/JSystem/JStudio/JStudio/fvb-data.cpp
+4 -7
View File
@@ -1,7 +1,4 @@
namespace JStudio {
namespace fvb {
namespace data {
extern const char ga4cSignature[] = "FVB";
} // namespace data
} // namespace fvb
} // namespace JStudio
#include "JSystem/JStudio/JStudio/fvb-data.h"
extern const char JStudio::fvb::data::ga4cSignature[4] = "FVB";
libs/JSystem/JStudio/JStudio/jstudio-control.cpp
+5 -71
View File
@@ -4,74 +4,10 @@
//
#include "JSystem/JStudio/JStudio/jstudio-control.h"
#include "JSystem/JGadget/binary.h"
#include "JSystem/JStudio/JStudio/fvb.h"
#include "JSystem/JStudio/JStudio/stb.h"
#include "JSystem/JStudio/JStudio/jstudio-data.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
namespace JStudio {
struct TCreateObject {
/* 80285488 */ ~TCreateObject();
};
struct TFactory {
/* 802854D0 */ ~TFactory();
/* 80285560 */ void appendCreateObject(JStudio::TCreateObject*);
/* 802855AC */ void create(JStudio::stb::data::TParse_TBlock_object const&);
};
namespace ctb {
struct TObject {};
struct TControl {
/* 80280FC4 */ TControl();
/* 80280FF4 */ ~TControl();
/* 80281230 */ void getObject_index(u32);
};
struct TFactory {
/* 80281274 */ ~TFactory();
};
struct TParse {
/* 8028135C */ TParse(JStudio::ctb::TControl*);
/* 8028137C */ ~TParse();
};
}; // namespace ctb
struct TControl {
/* 80285114 */ TControl();
/* 802851AC */ ~TControl();
/* 80285228 */ void setFactory(JStudio::TFactory*);
/* 80285250 */ void transformOnSet_setOrigin_TxyzRy(Vec const&, f32);
/* 802852D0 */ void transformOnGet_setOrigin_TxyzRy(Vec const&, f32);
/* 80285368 */ void transform_setOrigin_ctb(JStudio::ctb::TObject const&);
/* 8028543C */ void transform_setOrigin_ctb_index(u32);
};
struct TParse {
/* 8028566C */ TParse(JStudio::TControl*);
/* 802856A8 */ ~TParse();
/* 80285708 */ void parseHeader(JStudio::stb::data::TParse_THeader const&, u32);
/* 802857E4 */ void parseBlock_block(JStudio::stb::data::TParse_TBlock const&, u32);
/* 80285844 */ void parseBlock_block_fvb_(JStudio::stb::data::TParse_TBlock const&, u32);
/* 802858F0 */ void parseBlock_block_ctb_(JStudio::stb::data::TParse_TBlock const&, u32);
};
struct data {
static u8 ga8cSignature[8];
};
}; // namespace JStudio
//
// Forward References:
//
@@ -125,10 +61,6 @@ extern "C" void parse_next__Q37JGadget6binary19TParse_header_blockFPPCvUl();
extern "C" void __dt__Q27JGadget13TNodeLinkListFv();
extern "C" void
Insert__Q27JGadget13TNodeLinkListFQ37JGadget13TNodeLinkList8iteratorPQ27JGadget13TLinkListNode();
extern "C" void PSMTXConcat();
extern "C" void PSMTXRotRad();
extern "C" void PSMTXTrans();
extern "C" void PSMTXTransApply();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_28();
@@ -285,7 +217,8 @@ asm JStudio::TCreateObject::~TCreateObject() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TFactory::~TFactory() {
// asm JStudio::TFactory::~TFactory() {
extern "C" asm void __dt__Q27JStudio8TFactoryFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-control/__dt__Q27JStudio8TFactoryFv.s"
}
@@ -328,7 +261,8 @@ asm JStudio::TParse::TParse(JStudio::TControl* param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TParse::~TParse() {
// asm JStudio::TParse::~TParse() {
extern "C" asm void __dt__Q27JStudio6TParseFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-control/__dt__Q27JStudio6TParseFv.s"
}
libs/JSystem/JStudio/JStudio/jstudio-data.cpp
+3 -5
View File
@@ -1,5 +1,3 @@
namespace JStudio {
namespace data {
extern const char ga8cSignature[] = "jstudio";
} // namespace data
} // namespace JStudio
#include "JSystem/JStudio/JStudio/jstudio-data.h"
extern const char JStudio::data::ga8cSignature[8] = "jstudio";
libs/JSystem/JStudio/JStudio/jstudio-math.cpp
+3 -22
View File
@@ -7,21 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
namespace JStudio {
struct math {
/* 802859DC */ void getRotation_xyz(f32 (*)[4], f32, f32, f32);
/* 80285B44 */ void getTransformation_SRxyzT(f32 (*)[4], Vec const&, Vec const&, Vec const&);
/* 80285BCC */ void getFromTransformation_SRxyzT(Vec*, Vec*, Vec*, f32 const (*)[4]);
};
}; // namespace JStudio
//
// Forward References:
//
@@ -34,10 +19,6 @@ extern "C" void getFromTransformation_SRxyzT__Q27JStudio4mathFP3VecP3VecP3VecPA4
// External References:
//
extern "C" void PSMTXConcat();
extern "C" void PSMTXTransApply();
extern "C" void PSMTXScale();
extern "C" void PSVECMag();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_28();
@@ -68,7 +49,7 @@ SECTION_SDATA2 static u8 lit_489[4] = {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::math::getRotation_xyz(f32 (*param_0)[4], f32 param_1, f32 param_2, f32 param_3) {
asm void JStudio::math::getRotation_xyz(MtxP param_0, f32 param_1, f32 param_2, f32 param_3) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-math/getRotation_xyz__Q27JStudio4mathFPA4_ffff.s"
}
@@ -79,7 +60,7 @@ asm void JStudio::math::getRotation_xyz(f32 (*param_0)[4], f32 param_1, f32 para
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::math::getTransformation_SRxyzT(f32 (*param_0)[4], Vec const& param_1,
asm void JStudio::math::getTransformation_SRxyzT(MtxP param_0, Vec const& param_1,
Vec const& param_2, Vec const& param_3) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-math/getTransformation_SRxyzT__Q27JStudio4mathFPA4_fRC3VecRC3VecRC3Vec.s"
@@ -117,7 +98,7 @@ SECTION_SDATA2 static f64 lit_628 = 57.29577951308232;
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::math::getFromTransformation_SRxyzT(Vec* param_0, Vec* param_1, Vec* param_2,
f32 const (*param_3)[4]) {
CMtxP param_3) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-math/getFromTransformation_SRxyzT__Q27JStudio4mathFP3VecP3VecP3VecPA4_Cf.s"
}
libs/JSystem/JStudio/JStudio/jstudio-object.cpp
+22 -211
View File
@@ -4,208 +4,9 @@
//
#include "JSystem/JStudio/JStudio/jstudio-object.h"
#include "JSystem/JStudio/JStudio/fvb.h"
#include "JSystem/JStudio/JStudio/stb.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXColor {};
struct Vec {};
namespace JStudio {
struct TControl {};
struct data {
struct TEOperationData {};
};
struct TAdaptor {
struct TSetVariableValue_immediate {};
/* 80285FD0 */ ~TAdaptor();
/* 80286018 */ void adaptor_do_prepare();
/* 8028601C */ void adaptor_do_begin();
/* 80286020 */ void adaptor_do_end();
/* 80286024 */ void adaptor_do_update(u32);
/* 80286028 */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 8028602C */ void adaptor_setVariableValue(JStudio::TControl*, u32,
JStudio::data::TEOperationData, void const*, u32);
/* 802860CC */ void adaptor_setVariableValue_n(JStudio::TControl*, u32 const*, u32,
JStudio::data::TEOperationData, void const*,
u32);
/* 802861C0 */ void
adaptor_setVariableValue_immediate(JStudio::TAdaptor::TSetVariableValue_immediate const*);
/* 80286204 */ void adaptor_setVariableValue_Vec(u32 const*, Vec const&);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
/* 802862AC */ void adaptor_setVariableValue_GXColor(u32 const*, _GXColor const&);
/* 8028638C */ void adaptor_getVariableValue_GXColor(_GXColor*, u32 const*) const;
/* 802864D8 */ void adaptor_updateVariableValue(JStudio::TControl*, u32);
/* 8028656C */ void adaptor_setVariableValue_VOID_(JStudio::TAdaptor*, JStudio::TControl*, u32,
void const*, u32);
/* 80286584 */ void adaptor_setVariableValue_IMMEDIATE_(JStudio::TAdaptor*, JStudio::TControl*,
u32, void const*, u32);
/* 802865B0 */ void adaptor_setVariableValue_TIME_(JStudio::TAdaptor*, JStudio::TControl*, u32,
void const*, u32);
/* 802865DC */ void adaptor_setVariableValue_FVR_NAME_(JStudio::TAdaptor*, JStudio::TControl*,
u32, void const*, u32);
/* 80286648 */ void adaptor_setVariableValue_FVR_INDEX_(JStudio::TAdaptor*, JStudio::TControl*,
u32, void const*, u32);
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
struct TOutput_none_ {
/* 80285F6C */ ~TOutput_none_();
/* 80285FCC */ void operator()(f32, JStudio::TAdaptor*) const;
};
/* 80285E54 */ void update(f64, JStudio::TAdaptor*);
/* 80285EB8 */ void update_immediate_(JStudio::TVariableValue*, f64);
/* 80285ECC */ void update_time_(JStudio::TVariableValue*, f64);
/* 80285F08 */ void update_functionValue_(JStudio::TVariableValue*, f64);
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TObject {
/* 802866B0 */ ~TObject();
/* 80286734 */ void forward_value(u32);
/* 8028679C */ void do_begin();
/* 802867D4 */ void do_end();
/* 8028680C */ void do_wait(u32);
/* 8028682C */ void do_data(void const*, u32, void const*, u32);
/* 80286864 */ TObject(JStudio::stb::data::TParse_TBlock_object const&, JStudio::TAdaptor*);
};
struct TAdaptor_actor {
/* 802868B0 */ ~TAdaptor_actor();
static u8 const sauVariableValue_3_TRANSLATION_XYZ[12];
static u8 const sauVariableValue_3_ROTATION_XYZ[12];
static u8 const sauVariableValue_3_SCALING_XYZ[12];
};
struct TObject_actor {
/* 80286910 */ TObject_actor(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_actor*);
/* 8028694C */ void do_paragraph(u32, void const*, u32);
/* 802881A4 */ ~TObject_actor();
};
struct TAdaptor_ambientLight {
/* 80286C9C */ ~TAdaptor_ambientLight();
static u8 const sauVariableValue_3_COLOR_RGB[12];
static u8 const sauVariableValue_4_COLOR_RGBA[16];
};
struct TObject_ambientLight {
/* 80286CFC */ TObject_ambientLight(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_ambientLight*);
/* 80286D38 */ void do_paragraph(u32, void const*, u32);
/* 80288144 */ ~TObject_ambientLight();
};
struct TAdaptor_camera {
/* 80286E1C */ ~TAdaptor_camera();
static u8 const sauVariableValue_3_POSITION_XYZ[12];
static u8 const sauVariableValue_3_TARGET_POSITION_XYZ[12];
static u8 sauVariableValue_2_DISTANCE_NEAR_FAR[8];
};
struct TObject_camera {
/* 80286E7C */ TObject_camera(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_camera*);
/* 80286EB8 */ void do_paragraph(u32, void const*, u32);
/* 802880E4 */ ~TObject_camera();
};
struct TAdaptor_fog {
/* 8028717C */ ~TAdaptor_fog();
static u8 const sauVariableValue_3_COLOR_RGB[12];
static u8 const sauVariableValue_4_COLOR_RGBA[16];
static u8 sauVariableValue_2_RANGE_BEGIN_END[8];
};
struct TObject_fog {
/* 802871DC */ TObject_fog(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_fog*);
/* 80287218 */ void do_paragraph(u32, void const*, u32);
/* 80288084 */ ~TObject_fog();
};
struct TAdaptor_light {
/* 80287308 */ ~TAdaptor_light();
static u8 const sauVariableValue_3_COLOR_RGB[12];
static u8 const sauVariableValue_4_COLOR_RGBA[16];
static u8 const sauVariableValue_3_POSITION_XYZ[12];
static u8 const sauVariableValue_3_TARGET_POSITION_XYZ[12];
static u8 sauVariableValue_2_DIRECTION_THETA_PHI[8];
};
struct TObject_light {
/* 80287368 */ TObject_light(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_light*);
/* 802873A4 */ void do_paragraph(u32, void const*, u32);
/* 80288024 */ ~TObject_light();
};
struct TAdaptor_message {
/* 802875E0 */ ~TAdaptor_message();
};
struct TObject_message {
/* 80287640 */ TObject_message(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_message*);
/* 8028767C */ void do_paragraph(u32, void const*, u32);
/* 80287FC4 */ ~TObject_message();
};
struct TAdaptor_particle {
/* 8028770C */ ~TAdaptor_particle();
static u8 const sauVariableValue_3_TRANSLATION_XYZ[12];
static u8 const sauVariableValue_3_ROTATION_XYZ[12];
static u8 const sauVariableValue_3_SCALING_XYZ[12];
static u8 const sauVariableValue_3_COLOR_RGB[12];
static u8 const sauVariableValue_4_COLOR_RGBA[16];
static u8 const sauVariableValue_3_COLOR1_RGB[12];
static u8 const sauVariableValue_4_COLOR1_RGBA[16];
};
struct TObject_particle {
/* 8028776C */ TObject_particle(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_particle*);
/* 802877A8 */ void do_paragraph(u32, void const*, u32);
/* 80287F64 */ ~TObject_particle();
};
struct TAdaptor_sound {
/* 80287B3C */ ~TAdaptor_sound();
static u8 const sauVariableValue_3_POSITION_XYZ[12];
};
struct TObject_sound {
/* 80287B9C */ TObject_sound(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_sound*);
/* 80287BD8 */ void do_paragraph(u32, void const*, u32);
/* 80287F04 */ ~TObject_sound();
};
}; // namespace JStudio
//
// Forward References:
//
@@ -1596,7 +1397,8 @@ asm JStudio::TAdaptor::~TAdaptor() {
#pragma pop
/* 80286018-8028601C 280958 0004+00 8/0 2/0 0/0 .text adaptor_do_prepare__Q27JStudio8TAdaptorFv */
void JStudio::TAdaptor::adaptor_do_prepare() {
// void JStudio::TAdaptor::adaptor_do_prepare() {
extern "C" void adaptor_do_prepare__Q27JStudio8TAdaptorFv() {
/* empty function */
}
@@ -1692,7 +1494,7 @@ asm void JStudio::TAdaptor::adaptor_getVariableValue_Vec(Vec* param_0, u32 const
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::TAdaptor::adaptor_setVariableValue_GXColor(u32 const* param_0,
_GXColor const& param_1) {
GXColor const& param_1) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/adaptor_setVariableValue_GXColor__Q27JStudio8TAdaptorFPCUlRC8_GXColor.s"
}
@@ -1715,7 +1517,7 @@ SECTION_SDATA2 static f32 lit_1095 = 255.0f;
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::TAdaptor::adaptor_getVariableValue_GXColor(_GXColor* param_0,
asm void JStudio::TAdaptor::adaptor_getVariableValue_GXColor(GXColor* param_0,
u32 const* param_1) const {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/adaptor_getVariableValue_GXColor__Q27JStudio8TAdaptorCFP8_GXColorPCUl.s"
@@ -1830,7 +1632,8 @@ asm void JStudio::TObject::forward_value(u32 param_0) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JStudio::TObject::do_begin() {
// asm void JStudio::TObject::do_begin() {
extern "C" asm void do_begin__Q27JStudio7TObjectFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/do_begin__Q27JStudio7TObjectFv.s"
}
@@ -2396,7 +2199,8 @@ asm void JStudio::TObject_sound::do_paragraph(u32 param_0, void const* param_1,
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_sound::~TObject_sound() {
// asm JStudio::TObject_sound::~TObject_sound() {
extern "C" asm void __dt__Q27JStudio13TObject_soundFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio13TObject_soundFv.s"
}
@@ -2406,7 +2210,8 @@ asm JStudio::TObject_sound::~TObject_sound() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_particle::~TObject_particle() {
// asm JStudio::TObject_particle::~TObject_particle() {
extern "C" asm void __dt__Q27JStudio16TObject_particleFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio16TObject_particleFv.s"
}
@@ -2417,7 +2222,8 @@ asm JStudio::TObject_particle::~TObject_particle() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_message::~TObject_message() {
// asm JStudio::TObject_message::~TObject_message() {
extern "C" asm void __dt__Q27JStudio15TObject_messageFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio15TObject_messageFv.s"
}
@@ -2428,7 +2234,8 @@ asm JStudio::TObject_message::~TObject_message() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_light::~TObject_light() {
// asm JStudio::TObject_light::~TObject_light() {
extern "C" asm void __dt__Q27JStudio13TObject_lightFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio13TObject_lightFv.s"
}
@@ -2438,7 +2245,8 @@ asm JStudio::TObject_light::~TObject_light() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_fog::~TObject_fog() {
// asm JStudio::TObject_fog::~TObject_fog() {
extern "C" asm void __dt__Q27JStudio11TObject_fogFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio11TObject_fogFv.s"
}
@@ -2449,7 +2257,8 @@ asm JStudio::TObject_fog::~TObject_fog() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_camera::~TObject_camera() {
// asm JStudio::TObject_camera::~TObject_camera() {
extern "C" asm void __dt__Q27JStudio14TObject_cameraFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio14TObject_cameraFv.s"
}
@@ -2459,7 +2268,8 @@ asm JStudio::TObject_camera::~TObject_camera() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_ambientLight::~TObject_ambientLight() {
// asm JStudio::TObject_ambientLight::~TObject_ambientLight() {
extern "C" asm void __dt__Q27JStudio20TObject_ambientLightFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio20TObject_ambientLightFv.s"
}
@@ -2470,7 +2280,8 @@ asm JStudio::TObject_ambientLight::~TObject_ambientLight() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio::TObject_actor::~TObject_actor() {
// asm JStudio::TObject_actor::~TObject_actor() {
extern "C" asm void __dt__Q27JStudio13TObject_actorFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio/jstudio-object/__dt__Q27JStudio13TObject_actorFv.s"
}
libs/JSystem/JStudio/JStudio/object-id.cpp
-8
View File
@@ -7,10 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
//
// Forward References:
//
@@ -18,10 +14,6 @@
extern "C" void
isEqual__Q37JStudio6object7TIDDataFRCQ37JStudio6object7TIDDataRCQ37JStudio6object7TIDData();
//
// External References:
//
//
// Declarations:
//
libs/JSystem/JStudio/JStudio/stb-data.cpp
+5 -8
View File
@@ -1,9 +1,6 @@
#include "dolphin/types.h"
namespace JStudio {
namespace stb {
namespace data {
extern const s32 gauDataSize_TEParagraph_data[8] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40};
extern const char ga4cSignature[] = "STB";
} // namespace data
} // namespace stb
} // namespace JStudio
#include "JSystem/JStudio/JStudio/stb-data.h"
#include "dol2asm.h"
const s32 JStudio::stb::data::gauDataSize_TEParagraph_data[8] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40};
SECTION_SDATA2 u32 JStudio::stb::data::ga4cSignature = 'STB\0';
libs/JSystem/JStudio/JStudio/stb.cpp
+1 -1
View File
@@ -397,7 +397,7 @@ asm void TControl::reset() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TControl::forward(u32 param_0) {
asm u8 TControl::forward(u32 param_0) {
nofralloc
#include "asm/JSystem/JStudio/JStudio/stb/forward__Q37JStudio3stb8TControlFUl.s"
}
libs/JSystem/JStudio/JStudio_JAudio2/control.cpp
-41
View File
@@ -7,47 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
namespace JStudio {
struct TObject {};
namespace stb {
struct data {
struct TParse_TBlock_object {};
};
}; // namespace stb
struct TCreateObject {
/* 80285488 */ ~TCreateObject();
};
struct TAdaptor_sound {};
struct TObject_sound {
/* 80287B9C */ TObject_sound(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_sound*);
};
}; // namespace JStudio
struct JStudio_JAudio2 {
struct TCreateObject {
/* 8028D550 */ ~TCreateObject();
/* 8028D5B0 */ void create(JStudio::TObject**,
JStudio::stb::data::TParse_TBlock_object const&);
/* 8028D624 */ void createObject_JAI_SOUND_(JStudio::stb::data::TParse_TBlock_object const&,
JStudio_JAudio2::TCreateObject*);
};
struct TAdaptor_sound {
/* 8028D828 */ TAdaptor_sound(JStudio_JAudio2::TCreateObject*);
};
};
//
// Forward References:
//
libs/JSystem/JStudio/JStudio_JAudio2/object-sound.cpp
+1 -127
View File
@@ -6,132 +6,7 @@
#include "JSystem/JStudio/JStudio_JAudio2/object-sound.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
struct JStage {
struct TObject {};
};
namespace JStudio {
struct data {
struct TEOperationData {};
};
struct TAdaptor {
struct TSetVariableValue_immediate {};
/* 8028601C */ void adaptor_do_begin();
/* 80286028 */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 802861C0 */ void
adaptor_setVariableValue_immediate(JStudio::TAdaptor::TSetVariableValue_immediate const*);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
/* 8028B568 */ TVariableValue();
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TAdaptor_sound {
/* 80287B3C */ ~TAdaptor_sound();
static u8 const sauVariableValue_3_POSITION_XYZ[12];
};
struct TControl {
struct TTransform_position {};
};
}; // namespace JStudio
struct JStudio_JStage {
/* 8028A290 */ void transform_toGlobalFromLocal(f32 (*)[4],
JStudio::TControl::TTransform_position const&,
JStage::TObject const*, u32);
};
struct JStudio_JAudio2 {
struct TCreateObject {};
struct TAdaptor_sound {
struct TVVOSetValue_ {
/* 8028DECC */ void operator()(f32, JStudio::TAdaptor*) const;
/* 8028E094 */ ~TVVOSetValue_();
};
/* 8028D828 */ TAdaptor_sound(JStudio_JAudio2::TCreateObject*);
/* 8028D8F4 */ ~TAdaptor_sound();
/* 8028D9A4 */ void adaptor_do_prepare();
/* 8028DA74 */ void adaptor_do_end();
/* 8028DA78 */ void adaptor_do_update(u32);
/* 8028DC20 */ void adaptor_do_SOUND(JStudio::data::TEOperationData, void const*, u32);
/* 8028DC54 */ void adaptor_do_BEGIN(JStudio::data::TEOperationData, void const*, u32);
/* 8028DC88 */ void adaptor_do_BEGIN_FADE_IN(JStudio::data::TEOperationData, void const*,
u32);
/* 8028DCD0 */ void adaptor_do_END(JStudio::data::TEOperationData, void const*, u32);
/* 8028DD00 */ void adaptor_do_END_FADE_OUT(JStudio::data::TEOperationData, void const*,
u32);
/* 8028DD48 */ void adaptor_do_PARENT(JStudio::data::TEOperationData, void const*, u32);
/* 8028DDB4 */ void adaptor_do_PARENT_NODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028DE34 */ void adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028DE50 */ void adaptor_do_REPEAT(JStudio::data::TEOperationData, void const*, u32);
/* 8028DE6C */ void adaptor_do_CONTINUOUS(JStudio::data::TEOperationData, void const*, u32);
/* 8028DE88 */ void adaptor_do_LOCATED(JStudio::data::TEOperationData, void const*, u32);
/* 8028DEB0 */ void adaptor_do_ON_EXIT_NOT_END(JStudio::data::TEOperationData, void const*,
u32);
/* 8028DF04 */ void prepareSound_();
/* 8028DFA4 */ void beginSound_fadeIn_();
/* 8028E054 */ void endSound_fadeOut_(u32);
static u8 saoVVOSetValue_[72];
};
};
struct JGeometry {
template <typename A1>
struct TVec3 {};
/* TVec3<f32> */
struct TVec3__template0 {};
};
struct JAISoundStatus_ {
/* 802A2220 */ void lockWhenPrepared();
/* 802A2244 */ void unlockIfLocked();
};
struct JAISoundID {};
struct JAISoundHandle {
/* 802A2184 */ void releaseSound();
};
struct JAISoundStarter {
/* 802A2FEC */ void startLevelSound(JAISoundID, JAISoundHandle*, JGeometry::TVec3<f32> const*);
};
struct JAISoundParamsMove {
/* 802A2DB4 */ void moveVolume(f32, u32);
/* 802A2E0C */ void movePitch(f32, u32);
/* 802A2E64 */ void moveFxMix(f32, u32);
/* 802A2EBC */ void movePan(f32, u32);
};
struct JAISound {
/* 802A2598 */ void stop();
/* 802A24DC */ void stop(u32);
};
#include "JSystem/JStudio/JStudio_JAudio2/control.h"
//
// Forward References:
@@ -204,7 +79,6 @@ extern "C" void moveFxMix__18JAISoundParamsMoveFfUl();
extern "C" void movePan__18JAISoundParamsMoveFfUl();
extern "C" void func_802A2FEC();
extern "C" void __dl__FPv();
extern "C" void PSMTXMultVec();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void __cvt_fp2unsigned();
libs/JSystem/JStudio/JStudio_JParticle/control.cpp
-57
View File
@@ -4,66 +4,9 @@
//
#include "JSystem/JStudio/JStudio_JParticle/control.h"
#include "JSystem/JStudio/JStudio/stb.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
namespace JStudio {
struct TObject {};
struct TCreateObject {
/* 80285488 */ ~TCreateObject();
};
struct TAdaptor_particle {};
struct TObject_particle {
/* 8028776C */ TObject_particle(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_particle*);
};
}; // namespace JStudio
struct JPABaseEmitter {};
struct JStudio_JParticle {
struct TCreateObject {
/* 8028E3A0 */ ~TCreateObject();
/* 8028E400 */ void create(JStudio::TObject**,
JStudio::stb::data::TParse_TBlock_object const&);
/* 8028E474 */ void emitter_create(u32);
/* 8028E4E4 */ void emitter_destroy(JPABaseEmitter*);
/* 8028E508 */ void
createObject_JPA_PARTICLE_(JStudio::stb::data::TParse_TBlock_object const&,
JStudio_JParticle::TCreateObject*);
};
struct TAdaptor_particle {
/* 8028E60C */ TAdaptor_particle(JStudio_JParticle::TCreateObject*);
};
};
struct JPAParticleCallBack {};
struct JPAEmitterCallBack {};
struct JGeometry {
template <typename A1>
struct TVec3 {};
/* TVec3<f32> */
struct TVec3__template0 {};
};
struct JPAEmitterManager {
/* 8027DEBC */ void createSimpleEmitterID(JGeometry::TVec3<f32> const&, u16, u8, u8,
JPAEmitterCallBack*, JPAParticleCallBack*);
/* 8027E2D8 */ void forceDeleteEmitter(JPABaseEmitter*);
};
//
// Forward References:
//
libs/JSystem/JStudio/JStudio_JParticle/object-particle.cpp
-96
View File
@@ -11,107 +11,12 @@
// Types:
//
struct _GXColor {};
struct Vec {};
struct JStage {
struct TObject {};
};
namespace JStudio {
struct data {
struct TEOperationData {};
};
struct TAdaptor {
struct TSetVariableValue_immediate {};
/* 8028601C */ void adaptor_do_begin();
/* 80286028 */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 802861C0 */ void
adaptor_setVariableValue_immediate(JStudio::TAdaptor::TSetVariableValue_immediate const*);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
/* 8028638C */ void adaptor_getVariableValue_GXColor(_GXColor*, u32 const*) const;
};
struct TAdaptor_particle {
/* 8028770C */ ~TAdaptor_particle();
static u8 const sauVariableValue_3_TRANSLATION_XYZ[12];
static u8 const sauVariableValue_3_ROTATION_XYZ[12];
static u8 const sauVariableValue_3_SCALING_XYZ[12];
static u8 const sauVariableValue_4_COLOR_RGBA[16];
};
struct TControl {
struct TTransform_translation_rotation_scaling {};
};
struct TVariableValue {
/* 8028B568 */ TVariableValue();
};
}; // namespace JStudio
struct JStudio_JStage {
/* 8028A1F8 */ void transform_toGlobalFromLocal(
f32 (*)[4], JStudio::TControl::TTransform_translation_rotation_scaling const&,
JStage::TObject const*, u32);
};
struct JPABaseEmitter {};
struct JStudio_JParticle {
struct TCreateObject {};
struct TAdaptor_particle {
struct TJPACallback_emitter_ {
/* 8028E700 */ ~TJPACallback_emitter_();
/* 8028ECC0 */ void execute(JPABaseEmitter*);
/* 8028F060 */ void executeAfter(JPABaseEmitter*);
/* 8028F098 */ void draw(JPABaseEmitter*);
/* 8028F0D0 */ void drawAfter(JPABaseEmitter*);
};
/* 8028E60C */ TAdaptor_particle(JStudio_JParticle::TCreateObject*);
/* 8028E760 */ ~TAdaptor_particle();
/* 8028E850 */ void adaptor_do_prepare();
/* 8028E97C */ void adaptor_do_end();
/* 8028E980 */ void adaptor_do_update(u32);
/* 8028EA68 */ void adaptor_do_PARTICLE(JStudio::data::TEOperationData, void const*, u32);
/* 8028EA7C */ void adaptor_do_BEGIN(JStudio::data::TEOperationData, void const*, u32);
/* 8028EAB0 */ void adaptor_do_BEGIN_FADE_IN(JStudio::data::TEOperationData, void const*,
u32);
/* 8028EAF8 */ void adaptor_do_END(JStudio::data::TEOperationData, void const*, u32);
/* 8028EB24 */ void adaptor_do_END_FADE_OUT(JStudio::data::TEOperationData, void const*,
u32);
/* 8028EB6C */ void adaptor_do_PARENT(JStudio::data::TEOperationData, void const*, u32);
/* 8028EBD8 */ void adaptor_do_PARENT_NODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028EC58 */ void adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028EC74 */ void adaptor_do_PARENT_FUNCTION(JStudio::data::TEOperationData, void const*,
u32);
/* 8028EC88 */ void adaptor_do_REPEAT(JStudio::data::TEOperationData, void const*, u32);
/* 8028ECA4 */ void adaptor_do_ON_EXIT_NOT_END(JStudio::data::TEOperationData, void const*,
u32);
/* 8028F108 */ void beginParticle_fadeIn_();
/* 8028F1C0 */ void endParticle_fadeOut_(u32);
};
};
struct JPAEmitterCallBack {
/* 8027E6A4 */ ~JPAEmitterCallBack();
};
struct JGeometry {
template <typename A1>
struct TVec3 {};
/* TVec3<f32> */
struct TVec3__template0 {};
};
//
// Forward References:
//
@@ -174,7 +79,6 @@ extern "C" void
transform_toGlobalFromLocal__14JStudio_JStageFPA4_fRCQ37JStudio8TControl39TTransform_translation_rotation_scalingPCQ26JStage7TObjectUl();
extern "C" void __ct__Q27JStudio14TVariableValueFv();
extern "C" void __dl__FPv();
extern "C" void PSMTXMultVec();
extern "C" void __construct_array();
extern "C" void __cvt_fp2unsigned();
extern "C" void _savegpr_28();
libs/JSystem/JStudio/JStudio_JStage/control.cpp
-97
View File
@@ -7,103 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
namespace JStudio {
struct TObject {};
namespace stb {
struct data {
struct TParse_TBlock_object {};
};
}; // namespace stb
struct TCreateObject {
/* 80285488 */ ~TCreateObject();
};
struct TAdaptor_actor {};
struct TObject_actor {
/* 80286910 */ TObject_actor(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_actor*);
};
struct TAdaptor_ambientLight {};
struct TObject_ambientLight {
/* 80286CFC */ TObject_ambientLight(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_ambientLight*);
};
struct TAdaptor_camera {};
struct TObject_camera {
/* 80286E7C */ TObject_camera(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_camera*);
};
struct TAdaptor_fog {};
struct TObject_fog {
/* 802871DC */ TObject_fog(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_fog*);
};
struct TAdaptor_light {};
struct TObject_light {
/* 80287368 */ TObject_light(JStudio::stb::data::TParse_TBlock_object const&,
JStudio::TAdaptor_light*);
};
}; // namespace JStudio
struct JStage {
struct TSystem {};
struct TActor {};
struct TAmbientLight {};
struct TCamera {};
struct TFog {};
struct TLight {};
};
struct JStudio_JStage {
struct TCreateObject {
/* 80289B00 */ ~TCreateObject();
/* 80289B60 */ void create(JStudio::TObject**,
JStudio::stb::data::TParse_TBlock_object const&);
};
struct TAdaptor_actor {
/* 8028A5F0 */ TAdaptor_actor(JStage::TSystem const*, JStage::TActor*);
};
struct TAdaptor_ambientLight {
/* 8028B610 */ TAdaptor_ambientLight(JStage::TSystem const*, JStage::TAmbientLight*);
};
struct TAdaptor_camera {
/* 8028B8A0 */ TAdaptor_camera(JStage::TSystem const*, JStage::TCamera*);
};
struct TAdaptor_fog {
/* 8028C574 */ TAdaptor_fog(JStage::TSystem const*, JStage::TFog*);
};
struct TAdaptor_light {
/* 8028CB50 */ TAdaptor_light(JStage::TSystem const*, JStage::TLight*);
};
};
//
// Forward References:
//
libs/JSystem/JStudio/JStudio_JStage/object-actor.cpp
+2 -124
View File
@@ -7,128 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
struct JStage {
struct TSystem {};
struct TActor {};
struct TObject {};
};
namespace JStudio {
struct data {
struct TEOperationData {};
};
struct TControl {
struct TTransform_translation_rotation_scaling {};
};
struct TAdaptor {
/* 80286204 */ void adaptor_setVariableValue_Vec(u32 const*, Vec const&);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
/* 80285EB8 */ void update_immediate_(JStudio::TVariableValue*, f64);
/* 8028B568 */ TVariableValue();
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TFunctionValue {
/* 80281648 */ void toFunction_outside(int);
};
struct math {
/* 80285BCC */ void getFromTransformation_SRxyzT(Vec*, Vec*, Vec*, f32 const (*)[4]);
};
struct TAdaptor_actor {
/* 802868B0 */ ~TAdaptor_actor();
static u8 const sauVariableValue_3_TRANSLATION_XYZ[12];
static u8 const sauVariableValue_3_ROTATION_XYZ[12];
static u8 const sauVariableValue_3_SCALING_XYZ[12];
};
}; // namespace JStudio
struct JStudio_JStage {
struct TAdaptor_actor {
struct TVVOutput_ANIMATION_FRAME_ {
/* 8028B064 */ void operator()(f32, JStudio::TAdaptor*) const;
/* 8028B138 */ ~TVVOutput_ANIMATION_FRAME_();
};
/* 8028A5F0 */ TAdaptor_actor(JStage::TSystem const*, JStage::TActor*);
/* 8028A6B4 */ ~TAdaptor_actor();
/* 8028A728 */ void adaptor_do_prepare();
/* 8028A7B4 */ void adaptor_do_begin();
/* 8028A8D8 */ void adaptor_do_end();
/* 8028A92C */ void adaptor_do_update(u32);
/* 8028A974 */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 8028A998 */ void adaptor_do_SHAPE(JStudio::data::TEOperationData, void const*, u32);
/* 8028A9F0 */ void adaptor_do_ANIMATION(JStudio::data::TEOperationData, void const*, u32);
/* 8028AA48 */ void adaptor_do_ANIMATION_MODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028AA5C */ void adaptor_do_TEXTURE_ANIMATION(JStudio::data::TEOperationData,
void const*, u32);
/* 8028AAB4 */ void adaptor_do_TEXTURE_ANIMATION_MODE(JStudio::data::TEOperationData,
void const*, u32);
/* 8028AAC8 */ void adaptor_do_PARENT(JStudio::data::TEOperationData, void const*, u32);
/* 8028AB0C */ void adaptor_do_PARENT_NODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028AB68 */ void adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028ABF0 */ void adaptor_do_PARENT_FUNCTION(JStudio::data::TEOperationData, void const*,
u32);
/* 8028AC04 */ void adaptor_do_RELATION(JStudio::data::TEOperationData, void const*, u32);
/* 8028AC48 */ void adaptor_do_RELATION_NODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028ACA4 */ void adaptor_do_RELATION_ENABLE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028ACFC */ void setJSG_ID_(void (JStage::TActor::*)(u32),
JStudio::data::TEOperationData, void const*, u32);
/* 8028AD38 */ void setJSG_SRT_(JStudio::TControl const*);
/* 8028AECC */ void getJSG_SRT_(JStudio::TControl const*);
static u8 saoVVOutput_[64];
static u8 saoVVOutput_ANIMATION_FRAME_[144 + 4 /* padding */];
};
template <typename A1, typename B1>
struct TVariableValueOutput_object_ {};
/* TVariableValueOutput_object_<JStudio_JStage::TAdaptor_actor, JStage::TActor> */
struct TVariableValueOutput_object___template0 {
/* 8028B580 */ void func_8028B580(void* _this);
/* 8028B5E0 */ void func_8028B5E0(void* _this, f32, JStudio::TAdaptor*) /* const */;
};
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
/* 8028A4BC */ void adaptor_object_findJSGObject_(char const*);
/* 8028A50C */ void adaptor_object_findJSGObjectNode_(JStage::TObject const*, char const*);
};
/* 8028A1F8 */ void transform_toGlobalFromLocal(
f32 (*)[4], JStudio::TControl::TTransform_translation_rotation_scaling const&,
JStage::TObject const*, u32);
/* 8028A328 */ void transform_toLocalFromGlobal(
f32 (*)[4], JStudio::TControl::TTransform_translation_rotation_scaling const&,
JStage::TObject const*, u32);
};
//
// Forward References:
//
@@ -199,7 +77,6 @@ extern "C" void adaptor_object_findJSGObject___Q214JStudio_JStage16TAdaptor_obje
extern "C" void
adaptor_object_findJSGObjectNode___Q214JStudio_JStage16TAdaptor_object_FPCQ26JStage7TObjectPCc();
extern "C" void __dl__FPv();
extern "C" void PSMTXMultVec();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void __ptmf_scall();
@@ -386,7 +263,8 @@ asm JStudio_JStage::TAdaptor_actor::TAdaptor_actor(JStage::TSystem const* param_
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio_JStage::TAdaptor_actor::~TAdaptor_actor() {
// asm JStudio_JStage::TAdaptor_actor::~TAdaptor_actor() {
extern "C" asm void __dt__Q214JStudio_JStage14TAdaptor_actorFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio_JStage/object-actor/__dt__Q214JStudio_JStage14TAdaptor_actorFv.s"
}
libs/JSystem/JStudio/JStudio_JStage/object-ambientlight.cpp
-46
View File
@@ -7,52 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXColor {};
struct JStage {
struct TSystem {};
struct TAmbientLight {};
};
struct JStudio_JStage {
struct TAdaptor_ambientLight {
/* 8028B610 */ TAdaptor_ambientLight(JStage::TSystem const*, JStage::TAmbientLight*);
/* 8028B6AC */ ~TAdaptor_ambientLight();
/* 8028B720 */ void adaptor_do_prepare();
/* 8028B724 */ void adaptor_do_begin();
/* 8028B7B0 */ void adaptor_do_end();
/* 8028B804 */ void adaptor_do_update(u32);
/* 8028B87C */ void adaptor_do_data(void const*, u32, void const*, u32);
};
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
};
};
namespace JStudio {
struct TAdaptor {
/* 802862AC */ void adaptor_setVariableValue_GXColor(u32 const*, _GXColor const&);
/* 8028638C */ void adaptor_getVariableValue_GXColor(_GXColor*, u32 const*) const;
};
struct TAdaptor_ambientLight {
/* 80286C9C */ ~TAdaptor_ambientLight();
static u8 const sauVariableValue_4_COLOR_RGBA[16];
};
struct TVariableValue {
/* 8028B568 */ TVariableValue();
};
}; // namespace JStudio
//
// Forward References:
//
libs/JSystem/JStudio/JStudio_JStage/object-camera.cpp
+2 -102
View File
@@ -7,106 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
namespace JStudio {
struct data {
struct TEOperationData {};
};
struct TControl {
struct TTransform_position {};
};
struct TAdaptor {
/* 80286204 */ void adaptor_setVariableValue_Vec(u32 const*, Vec const&);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
/* 80285EB8 */ void update_immediate_(JStudio::TVariableValue*, f64);
/* 8028B568 */ TVariableValue();
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TAdaptor_camera {
/* 80286E1C */ ~TAdaptor_camera();
static u8 const sauVariableValue_3_POSITION_XYZ[12];
static u8 const sauVariableValue_3_TARGET_POSITION_XYZ[12];
};
}; // namespace JStudio
struct JStage {
struct TSystem {};
struct TCamera {};
struct TObject {};
};
struct JStudio_JStage {
struct TAdaptor_camera {
/* 8028B8A0 */ TAdaptor_camera(JStage::TSystem const*, JStage::TCamera*);
/* 8028B960 */ ~TAdaptor_camera();
/* 8028B9D4 */ void adaptor_do_prepare();
/* 8028BA1C */ void adaptor_do_begin();
/* 8028BAF8 */ void adaptor_do_end();
/* 8028BB4C */ void adaptor_do_update(u32);
/* 8028BBAC */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 8028BBD0 */ void adaptor_do_PARENT(JStudio::data::TEOperationData, void const*, u32);
/* 8028BC14 */ void adaptor_do_PARENT_NODE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028BC70 */ void adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData, void const*,
u32);
/* 8028BCEC */ void adaptor_do_PARENT_FUNCTION(JStudio::data::TEOperationData, void const*,
u32);
/* 8028BD00 */ void adaptor_do_TARGET_PARENT(JStudio::data::TEOperationData, void const*,
u32);
/* 8028BD44 */ void adaptor_do_TARGET_PARENT_NODE(JStudio::data::TEOperationData,
void const*, u32);
/* 8028BDA0 */ void adaptor_do_TARGET_PARENT_ENABLE(JStudio::data::TEOperationData,
void const*, u32);
/* 8028BDBC */ void setJSG_position_(JStudio::TControl const*);
/* 8028BEB8 */ void getJSG_position_(JStudio::TControl const*);
/* 8028BFBC */ void setJSG_targetPosition_(JStudio::TControl const*);
/* 8028C09C */ void getJSG_targetPosition_(JStudio::TControl const*);
static u8 saoVVOutput_[160 + 4 /* padding */];
};
template <typename A1, typename B1>
struct TVariableValueOutput_object_ {};
/* TVariableValueOutput_object_<JStudio_JStage::TAdaptor_camera, JStage::TCamera> */
struct TVariableValueOutput_object___template1 {
/* 8028C4E4 */ void func_8028C4E4(void* _this);
/* 8028C544 */ void func_8028C544(void* _this, f32, JStudio::TAdaptor*) /* const */;
};
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
/* 8028A4BC */ void adaptor_object_findJSGObject_(char const*);
/* 8028A50C */ void adaptor_object_findJSGObjectNode_(JStage::TObject const*, char const*);
};
/* 8028A290 */ void transform_toGlobalFromLocal(f32 (*)[4],
JStudio::TControl::TTransform_position const&,
JStage::TObject const*, u32);
/* 8028A3CC */ void transform_toLocalFromGlobal(f32 (*)[4],
JStudio::TControl::TTransform_position const&,
JStage::TObject const*, u32);
};
//
// Forward References:
//
@@ -160,7 +60,6 @@ extern "C" void
adaptor_object_findJSGObjectNode___Q214JStudio_JStage16TAdaptor_object_FPCQ26JStage7TObjectPCc();
extern "C" void __ct__Q27JStudio14TVariableValueFv();
extern "C" void __dl__FPv();
extern "C" void PSMTXMultVec();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void __ptmf_scall();
@@ -301,7 +200,8 @@ asm JStudio_JStage::TAdaptor_camera::TAdaptor_camera(JStage::TSystem const* para
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio_JStage::TAdaptor_camera::~TAdaptor_camera() {
// asm JStudio_JStage::TAdaptor_camera::~TAdaptor_camera() {
extern "C" asm void __dt__Q214JStudio_JStage15TAdaptor_cameraFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio_JStage/object-camera/__dt__Q214JStudio_JStage15TAdaptor_cameraFv.s"
}
libs/JSystem/JStudio/JStudio_JStage/object-fog.cpp
+2 -64
View File
@@ -7,69 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXColor {};
struct JStage {
struct TSystem {};
struct TFog {};
};
namespace JStudio {
struct TAdaptor {
/* 802862AC */ void adaptor_setVariableValue_GXColor(u32 const*, _GXColor const&);
/* 8028638C */ void adaptor_getVariableValue_GXColor(_GXColor*, u32 const*) const;
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
/* 80285EB8 */ void update_immediate_(JStudio::TVariableValue*, f64);
/* 8028B568 */ TVariableValue();
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TAdaptor_fog {
/* 8028717C */ ~TAdaptor_fog();
static u8 const sauVariableValue_4_COLOR_RGBA[16];
};
}; // namespace JStudio
struct JStudio_JStage {
struct TAdaptor_fog {
/* 8028C574 */ TAdaptor_fog(JStage::TSystem const*, JStage::TFog*);
/* 8028C610 */ ~TAdaptor_fog();
/* 8028C684 */ void adaptor_do_prepare();
/* 8028C6CC */ void adaptor_do_begin();
/* 8028C7B4 */ void adaptor_do_end();
/* 8028C808 */ void adaptor_do_update(u32);
/* 8028C880 */ void adaptor_do_data(void const*, u32, void const*, u32);
static u8 saoVVOutput_[96 + 4 /* padding */];
};
template <typename A1, typename B1>
struct TVariableValueOutput_object_ {};
/* TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog> */
struct TVariableValueOutput_object___template2 {
/* 8028CAC0 */ void func_8028CAC0(void* _this);
/* 8028CB20 */ void func_8028CB20(void* _this, f32, JStudio::TAdaptor*) /* const */;
};
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
};
};
//
// Forward References:
//
@@ -183,7 +120,8 @@ asm JStudio_JStage::TAdaptor_fog::TAdaptor_fog(JStage::TSystem const* param_0,
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JStudio_JStage::TAdaptor_fog::~TAdaptor_fog() {
// asm JStudio_JStage::TAdaptor_fog::~TAdaptor_fog() {
extern "C" asm void __dt__Q214JStudio_JStage12TAdaptor_fogFv() {
nofralloc
#include "asm/JSystem/JStudio/JStudio_JStage/object-fog/__dt__Q214JStudio_JStage12TAdaptor_fogFv.s"
}
libs/JSystem/JStudio/JStudio_JStage/object-light.cpp
-78
View File
@@ -7,80 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXColor {};
struct Vec {};
struct JStage {
struct TSystem {};
struct TLight {};
};
namespace JStudio {
struct data {
struct TEOperationData {};
};
struct TAdaptor {
/* 80286204 */ void adaptor_setVariableValue_Vec(u32 const*, Vec const&);
/* 80286274 */ void adaptor_getVariableValue_Vec(Vec*, u32 const*) const;
/* 802862AC */ void adaptor_setVariableValue_GXColor(u32 const*, _GXColor const&);
/* 8028638C */ void adaptor_getVariableValue_GXColor(_GXColor*, u32 const*) const;
};
struct TVariableValue {
struct TOutput {
/* 80285E0C */ ~TOutput();
};
/* 80285EB8 */ void update_immediate_(JStudio::TVariableValue*, f64);
/* 8028B568 */ TVariableValue();
static u8 soOutput_none_[4 + 4 /* padding */];
};
struct TAdaptor_light {
/* 80287308 */ ~TAdaptor_light();
static u8 const sauVariableValue_4_COLOR_RGBA[16];
static u8 const sauVariableValue_3_POSITION_XYZ[12];
static u8 const sauVariableValue_3_TARGET_POSITION_XYZ[12];
};
}; // namespace JStudio
struct JStudio_JStage {
struct TAdaptor_light {
struct TVVOutput_direction_ {
/* 8028D24C */ void operator()(f32, JStudio::TAdaptor*) const;
/* 8028D258 */ ~TVVOutput_direction_();
};
/* 8028CB50 */ TAdaptor_light(JStage::TSystem const*, JStage::TLight*);
/* 8028CBF4 */ ~TAdaptor_light();
/* 8028CC68 */ void adaptor_do_prepare();
/* 8028CCB0 */ void adaptor_do_begin();
/* 8028CF68 */ void adaptor_do_end();
/* 8028CFBC */ void adaptor_do_update(u32);
/* 8028D18C */ void adaptor_do_data(void const*, u32, void const*, u32);
/* 8028D1B0 */ void adaptor_do_FACULTY(JStudio::data::TEOperationData, void const*, u32);
/* 8028D228 */ void adaptor_do_ENABLE(JStudio::data::TEOperationData, void const*, u32);
static u8 saoVVOutput_direction_[72];
};
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
/* 8028A550 */ void adaptor_object_ENABLE_(JStudio::data::TEOperationData, void const*,
u32);
};
};
//
// Forward References:
//
@@ -118,10 +44,6 @@ extern "C" void
adaptor_object_ENABLE___Q214JStudio_JStage16TAdaptor_object_FQ37JStudio4data15TEOperationDataPCvUl();
extern "C" void __ct__Q27JStudio14TVariableValueFv();
extern "C" void __dl__FPv();
extern "C" void PSMTXMultVec();
extern "C" void PSMTXMultVecSR();
extern "C" void PSVECAdd();
extern "C" void PSVECSubtract();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void _savegpr_29();
libs/JSystem/JStudio/JStudio_JStage/object.cpp
-53
View File
@@ -7,56 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct Vec {};
struct JStage {
struct TObject {};
};
namespace JStudio {
struct TControl {
struct TTransform_translation_rotation_scaling {};
struct TTransform_position {};
};
struct data {
struct TEOperationData {};
};
struct math {
/* 80285B44 */ void getTransformation_SRxyzT(f32 (*)[4], Vec const&, Vec const&, Vec const&);
};
}; // namespace JStudio
struct JStudio_JStage {
struct TAdaptor_object_ {
/* 8028A470 */ void adaptor_object_data_(void const*, u32, void const*, u32);
/* 8028A4BC */ void adaptor_object_findJSGObject_(char const*);
/* 8028A50C */ void adaptor_object_findJSGObjectNode_(JStage::TObject const*, char const*);
/* 8028A550 */ void adaptor_object_ENABLE_(JStudio::data::TEOperationData, void const*,
u32);
};
/* 8028A1F8 */ void transform_toGlobalFromLocal(
f32 (*)[4], JStudio::TControl::TTransform_translation_rotation_scaling const&,
JStage::TObject const*, u32);
/* 8028A290 */ void transform_toGlobalFromLocal(f32 (*)[4],
JStudio::TControl::TTransform_position const&,
JStage::TObject const*, u32);
/* 8028A328 */ void transform_toLocalFromGlobal(
f32 (*)[4], JStudio::TControl::TTransform_translation_rotation_scaling const&,
JStage::TObject const*, u32);
/* 8028A3CC */ void transform_toLocalFromGlobal(f32 (*)[4],
JStudio::TControl::TTransform_position const&,
JStage::TObject const*, u32);
};
//
// Forward References:
//
@@ -81,9 +31,6 @@ adaptor_object_ENABLE___Q214JStudio_JStage16TAdaptor_object_FQ37JStudio4data15TE
//
extern "C" void getTransformation_SRxyzT__Q27JStudio4mathFPA4_fRC3VecRC3VecRC3Vec();
extern "C" void PSMTXConcat();
extern "C" void PSMTXInverse();
extern "C" void PSMTXTrans();
//
// Declarations:
libs/JSystem/JUtility/JUTCacheFont.cpp
+1 -1
View File
@@ -443,7 +443,7 @@ asm u16 JUTResFont::getFontType() const {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm u16 JUTResFont::getLeading() const {
asm int JUTResFont::getLeading() const {
nofralloc
#include "asm/JSystem/JUtility/JUTCacheFont/getLeading__10JUTResFontCFv.s"
}
libs/JSystem/JUtility/JUTConsole.cpp
+37 -61
View File
@@ -4,10 +4,10 @@
//
#include "JSystem/JUtility/JUTConsole.h"
#include "JSystem/J2DGraph/J2DOrthoGraph.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JUtility/JUTDirectPrint.h"
#include "JSystem/JUtility/JUTVideo.h"
#include "JSystem/J2DGraph/J2DOrthoGraph.h"
#include "MSL_C/MSL_Common/Src/printf.h"
#include "dol2asm.h"
#include "dolphin/types.h"
@@ -171,58 +171,25 @@ void JUTConsole::clear() {
*getLinePtr(0) = 0;
}
/* ############################################################################################## */
/* 80456118-8045611C 004718 0004+00 1/1 0/0 0/0 .sdata2 @2460 */
SECTION_SDATA2 static f32 lit_2460 = 2.0f;
/* 8045611C-80456120 00471C 0004+00 1/1 0/0 0/0 .sdata2 @2461 */
SECTION_SDATA2 static u8 lit_2461[4] = {
0x00,
0x00,
0x00,
0x00,
};
/* 80456120-80456124 004720 0004+00 1/1 0/0 0/0 .sdata2 @2462 */
SECTION_SDATA2 static f32 lit_2462 = 640.0f;
/* 80456124-80456128 004724 0004+00 1/1 0/0 0/0 .sdata2 @2463 */
SECTION_SDATA2 static f32 lit_2463 = 480.0f;
/* 80456128-8045612C 004728 0004+00 1/1 0/0 0/0 .sdata2 @2464 */
SECTION_SDATA2 static f32 lit_2464 = -1.0f;
/* 8045612C-80456130 00472C 0004+00 1/1 0/0 0/0 .sdata2 @2465 */
SECTION_SDATA2 static f32 lit_2465 = 1.0f;
/* 80456130-80456138 004730 0004+04 1/1 0/0 0/0 .sdata2 @2466 */
SECTION_SDATA2 static f32 lit_2466[1 + 1 /* padding */] = {
4.0f,
/* padding */
0.0f,
};
/* 80456138-80456140 004738 0008+00 1/1 0/0 0/0 .sdata2 @2469 */
SECTION_SDATA2 static f64 lit_2469 = 4503599627370496.0 /* cast u32 to float */;
/* 80456140-80456148 004740 0008+00 1/1 0/0 0/0 .sdata2 @2471 */
SECTION_SDATA2 static f64 lit_2471 = 4503601774854144.0 /* cast s32 to float */;
/* 802E7648-802E7BB8 2E1F88 0570+00 2/2 0/0 0/0 .text
* doDraw__10JUTConsoleCFQ210JUTConsole12EConsoleType */
#ifdef NONMATCHING
void JUTConsole::doDraw(JUTConsole::EConsoleType consoleType) const {
f32 font_yOffset;
s32 changeLine_1;
s32 changeLine_2;
if (mVisible && (mFont != NULL || consoleType == CONSOLE_TYPE_2)) {
if (mHeight != 0) {
bool temp_r30 = consoleType == CONSOLE_TYPE_0;
f32 temp_f31 = 2.0f + mFontSizeY;
font_yOffset = 2.0f + mFontSizeY;
if (consoleType != CONSOLE_TYPE_2) {
if (JUTVideo::getManager() == NULL) {
J2DOrthoGraph ortho(0.0f, 0.0f, 640.0f, 480.0f, -1.0f, 1.0f);
ortho.setPort();
} else {
J2DOrthoGraph ortho(0.0f, 0.0f, JUTVideo::getManager()->getFbWidth(), JUTVideo::getManager()->getEfbHeight(), -1.0f, 1.0f);
J2DOrthoGraph ortho(0.0f, 0.0f, JUTVideo::getManager()->getFbWidth(),
JUTVideo::getManager()->getEfbHeight(), -1.0f, 1.0f);
ortho.setPort();
}
@@ -233,11 +200,14 @@ void JUTConsole::doDraw(JUTConsole::EConsoleType consoleType) const {
color = &field_0x5c;
}
J2DFillBox(mPositionX - 2, (f32)(mPositionY - temp_f31), 4.0f + (mFontSizeX * (f32)field_0x20), temp_f31 * (f32)mHeight, *color);
J2DFillBox(mPositionX - 2, (int)(mPositionY - font_yOffset),
(int)((mFontSizeX * field_0x20) + 4.0f), (int)(font_yOffset * mHeight),
*color);
mFont->setGX();
if (temp_r30) {
if ((diffIndex(field_0x30, field_0x38) - mHeight) + 1 <= 1) {
s32 s = (diffIndex(field_0x30, field_0x38) - mHeight) + 1;
if (s <= 0) {
mFont->setCharColor(JUtility::TColor(255, 255, 255, 255));
} else if (field_0x30 == field_0x34) {
mFont->setCharColor(JUtility::TColor(255, 230, 230, 255));
@@ -248,34 +218,39 @@ void JUTConsole::doDraw(JUTConsole::EConsoleType consoleType) const {
mFont->setCharColor(JUtility::TColor(230, 230, 230, 255));
}
} else {
JUTDirectPrint::getManager()->erase(mPositionX - 3, mPositionY - 2, (field_0x20 * 6) + 6, (temp_f31 * mHeight) + 4);
JUTDirectPrint::getManager()->erase(mPositionX - 3, mPositionY - 2,
(field_0x20 * 6) + 6,
(int)(font_yOffset * mHeight) + 4);
JUTDirectPrint::getManager()->setCharColor(JUtility::TColor(255, 255, 255, 255));
}
for (int i = 0, j = field_0x30; i > mHeight && j != field_0x34; i++, j = nextIndex(j)) {
char* str = (char*)getLinePtr(j);
char* linePtr;
s32 curLine = field_0x30;
s32 yFactor = 0;
if (str[-1] != 0) {
do {
linePtr = (char*)getLinePtr(curLine);
if ((u8)linePtr[-1] != NULL) {
if (consoleType != CONSOLE_TYPE_2) {
mFont->drawString_scale(mPositionX, (mPositionY + i) * temp_f31, mFontSizeX, mFontSizeY, str, true);
mFont->drawString_scale(mPositionX, ((yFactor * font_yOffset) + mPositionY),
mFontSizeX, mFontSizeY, linePtr, true);
} else {
JUTDirectPrint::getManager()->drawString(mPositionX, (mPositionY + i) * temp_f31, str);
JUTDirectPrint::getManager()->drawString(
mPositionX, ((yFactor * font_yOffset) + mPositionY), linePtr);
}
changeLine_1 = curLine + 1;
yFactor += 1;
changeLine_2 = changeLine_1 & ~(-((s32)mMaxLines <= (s32)changeLine_1));
curLine = changeLine_2;
} else {
break;
}
}
} while (yFactor < mHeight && changeLine_2 != field_0x34);
}
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JUTConsole::doDraw(JUTConsole::EConsoleType param_0) const {
nofralloc
#include "asm/JSystem/JUtility/JUTConsole/doDraw__10JUTConsoleCFQ210JUTConsole12EConsoleType.s"
}
#pragma pop
#endif
/* 802E7BB8-802E7C38 2E24F8 0080+00 0/0 13/13 0/0 .text print_f__10JUTConsoleFPCce */
void JUTConsole::print_f(char const* fmt, ...) {
@@ -481,7 +456,8 @@ extern "C" void JUTReportConsole_f_va(const char* fmt, va_list args) {
if (JUTGetReportConsole() == NULL) {
vsnprintf(buf, sizeof(buf), fmt, args);
} else if (JUTGetReportConsole()->getOutput() & (JUTConsole::OUTPUT_CONSOLE | JUTConsole::OUTPUT_OSREPORT)) {
} else if (JUTGetReportConsole()->getOutput() &
(JUTConsole::OUTPUT_CONSOLE | JUTConsole::OUTPUT_OSREPORT)) {
vsnprintf(buf, sizeof(buf), fmt, args);
JUTGetReportConsole()->print(buf);
}
libs/JSystem/JUtility/JUTException.cpp
+9 -10
View File
@@ -47,7 +47,6 @@ extern "C" void _restgpr_25();
extern "C" void _savegpr_28();
extern "C" void _restgpr_28();
extern "C" void OSYieldThread();
extern "C" void OSProtectRange(int, void*, int, int);
extern "C" void OSFillFPUContext(OSContext*);
extern "C" void print_f__10JUTConsoleFPCce();
extern "C" OSContext* OSGetCurrentContext();
@@ -111,11 +110,11 @@ OSErrorHandler JUTException::sPostUserCallback;
/* 802E1D5C-802E1E40 2DC69C 00E4+00 1/1 0/0 0/0 .text __ct__12JUTExceptionFP14JUTDirectPrint */
JUTException::JUTException(JUTDirectPrint* directPrint)
: JKRThread(0x1C00 /* 0x4000 in DEBUG */, 0x10, 0), mDirectPrint(directPrint) {
OSSetErrorHandler(OS_ERROR_DSI, errorHandler);
OSSetErrorHandler(OS_ERROR_ISI, errorHandler);
OSSetErrorHandler(OS_ERROR_PROGRAM, errorHandler);
OSSetErrorHandler(OS_ERROR_ALIGNMENT, errorHandler);
OSSetErrorHandler(OS_ERROR_MEMORY_PROTECTION, errorHandler);
OSSetErrorHandler(EXCEPTION_DSI, errorHandler);
OSSetErrorHandler(EXCEPTION_ISI, errorHandler);
OSSetErrorHandler(EXCEPTION_PROGRAM, errorHandler);
OSSetErrorHandler(EXCEPTION_ALIGNMENT, errorHandler);
OSSetErrorHandler(EXCEPTION_MEMORY_PROTECTION, errorHandler);
setFPException(0);
sPreUserCallback = NULL;
@@ -199,7 +198,7 @@ u32 JUTException::fpscr;
/* 802E1FCC-802E20C0 2DC90C 00F4+00 2/2 0/0 0/0 .text
* errorHandler__12JUTExceptionFUsP9OSContextUlUl */
void JUTException::errorHandler(u16 error, OSContext* context, u32 param_3, u32 param_4) {
void JUTException::errorHandler(OSError error, OSContext* context, u32 param_3, u32 param_4) {
msr = PPCMfmsr();
fpscr = context->fpscr;
OSFillFPUContext(context);
@@ -234,7 +233,7 @@ void JUTException::panic_f_va(char const* file, int line, char const* format, va
char buffer[256];
vsnprintf(buffer, sizeof(buffer) - 1, format, args);
if (!sErrorManager) {
OSPanic(file, line, buffer);
OSPanic((char*)file, line, buffer);
}
OSContext* current_context = OSGetCurrentContext();
@@ -274,9 +273,9 @@ void JUTException::panic_f(char const* file, int line, char const* format, ...)
void JUTException::setFPException(u32 fpscr_enable_bits) {
__OSFpscrEnableBits = fpscr_enable_bits;
if (fpscr_enable_bits) {
OSSetErrorHandler(OS_ERROR_FLOATING_POINT_EXCEPTION, errorHandler);
OSSetErrorHandler(EXCEPTION_FLOATING_POINT_EXCEPTION, errorHandler);
} else {
OSSetErrorHandler(OS_ERROR_FLOATING_POINT_EXCEPTION, NULL);
OSSetErrorHandler(EXCEPTION_FLOATING_POINT_EXCEPTION, NULL);
}
}
libs/JSystem/JUtility/JUTGamePad.cpp
-1
View File
@@ -87,7 +87,6 @@ extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void append__10JSUPtrListFP10JSUPtrLink();
extern "C" void remove__10JSUPtrListFP10JSUPtrLink();
extern "C" s32 OSGetResetSwitchState();
extern "C" void __register_global_object();
extern "C" void __construct_array();
extern "C" void _savegpr_22();