summaryrefslogtreecommitdiff
path: root/src/JSystem/J3DGraphAnimator
diff options
context:
space:
mode:
authorTakaRikka <38417346+TakaRikka@users.noreply.github.com>2025-09-04 07:56:59 -0700
committerGitHub <noreply@github.com>2025-09-04 17:56:59 +0300
commitb45a089e15d79821b07be020db628e01a49b1fd2 (patch)
tree948057548cc19b19d644bd4f300ca6434e6bff11 /src/JSystem/J3DGraphAnimator
parentee8b843996f4d888903f8c125b95ec1af376877e (diff)
some J3D/misc cleanup (#2628)
* some j3d cleanup * begin using uintptr_t * j3dgraphbase cleanup * j3dgraphanimator cleanup
Diffstat (limited to 'src/JSystem/J3DGraphAnimator')
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DAnimation.cpp1027
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DCluster.cpp50
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DJoint.cpp6
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DJointTree.cpp90
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DMaterialAnm.cpp82
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DMaterialAttach.cpp200
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DModel.cpp333
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DModelData.cpp33
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DMtxBuffer.cpp119
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DShapeTable.cpp5
-rw-r--r--src/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp521
11 files changed, 1327 insertions, 1139 deletions
diff --git a/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp b/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
index 78f0cd70ab..caf7a91a91 100644
--- a/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
@@ -1,19 +1,13 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DAnimation
-//
-
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
#include "JSystem/J3DGraphBase/J3DStruct.h"
#include "JSystem/JMath/JMath.h"
-#include "dolphin/os.h"
/* 803283FC-8032842C 322D3C 0030+00 0/0 25/25 285/285 .text init__12J3DFrameCtrlFs */
-void J3DFrameCtrl::init(s16 i_end) {
- mAttribute = 2;
+void J3DFrameCtrl::init(s16 endFrame) {
+ mAttribute = EMode_LOOP;
mState = 0;
mStart = 0;
- mEnd = i_end;
+ mEnd = endFrame;
mLoop = 0;
mRate = 1.0f;
mFrame = 0.0f;
@@ -21,9 +15,8 @@ void J3DFrameCtrl::init(s16 i_end) {
/* 8032842C-803289CC 322D6C 05A0+00 0/0 92/92 382/382 .text checkPass__12J3DFrameCtrlFf
*/
-int J3DFrameCtrl::checkPass(f32 pass_frame) {
- f32 cur_frame = mFrame;
- f32 next_frame = cur_frame + mRate;
+int J3DFrameCtrl::checkPass(f32 passFrame) {
+ f32 next_frame = mFrame + mRate;
switch (mAttribute) {
case 0:
@@ -36,20 +29,20 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame = mEnd - 0.001f;
}
- if (cur_frame <= next_frame) {
- if (cur_frame <= pass_frame && pass_frame < next_frame) {
+ if (mFrame <= next_frame) {
+ if (mFrame <= passFrame && passFrame < next_frame) {
return true;
} else {
return false;
}
}
- if (next_frame <= pass_frame && pass_frame < cur_frame) {
+ if (next_frame <= passFrame && passFrame < mFrame) {
return true;
}
return false;
case 2:
- if (cur_frame < mStart) {
+ if (mFrame < mStart) {
while (next_frame < mStart) {
if (mLoop - mStart <= 0.0f) {
break;
@@ -57,12 +50,12 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame += mLoop - mStart;
}
- if (next_frame <= pass_frame && pass_frame < mLoop) {
+ if (next_frame <= passFrame && passFrame < mLoop) {
return true;
} else {
return false;
}
- } else if (mEnd <= cur_frame) {
+ } else if (mEnd <= mFrame) {
while (next_frame >= mEnd) {
if (mEnd - mLoop <= 0.0f) {
break;
@@ -70,7 +63,7 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame -= mEnd - mLoop;
}
- if (mLoop <= pass_frame && pass_frame < next_frame) {
+ if (mLoop <= passFrame && passFrame < next_frame) {
return true;
} else {
return false;
@@ -83,7 +76,7 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame += mLoop - mStart;
}
- if ((mStart <= pass_frame && pass_frame < cur_frame) || (next_frame <= pass_frame && pass_frame < mLoop)) {
+ if ((mStart <= passFrame && passFrame < mFrame) || (next_frame <= passFrame && passFrame < mLoop)) {
return true;
} else {
return false;
@@ -97,18 +90,18 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame -= mEnd - mLoop;
}
- if ((cur_frame <= pass_frame && pass_frame < mEnd) || (mLoop <= pass_frame && pass_frame < next_frame)) {
+ if ((mFrame <= passFrame && passFrame < mEnd) || (mLoop <= passFrame && passFrame < next_frame)) {
return true;
} else {
return false;
}
- } else if (cur_frame <= next_frame) {
- if (cur_frame <= pass_frame && pass_frame < next_frame) {
+ } else if (mFrame <= next_frame) {
+ if (mFrame <= passFrame && passFrame < next_frame) {
return true;
} else {
return false;
}
- } else if (next_frame <= pass_frame && pass_frame < cur_frame) {
+ } else if (next_frame <= passFrame && passFrame < mFrame) {
return true;
}
return false;
@@ -122,15 +115,15 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
next_frame = mStart;
}
- if (cur_frame <= next_frame) {
- if (cur_frame <= pass_frame && pass_frame < next_frame) {
+ if (mFrame <= next_frame) {
+ if (mFrame <= passFrame && passFrame < next_frame) {
return true;
} else {
return false;
}
}
- if (next_frame <= pass_frame && pass_frame < cur_frame) {
+ if (next_frame <= passFrame && passFrame < mFrame) {
return true;
}
return false;
@@ -144,48 +137,49 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
void J3DFrameCtrl::update() {
mState = 0;
mFrame += mRate;
+
switch (mAttribute) {
- case 0:
+ case EMode_NONE:
if (mFrame < mStart) {
mFrame = mStart;
mRate = 0.0f;
- mState |= 1;
+ mState |= (u8)1;
}
if (mFrame >= mEnd) {
mFrame = mEnd - 0.001f;
mRate = 0.0f;
- mState |= 1;
+ mState |= (u8)1;
}
break;
- case 1:
+ case EMode_RESET:
if (mFrame < mStart) {
mFrame = mStart;
mRate = 0.0f;
- mState |= 1;
+ mState |= (u8)1;
}
if (mFrame >= mEnd) {
mFrame = mStart;
mRate = 0.0f;
- mState |= 1;
+ mState |= (u8)1;
}
break;
- case 2:
+ case EMode_LOOP:
while (mFrame < mStart) {
- mState |= 2;
+ mState |= (u8)2;
if (mLoop - mStart <= 0.0f) {
break;
}
mFrame += mLoop - mStart;
}
while (mFrame >= mEnd) {
- mState |= 2;
+ mState |= (u8)2;
if (mEnd - mLoop <= 0.0f) {
break;
}
mFrame -= mEnd - mLoop;
}
break;
- case 3:
+ case EMode_REVERSE:
if (mFrame >= mEnd) {
mFrame = mEnd - (mFrame - mEnd);
mRate = -mRate;
@@ -193,10 +187,10 @@ void J3DFrameCtrl::update() {
if (mFrame < mStart) {
mFrame = mStart - (mFrame - mStart);
mRate = 0.0f;
- mState |= 1;
+ mState |= (u8)1;
}
break;
- case 4:
+ case EMode_LOOP_REVERSE:
if (mFrame >= mEnd - 1.0f) {
mFrame = (mEnd - 1.0f) - (mFrame - (mEnd - 1.0f));
mRate = -mRate;
@@ -204,19 +198,18 @@ void J3DFrameCtrl::update() {
if (mFrame < mStart) {
mFrame = mStart - (mFrame - mStart);
mRate = -mRate;
- mState |= 2;
+ mState |= (u8)2;
}
break;
}
}
-
/* 80328E40-80328E90 323780 0050+00 0/0 3/3 0/0 .text __ct__15J3DAnmTransformFsPfPsPf */
-J3DAnmTransform::J3DAnmTransform(s16 param_0, f32* param_1, s16* param_2, f32* param_3)
- : J3DAnmBase(param_0) {
- mScaleData = param_1;
- mRotData = param_2;
- mTransData = param_3;
+J3DAnmTransform::J3DAnmTransform(s16 frameMax, f32* pScaleData, s16* pRotData, f32* pTransData)
+ : J3DAnmBase(frameMax) {
+ mScaleData = pScaleData;
+ mRotData = pRotData;
+ mTransData = pTransData;
field_0x18 = 0;
field_0x1a = 0;
field_0x1c = 0;
@@ -225,169 +218,207 @@ J3DAnmTransform::J3DAnmTransform(s16 param_0, f32* param_1, s16* param_2, f32* p
/* 80328E90-803291F0 3237D0 0360+00 1/0 0/0 0/0 .text
* getTransform__19J3DAnmTransformFullCFUsP16J3DTransformInfo */
-void J3DAnmTransformFull::getTransform(u16 i_index, J3DTransformInfo* o_transform) const {
- u16 idx = i_index * 3;
+void J3DAnmTransformFull::getTransform(u16 jointNo, J3DTransformInfo* pTransform) const {
+ J3D_ASSERT_RANGE(317, jointNo >= 0 && jointNo < field_0x1e);
+ J3D_ASSERT_NULLPTR(318, pTransform != NULL);
+
+ u16 idx = jointNo * 3;
J3DAnmTransformFullTable* entryX = &mAnmTable[idx];
J3DAnmTransformFullTable* entryY = &mAnmTable[idx + 1];
J3DAnmTransformFullTable* entryZ = &mAnmTable[idx + 2];
+
if (mFrame < 0.0f) {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset];
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset];
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset];
- o_transform->mRotation.x = mRotData[entryX->mRotationOffset];
- o_transform->mRotation.y = mRotData[entryY->mRotationOffset];
- o_transform->mRotation.z = mRotData[entryZ->mRotationOffset];
- o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset];
- o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset];
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset];
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset];
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset];
+
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset];
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset];
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset];
+
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset];
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset];
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
} else {
+ u32 frame_max;
u32 frame = (int)(mFrame + 0.5f);
- if (frame >= entryX->mScaleMaxFrame) {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+
+ frame_max = entryX->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
}
- if (frame >= entryX->mRotationMaxFrame) {
- o_transform->mRotation.x =
- mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+ frame_max = entryX->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
}
- if (frame >= entryX->mTranslateMaxFrame) {
- o_transform->mTranslate.x =
- mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+ frame_max = entryX->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
}
- if (frame >= entryY->mScaleMaxFrame) {
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+ frame_max = entryY->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
}
- if (frame >= entryY->mRotationMaxFrame) {
- o_transform->mRotation.y =
- mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+ frame_max = entryY->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
}
- if (frame >= entryY->mTranslateMaxFrame) {
- o_transform->mTranslate.y =
- mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+ frame_max = entryY->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
}
- if (frame >= entryZ->mScaleMaxFrame) {
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+ frame_max = entryZ->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
}
- if (frame >= entryZ->mRotationMaxFrame) {
- o_transform->mRotation.z =
- mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+ frame_max = entryZ->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
}
- if (frame >= entryZ->mTranslateMaxFrame) {
- o_transform->mTranslate.z =
- mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+ frame_max = entryZ->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
}
}
}
/* 803291F0-80329A34 323B30 0844+00 1/0 0/0 0/0 .text
* getTransform__27J3DAnmTransformFullWithLerpCFUsP16J3DTransformInfo */
-void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_transform) const {
- u16 idx = i_index * 3;
+void J3DAnmTransformFullWithLerp::getTransform(u16 jointNo, J3DTransformInfo* pTransform) const {
+ J3D_ASSERT_RANGE(421, jointNo >= 0 && jointNo < field_0x1e);
+ J3D_ASSERT_NULLPTR(422, pTransform != NULL);
+
+ u16 idx = jointNo * 3;
J3DAnmTransformFullTable* entryX = &mAnmTable[idx];
J3DAnmTransformFullTable* entryY = &mAnmTable[idx + 1];
J3DAnmTransformFullTable* entryZ = &mAnmTable[idx + 2];
+
if (mFrame < 0.0f) {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset];
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset];
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset];
- o_transform->mRotation.x = mRotData[entryX->mRotationOffset];
- o_transform->mRotation.y = mRotData[entryY->mRotationOffset];
- o_transform->mRotation.z = mRotData[entryZ->mRotationOffset];
- o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset];
- o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset];
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset];
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset];
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset];
+
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset];
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset];
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset];
+
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset];
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset];
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
} else {
- int frame_ = (int)mFrame;
- u32 frame = frame_;
- if (frame_ == mFrame) {
- if (frame >= entryX->mScaleMaxFrame) {
- o_transform->mScale.x =
- mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+ u32 frame_max;
+ int frame = (int)mFrame;
+
+ if (frame == mFrame) {
+ frame_max = entryX->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
}
- if (frame >= entryX->mRotationMaxFrame) {
- o_transform->mRotation.x =
- mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+ frame_max = entryX->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
}
- if (frame >= entryX->mTranslateMaxFrame) {
- o_transform->mTranslate.x =
- mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+ frame_max = entryX->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
}
- if (frame >= entryY->mScaleMaxFrame) {
- o_transform->mScale.y =
- mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+ frame_max = entryY->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
}
- if (frame >= entryY->mRotationMaxFrame) {
- o_transform->mRotation.y =
- mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+ frame_max = entryY->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
}
- if (frame >= entryY->mTranslateMaxFrame) {
- o_transform->mTranslate.y =
- mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+ frame_max = entryY->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
}
- if (frame >= entryZ->mScaleMaxFrame) {
- o_transform->mScale.z =
- mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+ frame_max = entryZ->mScaleMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
}
- if (frame >= entryZ->mRotationMaxFrame) {
- o_transform->mRotation.z =
- mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+ frame_max = entryZ->mRotationMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
} else {
- o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
}
- if (frame >= entryZ->mTranslateMaxFrame) {
- o_transform->mTranslate.z =
- mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+ frame_max = entryZ->mTranslateMaxFrame;
+ if (frame >= frame_max) {
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
}
} else {
- f32 rate = mFrame - frame_;
- u32 frame2 = frame + 1;
- if (frame2 >= entryX->mScaleMaxFrame) {
- o_transform->mScale.x =
- mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+ f32 rate = mFrame - frame;
+ f32 var_f30 = 1.0f - rate;
+
+ u32 next_frame = frame + 1;
+
+ frame_max = entryX->mScaleMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
- + rate * (mScaleData[entryX->mScaleOffset + frame2]
+ pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
+ + rate * (mScaleData[entryX->mScaleOffset + next_frame]
- mScaleData[entryX->mScaleOffset + frame]);
}
- if (frame2 >= entryX->mRotationMaxFrame) {
- o_transform->mRotation.x =
- mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+ frame_max = entryX->mRotationMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
} else {
u32 rot1 = (u16)mRotData[entryX->mRotationOffset + frame];
- u32 rot2 = (u16)mRotData[entryX->mRotationOffset + frame2];
+ u32 rot2 = (u16)mRotData[entryX->mRotationOffset + next_frame];
int delta = rot2 - rot1;
if (delta > 0x8000) {
rot1 += 0x10000;
@@ -395,30 +426,33 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
} else if (-delta > 0x8000) {
delta += 0x10000;
}
- o_transform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
+ pTransform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
}
- if (frame2 >= entryX->mTranslateMaxFrame) {
- o_transform->mTranslate.x =
- mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+ frame_max = entryX->mTranslateMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
- + rate * (mTransData[entryX->mTranslateOffset + frame2]
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
+ + rate * (mTransData[entryX->mTranslateOffset + next_frame]
- mTransData[entryX->mTranslateOffset + frame]);
}
- if (frame2 >= entryY->mScaleMaxFrame) {
- o_transform->mScale.y =
- mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+ frame_max = entryY->mScaleMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
- + rate * (mScaleData[entryY->mScaleOffset + frame2]
+ pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
+ + rate * (mScaleData[entryY->mScaleOffset + next_frame]
- mScaleData[entryY->mScaleOffset + frame]);
}
- if (frame2 >= entryY->mRotationMaxFrame) {
- o_transform->mRotation.y =
- mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+ frame_max = entryY->mRotationMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
} else {
u32 rot1 = (u16)mRotData[entryY->mRotationOffset + frame];
- u32 rot2 = (u16)mRotData[entryY->mRotationOffset + frame2];
+ u32 rot2 = (u16)mRotData[entryY->mRotationOffset + next_frame];
int delta = rot2 - rot1;
if (delta > 0x8000) {
rot1 += 0x10000;
@@ -426,30 +460,33 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
} else if (-delta > 0x8000) {
delta += 0x10000;
}
- o_transform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
+ pTransform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
}
- if (frame2 >= entryY->mTranslateMaxFrame) {
- o_transform->mTranslate.y =
- mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+ frame_max = entryY->mTranslateMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
- + rate * (mTransData[entryY->mTranslateOffset + frame2]
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
+ + rate * (mTransData[entryY->mTranslateOffset + next_frame]
- mTransData[entryY->mTranslateOffset + frame]);
}
- if (frame2 >= entryZ->mScaleMaxFrame) {
- o_transform->mScale.z =
- mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+ frame_max = entryZ->mScaleMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
} else {
- o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
- + rate * (mScaleData[entryZ->mScaleOffset + frame2]
+ pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
+ + rate * (mScaleData[entryZ->mScaleOffset + next_frame]
- mScaleData[entryZ->mScaleOffset + frame]);
}
- if (frame2 >= entryZ->mRotationMaxFrame) {
- o_transform->mRotation.z =
- mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+ frame_max = entryZ->mRotationMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
} else {
u32 rot1 = (u16)mRotData[entryZ->mRotationOffset + frame];
- u32 rot2 = (u16)mRotData[entryZ->mRotationOffset + frame2];
+ u32 rot2 = (u16)mRotData[entryZ->mRotationOffset + next_frame];
int delta = rot2 - rot1;
if (delta > 0x8000) {
rot1 += 0x10000;
@@ -457,14 +494,15 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
} else if (-delta > 0x8000) {
delta += 0x10000;
}
- o_transform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
+ pTransform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
}
- if (frame2 >= entryZ->mTranslateMaxFrame) {
- o_transform->mTranslate.z =
- mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+ frame_max = entryZ->mTranslateMaxFrame;
+ if (next_frame >= frame_max) {
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
} else {
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
- + rate * (mTransData[entryZ->mTranslateOffset + frame2]
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
+ + rate * (mTransData[entryZ->mTranslateOffset + next_frame]
- mTransData[entryZ->mTranslateOffset + frame]);
}
}
@@ -524,275 +562,294 @@ inline f32 J3DHermiteInterpolation(register f32 pp1, register s16 const* pp2,
}
template<typename T>
-f32 J3DGetKeyFrameInterpolation(f32 i_frame, J3DAnmKeyTableBase* i_entry, T* i_data) {
- if (i_frame < i_data[0]) {
- return i_data[1];
+f32 J3DGetKeyFrameInterpolation(f32 frame, J3DAnmKeyTableBase* pKeyTable, T* pData) {
+ J3D_ASSERT_NULLPTR(740, pData != NULL);
+
+ if (frame < pData[0]) {
+ return pData[1];
}
- if (i_entry->mType == 0) {
- u32 idx = i_entry->mMaxFrame - 1;
- if (i_data[idx * 3] <= i_frame) {
- return i_data[idx * 3 + 1];
+
+ if (pKeyTable->mType == 0) {
+ u32 idx = pKeyTable->mMaxFrame - 1;
+ if (pData[idx * 3] <= frame) {
+ return pData[idx * 3 + 1];
}
- u32 uVar7 = i_entry->mMaxFrame;
+
+ u32 uVar7 = pKeyTable->mMaxFrame;
while (uVar7 > 1) {
u32 uVar2 = uVar7 >> 1;
u32 tmp = uVar2 * 3;
- if (i_frame >= i_data[tmp]) {
- i_data += tmp;
+ if (frame >= pData[tmp]) {
+ pData += tmp;
uVar7 = uVar7 - uVar2;
} else {
uVar7 = uVar2;
}
}
- return J3DHermiteInterpolation(i_frame, &i_data[0], &i_data[1], &i_data[2],
- &i_data[3], &i_data[4], &i_data[5]);
+
+ f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[2], &pData[3], &pData[4], &pData[5]);
+ return interpolated;
} else {
- u32 idx = i_entry->mMaxFrame - 1;
- if (i_data[idx * 4] <= i_frame) {
- return i_data[idx * 4 + 1];
+ u32 idx = pKeyTable->mMaxFrame - 1;
+ if (pData[idx * 4] <= frame) {
+ return pData[idx * 4 + 1];
}
- u32 uVar7 = i_entry->mMaxFrame;
- while (uVar7 > 1) {
- u32 uVar2 = uVar7 >> 1;
- if (i_frame >= i_data[uVar2 * 4]) {
- i_data += uVar2 * 4;
- uVar7 = uVar7 - uVar2;
+
+ u32 var_r27 = pKeyTable->mMaxFrame;
+ while (var_r27 > 1) {
+ u32 var_r25 = var_r27 >> 1;
+ u32 var_r23 = var_r25 * 4;
+ if (frame >= pData[var_r23]) {
+ pData += var_r23;
+ var_r27 = var_r27 - var_r25;
} else {
- uVar7 = uVar2;
+ var_r27 = var_r25;
}
}
- return J3DHermiteInterpolation(i_frame, &i_data[0], &i_data[1], &i_data[3],
- &i_data[4], &i_data[5], &i_data[6]);
+
+ f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[3], &pData[4], &pData[5], &pData[6]);
+ return interpolated;
}
}
/* 80329A34-80329E5C 324374 0428+00 0/0 1/1 0/0 .text
* calcTransform__18J3DAnmTransformKeyCFfUsP16J3DTransformInfo */
-void J3DAnmTransformKey::calcTransform(f32 i_frame, u16 i_index,
- J3DTransformInfo* o_transform) const {
- u16 idx = i_index * 3;
+void J3DAnmTransformKey::calcTransform(f32 frame, u16 jointNo, J3DTransformInfo* pTransform) const {
+ J3D_ASSERT_RANGE(829, jointNo >= 0 && jointNo < field_0x1e);
+ J3D_ASSERT_NULLPTR(830, pTransform != NULL);
+
+ u16 idx = jointNo * 3;
J3DAnmTransformKeyTable* entryX = &mAnmTable[idx];
J3DAnmTransformKeyTable* entryY = &mAnmTable[idx + 1];
J3DAnmTransformKeyTable* entryZ = &mAnmTable[idx + 2];
+
switch (entryX->mScaleInfo.mMaxFrame) {
case 0:
- o_transform->mScale.x = 1.0f;
+ pTransform->mScale.x = 1.0f;
break;
case 1:
- o_transform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
+ pTransform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
break;
default:
- o_transform->mScale.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
+ pTransform->mScale.x = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
&mScaleData[entryX->mScaleInfo.mOffset]);
}
+
switch (entryY->mScaleInfo.mMaxFrame) {
case 0:
- o_transform->mScale.y = 1.0f;
+ pTransform->mScale.y = 1.0f;
break;
case 1:
- o_transform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
+ pTransform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
break;
default:
- o_transform->mScale.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
+ pTransform->mScale.y = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
&mScaleData[entryY->mScaleInfo.mOffset]);
}
+
switch (entryZ->mScaleInfo.mMaxFrame) {
case 0:
- o_transform->mScale.z = 1.0f;
+ pTransform->mScale.z = 1.0f;
break;
case 1:
- o_transform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
+ pTransform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
break;
default:
- o_transform->mScale.z = J3DGetKeyFrameInterpolation(i_frame, &entryZ->mScaleInfo,
+ pTransform->mScale.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mScaleInfo,
&mScaleData[entryZ->mScaleInfo.mOffset]);
}
+
switch (entryX->mRotationInfo.mMaxFrame) {
case 0:
- o_transform->mRotation.x = 0;
+ pTransform->mRotation.x = 0;
break;
case 1:
- o_transform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
+ pTransform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
break;
default:
- o_transform->mRotation.x = (int)J3DGetKeyFrameInterpolation(i_frame, &entryX->mRotationInfo,
+ pTransform->mRotation.x = (int)J3DGetKeyFrameInterpolation(frame, &entryX->mRotationInfo,
&mRotData[entryX->mRotationInfo.mOffset]) << mDecShift;
}
+
switch (entryY->mRotationInfo.mMaxFrame) {
case 0:
- o_transform->mRotation.y = 0;
+ pTransform->mRotation.y = 0;
break;
case 1:
- o_transform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
+ pTransform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
break;
default:
- o_transform->mRotation.y = (int)J3DGetKeyFrameInterpolation(i_frame, &entryY->mRotationInfo,
+ pTransform->mRotation.y = (int)J3DGetKeyFrameInterpolation(frame, &entryY->mRotationInfo,
&mRotData[entryY->mRotationInfo.mOffset]) << mDecShift;
}
+
switch (entryZ->mRotationInfo.mMaxFrame) {
case 0:
- o_transform->mRotation.z = 0;
+ pTransform->mRotation.z = 0;
break;
case 1:
- o_transform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
+ pTransform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
break;
default:
- o_transform->mRotation.z = (int)J3DGetKeyFrameInterpolation(i_frame, &entryZ->mRotationInfo,
+ pTransform->mRotation.z = (int)J3DGetKeyFrameInterpolation(frame, &entryZ->mRotationInfo,
&mRotData[entryZ->mRotationInfo.mOffset]) << mDecShift;
}
+
switch (entryX->mTranslateInfo.mMaxFrame) {
case 0:
- o_transform->mTranslate.x = 0.0f;
+ pTransform->mTranslate.x = 0.0f;
break;
case 1:
- o_transform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
+ pTransform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
break;
default:
- o_transform->mTranslate.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
+ pTransform->mTranslate.x = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
&mTransData[entryX->mTranslateInfo.mOffset]);
}
+
switch (entryY->mTranslateInfo.mMaxFrame) {
case 0:
- o_transform->mTranslate.y = 0.0f;
+ pTransform->mTranslate.y = 0.0f;
break;
case 1:
- o_transform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
+ pTransform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
break;
default:
- o_transform->mTranslate.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mTranslateInfo,
+ pTransform->mTranslate.y = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
&mTransData[entryY->mTranslateInfo.mOffset]);
}
+
switch (entryZ->mTranslateInfo.mMaxFrame) {
case 0:
- o_transform->mTranslate.z = 0.0f;
+ pTransform->mTranslate.z = 0.0f;
break;
case 1:
- o_transform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
+ pTransform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
break;
default:
- o_transform->mTranslate.z = J3DGetKeyFrameInterpolation(i_frame, &entryZ->mTranslateInfo,
+ pTransform->mTranslate.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mTranslateInfo,
&mTransData[entryZ->mTranslateInfo.mOffset]);
}
}
/* 80329E5C-80329F14 32479C 00B8+00 0/0 2/2 0/0 .text __ct__19J3DAnmTextureSRTKeyFv */
-J3DAnmTextureSRTKey::J3DAnmTextureSRTKey() : J3DAnmBase(0) {
+J3DAnmTextureSRTKey::J3DAnmTextureSRTKey() {
mDecShift = 0;
- mTransNum = 0;
- mRotNum = 0;
- mScaleNum = 0;
- mTrackNum = 0;
+ mTrackNum = mScaleNum = mRotNum = mTransNum = 0;
mAnmTable = NULL;
- mTransData = NULL;
- mScaleData = NULL;
+ mScaleData = mTransData = NULL;
mRotData = NULL;
- field_0x48 = 0;
- field_0x46 = 0;
- field_0x44 = 0;
- field_0x4a = 0;
+ field_0x4a = field_0x44 = field_0x46 = field_0x48 = 0;
field_0x58 = NULL;
- field_0x54 = NULL;
- field_0x4c = NULL;
+ field_0x4c = field_0x54 = NULL;
field_0x50 = NULL;
mTexMtxCalcType = 0;
}
-
/* 80329F14-8032A184 324854 0270+00 0/0 1/1 0/0 .text
* calcTransform__19J3DAnmTextureSRTKeyCFfUsP17J3DTextureSRTInfo */
-void J3DAnmTextureSRTKey::calcTransform(f32 i_frame, u16 i_index,
- J3DTextureSRTInfo* o_texinfo) const {
- u16 idx = i_index * 3;
+void J3DAnmTextureSRTKey::calcTransform(f32 frame, u16 jointNo, J3DTextureSRTInfo* pTexSRTInfo) const {
+ J3D_ASSERT_RANGE(992, jointNo >= 0 && jointNo < mTrackNum);
+ J3D_ASSERT_NULLPTR(993, pTexSRTInfo != NULL);
+
+ u16 idx = jointNo * 3;
J3DAnmTransformKeyTable* entryX = &mAnmTable[idx];
J3DAnmTransformKeyTable* entryY = &mAnmTable[idx + 1];
J3DAnmTransformKeyTable* entryRot = &mAnmTable[idx + 2];
+
switch (entryX->mScaleInfo.mMaxFrame) {
case 0:
- o_texinfo->mScaleX = 1.0f;
+ pTexSRTInfo->mScaleX = 1.0f;
break;
case 1:
- o_texinfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
+ pTexSRTInfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
break;
default:
- o_texinfo->mScaleX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
+ pTexSRTInfo->mScaleX = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
&mScaleData[entryX->mScaleInfo.mOffset]);
}
+
switch (entryY->mScaleInfo.mMaxFrame) {
case 0:
- o_texinfo->mScaleY = 1.0f;
+ pTexSRTInfo->mScaleY = 1.0f;
break;
case 1:
- o_texinfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
+ pTexSRTInfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
break;
default:
- o_texinfo->mScaleY = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
+ pTexSRTInfo->mScaleY = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
&mScaleData[entryY->mScaleInfo.mOffset]);
}
+
switch (entryRot->mRotationInfo.mMaxFrame) {
case 0:
- o_texinfo->mRotation = 0;
+ pTexSRTInfo->mRotation = 0;
break;
case 1:
- o_texinfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
+ pTexSRTInfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
break;
default:
- o_texinfo->mRotation = (int)J3DGetKeyFrameInterpolation(i_frame, &entryRot->mRotationInfo,
+ pTexSRTInfo->mRotation = (int)J3DGetKeyFrameInterpolation(frame, &entryRot->mRotationInfo,
&mRotData[entryRot->mRotationInfo.mOffset]) << mDecShift;
}
+
switch (entryX->mTranslateInfo.mMaxFrame) {
case 0:
- o_texinfo->mTranslationX = 0.0f;
+ pTexSRTInfo->mTranslationX = 0.0f;
break;
case 1:
- o_texinfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
+ pTexSRTInfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
break;
default:
- o_texinfo->mTranslationX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
+ pTexSRTInfo->mTranslationX = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
&mTransData[entryX->mTranslateInfo.mOffset]);
}
+
switch (entryY->mTranslateInfo.mMaxFrame) {
case 0:
- o_texinfo->mTranslationY = 0.0f;
+ pTexSRTInfo->mTranslationY = 0.0f;
break;
case 1:
- o_texinfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
+ pTexSRTInfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
break;
default:
- o_texinfo->mTranslationY = J3DGetKeyFrameInterpolation(i_frame, &entryY->mTranslateInfo,
+ pTexSRTInfo->mTranslationY = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
&mTransData[entryY->mTranslateInfo.mOffset]);
}
}
/* 8032A184-8032A218 324AC4 0094+00 1/0 0/0 0/0 .text getWeight__17J3DAnmClusterFullCFUs
*/
-f32 J3DAnmClusterFull::getWeight(u16 i_index) const {
- int maxFrame = mAnmTable[i_index].mMaxFrame;
+f32 J3DAnmClusterFull::getWeight(u16 index) const {
+ int maxFrame = mAnmTable[index].mMaxFrame;
int frame = (int)(mFrame + 0.5f);
+
if (mFrame < 0.0f) {
- return mWeight[mAnmTable[i_index].mOffset];
- } else if (frame >= maxFrame) {
- return mWeight[mAnmTable[i_index].mOffset + (maxFrame - 1)];
+ return mWeight[mAnmTable[index].mOffset];
+ } else if (frame >= (u16)maxFrame) {
+ return mWeight[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
} else {
- return mWeight[mAnmTable[i_index].mOffset + frame];
+ return mWeight[mAnmTable[index].mOffset + frame];
}
}
/* 8032A218-8032A29C 324B58 0084+00 1/0 0/0 0/0 .text getWeight__16J3DAnmClusterKeyCFUs
*/
-f32 J3DAnmClusterKey::getWeight(u16 i_index) const {
- switch (mAnmTable[i_index].mWeightTable.mMaxFrame) {
+f32 J3DAnmClusterKey::getWeight(u16 index) const {
+ int maxFrame = (u16)mAnmTable[index].mWeightTable.mMaxFrame;
+ switch (maxFrame) {
case 0:
return 1.0f;
case 1:
- return mWeight[mAnmTable[i_index].mWeightTable.mOffset];
+ return mWeight[mAnmTable[index].mWeightTable.mOffset];
default:
- return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[i_index].mWeightTable,
- &mWeight[mAnmTable[i_index].mWeightTable.mOffset]);
+ return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[index].mWeightTable,
+ &mWeight[mAnmTable[index].mWeightTable.mOffset]);
}
}
/* 8032A29C-8032A30C 324BDC 0070+00 2/2 0/0 0/0 .text __ct__14J3DAnmVtxColorFv */
-J3DAnmVtxColor::J3DAnmVtxColor() : J3DAnmBase(0) {
+J3DAnmVtxColor::J3DAnmVtxColor() {
for (int i = 0; i < 2; i++) {
mAnmTableNum[i] = 0;
}
@@ -801,7 +858,6 @@ J3DAnmVtxColor::J3DAnmVtxColor() : J3DAnmBase(0) {
}
}
-
/* 8032A30C-8032A368 324C4C 005C+00 0/0 1/1 0/0 .text __ct__18J3DAnmVtxColorFullFv */
J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
for (int i = 0; i < 2; i++) {
@@ -811,34 +867,45 @@ J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
/* 8032A368-8032A4E0 324CA8 0178+00 1/0 0/0 0/0 .text
* getColor__18J3DAnmVtxColorFullCFUcUsP8_GXColor */
-void J3DAnmVtxColorFull::getColor(u8 i_table, u16 i_index, GXColor* o_color) const {
- J3DAnmColorFullTable* entry = &mpTable[i_table][i_index];
+void J3DAnmVtxColorFull::getColor(u8 tableNo, u16 index, GXColor* pColor) const {
+ J3D_ASSERT_NULLPTR(1254, pColor != NULL);
+ J3DAnmColorFullTable* entry = &mpTable[tableNo][index];
+
if (mFrame < 0.0f) {
- o_color->r = mColorR[entry->mROffset];
- o_color->g = mColorG[entry->mGOffset];
- o_color->b = mColorB[entry->mBOffset];
- o_color->a = mColorA[entry->mAOffset];
+ pColor->r = mColorR[entry->mROffset];
+ pColor->g = mColorG[entry->mGOffset];
+ pColor->b = mColorB[entry->mBOffset];
+ pColor->a = mColorA[entry->mAOffset];
} else {
int frame = (int)(mFrame + 0.5f);
- if (frame >= entry->mRMaxFrame) {
- o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
+ u16 maxFrame;
+
+ maxFrame = entry->mRMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
} else {
- o_color->r = mColorR[entry->mROffset + frame];
+ pColor->r = mColorR[entry->mROffset + frame];
}
- if (frame >= entry->mGMaxFrame) {
- o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
+
+ maxFrame = entry->mGMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
} else {
- o_color->g = mColorG[entry->mGOffset + frame];
+ pColor->g = mColorG[entry->mGOffset + frame];
}
- if (frame >= entry->mBMaxFrame) {
- o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
+
+ maxFrame = entry->mBMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
} else {
- o_color->b = mColorB[entry->mBOffset + frame];
+ pColor->b = mColorB[entry->mBOffset + frame];
}
- if (frame >= entry->mAMaxFrame) {
- o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
+
+ maxFrame = entry->mAMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
} else {
- o_color->a = mColorA[entry->mAOffset + frame];
+ pColor->a = mColorA[entry->mAOffset + frame];
}
}
}
@@ -852,93 +919,98 @@ J3DAnmVtxColorKey::J3DAnmVtxColorKey() {
/* 8032A53C-8032A828 324E7C 02EC+00 1/0 0/0 0/0 .text
* getColor__17J3DAnmVtxColorKeyCFUcUsP8_GXColor */
-void J3DAnmVtxColorKey::getColor(u8 i_table, u16 i_index, GXColor* o_color) const {
- J3DAnmColorKeyTable* entry = &mpTable[i_table][i_index];
+void J3DAnmVtxColorKey::getColor(u8 tableNo, u16 index, GXColor* pColor) const {
+ J3D_ASSERT_NULLPTR(1338, pColor != NULL);
+ J3DAnmColorKeyTable* entry = &mpTable[tableNo][index];
+
f32 col;
switch (entry->mRInfo.mMaxFrame) {
case 0:
- o_color->r = 0;
+ pColor->r = 0;
break;
case 1:
- o_color->r = mColorR[entry->mRInfo.mOffset];
+ pColor->r = mColorR[entry->mRInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
&mColorR[entry->mRInfo.mOffset]);
if (col <= 0.0f) {
- o_color->r = 0;
+ pColor->r = 0;
} else if (col <= 255.0f) {
- OSf32tou8(&col, &o_color->r);
+ OSf32tou8(&col, &pColor->r);
} else {
- o_color->r = 255;
+ pColor->r = 255;
}
}
+
switch (entry->mGInfo.mMaxFrame) {
case 0:
- o_color->g = 0;
+ pColor->g = 0;
break;
case 1:
- o_color->g = mColorG[entry->mGInfo.mOffset];
+ pColor->g = mColorG[entry->mGInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
&mColorG[entry->mGInfo.mOffset]);
if (col <= 0.0f) {
- o_color->g = 0;
+ pColor->g = 0;
} else if (col <= 255.0f) {
- OSf32tou8(&col, &o_color->g);
+ OSf32tou8(&col, &pColor->g);
} else {
- o_color->g = 255;
+ pColor->g = 255;
}
}
+
switch (entry->mBInfo.mMaxFrame) {
case 0:
- o_color->b = 0;
+ pColor->b = 0;
break;
case 1:
- o_color->b = mColorB[entry->mBInfo.mOffset];
+ pColor->b = mColorB[entry->mBInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
&mColorB[entry->mBInfo.mOffset]);
if (col <= 0.0f) {
- o_color->b = 0;
+ pColor->b = 0;
} else if (col <= 255.0f) {
- OSf32tou8(&col, &o_color->b);
+ OSf32tou8(&col, &pColor->b);
} else {
- o_color->b = 255;
+ pColor->b = 255;
}
}
+
switch (entry->mAInfo.mMaxFrame) {
case 0:
- o_color->a = 0;
+ pColor->a = 0;
break;
case 1:
- o_color->a = mColorA[entry->mAInfo.mOffset];
+ pColor->a = mColorA[entry->mAInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
&mColorA[entry->mAInfo.mOffset]);
if (col <= 0.0f) {
- o_color->a = 0;
+ pColor->a = 0;
} else if (col <= 255.0f) {
- OSf32tou8(&col, &o_color->a);
+ OSf32tou8(&col, &pColor->a);
} else {
- o_color->a = 255;
+ pColor->a = 255;
}
}
}
/* 8032A828-8032A8A4 325168 007C+00 2/2 0/0 0/0 .text __ct__11J3DAnmColorFv */
-J3DAnmColor::J3DAnmColor() : J3DAnmBase(0), field_0xc(0), field_0xe(0), field_0x10(0),
+J3DAnmColor::J3DAnmColor() : field_0xc(0), field_0xe(0), field_0x10(0),
field_0x12(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
/* 8032A8A4-8032A93C 3251E4 0098+00 0/0 1/1 0/0 .text
* searchUpdateMaterialID__11J3DAnmColorFP16J3DMaterialTable */
-void J3DAnmColor::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
+void J3DAnmColor::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
- int index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+ int index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
if (index != -1) {
mUpdateMaterialID[i] = index;
} else {
@@ -957,34 +1029,46 @@ J3DAnmColorFull::J3DAnmColorFull() {
}
/* 8032A990-8032AB00 3252D0 0170+00 1/0 0/0 0/0 .text getColor__15J3DAnmColorFullCFUsP8_GXColor */
-void J3DAnmColorFull::getColor(u16 i_index, GXColor* o_color) const {
- J3DAnmColorFullTable* entry = &mAnmTable[i_index];
+void J3DAnmColorFull::getColor(u16 index, GXColor* pColor) const {
+ J3D_ASSERT_RANGE(1537, index >= 0 && index < mUpdateMaterialNum);
+ J3D_ASSERT_NULLPTR(1538, pColor != NULL);
+ J3DAnmColorFullTable* entry = &mAnmTable[index];
+
if (mFrame < 0.0f) {
- o_color->r = mColorR[entry->mROffset];
- o_color->g = mColorG[entry->mGOffset];
- o_color->b = mColorB[entry->mBOffset];
- o_color->a = mColorA[entry->mAOffset];
+ pColor->r = mColorR[entry->mROffset];
+ pColor->g = mColorG[entry->mGOffset];
+ pColor->b = mColorB[entry->mBOffset];
+ pColor->a = mColorA[entry->mAOffset];
} else {
int frame = (int)(mFrame + 0.5f);
- if (frame >= entry->mRMaxFrame) {
- o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
+ u16 maxFrame;
+
+ maxFrame = entry->mRMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
} else {
- o_color->r = mColorR[entry->mROffset + frame];
+ pColor->r = mColorR[entry->mROffset + frame];
}
- if (frame >= entry->mGMaxFrame) {
- o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
+
+ maxFrame = entry->mGMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
} else {
- o_color->g = mColorG[entry->mGOffset + frame];
+ pColor->g = mColorG[entry->mGOffset + frame];
}
- if (frame >= entry->mBMaxFrame) {
- o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
+
+ maxFrame = entry->mBMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
} else {
- o_color->b = mColorB[entry->mBOffset + frame];
+ pColor->b = mColorB[entry->mBOffset + frame];
}
- if (frame >= entry->mAMaxFrame) {
- o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
+
+ maxFrame = entry->mAMaxFrame;
+ if (frame >= maxFrame) {
+ pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
} else {
- o_color->a = mColorA[entry->mAOffset + frame];
+ pColor->a = mColorA[entry->mAOffset + frame];
}
}
}
@@ -999,130 +1083,143 @@ J3DAnmColorKey::J3DAnmColorKey() {
}
/* 8032AB54-8032AE18 325494 02C4+00 1/0 0/0 0/0 .text getColor__14J3DAnmColorKeyCFUsP8_GXColor */
-void J3DAnmColorKey::getColor(u16 i_index, GXColor* o_color) const {
- J3DAnmColorKeyTable* entry = &mAnmTable[i_index];
+void J3DAnmColorKey::getColor(u16 index, GXColor* pColor) const {
+ J3D_ASSERT_RANGE(1614, index >= 0 && index < mUpdateMaterialNum);
+ J3D_ASSERT_NULLPTR(1615, pColor != NULL);
+ J3DAnmColorKeyTable* entry = &mAnmTable[index];
+
f32 col;
switch (entry->mRInfo.mMaxFrame) {
case 0:
- o_color->r = 0;
+ pColor->r = 0;
break;
case 1:
- o_color->r = mColorR[entry->mRInfo.mOffset];
+ pColor->r = mColorR[entry->mRInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
&mColorR[entry->mRInfo.mOffset]);
if (col < 0.0f) {
- o_color->r = 0;
+ pColor->r = 0;
} else if (col > 255.0f) {
- o_color->r = 255;
+ pColor->r = 255;
} else {
- OSf32tou8(&col, &o_color->r);
+ OSf32tou8(&col, &pColor->r);
}
}
+
switch (entry->mGInfo.mMaxFrame) {
case 0:
- o_color->g = 0;
+ pColor->g = 0;
break;
case 1:
- o_color->g = mColorG[entry->mGInfo.mOffset];
+ pColor->g = mColorG[entry->mGInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
&mColorG[entry->mGInfo.mOffset]);
if (col < 0.0f) {
- o_color->g = 0;
+ pColor->g = 0;
} else if (col > 255.0f) {
- o_color->g = 255;
+ pColor->g = 255;
} else {
- OSf32tou8(&col, &o_color->g);
+ OSf32tou8(&col, &pColor->g);
}
}
+
switch (entry->mBInfo.mMaxFrame) {
case 0:
- o_color->b = 0;
+ pColor->b = 0;
break;
case 1:
- o_color->b = mColorB[entry->mBInfo.mOffset];
+ pColor->b = mColorB[entry->mBInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
&mColorB[entry->mBInfo.mOffset]);
if (col < 0.0f) {
- o_color->b = 0;
+ pColor->b = 0;
} else if (col > 255.0f) {
- o_color->b = 255;
+ pColor->b = 255;
} else {
- OSf32tou8(&col, &o_color->b);
+ OSf32tou8(&col, &pColor->b);
}
}
+
switch (entry->mAInfo.mMaxFrame) {
case 0:
- o_color->a = 0;
+ pColor->a = 0;
break;
case 1:
- o_color->a = mColorA[entry->mAInfo.mOffset];
+ pColor->a = mColorA[entry->mAInfo.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
&mColorA[entry->mAInfo.mOffset]);
if (col < 0.0f) {
- o_color->a = 0;
+ pColor->a = 0;
} else if (col > 255.0f) {
- o_color->a = 255;
+ pColor->a = 255;
} else {
- OSf32tou8(&col, &o_color->a);
+ OSf32tou8(&col, &pColor->a);
}
}
}
/* 8032AE18-8032AED8 325758 00C0+00 0/0 1/1 0/0 .text __ct__15J3DAnmTevRegKeyFv */
-J3DAnmTevRegKey::J3DAnmTevRegKey() : J3DAnmBase(0) {
- mKRegUpdateMaterialNum = 0;
- mCRegUpdateMaterialNum = 0;
+J3DAnmTevRegKey::J3DAnmTevRegKey() {
+ mCRegUpdateMaterialNum = mKRegUpdateMaterialNum = 0;
+
+ mCRegDataCountR =
+ mCRegDataCountG =
+ mCRegDataCountB =
mCRegDataCountA = 0;
- mCRegDataCountB = 0;
- mCRegDataCountG = 0;
- mCRegDataCountR = 0;
+
+ mKRegDataCountR =
+ mKRegDataCountG =
+ mKRegDataCountB =
mKRegDataCountA = 0;
- mKRegDataCountB = 0;
- mKRegDataCountG = 0;
- mKRegDataCountR = 0;
- mKRegUpdateMaterialID = NULL;
- mCRegUpdateMaterialID = NULL;
+
+ mCRegUpdateMaterialID = mKRegUpdateMaterialID = NULL;
+
+ mAnmCRegDataR =
+ mAnmCRegDataG =
+ mAnmCRegDataB =
mAnmCRegDataA = NULL;
- mAnmCRegDataB = NULL;
- mAnmCRegDataG = NULL;
- mAnmCRegDataR = NULL;
+
+ mAnmKRegDataR =
+ mAnmKRegDataG =
+ mAnmKRegDataB =
mAnmKRegDataA = NULL;
- mAnmKRegDataB = NULL;
- mAnmKRegDataG = NULL;
- mAnmKRegDataR = NULL;
}
/* 8032AED8-8032AF50 325818 0078+00 0/0 2/2 0/0 .text __ct__16J3DAnmTexPatternFv */
-J3DAnmTexPattern::J3DAnmTexPattern() : J3DAnmBase(0), mTextureIndex(NULL), mAnmTable(NULL),
+J3DAnmTexPattern::J3DAnmTexPattern() : mTextureIndex(NULL), mAnmTable(NULL),
field_0x14(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
/* 8032AF50-8032B004 325890 00B4+00 0/0 1/1 72/72 .text getTexNo__16J3DAnmTexPatternCFUsPUs */
-void J3DAnmTexPattern::getTexNo(u16 i_index, u16* o_texNo) const {
- u32 maxFrame = mAnmTable[i_index].mMaxFrame;
+void J3DAnmTexPattern::getTexNo(u16 index, u16* pTexNo) const {
+ u32 maxFrame = mAnmTable[index].mMaxFrame;
+ J3D_ASSERT_RANGE(1743, index >= 0 && index < mUpdateMaterialNum);
+ J3D_ASSERT_NULLPTR(1744, pTexNo != NULL);
+
if (mFrame < 0.0f) {
- *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset];
- } else if (mFrame >= maxFrame) {
- *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset + (maxFrame - 1)];
+ *pTexNo = mTextureIndex[mAnmTable[index].mOffset];
+ } else if (mFrame >= (u16)maxFrame) {
+ *pTexNo = mTextureIndex[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
} else {
- *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset + (int)mFrame];
+ *pTexNo = mTextureIndex[mAnmTable[index].mOffset + (int)mFrame];
}
}
/* 8032B004-8032B09C 325944 0098+00 1/1 1/1 0/0 .text
* searchUpdateMaterialID__16J3DAnmTexPatternFP16J3DMaterialTable */
-void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
- J3D_ASSERT(1790, i_materialTable, "Error : null pointer.");
+void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+ J3D_ASSERT_NULLPTR(1790, pMatTable != NULL);
+
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
- s32 index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+ s32 index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
if (index != -1) {
mUpdateMaterialID[i] = index;
} else {
@@ -1133,25 +1230,27 @@ void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* i_materialTable)
/* 8032B09C-8032B0C0 3259DC 0024+00 0/0 4/4 1/1 .text
* searchUpdateMaterialID__16J3DAnmTexPatternFP12J3DModelData */
-void J3DAnmTexPattern::searchUpdateMaterialID(J3DModelData* i_modelData) {
- J3D_ASSERT(1813, i_modelData, "Error : null pointer.");
- searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTexPattern::searchUpdateMaterialID(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(1813, pModelData != NULL);
+ searchUpdateMaterialID(&pModelData->getMaterialTable());
}
/* 8032B0C0-8032B1D4 325A00 0114+00 1/1 1/1 0/0 .text
* searchUpdateMaterialID__19J3DAnmTextureSRTKeyFP16J3DMaterialTable */
-void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
- J3D_ASSERT(1832, i_materialTable, "Error : null pointer.");
+void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+ J3D_ASSERT_NULLPTR(1832, pMatTable != NULL);
+
for (u16 i = 0; i < getUpdateMaterialNum(); i++) {
- s32 index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+ s32 index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
if (index != -1) {
mUpdateMaterialID[i] = index;
} else {
mUpdateMaterialID[i] = -1;
}
}
+
for (u16 i = 0; i < getPostUpdateMaterialNum(); i++) {
- s32 index = i_materialTable->getMaterialName()->getIndex(mPostUpdateMaterialName.getName(i));
+ s32 index = pMatTable->getMaterialName()->getIndex(mPostUpdateMaterialName.getName(i));
if (index != -1) {
mPostUpdateMaterialID[i] = index;
} else {
@@ -1162,183 +1261,197 @@ void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTab
/* 8032B1D4-8032B1F8 325B14 0024+00 0/0 8/8 6/6 .text
* searchUpdateMaterialID__19J3DAnmTextureSRTKeyFP12J3DModelData */
-void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DModelData* i_modelData) {
- J3D_ASSERT(1871, i_modelData, "Error : null pointer.");
- searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(1871, pModelData != NULL);
+ searchUpdateMaterialID(&pModelData->getMaterialTable());
}
/* 8032B1F8-8032B4BC 325B38 02C4+00 0/0 2/2 1/1 .text
* getTevColorReg__15J3DAnmTevRegKeyCFUsP11_GXColorS10 */
-void J3DAnmTevRegKey::getTevColorReg(u16 i_index, GXColorS10* o_color) const {
- J3DAnmCRegKeyTable* entry = &mAnmCRegKeyTable[i_index];
+void J3DAnmTevRegKey::getTevColorReg(u16 index, GXColorS10* pColor) const {
+ J3D_ASSERT_RANGE(1887, index >= 0 && index < mCRegUpdateMaterialNum);
+ J3D_ASSERT_NULLPTR(1888, pColor != NULL);
+ J3DAnmCRegKeyTable* entry = &mAnmCRegKeyTable[index];
+
f32 col;
switch (entry->mRTable.mMaxFrame) {
case 0:
- o_color->r = 0;
+ pColor->r = 0;
break;
case 1:
- o_color->r = mAnmCRegDataR[entry->mRTable.mOffset];
+ pColor->r = mAnmCRegDataR[entry->mRTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
&mAnmCRegDataR[entry->mRTable.mOffset]);
if (col < -0x400) {
- o_color->r = -0x400;
+ pColor->r = -0x400;
} else if (col > 0x3FF) {
- o_color->r = 0x3FF;
+ pColor->r = 0x3FF;
} else {
- OSf32tos16(&col, &o_color->r);
+ OSf32tos16(&col, &pColor->r);
}
}
+
switch (entry->mGTable.mMaxFrame) {
case 0:
- o_color->g = 0;
+ pColor->g = 0;
break;
case 1:
- o_color->g = mAnmCRegDataG[entry->mGTable.mOffset];
+ pColor->g = mAnmCRegDataG[entry->mGTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
&mAnmCRegDataG[entry->mGTable.mOffset]);
if (col < -0x400) {
- o_color->g = -0x400;
+ pColor->g = -0x400;
} else if (col > 0x3FF) {
- o_color->g = 0x3FF;
+ pColor->g = 0x3FF;
} else {
- OSf32tos16(&col, &o_color->g);
+ OSf32tos16(&col, &pColor->g);
}
}
+
switch (entry->mBTable.mMaxFrame) {
case 0:
- o_color->b = 0;
+ pColor->b = 0;
break;
case 1:
- o_color->b = mAnmCRegDataB[entry->mBTable.mOffset];
+ pColor->b = mAnmCRegDataB[entry->mBTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
&mAnmCRegDataB[entry->mBTable.mOffset]);
if (col < -0x400) {
- o_color->b = -0x400;
+ pColor->b = -0x400;
} else if (col > 0x3FF) {
- o_color->b = 0x3FF;
+ pColor->b = 0x3FF;
} else {
- OSf32tos16(&col, &o_color->b);
+ OSf32tos16(&col, &pColor->b);
}
}
+
switch (entry->mATable.mMaxFrame) {
case 0:
- o_color->a = 0;
+ pColor->a = 0;
break;
case 1:
- o_color->a = mAnmCRegDataA[entry->mATable.mOffset];
+ pColor->a = mAnmCRegDataA[entry->mATable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
&mAnmCRegDataA[entry->mATable.mOffset]);
if (col < -0x400) {
- o_color->a = -0x400;
+ pColor->a = -0x400;
} else if (col > 0x3FF) {
- o_color->a = 0x3FF;
+ pColor->a = 0x3FF;
} else {
- OSf32tos16(&col, &o_color->a);
+ OSf32tos16(&col, &pColor->a);
}
}
}
/* 8032B4BC-8032B780 325DFC 02C4+00 0/0 1/1 1/1 .text
* getTevKonstReg__15J3DAnmTevRegKeyCFUsP8_GXColor */
-void J3DAnmTevRegKey::getTevKonstReg(u16 i_index, GXColor* o_color) const {
- J3DAnmKRegKeyTable* entry = &mAnmKRegKeyTable[i_index];
+void J3DAnmTevRegKey::getTevKonstReg(u16 index, GXColor* pColor) const {
+ J3D_ASSERT_RANGE(1989, index >= 0 && index < mKRegUpdateMaterialNum);
+ J3D_ASSERT_NULLPTR(1990, pColor != NULL);
+ J3DAnmKRegKeyTable* entry = &mAnmKRegKeyTable[index];
+
f32 col;
switch (entry->mRTable.mMaxFrame) {
case 0:
- o_color->r = 0;
+ pColor->r = 0;
break;
case 1:
- o_color->r = mAnmKRegDataR[entry->mRTable.mOffset];
+ pColor->r = mAnmKRegDataR[entry->mRTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
&mAnmKRegDataR[entry->mRTable.mOffset]);
if (col < 0) {
- o_color->r = 0;
+ pColor->r = 0;
} else if (col > 0xFF) {
- o_color->r = 0xFF;
+ pColor->r = 0xFF;
} else {
- OSf32tou8(&col, &o_color->r);
+ OSf32tou8(&col, &pColor->r);
}
}
+
switch (entry->mGTable.mMaxFrame) {
case 0:
- o_color->g = 0;
+ pColor->g = 0;
break;
case 1:
- o_color->g = mAnmKRegDataG[entry->mGTable.mOffset];
+ pColor->g = mAnmKRegDataG[entry->mGTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
&mAnmKRegDataG[entry->mGTable.mOffset]);
if (col < 0) {
- o_color->g = 0;
+ pColor->g = 0;
} else if (col > 0xFF) {
- o_color->g = 0xFF;
+ pColor->g = 0xFF;
} else {
- OSf32tou8(&col, &o_color->g);
+ OSf32tou8(&col, &pColor->g);
}
}
+
switch (entry->mBTable.mMaxFrame) {
case 0:
- o_color->b = 0;
+ pColor->b = 0;
break;
case 1:
- o_color->b = mAnmKRegDataB[entry->mBTable.mOffset];
+ pColor->b = mAnmKRegDataB[entry->mBTable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
&mAnmKRegDataB[entry->mBTable.mOffset]);
if (col < 0) {
- o_color->b = 0;
+ pColor->b = 0;
} else if (col > 0xFF) {
- o_color->b = 0xFF;
+ pColor->b = 0xFF;
} else {
- OSf32tou8(&col, &o_color->b);
+ OSf32tou8(&col, &pColor->b);
}
}
+
switch (entry->mATable.mMaxFrame) {
case 0:
- o_color->a = 0;
+ pColor->a = 0;
break;
case 1:
- o_color->a = mAnmKRegDataA[entry->mATable.mOffset];
+ pColor->a = mAnmKRegDataA[entry->mATable.mOffset];
break;
default:
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
&mAnmKRegDataA[entry->mATable.mOffset]);
if (col < 0) {
- o_color->a = 0;
+ pColor->a = 0;
} else if (col > 0xFF) {
- o_color->a = 0xFF;
+ pColor->a = 0xFF;
} else {
- OSf32tou8(&col, &o_color->a);
+ OSf32tou8(&col, &pColor->a);
}
}
}
/* 8032B780-8032B87C 3260C0 00FC+00 1/1 1/1 0/0 .text
* searchUpdateMaterialID__15J3DAnmTevRegKeyFP16J3DMaterialTable */
-void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
- J3D_ASSERT(2083, i_materialTable, "Error : null pointer.");
+void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+ J3D_ASSERT_NULLPTR(2083, pMatTable != NULL);
+
for (u16 i = 0; i < mCRegUpdateMaterialNum; i++) {
- s32 index = i_materialTable->getMaterialName()->getIndex(mCRegUpdateMaterialName.getName(i));
+ s32 index = pMatTable->getMaterialName()->getIndex(mCRegUpdateMaterialName.getName(i));
if (index != -1) {
mCRegUpdateMaterialID[i] = index;
} else {
mCRegUpdateMaterialID[i] = -1;
}
}
+
for (u16 i = 0; i < mKRegUpdateMaterialNum; i++) {
- s32 index = i_materialTable->getMaterialName()->getIndex(mKRegUpdateMaterialName.getName(i));
+ s32 index = pMatTable->getMaterialName()->getIndex(mKRegUpdateMaterialName.getName(i));
if (index != -1) {
mKRegUpdateMaterialID[i] = index;
} else {
@@ -1349,7 +1462,7 @@ void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable)
/* 8032B87C-8032B8A0 3261BC 0024+00 0/0 9/9 4/4 .text
* searchUpdateMaterialID__15J3DAnmTevRegKeyFP12J3DModelData */
-void J3DAnmTevRegKey::searchUpdateMaterialID(J3DModelData* i_modelData) {
- J3D_ASSERT(2119, i_modelData, "Error : null pointer.");
- searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTevRegKey::searchUpdateMaterialID(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(2119, pModelData != NULL);
+ searchUpdateMaterialID(&pModelData->getMaterialTable());
}
diff --git a/src/JSystem/J3DGraphAnimator/J3DCluster.cpp b/src/JSystem/J3DGraphAnimator/J3DCluster.cpp
index b4e8f6780b..97b45a3c8d 100644
--- a/src/JSystem/J3DGraphAnimator/J3DCluster.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DCluster.cpp
@@ -1,15 +1,8 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DCluster
-//
-
#include "JSystem/J3DGraphAnimator/J3DCluster.h"
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
#include "JSystem/J3DGraphAnimator/J3DModel.h"
#include "JSystem/JMath/JMATrigonometric.h"
-#include "JSystem/JUtility/JUTAssert.h"
#include "dolphin/base/PPCArch.h"
-#include "dolphin/os.h"
/* 8032E1F8-8032E230 328B38 0038+00 0/0 1/1 0/0 .text __ct__13J3DDeformDataFv */
J3DDeformData::J3DDeformData() {
@@ -37,7 +30,7 @@ void J3DDeformData::offAllFlag(u32 i_flag) {
/* 8032E274-8032E298 328BB4 0024+00 0/0 1/1 0/0 .text deform__13J3DDeformDataFP8J3DModel
*/
void J3DDeformData::deform(J3DModel* model) {
- J3D_ASSERT(110, model, "Error : null pointer");
+ J3D_ASSERT_NULLPTR(110, model);
deform(model->getVertexBuffer());
}
@@ -45,7 +38,7 @@ void J3DDeformData::deform(J3DModel* model) {
/* 8032E298-8032E364 328BD8 00CC+00 1/1 0/0 0/0 .text deform__13J3DDeformDataFP15J3DVertexBuffer
*/
void J3DDeformData::deform(J3DVertexBuffer* buffer) {
- J3D_ASSERT(141, buffer, "Error : null pointer");
+ J3D_ASSERT_NULLPTR(141, buffer);
buffer->swapVtxPosArrayPointer();
buffer->swapVtxNrmArrayPointer();
@@ -83,7 +76,7 @@ J3DDeformer::J3DDeformer(J3DDeformData* data) {
/* 8032E3BC-8032E4A4 328CFC 00E8+00 1/1 0/0 0/0 .text deform__11J3DDeformerFP15J3DVertexBufferUs
*/
void J3DDeformer::deform(J3DVertexBuffer* buffer, u16 param_1) {
- J3D_ASSERT(222, buffer, "Error : null pointer");
+ J3D_ASSERT_NULLPTR(222, buffer);
u16 var_r31 = 0;
if (mAnmCluster != NULL) {
@@ -246,19 +239,29 @@ void J3DDeformer::deform_VtxNrmF32(J3DVertexBuffer* i_buffer, J3DCluster* i_clus
/* 8032EAB4-8032EBCC 3293F4 0118+00 1/1 0/0 0/0 .text deform__11J3DDeformerFP15J3DVertexBufferUsPf
*/
void J3DDeformer::deform(J3DVertexBuffer* i_buffer, u16 param_1, f32* i_weights) {
- if (checkFlag(2) && i_buffer->getVertexData()->getVtxPosType() == 4) {
- J3DCluster* cluster = mDeformData->getClusterPointer(param_1);
- u16 offset = 0;
- for (u16 i = 0; i < param_1; i++) {
- offset += mDeformData->getClusterPointer(i)->mKeyNum + 1;
- }
- J3DClusterKey* clusterKey = mDeformData->getClusterKeyPointer(offset);
-
- normalizeWeight(cluster->mKeyNum, i_weights);
- deform_VtxPosF32(i_buffer, cluster, clusterKey, i_weights);
- if (checkFlag(1) && cluster->mFlags != 0 && i_buffer->getVertexData()->getVtxNrmType() == 4)
- {
- deform_VtxNrmF32(i_buffer, cluster, clusterKey, i_weights);
+ J3D_ASSERT_NULLPTR(505, i_buffer != NULL);
+
+ if (checkFlag(2)) {
+ JUT_ASSERT_MSG(512, i_buffer->getVertexData()->getVtxPosType() == 4, "Error : Invalid Verex Format");
+ if (i_buffer->getVertexData()->getVtxPosType() == 4) {
+ J3DCluster* cluster = mDeformData->getClusterPointer(param_1);
+ u16 offset = 0;
+ J3DClusterKey* clusterKey = NULL;
+
+ for (u16 i = 0; i < param_1; i++) {
+ offset += mDeformData->getClusterPointer(i)->mKeyNum + 1;
+ }
+
+ clusterKey = mDeformData->getClusterKeyPointer(offset);
+
+ int var_r23 = cluster->mKeyNum;
+ normalizeWeight(var_r23, i_weights);
+ deform_VtxPosF32(i_buffer, cluster, clusterKey, i_weights);
+
+ if (checkFlag(1) && cluster->mFlags != 0 && i_buffer->getVertexData()->getVtxNrmType() == 4)
+ {
+ deform_VtxNrmF32(i_buffer, cluster, clusterKey, i_weights);
+ }
}
}
}
@@ -270,6 +273,7 @@ void J3DDeformer::normalizeWeight(int i_keyNum, f32* i_weights) {
for (u16 i = 0; i < i_keyNum; i++) {
totalWeight += i_weights[i];
}
+
f32 scale = 1.0f / totalWeight;
for (u16 i = 0; i < i_keyNum; i++) {
i_weights[i] *= scale;
diff --git a/src/JSystem/J3DGraphAnimator/J3DJoint.cpp b/src/JSystem/J3DGraphAnimator/J3DJoint.cpp
index 900edf00f4..5d18acb4c7 100644
--- a/src/JSystem/J3DGraphAnimator/J3DJoint.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DJoint.cpp
@@ -24,7 +24,6 @@ void J3DMtxCalcJ3DSysInitMaya::init(Vec const& scale, Mtx const& mtx) {
J3DSys::mCurrentS.z);
}
-/* ############################################################################################## */
/* 804515F0-804515F4 000AF0 0004+00 3/3 1/1 0/0 .sbss mMtxBuffer__10J3DMtxCalc */
J3DMtxBuffer* J3DMtxCalc::mMtxBuffer;
@@ -180,7 +179,7 @@ void J3DJoint::entryIn() {
j3dSys.getDrawBuffer(0)->setZMtx(anmMtx);
j3dSys.getDrawBuffer(1)->setZMtx(anmMtx);
for (J3DMaterial* mesh = mMesh; mesh != NULL;) {
- if (mesh->getShape()->checkFlag(1)) {
+ if (mesh->getShape()->checkFlag(J3DShpFlag_Visible)) {
mesh = mesh->getNext();
} else {
J3DMatPacket* matPacket = j3dSys.getModel()->getMatPacket(mesh->getIndex());
@@ -207,7 +206,6 @@ void J3DJoint::entryIn() {
}
}
-/* ############################################################################################## */
/* 804515F8-80451600 000AF8 0004+04 1/1 1/1 0/0 .sbss mCurrentMtxCalc__8J3DJoint */
J3DMtxCalc* J3DJoint::mCurrentMtxCalc;
@@ -265,4 +263,4 @@ void J3DJoint::recursiveCalc() {
if (younger != NULL) {
younger->recursiveCalc();
}
-} \ No newline at end of file
+}
diff --git a/src/JSystem/J3DGraphAnimator/J3DJointTree.cpp b/src/JSystem/J3DGraphAnimator/J3DJointTree.cpp
index b9aaa4618b..9b6cae0b3b 100644
--- a/src/JSystem/J3DGraphAnimator/J3DJointTree.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DJointTree.cpp
@@ -3,6 +3,15 @@
#include "JSystem/J3DGraphAnimator/J3DShapeTable.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
+enum {
+ kTypeEnd = 0x00,
+ kTypeBeginChild = 0x01,
+ kTypeEndChild = 0x02,
+ kTypeJoint = 0x10,
+ kTypeMaterial = 0x11,
+ kTypeShape = 0x12,
+};
+
/* 80325A18-80325A9C 320358 0084+00 0/0 1/1 0/0 .text __ct__12J3DJointTreeFv */
J3DJointTree::J3DJointTree()
: mHierarchy(NULL), mFlags(0), mModelDataType(0), mRootNode(NULL), mBasicMtxCalc(NULL),
@@ -13,52 +22,34 @@ J3DJointTree::J3DJointTree()
/* 80325A9C-80325C00 3203DC 0164+00 1/0 2/2 0/0 .text
* makeHierarchy__12J3DJointTreeFP8J3DJointPPC17J3DModelHierarchyP16J3DMaterialTableP13J3DShapeTable
*/
-void J3DJointTree::makeHierarchy(J3DJoint* pJoint, J3DModelHierarchy const** pHierarchy,
+void J3DJointTree::makeHierarchy(J3DJoint* pJoint, const J3DModelHierarchy** pHierarchy,
J3DMaterialTable* pMaterialTable, J3DShapeTable* pShapeTable) {
- enum {
- kTypeEnd = 0x00,
- kTypeBeginChild = 0x01,
- kTypeEndChild = 0x02,
- kTypeJoint = 0x10,
- kTypeMaterial = 0x11,
- kTypeShape = 0x12,
- };
-
- J3DJoint * curJoint = pJoint;
+ J3D_ASSERT_NULLPTR(95, pHierarchy != NULL);
+ J3DJoint* curJoint = pJoint;
while (true) {
- J3DJoint * newJoint = NULL;
- J3DMaterial * newMaterial = NULL;
- J3DShape * newShape = NULL;
- const J3DModelHierarchy * inf = *pHierarchy;
- u16 val;
+ J3DJoint* newJoint = NULL;
+ J3DMaterial* newMaterial = NULL;
+ J3DShape* newShape = NULL;
- switch (inf->mType) {
+ switch ((*pHierarchy)->mType) {
case kTypeBeginChild:
- *pHierarchy = inf + 1;
+ (*pHierarchy)++;
makeHierarchy(curJoint, pHierarchy, pMaterialTable, pShapeTable);
break;
case kTypeEndChild:
- *pHierarchy = inf + 1;
+ (*pHierarchy)++;
return;
case kTypeEnd:
return;
case kTypeJoint:
- {
- J3DJoint ** jointNodePointer = mJointNodePointer;
- *pHierarchy = inf + 1;
- newJoint = jointNodePointer[inf->mValue];
- }
+ newJoint = mJointNodePointer[((*pHierarchy)++)->mValue];
break;
case kTypeMaterial:
- *pHierarchy = inf + 1;
- val = inf->mValue;
- newMaterial = pMaterialTable->getMaterialNodePointer(val);
+ newMaterial = pMaterialTable->getMaterialNodePointer(((*pHierarchy)++)->mValue);
break;
case kTypeShape:
- *pHierarchy = inf + 1;
- val = inf->mValue;
- newShape = pShapeTable->getShapeNodePointer(val);
+ newShape = pShapeTable->getShapeNodePointer(((*pHierarchy)++)->mValue);
break;
}
@@ -68,31 +59,29 @@ void J3DJointTree::makeHierarchy(J3DJoint* pJoint, J3DModelHierarchy const** pHi
mRootNode = newJoint;
else
pJoint->appendChild(newJoint);
- } else if (newMaterial != NULL) {
- if (pJoint->getMesh() != NULL)
- newMaterial->mNext = pJoint->getMesh();
- pJoint->mMesh = newMaterial;
- newMaterial->mJoint = pJoint;
- } else if (newShape != NULL) {
- newMaterial = pJoint->getMesh();
- newMaterial->mShape = newShape;
- newShape->mMaterial = newMaterial;
+ } else if (newMaterial != NULL && pJoint->getType() == 'NJNT') {
+ pJoint->addMesh(newMaterial);
+ newMaterial->setJoint(pJoint);
+ } else if (newShape != NULL && pJoint->getType() == 'NJNT') {
+ J3DMaterial* newMaterial = pJoint->getMesh();
+ newMaterial->addShape(newShape);
+ newShape->setMaterial(newMaterial);
}
}
}
/* 80325C00-80325CAC 320540 00AC+00 0/0 2/2 0/0 .text findImportantMtxIndex__12J3DJointTreeFv */
void J3DJointTree::findImportantMtxIndex() {
- const s32 wEvlpMtxNum = getWEvlpMtxNum();
+ s32 wEvlpMtxNum = getWEvlpMtxNum();
u32 tableIdx = 0;
- const u16 drawFullWgtMtxNum = getDrawFullWgtMtxNum();
- const u16 * wEvlpMixIndex = getWEvlpMixMtxIndex();
- const f32 * wEvlpMixWeight = getWEvlpMixWeight();
- u16 * wEvlpImportantMtxIdx = getWEvlpImportantMtxIndex();
+ u16 drawFullWgtMtxNum = getDrawFullWgtMtxNum();
+ u16* wEvlpMixIndex = getWEvlpMixMtxIndex();
+ f32* wEvlpMixWeight = getWEvlpMixWeight();
+ u16* wEvlpImportantMtxIdx = getWEvlpImportantMtxIndex();
// Rigid matrices are easy.
for (u16 i = 0; i < drawFullWgtMtxNum; i++)
- wEvlpImportantMtxIdx[i] = mDrawMtxData.mDrawMtxIndex[i];
+ wEvlpImportantMtxIdx[i] = getDrawMtxIndex(i);
// For envelope matrices, we need to find the matrix with the most contribution.
for (s32 i = 0; i < wEvlpMtxNum; i++) {
@@ -100,26 +89,25 @@ void J3DJointTree::findImportantMtxIndex() {
u16 bestIdx = 0;
f32 bestWeight = -0.1f;
- for (s32 j = 0; j < mixNum; j++) {
+ for (s32 j = 0; j < mixNum; j++, tableIdx++) {
if (bestWeight < wEvlpMixWeight[tableIdx]) {
bestWeight = wEvlpMixWeight[tableIdx];
bestIdx = wEvlpMixIndex[tableIdx];
}
-
- tableIdx++;
}
- wEvlpImportantMtxIdx[i + mDrawMtxData.mDrawFullWgtMtxNum] = bestIdx;
+ wEvlpImportantMtxIdx[i + getDrawFullWgtMtxNum()] = bestIdx;
}
}
/* 80325CAC-80325D1C 3205EC 0070+00 1/0 0/0 0/0 .text
* calc__12J3DJointTreeFP12J3DMtxBufferRC3VecRA3_A4_Cf */
void J3DJointTree::calc(J3DMtxBuffer* pMtxBuffer, Vec const& scale, f32 const (&mtx)[3][4]) {
+ J3D_ASSERT_NULLPTR(217, pMtxBuffer != NULL);
getBasicMtxCalc()->init(scale, mtx);
- J3DMtxCalc::setMtxBuffer(pMtxBuffer);
- J3DJoint* root = getRootNode();
+ getBasicMtxCalc()->setMtxBuffer(pMtxBuffer);
+ J3DJoint* root = getRootNode();
if (root == NULL)
return;
diff --git a/src/JSystem/J3DGraphAnimator/J3DMaterialAnm.cpp b/src/JSystem/J3DGraphAnimator/J3DMaterialAnm.cpp
index bb4f0931ae..a05ae6e6e1 100644
--- a/src/JSystem/J3DGraphAnimator/J3DMaterialAnm.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DMaterialAnm.cpp
@@ -1,22 +1,5 @@
#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
-#include "dol2asm.h"
-
-//
-// Forward References:
-//
-
-extern "C" void calc__14J3DMaterialAnmCFP11J3DMaterial();
-
-//
-// External References:
-//
-
-extern "C" void __dt__14J3DMaterialAnmFv();
-
-//
-// Declarations:
-//
void J3DMaterialAnm::initialize() {
for (int i = 0; i < ARRAY_SIZE(mMatColorAnm); i++) {
@@ -40,10 +23,12 @@ void J3DMaterialAnm::initialize() {
}
}
-void J3DMaterialAnm::calc(J3DMaterial* pMat) const {
+void J3DMaterialAnm::calc(J3DMaterial* pMaterial) const {
+ J3D_ASSERT_NULLPTR(54, pMaterial != NULL);
+
for (u32 i = 0; i < ARRAY_SIZE(mMatColorAnm); i++) {
if (mMatColorAnm[i].getAnmFlag()) {
- _GXColor* color = pMat->getColorBlock()->getMatColor(i);
+ GXColor* color = pMaterial->mColorBlock->getMatColor(i);
mMatColorAnm[i].calc(color);
}
}
@@ -52,77 +37,78 @@ void J3DMaterialAnm::calc(J3DMaterial* pMat) const {
for (u32 i = 0; i < ARRAY_SIZE(mTexNoAnm); i++) {
if (mTexNoAnm[i].getAnmFlag()) {
mTexNoAnm[i].calc(&tmp);
- pMat->getTevBlock()->setTexNo(i, tmp);
+ pMaterial->mTevBlock->setTexNo(i, tmp);
}
}
for (u32 i = 0; i < 3; i++) {
if (mTevColorAnm[i].getAnmFlag()) {
- _GXColorS10* color = pMat->getTevBlock()->getTevColor(i);
+ GXColorS10* color = pMaterial->mTevBlock->getTevColor(i);
mTevColorAnm[i].calc(color);
}
}
for (u32 i = 0; i < ARRAY_SIZE(mTevKColorAnm); i++) {
if (mTevKColorAnm[i].getAnmFlag()) {
- _GXColor* color = pMat->getTevBlock()->getTevKColor(i);
+ GXColor* color = pMaterial->mTevBlock->getTevKColor(i);
mTevKColorAnm[i].calc(color);
}
}
for (u32 i = 0; i < ARRAY_SIZE(mTexMtxAnm); i++) {
if (mTexMtxAnm[i].getAnmFlag()) {
- J3DTexMtx* texMtx = pMat->getTexGenBlock()->getTexMtx(i);
- mTexMtxAnm[i].calc(&texMtx->getTexMtxInfo().mSRT);
+ J3DTextureSRTInfo* pSRT = &pMaterial->mTexGenBlock->getTexMtx(i)->getTexMtxInfo().mSRT;
+ mTexMtxAnm[i].calc(pSRT);
}
}
}
-void J3DMaterialAnm::setMatColorAnm(int idx, J3DMatColorAnm* p_matColorAnm) {
- if (p_matColorAnm == NULL) {
+void J3DMaterialAnm::setMatColorAnm(int idx, J3DMatColorAnm* pMatColorAnm) {
+ J3D_ASSERT_RANGE(106, idx >= 0 && idx < 2);
+
+ if (pMatColorAnm == NULL) {
mMatColorAnm[idx].setAnmFlag(false);
} else {
- mMatColorAnm[idx] = *p_matColorAnm;
+ mMatColorAnm[idx] = *pMatColorAnm;
}
}
-void J3DMaterialAnm::setTexMtxAnm(int idx, J3DTexMtxAnm* p_texMtxAnm) {
- if (p_texMtxAnm == NULL) {
+void J3DMaterialAnm::setTexMtxAnm(int idx, J3DTexMtxAnm* pTexMtxAnm) {
+ J3D_ASSERT_RANGE(117, idx >= 0 && idx < 8);
+
+ if (pTexMtxAnm == NULL) {
mTexMtxAnm[idx].setAnmFlag(false);
} else {
- mTexMtxAnm[idx] = *p_texMtxAnm;
+ mTexMtxAnm[idx] = *pTexMtxAnm;
}
}
-void J3DMaterialAnm::setTexNoAnm(int idx, J3DTexNoAnm* p_texNoAnm) {
- if (p_texNoAnm == NULL) {
+void J3DMaterialAnm::setTexNoAnm(int idx, J3DTexNoAnm* pTexNoAnm) {
+ J3D_ASSERT_RANGE(128, idx >= 0 && idx < 8);
+
+ if (pTexNoAnm == NULL) {
mTexNoAnm[idx].setAnmFlag(false);
} else {
- mTexNoAnm[idx] = *p_texNoAnm;
+ mTexNoAnm[idx] = *pTexNoAnm;
}
}
-void J3DMaterialAnm::setTevColorAnm(int idx, J3DTevColorAnm* p_tevColorAnm) {
- if (p_tevColorAnm == NULL) {
+void J3DMaterialAnm::setTevColorAnm(int idx, J3DTevColorAnm* pTevColorAnm) {
+ J3D_ASSERT_RANGE(139, idx >= 0 && idx < 4);
+
+ if (pTevColorAnm == NULL) {
mTevColorAnm[idx].setAnmFlag(false);
} else {
- mTevColorAnm[idx] = *p_tevColorAnm;
+ mTevColorAnm[idx] = *pTevColorAnm;
}
}
-void J3DMaterialAnm::setTevKColorAnm(int idx, J3DTevKColorAnm* p_tevKColorAnm) {
- if (p_tevKColorAnm == NULL) {
+void J3DMaterialAnm::setTevKColorAnm(int idx, J3DTevKColorAnm* pTevKColorAnm) {
+ J3D_ASSERT_RANGE(150, idx >= 0 && idx < 4);
+
+ if (pTevKColorAnm == NULL) {
mTevKColorAnm[idx].setAnmFlag(false);
} else {
- mTevKColorAnm[idx] = *p_tevKColorAnm;
+ mTevKColorAnm[idx] = *pTevKColorAnm;
}
}
-
-/* ############################################################################################## */
-/* 803CEE60-803CEE70 02BF80 0010+00 0/0 10/10 74/74 .data __vt__14J3DMaterialAnm */
-SECTION_DATA extern void* __vt__14J3DMaterialAnm[4] = {
- (void*)NULL /* RTTI */,
- (void*)NULL,
- (void*)__dt__14J3DMaterialAnmFv,
- (void*)calc__14J3DMaterialAnmCFP11J3DMaterial,
-}; \ No newline at end of file
diff --git a/src/JSystem/J3DGraphAnimator/J3DMaterialAttach.cpp b/src/JSystem/J3DGraphAnimator/J3DMaterialAttach.cpp
index 4bac6a28d4..b0f1232d52 100644
--- a/src/JSystem/J3DGraphAnimator/J3DMaterialAttach.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DMaterialAttach.cpp
@@ -1,8 +1,3 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DMaterialAttach
-//
-
#include "JSystem/J3DGraphAnimator/J3DMaterialAttach.h"
#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
@@ -38,13 +33,14 @@ J3DMaterialTable::~J3DMaterialTable() {}
/* 8032F64C-8032F6F8 329F8C 00AC+00 0/0 1/1 5/5 .text
* removeMatColorAnimator__16J3DMaterialTableFP11J3DAnmColor */
int J3DMaterialTable::removeMatColorAnimator(J3DAnmColor* pAnmColor) {
- JUT_ASSERT_MSG(208, pAnmColor != NULL, "Error : null pointer.")
+ J3D_ASSERT_NULLPTR(208, pAnmColor != NULL);
int ret = false;
+
u16 updateMatNum = pAnmColor->getUpdateMaterialNum();
for (u16 i = 0; i < updateMatNum; i++) {
if (pAnmColor->isValidUpdateMaterialID(i)) {
- u16 materialUpdateId = pAnmColor->getUpdateMaterialID(i);
- J3DMaterialAnm* materialAnm = getMaterialNodePointer(materialUpdateId)->getMaterialAnm();
+ u16 matNo = pAnmColor->getUpdateMaterialID(i);
+ J3DMaterialAnm* materialAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
if (materialAnm == NULL) {
ret = true;
} else {
@@ -52,22 +48,23 @@ int J3DMaterialTable::removeMatColorAnimator(J3DAnmColor* pAnmColor) {
}
}
}
+
return ret;
}
/* 8032F6F8-8032F7B4 32A038 00BC+00 0/0 5/5 10/10 .text
* removeTexNoAnimator__16J3DMaterialTableFP16J3DAnmTexPattern */
-int J3DMaterialTable::removeTexNoAnimator(J3DAnmTexPattern* anm) {
- JUT_ASSERT_MSG(242, anm != NULL, "Error : null pointer.")
+int J3DMaterialTable::removeTexNoAnimator(J3DAnmTexPattern* pAnmTexPattern) {
+ J3D_ASSERT_NULLPTR(242, pAnmTexPattern != NULL);
int ret = 0;
- u16 materialNum = anm->getUpdateMaterialNum();
- J3DAnmTexPatternFullTable* anm_table = (J3DAnmTexPatternFullTable*)anm->getAnmTable();
- for (u16 i = 0; i < materialNum; i++) {
- if (anm->isValidUpdateMaterialID(i)) {
- u16 materialID = anm->getUpdateMaterialID(i);
+ u16 materialNum = pAnmTexPattern->getUpdateMaterialNum();
+ J3DAnmTexPatternFullTable* anm_table = (J3DAnmTexPatternFullTable*)pAnmTexPattern->getAnmTable();
- J3DMaterialAnm* pMatAnm = getMaterialNodePointer(materialID)->getMaterialAnm();
+ for (u16 i = 0; i < materialNum; i++) {
+ if (pAnmTexPattern->isValidUpdateMaterialID(i)) {
+ u16 matNo = pAnmTexPattern->getUpdateMaterialID(i);
+ J3DMaterialAnm* pMatAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
u8 texNo = anm_table[i].mTexNo;
if (pMatAnm == NULL)
ret = 1;
@@ -81,19 +78,20 @@ int J3DMaterialTable::removeTexNoAnimator(J3DAnmTexPattern* anm) {
/* 8032F7B4-8032F880 32A0F4 00CC+00 0/0 4/4 26/26 .text
* removeTexMtxAnimator__16J3DMaterialTableFP19J3DAnmTextureSRTKey */
-int J3DMaterialTable::removeTexMtxAnimator(J3DAnmTextureSRTKey* pAnm) {
- JUT_ASSERT_MSG(278, pAnm != NULL, "Error : null pointer.")
+int J3DMaterialTable::removeTexMtxAnimator(J3DAnmTextureSRTKey* pAnmTexSRTKey) {
+ J3D_ASSERT_NULLPTR(278, pAnmTexSRTKey != NULL);
s32 ret = 0;
- u16 materialNum = pAnm->getUpdateMaterialNum();
+
+ u16 materialNum = pAnmTexSRTKey->getUpdateMaterialNum();
u16 postUpdateMaterialNum[1];
- postUpdateMaterialNum[0] = pAnm->getPostUpdateMaterialNum();
+ postUpdateMaterialNum[0] = pAnmTexSRTKey->getPostUpdateMaterialNum();
for (u16 i = 0; i < materialNum; i++) {
- if (pAnm->isValidUpdateMaterialID(i)) {
- u16 updateMaterial = pAnm->getUpdateMaterialID(i);
- J3DMaterial* pMaterial = getMaterialNodePointer(updateMaterial);
+ if (pAnmTexSRTKey->isValidUpdateMaterialID(i)) {
+ u16 matNo = pAnmTexSRTKey->getUpdateMaterialID(i);
+ J3DMaterial* pMaterial = getMaterialNodePointer(matNo);
J3DMaterialAnm* pMatAnm = pMaterial->getMaterialAnm();
- u8 texMtxID = pAnm->getUpdateTexMtxID(i);
+ u8 texMtxID = pAnmTexSRTKey->getUpdateTexMtxID(i);
if (pMatAnm == NULL) {
ret = 1;
} else if (texMtxID != 0xFF) {
@@ -107,15 +105,19 @@ int J3DMaterialTable::removeTexMtxAnimator(J3DAnmTextureSRTKey* pAnm) {
/* 8032F880-8032F9C0 32A1C0 0140+00 0/0 7/7 24/24 .text
* removeTevRegAnimator__16J3DMaterialTableFP15J3DAnmTevRegKey */
-int J3DMaterialTable::removeTevRegAnimator(J3DAnmTevRegKey* pAnm) {
+int J3DMaterialTable::removeTevRegAnimator(J3DAnmTevRegKey* pAnmTevRegKey) {
+ J3D_ASSERT_NULLPTR(320, pAnmTevRegKey != NULL);
s32 ret = 0;
- u16 cRegMaterialNum = pAnm->getCRegUpdateMaterialNum();
- u16 kRegMaterialNum = pAnm->getKRegUpdateMaterialNum();
+
+ u16 cRegMaterialNum = pAnmTevRegKey->getCRegUpdateMaterialNum();
+ u16 kRegMaterialNum = pAnmTevRegKey->getKRegUpdateMaterialNum();
for (u16 i = 0; i < cRegMaterialNum; i++) {
- if (pAnm->getCRegUpdateMaterialID(i) != 0xFFFF) {
- J3DMaterialAnm * pMatAnm = getMaterialNodePointer(pAnm->getCRegUpdateMaterialID(i))->getMaterialAnm();
- u32 colorId = pAnm->getAnmCRegKeyTable()[i].mColorId;
+ if (pAnmTevRegKey->isValidCRegUpdateMaterialID(i)) {
+ const u16 spC = pAnmTevRegKey->getCRegUpdateMaterialID(i);
+ J3DMaterialAnm* pMatAnm = getMaterialNodePointer(spC)->getMaterialAnm();
+ const J3DAnmCRegKeyTable* table = pAnmTevRegKey->getAnmCRegKeyTable();
+ const u8 colorId = table[i].mColorId;
if (pMatAnm == NULL)
ret = 1;
else
@@ -124,9 +126,11 @@ int J3DMaterialTable::removeTevRegAnimator(J3DAnmTevRegKey* pAnm) {
}
for (u16 i = 0; i < kRegMaterialNum; i++) {
- if (pAnm->getKRegUpdateMaterialID(i) != 0xFFFF) {
- J3DMaterialAnm * pMatAnm = getMaterialNodePointer(pAnm->getKRegUpdateMaterialID(i))->getMaterialAnm();
- u32 colorId = pAnm->getAnmKRegKeyTable()[i].mColorId;
+ if (pAnmTevRegKey->isValidKRegUpdateMaterialID(i)) {
+ const u16 spA = pAnmTevRegKey->getKRegUpdateMaterialID(i);
+ J3DMaterialAnm* pMatAnm = getMaterialNodePointer(spA)->getMaterialAnm();
+ const J3DAnmKRegKeyTable* table = pAnmTevRegKey->getAnmKRegKeyTable();
+ const u8 colorId = table[i].mColorId;
if (pMatAnm == NULL) {
ret = 1;
} else {
@@ -140,99 +144,117 @@ int J3DMaterialTable::removeTevRegAnimator(J3DAnmTevRegKey* pAnm) {
/* 8032F9C0-8032FAF4 32A300 0134+00 1/1 0/0 0/0 .text
* createTexMtxForAnimator__16J3DMaterialTableFP19J3DAnmTextureSRTKey */
-int J3DMaterialTable::createTexMtxForAnimator(J3DAnmTextureSRTKey* param_1) {
+int J3DMaterialTable::createTexMtxForAnimator(J3DAnmTextureSRTKey* pTexSRTKey) {
+ J3D_ASSERT_NULLPTR(382, pTexSRTKey != NULL);
int rv = 0;
- u16 materialNum = param_1->getUpdateMaterialNum();
+
+ u16 materialNum = pTexSRTKey->getUpdateMaterialNum();
if (isLocked()) {
return 2;
}
+
for (u16 i = 0; i < materialNum; i++) {
- if (param_1->isValidUpdateMaterialID(i)) {
- J3DMaterial* material = getMaterialNodePointer(param_1->getUpdateMaterialID(i));
- u8 mtxId = param_1->getUpdateTexMtxID(i);
- if (material->getMaterialAnm() == 0) {
+ if (pTexSRTKey->isValidUpdateMaterialID(i)) {
+ const u16 matNo = pTexSRTKey->getUpdateMaterialID(i);
+ J3DMaterial* material = getMaterialNodePointer(matNo);
+ u8 texMtx = pTexSRTKey->getUpdateTexMtxID(i);
+
+ J3DMaterialAnm* pMaterialAnm = material->getMaterialAnm();
+ if (pMaterialAnm == NULL) {
rv = 1;
} else {
- u32 mtxId2 = mtxId;
- if (mtxId2 != 0xff && material->getTexMtx(mtxId2) == 0) {
+ if (texMtx != 0xff && material->getTexMtx(texMtx) == NULL) {
J3DTexMtx* mtx = new J3DTexMtx();
rv = 4;
- material->setTexMtx(mtxId2, mtx);
- JUT_WARN(420, "matNo<%d> : texMtx%d nothing !\n", i, mtxId);
+ material->setTexMtx(texMtx, mtx);
+ JUT_WARN(420, "matNo<%d> : texMtx%d nothing !\n", matNo, texMtx);
}
}
}
}
+
return rv;
}
/* 8032FAF4-8032FBC8 32A434 00D4+00 0/0 1/1 0/0 .text
* entryMatColorAnimator__16J3DMaterialTableFP11J3DAnmColor */
-int J3DMaterialTable::entryMatColorAnimator(J3DAnmColor* param_1) {
+int J3DMaterialTable::entryMatColorAnimator(J3DAnmColor* pAnmColor) {
+ J3D_ASSERT_NULLPTR(450, pAnmColor != NULL);
int rv = 0;
- u16 materialNum = param_1->getUpdateMaterialNum();
+
+ u16 materialNum = pAnmColor->getUpdateMaterialNum();
if (isLocked()) {
return 2;
}
+
for (u16 i = 0; i < materialNum; i++) {
- if (param_1->isValidUpdateMaterialID(i)) {
- J3DMaterial* material = getMaterialNodePointer(param_1->getUpdateMaterialID(i));
- J3DMaterialAnm* materialAnm = material->getMaterialAnm();
- if (materialAnm == 0) {
+ if (pAnmColor->isValidUpdateMaterialID(i)) {
+ const u16 matNo = pAnmColor->getUpdateMaterialID(i);
+ J3DMaterialAnm* materialAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
+ if (materialAnm == NULL) {
rv = 1;
} else {
- J3DMatColorAnm matColorAnm(i, param_1);
+ J3DMatColorAnm matColorAnm(i, pAnmColor);
materialAnm->setMatColorAnm(0, &matColorAnm);
}
}
}
+
return rv;
}
/* 8032FBC8-8032FCC4 32A508 00FC+00 0/0 7/7 1/1 .text
* entryTexNoAnimator__16J3DMaterialTableFP16J3DAnmTexPattern */
-int J3DMaterialTable::entryTexNoAnimator(J3DAnmTexPattern* param_1) {
+int J3DMaterialTable::entryTexNoAnimator(J3DAnmTexPattern* pAnmTexPattern) {
+ J3D_ASSERT_NULLPTR(489, pAnmTexPattern != NULL);
int rv = 0;
- u16 materialNum = param_1->getUpdateMaterialNum();
+
+ u16 materialNum = pAnmTexPattern->getUpdateMaterialNum();
if (isLocked()) {
return 2;
}
+
for (u16 i = 0; i < materialNum; i++) {
- if (param_1->isValidUpdateMaterialID(i)) {
- J3DMaterial* material = getMaterialNodePointer(param_1->getUpdateMaterialID(i));
- J3DMaterialAnm* materialAnm = material->getMaterialAnm();
- u8 texNo = param_1->getAnmTable()[i].mTexNo;
- if (materialAnm == 0) {
+ if (pAnmTexPattern->isValidUpdateMaterialID(i)) {
+ const u16 matNo = pAnmTexPattern->getUpdateMaterialID(i);
+ J3DMaterialAnm* materialAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
+ const J3DAnmTexPatternFullTable* table = pAnmTexPattern->getAnmTable();
+ const u8 texNo = table[i].mTexNo;
+ if (materialAnm == NULL) {
rv = 1;
} else {
- J3DTexNoAnm texNoAnm(i, param_1);
+ J3DTexNoAnm texNoAnm(i, pAnmTexPattern);
materialAnm->setTexNoAnm(texNo, &texNoAnm);
}
}
}
+
return rv;
}
/* 8032FCC4-8032FE70 32A604 01AC+00 0/0 14/14 6/6 .text
* entryTexMtxAnimator__16J3DMaterialTableFP19J3DAnmTextureSRTKey */
-int J3DMaterialTable::entryTexMtxAnimator(J3DAnmTextureSRTKey* btk) {
- JUT_ASSERT_MSG(532, btk != NULL, "Error : null pointer.")
+int J3DMaterialTable::entryTexMtxAnimator(J3DAnmTextureSRTKey* pAnmTexSRTKey) {
+ J3D_ASSERT_NULLPTR(532, pAnmTexSRTKey != NULL);
int rv = 0;
- u16 materialNum = btk->getUpdateMaterialNum();
- rv = createTexMtxForAnimator(btk);
+ u16 materialNum = pAnmTexSRTKey->getUpdateMaterialNum();
+
+ rv = createTexMtxForAnimator(pAnmTexSRTKey);
if (rv != 0) {
return rv;
}
+
if (isLocked()) {
return 2;
}
+
for (u16 no = 0; no < materialNum; no++) {
- if (btk->isValidUpdateMaterialID(no)) {
- u16 updateMaterialId = btk->getUpdateMaterialID(no);
- J3DMaterial* material = getMaterialNodePointer((u16)updateMaterialId);
+ if (pAnmTexSRTKey->isValidUpdateMaterialID(no)) {
+ const u16 matNo = pAnmTexSRTKey->getUpdateMaterialID(no);
+ J3DMaterial* material = getMaterialNodePointer(matNo);
J3DMaterialAnm* materialAnm = material->getMaterialAnm();
- u8 texMtxID = btk->getUpdateTexMtxID(no);
- if (materialAnm == 0) {
+ u8 texMtxID = pAnmTexSRTKey->getUpdateTexMtxID(no);
+ if (materialAnm == NULL) {
rv = 1;
} else {
if (texMtxID != 0xff) {
@@ -240,53 +262,61 @@ int J3DMaterialTable::entryTexMtxAnimator(J3DAnmTextureSRTKey* btk) {
material->getTexCoord(texMtxID)->setTexGenMtx((u8)texMtxID * 3 + 30);
}
J3DTexMtxInfo& tmtxinfo = material->getTexMtx(texMtxID)->getTexMtxInfo();
- tmtxinfo.mInfo = (tmtxinfo.mInfo & 0x3f) | (btk->getTexMtxCalcType() << 7);
- tmtxinfo.mCenter.x = btk->getSRTCenter(no)->x;
- tmtxinfo.mCenter.y = btk->getSRTCenter(no)->y;
- tmtxinfo.mCenter.z = btk->getSRTCenter(no)->z;
- J3DTexMtxAnm texMtxAnm(no, btk);
+ tmtxinfo.mInfo = (tmtxinfo.mInfo & 0x3f) | (pAnmTexSRTKey->getTexMtxCalcType() << 7);
+ tmtxinfo.mCenter.x = pAnmTexSRTKey->getSRTCenter(no)->x;
+ tmtxinfo.mCenter.y = pAnmTexSRTKey->getSRTCenter(no)->y;
+ tmtxinfo.mCenter.z = pAnmTexSRTKey->getSRTCenter(no)->z;
+ J3DTexMtxAnm texMtxAnm(no, pAnmTexSRTKey);
materialAnm->setTexMtxAnm(texMtxID, &texMtxAnm);
}
}
}
}
+
return rv;
}
/* 8032FE70-8032FFEC 32A7B0 017C+00 0/0 10/10 4/4 .text
* entryTevRegAnimator__16J3DMaterialTableFP15J3DAnmTevRegKey */
-int J3DMaterialTable::entryTevRegAnimator(J3DAnmTevRegKey* param_1) {
+int J3DMaterialTable::entryTevRegAnimator(J3DAnmTevRegKey* pAnmTevRegKey) {
+ J3D_ASSERT_NULLPTR(599, pAnmTevRegKey != NULL);
int rv = 0;
- u16 cRegNum = param_1->getCRegUpdateMaterialNum();
- u16 kRegNum = param_1->getKRegUpdateMaterialNum();
+
+ u16 cRegNum = pAnmTevRegKey->getCRegUpdateMaterialNum();
+ u16 kRegNum = pAnmTevRegKey->getKRegUpdateMaterialNum();
if (isLocked()) {
return 2;
}
+
for (u16 i = 0; i < cRegNum; i++) {
- if (param_1->isValidCRegUpdateMaterialID(i)) {
- J3DMaterial* material = getMaterialNodePointer(param_1->getCRegUpdateMaterialID(i));
- J3DMaterialAnm* materialAnm = material->getMaterialAnm();
- u8 colorId = param_1->getAnmCRegKeyTable()[i].mColorId;
+ if (pAnmTevRegKey->isValidCRegUpdateMaterialID(i)) {
+ const u16 matNo = pAnmTevRegKey->getCRegUpdateMaterialID(i);
+ J3DMaterialAnm* materialAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
+ const J3DAnmCRegKeyTable* table = pAnmTevRegKey->getAnmCRegKeyTable();
+ u8 colorId = table[i].mColorId;
if (materialAnm == NULL) {
rv = 1;
} else {
- J3DTevColorAnm tevColorAnm(i, param_1);
+ J3DTevColorAnm tevColorAnm(i, pAnmTevRegKey);
materialAnm->setTevColorAnm(colorId, &tevColorAnm);
}
}
}
+
for (u16 i = 0; i < kRegNum; i++) {
- if (param_1->isValidKRegUpdateMaterialID(i)) {
- J3DMaterial* material = getMaterialNodePointer(param_1->getKRegUpdateMaterialID(i));
- J3DMaterialAnm* materialAnm = material->getMaterialAnm();
- u32 colorId = param_1->getAnmKRegKeyTable()[i].mColorId;
+ if (pAnmTevRegKey->isValidKRegUpdateMaterialID(i)) {
+ const u16 matNo = pAnmTevRegKey->getKRegUpdateMaterialID(i);
+ J3DMaterialAnm* materialAnm = getMaterialNodePointer(matNo)->getMaterialAnm();
+ const J3DAnmKRegKeyTable* table = pAnmTevRegKey->getAnmKRegKeyTable();
+ const u8 colorId = table[i].mColorId;
if (materialAnm == NULL) {
rv = 1;
} else {
- J3DTevKColorAnm tevKColorAnm(i, param_1);
+ J3DTevKColorAnm tevKColorAnm(i, pAnmTevRegKey);
materialAnm->setTevKColorAnm(colorId, &tevKColorAnm);
}
}
}
+
return rv;
}
diff --git a/src/JSystem/J3DGraphAnimator/J3DModel.cpp b/src/JSystem/J3DGraphAnimator/J3DModel.cpp
index 7632bfe58a..92879e4e89 100644
--- a/src/JSystem/J3DGraphAnimator/J3DModel.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DModel.cpp
@@ -1,13 +1,10 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DModel
-//
-
#include "JSystem/J3DGraphAnimator/J3DModel.h"
#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/J3DGraphBase/J3DShapeMtx.h"
-#include "dolphin/os.h"
+
+#define J3D_ASSERTMSG(LINE, COND, MSG) JUT_ASSERT_MSG(LINE, (COND) != 0, MSG)
+#define J3D_WARN1(LINE, MSG, ARG1) JUT_WARN(LINE, MSG, ARG1)
/* 80327100-80327184 321A40 0084+00 0/0 3/3 0/0 .text initialize__8J3DModelFv */
void J3DModel::initialize() {
@@ -36,72 +33,80 @@ void J3DModel::initialize() {
/* 80327184-80327300 321AC4 017C+00 0/0 3/3 0/0 .text
* entryModelData__8J3DModelFP12J3DModelDataUlUl */
-s32 J3DModel::entryModelData(J3DModelData* p_modelData, u32 modelFlag, u32 mtxBufferFlag) {
- mModelData = p_modelData;
+s32 J3DModel::entryModelData(J3DModelData* pModelData, u32 mdlFlags, u32 mtxNum) {
+ J3D_ASSERTMSG(83, pModelData != NULL, "Error : null pointer.");
+ J3D_ASSERTMSG(84, mtxNum != 0, "Error : non-zero argument is specified 0.");
+ int ret = kJ3DError_Success;
+
+ mModelData = pModelData;
mMtxBuffer = new J3DMtxBuffer();
if (mMtxBuffer == NULL) {
- return 4;
+ return kJ3DError_Alloc;
}
- s32 ret = mMtxBuffer->create(p_modelData, mtxBufferFlag);
- if (ret) {
+ ret = mMtxBuffer->create(pModelData, mtxNum);
+ if (ret != kJ3DError_Success) {
return ret;
}
- ret = createShapePacket(p_modelData);
- if (ret) {
+
+ ret = createShapePacket(pModelData);
+ if (ret != kJ3DError_Success) {
return ret;
}
- ret = createMatPacket(p_modelData, modelFlag);
- if (ret) {
+
+ ret = createMatPacket(pModelData, mdlFlags);
+ if (ret != kJ3DError_Success) {
return ret;
}
- mVertexBuffer.setVertexData(&p_modelData->getVertexData());
+ mVertexBuffer.setVertexData(&pModelData->getVertexData());
prepareShapePackets();
- if (modelFlag & J3DMdlFlag_Unk00001) {
- onFlag(J3DMdlFlag_Unk00001);
+ if (mdlFlags & J3DMdlFlag_Unk1) {
+ onFlag(J3DMdlFlag_Unk1);
}
- if (modelFlag & J3DMdlFlag_Unk00002) {
- onFlag(J3DMdlFlag_Unk00002);
+ if (mdlFlags & J3DMdlFlag_UseDefaultJ3D) {
+ onFlag(J3DMdlFlag_UseDefaultJ3D);
}
- if (modelFlag & J3DMdlFlag_Unk00010) {
- onFlag(J3DMdlFlag_Unk00010);
+ if (mdlFlags & J3DMdlFlag_EnableLOD) {
+ onFlag(J3DMdlFlag_EnableLOD);
}
- if (modelFlag & J3DMdlFlag_Unk20000) {
- onFlag(J3DMdlFlag_Unk20000);
+ if (mdlFlags & J3DMdlFlag_UseSharedDL) {
+ onFlag(J3DMdlFlag_UseSharedDL);
}
- if (modelFlag & J3DMdlFlag_Unk40000) {
- onFlag(J3DMdlFlag_Unk40000);
+ if (mdlFlags & J3DMdlFlag_UseSingleDL) {
+ onFlag(J3DMdlFlag_UseSingleDL);
}
- if (modelFlag & J3DMdlFlag_Unk80000) {
- onFlag(J3DMdlFlag_Unk80000);
+ if (mdlFlags & J3DMdlFlag_DifferedDLBuffer) {
+ onFlag(J3DMdlFlag_DifferedDLBuffer);
}
- if (modelFlag & J3DMdlFlag_SkinPosCpu) {
+ if (mdlFlags & J3DMdlFlag_SkinPosCpu) {
+ J3D_WARN1(149, "%s", "Don't forget to call J3DModel::setSkinDeform\n if you set J3DMdlFlag_SkinPosCpu.");
onFlag(J3DMdlFlag_SkinPosCpu);
}
- if (modelFlag & J3DMdlFlag_SkinNrmCpu) {
+ if (mdlFlags & J3DMdlFlag_SkinNrmCpu) {
+ J3D_WARN1(154, "%s", "Don't forget to call J3DModel::setSkinDeform\n if you set J3DMdlFlag_SkinNrmCpu.");
onFlag(J3DMdlFlag_SkinNrmCpu);
}
- return 0;
+
+ return kJ3DError_Success;
}
/* 80327300-803273CC 321C40 00CC+00 1/1 0/0 0/0 .text createShapePacket__8J3DModelFP12J3DModelData
*/
-s32 J3DModel::createShapePacket(J3DModelData* p_modelData) {
- if (p_modelData->getShapeNum() != 0) {
- u16 shapeNum = p_modelData->getShapeNum();
+s32 J3DModel::createShapePacket(J3DModelData* pModelData) {
+ J3D_ASSERTMSG(173, pModelData != NULL, "Error : null pointer.");
- mShapePacket = new J3DShapePacket[shapeNum];
+ if (pModelData->getShapeNum() != 0) {
+ mShapePacket = new J3DShapePacket[pModelData->getShapeNum()];
if (mShapePacket == NULL) {
return kJ3DError_Alloc;
}
- for (int i = 0; i < p_modelData->getShapeNum(); i++) {
- J3DShape* shapeNode = p_modelData->getShapeNodePointer(i);
- mShapePacket[i].setShape(shapeNode);
+ for (int i = 0; i < pModelData->getShapeNum(); i++) {
+ mShapePacket[i].setShape(pModelData->getShapeNodePointer(i));
mShapePacket[i].setModel(this);
}
}
@@ -111,76 +116,78 @@ s32 J3DModel::createShapePacket(J3DModelData* p_modelData) {
/* 803273CC-803275FC 321D0C 0230+00 1/1 0/0 0/0 .text createMatPacket__8J3DModelFP12J3DModelDataUl
*/
-s32 J3DModel::createMatPacket(J3DModelData* p_modelData, u32 flag) {
- if (p_modelData->getMaterialNum() != 0) {
- mMatPacket = new J3DMatPacket[p_modelData->getMaterialNum()];
+s32 J3DModel::createMatPacket(J3DModelData* pModelData, u32 mdlFlags) {
+ J3D_ASSERTMSG(207, pModelData != NULL, "Error : null pointer.");
+ s32 ret = 0;
+
+ if (pModelData->getMaterialNum() != 0) {
+ mMatPacket = new J3DMatPacket[pModelData->getMaterialNum()];
if (mMatPacket == NULL) {
return kJ3DError_Alloc;
}
}
-
- s32 ret;
- u16 matNum = p_modelData->getMaterialNum();
-
- u32 singleDLFlag = flag & 0x40000;
+
+ u16 matNum = pModelData->getMaterialNum();
for (u16 i = 0; i < matNum; i++) {
- J3DMaterial* materialNode = p_modelData->getMaterialNodePointer(i);
- J3DMatPacket* pkt = mMatPacket + i;
-
- u16 shapeIndex = materialNode->getShape()->getIndex();
- J3DShapePacket* shapePacket = mShapePacket + shapeIndex;
-
- pkt->setMaterial(materialNode);
- pkt->setInitShapePacket(shapePacket);
- pkt->addShapePacket(shapePacket);
- pkt->setTexture(p_modelData->getTexture());
- pkt->setMaterialID(materialNode->mDiffFlag);
-
- if (p_modelData->getModelDataType() == 1) {
- pkt->mFlags |= 0x01;
+ J3DMaterial* materialNode = pModelData->getMaterialNodePointer(i);
+ J3DMatPacket* matPacket = mMatPacket + i;
+ J3DShapePacket* shapePacket = mShapePacket + materialNode->getShape()->getIndex();
+
+ matPacket->setMaterial(materialNode);
+ matPacket->setInitShapePacket(shapePacket);
+ matPacket->addShapePacket(shapePacket);
+ matPacket->setTexture(pModelData->getTexture());
+ matPacket->setMaterialID(materialNode->mDiffFlag);
+
+ if (pModelData->getModelDataType() == 1) {
+ matPacket->lock();
}
- if (!!(flag & 0x80000)) {
- pkt->mpDisplayListObj = materialNode->getSharedDisplayListObj();
+ if (mdlFlags & J3DMdlFlag_DifferedDLBuffer) {
+ J3DDisplayListObj* dlobj = materialNode->getSharedDisplayListObj();
+ J3D_ASSERTMSG(253, dlobj != NULL, "Error : User need to call J3DModelData::newSharedDisplayList() before using DifferedDLBuffer.");
+ matPacket->setDisplayListObj(dlobj);
} else {
- if (p_modelData->getModelDataType() == 1) {
- if (!!(flag & 0x40000)) {
- pkt->mpDisplayListObj = materialNode->getSharedDisplayListObj();
+ if (pModelData->getModelDataType() == 1) {
+ if (mdlFlags & J3DMdlFlag_UseSingleDL) {
+ matPacket->mpDisplayListObj = materialNode->getSharedDisplayListObj();
+ matPacket->setDisplayListObj(matPacket->mpDisplayListObj);
} else {
- J3DDisplayListObj* sharedDL = materialNode->getSharedDisplayListObj();
- ret = sharedDL->single_To_Double();
+ J3DDisplayListObj* dlobj = materialNode->getSharedDisplayListObj();
+ ret = dlobj->single_To_Double();
if (ret != kJ3DError_Success)
return ret;
- pkt->mpDisplayListObj = sharedDL;
+ matPacket->setDisplayListObj(dlobj);
}
- } else if (!!(flag & 0x20000)) {
- if (!!(flag & 0x40000)) {
+ } else if (mdlFlags & J3DMdlFlag_UseSharedDL) {
+ if (mdlFlags & J3DMdlFlag_UseSingleDL) {
ret = materialNode->newSingleSharedDisplayList(materialNode->countDLSize());
if (ret != kJ3DError_Success)
return ret;
- pkt->mpDisplayListObj = materialNode->getSharedDisplayListObj();
+ J3DDisplayListObj* dlobj = materialNode->getSharedDisplayListObj();
+ matPacket->setDisplayListObj(dlobj);
} else {
ret = materialNode->newSharedDisplayList(materialNode->countDLSize());
if (ret != kJ3DError_Success)
return ret;
- J3DDisplayListObj* sharedDL = materialNode->getSharedDisplayListObj();
- ret = sharedDL->single_To_Double();
+ J3DDisplayListObj* dlobj = materialNode->getSharedDisplayListObj();
+ ret = dlobj->single_To_Double();
if (ret != kJ3DError_Success)
return ret;
- pkt->mpDisplayListObj = sharedDL;
+ matPacket->setDisplayListObj(dlobj);
}
} else {
- if (!!(flag & 0x40000)) {
- ret = pkt->newSingleDisplayList(materialNode->countDLSize());
+ if (mdlFlags & J3DMdlFlag_UseSingleDL) {
+ ret = matPacket->newSingleDisplayList(materialNode->countDLSize());
if (ret != kJ3DError_Success)
return ret;
} else {
- ret = pkt->newDisplayList(materialNode->countDLSize());
+ ret = matPacket->newDisplayList(materialNode->countDLSize());
if (ret != kJ3DError_Success)
return ret;
}
@@ -192,21 +199,40 @@ s32 J3DModel::createMatPacket(J3DModelData* p_modelData, u32 flag) {
}
/* 803275FC-8032767C 321F3C 0080+00 0/0 1/1 0/0 .text newDifferedDisplayList__8J3DModelFUl */
-s32 J3DModel::newDifferedDisplayList(u32 flag) {
- mDiffFlag = flag;
+s32 J3DModel::newDifferedDisplayList(u32 diffFlags) {
+ mDiffFlag = diffFlags;
+
u16 shapeNum = getModelData()->getShapeNum();
for (u16 i = 0; i < shapeNum; i++) {
- s32 ret = mShapePacket[i].newDifferedDisplayList(flag);
+ s32 ret = getShapePacket(i)->newDifferedDisplayList(diffFlags);
if (ret != kJ3DError_Success)
return ret;
}
+
return kJ3DError_Success;
}
-/* 8032767C-803276B4 321FBC 0038+00 0/0 4/4 0/0 .text lock__8J3DModelFv */
-void J3DModel::lock() {
+void J3DModel::ptrToIndex() {
+ j3dSys.setModel(this);
+ j3dSys.setTexture(mModelData->getTexture());
+
u16 matNum = mModelData->getMaterialNum();
+ for (u16 i = 0; i < matNum; i++) {
+ J3DMatPacket* matPacket = getMatPacket(i);
+ GDLObj dlobj;
+ GDInitGDLObj(&dlobj, matPacket->getDisplayList(0), matPacket->getDisplayListSize());
+ GDSetCurrent(&dlobj);
+
+ mModelData->getMaterialNodePointer(i)->getTevBlock()->ptrToIndex();
+
+ GDSetCurrent(NULL);
+ }
+}
+
+/* 8032767C-803276B4 321FBC 0038+00 0/0 4/4 0/0 .text lock__8J3DModelFv */
+void J3DModel::lock() {
+ int matNum = mModelData->getMaterialNum();
for (int i = 0; i < matNum; i++) {
mMatPacket[i].lock();
}
@@ -214,24 +240,34 @@ void J3DModel::lock() {
/* 803276B4-803276EC 321FF4 0038+00 0/0 2/2 0/0 .text unlock__8J3DModelFv */
void J3DModel::unlock() {
- u16 matNum = mModelData->getMaterialNum();
-
+ int matNum = mModelData->getMaterialNum();
for (int i = 0; i < matNum; i++) {
mMatPacket[i].unlock();
}
}
+void J3DModel::makeDL() {
+ j3dSys.setModel(this);
+ j3dSys.setTexture(mModelData->getTexture());
+
+ u16 matNum = mModelData->getMaterialNum();
+ for (u16 i = 0; i < matNum; i++) {
+ j3dSys.setMatPacket(&mMatPacket[i]);
+ mModelData->getMaterialNodePointer(i)->makeDisplayList();
+ }
+}
+
/* 803276EC-80327858 32202C 016C+00 1/0 0/0 0/0 .text calcMaterial__8J3DModelFv */
void J3DModel::calcMaterial() {
j3dSys.setModel(this);
- if (checkFlag(4)) {
+ if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
j3dSys.onFlag(4);
} else {
j3dSys.offFlag(4);
}
- if (checkFlag(8)) {
+ if (checkFlag(J3DMdlFlag_SkinNrmCpu)) {
j3dSys.onFlag(8);
} else {
j3dSys.offFlag(8);
@@ -249,31 +285,31 @@ void J3DModel::calcMaterial() {
material->getMaterialAnm()->calc(material);
}
- int jntNo = material->getJoint()->getJntNo();
- material->calc(getAnmMtx(jntNo));
+ material->calc(getAnmMtx(material->getJoint()->getJntNo()));
}
}
/* 80327858-803279A0 322198 0148+00 1/0 0/0 0/0 .text calcDiffTexMtx__8J3DModelFv */
-// NONMATCHING regalloc
void J3DModel::calcDiffTexMtx() {
j3dSys.setModel(this);
- for (u16 num = mModelData->getMaterialNum(), i = 0; i < num; i++) {
+ u16 matNum = mModelData->getMaterialNum();
+ for (u16 i = 0; i < matNum; i++) {
j3dSys.setMatPacket(&mMatPacket[i]);
J3DMaterial* materialNode = mModelData->getMaterialNodePointer(i);
materialNode->calcDiffTexMtx(getAnmMtx(materialNode->getJoint()->getJntNo()));
}
- for (u16 num = mModelData->getShapeNum(), i = 0; i < num; i++) {
+ u16 shapeNum = getModelData()->getShapeNum();
+ for (u16 i = 0; i < shapeNum; i++) {
J3DShapePacket* shapePacket = getShapePacket(i);
- J3DTexGenBlock* texGenBlock =
- mModelData->getShapeNodePointer(i)->getMaterial()->getTexGenBlock();
+ J3DTexGenBlock* texGenBlock = mModelData->getShapeNodePointer(i)->getMaterial()->getTexGenBlock();
+
for (u16 j = 0; (int)j < 8; j++) {
J3DTexMtx* texMtxNode = texGenBlock->getTexMtx(j);
J3DTexMtxObj* texMtxObj = shapePacket->getTexMtxObj();
if (texMtxNode != NULL && texMtxObj != NULL) {
- texMtxObj->setMtx(j, &texMtxNode->getMtx());
+ texMtxObj->setMtx(j, texMtxNode->getMtx());
}
}
}
@@ -281,9 +317,10 @@ void J3DModel::calcDiffTexMtx() {
/* 803279A0-80327A2C 3222E0 008C+00 0/0 2/2 0/0 .text diff__8J3DModelFv */
void J3DModel::diff() {
- for (u16 n = getModelData()->getMaterialNum(), i = 0; i < n; i++) {
+ u16 matNum = mModelData->getMaterialNum();
+ for (u16 i = 0; i < matNum; i++) {
j3dSys.setMatPacket(&mMatPacket[i]);
- getModelData()->getMaterialNodePointer(i)->diff(mDiffFlag);
+ mModelData->getMaterialNodePointer(i)->diff(mDiffFlag);
}
}
@@ -293,17 +330,19 @@ s32 J3DModel::setDeformData(J3DDeformData* p_deformData, u32 param_1) {
mDeformData = p_deformData;
if (p_deformData == NULL) {
- return 0;
+ return kJ3DError_Success;
}
s32 ret = mVertexBuffer.copyLocalVtxArray(param_1);
if (ret) {
return ret;
}
+
if (param_1 & 4) {
p_deformData->offAllFlag(1);
}
- return 0;
+
+ return kJ3DError_Success;
}
/* 80327AA0-80327BD4 3223E0 0134+00 0/0 0/0 2/2 .text setSkinDeform__8J3DModelFP13J3DSkinDeformUl
@@ -311,46 +350,43 @@ s32 J3DModel::setDeformData(J3DDeformData* p_deformData, u32 param_1) {
s32 J3DModel::setSkinDeform(J3DSkinDeform* p_skinDeform, u32 flags) {
mSkinDeform = p_skinDeform;
- s32 ret = kJ3DError_Success;
-
if (p_skinDeform == NULL) {
offFlag(J3DMdlFlag_SkinPosCpu);
offFlag(J3DMdlFlag_SkinNrmCpu);
return 5;
- } else {
- mSkinDeform->initMtxIndexArray(mModelData);
+ }
- ret = mModelData->checkFlag(0x100);
- if (ret != kJ3DError_Success) {
- mSkinDeform->changeFastSkinDL(mModelData);
- flags &= ~2;
- flags &= ~4;
- mSkinDeform->transformVtxPosNrm(mModelData);
- mSkinDeform->initSkinInfo(mModelData);
- }
+ mSkinDeform->initMtxIndexArray(mModelData);
- ret = 0;
- if ((~flags & 2)) {
- ret = mVertexBuffer.allocTransformedVtxPosArray();
- if (ret != kJ3DError_Success) {
- offFlag(J3DMdlFlag_SkinPosCpu);
- return ret;
- }
- onFlag(J3DMdlFlag_SkinPosCpu);
- } else {
+ if (mModelData->checkFlag(0x100)) {
+ mSkinDeform->changeFastSkinDL(mModelData);
+ flags &= ~2;
+ flags &= ~4;
+ mSkinDeform->transformVtxPosNrm(mModelData);
+ mSkinDeform->initSkinInfo(mModelData);
+ }
+
+ s32 ret = kJ3DError_Success;
+ if ((~flags & 2)) {
+ ret = mVertexBuffer.allocTransformedVtxPosArray();
+ if (ret != kJ3DError_Success) {
offFlag(J3DMdlFlag_SkinPosCpu);
+ return ret;
}
+ onFlag(J3DMdlFlag_SkinPosCpu);
+ } else {
+ offFlag(J3DMdlFlag_SkinPosCpu);
+ }
- if ((~flags & 4)) {
- ret = mVertexBuffer.allocTransformedVtxNrmArray();
- if (ret != kJ3DError_Success) {
- offFlag(J3DMdlFlag_SkinNrmCpu);
- return ret;
- }
- onFlag(J3DMdlFlag_SkinNrmCpu);
- } else {
+ if ((~flags & 4)) {
+ ret = mVertexBuffer.allocTransformedVtxNrmArray();
+ if (ret != kJ3DError_Success) {
offFlag(J3DMdlFlag_SkinNrmCpu);
+ return ret;
}
+ onFlag(J3DMdlFlag_SkinNrmCpu);
+ } else {
+ offFlag(J3DMdlFlag_SkinNrmCpu);
}
return ret;
@@ -360,7 +396,7 @@ s32 J3DModel::setSkinDeform(J3DSkinDeform* p_skinDeform, u32 flags) {
void J3DModel::calcAnmMtx() {
j3dSys.setModel(this);
- if (checkFlag(2)) {
+ if (checkFlag(J3DMdlFlag_UseDefaultJ3D)) {
getModelData()->getJointTree().calc(mMtxBuffer, j3dDefaultScale, j3dDefaultMtx);
} else {
getModelData()->getJointTree().calc(mMtxBuffer, mBaseScale, mBaseTransformMtx);
@@ -370,7 +406,7 @@ void J3DModel::calcAnmMtx() {
/* 80327C58-80327CA4 322598 004C+00 1/1 1/1 1/1 .text calcWeightEnvelopeMtx__8J3DModelFv
*/
void J3DModel::calcWeightEnvelopeMtx() {
- if (getModelData()->getWEvlpMtxNum() != 0 && !checkFlag(0x10)) {
+ if (getModelData()->getWEvlpMtxNum() != 0 && !checkFlag(J3DMdlFlag_EnableLOD)) {
if (!getModelData()->checkFlag(0x100)) {
mMtxBuffer->calcWeightEnvelopeMtx();
}
@@ -383,7 +419,6 @@ void J3DModel::update() {
entry();
}
-
/* 80327CF0-80327E4C 322630 015C+00 1/0 0/0 0/0 .text calc__8J3DModelFv */
void J3DModel::calc() {
j3dSys.setModel(this);
@@ -400,11 +435,11 @@ void J3DModel::calc() {
j3dSys.offFlag(J3DSysFlag_SkinNrmCpu);
}
- getModelData()->syncJ3DSysFlags();
+ mModelData->syncJ3DSysFlags();
mVertexBuffer.frameInit();
if (mUnkCalc2 != NULL) {
- mUnkCalc2->calc(getModelData());
+ mUnkCalc2->calc(mModelData);
}
if (mDeformData != NULL) {
@@ -447,11 +482,11 @@ void J3DModel::entry() {
j3dSys.offFlag(J3DSysFlag_SkinNrmCpu);
}
- getModelData()->syncJ3DSysFlags();
- j3dSys.setTexture(getModelData()->getTexture());
+ mModelData->syncJ3DSysFlags();
+ j3dSys.setTexture(mModelData->getTexture());
- for (u16 i = 0; i < getModelData()->getJointNum(); i++) {
- J3DJoint* joint = getModelData()->getJointNodePointer(i);
+ for (u16 i = 0; i < mModelData->getJointNum(); i++) {
+ J3DJoint* joint = mModelData->getJointNodePointer(i);
if (joint->getMesh() != NULL) {
joint->entryIn();
}
@@ -463,7 +498,7 @@ void J3DModel::viewCalc() {
mMtxBuffer->swapDrawMtx();
mMtxBuffer->swapNrmMtx();
- if (mModelData->checkFlag(0x10)) {
+ if (getModelData()->checkFlag(0x10)) {
if (getMtxCalcMode() == 2) {
J3DCalcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx,
(MtxP)&mInternalView);
@@ -502,17 +537,16 @@ void J3DModel::calcNrmMtx() {
/* 803281B4-803282B8 322AF4 0104+00 1/1 0/0 0/0 .text calcBumpMtx__8J3DModelFv */
void J3DModel::calcBumpMtx() {
- if (getModelData()->checkBumpFlag() == 1) {
+ if (getModelData()->checkBumpFlag()) {
u32 bumpMtxIdx = 0;
u16 materialNum = getModelData()->getMaterialNum();
- u16 i = 0;
- for (; i < materialNum; i++) {
+ for (u16 i = 0; i < materialNum; i++) {
J3DMaterial* material = getModelData()->getMaterialNodePointer(i);
- if (material->getNBTScale()->mbHasScale == 1) {
+ if (material->getNBTScale()->mbHasScale == TRUE) {
material->getShape()->calcNBTScale(*material->getNBTScale()->getScale(),
getNrmMtxPtr(), getBumpMtxPtr(bumpMtxIdx));
- DCStoreRange(getBumpMtxPtr(bumpMtxIdx), getModelData()->getDrawMtxNum() * 0x24);
+ DCStoreRange(getBumpMtxPtr(bumpMtxIdx), mModelData->getDrawMtxNum() * sizeof(Mtx33));
bumpMtxIdx++;
}
}
@@ -521,23 +555,24 @@ void J3DModel::calcBumpMtx() {
/* 803282B8-803282EC 322BF8 0034+00 1/1 0/0 0/0 .text calcBBoardMtx__8J3DModelFv */
void J3DModel::calcBBoardMtx() {
- if (mModelData->checkBBoardFlag()) {
+ if (getModelData()->checkBBoardFlag()) {
mMtxBuffer->calcBBoardMtx();
}
}
/* 803282EC-80328350 322C2C 0064+00 2/2 0/0 0/0 .text prepareShapePackets__8J3DModelFv */
void J3DModel::prepareShapePackets() {
- u16 shapeNum = getModelData()->getShapeNum();
+ u16 shapeNum = mModelData->getShapeNum();
for (u16 i = 0; i < shapeNum; i++) {
- J3DShape* xx = mModelData->getShapeNodePointer(i);
- J3DShapePacket* pkt = getShapePacket(i);
- pkt->setMtxBuffer(mMtxBuffer);
+ J3DShape* shapeNode = mModelData->getShapeNodePointer(i);
+ J3DShapePacket* shapePacket = &mShapePacket[i];
+ shapePacket->setMtxBuffer(mMtxBuffer);
+
if (getMtxCalcMode() == 2) {
- pkt->setBaseMtxPtr(&mInternalView);
+ shapePacket->setBaseMtxPtr(&mInternalView);
} else {
- pkt->setBaseMtxPtr(&j3dSys.mViewMtx);
+ shapePacket->setBaseMtxPtr((Mtx*)j3dSys.getViewMtx());
}
}
}
diff --git a/src/JSystem/J3DGraphAnimator/J3DModelData.cpp b/src/JSystem/J3DGraphAnimator/J3DModelData.cpp
index 5f3572ade2..bab3b416a7 100644
--- a/src/JSystem/J3DGraphAnimator/J3DModelData.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DModelData.cpp
@@ -5,7 +5,7 @@
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
-#include "dolphin/os.h"
+#include "JSystem/J3DGraphAnimator/J3DModel.h"
/* 80325D88-80325DA0 3206C8 0018+00 1/1 2/2 0/0 .text clear__12J3DModelDataFv */
void J3DModelData::clear() {
@@ -21,16 +21,17 @@ J3DModelData::J3DModelData() {
}
/* 80325E14-80325EC8 320754 00B4+00 0/0 2/2 0/0 .text newSharedDisplayList__12J3DModelDataFUl */
-s32 J3DModelData::newSharedDisplayList(u32 flag) {
+s32 J3DModelData::newSharedDisplayList(u32 mdlFlags) {
u16 matNum = getMaterialNum();
for (u16 i = 0; i < matNum; i++) {
- if (!!(flag & 0x40000)) {
- s32 ret = getMaterialNodePointer(i)->newSingleSharedDisplayList(getMaterialNodePointer(i)->countDLSize());
+ s32 ret;
+ if (mdlFlags & J3DMdlFlag_UseSingleDL) {
+ ret = getMaterialNodePointer(i)->newSingleSharedDisplayList(getMaterialNodePointer(i)->countDLSize());
if (ret != kJ3DError_Success)
return ret;
} else {
- s32 ret = getMaterialNodePointer(i)->newSharedDisplayList(getMaterialNodePointer(i)->countDLSize());
+ ret = getMaterialNodePointer(i)->newSharedDisplayList(getMaterialNodePointer(i)->countDLSize());
if (ret != kJ3DError_Success)
return ret;
}
@@ -39,22 +40,11 @@ s32 J3DModelData::newSharedDisplayList(u32 flag) {
return kJ3DError_Success;
}
-/* ############################################################################################## */
-/* 804515E8-804515EC 000AE8 0004+00 1/1 0/0 0/0 .sbss sInterruptFlag$965 */
-static s32 sInterruptFlag;
-
-/* 804515EC-804515F0 000AEC 0004+00 1/1 0/0 0/0 .sbss None */
-static s8 sInitInterruptFlag;
-
/* 80325EC8-80325F94 320808 00CC+00 0/0 1/1 0/0 .text indexToPtr__12J3DModelDataFv */
void J3DModelData::indexToPtr() {
- J3DTexture* tex = getTexture();
- j3dSys.setTexture(tex);
+ j3dSys.setTexture(getTexture());
- if (!sInitInterruptFlag) {
- sInterruptFlag = OSDisableInterrupts();
- sInitInterruptFlag = true;
- }
+ static BOOL sInterruptFlag = OSDisableInterrupts();
OSDisableScheduler();
GDLObj gdl_obj;
@@ -67,6 +57,7 @@ void J3DModelData::indexToPtr() {
GDSetCurrent(&gdl_obj);
matNode->getTevBlock()->indexToPtr();
}
+
GDSetCurrent(NULL);
OSEnableScheduler();
OSRestoreInterrupts(sInterruptFlag);
@@ -74,8 +65,7 @@ void J3DModelData::indexToPtr() {
/* 80325F94-8032600C 3208D4 0078+00 0/0 2/2 0/0 .text makeSharedDL__12J3DModelDataFv */
void J3DModelData::makeSharedDL() {
- J3DTexture* tex = getTexture();
- j3dSys.setTexture(tex);
+ j3dSys.setTexture(getTexture());
u16 matNum = getMaterialNum();
for (u16 i = 0; i < matNum; i++) {
@@ -88,8 +78,9 @@ void J3DModelData::makeSharedDL() {
void J3DModelData::simpleCalcMaterial(u16 idx, Mtx param_1) {
syncJ3DSysFlags();
+ J3DMaterial* mat;
J3DJoint* jointNode = getJointNodePointer(idx);
- for (J3DMaterial* mat = jointNode->getMesh(); mat != NULL; mat = mat->getNext()) {
+ for (mat = jointNode->getMesh(); mat != NULL; mat = mat->getNext()) {
if (mat->getMaterialAnm() != NULL) {
mat->getMaterialAnm()->calc(mat);
}
diff --git a/src/JSystem/J3DGraphAnimator/J3DMtxBuffer.cpp b/src/JSystem/J3DGraphAnimator/J3DMtxBuffer.cpp
index ab4bdc7937..f1382d196d 100644
--- a/src/JSystem/J3DGraphAnimator/J3DMtxBuffer.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DMtxBuffer.cpp
@@ -1,13 +1,7 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DMtxBuffer
-//
-
#include "JSystem/J3DGraphAnimator/J3DMtxBuffer.h"
#include "JSystem/J3DGraphBase/J3DMaterial.h"
#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
#include "JSystem/JKernel/JKRHeap.h"
-#include "JSystem/JUtility/JUTAssert.h"
/* 804371C0-804371F0 063EE0 0030+00 1/0 0/0 0/0 .bss sNoUseDrawMtx__12J3DMtxBuffer */
Mtx J3DMtxBuffer::sNoUseDrawMtx;
@@ -43,7 +37,7 @@ void J3DMtxBuffer::initialize() {
mpNrmMtxArr[1] = NULL;
mpBumpMtxArr[0] = NULL;
mpBumpMtxArr[1] = NULL;
- mFlags = 1;
+ mMtxNum = 1;
mCurrentViewNo = 0;
mpUserAnmMtx = NULL;
}
@@ -54,33 +48,33 @@ enum {
J3DMdlDataFlag_NoAnimation = 0x100,
};
-s32 J3DMtxBuffer::create(J3DModelData* p_modelData, u32 flag) {
- J3D_ASSERT(76, p_modelData, "Error : null pointer.");
- J3D_ASSERT(77, flag, "Error : non-zero argument is specified 0.");
+s32 J3DMtxBuffer::create(J3DModelData* pModelData, u32 mtxNum) {
+ J3D_ASSERT_NULLPTR(76, pModelData != NULL);
+ J3D_ASSERT_NONZEROARG(77, mtxNum != 0);
- s32 ret = 0;
- mFlags = flag;
- mJointTree = &p_modelData->getJointTree();
+ s32 ret = kJ3DError_Success;
+ mMtxNum = mtxNum;
+ mJointTree = &pModelData->getJointTree();
- ret = createAnmMtx(p_modelData);
+ ret = createAnmMtx(pModelData);
if (ret != kJ3DError_Success)
return ret;
- ret = createWeightEnvelopeMtx(p_modelData);
+ ret = createWeightEnvelopeMtx(pModelData);
if (ret != kJ3DError_Success)
return ret;
- if (p_modelData->checkFlag(J3DMdlDataFlag_NoAnimation)) {
+ if (pModelData->checkFlag(J3DMdlDataFlag_NoAnimation)) {
setNoUseDrawMtx();
} else {
- u32 loadType = getMdlDataFlag_MtxLoadType(p_modelData->getFlag());
+ u32 loadType = getMdlDataFlag_MtxLoadType(pModelData->getFlag());
switch (loadType) {
case J3DMdlDataFlag_ConcatView:
ret = setNoUseDrawMtx();
break;
case 0:
default:
- ret = createDoubleDrawMtx(p_modelData, flag);
+ ret = createDoubleDrawMtx(pModelData, mtxNum);
break;
}
}
@@ -88,10 +82,10 @@ s32 J3DMtxBuffer::create(J3DModelData* p_modelData, u32 flag) {
if (ret != kJ3DError_Success)
return ret;
- if (p_modelData->getFlag() & J3DMdlDataFlag_ConcatView) {
- p_modelData->setBumpFlag(0);
+ if (pModelData->getFlag() & J3DMdlDataFlag_ConcatView) {
+ pModelData->setBumpFlag(0);
} else {
- ret = createBumpMtxArray(p_modelData, flag);
+ ret = createBumpMtxArray(pModelData, mtxNum);
if (ret != kJ3DError_Success)
return ret;
@@ -102,10 +96,10 @@ s32 J3DMtxBuffer::create(J3DModelData* p_modelData, u32 flag) {
/* 80326364-803263F0 320CA4 008C+00 1/1 0/0 0/0 .text createAnmMtx__12J3DMtxBufferFP12J3DModelData
*/
- J3DError J3DMtxBuffer::createAnmMtx(J3DModelData* p_modelData) {
- if (p_modelData->getJointNum() != 0) {
- mpScaleFlagArr = new u8[p_modelData->getJointNum()];
- mpAnmMtx = new Mtx[p_modelData->getJointNum()];
+J3DError J3DMtxBuffer::createAnmMtx(J3DModelData* pModelData) {
+ if (pModelData->getJointNum() != 0) {
+ mpScaleFlagArr = new u8[pModelData->getJointNum()];
+ mpAnmMtx = new Mtx[pModelData->getJointNum()];
mpUserAnmMtx = mpAnmMtx;
}
@@ -115,20 +109,21 @@ s32 J3DMtxBuffer::create(J3DModelData* p_modelData, u32 flag) {
if (mpAnmMtx == NULL) {
return kJ3DError_Alloc;
}
+
return kJ3DError_Success;
}
/* 803263F0-8032648C 320D30 009C+00 1/1 0/0 0/0 .text
* createWeightEnvelopeMtx__12J3DMtxBufferFP12J3DModelData */
-s32 J3DMtxBuffer::createWeightEnvelopeMtx(J3DModelData* p_modelData) {
- if (p_modelData->getWEvlpMtxNum() != 0) {
- mpEvlpScaleFlagArr = new u8[p_modelData->getWEvlpMtxNum()];
- mpWeightEvlpMtx = new Mtx[p_modelData->getWEvlpMtxNum()];
+s32 J3DMtxBuffer::createWeightEnvelopeMtx(J3DModelData* pModelData) {
+ if (pModelData->getWEvlpMtxNum() != 0) {
+ mpEvlpScaleFlagArr = new u8[pModelData->getWEvlpMtxNum()];
+ mpWeightEvlpMtx = new Mtx[pModelData->getWEvlpMtxNum()];
}
- if (p_modelData->getWEvlpMtxNum() != 0 && mpEvlpScaleFlagArr == NULL)
+ if (pModelData->getWEvlpMtxNum() != 0 && mpEvlpScaleFlagArr == NULL)
return kJ3DError_Alloc;
- if (p_modelData->getWEvlpMtxNum() != 0 && mpWeightEvlpMtx == NULL)
+ if (pModelData->getWEvlpMtxNum() != 0 && mpWeightEvlpMtx == NULL)
return kJ3DError_Alloc;
return kJ3DError_Success;
@@ -145,16 +140,16 @@ s32 J3DMtxBuffer::setNoUseDrawMtx() {
/* 803264B8-80326664 320DF8 01AC+00 1/1 0/0 0/0 .text
* createDoubleDrawMtx__12J3DMtxBufferFP12J3DModelDataUl */
-s32 J3DMtxBuffer::createDoubleDrawMtx(J3DModelData* p_modelData, u32 num) {
- if (num != 0) {
+s32 J3DMtxBuffer::createDoubleDrawMtx(J3DModelData* pModelData, u32 mtxNum) {
+ if (mtxNum != 0) {
for (s32 i = 0; i < 2; i++) {
- mpDrawMtxArr[i] = new Mtx*[num];
- mpNrmMtxArr[i] = new Mtx33*[num];
+ mpDrawMtxArr[i] = new Mtx*[mtxNum];
+ mpNrmMtxArr[i] = new Mtx33*[mtxNum];
mpBumpMtxArr[i] = NULL;
}
}
- if (num != 0) {
+ if (mtxNum != 0) {
for (s32 i = 0; i < 2; i++) {
if (mpDrawMtxArr[i] == NULL)
return kJ3DError_Alloc;
@@ -164,17 +159,17 @@ s32 J3DMtxBuffer::createDoubleDrawMtx(J3DModelData* p_modelData, u32 num) {
}
for (s32 i = 0; i < 2; i++) {
- for (u32 j = 0; j < num; j++) {
- if (p_modelData->getDrawMtxNum() != 0) {
- mpDrawMtxArr[i][j] = new (0x20) Mtx[p_modelData->getDrawMtxNum()];
- mpNrmMtxArr[i][j] = new (0x20) Mtx33[p_modelData->getDrawMtxNum()];
+ for (u32 j = 0; j < mtxNum; j++) {
+ if (pModelData->getDrawMtxNum() != 0) {
+ mpDrawMtxArr[i][j] = new (0x20) Mtx[pModelData->getDrawMtxNum()];
+ mpNrmMtxArr[i][j] = new (0x20) Mtx33[pModelData->getDrawMtxNum()];
}
}
}
for (s32 i = 0; i < 2; i++) {
- for (u32 j = 0; j < num; j++) {
- if (p_modelData->getDrawMtxNum() != 0) {
+ for (u32 j = 0; j < mtxNum; j++) {
+ if (pModelData->getDrawMtxNum() != 0) {
if (mpDrawMtxArr[i][j] == NULL)
return kJ3DError_Alloc;
if (mpNrmMtxArr[i][j] == NULL)
@@ -188,8 +183,9 @@ s32 J3DMtxBuffer::createDoubleDrawMtx(J3DModelData* p_modelData, u32 num) {
/* 80326664-803268D4 320FA4 0270+00 1/1 0/0 0/0 .text
* createBumpMtxArray__12J3DMtxBufferFP12J3DModelDataUl */
-s32 J3DMtxBuffer::createBumpMtxArray(J3DModelData* i_modelData, u32 param_1) {
- J3D_ASSERT(295, i_modelData, "Error : null pointer.");
+s32 J3DMtxBuffer::createBumpMtxArray(J3DModelData* i_modelData, u32 mtxNum) {
+ J3D_ASSERT_NULLPTR(295, i_modelData != NULL);
+
if (i_modelData->getModelDataType() == 0) {
u16 bumpMtxNum = 0;
u16 materialCount = 0;
@@ -202,7 +198,7 @@ s32 J3DMtxBuffer::createBumpMtxArray(J3DModelData* i_modelData, u32 param_1) {
}
}
- if (bumpMtxNum != 0 && param_1 != 0) {
+ if (bumpMtxNum != 0 && mtxNum != 0) {
for (int i = 0; i < 2; i++) {
mpBumpMtxArr[i] = new Mtx33**[(u16)materialCount];
if (mpBumpMtxArr[i] == NULL) {
@@ -217,7 +213,7 @@ s32 J3DMtxBuffer::createBumpMtxArray(J3DModelData* i_modelData, u32 param_1) {
for (u16 j = 0; j < materialNum; j++) {
J3DMaterial* material = i_modelData->getMaterialNodePointer(j);
if (material->getNBTScale()->mbHasScale == true) {
- mpBumpMtxArr[i][offset] = new Mtx33*[param_1];
+ mpBumpMtxArr[i][offset] = new Mtx33*[mtxNum];
if (mpBumpMtxArr[i][offset] == NULL) {
return kJ3DError_Alloc;
}
@@ -233,7 +229,7 @@ s32 J3DMtxBuffer::createBumpMtxArray(J3DModelData* i_modelData, u32 param_1) {
for (u16 j = 0; j < materialNum; j++) {
J3DMaterial* material = i_modelData->getMaterialNodePointer((u16)j);
if (material->getNBTScale()->mbHasScale == true) {
- for (int k = 0; k < param_1; k++) {
+ for (int k = 0; k < mtxNum; k++) {
mpBumpMtxArr[i][offset][k] = new (0x20) Mtx33[i_modelData->getDrawMtxNum()];
if (mpBumpMtxArr[i][offset][k] == NULL) {
return kJ3DError_Alloc;
@@ -273,10 +269,12 @@ void J3DMtxBuffer::calcWeightEnvelopeMtx() {
f32* weights;
u8* pScale;
Mtx mtx;
+
i = -1;
max = mJointTree->getWEvlpMtxNum();
indices = mJointTree->getWEvlpMixMtxIndex() - 1;
weights = mJointTree->getWEvlpMixWeight() - 1;
+
while (++i < max) {
pScale = &mpEvlpScaleFlagArr[i];
*pScale = 1;
@@ -284,6 +282,7 @@ void J3DMtxBuffer::calcWeightEnvelopeMtx() {
weightAnmMtx[0][0] = weightAnmMtx[0][1] = weightAnmMtx[0][2] = weightAnmMtx[0][3] =
weightAnmMtx[1][0] = weightAnmMtx[1][1] = weightAnmMtx[1][2] = weightAnmMtx[1][3] =
weightAnmMtx[2][0] = weightAnmMtx[2][1] = weightAnmMtx[2][2] = weightAnmMtx[2][3] = 0.0f;
+
j = 0;
mixNum = mJointTree->getWEvlpMixMtxNum(i);
do {
@@ -291,6 +290,7 @@ void J3DMtxBuffer::calcWeightEnvelopeMtx() {
worldMtx = &mpAnmMtx[idx];
invMtx = &mJointTree->getInvJointMtx((u16)idx);
MTXConcat(*worldMtx, *invMtx, mtx);
+
weight = *++weights;
weightAnmMtx[0][0] += mtx[0][0] * weight;
weightAnmMtx[0][1] += mtx[0][1] * weight;
@@ -304,6 +304,7 @@ void J3DMtxBuffer::calcWeightEnvelopeMtx() {
weightAnmMtx[2][1] += mtx[2][1] * weight;
weightAnmMtx[2][2] += mtx[2][2] * weight;
weightAnmMtx[2][3] += mtx[2][3] * weight;
+
*pScale &= mpScaleFlagArr[idx];
} while (++j < mixNum);
}
@@ -311,12 +312,17 @@ void J3DMtxBuffer::calcWeightEnvelopeMtx() {
/* 80326ACC-80326D3C 32140C 0270+00 0/0 1/1 0/0 .text
* calcDrawMtx__12J3DMtxBufferFUlRC3VecRA3_A4_Cf */
-void J3DMtxBuffer::calcDrawMtx(u32 param_0, Vec const& param_1, Mtx const& param_2) {
+void J3DMtxBuffer::calcDrawMtx(u32 mdlFlag, Vec const& param_1, Mtx const& param_2) {
+ Mtx* sp24, *sp20;
+ int sp1C = 0;
+ sp20 = mpAnmMtx;
+ sp24 = mpWeightEvlpMtx;
+
MtxP viewMtx;
Mtx viewBaseMtx;
u16 fullWgtNum;
- switch (param_0) {
+ switch (mdlFlag) {
case 0:
viewMtx = j3dSys.getViewMtx();
fullWgtNum = mJointTree->getDrawFullWgtMtxNum();
@@ -327,8 +333,7 @@ void J3DMtxBuffer::calcDrawMtx(u32 param_0, Vec const& param_1, Mtx const& param
J3DPSMtxArrayConcat(viewMtx, *mpWeightEvlpMtx, *getDrawMtx(fullWgtNum),
mJointTree->getWEvlpMtxNum());
}
- break;
-
+ return;
case 1:
fullWgtNum = mJointTree->getDrawFullWgtMtxNum();
for (u16 i = 0; i < fullWgtNum; i++) {
@@ -339,7 +344,6 @@ void J3DMtxBuffer::calcDrawMtx(u32 param_0, Vec const& param_1, Mtx const& param
MTXCopy(getWeightAnmMtx(i), *getDrawMtx(mJointTree->getDrawFullWgtMtxNum() + i));
}
break;
-
case 2:
J3DCalcViewBaseMtx(j3dSys.getViewMtx(), param_1, param_2, viewBaseMtx);
fullWgtNum = mJointTree->getDrawFullWgtMtxNum();
@@ -351,25 +355,25 @@ void J3DMtxBuffer::calcDrawMtx(u32 param_0, Vec const& param_1, Mtx const& param
*getDrawMtx(mJointTree->getDrawFullWgtMtxNum()),
mJointTree->getWEvlpMtxNum());
}
- break;
+ return;
+ default:
+ JUT_ASSERT_MSG(778, 0, "Error : model flag is invalid.")
}
}
-extern void J3DPSCalcInverseTranspose(Mtx p1, Mtx33 p2);
-
/* 80326D3C-80326EF0 32167C 01B4+00 0/0 1/1 0/0 .text calcNrmMtx__12J3DMtxBufferFv */
void J3DMtxBuffer::calcNrmMtx() {
u16 drawMtxNum = mJointTree->getDrawMtxNum();
for (u16 i = 0; i < drawMtxNum; i++) {
if (mJointTree->getDrawMtxFlag(i) == 0) {
if (getScaleFlag(mJointTree->getDrawMtxIndex(i)) == 1) {
- setNrmMtx(i, getDrawMtx(i));
+ setNrmMtx(i, *getDrawMtx(i));
} else {
J3DPSCalcInverseTranspose(*getDrawMtx(i), *getNrmMtx(i));
}
} else {
if (getEnvScaleFlag(mJointTree->getDrawMtxIndex(i)) == 1) {
- setNrmMtx(i, getDrawMtx(i));
+ setNrmMtx(i, *getDrawMtx(i));
} else {
J3DPSCalcInverseTranspose(*getDrawMtx(i), *getNrmMtx(i));
}
@@ -386,6 +390,7 @@ void J3DMtxBuffer::calcBBoardMtx() {
if (mJointTree->getJointNodePointer(index)->getMtxType() == 1) {
MtxP drawMtx = *getDrawMtx(i);
J3DCalcBBoardMtx(drawMtx);
+
Mtx33* nrmMtx = getNrmMtx(i);
(*nrmMtx)[0][0] = 1.0f / drawMtx[0][0];
(*nrmMtx)[0][1] = 0.0f;
diff --git a/src/JSystem/J3DGraphAnimator/J3DShapeTable.cpp b/src/JSystem/J3DGraphAnimator/J3DShapeTable.cpp
index 29357ff035..044161ecad 100644
--- a/src/JSystem/J3DGraphAnimator/J3DShapeTable.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DShapeTable.cpp
@@ -30,9 +30,8 @@ void J3DShapeTable::sortVcdVatCmd() {
for (u16 next = 0; next < shapeNum; next++) {
for (u16 prev = 0; prev < next; prev++) {
if (mShapeNodePointer[next]->isSameVcdVatCmd(mShapeNodePointer[prev])) {
- void* nodeVatCmd = mShapeNodePointer[prev]->getVcdVatCmd();
- mShapeNodePointer[next]->setVcdVatCmd(nodeVatCmd);
+ mShapeNodePointer[next]->setVcdVatCmd(mShapeNodePointer[prev]->getVcdVatCmd());
}
}
}
-} \ No newline at end of file
+}
diff --git a/src/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp b/src/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp
index fe9a21ebb3..4731c10415 100644
--- a/src/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp
@@ -1,14 +1,7 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DSkinDeform
-//
-
#include "JSystem/J3DGraphAnimator/J3DSkinDeform.h"
#include "JSystem/J3DGraphAnimator/J3DModel.h"
#include "JSystem/JKernel/JKRHeap.h"
-#include "dol2asm.h"
-#include "dolphin/os.h"
-#include "string.h"
+#include <string.h>
/* 8032C6E4-8032C704 327024 0020+00 1/1 0/0 0/0 .text __ct__12J3DSkinNListFv */
J3DSkinNList::J3DSkinNList() {
@@ -78,8 +71,6 @@ void J3DSkinNList::calcSkin_VtxNrmF32(f32 (*param_0)[4], void* param_1, void* pa
}
}
-/* ############################################################################################## */
-
/* 8032C96C-8032C9B0 3272AC 0044+00 0/0 0/0 2/2 .text __ct__13J3DSkinDeformFv */
J3DSkinDeform::J3DSkinDeform() {
mPosData = NULL;
@@ -94,7 +85,6 @@ J3DSkinDeform::J3DSkinDeform() {
mSkinNList = NULL;
}
-/* ############################################################################################## */
/* 80437218-80438218 063F38 1000+00 1/1 0/0 0/0 .bss sWorkArea_WEvlpMixMtx__13J3DSkinDeform */
u16* J3DSkinDeform::sWorkArea_WEvlpMixMtx[1024];
@@ -103,32 +93,34 @@ f32* J3DSkinDeform::sWorkArea_WEvlpMixWeight[1024];
/* 8032C9B0-8032CF44 3272F0 0594+00 0/0 1/1 0/0 .text
* initSkinInfo__13J3DSkinDeformFP12J3DModelData */
-void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
- J3D_ASSERT(322, param_0, "Error : null pointer.");
- int vtxNum = param_0->getVtxNum();
- int wevlpMtxNum = param_0->getWEvlpMtxNum();
- u16* wevlpMtxIndex = param_0->getWEvlpMixMtxIndex();
- f32* wevlpMixWeights = param_0->getWEvlpMixWeight();
+void J3DSkinDeform::initSkinInfo(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(322, pModelData != NULL);
+
+ int vtxNum = pModelData->getVtxNum();
+ int wevlpMtxNum = pModelData->getWEvlpMtxNum();
+ u16* wevlpMtxIndex = pModelData->getWEvlpMixMtxIndex();
+ f32* wevlpMixWeights = pModelData->getWEvlpMixWeight();
int currentOffset = 0;
+
for (int i = 0; i < wevlpMtxNum; i++) {
sWorkArea_WEvlpMixMtx[i] = wevlpMtxIndex + currentOffset;
sWorkArea_WEvlpMixWeight[i] = wevlpMixWeights + currentOffset;
- currentOffset += param_0->getWEvlpMixMtxNum(i);
+ currentOffset += pModelData->getWEvlpMixMtxNum(i);
}
- if (param_0->getJointNum() != 0) {
- mSkinNList = new J3DSkinNList[param_0->getJointNum()];
+ if (pModelData->getJointNum() != 0) {
+ mSkinNList = new J3DSkinNList[pModelData->getJointNum()];
}
- for (int i = 0; i < param_0->getVtxNum(); i++) {
+ for (int i = 0; i < pModelData->getVtxNum(); i++) {
u16 uVar8 = mPosData[i];
if (uVar8 != 0xffff) {
- if (param_0->getDrawMtxFlag(uVar8) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
+ if (!pModelData->getDrawMtxFlag(uVar8)) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
mSkinNList[drawMtxIndex].field_0x10++;
} else {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
- int wevlpMtxNum = param_0->getWEvlpMixMtxNum(drawMtxIndex);
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
+ int wevlpMtxNum = pModelData->getWEvlpMixMtxNum(drawMtxIndex);
u16* indices = sWorkArea_WEvlpMixMtx[drawMtxIndex];
for (int j = 0; j < wevlpMtxNum; j++) {
mSkinNList[indices[j]].field_0x10++;
@@ -136,15 +128,16 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
}
}
}
- for (int i = 0; i < param_0->getNrmNum(); i++) {
+
+ for (int i = 0; i < pModelData->getNrmNum(); i++) {
u16 uVar8 = mNrmData[i];
if (uVar8 != 0xffff) {
- if (param_0->getDrawMtxFlag(uVar8) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
+ if (!pModelData->getDrawMtxFlag(uVar8)) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
mSkinNList[drawMtxIndex].field_0x12++;
} else {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
- int wevlpMtxNum = param_0->getWEvlpMixMtxNum(drawMtxIndex);
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
+ int wevlpMtxNum = pModelData->getWEvlpMixMtxNum(drawMtxIndex);
u16* indices = sWorkArea_WEvlpMixMtx[drawMtxIndex];
for (int j = 0; j < wevlpMtxNum; j++) {
mSkinNList[indices[j]].field_0x12++;
@@ -152,7 +145,8 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
}
}
}
- for (u16 i = 0; i < param_0->getJointNum(); i++) {
+
+ for (u16 i = 0; i < pModelData->getJointNum(); i++) {
if (mSkinNList[i].field_0x10) {
mSkinNList[i].field_0x0 = new u16[mSkinNList[i].field_0x10];
mSkinNList[i].field_0x8 = new f32[mSkinNList[i].field_0x10];
@@ -164,17 +158,18 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
mSkinNList[i].field_0x12 = 0;
}
}
- for (int i = 0; i < param_0->getVtxNum(); i++) {
+
+ for (int i = 0; i < pModelData->getVtxNum(); i++) {
u16 uVar8 = mPosData[i];
if (uVar8 != 0xffff) {
- if (param_0->getDrawMtxFlag(uVar8) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
+ if (!pModelData->getDrawMtxFlag(uVar8)) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
int uVar9 = mSkinNList[drawMtxIndex].field_0x10++;
mSkinNList[drawMtxIndex].field_0x0[uVar9] = i;
mSkinNList[drawMtxIndex].field_0x8[uVar9] = 1.0f;
} else {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
- int wevlpMtxNum = param_0->getWEvlpMixMtxNum(drawMtxIndex);
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
+ int wevlpMtxNum = pModelData->getWEvlpMixMtxNum(drawMtxIndex);
u16* indices = sWorkArea_WEvlpMixMtx[drawMtxIndex];
f32* weights = sWorkArea_WEvlpMixWeight[drawMtxIndex];
for (int j = 0; j < wevlpMtxNum; j++) {
@@ -185,17 +180,18 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
}
}
}
- for (int i = 0; i < param_0->getNrmNum(); i++) {
+
+ for (int i = 0; i < pModelData->getNrmNum(); i++) {
u16 uVar8 = mNrmData[i];
if (uVar8 != 0xffff) {
- if (param_0->getDrawMtxFlag(uVar8) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
+ if (!pModelData->getDrawMtxFlag(uVar8)) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
int uVar9 = mSkinNList[drawMtxIndex].field_0x12++;
mSkinNList[drawMtxIndex].field_0x4[uVar9] = i;
mSkinNList[drawMtxIndex].field_0xc[uVar9] = 1.0f;
} else {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(uVar8);
- int wevlpMtxNum = param_0->getWEvlpMixMtxNum(drawMtxIndex);
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(uVar8);
+ int wevlpMtxNum = pModelData->getWEvlpMixMtxNum(drawMtxIndex);
u16* indices = sWorkArea_WEvlpMixMtx[drawMtxIndex];
f32* weights = sWorkArea_WEvlpMixWeight[drawMtxIndex];
for (int j = 0; j < wevlpMtxNum; j++) {
@@ -210,128 +206,133 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* param_0) {
/* 80439218-80439A20 065F38 0800+08 1/1 0/0 0/0 .bss sWorkArea_MtxReg__13J3DSkinDeform
*/
-u16 J3DSkinDeform::sWorkArea_MtxReg[1024 + 4 /* padding */];
+u16 J3DSkinDeform::sWorkArea_MtxReg[1024];
/* 8032CF44-8032D378 327884 0434+00 0/0 1/1 0/0 .text
* initMtxIndexArray__13J3DSkinDeformFP12J3DModelData */
-// NONMATCHING - local_58 issue
-int J3DSkinDeform::initMtxIndexArray(J3DModelData* param_0) {
- J3D_ASSERT(507, param_0, "Error : null pointer.");
+// NONMATCHING - matches debug, not retail
+int J3DSkinDeform::initMtxIndexArray(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(507, pModelData != NULL);
if (mPosData != NULL && mNrmData != NULL) {
- return 0;
+ return kJ3DError_Success;
}
- mPosData = new u16[param_0->getVtxNum()];
+ mPosData = new u16[pModelData->getVtxNum()];
if (mPosData == NULL) {
- return 4;
+ return kJ3DError_Alloc;
}
- for (int i = 0; i < param_0->getVtxNum(); i++) {
+ for (int i = 0; i < pModelData->getVtxNum(); i++) {
mPosData[i] = 0xffff;
}
- if (param_0->getNrmNum()) {
- mNrmData = new u16[param_0->getNrmNum()];
+ if (pModelData->getNrmNum()) {
+ mNrmData = new u16[pModelData->getNrmNum()];
if (mNrmData == NULL) {
- return 4;
+ return kJ3DError_Alloc;
}
- for (int i = 0; i < param_0->getNrmNum(); i++) {
+ for (int i = 0; i < pModelData->getNrmNum(); i++) {
mNrmData[i] = 0;
}
} else {
mNrmData = NULL;
}
- mPosMtx = new Mtx[param_0->getJointNum()];
- mNrmMtx = new (32) Mtx33[param_0->getDrawMtxNum()];
+ mPosMtx = new Mtx[pModelData->getJointNum()];
+ mNrmMtx = new (32) Mtx33[pModelData->getDrawMtxNum()];
if (mPosMtx == NULL) {
- return 4;
+ return kJ3DError_Alloc;
}
if (mNrmMtx == NULL) {
- return 4;
+ return kJ3DError_Alloc;
}
- for (u16 local_6c = 0; local_6c < param_0->getShapeNum(); local_6c++) {
- u32 local_28[4] = {0,1,1,2};
- int r26 = -1;
- int r25 = -1;
- int r24 = -1;
- int stack_3c = -1;
+ for (u16 i = 0; i < pModelData->getShapeNum(); i++) {
+ u32 kSize[4] = {0, 1, 1, 2};
+ int pnmtx_num = -1;
+ int vtx_num = -1;
+ int nrm_num = -1;
+ int tex_num = -1;
int r23 = 0;
- for (GXVtxDescList* local_4c = param_0->getShapeNodePointer(local_6c)->getVtxDesc(); local_4c->attr != 0xff; local_4c++) {
- switch (local_4c->attr) {
+ for (GXVtxDescList* vtxDesc = pModelData->getShapeNodePointer(i)->getVtxDesc(); vtxDesc->attr != 0xff; vtxDesc++) {
+ switch (vtxDesc->attr) {
case GX_VA_PNMTXIDX:
- r26 = r23;
+ pnmtx_num = r23;
break;
case GX_VA_POS:
- r25 = r23;
- if (local_4c->type != GX_INDEX16) {
+ vtx_num = r23;
+ if (vtxDesc->type != GX_INDEX16) {
OSReport(" Invlid Data : CPU Pipeline process GX_INDEX16 Data Only\n");
return 6;
}
break;
case GX_VA_NRM:
- r24 = r23;
- if (local_4c->type != GX_INDEX16) {
+ nrm_num = r23;
+ if (vtxDesc->type != GX_INDEX16) {
OSReport(" Invlid Data : CPU Pipeline process GX_INDEX16 Data Only\n");
return 6;
}
break;
case GX_VA_TEX0:
- stack_3c = r23;
- if (local_4c->type != GX_INDEX16) {
+ tex_num = r23;
+ if (vtxDesc->type != GX_INDEX16) {
OSReport(" Invlid Data : CPU Pipeline process GX_INDEX16 Data Only\n");
return 6;
}
break;
}
- r23 += local_28[(int)local_4c->type];
+ r23 += kSize[(int)vtxDesc->type];
}
- for (u16 local_6e = 0; local_6e < param_0->getShapeNodePointer(local_6c)->getMtxGroupNum(); local_6e++) {
- J3DShapeMtx* piVar8 = param_0->getShapeNodePointer(local_6c)->getShapeMtx(local_6e);
- u8* pcVar10 = param_0->getShapeNodePointer(local_6c)->getShapeDraw(local_6e)->getDisplayList();
- u8* local_58 = pcVar10;
+
+ for (u16 j = 0; j < (u16)pModelData->getShapeNodePointer(i)->getMtxGroupNum(); j++) {
+ J3DShapeMtx* pShapeMtx = pModelData->getShapeNodePointer(i)->getShapeMtx(j);
+ u8* pDList = pModelData->getShapeNodePointer(i)->getShapeDraw(j)->getDisplayList();
+ u8* pDListPos = pDList;
int uVar13;
for (;
- (int)local_58 - (int)pcVar10 < param_0->getShapeNodePointer(local_6c)->getShapeDraw(local_6e)->getDisplayListSize();
- local_58 += r23 * uVar13) {
- u8 uVar1 = *local_58;
- local_58++;
- if (uVar1 != 0xA0 && uVar1 != 0x98) {
+ (int)pDListPos - (int)pDList < pModelData->getShapeNodePointer(i)->getShapeDraw(j)->getDisplayListSize();
+ pDListPos += r23 * uVar13)
+ {
+ u8 command = *pDListPos;
+ pDListPos++;
+ if (command != GX_TRIANGLEFAN && command != GX_TRIANGLESTRIP) {
break;
}
- uVar13 = *(u16*)local_58;
- local_58 += 2;
+ uVar13 = *(u16*)pDListPos;
+ pDListPos += 2;
for (int local_60 = 0; local_60 < uVar13; local_60++) {
- u8* iVar5 = local_58 + r23 * local_60;
- u8 bVar3 = *(iVar5 + r26) / 3U;
- u16 uVar1 = *(u16*)(iVar5 + r25);
- u16 uVar2 = *(u16*)(iVar5 + r24);
- u16 uVar3 = *(u16*)(iVar5 + stack_3c);
- u16 local_76 = piVar8->getUseMtxIndex(bVar3);
+ u8* iVar5 = pDListPos + r23 * local_60;
+ u8 bVar3 = *(iVar5 + pnmtx_num) / 3U;
+ u16 vtx_idx = *(u16*)(iVar5 + vtx_num);
+ u16 nrm_idx = *(u16*)(iVar5 + nrm_num);
+ u16 uVar3 = *(u16*)(iVar5 + tex_num);
+ u16 local_76 = pShapeMtx->getUseMtxIndex(bVar3);
if (local_76 == 0xffff) {
local_76 = sWorkArea_MtxReg[bVar3];
- } else if (r26 != -1) {
+ } else if (pnmtx_num != -1) {
sWorkArea_MtxReg[bVar3] = local_76;
}
- J3D_ASSERT(673, local_76 < param_0->getDrawMtxNum(), "Error : range over.");
- J3D_ASSERT(674, uVar1 < param_0->getVtxNum(), "Error : range over.");
- mPosData[uVar1] = local_76;
- if (r24 != -1) {
- J3D_ASSERT(680, uVar2 < param_0->getNrmNum(), "Error : range over.");
- mNrmData[uVar2] = local_76;
+
+ J3D_ASSERT_RANGE(673, local_76 < pModelData->getDrawMtxNum());
+ J3D_ASSERT_RANGE(674, vtx_idx < pModelData->getVtxNum());
+ mPosData[vtx_idx] = local_76;
+
+ if (nrm_num != -1) {
+ J3D_ASSERT_RANGE(680, nrm_idx < pModelData->getNrmNum());
+ mNrmData[nrm_idx] = local_76;
}
}
}
- if (r24 == -1) {
- param_0->getShapeNodePointer(local_6c)->onFlag(0x100);
- param_0->getShapeNodePointer(local_6c)->offFlag(8);
+
+ if (nrm_num == -1) {
+ pModelData->getShapeNodePointer(i)->onFlag(J3DShpFlag_EnableLod);
+ pModelData->getShapeNodePointer(i)->offFlag(J3DShpFlag_SkinNrmCpu);
}
}
}
- for (int i = 0; i < param_0->getVtxNum(); i++) {
+ for (int i = 0; i < pModelData->getVtxNum(); i++) {
if (mPosData[i] == 0xffff) {
field_0x18 = 0x0;
mPosData[i] = 0;
@@ -340,36 +341,38 @@ int J3DSkinDeform::initMtxIndexArray(J3DModelData* param_0) {
}
}
- return 0;
+ return kJ3DError_Success;
}
/* 8032D378-8032D5C4 327CB8 024C+00 0/0 1/1 0/0 .text
* changeFastSkinDL__13J3DSkinDeformFP12J3DModelData */
// NONMATCHING - regalloc, display list access issues
-void J3DSkinDeform::changeFastSkinDL(J3DModelData* param_0) {
- J3D_ASSERT(740, param_0, "Error : null pointer.");
- for (u16 i = 0; i < param_0->getShapeNum(); i++) {
- u32 local_28[4] = {0,1,1,2};
+void J3DSkinDeform::changeFastSkinDL(J3DModelData* pModelData) {
+ J3D_ASSERT_NULLPTR(740, pModelData != NULL);
+ for (u16 i = 0; i < pModelData->getShapeNum(); i++) {
+ u32 kSize[4] = {0,1,1,2};
int local_30 = -1;
int local_34 = 0;
- J3DShape* pShapeNode = param_0->getShapeNodePointer(i);
- for (GXVtxDescList* local_3c = pShapeNode->getVtxDesc(); local_3c->attr != GX_VA_NULL; local_3c++) {
- if (local_3c->attr == GX_VA_PNMTXIDX) {
+ J3DShape* pShapeNode = pModelData->getShapeNodePointer(i);
+ for (GXVtxDescList* vtxDesc = pShapeNode->getVtxDesc(); vtxDesc->attr != GX_VA_NULL; vtxDesc++) {
+ if (vtxDesc->attr == GX_VA_PNMTXIDX) {
local_30 = local_34;
}
- local_34 += local_28[local_3c->type];
+ local_34 += kSize[vtxDesc->type];
}
+
if (local_30 != -1) {
- for (u16 j = 0; j < pShapeNode->getMtxGroupNum(); j++) {
- u8* puVar5 = pShapeNode->getShapeDraw(j)->getDisplayList();
- u8* local_44 = puVar5;
- u8* puVar10 = puVar5;
- while (local_44 - puVar5 < pShapeNode->getShapeDraw(j)->getDisplayListSize()) {
- u8 cVar1 = *local_44;
+ for (u16 j = 0; j < (u16)pShapeNode->getMtxGroupNum(); j++) {
+ u8* pDList = pShapeNode->getShapeDraw(j)->getDisplayList();
+ u8* local_44 = pDList;
+ u8* puVar10 = pDList;
+ while (local_44 - pDList < pShapeNode->getShapeDraw(j)->getDisplayListSize()) {
+ u8 command = *local_44;
local_44++;
- *puVar10++ = cVar1;
- if ((cVar1 != 0xA0) && (cVar1 != 0x98))
+ *puVar10++ = command;
+ if (command != GX_TRIANGLEFAN && command != GX_TRIANGLESTRIP)
break;
+
int uVar9 = *(u16*)local_44;
local_44 += 2;
*(u16*)puVar10 = uVar9;
@@ -381,19 +384,20 @@ void J3DSkinDeform::changeFastSkinDL(J3DModelData* param_0) {
}
local_44 += local_34 * uVar9;
}
- int pcVar2 = ((int)puVar10 - (int)puVar5 + 0x1f) & ~0x1f;
- while ((int)puVar10 - (int)puVar5 < pShapeNode->getShapeDraw(j)->getDisplayListSize()) {
+
+ int dlistSize = ((int)puVar10 - (int)pDList + 0x1f) & ~0x1f;
+ while ((int)puVar10 - (int)pDList < pShapeNode->getShapeDraw(j)->getDisplayListSize()) {
*puVar10++ = 0;
}
- pShapeNode->getShapeDraw(j)->setDisplayListSize(pcVar2);
- DCStoreRange(puVar5, pShapeNode->getShapeDraw(j)->getDisplayListSize());
+
+ pShapeNode->getShapeDraw(j)->setDisplayListSize(dlistSize);
+ DCStoreRange(pDList, pShapeNode->getShapeDraw(j)->getDisplayListSize());
}
}
}
- ;
- ;
- for (u16 i = 0; i < param_0->getShapeNum(); i++) {
- J3DShape* pShape = param_0->getShapeNodePointer(i);
+
+ for (u16 i = 0; i < pModelData->getShapeNum(); i++) {
+ J3DShape* pShape = pModelData->getShapeNodePointer(i);
GXVtxDescList* local_5c = pShape->getVtxDesc();
GXVtxDescList* local_60 = local_5c;
for (; local_5c->attr != GX_VA_NULL; local_5c++) {
@@ -411,21 +415,21 @@ void J3DSkinDeform::changeFastSkinDL(J3DModelData* param_0) {
/* 8032D5C4-8032D738 327F04 0174+00 1/1 0/0 0/0 .text calcNrmMtx__13J3DSkinDeformFP12J3DMtxBuffer
*/
-void J3DSkinDeform::calcNrmMtx(J3DMtxBuffer* param_0) {
- J3DJointTree* jointTree = param_0->getJointTree();
+void J3DSkinDeform::calcNrmMtx(J3DMtxBuffer* pMtxBuffer) {
+ J3DJointTree* jointTree = pMtxBuffer->getJointTree();
u16 drawMtxNum = jointTree->getDrawMtxNum();
for (u16 i = 0; i < drawMtxNum; i++) {
if (jointTree->getDrawMtxFlag(i) == 0) {
- if (param_0->getScaleFlag(jointTree->getDrawMtxIndex(i)) == 1) {
- setNrmMtx(i, param_0->getAnmMtx(jointTree->getDrawMtxIndex(i)));
+ if (pMtxBuffer->getScaleFlag(jointTree->getDrawMtxIndex(i)) == 1) {
+ setNrmMtx(i, pMtxBuffer->getAnmMtx(jointTree->getDrawMtxIndex(i)));
} else {
- J3DPSCalcInverseTranspose(param_0->getAnmMtx(jointTree->getDrawMtxIndex(i)), getNrmMtx(i));
+ J3DPSCalcInverseTranspose(pMtxBuffer->getAnmMtx(jointTree->getDrawMtxIndex(i)), getNrmMtx(i));
}
} else {
- if (param_0->getEnvScaleFlag(jointTree->getDrawMtxIndex(i)) == 1) {
- setNrmMtx(i, param_0->getWeightAnmMtx(jointTree->getDrawMtxIndex(i)));
+ if (pMtxBuffer->getEnvScaleFlag(jointTree->getDrawMtxIndex(i)) == 1) {
+ setNrmMtx(i, pMtxBuffer->getWeightAnmMtx(jointTree->getDrawMtxIndex(i)));
} else {
- J3DPSCalcInverseTranspose(param_0->getWeightAnmMtx(jointTree->getDrawMtxIndex(i)), getNrmMtx(i));
+ J3DPSCalcInverseTranspose(pMtxBuffer->getWeightAnmMtx(jointTree->getDrawMtxIndex(i)), getNrmMtx(i));
}
}
}
@@ -433,41 +437,46 @@ void J3DSkinDeform::calcNrmMtx(J3DMtxBuffer* param_0) {
/* 8032D738-8032D87C 328078 0144+00 0/0 1/1 0/0 .text
* transformVtxPosNrm__13J3DSkinDeformFP12J3DModelData */
-void J3DSkinDeform::transformVtxPosNrm(J3DModelData* param_0) {
- if (param_0->getWEvlpMtxNum() != 0 && field_0x19 == 0) {
- int vtmNum = param_0->getVtxNum();
- int nrmNum = param_0->getNrmNum();
+void J3DSkinDeform::transformVtxPosNrm(J3DModelData* pModelData) {
+ if (pModelData->getWEvlpMtxNum() != 0 && field_0x19 == 0) {
+ int vtmNum = pModelData->getVtxNum();
+ int nrmNum = pModelData->getNrmNum();
+
for (int i = 0; i < vtmNum; i++) {
u16 posIndex = mPosData[i];
- if (param_0->getDrawMtxFlag(posIndex) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(posIndex);
- Vec* pos = ((Vec*)param_0->getVtxPosArray()) + i;
+ if (pModelData->getDrawMtxFlag(posIndex) == 0) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(posIndex);
+ Vec* pos = ((Vec*)pModelData->getVtxPosArray()) + i;
Mtx invMtx;
- MTXInverse(param_0->getInvJointMtx(drawMtxIndex), invMtx);
+ MTXInverse(pModelData->getInvJointMtx(drawMtxIndex), invMtx);
MTXMultVec(invMtx, pos, pos);
}
}
+
for (int i = 0; i < nrmNum; i++) {
u16 nrmIndex = mNrmData[i];
- if (param_0->getDrawMtxFlag(nrmIndex) == 0) {
- u16 drawMtxIndex = param_0->getDrawMtxIndex(nrmIndex);
- Vec* nrm = ((Vec*)param_0->getVtxNrmArray()) + i;
+ if (pModelData->getDrawMtxFlag(nrmIndex) == 0) {
+ u16 drawMtxIndex = pModelData->getDrawMtxIndex(nrmIndex);
+ Vec* nrm = ((Vec*)pModelData->getVtxNrmArray()) + i;
Mtx invMtx;
- MTXInverse(param_0->getInvJointMtx(drawMtxIndex), invMtx);
+ MTXInverse(pModelData->getInvJointMtx(drawMtxIndex), invMtx);
MTXMultVecSR(invMtx, nrm, nrm);
}
}
+
field_0x19 = 1;
}
}
/* 8032D87C-8032D8F4 3281BC 0078+00 1/1 0/0 0/0 .text
* calcAnmInvJointMtx__13J3DSkinDeformFP12J3DMtxBuffer */
-void J3DSkinDeform::calcAnmInvJointMtx(J3DMtxBuffer* param_0) {
- if (param_0->getJointTree()->getWEvlpMtxNum() != 0) {
- u16 jointNum = param_0->getJointTree()->getJointNum();
- Mtx* anmMtx = (Mtx*)param_0->getAnmMtx(0);
- Mtx* invJointMtx = &param_0->getJointTree()->getInvJointMtx(0);
+void J3DSkinDeform::calcAnmInvJointMtx(J3DMtxBuffer* pMtxBuffer) {
+ J3D_ASSERT_NULLPTR(978, pMtxBuffer != NULL);
+
+ if (pMtxBuffer->getJointTree()->getWEvlpMtxNum() != 0) {
+ int jointNum = pMtxBuffer->getJointTree()->getJointNum();
+ Mtx* anmMtx = (Mtx*)pMtxBuffer->getAnmMtx(0);
+ Mtx* invJointMtx = &pMtxBuffer->getJointTree()->getInvJointMtx(0);
Mtx* posMtx = mPosMtx;
for (int i = 0; i < jointNum; i++) {
MTXConcat(anmMtx[i], invJointMtx[i], posMtx[i]);
@@ -477,177 +486,208 @@ void J3DSkinDeform::calcAnmInvJointMtx(J3DMtxBuffer* param_0) {
/* 8032D8F4-8032DA1C 328234 0128+00 1/1 0/0 0/0 .text
* deformFastVtxPos_F32__13J3DSkinDeformCFP15J3DVertexBufferP12J3DMtxBuffer */
-void J3DSkinDeform::deformFastVtxPos_F32(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) const {
- param_0->swapTransformedVtxPos();
- J3DJointTree* jointTree = param_1->getJointTree();
- u32 vtxNum = param_0->getVertexData()->getVtxNum();
- void* currentVtxPos = param_0->getCurrentVtxPos();
- void* transformedVtxPos = param_0->getTransformedVtxPos(0);
- J3DFillZero32B(transformedVtxPos, (vtxNum * sizeof(Vec) + 0x1f) & ~0x1f);
+void J3DSkinDeform::deformFastVtxPos_F32(J3DVertexBuffer* pVtxBuffer, J3DMtxBuffer* pMtxBuffer) const {
+ pVtxBuffer->swapTransformedVtxPos();
+ J3DJointTree* jointTree = pMtxBuffer->getJointTree();
+ u32 vtxNum = pVtxBuffer->getVertexData()->getVtxNum();
+ int sp14 = jointTree->getDrawMtxNum();
+ void* currentVtxPos = pVtxBuffer->getCurrentVtxPos();
+ void* transformedVtxPos = pVtxBuffer->getTransformedVtxPos(0);
+
+ J3DFillZero32B(transformedVtxPos, OSRoundUp32B(vtxNum * sizeof(Vec)));
+
if (jointTree->getWEvlpMtxNum() != 0) {
u16 jointNum = jointTree->getJointNum();
for (u16 i = 0; i < jointNum; i++) {
- mSkinNList[i].calcSkin_VtxPosF32(mPosMtx[i], currentVtxPos, transformedVtxPos);
+ J3DSkinNList* skinList = mSkinNList + i;
+ skinList->calcSkin_VtxPosF32(mPosMtx[i], currentVtxPos, transformedVtxPos);
}
} else {
u16 jointNum = jointTree->getJointNum();
for (u16 i = 0; i < jointNum; i++) {
J3DSkinNList* skinList = mSkinNList + i;
- skinList->calcSkin_VtxPosF32(param_1->getAnmMtx(i), currentVtxPos, transformedVtxPos);
+ skinList->calcSkin_VtxPosF32(pMtxBuffer->getAnmMtx(i), currentVtxPos, transformedVtxPos);
}
}
- DCStoreRange(param_0->getTransformedVtxPos(0), param_0->getVertexData()->getVtxNum() * sizeof(Vec));
- param_0->setCurrentVtxPos(transformedVtxPos);
-}
-/* ############################################################################################## */
+ DCStoreRange(pVtxBuffer->getTransformedVtxPos(0), pVtxBuffer->getVertexData()->getVtxNum() * sizeof(Vec));
+ pVtxBuffer->setCurrentVtxPos(transformedVtxPos);
+}
/* 8032DA1C-8032DB50 32835C 0134+00 1/1 0/0 0/0 .text
* deformFastVtxNrm_F32__13J3DSkinDeformCFP15J3DVertexBufferP12J3DMtxBuffer */
-void J3DSkinDeform::deformFastVtxNrm_F32(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) const {
- param_0->swapTransformedVtxNrm();
- J3DJointTree* jointTree = param_1->getJointTree();
- int nrmNum = param_0->getVertexData()->getNrmNum();
- void* currentVtxNrm = param_0->getCurrentVtxNrm();
- void* transformedVtxNrm = param_0->getTransformedVtxNrm(0);
+void J3DSkinDeform::deformFastVtxNrm_F32(J3DVertexBuffer* pVtxBuffer, J3DMtxBuffer* pMtxBuffer) const {
+ pVtxBuffer->swapTransformedVtxNrm();
+ J3DJointTree* jointTree = pMtxBuffer->getJointTree();
+ int nrmNum = pVtxBuffer->getVertexData()->getNrmNum();
+ int sp18 = jointTree->getDrawMtxNum();
+ void* currentVtxNrm = pVtxBuffer->getCurrentVtxNrm();
+ void* transformedVtxNrm = pVtxBuffer->getTransformedVtxNrm(0);
+
for (int i = 0; i < nrmNum; i++) {
- ((Vec*)transformedVtxNrm)[i].x = 0.0f;
- ((Vec*)transformedVtxNrm)[i].y = 0.0f;
- ((Vec*)transformedVtxNrm)[i].z = 0.0f;
+ ((f32*)transformedVtxNrm)[(i * 3) + 0] = 0.0f;
+ ((f32*)transformedVtxNrm)[(i * 3) + 1] = 0.0f;
+ ((f32*)transformedVtxNrm)[(i * 3) + 2] = 0.0f;
}
+
if (jointTree->getWEvlpMtxNum() != 0) {
u16 jointNum = jointTree->getJointNum();
for (u16 i = 0; i < jointNum; i++) {
- mSkinNList[i].calcSkin_VtxNrmF32(mPosMtx[i], currentVtxNrm, transformedVtxNrm);
+ J3DSkinNList* skinList = mSkinNList + i;
+ skinList->calcSkin_VtxNrmF32(mPosMtx[i], currentVtxNrm, transformedVtxNrm);
}
} else {
u16 jointNum = jointTree->getJointNum();
for (u16 i = 0; i < jointNum; i++) {
J3DSkinNList* skinList = mSkinNList + i;
- skinList->calcSkin_VtxNrmF32(param_1->getAnmMtx(i), currentVtxNrm, transformedVtxNrm);
+ skinList->calcSkin_VtxNrmF32(pMtxBuffer->getAnmMtx(i), currentVtxNrm, transformedVtxNrm);
}
}
- DCStoreRange(param_0->getTransformedVtxNrm(0), param_0->getVertexData()->getNrmNum() * sizeof(Vec));
- param_0->setCurrentVtxNrm(transformedVtxNrm);
+
+ DCStoreRange(pVtxBuffer->getTransformedVtxNrm(0), pVtxBuffer->getVertexData()->getNrmNum() * sizeof(Vec));
+ pVtxBuffer->setCurrentVtxNrm(transformedVtxNrm);
}
/* 8032DB50-8032DC74 328490 0124+00 1/1 0/0 0/0 .text
* deformVtxPos_F32__13J3DSkinDeformCFP15J3DVertexBufferP12J3DMtxBuffer */
// NONMATCHING - J3DPSMulMtxVec regalloc
-void J3DSkinDeform::deformVtxPos_F32(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) const {
+void J3DSkinDeform::deformVtxPos_F32(J3DVertexBuffer* pVtxBuffer, J3DMtxBuffer* pMtxBuffer) const {
+ Mtx* anmMtx = NULL;
Mtx* anmMtxs[2];
- anmMtxs[0] = (Mtx*)param_1->getAnmMtx(0);
- anmMtxs[1] = (Mtx*)param_1->getWeightAnmMtx(0);
- param_0->swapTransformedVtxPos();
- J3DJointTree* jointTree = param_1->getJointTree();
- int vtxNum = param_0->getVertexData()->getVtxNum();
- void* currentVtxPos = param_0->getCurrentVtxPos();
- void* transformedVtxPos = param_0->getTransformedVtxPos(0);
+ anmMtxs[0] = (Mtx*)pMtxBuffer->getAnmMtx(0);
+ anmMtxs[1] = (Mtx*)pMtxBuffer->getWeightAnmMtx(0);
+ pVtxBuffer->swapTransformedVtxPos();
+
+ J3DJointTree* jointTree = pMtxBuffer->getJointTree();
+ int vtxNum = pVtxBuffer->getVertexData()->getVtxNum();
+ int sp8 = jointTree->getDrawMtxNum();
+ void* currentVtxPos = pVtxBuffer->getCurrentVtxPos();
+ void* transformedVtxPos = pVtxBuffer->getTransformedVtxPos(0);
+
for (int i = 0; i < vtxNum; i++) {
- Mtx* anmMtx = anmMtxs[jointTree->getDrawMtxFlag(mPosData[i])];
- J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], ((Vec*)currentVtxPos) + i, ((Vec*)transformedVtxPos) + i);
+ anmMtx = anmMtxs[jointTree->getDrawMtxFlag(mPosData[i])];
+ J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], (Vec*)(((f32*)currentVtxPos) + (i * 3)), (Vec*)(((f32*)transformedVtxPos) + (i * 3)));
}
- DCStoreRange(param_0->getTransformedVtxPos(0), param_0->getVertexData()->getVtxNum() * sizeof(Vec));
- param_0->setCurrentVtxPos(transformedVtxPos);
+
+ DCStoreRange(pVtxBuffer->getTransformedVtxPos(0), pVtxBuffer->getVertexData()->getVtxNum() * sizeof(Vec));
+ pVtxBuffer->setCurrentVtxPos(transformedVtxPos);
}
/* 8032DC74-8032DDB8 3285B4 0144+00 1/1 0/0 0/0 .text
* deformVtxPos_S16__13J3DSkinDeformCFP15J3DVertexBufferP12J3DMtxBuffer */
// NONMATCHING - J3DPSMulMtxVec regalloc
-void J3DSkinDeform::deformVtxPos_S16(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) const {
+void J3DSkinDeform::deformVtxPos_S16(J3DVertexBuffer* pVtxBuffer, J3DMtxBuffer* pMtxBuffer) const {
+ Mtx* anmMtx = NULL;
Mtx* anmMtxs[2];
- anmMtxs[0] = (Mtx*)param_1->getAnmMtx(0);
- anmMtxs[1] = (Mtx*)param_1->getWeightAnmMtx(0);
- u8 vtxPosFrac = param_0->getVertexData()->getVtxPosFrac();
+ anmMtxs[0] = (Mtx*)pMtxBuffer->getAnmMtx(0);
+ anmMtxs[1] = (Mtx*)pMtxBuffer->getWeightAnmMtx(0);
+ int vtxPosFrac = pVtxBuffer->getVertexData()->getVtxPosFrac();
J3DGQRSetup7(vtxPosFrac, 7, vtxPosFrac, 7);
- param_0->swapTransformedVtxPos();
- J3DJointTree* jointTree = param_1->getJointTree();
- int vtxNum = param_0->getVertexData()->getVtxNum();
- void* currentVtxPos = param_0->getCurrentVtxPos();
- void* transformedVtxPos = param_0->getTransformedVtxPos(0);
+ pVtxBuffer->swapTransformedVtxPos();
+
+ J3DJointTree* jointTree = pMtxBuffer->getJointTree();
+ int vtxNum = pVtxBuffer->getVertexData()->getVtxNum();
+ int sp8 = jointTree->getDrawMtxNum();
+ void* currentVtxPos = pVtxBuffer->getCurrentVtxPos();
+ void* transformedVtxPos = pVtxBuffer->getTransformedVtxPos(0);
+
for (int i = 0; i < vtxNum; i++) {
- Mtx* anmMtx = anmMtxs[jointTree->getDrawMtxFlag(mPosData[i])];
- J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], ((S16Vec*)currentVtxPos) + i, ((S16Vec*)transformedVtxPos) + i);
+ anmMtx = anmMtxs[jointTree->getDrawMtxFlag(mPosData[i])];
+ J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], (S16Vec*)(((s16*)currentVtxPos) + (i * 3)), (S16Vec*)(((s16*)transformedVtxPos) + (i * 3)));
}
- DCStoreRange(param_0->getTransformedVtxPos(0), param_0->getVertexData()->getVtxNum() * sizeof(S16Vec));
- param_0->setCurrentVtxPos(transformedVtxPos);
+
+ DCStoreRange(pVtxBuffer->getTransformedVtxPos(0), pVtxBuffer->getVertexData()->getVtxNum() * sizeof(S16Vec));
+ pVtxBuffer->setCurrentVtxPos(transformedVtxPos);
}
/* 8032DDB8-8032DEBC 3286F8 0104+00 1/1 0/0 0/0 .text
* deformVtxNrm_F32__13J3DSkinDeformCFP15J3DVertexBuffer */
// NONMATCHING - J3DPSMulMtxVec regalloc
-void J3DSkinDeform::deformVtxNrm_F32(J3DVertexBuffer* param_0) const {
- param_0->swapTransformedVtxNrm();
- int nrmNum = param_0->getVertexData()->getNrmNum();
- void* currentVtxNrm = param_0->getCurrentVtxNrm();
- void* transformedVtxNrm = param_0->getTransformedVtxNrm(0);
+void J3DSkinDeform::deformVtxNrm_F32(J3DVertexBuffer* pVtxBuffer) const {
+ pVtxBuffer->swapTransformedVtxNrm();
+ int nrmNum = pVtxBuffer->getVertexData()->getNrmNum();
+ void* currentVtxNrm = pVtxBuffer->getCurrentVtxNrm();
+ void* transformedVtxNrm = pVtxBuffer->getTransformedVtxNrm(0);
+
for (int i = 0; i < nrmNum; i++) {
J3DPSMulMtxVec(mNrmMtx[mNrmData[i]], (Vec*)((u8*)currentVtxNrm + i * 3 * 4), (Vec*)((u8*)transformedVtxNrm + i * 3 * 4));
}
- DCStoreRange(param_0->getTransformedVtxNrm(0), param_0->getVertexData()->getNrmNum() * sizeof(Vec));
- param_0->setCurrentVtxNrm(transformedVtxNrm);
+
+ DCStoreRange(pVtxBuffer->getTransformedVtxNrm(0), pVtxBuffer->getVertexData()->getNrmNum() * sizeof(Vec));
+ pVtxBuffer->setCurrentVtxNrm(transformedVtxNrm);
}
/* 8032DEBC-8032DFDC 3287FC 0120+00 1/1 0/0 0/0 .text
* deformVtxNrm_S16__13J3DSkinDeformCFP15J3DVertexBuffer */
// NONMATCHING - J3DPSMulMtxVec regalloc
-void J3DSkinDeform::deformVtxNrm_S16(J3DVertexBuffer* param_0) const {
- u8 vtxNrmFrac = param_0->getVertexData()->getVtxNrmFrac();
+void J3DSkinDeform::deformVtxNrm_S16(J3DVertexBuffer* pVtxBuffer) const {
+ int vtxNrmFrac = pVtxBuffer->getVertexData()->getVtxNrmFrac();
J3DGQRSetup7(vtxNrmFrac, 7, vtxNrmFrac, 7);
- param_0->swapTransformedVtxNrm();
- int nrmNum = param_0->getVertexData()->getNrmNum();
- void* currentVtxNrm = param_0->getCurrentVtxNrm();
- void* transformedVtxNrm = param_0->getTransformedVtxNrm(0);
+ pVtxBuffer->swapTransformedVtxNrm();
+
+ int nrmNum = pVtxBuffer->getVertexData()->getNrmNum();
+ void* currentVtxNrm = pVtxBuffer->getCurrentVtxNrm();
+ void* transformedVtxNrm = pVtxBuffer->getTransformedVtxNrm(0);
+
for (int i = 0; i < nrmNum; i++) {
- J3DPSMulMtxVec(mNrmMtx[mNrmData[i]], ((S16Vec*)currentVtxNrm) + i, ((S16Vec*)transformedVtxNrm) + i);
+ J3DPSMulMtxVec(mNrmMtx[mNrmData[i]], (S16Vec*)(((s16*)currentVtxNrm) + (i * 3)), (S16Vec*)(((s16*)transformedVtxNrm) + (i * 3)));
}
- DCStoreRange(param_0->getTransformedVtxNrm(0), param_0->getVertexData()->getNrmNum() * sizeof(S16Vec));
- param_0->setCurrentVtxNrm(transformedVtxNrm);
+
+ DCStoreRange(pVtxBuffer->getTransformedVtxNrm(0), pVtxBuffer->getVertexData()->getNrmNum() * sizeof(S16Vec));
+ pVtxBuffer->setCurrentVtxNrm(transformedVtxNrm);
}
/* 8032DFDC-8032E064 32891C 0088+00 0/0 1/1 0/0 .text deform__13J3DSkinDeformFP8J3DModel
*/
-void J3DSkinDeform::deform(J3DModel* param_0) {
- if (param_0->checkFlag(4)) {
+void J3DSkinDeform::deform(J3DModel* pModel) {
+ J3D_ASSERT_NULLPTR(1270, pModel != NULL);
+
+ if (pModel->checkFlag(J3DMdlFlag_SkinPosCpu)) {
onFlag(2);
} else {
offFlag(2);
}
- if (param_0->checkFlag(8)) {
+ if (pModel->checkFlag(J3DMdlFlag_SkinNrmCpu)) {
onFlag(1);
} else {
offFlag(1);
}
- deform(param_0->getVertexBuffer(), param_0->getMtxBuffer());
+
+ deform(pModel->getVertexBuffer(), pModel->getMtxBuffer());
}
/* 8032E064-8032E180 3289A4 011C+00 1/0 0/0 0/0 .text
* deform__13J3DSkinDeformFP15J3DVertexBufferP12J3DMtxBuffer */
-void J3DSkinDeform::deform(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) {
- if (param_1->getJointTree()->checkFlag(0x100)) {
- calcAnmInvJointMtx(param_1);
+void J3DSkinDeform::deform(J3DVertexBuffer* pVtxBuffer, J3DMtxBuffer* pMtxBuffer) {
+ J3D_ASSERT_NULLPTR(1299, pVtxBuffer != NULL);
+ J3D_ASSERT_NULLPTR(1300, pMtxBuffer != NULL);
+
+ if (pMtxBuffer->getJointTree()->checkFlag(0x100)) {
+ calcAnmInvJointMtx(pMtxBuffer);
}
+
if (checkFlag(2) != 0) {
- if (param_1->getJointTree()->checkFlag(0x100)) {
- deformFastVtxPos_F32(param_0, param_1);
+ if (pMtxBuffer->getJointTree()->checkFlag(0x100)) {
+ deformFastVtxPos_F32(pVtxBuffer, pMtxBuffer);
} else {
- if (param_0->getVertexData()->getVtxPosType() == 4) {
- deformVtxPos_F32(param_0, param_1);
+ if (pVtxBuffer->getVertexData()->getVtxPosType() == 4) {
+ deformVtxPos_F32(pVtxBuffer, pMtxBuffer);
} else {
- deformVtxPos_S16(param_0, param_1);
+ deformVtxPos_S16(pVtxBuffer, pMtxBuffer);
}
}
}
- if (checkFlag(1) != 0) {
- if (param_1->getJointTree()->checkFlag(0x100)) {
- deformFastVtxNrm_F32(param_0, param_1);
+
+ if (checkFlag(1)) {
+ if (pMtxBuffer->getJointTree()->checkFlag(0x100)) {
+ deformFastVtxNrm_F32(pVtxBuffer, pMtxBuffer);
} else {
- calcNrmMtx(param_1);
- if (param_0->getVertexData()->getVtxNrmType() == 4) {
- deformVtxNrm_F32(param_0);
+ calcNrmMtx(pMtxBuffer);
+ if (pVtxBuffer->getVertexData()->getVtxNrmType() == 4) {
+ deformVtxNrm_F32(pVtxBuffer);
} else {
- deformVtxNrm_S16(param_0);
+ deformVtxNrm_S16(pVtxBuffer);
}
}
}
@@ -655,11 +695,10 @@ void J3DSkinDeform::deform(J3DVertexBuffer* param_0, J3DMtxBuffer* param_1) {
/* 8032E180-8032E1B0 328AC0 0030+00 0/0 1/1 0/0 .text calc__15J3DVtxColorCalcFP8J3DModel
*/
-void J3DVtxColorCalc::calc(J3DModel* param_0) {
- calc(param_0->getVertexBuffer());
+void J3DVtxColorCalc::calc(J3DModel* pModel) {
+ J3D_ASSERT_NULLPTR(1351, pModel != NULL);
+ calc(pModel->getVertexBuffer());
}
/* 8032E1B0-8032E1F8 328AF0 0048+00 1/0 0/0 0/0 .text __dt__13J3DSkinDeformFv */
J3DSkinDeform::~J3DSkinDeform() {}
-
-/* 803A2028-803A2028 02E688 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
generated by cgit v1.2.3 (git 2.25.1) at 2026-09-18 07:30:07 +0000