summaryrefslogtreecommitdiff
path: root/src/JSystem/J3DGraphLoader
diff options
context:
space:
mode:
Diffstat (limited to 'src/JSystem/J3DGraphLoader')
-rw-r--r--src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp126
-rw-r--r--src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp13
-rw-r--r--src/JSystem/J3DGraphLoader/J3DJointFactory.cpp1
-rw-r--r--src/JSystem/J3DGraphLoader/J3DModelLoader.cpp143
-rw-r--r--src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp102
-rw-r--r--src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp43
6 files changed, 297 insertions, 131 deletions
diff --git a/src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp b/src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp
index 9a1149c4be..8add976ec4 100644
--- a/src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DAnmLoader.cpp
@@ -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;
diff --git a/src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp b/src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp
index b6afb156b9..03a0e66213 100644
--- a/src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DClusterLoader.cpp
@@ -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];
diff --git a/src/JSystem/J3DGraphLoader/J3DJointFactory.cpp b/src/JSystem/J3DGraphLoader/J3DJointFactory.cpp
index 0a93c6626d..dafc4ce417 100644
--- a/src/JSystem/J3DGraphLoader/J3DJointFactory.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DJointFactory.cpp
@@ -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);
diff --git a/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp b/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
index b05a5a9148..68622ff346 100644
--- a/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DModelLoader.cpp
@@ -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;
diff --git a/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp b/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
index d3754ad8b4..5957fcc642 100644
--- a/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
@@ -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++) {
diff --git a/src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp b/src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp
index 8048b12bf8..d724d7cb8e 100644
--- a/src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp
+++ b/src/JSystem/J3DGraphLoader/J3DShapeFactory.cpp
@@ -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");
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-03 22:45:43 +0000