mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-07-10 12:54:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into 26-02-27-allocator-isolation

Browse Source
This commit is contained in:
PJB3005
2026-03-05 00:15:09 +01:00
parent 038ef4216f 3c6552dbd2
commit 3ffc3266d7
5530 changed files with 252979 additions and 26830 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/src/J3DGraphLoader/J3DAnmLoader.cpp
+711
View File
@@ -0,0 +1,711 @@
//
// J3DAnmLoader
//
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DAnmLoader.h"
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
#include "JSystem/JSupport/JSupport.h"
#include <os.h>
#include "JSystem/JKernel/JKRHeap.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;
}
if (header->mMagic == 'J3D1') {
switch (header->mType) {
case 'bck1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmTransformKey();
return loader.load(i_data);
}
case 'bpk1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmColorKey();
return loader.load(i_data);
}
case 'blk1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmClusterKey();
return loader.load(i_data);
}
case 'btk1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmTextureSRTKey();
return loader.load(i_data);
}
case 'brk1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmTevRegKey();
return loader.load(i_data);
}
case 'bxk1': {
J3DAnmKeyLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmVtxColorKey();
return loader.load(i_data);
}
case 'bca1': {
J3DAnmFullLoader_v15 loader;
if (flag & J3DLOADER_UNK_FLAG1) {
loader.mAnm = JKR_NEW J3DAnmTransformFullWithLerp();
} else {
loader.mAnm = JKR_NEW J3DAnmTransformFull();
}
return loader.load(i_data);
}
case 'bpa1': {
J3DAnmFullLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmColorFull();
return loader.load(i_data);
}
case 'btp1': {
J3DAnmFullLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmTexPattern();
return loader.load(i_data);
}
case 'bva1': {
J3DAnmFullLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmVisibilityFull();
return loader.load(i_data);
}
case 'bla1': {
J3DAnmFullLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmClusterFull();
return loader.load(i_data);
}
case 'bxa1': {
J3DAnmFullLoader_v15 loader;
loader.mAnm = JKR_NEW J3DAnmVtxColorFull();
return loader.load(i_data);
}
default:
OSReport("J3DAnmLoader: this is not a J3D Binary.\n");
return NULL;
}
}
return NULL;
}
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') {
return;
}
switch (header->mType) {
case 'bck1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bpk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'blk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'btk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'brk1': {
J3DAnmKeyLoader_v15 loader;
if (param_1->getKind() == 5) {
loader.setResource(param_1, i_data);
}
break;
}
case 'bxk1': {
J3DAnmKeyLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bca1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bpa1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'btp1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bla1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bxa1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
case 'bva1': {
J3DAnmFullLoader_v15 loader;
loader.setResource(param_1, i_data);
break;
}
default: {
OSReport("J3DAnmLoader: this is not a J3D Binary.\n");
break;
}
}
}
J3DAnmFullLoader_v15::J3DAnmFullLoader_v15() {}
J3DAnmFullLoader_v15::~J3DAnmFullLoader_v15() {}
J3DAnmKeyLoader_v15::J3DAnmKeyLoader_v15() {}
J3DAnmKeyLoader_v15::~J3DAnmKeyLoader_v15() {}
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) {
case 'ANF1':
readAnmTransform((J3DAnmTransformFullData*)block);
break;
case 'PAF1':
readAnmColor((J3DAnmColorFullData*)block);
break;
case 'TPT1':
readAnmTexPattern((J3DAnmTexPatternFullData*)block);
break;
case 'CLF1':
readAnmCluster((J3DAnmClusterFullData*)block);
break;
case 'VAF1':
readAnmVisibility((J3DAnmVisibilityFullData*)block);
break;
case 'VCF1':
readAnmVtxColor((J3DAnmVtxColorFullData*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
block = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
return mAnm;
}
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 = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
}
void J3DAnmFullLoader_v15::readAnmTransform(const J3DAnmTransformFullData* 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;
param_1->mFrame = 0.0f;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTransformFullTable>(param_2, param_2->mTableOffset);
param_1->mScaleData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mScaleValOffset);
param_1->mRotData = JSUConvertOffsetToPtr<s16>(param_2, param_2->mRotValOffset);
param_1->mTransData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mTransValOffset);
}
void J3DAnmFullLoader_v15::readAnmColor(const J3DAnmColorFullData* 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;
param_1->mUpdateMaterialNum = param_2->mUpdateMaterialNum;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(param_2, param_2->mTableOffset);
param_1->mColorR = JSUConvertOffsetToPtr<u8>(param_2, param_2->mRValuesOffset);
param_1->mColorG = JSUConvertOffsetToPtr<u8>(param_2, param_2->mGValuesOffset);
param_1->mColorB = JSUConvertOffsetToPtr<u8>(param_2, param_2->mBValuesOffset);
param_1->mColorA = JSUConvertOffsetToPtr<u8>(param_2, param_2->mAValuesOffset);
param_1->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mUpdateMaterialIDOffset);
param_1->mUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mNameTabOffset));
}
void J3DAnmFullLoader_v15::readAnmTexPattern(const J3DAnmTexPatternFullData* 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;
param_1->mUpdateMaterialNum = param_2->field_0xc;
param_1->field_0x14 = param_2->field_0xe;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTexPatternFullTable>(param_2, param_2->mTableOffset);
param_1->mTextureIndex = JSUConvertOffsetToPtr<u16>(param_2, param_2->mValuesOffset);
param_1->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mUpdateMaterialIDOffset);
param_1->mUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mNameTabOffset));
}
void J3DAnmFullLoader_v15::readAnmVisibility(const J3DAnmVisibilityFullData* 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;
param_1->mUpdateMaterialNum = param_2->field_0xc;
param_1->field_0xe = param_2->field_0xe;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmVisibilityFullTable>(param_2, param_2->mTableOffset);
param_1->mVisibility = JSUConvertOffsetToPtr<u8>(param_2, param_2->mValuesOffset);
}
void J3DAnmFullLoader_v15::readAnmCluster(const J3DAnmClusterFullData* 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;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmClusterFullTable>(param_2, param_2->mTableOffset);
param_1->mWeight = JSUConvertOffsetToPtr<f32>(param_2, param_2->mWeightOffset);
}
void J3DAnmFullLoader_v15::readAnmVtxColor(const J3DAnmVtxColorFullData* 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;
dst->mAnmTableNum[0] = data->mAnmTableNum[0];
dst->mAnmTableNum[1] = data->mAnmTableNum[1];
dst->mpTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(data, data->mTableOffsets[0]);
dst->mpTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorFullTable>(data, data->mTableOffsets[1]);
dst->mAnmVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
data, data->mVtxColorIndexDataOffsets[0]);
dst->mAnmVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
data, data->mVtxColorIndexDataOffsets[1]);
u16* indexPtr0 =
JSUConvertOffsetToPtr<u16>(data, data->mVtxColorIndexPointerOffsets[0]);
u16* indexPtr1 =
JSUConvertOffsetToPtr<u16>(data, data->mVtxColorIndexPointerOffsets[1]);
#if TARGET_PC
dst->colorAddressBase[0] = indexPtr0;
dst->colorAddressBase[1] = indexPtr1;
#else
for (s32 i = 0; i < dst->mAnmTableNum[0]; i++)
dst->mAnmVtxColorIndexData[0][i].mpData =
(void*)((s32)indexPtr0 + (s32)dst->mAnmVtxColorIndexData[0][i].mpData * 2);
for (s32 i = 0; i < dst->mAnmTableNum[1]; i++)
dst->mAnmVtxColorIndexData[1][i].mpData =
(void*)((s32)indexPtr1 + (s32)dst->mAnmVtxColorIndexData[1][i].mpData * 2);
#endif
dst->mColorR = JSUConvertOffsetToPtr<u8>(data, data->mRValuesOffset);
dst->mColorG = JSUConvertOffsetToPtr<u8>(data, data->mGValuesOffset);
dst->mColorB = JSUConvertOffsetToPtr<u8>(data, data->mBValuesOffset);
dst->mColorA = JSUConvertOffsetToPtr<u8>(data, data->mAValuesOffset);
}
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++) {
switch (block->mType) {
case 'ANK1':
readAnmTransform((J3DAnmTransformKeyData*)block);
break;
case 'PAK1':
readAnmColor((J3DAnmColorKeyData*)block);
break;
case 'CLK1':
readAnmCluster((J3DAnmClusterKeyData*)block);
break;
case 'TTK1':
readAnmTextureSRT((J3DAnmTextureSRTKeyData*)block);
break;
case 'TRK1':
readAnmTevReg((J3DAnmTevRegKeyData*)block);
break;
case 'VCK1':
readAnmVtxColor((J3DAnmVtxColorKeyData*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
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 = (JUTDataBlockHeader*)((u8*)block + block->mSize);
}
}
void J3DAnmKeyLoader_v15::readAnmTransform(const J3DAnmTransformKeyData* param_1) {
J3DAnmTransformKey* anm = (J3DAnmTransformKey*)mAnm;
setAnmTransform(anm, param_1);
}
#if TARGET_LITTLE_ENDIAN
static void ByteSwapTransformKeyData(
J3DAnmTransformKey& target,
const J3DAnmTransformKeyData& source) {
for (int i = 0; i < source.mSCount; i += 1) {
be_swap(target.mScaleData[i]);
}
for (int i = 0; i < source.mRCount; i += 1) {
be_swap(target.mRotData[i]);
}
for (int i = 0; i < source.mTCount; i += 1) {
be_swap(target.mTransData[i]);
}
}
#endif
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->mJointAnimationTableCount;
param_1->mFrameMax = param_2->mFrameMax;
param_1->mAttribute = param_2->mLoopMode;
param_1->mDecShift = param_2->mRotationDecimal;
param_1->mFrame = 0.0f;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(param_2, param_2->mJointAnimationTableOffs);
param_1->mScaleData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mSTableOffs);
param_1->mRotData = JSUConvertOffsetToPtr<s16>(param_2, param_2->mRTableOffs);
param_1->mTransData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mTTableOffs);
#if TARGET_LITTLE_ENDIAN
ByteSwapTransformKeyData(*param_1, *param_2);
#endif
}
void J3DAnmKeyLoader_v15::readAnmTextureSRT(const J3DAnmTextureSRTKeyData* 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;
param_1->mDecShift = param_2->field_0x9;
param_1->mFrame = 0.0f;
param_1->mTrackNum = param_2->field_0xc;
param_1->mScaleNum = param_2->field_0xe;
param_1->mRotNum = param_2->field_0x10;
param_1->mTransNum = param_2->field_0x12;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(param_2, param_2->mTableOffset);
param_1->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mUpdateMatIDOffset);
param_1->mUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mNameTab1Offset));
param_1->mUpdateTexMtxID =
JSUConvertOffsetToPtr<u8>(param_2, param_2->mUpdateTexMtxIDOffset);
param_1->mSRTCenter = JSUConvertOffsetToPtr<Vec>(param_2, param_2->unkOffset);
param_1->mScaleData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mScaleValOffset);
param_1->mRotData = JSUConvertOffsetToPtr<s16>(param_2, param_2->mRotValOffset);
param_1->mTransData = JSUConvertOffsetToPtr<f32>(param_2, param_2->mTransValOffset);
if (param_2->mNameTab2Offset) {
param_1->mPostUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mNameTab2Offset));
}
param_1->field_0x4a = param_2->field_0x34;
param_1->field_0x44 = param_2->field_0x36;
param_1->field_0x46 = param_2->field_0x38;
param_1->field_0x48 = param_2->field_0x3a;
param_1->field_0x58 =
JSUConvertOffsetToPtr<J3DAnmTransformKeyTable>(param_2, param_2->mInfoTable2Offset);
param_1->mPostUpdateMaterialID = JSUConvertOffsetToPtr<u16>(param_2, param_2->field_0x40);
param_1->mPostUpdateTexMtxID = JSUConvertOffsetToPtr<u8>(param_2, param_2->field_0x48);
param_1->mPostSRTCenter = JSUConvertOffsetToPtr<Vec>(param_2, param_2->field_0x4c);
param_1->field_0x4c = JSUConvertOffsetToPtr<f32>(param_2, param_2->field_0x50);
param_1->field_0x50 = JSUConvertOffsetToPtr<s16>(param_2, param_2->field_0x54);
param_1->field_0x54 = JSUConvertOffsetToPtr<f32>(param_2, param_2->field_0x58);
switch (param_2->field_0x5c) {
case 0:
case 1:
param_1->mTexMtxCalcType = param_2->field_0x5c;
break;
default:
param_1->mTexMtxCalcType = 0;
break;
}
}
void J3DAnmKeyLoader_v15::readAnmColor(const J3DAnmColorKeyData* 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;
param_1->mUpdateMaterialNum = param_2->mUpdateMaterialNum;
param_1->field_0xc = param_2->field_0x10;
param_1->field_0xe = param_2->field_0x12;
param_1->field_0x10 = param_2->field_0x14;
param_1->field_0x12 = param_2->field_0x16;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(param_2, param_2->mTableOffset);
param_1->mColorR = JSUConvertOffsetToPtr<s16>(param_2, param_2->mRValOffset);
param_1->mColorG = JSUConvertOffsetToPtr<s16>(param_2, param_2->mGValOffset);
param_1->mColorB = JSUConvertOffsetToPtr<s16>(param_2, param_2->mBValOffset);
param_1->mColorA = JSUConvertOffsetToPtr<s16>(param_2, param_2->mAValOffset);
param_1->mUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mUpdateMaterialIDOffset);
param_1->mUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mNameTabOffset));
}
void J3DAnmKeyLoader_v15::readAnmCluster(const J3DAnmClusterKeyData* 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;
param_1->mAnmTable =
JSUConvertOffsetToPtr<J3DAnmClusterKeyTable>(param_2, param_2->mTableOffset);
param_1->mWeight = JSUConvertOffsetToPtr<f32>(param_2, param_2->mWeightOffset);
}
void J3DAnmKeyLoader_v15::readAnmTevReg(const J3DAnmTevRegKeyData* 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;
param_1->mCRegUpdateMaterialNum = param_2->mCRegUpdateMaterialNum;
param_1->mAnmCRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmCRegKeyTable>(param_2, param_2->mCRegTableOffset);
param_1->mCRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mCRegUpdateMaterialIDOffset);
param_1->mCRegUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mCRegNameTabOffset));
param_1->mKRegUpdateMaterialNum = param_2->mKRegUpdateMaterialNum;
param_1->mAnmKRegKeyTable =
JSUConvertOffsetToPtr<J3DAnmKRegKeyTable>(param_2, param_2->mKRegTableOffset);
param_1->mKRegUpdateMaterialID =
JSUConvertOffsetToPtr<u16>(param_2, param_2->mKRegUpdateMaterialIDOffset);
param_1->mKRegUpdateMaterialName.setResource(
JSUConvertOffsetToPtr<ResNTAB>(param_2, param_2->mKRegNameTabOffset));
param_1->mCRegDataCountR = param_2->field_0x10;
param_1->mCRegDataCountG = param_2->field_0x12;
param_1->mCRegDataCountB = param_2->field_0x14;
param_1->mCRegDataCountA = param_2->field_0x16;
param_1->mAnmCRegDataR = JSUConvertOffsetToPtr<s16>(param_2, param_2->mCRValuesOffset);
param_1->mAnmCRegDataG = JSUConvertOffsetToPtr<s16>(param_2, param_2->mCGValuesOffset);
param_1->mAnmCRegDataB = JSUConvertOffsetToPtr<s16>(param_2, param_2->mCBValuesOffset);
param_1->mAnmCRegDataA = JSUConvertOffsetToPtr<s16>(param_2, param_2->mCAValuesOffset);
param_1->mKRegDataCountR = param_2->field_0x18;
param_1->mKRegDataCountG = param_2->field_0x1a;
param_1->mKRegDataCountB = param_2->field_0x1c;
param_1->mKRegDataCountA = param_2->field_0x1e;
param_1->mAnmKRegDataR = JSUConvertOffsetToPtr<s16>(param_2, param_2->mKRValuesOffset);
param_1->mAnmKRegDataG = JSUConvertOffsetToPtr<s16>(param_2, param_2->mKGValuesOffset);
param_1->mAnmKRegDataB = JSUConvertOffsetToPtr<s16>(param_2, param_2->mKBValuesOffset);
param_1->mAnmKRegDataA = JSUConvertOffsetToPtr<s16>(param_2, param_2->mKAValuesOffset);
}
void J3DAnmKeyLoader_v15::readAnmVtxColor(const J3DAnmVtxColorKeyData* 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;
dst->mAnmTableNum[0] = data->mAnmTableNum[0];
dst->mAnmTableNum[1] = data->mAnmTableNum[1];
dst->mpTable[0] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(data, data->mTableOffsets[0]);
dst->mpTable[1] =
JSUConvertOffsetToPtr<J3DAnmColorKeyTable>(data, data->mTableOffsets[1]);
dst->mAnmVtxColorIndexData[0] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
data, data->mVtxColoIndexDataOffset[0]);
dst->mAnmVtxColorIndexData[1] = JSUConvertOffsetToPtr<J3DAnmVtxColorIndexData>(
data, data->mVtxColoIndexDataOffset[1]);
u16* indexPtr0 = JSUConvertOffsetToPtr<u16>(data, data->mVtxColoIndexPointerOffset[0]);
u16* indexPtr1 = JSUConvertOffsetToPtr<u16>(data, data->mVtxColoIndexPointerOffset[1]);
#if TARGET_PC
dst->colorAddressBase[0] = indexPtr0;
dst->colorAddressBase[1] = indexPtr1;
#else
for (s32 i = 0; i < dst->mAnmTableNum[0]; i++)
dst->mAnmVtxColorIndexData[0][i].mpData =
(void*)((s32)indexPtr0 + (s32)dst->mAnmVtxColorIndexData[0][i].mpData * 2);
for (s32 i = 0; i < dst->mAnmTableNum[1]; i++)
dst->mAnmVtxColorIndexData[1][i].mpData =
(void*)((s32)indexPtr1 + (s32)dst->mAnmVtxColorIndexData[1][i].mpData * 2);
#endif
dst->mColorR = JSUConvertOffsetToPtr<s16>(data, data->mRValOffset);
dst->mColorG = JSUConvertOffsetToPtr<s16>(data, data->mGValOffset);
dst->mColorB = JSUConvertOffsetToPtr<s16>(data, data->mBValOffset);
dst->mColorA = JSUConvertOffsetToPtr<s16>(data, data->mAValOffset);
}
libs/JSystem/src/J3DGraphLoader/J3DClusterLoader.cpp
+129
View File
@@ -0,0 +1,129 @@
//
// J3DClusterLoader
//
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DClusterLoader.h"
#include "JSystem/J3DGraphAnimator/J3DSkinDeform.h"
#include "JSystem/JSupport/JSupport.h"
#include "JSystem/JKernel/JKRHeap.h"
#include <os.h>
#include <cstring>
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;
return loader.load(i_data);
} else if (fileHeader->mMagic == 'J3D2' && fileHeader->mType == 'bls2') {
return NULL;
}
return NULL;
}
J3DClusterLoader_v15::J3DClusterLoader_v15() {}
J3DClusterLoader_v15::~J3DClusterLoader_v15() {}
void* J3DClusterLoader_v15::load(const void* i_data) {
J3D_ASSERT_NULLPTR(98, i_data);
mpDeformData = JKR_NEW J3DDeformData();
const JUTDataFileHeader* fileHeader = (JUTDataFileHeader*)i_data;
const JUTDataBlockHeader* block = &fileHeader->mFirstBlock;
for (int i = 0; i < fileHeader->mBlockNum; i++) {
switch (block->mType) {
case 'CLS1':
readCluster((J3DClusterBlock*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
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;
mpDeformData->mVtxNrmNum = block->mVtxNrmNum;
mpDeformData->mClusterVertexNum = block->mClusterVertexNum;
if (block->mClusterName != NULL) {
mpDeformData->mClusterName =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(block, block->mClusterName));
} else {
mpDeformData->mClusterName = NULL;
}
if (block->mClusterKeyName != NULL) {
mpDeformData->mClusterKeyName =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(block, block->mClusterKeyName));
} else {
mpDeformData->mClusterKeyName = NULL;
}
mpDeformData->mVtxPos = JSUConvertOffsetToPtr<f32>(block, block->mVtxPos);
mpDeformData->mVtxNrm = JSUConvertOffsetToPtr<f32>(block, block->mVtxNrm);
intptr_t clusterPointer = (intptr_t) block->mClusterPointer;
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 = JKR_NEW_ARGS (0x20) u8[vtxPosSize];
memcpy(arr, JSUConvertOffsetToPtr<J3DCluster>(block, block->mClusterPointer), vtxPosSize);
mpDeformData->mClusterPointer = (J3DCluster*)arr;
mpDeformData->mClusterKeyPointer = (J3DClusterKey*)&arr[clusterKeyPointerSize];
mpDeformData->mClusterVertex = (J3DClusterVertex*)&arr[clusterVertexPointerSize];
#if TARGET_PC
mpDeformData->mDeformers = JKR_NEW J3DDeformer*[mpDeformData->getClusterNum()];
#endif
for (int i = 0; i < mpDeformData->getClusterNum(); i++) {
J3DCluster* cluster = &mpDeformData->mClusterPointer[i];
#if !TARGET_PC
cluster->mClusterKey = JSUConvertOffsetToPtr<J3DClusterKey>(arr - (intptr_t)clusterPointer, cluster->mClusterKey);
cluster->field_0x18 = JSUConvertOffsetToPtr<u16>(block, cluster->field_0x18);
cluster->mClusterVertex =
JSUConvertOffsetToPtr<J3DClusterVertex>(arr - (intptr_t)clusterPointer, cluster->mClusterVertex);
#endif
J3DDeformer* deformer = JKR_NEW J3DDeformer(mpDeformData);
if (cluster->field_0x14 != 0) {
deformer->field_0xc = JKR_NEW f32[cluster->field_0x14 * 3];
} else {
deformer->field_0xc = NULL;
}
deformer->mFlags = cluster->mFlags;
deformer->field_0x8 = JKR_NEW f32[cluster->mKeyNum];
#if TARGET_PC
deformer->mArrayBase = arr - clusterPointer;
deformer->mBlockBase = block;
mpDeformData->mDeformers[i] = deformer;
#else
cluster->setDeformer(deformer);
#endif
}
#if !TARGET_PC
for (int i = 0; i < mpDeformData->getClusterKeyNum(); i++) {
J3DClusterKey* clusterKey = &mpDeformData->mClusterKeyPointer[i];
clusterKey->field_0x4 = JSUConvertOffsetToPtr<u16>(block, clusterKey->field_0x4);
clusterKey->field_0x8 = JSUConvertOffsetToPtr<u16>(block, clusterKey->field_0x8);
}
for (int i = 0; i < mpDeformData->mClusterVertexNum; i++) {
J3DClusterVertex* clusterVertex = &mpDeformData->mClusterVertex[i];
clusterVertex->field_0x4 = JSUConvertOffsetToPtr<u16>(block, clusterVertex->field_0x4);
clusterVertex->field_0x8 = JSUConvertOffsetToPtr<u16>(block, clusterVertex->field_0x8);
}
#endif
DCStoreRange(arr, vtxPosSize);
}
libs/JSystem/src/J3DGraphLoader/J3DJointFactory.cpp
+46
View File
@@ -0,0 +1,46 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphAnimator/J3DJoint.h"
#include "JSystem/J3DGraphLoader/J3DJointFactory.h"
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JSupport/JSupport.h"
J3DJointFactory::J3DJointFactory(J3DJointBlock const& block) {
mJointInitData = JSUConvertOffsetToPtr<J3DJointInitData>(&block, (uintptr_t)block.mpJointInitData);
mIndexTable = JSUConvertOffsetToPtr<u16>(&block, (uintptr_t)block.mpIndexTable);
#if TARGET_LITTLE_ENDIAN
for (int i = 0; i < block.mJointNum; i++) {
auto& index = mIndexTable[i];
be_swap(index);
auto initData = &mJointInitData[index];
be_swap(initData->mKind);
be_swap(initData->mTransformInfo.mScale);
be_swap(initData->mTransformInfo.mRotation);
be_swap(initData->mTransformInfo.mTranslate);
be_swap(initData->mRadius);
be_swap(initData->mMin);
be_swap(initData->mMax);
}
#endif
}
J3DJoint* J3DJointFactory::create(int no) {
J3DJoint* joint = JKR_NEW J3DJoint();
J3D_ASSERT_ALLOCMEM(50, joint);
joint->mJntNo = no;
joint->mKind = getKind(no);
joint->mScaleCompensate = getScaleCompensate(no);
joint->mTransformInfo = getTransformInfo(no);
joint->mBoundingSphereRadius = getRadius(no);
joint->mMin = getMin(no);
joint->mMax = getMax(no);
joint->mMtxCalc = NULL;
if (joint->mScaleCompensate == 0xFF)
joint->mScaleCompensate = 0;
return joint;
}
libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory.cpp
+744
View File
@@ -0,0 +1,744 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include <algorithm>
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JMath/JMath.h"
#include "JSystem/JSupport/JSupport.h"
#include "JSystem/JUtility/JUTAssert.h"
J3DMaterialFactory::J3DMaterialFactory(J3DMaterialBlock const& i_block) {
mMaterialNum = i_block.mMaterialNum;
mpMaterialInitData = JSUConvertOffsetToPtr<J3DMaterialInitData>(&i_block, i_block.mpMaterialInitData);
mpMaterialID = JSUConvertOffsetToPtr<BE(u16)>(&i_block, i_block.mpMaterialID);
if (i_block.mpIndInitData != NULL && (uintptr_t)i_block.mpIndInitData - (uintptr_t)i_block.mpNameTable > 4) {
mpIndInitData = JSUConvertOffsetToPtr<J3DIndInitData>(&i_block, i_block.mpIndInitData);
} else {
mpIndInitData = NULL;
}
mpCullMode = JSUConvertOffsetToPtr<BE(GXCullMode)>(&i_block, i_block.mpCullMode);
mpMatColor = JSUConvertOffsetToPtr<GXColor>(&i_block, i_block.mpMatColor);
mpColorChanNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpColorChanNum);
mpColorChanInfo = JSUConvertOffsetToPtr<J3DColorChanInfo>(&i_block, i_block.mpColorChanInfo);
mpAmbColor = JSUConvertOffsetToPtr<GXColor>(&i_block, i_block.mpAmbColor);
mpLightInfo = JSUConvertOffsetToPtr<J3DLightInfo>(&i_block, i_block.mpLightInfo);
mpTexGenNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpTexGenNum);
mpTexCoordInfo = JSUConvertOffsetToPtr<J3DTexCoordInfo>(&i_block, i_block.mpTexCoordInfo);
mpTexCoord2Info = JSUConvertOffsetToPtr<J3DTexCoord2Info>(&i_block, i_block.mpTexCoord2Info);
mpTexMtxInfo = JSUConvertOffsetToPtr<J3DTexMtxInfo>(&i_block, i_block.mpTexMtxInfo);
field_0x34 = JSUConvertOffsetToPtr<J3DTexMtxInfo>(&i_block, i_block.field_0x44);
mpTexNo = JSUConvertOffsetToPtr<BE(u16)>(&i_block, i_block.mpTexNo);
mpTevOrderInfo = JSUConvertOffsetToPtr<J3DTevOrderInfo>(&i_block, i_block.mpTevOrderInfo);
mpTevColor = JSUConvertOffsetToPtr<BE(GXColorS10)>(&i_block, i_block.mpTevColor);
mpTevKColor = JSUConvertOffsetToPtr<GXColor>(&i_block, i_block.mpTevKColor);
mpTevStageNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpTevStageNum);
mpTevStageInfo = JSUConvertOffsetToPtr<J3DTevStageInfo>(&i_block, i_block.mpTevStageInfo);
mpTevSwapModeInfo = JSUConvertOffsetToPtr<J3DTevSwapModeInfo>(&i_block, i_block.mpTevSwapModeInfo);
mpTevSwapModeTableInfo = JSUConvertOffsetToPtr<J3DTevSwapModeTableInfo>(&i_block, i_block.mpTevSwapModeTableInfo);
mpFogInfo = JSUConvertOffsetToPtr<J3DFogInfo>(&i_block, i_block.mpFogInfo);
mpAlphaCompInfo = JSUConvertOffsetToPtr<J3DAlphaCompInfo>(&i_block, i_block.mpAlphaCompInfo);
mpBlendInfo = JSUConvertOffsetToPtr<J3DBlendInfo>(&i_block, i_block.mpBlendInfo);
mpZModeInfo = JSUConvertOffsetToPtr<J3DZModeInfo>(&i_block, i_block.mpZModeInfo);
mpZCompLoc = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpZCompLoc);
mpDither = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpDither);
mpNBTScaleInfo = JSUConvertOffsetToPtr<J3DNBTScaleInfo>(&i_block, i_block.mpNBTScaleInfo);
mpDisplayListInit = NULL;
mpPatchingInfo = NULL;
mpCurrentMtxInfo = NULL;
mpMaterialMode = NULL;
}
J3DMaterialFactory::J3DMaterialFactory(J3DMaterialDLBlock const& i_block) {
mMaterialNum = i_block.mMaterialNum;
mpMaterialInitData = NULL;
mpDisplayListInit = JSUConvertOffsetToPtr<J3DDisplayListInit>(&i_block, i_block.mpDisplayListInit);
mpPatchingInfo = JSUConvertOffsetToPtr<J3DPatchingInfo>(&i_block, i_block.mpPatchingInfo);
mpCurrentMtxInfo = JSUConvertOffsetToPtr<J3DCurrentMtxInfo>(&i_block, i_block.mpCurrentMtxInfo);
mpMaterialMode = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpMaterialMode);
}
u16 J3DMaterialFactory::countUniqueMaterials() {
u16 count = 0;
s32 id = -1;
for (u16 i = 0; i < mMaterialNum; i++) {
if (id < mpMaterialID[i]) {
id = mpMaterialID[i];
count++;
}
}
return count;
}
u32 J3DMaterialFactory::countTexGens(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexGenNumIdx != 0xff) {
return mpTexGenNum[mtl_init_data->mTexGenNumIdx];
}
return 0;
}
u32 J3DMaterialFactory::countStages(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
u32 count1 = 0;
u32 count2 = 0;
if (mtl_init_data->mTevStageNumIdx != 0xff) {
count2 = mpTevStageNum[mtl_init_data->mTevStageNumIdx];
}
for (int i = 0; i < 8; i++) {
if (mtl_init_data->mTexNoIdx[i] != 0xffff) {
count1++;
}
}
if (count2 != count1 && count1 != 0) {
u32 count3;
if (count2 > count1) {
count3 = count2;
} else {
count3 = count1;
}
return count3;
}
return count2;
}
J3DMaterial* J3DMaterialFactory::create(J3DMaterial* i_material, MaterialType i_type,
int i_idx, u32 i_flags) const {
switch (i_type) {
case MATERIAL_TYPE_NORMAL:
i_material = createNormalMaterial(i_material, i_idx, i_flags);
break;
case MATERIAL_TYPE_LOCKED:
i_material = createLockedMaterial(i_material, i_idx, i_flags);
break;
case MATERIAL_TYPE_PATCHED:
i_material = createPatchedMaterial(i_material, i_idx, i_flags);
break;
}
return i_material;
}
J3DMaterial* J3DMaterialFactory::createNormalMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
if (mpDisplayListInit != NULL) {
return createLockedMaterial(i_material, i_idx, i_flags);
}
const u32 stages = countStages(i_idx);
u32 tev_stage_num = getMdlDataFlag_TevStageNum(i_flags);
u32 tev_stage_num_max = JMAMax(stages, tev_stage_num);
u32 tex_num = tev_stage_num_max > 8 ? 8 : tev_stage_num_max;
u32 texgens = countTexGens(i_idx);
u32 texgen_flag = texgens > 4 ? getMdlDataFlag_TexGenFlag(0) : getMdlDataFlag_TexGenFlag(i_flags);
u32 color_flag = getMdlDataFlag_ColorFlag(i_flags);
u32 pe_flag = getMdlDataFlag_PEFlag(i_flags);
BOOL ind_flag = (i_flags & 0x1000000) ? TRUE : FALSE;
if (i_material == NULL) {
i_material = JKR_NEW J3DMaterial();
J3D_ASSERT_ALLOCMEM(269, i_material);
}
i_material->mColorBlock = J3DMaterial::createColorBlock(color_flag);
i_material->mTexGenBlock = J3DMaterial::createTexGenBlock(texgen_flag);
i_material->mTevBlock = J3DMaterial::createTevBlock((u16)tev_stage_num_max);
i_material->mIndBlock = J3DMaterial::createIndBlock(ind_flag);
i_material->mPEBlock = J3DMaterial::createPEBlock(pe_flag, getMaterialMode(i_idx));
i_material->mIndex = i_idx;
i_material->mMaterialMode = getMaterialMode(i_idx);
i_material->mColorBlock->setColorChanNum(newColorChanNum(i_idx));
i_material->mColorBlock->setCullMode(newCullMode(i_idx));
i_material->mTexGenBlock->setTexGenNum(newTexGenNum(i_idx));
i_material->mTexGenBlock->setNBTScale(newNBTScale(i_idx));
i_material->mPEBlock->setFog(newFog(i_idx));
i_material->mPEBlock->setAlphaComp(newAlphaComp(i_idx));
i_material->mPEBlock->setBlend(newBlend(i_idx));
i_material->mPEBlock->setZMode(newZMode(i_idx));
i_material->mPEBlock->setZCompLoc(newZCompLoc(i_idx));
i_material->mPEBlock->setDither(newDither(i_idx));
i_material->mTevBlock->setTevStageNum(newTevStageNum(i_idx));
for (u8 i = 0; i < tex_num; i++) {
i_material->mTevBlock->setTexNo(i, newTexNo(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
i_material->mTevBlock->setTevOrder(i, newTevOrder(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
J3DMaterialInitData* material_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
i_material->mTevBlock->setTevStage(i, newTevStage(i_idx, i));
if (material_init_data->mTevSwapModeIdx[i] != 0xffff) {
i_material->mTevBlock->getTevStage(i)->setTexSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mTexSel);
i_material->mTevBlock->getTevStage(i)->setRasSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mRasSel);
}
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevKColor(i, newTevKColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevColor(i, newTevColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevSwapModeTable(i, newTevSwapModeTable(i_idx, i));
}
for (u8 i = 0; i < 2; i++) {
i_material->mColorBlock->setAmbColor(i, newAmbColor(i_idx, i));
}
for (u8 i = 0; i < 2; i++) {
i_material->mColorBlock->setMatColor(i, newMatColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
J3DColorChan color_chan = newColorChan(i_idx, i);
i_material->mColorBlock->setColorChan(i, color_chan);
}
for (u8 i = 0; i < texgens; i++) {
J3DTexCoord tex_coord = newTexCoord(i_idx, i);
i_material->mTexGenBlock->setTexCoord(i, &tex_coord);
}
for (u8 i = 0; i < 8; i++) {
i_material->mTexGenBlock->setTexMtx(i, newTexMtx(i_idx, i));
}
J3DMaterialInitData* material_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
for (u8 i = 0; i < tev_stage_num_max; i++) {
if (material_init_data->mTevKColorSel[i] != 0xff) {
i_material->mTevBlock->setTevKColorSel(i, material_init_data->mTevKColorSel[i]);
} else {
i_material->mTevBlock->setTevKColorSel(i, 0xc);
}
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
if (material_init_data->mTevKAlphaSel[i] != 0xff) {
i_material->mTevBlock->setTevKAlphaSel(i, material_init_data->mTevKAlphaSel[i]);
} else {
i_material->mTevBlock->setTevKAlphaSel(i, 0x1c);
}
}
if (mpIndInitData != NULL) {
u8 ind_tex_stage_num = newIndTexStageNum(i_idx);
i_material->mIndBlock->setIndTexStageNum(newIndTexStageNum(i_idx));
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexMtx(i, newIndTexMtx(i_idx, i));
}
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexOrder(i, newIndTexOrder(i_idx, i));
}
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexCoordScale(i, newIndTexCoordScale(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
i_material->mTevBlock->setIndTevStage(i, newIndTevStage(i_idx, i));
}
}
return i_material;
}
J3DMaterial* J3DMaterialFactory::createPatchedMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
if (i_material == NULL) {
i_material = JKR_NEW J3DPatchedMaterial();
J3D_ASSERT_ALLOCMEM(430, i_material);
}
bool bVar1 = i_flags & 0x3000000 ? true : false;
i_material->mColorBlock = J3DMaterial::createColorBlock(0x40000000);
i_material->mTexGenBlock = JKR_NEW J3DTexGenBlockPatched();
J3D_ASSERT_ALLOCMEM(440, i_material->mTexGenBlock);
i_material->mTevBlock = JKR_NEW J3DTevBlockPatched();
J3D_ASSERT_ALLOCMEM(442, i_material->mTevBlock);
i_material->mIndBlock = J3DMaterial::createIndBlock(bVar1);
i_material->mPEBlock = J3DMaterial::createPEBlock(0x10000000, getMaterialMode(i_idx));
i_material->mIndex = i_idx;
i_material->mMaterialMode = getMaterialMode(i_idx);
i_material->mTevBlock->setTevStageNum(newTevStageNum(i_idx));
i_material->mColorBlock->setColorChanNum(newColorChanNum(i_idx));
i_material->mColorBlock->setCullMode(newCullMode(i_idx));
i_material->mPEBlock->setFog(newFog(i_idx));
i_material->mPEBlock->setAlphaComp(newAlphaComp(i_idx));
i_material->mPEBlock->setBlend(newBlend(i_idx));
i_material->mPEBlock->setZMode(newZMode(i_idx));
i_material->mPEBlock->setZCompLoc(newZCompLoc(i_idx));
i_material->mPEBlock->setDither(newDither(i_idx));
u8 tev_stage_num = i_material->mTevBlock->getTevStageNum();
for (u8 i = 0; i < 8; i++) {
i_material->mTevBlock->setTexNo(i, newTexNo(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num; i++) {
i_material->mTevBlock->setTevOrder(i, newTevOrder(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevKColor(i, newTevKColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevColor(i, newTevColor(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num; i++) {
J3DMaterialInitData* material_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
i_material->mTevBlock->setTevStage(i, newTevStage(i_idx, i));
if (material_init_data->mTevSwapModeIdx[i] != 0xffff) {
i_material->mTevBlock->getTevStage(i)->setTexSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mTexSel);
i_material->mTevBlock->getTevStage(i)->setRasSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mRasSel);
}
}
J3DMaterialInitData* init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
for (u8 i = 0; i < tev_stage_num; i++) {
if (init_data->mTevKColorSel[i] != 0xff) {
i_material->mTevBlock->setTevKColorSel(i, init_data->mTevKColorSel[i]);
} else {
i_material->mTevBlock->setTevKColorSel(i, 0xC);
}
}
for (u8 i = 0; i < 2; i++) {
i_material->mColorBlock->setMatColor(i, newMatColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
J3DColorChan color_chan = newColorChan(i_idx, i);
i_material->mColorBlock->setColorChan(i, color_chan);
}
u32 texgens = countTexGens(i_idx);
i_material->mTexGenBlock->setTexGenNum(newTexGenNum(i_idx));
for (u8 i = 0; i < 8; i++) {
i_material->mTexGenBlock->setTexMtx(i, newTexMtx(i_idx, i));
}
for (u8 i = 0; i < texgens; i++) {
J3DTexCoord tex_coord = newTexCoord(i_idx, i);
i_material->mTexGenBlock->setTexCoord(i, &tex_coord);
}
if (bVar1 && mpIndInitData != NULL) {
u8 ind_tex_stage_num = newIndTexStageNum(i_idx);
i_material->mIndBlock->setIndTexStageNum(newIndTexStageNum(i_idx));
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexMtx(i, newIndTexMtx(i_idx, i));
}
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexOrder(i, newIndTexOrder(i_idx, i));
}
for (u8 i = 0; i < ind_tex_stage_num; i++) {
i_material->mIndBlock->setIndTexCoordScale(i, newIndTexCoordScale(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num; i++) {
i_material->mTevBlock->setIndTevStage(i, newIndTevStage(i_idx, i));
}
}
return i_material;
}
void J3DMaterialFactory::modifyPatchedCurrentMtx(J3DMaterial* i_material, int i_idx) const {
J3DTexCoord coord[8];
u32 tex_gens = countTexGens(i_idx);
for (u8 i = 0; i < tex_gens; i++) {
coord[i] = newTexCoord(i_idx, i);
}
J3DCurrentMtx currentMtx;
currentMtx.setCurrentTexMtx(
coord[0].getTexGenMtx(),
coord[1].getTexGenMtx(),
coord[2].getTexGenMtx(),
coord[3].getTexGenMtx(),
coord[4].getTexGenMtx(),
coord[5].getTexGenMtx(),
coord[6].getTexGenMtx(),
coord[7].getTexGenMtx()
);
i_material->mCurrentMtx = currentMtx;
}
J3DMaterial* J3DMaterialFactory::createLockedMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
if (i_material == NULL) {
i_material = JKR_NEW J3DLockedMaterial();
J3D_ASSERT_ALLOCMEM(629, i_material);
i_material->mColorBlock = JKR_NEW J3DColorBlockNull();
J3D_ASSERT_ALLOCMEM(634, i_material->mColorBlock);
i_material->mTexGenBlock = JKR_NEW J3DTexGenBlockNull();
J3D_ASSERT_ALLOCMEM(636, i_material->mTexGenBlock);
i_material->mTevBlock = JKR_NEW J3DTevBlockNull();
J3D_ASSERT_ALLOCMEM(638, i_material->mTevBlock);
i_material->mIndBlock = JKR_NEW J3DIndBlockNull();
J3D_ASSERT_ALLOCMEM(640, i_material->mIndBlock);
i_material->mPEBlock = JKR_NEW J3DPEBlockNull();
J3D_ASSERT_ALLOCMEM(642, i_material->mPEBlock);
i_material->mIndex = i_idx;
i_material->mMaterialMode = mpMaterialMode[i_idx];
}
i_material->mCurrentMtx = mpCurrentMtxInfo[i_idx];
i_material->getColorBlock()->setMatColorOffset(mpPatchingInfo[i_idx].mMatColorOffset);
i_material->getColorBlock()->setColorChanOffset(mpPatchingInfo[i_idx].mColorChanOffset);
i_material->getTexGenBlock()->setTexMtxOffset(mpPatchingInfo[i_idx].mTexMtxOffset);
i_material->getTevBlock()->setTexNoOffset(mpPatchingInfo[i_idx].mTexNoOffset);
i_material->getTevBlock()->setTevRegOffset(mpPatchingInfo[i_idx].mTevRegOffset);
i_material->getPEBlock()->setFogOffset(mpPatchingInfo[i_idx].mFogOffset);
if (i_material->mSharedDLObj == NULL) {
i_material->mSharedDLObj = JKR_NEW J3DDisplayListObj();
J3D_ASSERT_ALLOCMEM(673, i_material->mSharedDLObj);
i_material->mSharedDLObj->setSingleDisplayList((void*)(
mpDisplayListInit[i_idx].mOffset + (uintptr_t)&mpDisplayListInit[i_idx]),
mpDisplayListInit[i_idx].field_0x4
);
}
return i_material;
}
u32 J3DMaterialFactory::calcSize(J3DMaterial* i_material, J3DMaterialFactory::MaterialType i_type,
int i_idx, u32 i_flags) const {
u32 size = 0;
switch (i_type) {
case MATERIAL_TYPE_NORMAL:
size += calcSizeNormalMaterial(i_material, i_idx, i_flags);
break;
case MATERIAL_TYPE_LOCKED:
size += calcSizeLockedMaterial(i_material, i_idx, i_flags);
break;
case MATERIAL_TYPE_PATCHED:
size += calcSizePatchedMaterial(i_material, i_idx, i_flags);
break;
}
return size;
}
u32 J3DMaterialFactory::calcSizeNormalMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
u32 size = 0;
if (mpDisplayListInit != NULL) {
return calcSizeLockedMaterial(i_material, i_idx, i_flags);
}
const u32 stages = countStages(i_idx);
u32 tev_stage_num = getMdlDataFlag_TevStageNum(i_flags);
u32 tev_stage_num_max = JMAMax(stages, tev_stage_num);
u32 tex_num = tev_stage_num_max > 8 ? 8 : tev_stage_num_max;
u32 tex_gens = countTexGens(i_idx);
u32 tex_gen_flag = tex_gens > 4 ? getMdlDataFlag_TexGenFlag(0) : getMdlDataFlag_TexGenFlag(i_flags);
u32 color_block_flag = getMdlDataFlag_ColorFlag(i_flags);
u32 pe_flag = getMdlDataFlag_PEFlag(i_flags);
BOOL ind_flag = (i_flags & 0x1000000) ? TRUE : FALSE;
if (i_material == NULL) {
size += sizeof(J3DMaterial);
}
size += J3DMaterial::calcSizeColorBlock(color_block_flag);
size += J3DMaterial::calcSizeTexGenBlock(tex_gen_flag);
size += J3DMaterial::calcSizeTevBlock((u16)tev_stage_num_max);
size += J3DMaterial::calcSizeIndBlock(ind_flag);
size += J3DMaterial::calcSizePEBlock(pe_flag, getMaterialMode(i_idx));
J3DMaterialInitData* init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
for (u32 i = 0; i < 8; i++) {
if (init_data->mTexMtxIdx[i] != 0xffff) {
size += sizeof(J3DTexMtx);
}
}
return size;
}
u32 J3DMaterialFactory::calcSizePatchedMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
u32 size = 0;
if (i_material == NULL) {
size += sizeof(J3DPatchedMaterial);
}
u8 ind_flag = (i_flags & 0x3000000) != 0 ? (u8)1 : (u8)0;
size += J3DMaterial::calcSizeColorBlock(0x40000000);
size += sizeof(J3DTexGenBlockPatched);
size += sizeof(J3DTevBlockPatched);
size += J3DMaterial::calcSizeIndBlock(ind_flag);
size += J3DMaterial::calcSizePEBlock(0x10000000, getMaterialMode(i_idx));
J3DMaterialInitData* init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
for (u32 i = 0; i < 8; i++) {
if (init_data->mTexMtxIdx[i] != 0xffff) {
size += sizeof(J3DTexMtx);
}
}
return size;
}
u32 J3DMaterialFactory::calcSizeLockedMaterial(J3DMaterial* i_material, int i_idx,
u32 i_flags) const {
u32 size = 0;
if (i_material == NULL) {
size += sizeof(J3DLockedMaterial);
size += sizeof(J3DColorBlockNull);
size += sizeof(J3DTexGenBlockNull);
size += sizeof(J3DTevBlockNull);
size += sizeof(J3DIndBlockNull);
size += sizeof(J3DPEBlockNull);
}
size += sizeof(J3DDisplayListObj);
return size;
}
J3DGXColor J3DMaterialFactory::newMatColor(int i_idx, int i_no) const {
#ifdef __MWERKS__
J3DGXColor dflt = (GXColor){0xff, 0xff, 0xff, 0xff};
#else
J3DGXColor dflt = GXColor{0xff, 0xff, 0xff, 0xff};
#endif
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mMatColorIdx[i_no] != 0xffff) {
return (GXColor) mpMatColor[mtl_init_data->mMatColorIdx[i_no]];
} else {
return dflt;
}
}
const u8 J3DMaterialFactory::newColorChanNum(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mColorChanNumIdx != 0xff) {
return mpColorChanNum[mtl_init_data->mColorChanNumIdx];
} else {
return 0;
}
}
J3DColorChan J3DMaterialFactory::newColorChan(int i_idx, int i_no) const {
u32 r29 = 0;
J3DMaterialInitData* init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (init_data->mColorChanIdx[i_no] != 0xffff) {
return J3DColorChan(mpColorChanInfo[init_data->mColorChanIdx[i_no]]);
} else {
return J3DColorChan();
}
}
J3DGXColor J3DMaterialFactory::newAmbColor(int i_idx, int i_no) const {
#ifdef __MWERKS__
J3DGXColor dflt = (GXColor){0x32, 0x32, 0x32, 0x32};
#else
J3DGXColor dflt = GXColor{0x32, 0x32, 0x32, 0x32};
#endif
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mAmbColorIdx[i_no] != 0xffff) {
return (GXColor) mpAmbColor[mtl_init_data->mAmbColorIdx[i_no]];
} else {
return dflt;
}
}
u32 J3DMaterialFactory::newTexGenNum(int i_idx) const {
u32 r30 = 0;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexGenNumIdx != 0xff) {
return mpTexGenNum[mtl_init_data->mTexGenNumIdx];
} else {
return 0;
}
}
J3DTexCoord J3DMaterialFactory::newTexCoord(int i_idx, int i_no) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexCoordIdx[i_no] != 0xffff) {
return J3DTexCoord(mpTexCoordInfo[mtl_init_data->mTexCoordIdx[i_no]]);
} else {
return J3DTexCoord();
}
}
J3DTexMtx* J3DMaterialFactory::newTexMtx(int i_idx, int i_no) const {
J3DTexMtx* tex_mtx = NULL;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexMtxIdx[i_no] != 0xffff) {
#if TARGET_LITTLE_ENDIAN
auto tex_mtx_info = mpTexMtxInfo[mtl_init_data->mTexMtxIdx[i_no]];
be_swap(tex_mtx_info.mCenter);
be_swap(tex_mtx_info.mSRT.mScaleX);
be_swap(tex_mtx_info.mSRT.mScaleY);
be_swap(tex_mtx_info.mSRT.mRotation);
be_swap(tex_mtx_info.mSRT.mTranslationX);
be_swap(tex_mtx_info.mSRT.mTranslationY);
tex_mtx = JKR_NEW J3DTexMtx(tex_mtx_info);
#else
tex_mtx = JKR_NEW J3DTexMtx(mpTexMtxInfo[mtl_init_data->mTexMtxIdx[i_no]]);
#endif
}
return tex_mtx;
}
u8 J3DMaterialFactory::newCullMode(int i_idx) const {
u32 r30 = 0;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mCullModeIdx != 0xff) {
return mpCullMode[mtl_init_data->mCullModeIdx];
} else {
return 0xff;
}
}
u16 J3DMaterialFactory::newTexNo(int i_idx, int i_no) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexNoIdx[i_no] != 0xffff) {
return mpTexNo[mtl_init_data->mTexNoIdx[i_no]];
} else {
return 0xffff;
}
}
J3DTevOrder J3DMaterialFactory::newTevOrder(int i_idx, int i_no) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevOrderIdx[i_no] != 0xffff) {
return J3DTevOrder(mpTevOrderInfo[mtl_init_data->mTevOrderIdx[i_no]]);
} else {
return J3DTevOrder();
}
}
J3DGXColorS10 J3DMaterialFactory::newTevColor(int i_idx, int i_no) const {
GXColorS10 _dflt = {0, 0, 0, 0};
J3DGXColorS10 dflt = _dflt;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevColorIdx[i_no] != 0xffff) {
return (GXColorS10) mpTevColor[mtl_init_data->mTevColorIdx[i_no]];
} else {
return dflt;
}
}
J3DGXColor J3DMaterialFactory::newTevKColor(int i_idx, int i_no) const {
#ifdef __MWERKS__
J3DGXColor dflt = (GXColor){0xff, 0xff, 0xff, 0xff};
#else
J3DGXColor dflt = GXColor{0xff, 0xff, 0xff, 0xff};
#endif
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevKColorIdx[i_no] != 0xffff) {
return (GXColor) mpTevKColor[mtl_init_data->mTevKColorIdx[i_no]];
} else {
return dflt;
}
}
const u8 J3DMaterialFactory::newTevStageNum(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevStageNumIdx != 0xff) {
return mpTevStageNum[mtl_init_data->mTevStageNumIdx];
} else {
return 0xff;
}
}
J3DTevStage J3DMaterialFactory::newTevStage(int i_idx, int i_no) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevStageIdx[i_no] != 0xffff) {
return J3DTevStage(mpTevStageInfo[mtl_init_data->mTevStageIdx[i_no]]);
} else {
return J3DTevStage();
}
}
J3DTevSwapModeTable J3DMaterialFactory::newTevSwapModeTable(int i_idx, int i_no) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevSwapModeTableIdx[i_no] != 0xffff) {
return J3DTevSwapModeTable(mpTevSwapModeTableInfo[mtl_init_data->mTevSwapModeTableIdx[i_no]]);
} else {
return J3DTevSwapModeTable(j3dDefaultTevSwapModeTable);
}
}
u8 J3DMaterialFactory::newIndTexStageNum(int i_idx) const {
u8 dflt = 0;
if (mpIndInitData[i_idx].mEnabled == true) {
return mpIndInitData[i_idx].mIndTexStageNum;
} else {
return dflt;
}
}
J3DIndTexOrder J3DMaterialFactory::newIndTexOrder(int i_idx, int i_no) const {
J3DIndTexOrder dflt;
if (mpIndInitData[i_idx].mEnabled == true) {
return J3DIndTexOrder(mpIndInitData[i_idx].mIndTexOrderInfo[i_no]);
} else {
return dflt;
}
}
J3DIndTexMtx J3DMaterialFactory::newIndTexMtx(int i_idx, int i_no) const {
J3DIndTexMtx dflt;
if (mpIndInitData[i_idx].mEnabled == true) {
return J3DIndTexMtx(mpIndInitData[i_idx].mIndTexMtxInfo[i_no]);
} else {
return dflt;
}
}
J3DIndTevStage J3DMaterialFactory::newIndTevStage(int i_idx, int i_no) const {
J3DIndTevStage dflt;
if (mpIndInitData[i_idx].mEnabled == true) {
return J3DIndTevStage(mpIndInitData[i_idx].mIndTevStageInfo[i_no]);
} else {
return dflt;
}
}
J3DIndTexCoordScale J3DMaterialFactory::newIndTexCoordScale(int i_idx, int i_no) const {
J3DIndTexCoordScale dflt;
if (mpIndInitData[i_idx].mEnabled == true) {
return J3DIndTexCoordScale(mpIndInitData[i_idx].mIndTexCoordScaleInfo[i_no]);
} else {
return dflt;
}
}
J3DFog J3DMaterialFactory::newFog(int i_idx) const {
J3DFog fog;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mFogIdx != 0xffff) {
fog.setFogInfo(mpFogInfo[mtl_init_data->mFogIdx]);
}
return fog;
}
J3DAlphaComp J3DMaterialFactory::newAlphaComp(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mAlphaCompIdx != 0xffff) {
return J3DAlphaComp(mpAlphaCompInfo[mtl_init_data->mAlphaCompIdx]);
} else {
return J3DAlphaComp(0xffff);
}
}
J3DBlend J3DMaterialFactory::newBlend(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mBlendIdx != 0xffff) {
return J3DBlend(mpBlendInfo[mtl_init_data->mBlendIdx]);
} else {
return J3DBlend(j3dDefaultBlendInfo);
}
}
J3DZMode J3DMaterialFactory::newZMode(int i_idx) const {
u32 r29 = 0;
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mZModeIdx != 0xff) {
return J3DZMode(mpZModeInfo[mtl_init_data->mZModeIdx]);
} else {
return J3DZMode();
}
}
const u8 J3DMaterialFactory::newZCompLoc(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mZCompLocIdx != 0xff){
return mpZCompLoc[mtl_init_data->mZCompLocIdx];
} else {
return 0;
}
}
const u8 J3DMaterialFactory::newDither(int i_idx) const {
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mDitherIdx != 0xff){
return mpDither[mtl_init_data->mDitherIdx];
} else {
return 1;
}
}
J3DNBTScale J3DMaterialFactory::newNBTScale(int i_idx) const {
J3DNBTScale dflt(j3dDefaultNBTScaleInfo);
J3DMaterialInitData* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mNBTScaleIdx != 0xffff) {
return J3DNBTScale(mpNBTScaleInfo[mtl_init_data->mNBTScaleIdx]);
} else {
return dflt;
}
}
libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory_v21.cpp
+370
View File
@@ -0,0 +1,370 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory_v21.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JMath/JMath.h"
#include "JSystem/JSupport/JSupport.h"
J3DMaterialFactory_v21::J3DMaterialFactory_v21(J3DMaterialBlock_v21 const& i_block) {
mMaterialNum = i_block.mMaterialNum;
mpMaterialInitData = JSUConvertOffsetToPtr<J3DMaterialInitData_v21>(&i_block, i_block.mpMaterialInitData);
mpMaterialID = JSUConvertOffsetToPtr<u16>(&i_block, i_block.mpMaterialID);
mpCullMode = JSUConvertOffsetToPtr<GXCullMode>(&i_block, i_block.mpCullMode);
mpMatColor = JSUConvertOffsetToPtr<GXColor>(&i_block, i_block.mpMatColor);
mpColorChanNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpColorChanNum);
mpColorChanInfo = JSUConvertOffsetToPtr<J3DColorChanInfo>(&i_block, i_block.mpColorChanInfo);
mpTexGenNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpTexGenNum);
mpTexCoordInfo = JSUConvertOffsetToPtr<J3DTexCoordInfo>(&i_block, i_block.mpTexCoordInfo);
mpTexCoord2Info = JSUConvertOffsetToPtr<J3DTexCoord2Info>(&i_block, i_block.mpTexCoord2Info);
mpTexMtxInfo = JSUConvertOffsetToPtr<J3DTexMtxInfo>(&i_block, i_block.mpTexMtxInfo);
field_0x28 = JSUConvertOffsetToPtr<J3DTexMtxInfo>(&i_block, i_block.field_0x38);
mpTexNo = JSUConvertOffsetToPtr<u16>(&i_block, i_block.mpTexNo);
mpTevOrderInfo = JSUConvertOffsetToPtr<J3DTevOrderInfo>(&i_block, i_block.mpTevOrderInfo);
mpTevColor = JSUConvertOffsetToPtr<GXColorS10>(&i_block, i_block.mpTevColor);
mpTevKColor = JSUConvertOffsetToPtr<GXColor>(&i_block, i_block.mpTevKColor);
mpTevStageNum = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpTevStageNum);
mpTevStageInfo = JSUConvertOffsetToPtr<J3DTevStageInfo>(&i_block, i_block.mpTevStageInfo);
mpTevSwapModeInfo = JSUConvertOffsetToPtr<J3DTevSwapModeInfo>(&i_block, i_block.mpTevSwapModeInfo);
mpTevSwapModeTableInfo = JSUConvertOffsetToPtr<J3DTevSwapModeTableInfo>(&i_block, i_block.mpTevSwapModeTableInfo);
mpFogInfo = JSUConvertOffsetToPtr<J3DFogInfo>(&i_block, i_block.mpFogInfo);
mpAlphaCompInfo = JSUConvertOffsetToPtr<J3DAlphaCompInfo>(&i_block, i_block.mpAlphaCompInfo);
mpBlendInfo = JSUConvertOffsetToPtr<J3DBlendInfo>(&i_block, i_block.mpBlendInfo);
mpZModeInfo = JSUConvertOffsetToPtr<J3DZModeInfo>(&i_block, i_block.mpZModeInfo);
mpZCompLoc = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpZCompLoc);
mpDither = JSUConvertOffsetToPtr<u8>(&i_block, i_block.mpDither);
mpNBTScaleInfo = JSUConvertOffsetToPtr<J3DNBTScaleInfo>(&i_block, i_block.mpNBTScaleInfo);
}
u16 J3DMaterialFactory_v21::countUniqueMaterials() {
u16 i;
for (i = 0; i < mMaterialNum; i++) {
if (mpMaterialID[i] - i == 0) {
// No code, maybe commented out.
}
}
return i;
}
u32 J3DMaterialFactory_v21::countTexGens(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexGenNumIdx != 0xff) {
return mpTexGenNum[mtl_init_data->mTexGenNumIdx];
}
return 0;
}
u32 J3DMaterialFactory_v21::countStages(int i_idx) const {
J3DMaterialInitData_v21* init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
u32 count1 = 0;
u32 count2 = 0;
if (init_data->mTevStageNumIdx != 0xff) {
count2 = mpTevStageNum[init_data->mTevStageNumIdx];
}
for (int i = 0; i < 8; i++) {
if (init_data->mTexNoIdx[i] != 0xffff) {
count1++;
}
}
if (count2 != count1 && count1 != 0) {
u32 count3;
if (count2 > count1) {
count3 = count2;
} else {
count3 = count1;
}
return count3;
}
return count2;
}
J3DMaterial* J3DMaterialFactory_v21::create(J3DMaterial* i_material, int i_idx, u32 i_flags) const {
const u32 stages = countStages(i_idx);
u32 tev_stage_num = getMdlDataFlag_TevStageNum(i_flags);
u32 tev_stage_num_max = JMAMax(stages, tev_stage_num);
u32 tex_num = tev_stage_num_max > 8 ? 8 : tev_stage_num_max;
u32 texgens = countTexGens(i_idx);
u32 texgen_flag = texgens > 4 ? getMdlDataFlag_TexGenFlag(0) : getMdlDataFlag_TexGenFlag(i_flags);
u32 color_flag = getMdlDataFlag_ColorFlag(i_flags);
u32 pe_flag = getMdlDataFlag_PEFlag(i_flags);
BOOL ind_flag = (i_flags & 0x1000000) ? TRUE : FALSE;
if (i_material == NULL) {
i_material = JKR_NEW J3DMaterial();
}
i_material->mColorBlock = J3DMaterial::createColorBlock(color_flag);
i_material->mTexGenBlock = J3DMaterial::createTexGenBlock(texgen_flag);
i_material->mTevBlock = J3DMaterial::createTevBlock((u16)tev_stage_num_max);
i_material->mIndBlock = J3DMaterial::createIndBlock(ind_flag);
i_material->mPEBlock = J3DMaterial::createPEBlock(pe_flag, getMaterialMode(i_idx));
i_material->mIndex = i_idx;
i_material->mMaterialMode = getMaterialMode(i_idx);
i_material->mColorBlock->setColorChanNum(newColorChanNum(i_idx));
i_material->mColorBlock->setCullMode(newCullMode(i_idx));
i_material->mTexGenBlock->setTexGenNum(newTexGenNum(i_idx));
i_material->mTexGenBlock->setNBTScale(newNBTScale(i_idx));
i_material->mPEBlock->setFog(newFog(i_idx));
i_material->mPEBlock->setAlphaComp(newAlphaComp(i_idx));
i_material->mPEBlock->setBlend(newBlend(i_idx));
i_material->mPEBlock->setZMode(newZMode(i_idx));
i_material->mPEBlock->setZCompLoc(newZCompLoc(i_idx));
i_material->mPEBlock->setDither(newDither(i_idx));
i_material->mTevBlock->setTevStageNum(newTevStageNum(i_idx));
for (u8 i = 0; i < tex_num; i++) {
i_material->mTevBlock->setTexNo(i, newTexNo(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
i_material->mTevBlock->setTevOrder(i, newTevOrder(i_idx, i));
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
J3DMaterialInitData_v21* material_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
i_material->mTevBlock->setTevStage(i, newTevStage(i_idx, i));
if (material_init_data->mTevSwapModeIdx[i] != 0xffff) {
i_material->mTevBlock->getTevStage(i)->setTexSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mTexSel);
i_material->mTevBlock->getTevStage(i)->setRasSel(
mpTevSwapModeInfo[material_init_data->mTevSwapModeIdx[i]].mRasSel);
}
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevKColor(i, newTevKColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevColor(i, newTevColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
i_material->mTevBlock->setTevSwapModeTable(i, newTevSwapModeTable(i_idx, i));
}
for (u8 i = 0; i < 2; i++) {
i_material->mColorBlock->setMatColor(i, newMatColor(i_idx, i));
}
for (u8 i = 0; i < 4; i++) {
J3DColorChan color_chan = newColorChan(i_idx, i);
i_material->mColorBlock->setColorChan(i, color_chan);
}
for (u8 i = 0; i < texgens; i++) {
J3DTexCoord tex_coord = newTexCoord(i_idx, i);
i_material->mTexGenBlock->setTexCoord(i, &tex_coord);
}
for (u8 i = 0; i < 8; i++) {
i_material->mTexGenBlock->setTexMtx(i, newTexMtx(i_idx, i));
}
J3DMaterialInitData_v21* material_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
for (u8 i = 0; i < tev_stage_num_max; i++) {
if (material_init_data->mTevKColorSel[i] != 0xff) {
i_material->mTevBlock->setTevKColorSel(i, material_init_data->mTevKColorSel[i]);
} else {
i_material->mTevBlock->setTevKColorSel(i, 0xc);
}
}
for (u8 i = 0; i < tev_stage_num_max; i++) {
if (material_init_data->mTevKAlphaSel[i] != 0xff) {
i_material->mTevBlock->setTevKAlphaSel(i, material_init_data->mTevKAlphaSel[i]);
} else {
i_material->mTevBlock->setTevKAlphaSel(i, 0x1c);
}
}
return i_material;
}
J3DGXColor J3DMaterialFactory_v21::newMatColor(int i_idx, int i_no) const {
#ifdef __MWERKS__
J3DGXColor defaultColor = (GXColor){0xff, 0xff, 0xff, 0xff};
#else
J3DGXColor defaultColor = GXColor{0xff, 0xff, 0xff, 0xff};
#endif
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mMatColorIdx[i_no] != 0xffff) {
return J3DGXColor(mpMatColor[mtl_init_data->mMatColorIdx[i_no]]);
}
return J3DGXColor(defaultColor);
}
const u8 J3DMaterialFactory_v21::newColorChanNum(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mColorChanNumIdx != 0xff) {
return mpColorChanNum[mtl_init_data->mColorChanNumIdx];
} else {
return 0;
}
}
J3DColorChan J3DMaterialFactory_v21::newColorChan(int i_idx, int i_no) const {
u8 r29 = 0;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mColorChanIdx[i_no] != 0xffff) {
return J3DColorChan(mpColorChanInfo[mtl_init_data->mColorChanIdx[i_no]]);
} else {
return J3DColorChan();
}
}
u32 J3DMaterialFactory_v21::newTexGenNum(int i_idx) const {
u8 r30 = 0;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexGenNumIdx != 0xff) {
return mpTexGenNum[mtl_init_data->mTexGenNumIdx];
} else {
return 0;
}
}
J3DTexCoord J3DMaterialFactory_v21::newTexCoord(int i_idx, int i_no) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexCoordIdx[i_no] != 0xffff) {
return J3DTexCoord(mpTexCoordInfo[mtl_init_data->mTexCoordIdx[i_no]]);
} else {
return J3DTexCoord();
}
}
J3DTexMtx* J3DMaterialFactory_v21::newTexMtx(int i_idx, int i_no) const {
J3DTexMtx* tex_mtx = NULL;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexMtxIdx[i_no] != 0xffff) {
tex_mtx = JKR_NEW J3DTexMtx(mpTexMtxInfo[mtl_init_data->mTexMtxIdx[i_no]]);
}
return tex_mtx;
}
u8 J3DMaterialFactory_v21::newCullMode(int i_idx) const {
u8 r30 = 0;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mCullModeIdx != 0xff) {
return mpCullMode[mtl_init_data->mCullModeIdx];
} else {
return 0xff;
}
}
u16 J3DMaterialFactory_v21::newTexNo(int i_idx, int i_no) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTexNoIdx[i_no] != 0xffff) {
return mpTexNo[mtl_init_data->mTexNoIdx[i_no]];
} else {
return 0xffff;
}
}
J3DTevOrder J3DMaterialFactory_v21::newTevOrder(int i_idx, int i_no) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevOrderIdx[i_no] != 0xffff) {
return J3DTevOrder(mpTevOrderInfo[mtl_init_data->mTevOrderIdx[i_no]]);
} else {
return J3DTevOrder();
}
}
J3DGXColorS10 J3DMaterialFactory_v21::newTevColor(int i_idx, int i_no) const {
GXColorS10 defaultTevColor = {0,0,0,0};
J3DGXColorS10 dflt = defaultTevColor;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevColorIdx[i_no] != 0xffff) {
return mpTevColor[mtl_init_data->mTevColorIdx[i_no]];
} else {
return dflt;
}
}
J3DGXColor J3DMaterialFactory_v21::newTevKColor(int i_idx, int param_1) const {
#ifdef __MWERKS__
J3DGXColor defaultColor = (GXColor){0xff, 0xff, 0xff, 0xff};
#else
J3DGXColor defaultColor = GXColor{0xff, 0xff, 0xff, 0xff};
#endif
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevKColorIdx[param_1] != 0xffff) {
return J3DGXColor(mpTevKColor[mtl_init_data->mTevKColorIdx[param_1]]);
}
return J3DGXColor(defaultColor);
}
const u8 J3DMaterialFactory_v21::newTevStageNum(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevStageNumIdx != 0xff) {
return mpTevStageNum[mtl_init_data->mTevStageNumIdx];
} else {
return 0xff;
}
}
J3DTevStage J3DMaterialFactory_v21::newTevStage(int i_idx, int i_no) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevStageIdx[i_no] != 0xffff) {
return J3DTevStage(mpTevStageInfo[mtl_init_data->mTevStageIdx[i_no]]);
} else {
return J3DTevStage();
}
}
J3DTevSwapModeTable J3DMaterialFactory_v21::newTevSwapModeTable(int i_idx, int param_1) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mTevSwapModeTableIdx[param_1] != 0xffff) {
return J3DTevSwapModeTable(mpTevSwapModeTableInfo[mtl_init_data->mTevSwapModeTableIdx[param_1]]);
}
return J3DTevSwapModeTable(j3dDefaultTevSwapModeTable);
}
J3DFog J3DMaterialFactory_v21::newFog(int i_idx) const {
J3DFog fog;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mFogIdx != 0xffff) {
fog.setFogInfo(mpFogInfo[mtl_init_data->mFogIdx]);
}
return fog;
}
J3DAlphaComp J3DMaterialFactory_v21::newAlphaComp(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mAlphaCompIdx != 0xffff) {
return J3DAlphaComp(mpAlphaCompInfo[mtl_init_data->mAlphaCompIdx]);
}
return J3DAlphaComp(0xffff);
}
J3DBlend J3DMaterialFactory_v21::newBlend(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mBlendIdx != 0xffff) {
return J3DBlend(mpBlendInfo[mtl_init_data->mBlendIdx]);
} else {
return J3DBlend(j3dDefaultBlendInfo);
}
}
const J3DZMode J3DMaterialFactory_v21::newZMode(int i_idx) const {
u8 r29 = 0;
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mZModeIdx != 0xff) {
return J3DZMode(mpZModeInfo[mtl_init_data->mZModeIdx]);
} else {
return J3DZMode();
}
}
const u8 J3DMaterialFactory_v21::newZCompLoc(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mZCompLocIdx != 0xff){
return mpZCompLoc[mtl_init_data->mZCompLocIdx];
} else {
return 0;
}
}
const u8 J3DMaterialFactory_v21::newDither(int i_idx) const {
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mDitherIdx != 0xff){
return mpDither[mtl_init_data->mDitherIdx];
} else {
return 1;
}
}
J3DNBTScale J3DMaterialFactory_v21::newNBTScale(int i_idx) const {
J3DNBTScale dflt(j3dDefaultNBTScaleInfo);
J3DMaterialInitData_v21* mtl_init_data = &mpMaterialInitData[mpMaterialID[i_idx]];
if (mtl_init_data->mNBTScaleIdx != 0xffff) {
return J3DNBTScale(mpNBTScaleInfo[mtl_init_data->mNBTScaleIdx]);
} else {
return dflt;
}
}
libs/JSystem/src/J3DGraphLoader/J3DModelLoader.cpp
+682
View File
@@ -0,0 +1,682 @@
#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/J3DJointFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory_v21.h"
#include "JSystem/J3DGraphLoader/J3DShapeFactory.h"
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/JUtility/JUTNameTab.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JSupport/JSupport.h"
J3DModelLoader::J3DModelLoader() :
mpModelData(NULL),
mpMaterialTable(NULL),
mpShapeBlock(NULL),
mpMaterialBlock(NULL),
mpModelHierarchy(NULL),
field_0x18(0),
mEnvelopeSize(0) {
/* empty function */
}
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 (header->mMagic1 == 'J3D1' && header->mMagic2 == 'bmd1') {
JUT_PANIC(64, "Error : version error.");
return NULL;
}
if (header->mMagic1 == 'J3D2' && header->mMagic2 == 'bmd2') {
J3DModelLoader_v21 loader;
return loader.load(i_data, i_flags);
}
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) {
s32 freeSize = JKRGetCurrentHeap()->getTotalFreeSize();
mpModelData = JKR_NEW J3DModelData();
J3D_ASSERT_ALLOCMEM(177, mpModelData);
mpModelData->clear();
mpModelData->mpRawData = i_data;
mpModelData->setModelDataType(0);
mpMaterialTable = &mpModelData->mMaterialTable;
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 'INF1':
readInformation((J3DModelInfoBlock*)block, (s32)i_flags);
break;
case 'VTX1':
readVertex((J3DVertexBlock*)block);
break;
case 'EVP1':
readEnvelop((J3DEnvelopeBlock*)block);
break;
case 'DRW1':
readDraw((J3DDrawBlock*)block);
break;
case 'JNT1':
readJoint((J3DJointBlock*)block);
break;
case 'MAT3':
readMaterial((J3DMaterialBlock*)block, (s32)i_flags);
break;
case 'MAT2':
readMaterial_v21((J3DMaterialBlock_v21*)block, (s32)i_flags);
break;
case 'SHP1':
readShape((J3DShapeBlock*)block, (s32)i_flags);
break;
case 'TEX1':
readTexture((J3DTextureBlock*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
block = (J3DModelBlock*)((uintptr_t)block + block->mBlockSize);
}
J3DModelHierarchy const* hierarchy = mpModelData->getHierarchy();
mpModelData->makeHierarchy(NULL, &hierarchy);
mpModelData->getShapeTable()->sortVcdVatCmd();
mpModelData->getJointTree().findImportantMtxIndex();
setupBBoardInfo();
if (mpModelData->getFlag() & 0x100) {
for (u16 shape_no = 0; shape_no < mpModelData->getShapeNum(); shape_no++) {
mpModelData->getShapeNodePointer(shape_no)->onFlag(0x200);
}
}
return mpModelData;
}
J3DMaterialTable* J3DModelLoader::loadMaterialTable(void const* i_data) {
int flags = 0x51100000;
mpMaterialTable = JKR_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, flags);
break;
case 'MAT2':
readMaterialTable_v21((J3DMaterialBlock_v21*)block, flags);
break;
case 'TEX1':
readTextureTable((J3DTextureBlock*)block);
break;
default:
OSReport("Unknown data block\n");
break;
}
block = (J3DModelBlock*)((uintptr_t)block + block->mBlockSize);
}
if (mpMaterialTable->mTexture == NULL) {
mpMaterialTable->mTexture = JKR_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 = JKR_NEW J3DModelData();
J3D_ASSERT_ALLOCMEM(338, mpModelData);
mpModelData->clear();
mpModelData->mpRawData = i_data;
mpModelData->setModelDataType(1);
mpMaterialTable = &mpModelData->mMaterialTable;
J3DModelFileData const* data = (J3DModelFileData*)i_data;
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;
readInformation((J3DModelInfoBlock*)block, flags);
break;
case 'VTX1':
readVertex((J3DVertexBlock*)block);
break;
case 'EVP1':
readEnvelop((J3DEnvelopeBlock*)block);
break;
case 'DRW1':
readDraw((J3DDrawBlock*)block);
break;
case 'JNT1':
readJoint((J3DJointBlock*)block);
break;
case 'SHP1':
readShape((J3DShapeBlock*)block, i_flags);
break;
case 'TEX1':
readTexture((J3DTextureBlock*)block);
break;
case 'MDL3':
readMaterialDL((J3DMaterialDLBlock*)block, i_flags);
modifyMaterial(i_flags);
break;
case 'MAT3':
flags = 0x50100000;
flags |= (i_flags & 0x3000000);
mpMaterialBlock = (J3DMaterialBlock*)block;
materialType = getBdlFlag_MaterialType(i_flags);
if (materialType == 0) {
readMaterial((J3DMaterialBlock*)block, flags);
} else if (materialType == 0x2000) {
readPatchedMaterial((J3DMaterialBlock*)block, flags);
}
break;
default:
OSReport("Unknown data block\n");
break;
}
block = (J3DModelBlock*)((uintptr_t)block + block->mBlockSize);
}
J3DModelHierarchy const* hierarchy = mpModelData->getHierarchy();
mpModelData->makeHierarchy(NULL, &hierarchy);
mpModelData->getShapeTable()->sortVcdVatCmd();
mpModelData->getJointTree().findImportantMtxIndex();
setupBBoardInfo();
mpModelData->indexToPtr();
return mpModelData;
}
void J3DModelLoader::setupBBoardInfo() {
for (u16 i = 0; i < mpModelData->getJointNum(); i++) {
J3DMaterial* mesh = mpModelData->getJointNodePointer(i)->getMesh();
if (mesh != NULL) {
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);
J3DShapeInitData* r26 = &shape_init_data[index_table[shape_index]];
switch (r26->mShapeMtxType) {
case 0:
mpModelData->getJointNodePointer(i)->setMtxType(0);
break;
case 1:
mpModelData->getJointNodePointer(i)->setMtxType(1);
mpModelData->mbHasBillboard = true;
break;
case 2:
mpModelData->getJointNodePointer(i)->setMtxType(2);
mpModelData->mbHasBillboard = true;
break;
case 3:
mpModelData->getJointNodePointer(i)->setMtxType(0);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (__FILE__)\n");
break;
}
}
}
}
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;
switch (mpModelData->mFlags & 0xf) {
case 0:
mtx_calc = JKR_NEW J3DMtxCalcNoAnm<J3DMtxCalcCalcTransformBasic,J3DMtxCalcJ3DSysInitBasic>();
break;
case 1:
mtx_calc = JKR_NEW J3DMtxCalcNoAnm<J3DMtxCalcCalcTransformSoftimage,J3DMtxCalcJ3DSysInitSoftimage>();
break;
case 2:
mtx_calc = JKR_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;
mpModelData->setHierarchy(JSUConvertOffsetToPtr<J3DModelHierarchy>(i_block, i_block->mpHierarchy));
}
static GXCompType getFmtType(GXVtxAttrFmtList* i_fmtList, GXAttr i_attr) {
for (; i_fmtList->attr != GX_VA_NULL; i_fmtList++) {
if (i_fmtList->attr == i_attr) {
return i_fmtList->type;
}
}
return GX_F32;
}
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);
vertex_data.mVtxPosArray = JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxPosArray);
vertex_data.mVtxNrmArray = JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxNrmArray);
vertex_data.mVtxNBTArray = JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxNBTArray);
for (int i = 0; i < 2; i++) {
vertex_data.mVtxColorArray[i] =
(GXColor*)JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxColorArray[i]);
}
for (int i = 0; i < 8; i++) {
vertex_data.mVtxTexCoordArray[i] =
JSUConvertOffsetToPtr<void>(i_block, i_block->mpVtxTexCoordArray[i]);
}
#if TARGET_LITTLE_ENDIAN
for (GXVtxAttrFmtList* attrFmt = vertex_data.mVtxAttrFmtList;; attrFmt++) {
*attrFmt = BE<GXVtxAttrFmtList>::swap(*attrFmt);
if (attrFmt->attr == GX_VA_NULL) {
break;
}
}
#endif
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) {
nrm_end = vertex_data.mVtxNBTArray;
} else if (vertex_data.mVtxColorArray[0] != NULL) {
nrm_end = vertex_data.mVtxColorArray[0];
} else if (vertex_data.mVtxTexCoordArray[0] != NULL) {
nrm_end = vertex_data.mVtxTexCoordArray[0];
}
if (vertex_data.mVtxNrmArray == NULL) {
vertex_data.mNrmNum = 0;
} else if (nrm_end != NULL) {
vertex_data.mNrmNum = ((uintptr_t)nrm_end - (uintptr_t)vertex_data.mVtxNrmArray) / nrm_size + 1;
} else {
vertex_data.mNrmNum = (i_block->mBlockSize - (uintptr_t)i_block->mpVtxNrmArray) / nrm_size + 1;
}
void* color0_end = NULL;
if (vertex_data.mVtxColorArray[1] != NULL) {
color0_end = vertex_data.mVtxColorArray[1];
} else if (vertex_data.mVtxTexCoordArray[0] != NULL) {
color0_end = vertex_data.mVtxTexCoordArray[0];
}
if (vertex_data.mVtxColorArray[0] == NULL) {
vertex_data.mColNum = 0;
} else if (color0_end != NULL) {
vertex_data.mColNum = ((uintptr_t)color0_end - (uintptr_t)vertex_data.mVtxColorArray[0]) / 4 + 1;
} else {
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);
mpModelData->getJointTree().mWEvlpMixMtxIndex =
JSUConvertOffsetToPtr<u16>(i_block, i_block->mpWEvlpMixIndex);
mpModelData->getJointTree().mWEvlpMixWeight =
JSUConvertOffsetToPtr<f32>(i_block, i_block->mpWEvlpMixWeight);
mpModelData->getJointTree().mInvJointMtx =
JSUConvertOffsetToPtr<Mtx>(i_block, i_block->mpInvJointMtx);
}
void J3DModelLoader::readDraw(J3DDrawBlock const* i_block) {
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 < drawMtxData->mEntryNum; i++) {
if (drawMtxData->mDrawMtxFlag[i] == 1) {
break;
}
}
drawMtxData->mDrawFullWgtMtxNum = i;
mpModelData->getJointTree().mWEvlpImportantMtxIdx = JKR_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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(791, mpModelData->getJointTree().mJointName);
} else {
mpModelData->getJointTree().mJointName = NULL;
}
mpModelData->getJointTree().mJointNodePointer =
JKR_NEW J3DJoint*[mpModelData->getJointTree().mJointNum];
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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(832, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_NEW J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(841, mpMaterialTable->mMaterialNodePointer);
if (i_flags & 0x200000) {
mpMaterialTable->field_0x10 = JKR_NEW_ARGS (0x20) J3DMaterial[mpMaterialTable->mUniqueMatNum];
J3D_ASSERT_ALLOCMEM(846, mpMaterialTable->field_0x10);
} else {
mpMaterialTable->field_0x10 = NULL;
}
if (i_flags & 0x200000) {
for (u16 i = 0; i < mpMaterialTable->mUniqueMatNum; i++) {
factory.create(&mpMaterialTable->field_0x10[i],
J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, i_flags);
mpMaterialTable->field_0x10[i].mDiffFlag = (uintptr_t)&mpMaterialTable->field_0x10[i] >> 4;
}
}
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i] =
factory.create(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, i_flags);
}
if (i_flags & 0x200000) {
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
(uintptr_t)&mpMaterialTable->field_0x10[factory.getMaterialID(i)] >> 4;
mpMaterialTable->mMaterialNodePointer[i]->mpOrigMaterial =
&mpMaterialTable->field_0x10[factory.getMaterialID(i)];
}
} else {
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
((uintptr_t)mpMaterialTable->mMaterialNodePointer >> 4) + factory.getMaterialID(i);
}
}
}
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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(930, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_NEW J3DMaterial*[mpMaterialTable->mMaterialNum];
J3D_ASSERT_ALLOCMEM(940, mpMaterialTable->mMaterialNodePointer);
if (i_flags & 0x200000) {
mpMaterialTable->field_0x10 = JKR_NEW_ARGS (0x20) J3DMaterial[mpMaterialTable->mUniqueMatNum];
J3D_ASSERT_ALLOCMEM(945, mpMaterialTable->field_0x10);
} else {
mpMaterialTable->field_0x10 = NULL;
}
if (i_flags & 0x200000) {
for (u16 i = 0; i < mpMaterialTable->mUniqueMatNum; i++) {
factory.create(&mpMaterialTable->field_0x10[i], i, i_flags);
mpMaterialTable->field_0x10[i].mDiffFlag = (uintptr_t)&mpMaterialTable->field_0x10[i] >> 4;
}
}
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i] = factory.create(NULL, i, i_flags);
}
if (i_flags & 0x200000) {
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
(uintptr_t)&mpMaterialTable->field_0x10[factory.getMaterialID(i)] >> 4;
mpMaterialTable->mMaterialNodePointer[i]->mpOrigMaterial =
&mpMaterialTable->field_0x10[factory.getMaterialID(i)];
}
} else {
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xc0000000;
}
}
}
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);
shape_table->mShapeNum = i_block->mShapeNum;
if (i_block->mpNameTable != NULL) {
shape_table->mShapeName =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1026, shape_table->mShapeName);
} else {
shape_table->mShapeName = NULL;
}
shape_table->mShapeNodePointer = JKR_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;
for (; hierarchy_entry->mType != 0; hierarchy_entry++) {
if (hierarchy_entry->mType == 0x12) {
shape_table->mShapeNodePointer[hierarchy_entry->mValue] =
factory.create(hierarchy_entry->mValue, i_flags, vtx_desc_list);
vtx_desc_list = factory.getVtxDescList(hierarchy_entry->mValue);
}
}
}
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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1077, mpMaterialTable->mTextureName);
} else {
mpMaterialTable->mTextureName = NULL;
}
mpMaterialTable->mTexture = JKR_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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1114, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_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);
}
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
(uintptr_t)mpMaterialTable->mMaterialNodePointer + factory.getMaterialID(i);
}
}
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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1165, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_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);
}
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
((uintptr_t)mpMaterialTable->mMaterialNodePointer >> 4) + factory.getMaterialID(i);
}
}
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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1211, mpMaterialTable->mTextureName);
} else {
mpMaterialTable->mTextureName = NULL;
}
mpMaterialTable->mTexture = JKR_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 =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1251, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_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] =
factory.create(NULL, J3DMaterialFactory::MATERIAL_TYPE_PATCHED, i, i_flags);
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag =
((uintptr_t)mpMaterialTable->mMaterialNodePointer >> 4) + factory.getMaterialID(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) {
mpMaterialTable->field_0x1c = 1;
mpMaterialTable->mMaterialNum = i_block->mMaterialNum;
mpMaterialTable->mUniqueMatNum = i_block->mMaterialNum;
if (i_block->mpNameTable != NULL) {
mpMaterialTable->mMaterialName =
JKR_NEW JUTNameTab(JSUConvertOffsetToPtr<ResNTAB>(i_block, i_block->mpNameTable));
J3D_ASSERT_ALLOCMEM(1312, mpMaterialTable->mMaterialName);
} else {
mpMaterialTable->mMaterialName = NULL;
}
mpMaterialTable->mMaterialNodePointer = JKR_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;
mpMaterialTable->mMaterialNodePointer[i] =
factory.create(NULL, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
mpMaterialTable->mMaterialNodePointer[i]->mDiffFlag = 0xc0000000;
}
} else {
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
flags = i_flags;
mpMaterialTable->mMaterialNodePointer[i] =
factory.create(mpMaterialTable->mMaterialNodePointer[i],
J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
}
}
void J3DModelLoader::modifyMaterial(u32 i_flags) {
if (i_flags & 0x2000) {
J3DMaterialFactory factory(*mpMaterialBlock);
for (u16 i = 0; i < mpMaterialTable->mMaterialNum; i++) {
factory.modifyPatchedCurrentMtx(mpMaterialTable->mMaterialNodePointer[i], i);
}
}
}
libs/JSystem/src/J3DGraphLoader/J3DModelLoaderCalcSize.cpp
+328
View File
@@ -0,0 +1,328 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DModelLoaderCalcSize.h"
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/J3DGraphLoader/J3DShapeFactory.h"
#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/J3DGraphAnimator/J3DJoint.h"
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
#include "JSystem/JSupport/JSupport.h"
#include <os.h>
#include "global.h"
u16 J3DModelLoader::countMaterialNum(const void* stream) {
const J3DModelFileData* header = (const J3DModelFileData*)stream;
const J3DModelBlock* block = header->mBlocks;
for (int i = 0; i < header->mBlockNum; i++)
{
if (block->mBlockType == 'MAT3') {
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_;
size_t size = 0;
// TODO: What sizeof will get us a size of 0xE4?
size += 0xE4;
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);
break;
case 'JNT1':
size += calcSizeJoint((const J3DJointBlock*)nextBlock);
break;
case 'MAT3':
size += calcSizeMaterial((const J3DMaterialBlock*)nextBlock, flags);
break;
case 'SHP1':
size += calcSizeShape((const J3DShapeBlock*)nextBlock, flags);
break;
case 'TEX1':
size += calcSizeTexture((const J3DTextureBlock*)nextBlock);
break;
case 'EVP1':
size += calcSizeEnvelope((const J3DEnvelopeBlock*)nextBlock);
break;
case 'DRW1':
size += calcSizeDraw((const J3DDrawBlock*)nextBlock);
break;
case 'VTX1':
break;
case 'MAT2':
JUT_PANIC(282, "Error : version error.");
break;
default:
OSReport("Unknown data block\n");
break;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
return size;
}
u32 J3DModelLoader::calcLoadMaterialTableSize(const void* stream) {
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;
const J3DModelFileData* header = reinterpret_cast<const J3DModelFileData*>(stream);
nextBlock = header->mBlocks;
hasTextureTable = false;
for (u32 i = 0; i < header->mBlockNum; i++) {
switch (nextBlock->mBlockType) {
case 'MAT3':
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;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
if (!hasTextureTable) {
size += 12;
}
return size;
}
inline u32 getBdlFlag_MaterialType(u32 flags) {
return flags & (J3DMLF_13 | J3DMLF_DoBdlMaterialCalc);
}
// NONMATCHING flags issue
u32 J3DModelLoader::calcLoadBinaryDisplayListSize(const void* stream, u32 flags) {
u32 size = 0;
size += sizeof(J3DModelData);
const J3DModelFileData* header = (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, (u32)flags);
break;
case 'JNT1':
size += calcSizeJoint((const J3DJointBlock*)nextBlock);
break;
case 'SHP1':
size += calcSizeShape((const J3DShapeBlock*)nextBlock, (u32)flags);
break;
case 'TEX1':
size += calcSizeTexture((const J3DTextureBlock*)nextBlock);
break;
case 'MDL3':
size += calcSizeMaterialDL((const J3DMaterialDLBlock*)nextBlock, flags);
break;
case 'MAT3': {
u32 flags2 = (J3DMLF_21 | J3DMLF_Material_PE_Full | J3DMLF_Material_Color_LightOn);
flags2 |= (u32)flags & (J3DMLF_Material_UseIndirect | J3DMLF_26);
mpMaterialBlock = (const J3DMaterialBlock*)nextBlock;
u32 flag_mtl_type = getBdlFlag_MaterialType(flags);
if (flag_mtl_type == 0) {
field_0x18 = 1;
size += calcSizeMaterial((const J3DMaterialBlock*)nextBlock, flags2);
} else if (flag_mtl_type == J3DMLF_DoBdlMaterialCalc) {
field_0x18 = 1;
size += calcSizePatchedMaterial((const J3DMaterialBlock*)nextBlock, flags2);
}
break;
}
case 'EVP1':
size += calcSizeEnvelope((const J3DEnvelopeBlock*)nextBlock);
break;
case 'DRW1':
size += calcSizeDraw((const J3DDrawBlock*)nextBlock);
break;
case 'VTX1':
break;
case 'MAT2':
JUT_PANIC(436, "Error : version error.");
break;
default:
OSReport("Unknown data block\n");
break;
}
nextBlock = (const J3DModelBlock*)((u8*)nextBlock + nextBlock->mBlockSize);
}
return size;
}
u32 J3DModelLoader::calcSizeInformation(const J3DModelInfoBlock* block, u32 flags) {
J3D_ASSERT_NULLPTR(462, block);
int size = 0;
u32 flags2 = flags | block->mFlags;
int r27 = 0;
switch (flags2 & J3DMLF_MtxTypeMask) {
case J3DMLF_None: // Basic
size += 4;
break;
case J3DMLF_MtxSoftImageCalc:
size += 4;
break;
case J3DMLF_MtxMayaCalc:
size += 4;
break;
default:
JUT_PANIC(481, "Error : Invalid MtxCalcType.");
break;
}
mpModelHierarchy = JSUConvertOffsetToPtr<J3DModelHierarchy>(block, block->mpHierarchy);
return size;
}
u32 J3DModelLoader::calcSizeJoint(const J3DJointBlock* block) {
J3D_ASSERT_NULLPTR(499, block);
int size = 0;
if (block->mpNameTable) {
size += 0x10;
}
size += (block->mJointNum * sizeof(J3DJoint*));
size += (block->mJointNum * sizeof(J3DJoint));
return size;
}
u32 J3DModelLoader::calcSizeEnvelope(const J3DEnvelopeBlock* block) {
J3D_ASSERT_NULLPTR(522, block);
mEnvelopeSize = block->mWEvlpMtxNum;
return 0;
}
u32 J3DModelLoader::calcSizeDraw(const J3DDrawBlock* block) {
J3D_ASSERT_NULLPTR(538, block);
u32 size = 0;
size += (block->mMtxNum - mEnvelopeSize) * 2;
return size;
}
u32 J3DModelLoader_v26::calcSizeMaterial(const J3DMaterialBlock* block, u32 flags) {
J3D_ASSERT_NULLPTR(558, block);
size_t size = 0;
J3DMaterialFactory factory(*block);
u32 count = block->mMaterialNum;
int uniqueCount = factory.countUniqueMaterials();
if (block->mpNameTable != NULL) {
size += 0x10;
}
size += (count * sizeof(J3DMaterial*));
if ((flags & J3DMLF_UseUniqueMaterials) != 0) {
// calc for allocated materials as well
size += ALIGN_NEXT((u16)uniqueCount * sizeof(J3DMaterial), 0x20);
}
if ((flags & J3DMLF_UseUniqueMaterials) != 0) {
for (u32 i = 0; i < uniqueCount; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
}
for (u32 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
return size;
}
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 += count * sizeof(J3DShape*);
size += factory.calcSizeVcdVatCmdBuffer(count);
J3DModelHierarchy* hierarchy;
for (hierarchy = mpModelHierarchy; hierarchy->mType != 0; hierarchy++) {
if (hierarchy->mType == 0x12) {
size += factory.calcSize(hierarchy->mValue, flags);
}
}
return size;
}
u32 J3DModelLoader::calcSizeTexture(const J3DTextureBlock* block) {
J3D_ASSERT_NULLPTR(663, block);
// TODO: use sizeofs here.
int size = 0;
if (block->mpNameTable) {
size += 0x10;
}
size += 0xC;
return size;
}
u32 J3DModelLoader_v26::calcSizeMaterialTable(const J3DMaterialBlock* block, u32 flags) {
int size = 0;
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
size += 0x10;
}
size += (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_NORMAL, i, flags);
}
return size;
}
u32 J3DModelLoader::calcSizeTextureTable(const J3DTextureBlock* block) {
return calcSizeTexture(block);
}
u32 J3DModelLoader::calcSizePatchedMaterial(const J3DMaterialBlock* block, u32 flags) {
int size = 0;
u32 count = block->mMaterialNum;
J3DMaterialFactory factory(*block);
if (block->mpNameTable) {
size += 0x10;
}
size += (count * sizeof(J3DMaterial*));
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_PATCHED, i, flags);
}
return size;
}
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 += count * sizeof(J3DLockedMaterial*);
for (u16 i = 0; i < count; i++) {
size += factory.calcSize(NULL, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
} else {
u32 count = block->mMaterialNum;
for (u16 i = 0; i < count; i++) {
size += factory.calcSize((J3DMaterial*)this, J3DMaterialFactory::MATERIAL_TYPE_LOCKED, i, flags);
}
}
return size;
}
libs/JSystem/src/J3DGraphLoader/J3DShapeFactory.cpp
+212
View File
@@ -0,0 +1,212 @@
#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J3DGraphLoader/J3DShapeFactory.h"
#include "JSystem/J3DGraphBase/J3DShape.h"
#include "JSystem/J3DGraphBase/J3DShapeMtx.h"
#include "JSystem/JKernel/JKRHeap.h"
#include "JSystem/JSupport/JSupport.h"
#include <os.h>
#include "global.h"
#include <algorithm>
J3DShapeFactory::J3DShapeFactory(J3DShapeBlock const& block) {
mShapeInitData = JSUConvertOffsetToPtr<J3DShapeInitData>(&block, (uintptr_t)block.mpShapeInitData);
mIndexTable = JSUConvertOffsetToPtr<BE(u16)>(&block, (uintptr_t)block.mpIndexTable);
mVtxDescList = JSUConvertOffsetToPtr<GXVtxDescList>(&block, (uintptr_t)block.mpVtxDescList);
mMtxTable = JSUConvertOffsetToPtr<BE(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);
mVcdVatCmdBuffer = NULL;
#if TARGET_LITTLE_ENDIAN
// mVtxDescList is in big endian, swap to little endian.
int maxVtxDescListStart = 0;
for (int shapeIdx = 0; shapeIdx < block.mShapeNum; shapeIdx++) {
u16 thisIndex = mShapeInitData[mIndexTable[shapeIdx]].mVtxDescListIndex;
maxVtxDescListStart = std::max(
maxVtxDescListStart,
(int)(thisIndex / sizeof(GXVtxDescList)));
}
GXVtxDescList* lastEntry = mVtxDescList + maxVtxDescListStart;
while (lastEntry->attr != BE(GXAttr)::swap(GX_VA_NULL)) {
lastEntry++;
}
for (GXVtxDescList* entry = mVtxDescList; entry <= lastEntry; entry++) {
*entry = BE(GXVtxDescList)::swap(*entry);
}
#endif
}
J3DShape* J3DShapeFactory::create(int no, u32 flag, GXVtxDescList* vtxDesc) {
J3DShape* shape = JKR_NEW J3DShape;
J3D_ASSERT_ALLOCMEM(67, shape);
shape->mMtxGroupNum = getMtxGroupNum(no);
shape->mRadius = getRadius(no);
shape->mVtxDesc = getVtxDescList(no);
shape->mShapeMtx = JKR_NEW J3DShapeMtx*[shape->mMtxGroupNum];
J3D_ASSERT_ALLOCMEM(74, shape->mShapeMtx);
shape->mShapeDraw = JKR_NEW J3DShapeDraw*[shape->mMtxGroupNum];
J3D_ASSERT_ALLOCMEM(76, shape->mShapeDraw);
shape->mMin = getMin(no);
shape->mMax = getMax(no);
shape->mVcdVatCmd = mVcdVatCmdBuffer + no * J3DShape::kVcdVatDLSize;
for (s32 i = 0; i < shape->mMtxGroupNum; i++) {
shape->mShapeMtx[i] = newShapeMtx(flag, no, i);
shape->mShapeDraw[i] = newShapeDraw(no, i);
}
shape->mIndex = no;
return shape;
}
enum {
J3DMdlDataFlag_ConcatView = 0x10,
};
enum {
J3DShapeMtxType_Mtx = 0x00,
J3DShapeMtxType_BBoard = 0x01,
J3DShapeMtxType_YBBoard = 0x02,
J3DShapeMtxType_Multi = 0x03,
};
J3DShapeMtx* J3DShapeFactory::newShapeMtx(u32 flag, int shapeNo, int mtxGroupNo) const {
J3DShapeMtx* ret = NULL;
const J3DShapeInitData& shapeInitData = mShapeInitData[mIndexTable[shapeNo]];
const J3DShapeMtxInitData& mtxInitData =
(&mMtxInitData[shapeInitData.mMtxInitDataIndex])[mtxGroupNo];
u32 mtxLoadType = getMdlDataFlag_MtxLoadType(flag);
switch (mtxLoadType) {
case J3DMdlDataFlag_ConcatView:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
ret = JKR_NEW J3DShapeMtxConcatView(mtxInitData.mUseMtxIndex);
break;
case J3DShapeMtxType_BBoard:
ret = JKR_NEW J3DShapeMtxBBoardConcatView(mtxInitData.mUseMtxIndex);
break;
case J3DShapeMtxType_YBBoard:
ret = JKR_NEW J3DShapeMtxYBBoardConcatView(mtxInitData.mUseMtxIndex);
break;
case J3DShapeMtxType_Multi:
ret = JKR_NEW J3DShapeMtxMultiConcatView(mtxInitData.mUseMtxIndex, mtxInitData.mUseMtxCount,
&mMtxTable[mtxInitData.mFirstUseMtxIndex]);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");
break;
}
break;
case 0:
default:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
case J3DShapeMtxType_BBoard:
case J3DShapeMtxType_YBBoard:
ret = JKR_NEW J3DShapeMtx(mtxInitData.mUseMtxIndex);
break;
case J3DShapeMtxType_Multi:
ret = JKR_NEW J3DShapeMtxMulti(mtxInitData.mUseMtxIndex, mtxInitData.mUseMtxCount,
&mMtxTable[mtxInitData.mFirstUseMtxIndex]);
break;
default:
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];
shapeDraw = JKR_NEW J3DShapeDraw(&mDisplayListData[drawInitData.mDisplayListIndex], drawInitData.mDisplayListSize);
J3D_ASSERT_ALLOCMEM(193, shapeDraw);
return shapeDraw;
}
void J3DShapeFactory::allocVcdVatCmdBuffer(u32 count) {
mVcdVatCmdBuffer = JKR_NEW_ARGS (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 = 0;
s32 mtxGroupNo = getMtxGroupNum(shapeNo);
size += sizeof(J3DShape);
size += mtxGroupNo * 4;
size += mtxGroupNo * 4;
for (u32 i = 0; i < mtxGroupNo; i++) {
size += calcSizeShapeMtx(flag, shapeNo, i);
size += 0x0C;
}
return size;
}
s32 J3DShapeFactory::calcSizeVcdVatCmdBuffer(u32 count) {
return ALIGN_NEXT(count * J3DShape::kVcdVatDLSize, 0x20);
}
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);
switch (mtxLoadType) {
case J3DMdlDataFlag_ConcatView:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
ret += sizeof(J3DShapeMtxConcatView);
break;
case J3DShapeMtxType_BBoard:
ret += sizeof(J3DShapeMtxBBoardConcatView);
break;
case J3DShapeMtxType_YBBoard:
ret += sizeof(J3DShapeMtxYBBoardConcatView);
break;
case J3DShapeMtxType_Multi:
ret += sizeof(J3DShapeMtxMultiConcatView);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");
}
break;
case 0:
default:
switch (shapeInitData.mShapeMtxType) {
case J3DShapeMtxType_Mtx:
case J3DShapeMtxType_BBoard:
case J3DShapeMtxType_YBBoard:
ret += 0x08;
break;
case J3DShapeMtxType_Multi:
ret += sizeof(J3DShapeMtxMultiConcatView);
break;
default:
OSReport("WRONG SHAPE MATRIX TYPE (J3DModelInit.cpp)\n");
}
break;
}
return ret;
}