mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-05-28 00:16:11 -04:00
Code Issues Packages Projects Releases Wiki Activity

J3DModelLoaderCalcSize + J2DScreen work (#2198)

Browse Source 
* All literals functions in J2DScreen were matched

* Import J3DModelLoaderCalcSize work

* d_a_obj_rfHole OK

* Minor fixes for daVrbox2
This commit is contained in:
hatal175
2024-09-14 10:48:38 +03:00
committed by GitHub
parent ee0c0f12ac
commit f2ac35d738
48 changed files with 606 additions and 2285 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
+287 -146
View File
@@ -4,66 +4,15 @@
//
#include "JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.h"
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/J3DGraphLoader/J3DShapeFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
#include "JSystem/JSupport/JSupport.h"
#include "dolphin/os.h"
#include "dol2asm.h"
//
// Types:
//
struct J3DTextureBlock {};
struct J3DShapeBlock {};
struct J3DShapeFactory {
/* 80337350 */ J3DShapeFactory(J3DShapeBlock const&);
/* 80337944 */ void calcSize(int, u32);
/* 803379D8 */ void calcSizeVcdVatCmdBuffer(u32);
};
struct J3DMaterialBlock {};
struct J3DModelLoader_v26 {
/* 80336DB4 */ void calcSizeMaterial(J3DMaterialBlock const*, u32);
/* 80336F60 */ void calcSizeMaterialTable(J3DMaterialBlock const*, u32);
};
struct J3DDrawBlock {};
struct J3DMaterialDLBlock {};
struct J3DJointBlock {};
struct J3DEnvelopeBlock {};
struct J3DModelInfoBlock {};
struct J3DModelLoader {
/* 80336794 */ void countMaterialNum(void const*);
/* 803367D4 */ void calcLoadSize(void const*, u32);
/* 803369A0 */ void calcLoadMaterialTableSize(void const*);
/* 80336A98 */ void calcLoadBinaryDisplayListSize(void const*, u32);
/* 80336CD8 */ void calcSizeInformation(J3DModelInfoBlock const*, u32);
/* 80336D64 */ void calcSizeJoint(J3DJointBlock const*);
/* 80336D90 */ void calcSizeEnvelope(J3DEnvelopeBlock const*);
/* 80336DA0 */ void calcSizeDraw(J3DDrawBlock const*);
/* 80336EA0 */ void calcSizeShape(J3DShapeBlock const*, u32);
/* 80336F44 */ void calcSizeTexture(J3DTextureBlock const*);
/* 80336FF0 */ void calcSizeTextureTable(J3DTextureBlock const*);
/* 80337010 */ void calcSizePatchedMaterial(J3DMaterialBlock const*, u32);
/* 803370A0 */ void calcSizeMaterialDL(J3DMaterialDLBlock const*, u32);
};
struct J3DMaterial {};
struct J3DMaterialFactory {
struct MaterialType {};
/* 8032FFEC */ J3DMaterialFactory(J3DMaterialBlock const&);
/* 80330234 */ J3DMaterialFactory(J3DMaterialDLBlock const&);
/* 803302BC */ void countUniqueMaterials();
/* 80331A7C */ void calcSize(J3DMaterial*, J3DMaterialFactory::MaterialType, int, u32) const;
};
//
// Forward References:
//
@@ -89,7 +38,6 @@ extern "C" extern char const* const J3DModelLoaderCalcSize__stringBase0;
// External References:
//
extern "C" void OSReport();
extern "C" void __ct__18J3DMaterialFactoryFRC16J3DMaterialBlock();
extern "C" void __ct__18J3DMaterialFactoryFRC18J3DMaterialDLBlock();
extern "C" void countUniqueMaterials__18J3DMaterialFactoryFv();
@@ -113,14 +61,17 @@ extern "C" void _restgpr_28();
//
/* 80336794-803367D4 3310D4 0040+00 0/0 3/0 0/0 .text countMaterialNum__14J3DModelLoaderFPCv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::countMaterialNum(void const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/countMaterialNum__14J3DModelLoaderFPCv.s"
u16 J3DModelLoader::countMaterialNum(const void* stream) {
const J3DModelFileData* header = (const J3DModelFileData*)stream;
const J3DModelBlock* block = header->mBlocks;
for (int i = 0; i < header->mBlockNum; block = (const J3DModelBlock*)((u8*)block + block->mBlockSize), i++)
{
if (block->mBlockType == 'MAT3') {
return ((const J3DMaterialBlock*)block)->mMaterialNum;
}
}
return 0;
}
#pragma pop
/* ############################################################################################## */
/* 803A20E8-803A20E8 02E748 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -132,156 +83,346 @@ SECTION_DEAD static char const* const pad_803A20FC = "\0\0\0";
#pragma pop
/* 803367D4-803369A0 331114 01CC+00 0/0 3/0 0/0 .text calcLoadSize__14J3DModelLoaderFPCvUl */
// size load issue.
#ifdef NONMATCHING
u32 J3DModelLoader::calcLoadSize(void const* stream, u32 flags_) {
int flags = flags_;
const J3DModelFileData* header = static_cast<const J3DModelFileData*>(stream);
size_t size;
const J3DModelBlock* nextBlock = header->mBlocks;
u32 i = 0;
// TODO: What sizeof will get us a size of 0xE4?
size = 0xE4;
for (; i < header->mBlockNum; i++) {
switch (nextBlock->mBlockType) {
case 'INF1':
size += calcSizeInformation((const J3DModelInfoBlock*)nextBlock, flags);
break;
case 'JNT1':
size += calcSizeJoint((const J3DJointBlock*)nextBlock);
break;
case 'MAT2':
break;
case 'MAT3':
size += calcSizeMaterial((const J3DMaterialBlock*)nextBlock, flags);
break;
case 'SHP1':
size += calcSizeShape((const J3DShapeBlock*)nextBlock, flags);
break;
case 'TEX1':
size += calcSizeTexture((const J3DTextureBlock*)nextBlock);
break;
case 'EVP1':
size += calcSizeEnvelope((const J3DEnvelopeBlock*)nextBlock);
break;
case 'DRW1':
size += calcSizeDraw((const J3DDrawBlock*)nextBlock);
break;
case 'VTX1':
break;
default:
OSReport("Unknown data block\n");
break;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
return size;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcLoadSize(void const* param_0, u32 param_1) {
asm u32 J3DModelLoader::calcLoadSize(void const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcLoadSize__14J3DModelLoaderFPCvUl.s"
}
#pragma pop
#endif
/* 803369A0-80336A98 3312E0 00F8+00 0/0 3/0 0/0 .text
* calcLoadMaterialTableSize__14J3DModelLoaderFPCv */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcLoadMaterialTableSize(void const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcLoadMaterialTableSize__14J3DModelLoaderFPCv.s"
u32 J3DModelLoader::calcLoadMaterialTableSize(const void* stream) {
size_t size;
const J3DModelBlock* nextBlock;
bool hasTextureTable;
u32 i;
const J3DModelFileData* header = reinterpret_cast<const J3DModelFileData*>(stream);
nextBlock = header->mBlocks;
hasTextureTable = false;
i = 0;
// TODO: What sizeof will get us a size of 0x20? Is this just the file header???
size = 0x20;
for (; i < header->mBlockNum; i++) {
switch (nextBlock->mBlockType) {
case 'MAT2':
break;
case 'MAT3':
size +=
calcSizeMaterialTable((const J3DMaterialBlock*)nextBlock,
J3DMLF_21 | J3DMLF_Material_UseIndirect |
J3DMLF_Material_PE_Full | J3DMLF_Material_Color_LightOn);
break;
case 'TEX1':
size += calcSizeTextureTable((const J3DTextureBlock*)nextBlock);
hasTextureTable = true;
break;
default:
OSReport("Unknown data block\n");
break;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
if (!hasTextureTable) {
size += 12;
}
return size;
}
#pragma pop
/* 80336A98-80336CD8 3313D8 0240+00 0/0 3/0 0/0 .text
* calcLoadBinaryDisplayListSize__14J3DModelLoaderFPCvUl */
// flags issue
#ifdef NONMATCHING
u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* stream, u32 flags) {
const J3DModelFileData* header = (const J3DModelFileData*)stream;
const J3DModelBlock* nextBlock = header->mBlocks;
u32 i = 0;
u32 matFlags = flags & (J3DMLF_Material_UseIndirect | J3DMLF_26);
int size = sizeof(J3DModelData);
for (; i < header->mBlockNum; i++) {
switch (nextBlock->mBlockType) {
case 'INF1':
size += calcSizeInformation((const J3DModelInfoBlock*)nextBlock, flags);
break;
case 'JNT1':
size += calcSizeJoint((const J3DJointBlock*)nextBlock);
break;
case 'SHP1':
size += calcSizeShape((const J3DShapeBlock*)nextBlock, flags);
break;
case 'TEX1':
size += calcSizeTexture((const J3DTextureBlock*)nextBlock);
break;
case 'MDL3':
size += calcSizeMaterialDL((const J3DMaterialDLBlock*)nextBlock, flags);
break;
case 'MAT2':
break;
case 'MAT3':
u32 flags2 = (J3DMLF_21 | J3DMLF_Material_PE_Full | J3DMLF_Material_Color_LightOn);
flags2 |= matFlags;
mpMaterialBlock = (const J3DMaterialBlock*)nextBlock;
if ((flags & (J3DMLF_13 | J3DMLF_DoBdlMaterialCalc)) == 0) {
field_0x18 = 1;
size += calcSizeMaterial((const J3DMaterialBlock*)nextBlock, flags2);
} else if ((flags & (J3DMLF_13 | J3DMLF_DoBdlMaterialCalc)) == J3DMLF_DoBdlMaterialCalc) {
field_0x18 = 1;
size += calcSizePatchedMaterial((const J3DMaterialBlock*)nextBlock, matFlags);
}
break;
case 'EVP1':
size += calcSizeEnvelope((const J3DEnvelopeBlock*)nextBlock);
break;
case 'DRW1':
size += calcSizeDraw((const J3DDrawBlock*)nextBlock);
break;
case 'VTX1':
break;
default:
OSReport("Unknown data block\n");
break;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
return size;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcLoadBinaryDisplayListSize(void const* param_0, u32 param_1) {
asm u32 J3DModelLoader::calcLoadBinaryDisplayListSize(void const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcLoadBinaryDisplayListSize__14J3DModelLoaderFPCvUl.s"
}
#pragma pop
#endif
/* 80336CD8-80336D64 331618 008C+00 2/2 0/0 0/0 .text
* calcSizeInformation__14J3DModelLoaderFPC17J3DModelInfoBlockUl */
// Matches with JSUConvertOffsetToPtr<J3DModelHierarchy>
#ifdef NONMATCHING
u32 J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock* block, u32 flags) {
int size = 0;
switch ((flags | block->mFlags) & J3DMLF_MtxTypeMask) {
case J3DMLF_None: // Basic
size = 4;
break;
case J3DMLF_MtxSoftImageCalc:
size = 4;
break;
case J3DMLF_MtxMayaCalc:
size = 4;
break;
default:
break;
}
mpModelHierarchy = JSUConvertOffsetToPtr<J3DModelHierarchy>(block, block->mpHierarchy);
return size;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeInformation(J3DModelInfoBlock const* param_0, u32 param_1) {
asm u32 J3DModelLoader::calcSizeInformation(J3DModelInfoBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeInformation__14J3DModelLoaderFPC17J3DModelInfoBlockUl.s"
}
#pragma pop
#endif
/* 80336D64-80336D90 3316A4 002C+00 2/2 0/0 0/0 .text
* calcSizeJoint__14J3DModelLoaderFPC13J3DJointBlock */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeJoint(J3DJointBlock const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeJoint__14J3DModelLoaderFPC13J3DJointBlock.s"
u32 J3DModelLoader::calcSizeJoint(const J3DJointBlock* block) {
int size = 0;
if (block->mpNameTable) {
size = 0x10;
}
size += (block->mJointNum * sizeof(J3DJoint*));
size += (block->mJointNum * sizeof(J3DJoint));
return size;
}
#pragma pop
/* 80336D90-80336DA0 3316D0 0010+00 2/2 0/0 0/0 .text
* calcSizeEnvelope__14J3DModelLoaderFPC16J3DEnvelopeBlock */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeEnvelope(J3DEnvelopeBlock const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeEnvelope__14J3DModelLoaderFPC16J3DEnvelopeBlock.s"
u32 J3DModelLoader::calcSizeEnvelope(const J3DEnvelopeBlock* block) {
mEnvelopeSize = block->mWEvlpMtxNum;
return 0;
}
#pragma pop
/* 80336DA0-80336DB4 3316E0 0014+00 2/2 0/0 0/0 .text
* calcSizeDraw__14J3DModelLoaderFPC12J3DDrawBlock */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeDraw(J3DDrawBlock const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeDraw__14J3DModelLoaderFPC12J3DDrawBlock.s"
u32 J3DModelLoader::calcSizeDraw(const J3DDrawBlock* block) {
return (block->mMtxNum - mEnvelopeSize) * 2;
}
#pragma pop
/* 80336DB4-80336EA0 3316F4 00EC+00 0/0 1/0 0/0 .text
* calcSizeMaterial__18J3DModelLoader_v26FPC16J3DMaterialBlockUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader_v26::calcSizeMaterial(J3DMaterialBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeMaterial__18J3DModelLoader_v26FPC16J3DMaterialBlockUl.s"
u32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock* block, u32 flags) {
int padding = 0;
J3DMaterialFactory factory(*block);
u32 count = block->mMaterialNum;
int uniqueCount = factory.countUniqueMaterials();
if (block->mpNameTable != NULL) {
padding = 0x10;
}
size_t size = padding + (count * sizeof(J3DMaterial*));
if ((flags & J3DMLF_UseUniqueMaterials) != 0) {
// calc for allocated materials as well
size += ALIGN_NEXT((u16)uniqueCount * sizeof(J3DMaterial), 0x20);
}
if ((flags & J3DMLF_UseUniqueMaterials) != 0) {
for (u32 i = 0; i < uniqueCount; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
}
for (u32 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
return size;
}
#pragma pop
/* 80336EA0-80336F44 3317E0 00A4+00 2/2 0/0 0/0 .text
* calcSizeShape__14J3DModelLoaderFPC13J3DShapeBlockUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeShape(J3DShapeBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeShape__14J3DModelLoaderFPC13J3DShapeBlockUl.s"
u32 J3DModelLoader::calcSizeShape(const J3DShapeBlock* block, u32 flags) {
int size = 0;
J3DShapeFactory factory(*block);
int count = block->mShapeNum;
if (block->mpNameTable) {
size = 0x10;
}
size += count * sizeof(J3DShape*);
size += factory.calcSizeVcdVatCmdBuffer(count);
for (J3DModelHierarchy* hierarchy = mpModelHierarchy; hierarchy->mType != 0; hierarchy++) {
if (hierarchy->mType == 0x12) {
size += factory.calcSize(hierarchy->mValue, flags);
}
}
return size;
}
#pragma pop
/* 80336F44-80336F60 331884 001C+00 3/3 0/0 0/0 .text
* calcSizeTexture__14J3DModelLoaderFPC15J3DTextureBlock */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeTexture(J3DTextureBlock const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeTexture__14J3DModelLoaderFPC15J3DTextureBlock.s"
u32 J3DModelLoader::calcSizeTexture(const J3DTextureBlock* block) {
// TODO: use sizeofs here.
int padding = 0;
if (block->mpNameTable) {
padding = 0x10;
}
return padding + 0xC;
}
#pragma pop
/* 80336F60-80336FF0 3318A0 0090+00 0/0 1/0 0/0 .text
* calcSizeMaterialTable__18J3DModelLoader_v26FPC16J3DMaterialBlockUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader_v26::calcSizeMaterialTable(J3DMaterialBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeMaterialTable__18J3DModelLoader_v26FPC16J3DMaterialBlockUl.s"
u32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock* block, u32 flags) {
int size = 0;
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
size = 0x10;
}
size += (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
return size;
}
#pragma pop
/* 80336FF0-80337010 331930 0020+00 1/1 0/0 0/0 .text
* calcSizeTextureTable__14J3DModelLoaderFPC15J3DTextureBlock */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeTextureTable(J3DTextureBlock const* param_0) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeTextureTable__14J3DModelLoaderFPC15J3DTextureBlock.s"
u32 J3DModelLoader::calcSizeTextureTable(const J3DTextureBlock* block) {
return calcSizeTexture(block);
}
#pragma pop
/* 80337010-803370A0 331950 0090+00 1/1 0/0 0/0 .text
* calcSizePatchedMaterial__14J3DModelLoaderFPC16J3DMaterialBlockUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizePatchedMaterial(J3DMaterialBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizePatchedMaterial__14J3DModelLoaderFPC16J3DMaterialBlockUl.s"
u32 J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock* block, u32 flags) {
int padding = 0;
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
padding = 0x10;
}
u32 size = padding + (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_PATCHED, i, flags);
}
return size;
}
#pragma pop
/* 803370A0-80337178 3319E0 00D8+00 1/1 0/0 0/0 .text
* calcSizeMaterialDL__14J3DModelLoaderFPC18J3DMaterialDLBlockUl */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void J3DModelLoader::calcSizeMaterialDL(J3DMaterialDLBlock const* param_0, u32 param_1) {
nofralloc
#include "asm/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize/calcSizeMaterialDL__14J3DModelLoaderFPC18J3DMaterialDLBlockUl.s"
u32 J3DModelLoader::calcSizeMaterialDL(const J3DMaterialDLBlock* block, u32 flags_) {
int flags = flags_;
size_t size = 0;
J3DMaterialFactory factory(*block);
;
if (!field_0x18) {
u32 count = block->mMaterialNum;
if (block->mpNameTable) {
size = 0x10;
}
size += count * sizeof(J3DLockedMaterial*);
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
} else {
u32 count = block->mMaterialNum;
for (u16 i = 0; i < count; i++) {
size += factory.calcSize((J3DMaterial*)this, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
}
return size;
}
#pragma pop
/* 803A20E8-803A20E8 02E748 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */