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

J3D debug (#3037)

Browse Source 
* J3DGraphBase debug

* J3DGraphAnimator debug

* J3DGraphLoader debug
This commit is contained in:
Jcw87
2026-01-13 07:49:09 -08:00
committed by GitHub
parent dd03bf861f
commit 1a65a6bbbd
34 changed files with 630 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp
+90 -36
View File
@@ -10,10 +10,11 @@
#include "dolphin/os.h"
J3DAnmBase* J3DAnmLoaderDataBase::load(const void* i_data, J3DAnmLoaderDataBaseFlag flag) {
const JUTDataFileHeader* header = (const JUTDataFileHeader*)i_data;
J3D_ASSERT_NULLPTR(48, i_data);
if (!i_data) {
return NULL;
}
const JUTDataFileHeader* header = (const JUTDataFileHeader*)i_data;
if (header->mMagic == 'J3D1') {
switch (header->mType) {
case 'bck1': {
@@ -90,9 +91,10 @@ J3DAnmBase* J3DAnmLoaderDataBase::load(const void* i_data, J3DAnmLoaderDataBaseF
return NULL;
}
void J3DAnmLoaderDataBase::setResource(J3DAnmBase* param_1, const void* param_2) {
const JUTDataFileHeader* header = (const JUTDataFileHeader*)param_2;
if (!header) {
void J3DAnmLoaderDataBase::setResource(J3DAnmBase* param_1, const void* i_data) {
const JUTDataFileHeader* header = (const JUTDataFileHeader*)i_data;
J3D_ASSERT_NULLPTR(188, i_data);
if (!i_data) {
return;
}
if (header->mMagic != 'J3D1') {
@@ -101,64 +103,64 @@ void J3DAnmLoaderDataBase::setResource(J3DAnmBase* param_1, const void* param_2)
switch (header->mType) {
case 'bck1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bpk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'blk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'btk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'brk1': {
J3DAnmKeyLoader_v15 loader;
if (param_1->getKind() == 5) {
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
}
break;
}
case 'bxk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bca1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bpa1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'btp1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bla1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bxa1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
case 'bva1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, param_2);
loader.setResource(param_1, i_data);
break;
}
default: {
@@ -176,8 +178,9 @@ J3DAnmKeyLoader_v15::J3DAnmKeyLoader_v15() {}
J3DAnmKeyLoader_v15::~J3DAnmKeyLoader_v15() {}
J3DAnmBase* J3DAnmFullLoader_v15::load(const void* param_1) {
const JUTDataFileHeader* header = (const JUTDataFileHeader*)param_1;
J3DAnmBase* J3DAnmFullLoader_v15::load(const void* i_data) {
J3D_ASSERT_NULLPTR(357, i_data);
const JUTDataFileHeader* header = (const JUTDataFileHeader*)i_data;
const JUTDataBlockHeader* block = &header->mFirstBlock;
for (int i = 0; i < header->mBlockNum; i++) {
switch (block->mType) {
@@ -203,49 +206,59 @@ J3DAnmBase* J3DAnmFullLoader_v15::load(const void* param_1) {
OSReport("Unknown data block\n");
break;
}
block = block->getNext();
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
return mAnm;
}
void J3DAnmFullLoader_v15::setResource(J3DAnmBase* param_1, const void* param_2) {
const JUTDataFileHeader* header = (const JUTDataFileHeader*)param_2;
void J3DAnmFullLoader_v15::setResource(J3DAnmBase* param_1, const void* i_data) {
J3D_ASSERT_NULLPTR(416, i_data);
const JUTDataFileHeader* header = (const JUTDataFileHeader*)i_data;
const JUTDataBlockHeader* block = &header->mFirstBlock;
for (int i = 0; i < header->mBlockNum; i++) {
switch (block->mType) {
case 'ANF1':
JUT_ASSERT_MSG(428, param_1->getKind() == 9, "Error: Resource type inconsistency");
setAnmTransform((J3DAnmTransformFull*)param_1, (const J3DAnmTransformFullData*)block);
break;
case 'PAF1':
JUT_ASSERT_MSG(435, param_1->getKind() == 10, "Error: Resource type inconsistency");
setAnmColor((J3DAnmColorFull*)param_1, (const J3DAnmColorFullData*)block);
break;
case 'TPT1':
JUT_ASSERT_MSG(441, param_1->getKind() == 2, "Error: Resource type inconsistency");
setAnmTexPattern((J3DAnmTexPattern*)param_1, (const J3DAnmTexPatternFullData*)block);
break;
case 'CLF1':
JUT_ASSERT_MSG(448, param_1->getKind() == 12, "Error: Resource type inconsistency");
setAnmCluster((J3DAnmClusterFull*)param_1, (const J3DAnmClusterFullData*)block);
break;
case 'VAF1':
JUT_ASSERT_MSG(454, param_1->getKind() == 6, "Error: Resource type inconsistency");
setAnmVisibility((J3DAnmVisibilityFull*)param_1,
(const J3DAnmVisibilityFullData*)block);
break;
case 'VCF1':
JUT_ASSERT_MSG(461, param_1->getKind() == 14, "Error: Resource type inconsistency");
setAnmVtxColor((J3DAnmVtxColorFull*)param_1, (const J3DAnmVtxColorFullData*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
block = block->getNext();
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
}
void J3DAnmFullLoader_v15::readAnmTransform(const J3DAnmTransformFullData* param_1) {
setAnmTransform((J3DAnmTransformFull*)mAnm, param_1);
J3DAnmTransformFull* anm = (J3DAnmTransformFull*)mAnm;
setAnmTransform(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmTransform(J3DAnmTransformFull* param_1,
const J3DAnmTransformFullData* param_2) {
J3D_ASSERT_NULLPTR(504, param_1);
J3D_ASSERT_NULLPTR(505, param_2);
param_1->field_0x1e = param_2->field_0xc;
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
@@ -259,11 +272,14 @@ void J3DAnmFullLoader_v15::setAnmTransform(J3DAnmTransformFull* param_1,
void J3DAnmFullLoader_v15::readAnmColor(const J3DAnmColorFullData* param_1) {
setAnmColor((J3DAnmColorFull*)mAnm, param_1);
J3DAnmColorFull* anm = (J3DAnmColorFull*)mAnm;
setAnmColor(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmColor(J3DAnmColorFull* param_1,
const J3DAnmColorFullData* param_2) {
J3D_ASSERT_NULLPTR(550, param_1);
J3D_ASSERT_NULLPTR(551, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -281,11 +297,14 @@ void J3DAnmFullLoader_v15::setAnmColor(J3DAnmColorFull* param_1,
}
void J3DAnmFullLoader_v15::readAnmTexPattern(const J3DAnmTexPatternFullData* param_1) {
setAnmTexPattern((J3DAnmTexPattern*)mAnm, param_1);
J3DAnmTexPattern* anm = (J3DAnmTexPattern*)mAnm;
setAnmTexPattern(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmTexPattern(J3DAnmTexPattern* param_1,
const J3DAnmTexPatternFullData* param_2) {
J3D_ASSERT_NULLPTR(603, param_1);
J3D_ASSERT_NULLPTR(604, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -301,11 +320,14 @@ void J3DAnmFullLoader_v15::setAnmTexPattern(J3DAnmTexPattern* param_1,
}
void J3DAnmFullLoader_v15::readAnmVisibility(const J3DAnmVisibilityFullData* param_1) {
setAnmVisibility((J3DAnmVisibilityFull*)mAnm, param_1);
J3DAnmVisibilityFull* anm = (J3DAnmVisibilityFull*)mAnm;
setAnmVisibility(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmVisibility(J3DAnmVisibilityFull* param_1,
const J3DAnmVisibilityFullData* param_2) {
J3D_ASSERT_NULLPTR(654, param_1);
J3D_ASSERT_NULLPTR(655, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -317,11 +339,14 @@ void J3DAnmFullLoader_v15::setAnmVisibility(J3DAnmVisibilityFull* param_1,
}
void J3DAnmFullLoader_v15::readAnmCluster(const J3DAnmClusterFullData* param_1) {
setAnmCluster((J3DAnmClusterFull*)mAnm, param_1);
J3DAnmClusterFull* anm = (J3DAnmClusterFull*)mAnm;
setAnmCluster(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmCluster(J3DAnmClusterFull* param_1,
const J3DAnmClusterFullData* param_2) {
J3D_ASSERT_NULLPTR(697, param_1);
J3D_ASSERT_NULLPTR(698, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -331,11 +356,14 @@ void J3DAnmFullLoader_v15::setAnmCluster(J3DAnmClusterFull* param_1,
}
void J3DAnmFullLoader_v15::readAnmVtxColor(const J3DAnmVtxColorFullData* param_1) {
setAnmVtxColor((J3DAnmVtxColorFull*)mAnm, param_1);
J3DAnmVtxColorFull* anm = (J3DAnmVtxColorFull*)mAnm;
setAnmVtxColor(anm, param_1);
}
void J3DAnmFullLoader_v15::setAnmVtxColor(J3DAnmVtxColorFull* dst,
const J3DAnmVtxColorFullData* data) {
J3D_ASSERT_NULLPTR(738, dst);
J3D_ASSERT_NULLPTR(739, data);
dst->mFrameMax = data->mFrameMax;
dst->mAttribute = data->field_0x8;
dst->mFrame = 0.0f;
@@ -368,6 +396,7 @@ void J3DAnmFullLoader_v15::setAnmVtxColor(J3DAnmVtxColorFull* dst,
}
J3DAnmBase* J3DAnmKeyLoader_v15::load(const void* param_1) {
J3D_ASSERT_NULLPTR(801, param_1);
const JUTDataFileHeader* header = (const JUTDataFileHeader*)param_1;
const JUTDataBlockHeader* block = &header->mFirstBlock;
for (int i = 0; i < header->mBlockNum; i++) {
@@ -394,48 +423,58 @@ J3DAnmBase* J3DAnmKeyLoader_v15::load(const void* param_1) {
OSReport("Unknown data block\n");
break;
}
block = block->getNext();
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
return mAnm;
}
void J3DAnmKeyLoader_v15::setResource(J3DAnmBase* param_1, const void* param_2) {
J3D_ASSERT_NULLPTR(858, param_2);
const JUTDataFileHeader* header = (const JUTDataFileHeader*)param_2;
const JUTDataBlockHeader* block = &header->mFirstBlock;
for (int i = 0; i < header->mBlockNum; i++) {
switch (block->mType) {
case 'ANK1':
JUT_ASSERT_MSG(870, param_1->getKind() == 8, "Error: Resource type inconsistency");
setAnmTransform((J3DAnmTransformKey*)param_1, (const J3DAnmTransformKeyData*)block);
break;
case 'PAK1':
JUT_ASSERT_MSG(876, param_1->getKind() == 11, "Error: Resource type inconsistency");
setAnmColor((J3DAnmColorKey*)param_1, (const J3DAnmColorKeyData*)block);
break;
case 'CLK1':
JUT_ASSERT_MSG(883, param_1->getKind() == 13, "Error: Resource type inconsistency");
setAnmCluster((J3DAnmClusterKey*)param_1, (const J3DAnmClusterKeyData*)block);
break;
case 'TTK1':
JUT_ASSERT_MSG(888, param_1->getKind() == 4, "Error: Resource type inconsistency");
setAnmTextureSRT((J3DAnmTextureSRTKey*)param_1, (const J3DAnmTextureSRTKeyData*)block);
break;
case 'TRK1':
JUT_ASSERT_MSG(894, param_1->getKind() == 5, "Error: Resource type inconsistency");
setAnmTevReg((J3DAnmTevRegKey*)param_1, (const J3DAnmTevRegKeyData*)block);
break;
case 'VCK1':
JUT_ASSERT_MSG(901, param_1->getKind() == 15, "Error: Resource type inconsistency");
setAnmVtxColor((J3DAnmVtxColorKey*)param_1, (const J3DAnmVtxColorKeyData*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
block = block->getNext();
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
}
void J3DAnmKeyLoader_v15::readAnmTransform(const J3DAnmTransformKeyData* param_1) {
setAnmTransform((J3DAnmTransformKey*)mAnm, param_1);
J3DAnmTransformKey* anm = (J3DAnmTransformKey*)mAnm;
setAnmTransform(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmTransform(J3DAnmTransformKey* param_1,
const J3DAnmTransformKeyData* param_2) {
J3D_ASSERT_NULLPTR(944, param_1);
J3D_ASSERT_NULLPTR(945, param_2);
param_1->field_0x1e = param_2->field_0xc;
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
@@ -450,11 +489,14 @@ void J3DAnmKeyLoader_v15::setAnmTransform(J3DAnmTransformKey* param_1,
void J3DAnmKeyLoader_v15::readAnmTextureSRT(const J3DAnmTextureSRTKeyData* param_1) {
setAnmTextureSRT((J3DAnmTextureSRTKey*)mAnm, param_1);
J3DAnmTextureSRTKey* anm = (J3DAnmTextureSRTKey*)mAnm;
setAnmTextureSRT(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmTextureSRT(J3DAnmTextureSRTKey* param_1,
const J3DAnmTextureSRTKeyData* param_2) {
J3D_ASSERT_NULLPTR(987, param_1);
J3D_ASSERT_NULLPTR(988, param_2);
param_1->mTrackNum = param_2->field_0xc;
param_1->mFrameMax = param_2->field_0xa;
param_1->mAttribute = param_2->field_0x8;
@@ -505,10 +547,13 @@ void J3DAnmKeyLoader_v15::setAnmTextureSRT(J3DAnmTextureSRTKey* param_1,
void J3DAnmKeyLoader_v15::readAnmColor(const J3DAnmColorKeyData* param_1) {
setAnmColor((J3DAnmColorKey*)mAnm, param_1);
J3DAnmColorKey* anm = (J3DAnmColorKey*)mAnm;
setAnmColor(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmColor(J3DAnmColorKey* param_1, const J3DAnmColorKeyData* param_2) {
J3D_ASSERT_NULLPTR(1097, param_1);
J3D_ASSERT_NULLPTR(1098, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -531,11 +576,14 @@ void J3DAnmKeyLoader_v15::setAnmColor(J3DAnmColorKey* param_1, const J3DAnmColor
void J3DAnmKeyLoader_v15::readAnmCluster(const J3DAnmClusterKeyData* param_1) {
setAnmCluster((J3DAnmClusterKey*)mAnm, param_1);
J3DAnmClusterKey* anm = (J3DAnmClusterKey*)mAnm;
setAnmCluster(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmCluster(J3DAnmClusterKey* param_1,
const J3DAnmClusterKeyData* param_2) {
J3D_ASSERT_NULLPTR(1156, param_1);
J3D_ASSERT_NULLPTR(1157, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -546,11 +594,14 @@ void J3DAnmKeyLoader_v15::setAnmCluster(J3DAnmClusterKey* param_1,
void J3DAnmKeyLoader_v15::readAnmTevReg(const J3DAnmTevRegKeyData* param_1) {
setAnmTevReg((J3DAnmTevRegKey*)mAnm, param_1);
J3DAnmTevRegKey* anm = (J3DAnmTevRegKey*)mAnm;
setAnmTevReg(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmTevReg(J3DAnmTevRegKey* param_1,
const J3DAnmTevRegKeyData* param_2) {
J3D_ASSERT_NULLPTR(1195, param_1);
J3D_ASSERT_NULLPTR(1196, param_2);
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->field_0x8;
param_1->mFrame = 0.0f;
@@ -588,11 +639,14 @@ void J3DAnmKeyLoader_v15::setAnmTevReg(J3DAnmTevRegKey* param_1,
void J3DAnmKeyLoader_v15::readAnmVtxColor(const J3DAnmVtxColorKeyData* param_1) {
setAnmVtxColor((J3DAnmVtxColorKey*)mAnm, param_1);
J3DAnmVtxColorKey* anm = (J3DAnmVtxColorKey*)mAnm;
setAnmVtxColor(anm, param_1);
}
void J3DAnmKeyLoader_v15::setAnmVtxColor(J3DAnmVtxColorKey* dst,
const J3DAnmVtxColorKeyData* data) {
J3D_ASSERT_NULLPTR(1275, dst);
J3D_ASSERT_NULLPTR(1276, data);
dst->mFrameMax = data->mFrameMax;
dst->mAttribute = data->field_0x8;
dst->mFrame = 0.0f;
src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp
+8 -5
View File
@@ -12,6 +12,7 @@
#include <string>
void* J3DClusterLoaderDataBase::load(const void* i_data) {
J3D_ASSERT_NULLPTR(41, i_data);
const JUTDataFileHeader* fileHeader = (JUTDataFileHeader*)i_data;
if (fileHeader->mMagic == 'J3D1' && fileHeader->mType == 'bls1') {
J3DClusterLoader_v15 loader;
@@ -27,6 +28,7 @@ J3DClusterLoader_v15::J3DClusterLoader_v15() {}
J3DClusterLoader_v15::~J3DClusterLoader_v15() {}
void* J3DClusterLoader_v15::load(const void* i_data) {
J3D_ASSERT_NULLPTR(98, i_data);
mpDeformData = new J3DDeformData();
const JUTDataFileHeader* fileHeader = (JUTDataFileHeader*)i_data;
@@ -40,13 +42,14 @@ void* J3DClusterLoader_v15::load(const void* i_data) {
OSReport("Unknown data block\n");
break;
}
block = block->getNext();
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
return mpDeformData;
}
void J3DClusterLoader_v15::readCluster(const J3DClusterBlock* block) {
J3D_ASSERT_NULLPTR(147, block);
mpDeformData->mClusterNum = block->mClusterNum;
mpDeformData->mClusterKeyNum = block->mClusterKeyNum;
mpDeformData->mVtxPosNum = block->mVtxPosNum;
@@ -70,11 +73,11 @@ void J3DClusterLoader_v15::readCluster(const J3DClusterBlock* block) {
mpDeformData->mVtxNrm = JSUConvertOffsetToPtr<f32>(block, block->mVtxNrm);
void* clusterPointer = block->mClusterPointer;
int clusterKeyPointerSize = (intptr_t)block->mClusterKeyPointer - (intptr_t)clusterPointer;
int clusterVertexPointerSize = (intptr_t)block->mClusterVertex - (intptr_t)clusterPointer;
int vtxPosSize = (intptr_t)block->mVtxPos - (intptr_t)clusterPointer;
int clusterKeyPointerSize = (intptr_t)block->mClusterKeyPointer - (intptr_t)block->mClusterPointer;
int clusterVertexPointerSize = (intptr_t)block->mClusterVertex - (intptr_t)block->mClusterPointer;
int vtxPosSize = (intptr_t)block->mVtxPos - (intptr_t)block->mClusterPointer;
u8* arr = new (0x20) u8[vtxPosSize];
memcpy(arr, JSUConvertOffsetToPtr<J3DCluster>(block, clusterPointer), vtxPosSize);
memcpy(arr, JSUConvertOffsetToPtr<J3DCluster>(block, block->mClusterPointer), vtxPosSize);
mpDeformData->mClusterPointer = (J3DCluster*)arr;
mpDeformData->mClusterKeyPointer = (J3DClusterKey*)&arr[clusterKeyPointerSize];
mpDeformData->mClusterVertex = (J3DClusterVertex*)&arr[clusterVertexPointerSize];
src/JSystem/J3DGraphLoader/J3DJointFactory.cpp
+1
View File
@@ -12,6 +12,7 @@ J3DJointFactory::J3DJointFactory(J3DJointBlock const& block) {
J3DJoint* J3DJointFactory::create(int no) {
J3DJoint* joint = new J3DJoint();
J3D_ASSERT_ALLOCMEM(50, joint);
joint->mJntNo = no;
joint->mKind = getKind(no);
joint->mScaleCompensate = getScaleCompensate(no);
src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
+111 -32
View File
@@ -1,9 +1,10 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
#include "JSystem/J3DGraphAnimator/J3DShapeTable.h"
#include "JSystem/J3DGraphAnimator/J3DJointTree.h"
#include "JSystem/J3DGraphAnimator/J3DJoint.h"
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/J3DGraphLoader/J3DJointFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory_v21.h"
@@ -26,26 +27,45 @@ J3DModelLoader::J3DModelLoader() :
}
J3DModelData* J3DModelLoaderDataBase::load(void const* i_data, u32 i_flags) {
J3D_ASSERT_NULLPTR(52, i_data);
const J3DModelFileData* header = (const J3DModelFileData*)i_data;
if (i_data == NULL) {
return NULL;
}
if (*(u32*)i_data == 'J3D1' && *(u32*)((uintptr_t)i_data + 4) == 'bmd1') {
if (header->mMagic1 == 'J3D1' && header->mMagic2 == 'bmd1') {
JUT_PANIC(64, "Error : version error.");
return NULL;
}
if (*(u32*)i_data == 'J3D2' && *(u32*)((uintptr_t)i_data + 4) == 'bmd2') {
if (header->mMagic1 == 'J3D2' && header->mMagic2 == 'bmd2') {
J3DModelLoader_v21 loader;
return loader.load(i_data, i_flags);
}
if (*(u32*)i_data == 'J3D2' && *(u32*)((uintptr_t)i_data + 4) == 'bmd3') {
if (header->mMagic1 == 'J3D2' && header->mMagic2 == 'bmd3') {
J3DModelLoader_v26 loader;
return loader.load(i_data, i_flags);
}
JUT_PANIC(89, "Error : version error.");
return NULL;
}
J3DModelData* J3DModelLoaderDataBase::loadBinaryDisplayList(const void* i_data, u32 flags) {
J3D_ASSERT_NULLPTR(138, i_data);
const J3DModelFileData* header = (const J3DModelFileData*)i_data;
if (!i_data) {
return NULL;
}
if (header->mMagic1 == 'J3D2' && (header->mMagic2 == 'bdl3' || header->mMagic2 == 'bdl4')) {
J3DModelLoader_v26 loader;
return loader.loadBinaryDisplayList(i_data, flags);
}
JUT_PANIC(157, "Error : version error.");
return NULL;
}
J3DModelData* J3DModelLoader::load(void const* i_data, u32 i_flags) {
JKRGetCurrentHeap()->getTotalFreeSize();
s32 freeSize = JKRGetCurrentHeap()->getTotalFreeSize();
mpModelData = new J3DModelData();
J3D_ASSERT_ALLOCMEM(177, mpModelData);
mpModelData->clear();
mpModelData->mpRawData = i_data;
mpModelData->setModelDataType(0);
@@ -102,17 +122,19 @@ J3DModelData* J3DModelLoader::load(void const* i_data, u32 i_flags) {
J3DMaterialTable* J3DModelLoader::loadMaterialTable(void const* i_data) {
int flags = 0x51100000;
mpMaterialTable = new J3DMaterialTable();
J3D_ASSERT_ALLOCMEM(279, mpMaterialTable);
mpMaterialTable->clear();
J3DModelFileData const* data = (J3DModelFileData*)i_data;
J3DModelBlock const* block = data->mBlocks;
for (u32 block_no = 0; block_no < data->mBlockNum; block_no++) {
switch (block->mBlockType) {
case 'MAT3':
readMaterialTable((J3DMaterialBlock*)block, 0x51100000);
readMaterialTable((J3DMaterialBlock*)block, flags);
break;
case 'MAT2':
readMaterialTable_v21((J3DMaterialBlock_v21*)block, 0x51100000);
readMaterialTable_v21((J3DMaterialBlock_v21*)block, flags);
break;
case 'TEX1':
readTextureTable((J3DTextureBlock*)block);
@@ -125,12 +147,18 @@ J3DMaterialTable* J3DModelLoader::loadMaterialTable(void const* i_data) {
}
if (mpMaterialTable->mTexture == NULL) {
mpMaterialTable->mTexture = new J3DTexture(0, NULL);
J3D_ASSERT_ALLOCMEM(319, mpMaterialTable->mTexture);
}
return mpMaterialTable;
}
inline u32 getBdlFlag_MaterialType(u32 flags) {
return flags & (J3DMLF_13 | J3DMLF_DoBdlMaterialCalc);
}
J3DModelData* J3DModelLoader::loadBinaryDisplayList(void const* i_data, u32 i_flags) {
mpModelData = new J3DModelData();
J3D_ASSERT_ALLOCMEM(338, mpModelData);
mpModelData->clear();
mpModelData->mpRawData = i_data;
mpModelData->setModelDataType(1);
@@ -139,6 +167,7 @@ J3DModelData* J3DModelLoader::loadBinaryDisplayList(void const* i_data, u32 i_fl
J3DModelBlock const* block = data->mBlocks;
for (u32 block_no = 0; block_no < data->mBlockNum; block_no++) {
s32 flags;
u32 materialType;
switch (block->mBlockType) {
case 'INF1':
flags = i_flags;
@@ -170,9 +199,10 @@ J3DModelData* J3DModelLoader::loadBinaryDisplayList(void const* i_data, u32 i_fl
flags = 0x50100000;
flags |= (i_flags & 0x3000000);
mpMaterialBlock = (J3DMaterialBlock*)block;
if (((u32)i_flags & 0x3000) == 0) {
materialType = getBdlFlag_MaterialType(i_flags);
if (materialType == 0) {
readMaterial((J3DMaterialBlock*)block, flags);
} else if (((u32)i_flags & 0x3000) == 0x2000) {
} else if (materialType == 0x2000) {
readPatchedMaterial((J3DMaterialBlock*)block, flags);
}
break;
@@ -195,31 +225,27 @@ void J3DModelLoader::setupBBoardInfo() {
for (u16 i = 0; i < mpModelData->getJointNum(); i++) {
J3DMaterial* mesh = mpModelData->getJointNodePointer(i)->getMesh();
if (mesh != NULL) {
u16 shape_index = mesh->getShape()->getIndex();
u32 shape_index = mesh->getShape()->getIndex();
u16* index_table = JSUConvertOffsetToPtr<u16>(mpShapeBlock,
(uintptr_t)mpShapeBlock->mpIndexTable);
J3DShapeInitData* shape_init_data =
JSUConvertOffsetToPtr<J3DShapeInitData>(mpShapeBlock,
(uintptr_t)mpShapeBlock->mpShapeInitData);
J3DJoint* joint;
switch (shape_init_data[index_table[shape_index]].mShapeMtxType) {
J3DShapeInitData* r26 = &shape_init_data[index_table[shape_index]];
switch (r26->mShapeMtxType) {
case 0:
joint = mpModelData->getJointNodePointer(i);
joint->setMtxType(0);
mpModelData->getJointNodePointer(i)->setMtxType(0);
break;
case 1:
joint = mpModelData->getJointNodePointer(i);
joint->setMtxType(1);
mpModelData->getJointNodePointer(i)->setMtxType(1);
mpModelData->mbHasBillboard = true;
break;
case 2:
joint = mpModelData->getJointNodePointer(i);
joint->setMtxType(2);
mpModelData->getJointNodePointer(i)->setMtxType(2);
mpModelData->mbHasBillboard = true;
break;
case 3:
joint = mpModelData->getJointNodePointer(i);
joint->setMtxType(0);
mpModelData->getJointNodePointer(i)->setMtxType(0);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (__FILE__)\n");
@@ -230,6 +256,7 @@ void J3DModelLoader::setupBBoardInfo() {
}
void J3DModelLoader::readInformation(J3DModelInfoBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(506, i_block);
mpModelData->mFlags = i_flags | i_block->mFlags;
mpModelData->getJointTree().setFlag(mpModelData->mFlags);
J3DMtxCalc* mtx_calc = NULL;
@@ -243,7 +270,11 @@ void J3DModelLoader::readInformation(J3DModelInfoBlock const* i_block, u32 i_fla
case 2:
mtx_calc = new J3DMtxCalcNoAnm<J3DMtxCalcCalcTransformMaya,J3DMtxCalcJ3DSysInitMaya>();
break;
default:
JUT_PANIC(529, "Error : Invalid MtxCalcType.");
break;
}
J3D_ASSERT_ALLOCMEM(532, mtx_calc);
mpModelData->setBasicMtxCalc(mtx_calc);
mpModelData->getVertexData().mPacketNum = i_block->mPacketNum;
mpModelData->getVertexData().mVtxNum = i_block->mVtxNum;
@@ -260,6 +291,7 @@ static _GXCompType getFmtType(_GXVtxAttrFmtList* i_fmtList, _GXAttr i_attr) {
}
void J3DModelLoader::readVertex(J3DVertexBlock const* i_block) {
J3D_ASSERT_NULLPTR(577, i_block);
J3DVertexData& vertex_data = mpModelData->getVertexData();
vertex_data.mVtxAttrFmtList =
JSUConvertOffsetToPtr<GXVtxAttrFmtList>(i_block, i_block->mpVtxAttrFmtList);
@@ -275,8 +307,12 @@ void J3DModelLoader::readVertex(J3DVertexBlock const* i_block) {
JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxTexCoordArray[i]);
}
_GXCompType nrm_type = getFmtType(vertex_data.mVtxAttrFmtList, GX_VA_NRM);
u32 nrm_size = nrm_type == GX_F32 ? 12 : 6;
u32 nrm_size = 12;
if (getFmtType(vertex_data.mVtxAttrFmtList, GX_VA_NRM) == GX_F32) {
nrm_size = 12;
} else {
nrm_size = 6;
}
void* nrm_end = NULL;
if (vertex_data.mVtxNBTArray != NULL) {
@@ -310,14 +346,24 @@ void J3DModelLoader::readVertex(J3DVertexBlock const* i_block) {
vertex_data.mColNum = (i_block->mBlockSize - (uintptr_t)i_block->mpVtxColorArray[0]) / 4 + 1;
}
int local_28 = 0;
if (vertex_data.mVtxTexCoordArray[1]) {
color0_end = vertex_data.mVtxTexCoordArray[1];
}
if (vertex_data.mVtxTexCoordArray[0] == NULL) {
vertex_data.mTexCoordNum = 0;
return;
}
if (local_28) {
vertex_data.mTexCoordNum = (local_28 - (uintptr_t)vertex_data.mVtxTexCoordArray[0]) / 8 + 1;
} else {
vertex_data.mTexCoordNum = (i_block->mBlockSize - (uintptr_t)i_block->mpVtxTexCoordArray[0]) / 8 + 1;
}
}
void J3DModelLoader::readEnvelop(J3DEnvelopeBlock const* i_block) {
J3D_ASSERT_NULLPTR(724, i_block);
mpModelData->getJointTree().mWEvlpMtxNum = i_block->mWEvlpMtxNum;
mpModelData->getJointTree().mWEvlpMixMtxNum =
JSUConvertOffsetToPtr<u8>(i_block, i_block->mpWEvlpMixMtxNum);
@@ -330,50 +376,58 @@ void J3DModelLoader::readEnvelop(J3DEnvelopeBlock const* i_block) {
}
void J3DModelLoader::readDraw(J3DDrawBlock const* i_block) {
J3DJointTree& joint_tree = mpModelData->getJointTree();
joint_tree.mDrawMtxData.mEntryNum = i_block->mMtxNum - mpModelData->getJointTree().mWEvlpMtxNum;
joint_tree.mDrawMtxData.mDrawMtxFlag = JSUConvertOffsetToPtr<u8>(i_block, i_block->mpDrawMtxFlag);
joint_tree.mDrawMtxData.mDrawMtxIndex = JSUConvertOffsetToPtr<u16>(i_block, i_block->mpDrawMtxIndex);
J3D_ASSERT_NULLPTR(747, i_block);
J3DDrawMtxData* drawMtxData = mpModelData->getDrawMtxData();
drawMtxData->mEntryNum = i_block->mMtxNum - mpModelData->getWEvlpMtxNum();
drawMtxData->mDrawMtxFlag = JSUConvertOffsetToPtr<u8>(i_block, i_block->mpDrawMtxFlag);
drawMtxData->mDrawMtxIndex = JSUConvertOffsetToPtr<u16>(i_block, i_block->mpDrawMtxIndex);
u16 i;
for (i = 0; i < joint_tree.mDrawMtxData.mEntryNum; i++) {
if (joint_tree.mDrawMtxData.mDrawMtxFlag[i] == 1) {
for (i = 0; i < drawMtxData->mEntryNum; i++) {
if (drawMtxData->mDrawMtxFlag[i] == 1) {
break;
}
}
joint_tree.mDrawMtxData.mDrawFullWgtMtxNum = i;
mpModelData->getJointTree().mWEvlpImportantMtxIdx = new u16[joint_tree.mDrawMtxData.mEntryNum];
drawMtxData->mDrawFullWgtMtxNum = i;
mpModelData->getJointTree().mWEvlpImportantMtxIdx = new u16[drawMtxData->mEntryNum];
J3D_ASSERT_ALLOCMEM(767, mpModelData->getJointTree().mWEvlpImportantMtxIdx);
}
void J3DModelLoader::readJoint(J3DJointBlock const* i_block) {
J3D_ASSERT_NULLPTR(781, i_block);
J3DJointFactory factory(*i_block);
mpModelData->getJointTree().mJointNum = i_block->mJointNum;
if (i_block->mpNameTable != NULL) {
mpModelData->getJointTree().mJointName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(791, mpModelData->getJointTree().mJointName);
} else {
mpModelData->getJointTree().mJointName = NULL;
}
mpModelData->getJointTree().mJointNodePointer =
new J3DJoint*[mpModelData->getJointTree().mJointNum];
for (u16 i = 0; i < mpModelData->getJointTree().getJointNum(); i++) {
J3D_ASSERT_ALLOCMEM(797, mpModelData->getJointTree().mJointNodePointer);
for (u16 i = 0; i < mpModelData->getJointNum(); i++) {
mpModelData->getJointTree().mJointNodePointer[i] = factory.create(i);
}
}
void J3DModelLoader_v26::readMaterial(J3DMaterialBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(817, i_block);
J3DMaterialFactory factory(*i_block);
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
mpMaterialTable->mUniqueMatNum = factory.countUniqueMaterials();
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(832, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(841, mpMaterialTable->mMaterialNodePointer);
if (i_flags & 0x200000) {
mpMaterialTable->field_0x10 = new (0x20) J3DMaterial[mpMaterialTable->mUniqueMatNum];
J3D_ASSERT_ALLOCMEM(846, mpMaterialTable->field_0x10);
} else {
mpMaterialTable->field_0x10 = NULL;
}
@@ -404,18 +458,22 @@ void J3DModelLoader_v26::readMaterial(J3DMaterialBlock const* i_block, u32 i_fla
}
void J3DModelLoader_v21::readMaterial_v21(J3DMaterialBlock_v21 const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(913, i_block);
J3DMaterialFactory_v21 factory(*i_block);
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
mpMaterialTable->mUniqueMatNum = factory.countUniqueMaterials();
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(930, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(940, mpMaterialTable->mMaterialNodePointer);
if (i_flags & 0x200000) {
mpMaterialTable->field_0x10 = new (0x20) J3DMaterial[mpMaterialTable->mUniqueMatNum];
J3D_ASSERT_ALLOCMEM(945, mpMaterialTable->field_0x10);
} else {
mpMaterialTable->field_0x10 = NULL;
}
@@ -443,6 +501,7 @@ void J3DModelLoader_v21::readMaterial_v21(J3DMaterialBlock_v21 const* i_block, u
}
void J3DModelLoader::readShape(J3DShapeBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(1009, i_block);
mpShapeBlock = i_block;
J3DShapeTable* shape_table = mpModelData->getShapeTable();
J3DShapeFactory factory(*i_block);
@@ -450,10 +509,12 @@ void J3DModelLoader::readShape(J3DShapeBlock const* i_block, u32 i_flags) {
if (i_block->mpNameTable != NULL) {
shape_table->mShapeName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1026, shape_table->mShapeName);
} else {
shape_table->mShapeName = NULL;
}
shape_table->mShapeNodePointer = new J3DShape*[shape_table->mShapeNum];
J3D_ASSERT_ALLOCMEM(1034, shape_table->mShapeNodePointer);
factory.allocVcdVatCmdBuffer(shape_table->mShapeNum);
J3DModelHierarchy const* hierarchy_entry = mpModelData->getHierarchy();
GXVtxDescList* vtx_desc_list = NULL;
@@ -467,27 +528,33 @@ void J3DModelLoader::readShape(J3DShapeBlock const* i_block, u32 i_flags) {
}
void J3DModelLoader::readTexture(J3DTextureBlock const* i_block) {
J3D_ASSERT_NULLPTR(1067, i_block);
u16 texture_num = i_block->mTextureNum;
ResTIMG* texture_res = JSUConvertOffsetToPtr<ResTIMG>(i_block, i_block->mpTextureRes);
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mTextureName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1077, mpMaterialTable->mTextureName);
} else {
mpMaterialTable->mTextureName = NULL;
}
mpMaterialTable->mTexture = new J3DTexture(texture_num, texture_res);
J3D_ASSERT_ALLOCMEM(1084, mpMaterialTable->mTexture);
}
void J3DModelLoader_v26::readMaterialTable(J3DMaterialBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(1101, i_block);
J3DMaterialFactory factory(*i_block);
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1114, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(1121, mpMaterialTable->mMaterialNodePointer);
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i] =
factory.create(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, i_flags);
@@ -499,15 +566,18 @@ void J3DModelLoader_v26::readMaterialTable(J3DMaterialBlock const* i_block, u32
}
void J3DModelLoader_v21::readMaterialTable_v21(J3DMaterialBlock_v21 const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(1152, i_block);
J3DMaterialFactory_v21 factory(*i_block);
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1165, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(1172, mpMaterialTable->mMaterialNodePointer);
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i] =
factory.create(NULL, i, i_flags);
@@ -519,28 +589,34 @@ void J3DModelLoader_v21::readMaterialTable_v21(J3DMaterialBlock_v21 const* i_blo
}
void J3DModelLoader::readTextureTable(J3DTextureBlock const* i_block) {
J3D_ASSERT_NULLPTR(1200, i_block);
u16 texture_num = i_block->mTextureNum;
ResTIMG* texture_res = JSUConvertOffsetToPtr<ResTIMG>(i_block, i_block->mpTextureRes);
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mTextureName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1211, mpMaterialTable->mTextureName);
} else {
mpMaterialTable->mTextureName = NULL;
}
mpMaterialTable->mTexture = new J3DTexture(texture_num, texture_res);
J3D_ASSERT_ALLOCMEM(1218, mpMaterialTable->mTexture);
}
void J3DModelLoader::readPatchedMaterial(J3DMaterialBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(1234, i_block);
J3DMaterialFactory factory(*i_block);
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
mpMaterialTable->mUniqueMatNum = factory.countUniqueMaterials();
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1251, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(1260, mpMaterialTable->mMaterialNodePointer);
mpMaterialTable->field_0x10 = NULL;
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i] =
@@ -551,6 +627,7 @@ void J3DModelLoader::readPatchedMaterial(J3DMaterialBlock const* i_block, u32 i_
}
void J3DModelLoader::readMaterialDL(J3DMaterialDLBlock const* i_block, u32 i_flags) {
J3D_ASSERT_NULLPTR(1290, i_block);
J3DMaterialFactory factory(*i_block);
s32 flags;
if (mpMaterialTable->mMaterialNum == 0) {
@@ -560,10 +637,12 @@ void J3DModelLoader::readMaterialDL(J3DMaterialDLBlock const* i_block, u32 i_fla
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
new JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1312, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = new J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(1320, mpMaterialTable->mMaterialNodePointer);
mpMaterialTable->field_0x10 = NULL;
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
flags = i_flags;
src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
+60 -42
View File
@@ -14,24 +14,29 @@
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++)
for (int i = 0; i < header->mBlockNum; i++)
{
if (block->mBlockType == 'MAT3') {
return ((const J3DMaterialBlock*)block)->mMaterialNum;
const J3DMaterialBlock* materialBlock = (const J3DMaterialBlock*)block;
return materialBlock->mMaterialNum;
}
block = (const J3DModelBlock*)((u8*)block + block->mBlockSize);
}
return 0;
}
static void dummy() {
JUT_PANIC(0, "Error : null pointer.");
}
u32 J3DModelLoader::calcLoadSize(void const* stream, u32 flags_) {
int flags = flags_;
const J3DModelFileData* header = static_cast<const J3DModelFileData*>(stream);
size_t size = 0;
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++) {
const J3DModelFileData* header = static_cast<const J3DModelFileData*>(stream);
const J3DModelBlock* nextBlock = header->mBlocks;
for (u32 i = 0; i < header->mBlockNum; i++) {
switch (nextBlock->mBlockType) {
case 'INF1':
size += calcSizeInformation((const J3DModelInfoBlock*)nextBlock, flags);
@@ -39,8 +44,6 @@ u32 J3DModelLoader::calcLoadSize(void const* stream, u32 flags_) {
case 'JNT1':
size += calcSizeJoint((const J3DJointBlock*)nextBlock);
break;
case 'MAT2':
break;
case 'MAT3':
size += calcSizeMaterial((const J3DMaterialBlock*)nextBlock, flags);
break;
@@ -58,6 +61,9 @@ u32 J3DModelLoader::calcLoadSize(void const* stream, u32 flags_) {
break;
case 'VTX1':
break;
case 'MAT2':
JUT_PANIC(282, "Error : version error.");
break;
default:
OSReport("Unknown data block\n");
break;
@@ -68,30 +74,27 @@ u32 J3DModelLoader::calcLoadSize(void const* stream, u32 flags_) {
}
u32 J3DModelLoader::calcLoadMaterialTableSize(const void* stream) {
size_t size;
u32 flags = J3DMLF_21 | J3DMLF_Material_UseIndirect | J3DMLF_Material_PE_Full | J3DMLF_Material_Color_LightOn;
size_t size = 0;
// TODO: What sizeof will get us a size of 0x20? Is this just the file header???
size += 0x20;
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++) {
for (u32 i = 0; 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);
size += calcSizeMaterialTable((const J3DMaterialBlock*)nextBlock, flags);
break;
case 'TEX1':
size += calcSizeTextureTable((const J3DTextureBlock*)nextBlock);
hasTextureTable = true;
break;
case 'MAT2':
JUT_PANIC(334, "Error : version error.");
break;
default:
OSReport("Unknown data block\n");
break;
@@ -132,8 +135,6 @@ u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* stream, u32 flags)
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 |= (u32)flags & (J3DMLF_Material_UseIndirect | J3DMLF_26);
@@ -156,6 +157,9 @@ u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* stream, u32 flags)
break;
case 'VTX1':
break;
case 'MAT2':
JUT_PANIC(436, "Error : version error.");
break;
default:
OSReport("Unknown data block\n");
break;
@@ -166,18 +170,22 @@ u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* stream, u32 flags)
}
u32 J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock* block, u32 flags) {
J3D_ASSERT_NULLPTR(462, block);
int size = 0;
switch ((flags | block->mFlags) & J3DMLF_MtxTypeMask) {
u32 flags2 = flags | block->mFlags;
int r27 = 0;
switch (flags2 & J3DMLF_MtxTypeMask) {
case J3DMLF_None: // Basic
size = 4;
size += 4;
break;
case J3DMLF_MtxSoftImageCalc:
size = 4;
size += 4;
break;
case J3DMLF_MtxMayaCalc:
size = 4;
size += 4;
break;
default:
JUT_PANIC(481, "Error : Invalid MtxCalcType.");
break;
}
mpModelHierarchy = JSUConvertOffsetToPtr<J3DModelHierarchy>(block, block->mpHierarchy);
@@ -185,9 +193,10 @@ u32 J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock* block, u32 flag
}
u32 J3DModelLoader::calcSizeJoint(const J3DJointBlock* block) {
J3D_ASSERT_NULLPTR(499, block);
int size = 0;
if (block->mpNameTable) {
size = 0x10;
size += 0x10;
}
size += (block->mJointNum * sizeof(J3DJoint*));
size += (block->mJointNum * sizeof(J3DJoint));
@@ -195,23 +204,28 @@ u32 J3DModelLoader::calcSizeJoint(const J3DJointBlock* block) {
}
u32 J3DModelLoader::calcSizeEnvelope(const J3DEnvelopeBlock* block) {
J3D_ASSERT_NULLPTR(522, block);
mEnvelopeSize = block->mWEvlpMtxNum;
return 0;
}
u32 J3DModelLoader::calcSizeDraw(const J3DDrawBlock* block) {
return (block->mMtxNum - mEnvelopeSize) * 2;
J3D_ASSERT_NULLPTR(538, block);
u32 size = 0;
size += (block->mMtxNum - mEnvelopeSize) * 2;
return size;
}
u32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock* block, u32 flags) {
int padding = 0;
J3D_ASSERT_NULLPTR(558, block);
size_t size = 0;
J3DMaterialFactory factory(*block);
u32 count = block->mMaterialNum;
int uniqueCount = factory.countUniqueMaterials();
if (block->mpNameTable != NULL) {
padding = 0x10;
size += 0x10;
}
size_t size = padding + (count * sizeof(J3DMaterial*));
size += (count * sizeof(J3DMaterial*));
if ((flags & J3DMLF_UseUniqueMaterials) != 0) {
// calc for allocated materials as well
@@ -229,15 +243,17 @@ u32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock* block, u32 flag
}
u32 J3DModelLoader::calcSizeShape(const J3DShapeBlock* block, u32 flags) {
J3D_ASSERT_NULLPTR(616, block);
int size = 0;
J3DShapeFactory factory(*block);
int count = block->mShapeNum;
if (block->mpNameTable) {
size = 0x10;
size += 0x10;
}
size += count * sizeof(J3DShape*);
size += factory.calcSizeVcdVatCmdBuffer(count);
for (J3DModelHierarchy* hierarchy = mpModelHierarchy; hierarchy->mType != 0; hierarchy++) {
J3DModelHierarchy* hierarchy;
for (hierarchy = mpModelHierarchy; hierarchy->mType != 0; hierarchy++) {
if (hierarchy->mType == 0x12) {
size += factory.calcSize(hierarchy->mValue, flags);
}
@@ -246,12 +262,14 @@ u32 J3DModelLoader::calcSizeShape(const J3DShapeBlock* block, u32 flags) {
}
u32 J3DModelLoader::calcSizeTexture(const J3DTextureBlock* block) {
J3D_ASSERT_NULLPTR(663, block);
// TODO: use sizeofs here.
int padding = 0;
int size = 0;
if (block->mpNameTable) {
padding = 0x10;
size += 0x10;
}
return padding + 0xC;
size += 0xC;
return size;
}
u32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock* block, u32 flags) {
@@ -259,7 +277,7 @@ u32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock* block, u32
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
size = 0x10;
size += 0x10;
}
size += (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
@@ -273,13 +291,13 @@ u32 J3DModelLoader::calcSizeTextureTable(const J3DTextureBlock* block) {
}
u32 J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock* block, u32 flags) {
int padding = 0;
int size = 0;
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
padding = 0x10;
size += 0x10;
}
u32 size = padding + (count * sizeof(J3DMaterial*));
size += (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_PATCHED, i, flags);
}
@@ -287,14 +305,14 @@ u32 J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock* block, u32 f
}
u32 J3DModelLoader::calcSizeMaterialDL(const J3DMaterialDLBlock* block, u32 flags_) {
J3D_ASSERT_NULLPTR(758, block);
int flags = flags_;
size_t size = 0;
J3DMaterialFactory factory(*block);
;
if (!field_0x18) {
u32 count = block->mMaterialNum;
if (block->mpNameTable) {
size = 0x10;
size += 0x10;
}
size += count * sizeof(J3DLockedMaterial*);
for (u16 i = 0; i < count; i++) {
src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp
+27 -16
View File
@@ -11,21 +11,24 @@
J3DShapeFactory::J3DShapeFactory(J3DShapeBlock const& block) {
mShapeInitData = JSUConvertOffsetToPtr<J3DShapeInitData>(&block, (uintptr_t)block.mpShapeInitData);
mIndexTable = JSUConvertOffsetToPtr<u16>(&block, (uintptr_t)block.mpIndexTable);
mVtxDescList = JSUConvertOffsetToPtr<GXVtxDescList>(&block, (uintptr_t)block.mpVtxDescList),
mVtxDescList = JSUConvertOffsetToPtr<GXVtxDescList>(&block, (uintptr_t)block.mpVtxDescList);
mMtxTable = JSUConvertOffsetToPtr<u16>(&block, (uintptr_t)block.mpMtxTable);
mDisplayListData = JSUConvertOffsetToPtr<u8>(&block, (uintptr_t)block.mpDisplayListData),
mMtxInitData = JSUConvertOffsetToPtr<J3DShapeMtxInitData>(&block, (uintptr_t)block.mpMtxInitData),
mDrawInitData = JSUConvertOffsetToPtr<J3DShapeDrawInitData>(&block, (uintptr_t)block.mpDrawInitData),
mDisplayListData = JSUConvertOffsetToPtr<u8>(&block, (uintptr_t)block.mpDisplayListData);
mMtxInitData = JSUConvertOffsetToPtr<J3DShapeMtxInitData>(&block, (uintptr_t)block.mpMtxInitData);
mDrawInitData = JSUConvertOffsetToPtr<J3DShapeDrawInitData>(&block, (uintptr_t)block.mpDrawInitData);
mVcdVatCmdBuffer = NULL;
}
J3DShape* J3DShapeFactory::create(int no, u32 flag, GXVtxDescList* vtxDesc) {
J3DShape* shape = new J3DShape;
J3D_ASSERT_ALLOCMEM(67, shape);
shape->mMtxGroupNum = getMtxGroupNum(no);
shape->mRadius = getRadius(no);
shape->mVtxDesc = getVtxDescList(no);
shape->mShapeMtx = new J3DShapeMtx*[shape->mMtxGroupNum];
J3D_ASSERT_ALLOCMEM(74, shape->mShapeMtx);
shape->mShapeDraw = new J3DShapeDraw*[shape->mMtxGroupNum];
J3D_ASSERT_ALLOCMEM(76, shape->mShapeDraw);
shape->mMin = getMin(no);
shape->mMax = getMax(no);
shape->mVcdVatCmd = mVcdVatCmdBuffer + no * J3DShape::kVcdVatDLSize;
@@ -56,7 +59,8 @@ J3DShapeMtx* J3DShapeFactory::newShapeMtx(u32 flag, int shapeNo, int mtxGroupNo)
const J3DShapeMtxInitData& mtxInitData =
(&mMtxInitData[shapeInitData.mMtxInitDataIndex])[mtxGroupNo];
switch (getMdlDataFlag_MtxLoadType(flag)) {
u32 mtxLoadType = getMdlDataFlag_MtxLoadType(flag);
switch (mtxLoadType) {
case J3DMdlDataFlag_ConcatView:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
@@ -94,36 +98,41 @@ J3DShapeMtx* J3DShapeFactory::newShapeMtx(u32 flag, int shapeNo, int mtxGroupNo)
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");
break;
}
break;
}
J3D_ASSERT_ALLOCMEM(167, ret);
return ret;
}
J3DShapeDraw* J3DShapeFactory::newShapeDraw(int shapeNo, int mtxGroupNo) const {
J3DShapeDraw* shapeDraw = NULL;
const J3DShapeInitData& shapeInitData = mShapeInitData[mIndexTable[shapeNo]];
const J3DShapeDrawInitData& drawInitData =
(&mDrawInitData[shapeInitData.mDrawInitDataIndex])[mtxGroupNo];
return new J3DShapeDraw(&mDisplayListData[drawInitData.mDisplayListIndex],
drawInitData.mDisplayListSize);
shapeDraw = new J3DShapeDraw(&mDisplayListData[drawInitData.mDisplayListIndex], drawInitData.mDisplayListSize);
J3D_ASSERT_ALLOCMEM(193, shapeDraw);
return shapeDraw;
}
void J3DShapeFactory::allocVcdVatCmdBuffer(u32 count) {
mVcdVatCmdBuffer = new (0x20) u8[J3DShape::kVcdVatDLSize * count];
J3D_ASSERT_ALLOCMEM(211, mVcdVatCmdBuffer);
for (u32 i = 0; i < (J3DShape::kVcdVatDLSize * count) / 4; i++)
((u32*)mVcdVatCmdBuffer)[i] = 0;
}
s32 J3DShapeFactory::calcSize(int shapeNo, u32 flag) {
s32 size = 0x68;
s32 size = 0;
s32 mtxGroupNo = getMtxGroupNum(shapeNo);
size += sizeof(J3DShape);
size += mtxGroupNo * 4;
size += mtxGroupNo * 4;
for (u32 i = 0; i < mtxGroupNo; i++) {
s32 shapeMtxSize = calcSizeShapeMtx(flag, shapeNo, i);
size += shapeMtxSize;
size += calcSizeShapeMtx(flag, shapeNo, i);
size += 0x0C;
}
@@ -135,7 +144,9 @@ s32 J3DShapeFactory::calcSizeVcdVatCmdBuffer(u32 count) {
}
s32 J3DShapeFactory::calcSizeShapeMtx(u32 flag, int shapeNo, int mtxGroupNo) const {
int local_18 = 0;
const J3DShapeInitData& shapeInitData = mShapeInitData[mIndexTable[shapeNo]];
J3DShapeMtxInitData& mtxInitData = (&mMtxInitData[shapeInitData.mMtxInitDataIndex])[mtxGroupNo];
u32 ret = 0;
u32 mtxLoadType = getMdlDataFlag_MtxLoadType(flag);
@@ -143,16 +154,16 @@ s32 J3DShapeFactory::calcSizeShapeMtx(u32 flag, int shapeNo, int mtxGroupNo) con
case J3DMdlDataFlag_ConcatView:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
ret = 0x08;
ret += sizeof(J3DShapeMtxConcatView);
break;
case J3DShapeMtxType_BBoard:
ret = 0x08;
ret += sizeof(J3DShapeMtxBBoardConcatView);
break;
case J3DShapeMtxType_YBBoard:
ret = 0x08;
ret += sizeof(J3DShapeMtxYBBoardConcatView);
break;
case J3DShapeMtxType_Multi:
ret = 0x10;
ret += sizeof(J3DShapeMtxMultiConcatView);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");
@@ -165,10 +176,10 @@ s32 J3DShapeFactory::calcSizeShapeMtx(u32 flag, int shapeNo, int mtxGroupNo) con
case J3DShapeMtxType_Mtx:
case J3DShapeMtxType_BBoard:
case J3DShapeMtxType_YBBoard:
ret = 0x08;
ret += 0x08;
break;
case J3DShapeMtxType_Multi:
ret = 0x10;
ret += sizeof(J3DShapeMtxMultiConcatView);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");