mirror of https://github.com/zeldaret/tp.git
1356 lines
48 KiB
C++
1356 lines
48 KiB
C++
//
|
|
// 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;
|
|
mState = 0;
|
|
mStart = 0;
|
|
mEnd = i_end;
|
|
mLoop = 0;
|
|
mRate = 1.0f;
|
|
mFrame = 0.0f;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
switch (mAttribute) {
|
|
case 0:
|
|
case 1:
|
|
if (next_frame < mStart) {
|
|
next_frame = mStart;
|
|
}
|
|
|
|
if (next_frame >= mEnd) {
|
|
next_frame = mEnd - 0.001f;
|
|
}
|
|
|
|
if (cur_frame <= next_frame) {
|
|
if (cur_frame <= pass_frame && pass_frame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (next_frame <= pass_frame && pass_frame < cur_frame) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case 2:
|
|
if (cur_frame < mStart) {
|
|
while (next_frame < mStart) {
|
|
if (mLoop - mStart <= 0.0f) {
|
|
break;
|
|
}
|
|
next_frame += mLoop - mStart;
|
|
}
|
|
|
|
if (next_frame <= pass_frame && pass_frame < mLoop) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (mEnd <= cur_frame) {
|
|
while (next_frame >= mEnd) {
|
|
if (mEnd - mLoop <= 0.0f) {
|
|
break;
|
|
}
|
|
next_frame -= mEnd - mLoop;
|
|
}
|
|
|
|
if (mLoop <= pass_frame && pass_frame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (next_frame < mStart) {
|
|
while (next_frame < mStart) {
|
|
if (mLoop - mStart <= 0.0f) {
|
|
break;
|
|
}
|
|
next_frame += mLoop - mStart;
|
|
}
|
|
|
|
if ((mStart <= pass_frame && pass_frame < cur_frame) || (next_frame <= pass_frame && pass_frame < mLoop)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (mEnd <= next_frame) {
|
|
while (next_frame >= mEnd) {
|
|
if (mEnd - mLoop <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
next_frame -= mEnd - mLoop;
|
|
}
|
|
|
|
if ((cur_frame <= pass_frame && pass_frame < mEnd) || (mLoop <= pass_frame && pass_frame < next_frame)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (cur_frame <= next_frame) {
|
|
if (cur_frame <= pass_frame && pass_frame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (next_frame <= pass_frame && pass_frame < cur_frame) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case 3:
|
|
case 4:
|
|
if (next_frame >= mEnd) {
|
|
next_frame = mEnd - 0.001f;
|
|
}
|
|
|
|
if (next_frame < mStart) {
|
|
next_frame = mStart;
|
|
}
|
|
|
|
if (cur_frame <= next_frame) {
|
|
if (cur_frame <= pass_frame && pass_frame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (next_frame <= pass_frame && pass_frame < cur_frame) {
|
|
return true;
|
|
}
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/* 803289CC-80328E40 32330C 0474+00 0/0 3/3 0/0 .text update__12J3DFrameCtrlFv */
|
|
void J3DFrameCtrl::update() {
|
|
mState = 0;
|
|
mFrame += mRate;
|
|
switch (mAttribute) {
|
|
case 0:
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= 1;
|
|
}
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mEnd - 0.001f;
|
|
mRate = 0.0f;
|
|
mState |= 1;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= 1;
|
|
}
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= 1;
|
|
}
|
|
break;
|
|
case 2:
|
|
while (mFrame < mStart) {
|
|
mState |= 2;
|
|
if (mLoop - mStart <= 0.0f) {
|
|
break;
|
|
}
|
|
mFrame += mLoop - mStart;
|
|
}
|
|
while (mFrame >= mEnd) {
|
|
mState |= 2;
|
|
if (mEnd - mLoop <= 0.0f) {
|
|
break;
|
|
}
|
|
mFrame -= mEnd - mLoop;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mEnd - (mFrame - mEnd);
|
|
mRate = -mRate;
|
|
}
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart - (mFrame - mStart);
|
|
mRate = 0.0f;
|
|
mState |= 1;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (mFrame >= mEnd - 1.0f) {
|
|
mFrame = (mEnd - 1.0f) - (mFrame - (mEnd - 1.0f));
|
|
mRate = -mRate;
|
|
}
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart - (mFrame - mStart);
|
|
mRate = -mRate;
|
|
mState |= 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;
|
|
field_0x18 = 0;
|
|
field_0x1a = 0;
|
|
field_0x1c = 0;
|
|
field_0x1e = 0;
|
|
}
|
|
|
|
/* 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;
|
|
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];
|
|
} else {
|
|
u32 frame = (int)(mFrame + 0.5f);
|
|
if (frame >= entryX->mScaleMaxFrame) {
|
|
o_transform->mScale.x = mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryX->mRotationMaxFrame) {
|
|
o_transform->mRotation.x =
|
|
mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryX->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.x =
|
|
mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
|
|
}
|
|
if (frame >= entryY->mScaleMaxFrame) {
|
|
o_transform->mScale.y = mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryY->mRotationMaxFrame) {
|
|
o_transform->mRotation.y =
|
|
mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryY->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.y =
|
|
mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mScaleMaxFrame) {
|
|
o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mRotationMaxFrame) {
|
|
o_transform->mRotation.z =
|
|
mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.z =
|
|
mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->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;
|
|
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];
|
|
} 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)];
|
|
} else {
|
|
o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryX->mRotationMaxFrame) {
|
|
o_transform->mRotation.x =
|
|
mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryX->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.x =
|
|
mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
|
|
}
|
|
if (frame >= entryY->mScaleMaxFrame) {
|
|
o_transform->mScale.y =
|
|
mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryY->mRotationMaxFrame) {
|
|
o_transform->mRotation.y =
|
|
mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryY->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.y =
|
|
mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mScaleMaxFrame) {
|
|
o_transform->mScale.z =
|
|
mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mRotationMaxFrame) {
|
|
o_transform->mRotation.z =
|
|
mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
|
|
}
|
|
if (frame >= entryZ->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.z =
|
|
mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->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)];
|
|
} else {
|
|
o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryX->mScaleOffset + frame2]
|
|
- mScaleData[entryX->mScaleOffset + frame]);
|
|
}
|
|
if (frame2 >= entryX->mRotationMaxFrame) {
|
|
o_transform->mRotation.x =
|
|
mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
|
|
} else {
|
|
u32 rot1 = (u16)mRotData[entryX->mRotationOffset + frame];
|
|
u32 rot2 = (u16)mRotData[entryX->mRotationOffset + frame2];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
o_transform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
if (frame2 >= entryX->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.x =
|
|
mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryX->mTranslateOffset + frame2]
|
|
- mTransData[entryX->mTranslateOffset + frame]);
|
|
}
|
|
if (frame2 >= entryY->mScaleMaxFrame) {
|
|
o_transform->mScale.y =
|
|
mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryY->mScaleOffset + frame2]
|
|
- mScaleData[entryY->mScaleOffset + frame]);
|
|
}
|
|
if (frame2 >= entryY->mRotationMaxFrame) {
|
|
o_transform->mRotation.y =
|
|
mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
|
|
} else {
|
|
u32 rot1 = (u16)mRotData[entryY->mRotationOffset + frame];
|
|
u32 rot2 = (u16)mRotData[entryY->mRotationOffset + frame2];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
o_transform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
if (frame2 >= entryY->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.y =
|
|
mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryY->mTranslateOffset + frame2]
|
|
- mTransData[entryY->mTranslateOffset + frame]);
|
|
}
|
|
if (frame2 >= entryZ->mScaleMaxFrame) {
|
|
o_transform->mScale.z =
|
|
mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryZ->mScaleOffset + frame2]
|
|
- mScaleData[entryZ->mScaleOffset + frame]);
|
|
}
|
|
if (frame2 >= entryZ->mRotationMaxFrame) {
|
|
o_transform->mRotation.z =
|
|
mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
|
|
} else {
|
|
u32 rot1 = (u16)mRotData[entryZ->mRotationOffset + frame];
|
|
u32 rot2 = (u16)mRotData[entryZ->mRotationOffset + frame2];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
o_transform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
if (frame2 >= entryZ->mTranslateMaxFrame) {
|
|
o_transform->mTranslate.z =
|
|
mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
|
|
} else {
|
|
o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryZ->mTranslateOffset + frame2]
|
|
- mTransData[entryZ->mTranslateOffset + frame]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline f32 J3DHermiteInterpolation(f32 p1, f32 const* p2, f32 const* p3, f32 const* p4,
|
|
f32 const* p5, f32 const* p6, f32 const* p7) {
|
|
return JMAHermiteInterpolation(p1, *p2, *p3, *p4, *p5, *p6, *p7);
|
|
}
|
|
|
|
inline f32 J3DHermiteInterpolation(register f32 pp1, register s16 const* pp2,
|
|
register s16 const* pp3, register s16 const* pp4,
|
|
register s16 const* pp5, register s16 const* pp6,
|
|
register s16 const* pp7) {
|
|
register f32 p1 = pp1;
|
|
register f32 ff8;
|
|
register f32 ff7;
|
|
register f32 ff6;
|
|
register f32 ff5;
|
|
register f32 ff4;
|
|
register f32 ff3;
|
|
register f32 ff2;
|
|
register f32 ff0;
|
|
register f32 fout;
|
|
register s16 const* p2 = pp2;
|
|
register s16 const* p3 = pp3;
|
|
register s16 const* p4 = pp4;
|
|
register s16 const* p5 = pp5;
|
|
register s16 const* p6 = pp6;
|
|
register s16 const* p7 = pp7;
|
|
// clang-format off
|
|
asm {
|
|
psq_l ff2, 0(p2), 0x1, 5
|
|
psq_l ff0, 0(p5), 0x1, 5
|
|
psq_l ff7, 0(p3), 0x1, 5
|
|
fsubs ff5, ff0, ff2
|
|
psq_l ff6, 0(p6), 0x1, 5
|
|
fsubs ff3, p1, ff2
|
|
psq_l ff0, 0(p7), 0x1, 5
|
|
fsubs ff4, ff6, ff7
|
|
fdivs ff3, ff3, ff5
|
|
psq_l fout, 0(p4), 0x1, 5
|
|
fmadds ff0, ff0, ff5, ff7
|
|
fmuls ff2, ff3, ff3
|
|
fnmsubs ff4, ff5, fout, ff4
|
|
fsubs ff0, ff0, ff6
|
|
fsubs ff0, ff0, ff4
|
|
fmuls ff0, ff2, ff0
|
|
fmadds fout, ff5, fout, ff0
|
|
fmadds fout, fout, ff3, ff7
|
|
fmadds fout, ff4, ff2, fout
|
|
fsubs fout, fout, ff0
|
|
}
|
|
// clang-format on
|
|
return fout;
|
|
}
|
|
|
|
template<typename T>
|
|
f32 J3DGetKeyFrameInterpolation(f32 i_frame, J3DAnmKeyTableBase* i_entry, T* i_data) {
|
|
if (i_frame < i_data[0]) {
|
|
return i_data[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];
|
|
}
|
|
u32 uVar7 = i_entry->mMaxFrame;
|
|
while (uVar7 > 1) {
|
|
u32 uVar2 = uVar7 >> 1;
|
|
u32 tmp = uVar2 * 3;
|
|
if (i_frame >= i_data[tmp]) {
|
|
i_data += 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]);
|
|
} else {
|
|
u32 idx = i_entry->mMaxFrame - 1;
|
|
if (i_data[idx * 4] <= i_frame) {
|
|
return i_data[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;
|
|
} else {
|
|
uVar7 = uVar2;
|
|
}
|
|
}
|
|
return J3DHermiteInterpolation(i_frame, &i_data[0], &i_data[1], &i_data[3],
|
|
&i_data[4], &i_data[5], &i_data[6]);
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
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;
|
|
break;
|
|
case 1:
|
|
o_transform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mScale.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
|
|
&mScaleData[entryX->mScaleInfo.mOffset]);
|
|
}
|
|
switch (entryY->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mScale.y = 1.0f;
|
|
break;
|
|
case 1:
|
|
o_transform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mScale.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
|
|
&mScaleData[entryY->mScaleInfo.mOffset]);
|
|
}
|
|
switch (entryZ->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mScale.z = 1.0f;
|
|
break;
|
|
case 1:
|
|
o_transform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mScale.z = J3DGetKeyFrameInterpolation(i_frame, &entryZ->mScaleInfo,
|
|
&mScaleData[entryZ->mScaleInfo.mOffset]);
|
|
}
|
|
switch (entryX->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mRotation.x = 0;
|
|
break;
|
|
case 1:
|
|
o_transform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
o_transform->mRotation.x = (int)J3DGetKeyFrameInterpolation(i_frame, &entryX->mRotationInfo,
|
|
&mRotData[entryX->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
switch (entryY->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mRotation.y = 0;
|
|
break;
|
|
case 1:
|
|
o_transform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
o_transform->mRotation.y = (int)J3DGetKeyFrameInterpolation(i_frame, &entryY->mRotationInfo,
|
|
&mRotData[entryY->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
switch (entryZ->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mRotation.z = 0;
|
|
break;
|
|
case 1:
|
|
o_transform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
o_transform->mRotation.z = (int)J3DGetKeyFrameInterpolation(i_frame, &entryZ->mRotationInfo,
|
|
&mRotData[entryZ->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
switch (entryX->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mTranslate.x = 0.0f;
|
|
break;
|
|
case 1:
|
|
o_transform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mTranslate.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
|
|
&mTransData[entryX->mTranslateInfo.mOffset]);
|
|
}
|
|
switch (entryY->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mTranslate.y = 0.0f;
|
|
break;
|
|
case 1:
|
|
o_transform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mTranslate.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mTranslateInfo,
|
|
&mTransData[entryY->mTranslateInfo.mOffset]);
|
|
}
|
|
switch (entryZ->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
o_transform->mTranslate.z = 0.0f;
|
|
break;
|
|
case 1:
|
|
o_transform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_transform->mTranslate.z = J3DGetKeyFrameInterpolation(i_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) {
|
|
mDecShift = 0;
|
|
mTransNum = 0;
|
|
mRotNum = 0;
|
|
mScaleNum = 0;
|
|
mTrackNum = 0;
|
|
mAnmTable = NULL;
|
|
mTransData = NULL;
|
|
mScaleData = NULL;
|
|
mRotData = NULL;
|
|
field_0x48 = 0;
|
|
field_0x46 = 0;
|
|
field_0x44 = 0;
|
|
field_0x4a = 0;
|
|
field_0x58 = NULL;
|
|
field_0x54 = NULL;
|
|
field_0x4c = 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;
|
|
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;
|
|
break;
|
|
case 1:
|
|
o_texinfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_texinfo->mScaleX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
|
|
&mScaleData[entryX->mScaleInfo.mOffset]);
|
|
}
|
|
switch (entryY->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
o_texinfo->mScaleY = 1.0f;
|
|
break;
|
|
case 1:
|
|
o_texinfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_texinfo->mScaleY = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
|
|
&mScaleData[entryY->mScaleInfo.mOffset]);
|
|
}
|
|
switch (entryRot->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
o_texinfo->mRotation = 0;
|
|
break;
|
|
case 1:
|
|
o_texinfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
o_texinfo->mRotation = (int)J3DGetKeyFrameInterpolation(i_frame, &entryRot->mRotationInfo,
|
|
&mRotData[entryRot->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
switch (entryX->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
o_texinfo->mTranslationX = 0.0f;
|
|
break;
|
|
case 1:
|
|
o_texinfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_texinfo->mTranslationX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
|
|
&mTransData[entryX->mTranslateInfo.mOffset]);
|
|
}
|
|
switch (entryY->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
o_texinfo->mTranslationY = 0.0f;
|
|
break;
|
|
case 1:
|
|
o_texinfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
o_texinfo->mTranslationY = J3DGetKeyFrameInterpolation(i_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;
|
|
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)];
|
|
} else {
|
|
return mWeight[mAnmTable[i_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) {
|
|
case 0:
|
|
return 1.0f;
|
|
case 1:
|
|
return mWeight[mAnmTable[i_index].mWeightTable.mOffset];
|
|
default:
|
|
return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[i_index].mWeightTable,
|
|
&mWeight[mAnmTable[i_index].mWeightTable.mOffset]);
|
|
}
|
|
}
|
|
|
|
/* 8032A29C-8032A30C 324BDC 0070+00 2/2 0/0 0/0 .text __ct__14J3DAnmVtxColorFv */
|
|
J3DAnmVtxColor::J3DAnmVtxColor() : J3DAnmBase(0) {
|
|
for (int i = 0; i < 2; i++) {
|
|
mAnmTableNum[i] = 0;
|
|
}
|
|
for (int i = 0; i < 2; i++) {
|
|
mAnmVtxColorIndexData[i] = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/* 8032A30C-8032A368 324C4C 005C+00 0/0 1/1 0/0 .text __ct__18J3DAnmVtxColorFullFv */
|
|
J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
|
|
for (int i = 0; i < 2; i++) {
|
|
mpTable[i] = NULL;
|
|
}
|
|
}
|
|
|
|
/* 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];
|
|
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];
|
|
} else {
|
|
int frame = (int)(mFrame + 0.5f);
|
|
if (frame >= entry->mRMaxFrame) {
|
|
o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
|
|
} else {
|
|
o_color->r = mColorR[entry->mROffset + frame];
|
|
}
|
|
if (frame >= entry->mGMaxFrame) {
|
|
o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
|
|
} else {
|
|
o_color->g = mColorG[entry->mGOffset + frame];
|
|
}
|
|
if (frame >= entry->mBMaxFrame) {
|
|
o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
|
|
} else {
|
|
o_color->b = mColorB[entry->mBOffset + frame];
|
|
}
|
|
if (frame >= entry->mAMaxFrame) {
|
|
o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
|
|
} else {
|
|
o_color->a = mColorA[entry->mAOffset + frame];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 8032A4E0-8032A53C 324E20 005C+00 0/0 1/1 0/0 .text __ct__17J3DAnmVtxColorKeyFv */
|
|
J3DAnmVtxColorKey::J3DAnmVtxColorKey() {
|
|
for (int i = 0; i < 2; i++) {
|
|
mpTable[i] = 0;
|
|
}
|
|
}
|
|
|
|
/* 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];
|
|
f32 col;
|
|
switch (entry->mRInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->r = 0;
|
|
break;
|
|
case 1:
|
|
o_color->r = mColorR[entry->mRInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
|
|
&mColorR[entry->mRInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
o_color->r = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &o_color->r);
|
|
} else {
|
|
o_color->r = 255;
|
|
}
|
|
}
|
|
switch (entry->mGInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->g = 0;
|
|
break;
|
|
case 1:
|
|
o_color->g = mColorG[entry->mGInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
|
|
&mColorG[entry->mGInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
o_color->g = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &o_color->g);
|
|
} else {
|
|
o_color->g = 255;
|
|
}
|
|
}
|
|
switch (entry->mBInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->b = 0;
|
|
break;
|
|
case 1:
|
|
o_color->b = mColorB[entry->mBInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
|
|
&mColorB[entry->mBInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
o_color->b = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &o_color->b);
|
|
} else {
|
|
o_color->b = 255;
|
|
}
|
|
}
|
|
switch (entry->mAInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->a = 0;
|
|
break;
|
|
case 1:
|
|
o_color->a = mColorA[entry->mAInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
|
|
&mColorA[entry->mAInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
o_color->a = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &o_color->a);
|
|
} else {
|
|
o_color->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),
|
|
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) {
|
|
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
|
|
int index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mUpdateMaterialID[i] = index;
|
|
} else {
|
|
mUpdateMaterialID[i] = 0xffff;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 8032A93C-8032A990 32527C 0054+00 0/0 1/1 0/0 .text __ct__15J3DAnmColorFullFv */
|
|
J3DAnmColorFull::J3DAnmColorFull() {
|
|
mColorR = NULL;
|
|
mColorG = NULL;
|
|
mColorB = NULL;
|
|
mColorA = NULL;
|
|
mAnmTable = NULL;
|
|
}
|
|
|
|
/* 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];
|
|
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];
|
|
} else {
|
|
int frame = (int)(mFrame + 0.5f);
|
|
if (frame >= entry->mRMaxFrame) {
|
|
o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
|
|
} else {
|
|
o_color->r = mColorR[entry->mROffset + frame];
|
|
}
|
|
if (frame >= entry->mGMaxFrame) {
|
|
o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
|
|
} else {
|
|
o_color->g = mColorG[entry->mGOffset + frame];
|
|
}
|
|
if (frame >= entry->mBMaxFrame) {
|
|
o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
|
|
} else {
|
|
o_color->b = mColorB[entry->mBOffset + frame];
|
|
}
|
|
if (frame >= entry->mAMaxFrame) {
|
|
o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
|
|
} else {
|
|
o_color->a = mColorA[entry->mAOffset + frame];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 8032AB00-8032AB54 325440 0054+00 0/0 1/1 0/0 .text __ct__14J3DAnmColorKeyFv */
|
|
J3DAnmColorKey::J3DAnmColorKey() {
|
|
mColorR = NULL;
|
|
mColorG = NULL;
|
|
mColorB = NULL;
|
|
mColorA = NULL;
|
|
mAnmTable = NULL;
|
|
}
|
|
|
|
/* 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];
|
|
f32 col;
|
|
switch (entry->mRInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->r = 0;
|
|
break;
|
|
case 1:
|
|
o_color->r = mColorR[entry->mRInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
|
|
&mColorR[entry->mRInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
o_color->r = 0;
|
|
} else if (col > 255.0f) {
|
|
o_color->r = 255;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->r);
|
|
}
|
|
}
|
|
switch (entry->mGInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->g = 0;
|
|
break;
|
|
case 1:
|
|
o_color->g = mColorG[entry->mGInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
|
|
&mColorG[entry->mGInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
o_color->g = 0;
|
|
} else if (col > 255.0f) {
|
|
o_color->g = 255;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->g);
|
|
}
|
|
}
|
|
switch (entry->mBInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->b = 0;
|
|
break;
|
|
case 1:
|
|
o_color->b = mColorB[entry->mBInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
|
|
&mColorB[entry->mBInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
o_color->b = 0;
|
|
} else if (col > 255.0f) {
|
|
o_color->b = 255;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->b);
|
|
}
|
|
}
|
|
switch (entry->mAInfo.mMaxFrame) {
|
|
case 0:
|
|
o_color->a = 0;
|
|
break;
|
|
case 1:
|
|
o_color->a = mColorA[entry->mAInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
|
|
&mColorA[entry->mAInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
o_color->a = 0;
|
|
} else if (col > 255.0f) {
|
|
o_color->a = 255;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->a);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 8032AE18-8032AED8 325758 00C0+00 0/0 1/1 0/0 .text __ct__15J3DAnmTevRegKeyFv */
|
|
J3DAnmTevRegKey::J3DAnmTevRegKey() : J3DAnmBase(0) {
|
|
mKRegUpdateMaterialNum = 0;
|
|
mCRegUpdateMaterialNum = 0;
|
|
mCRegDataCountA = 0;
|
|
mCRegDataCountB = 0;
|
|
mCRegDataCountG = 0;
|
|
mCRegDataCountR = 0;
|
|
mKRegDataCountA = 0;
|
|
mKRegDataCountB = 0;
|
|
mKRegDataCountG = 0;
|
|
mKRegDataCountR = 0;
|
|
mKRegUpdateMaterialID = NULL;
|
|
mCRegUpdateMaterialID = NULL;
|
|
mAnmCRegDataA = NULL;
|
|
mAnmCRegDataB = NULL;
|
|
mAnmCRegDataG = NULL;
|
|
mAnmCRegDataR = NULL;
|
|
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),
|
|
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;
|
|
if (mFrame < 0.0f) {
|
|
*o_texNo = mTextureIndex[mAnmTable[i_index].mOffset];
|
|
} else if (mFrame >= maxFrame) {
|
|
*o_texNo = mTextureIndex[mAnmTable[i_index].mOffset + (maxFrame - 1)];
|
|
} else {
|
|
*o_texNo = mTextureIndex[mAnmTable[i_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.");
|
|
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
|
|
s32 index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mUpdateMaterialID[i] = index;
|
|
} else {
|
|
mUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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());
|
|
}
|
|
|
|
/* 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.");
|
|
for (u16 i = 0; i < getUpdateMaterialNum(); i++) {
|
|
s32 index = i_materialTable->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));
|
|
if (index != -1) {
|
|
mPostUpdateMaterialID[i] = index;
|
|
} else {
|
|
mPostUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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());
|
|
}
|
|
|
|
/* 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];
|
|
f32 col;
|
|
switch (entry->mRTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->r = 0;
|
|
break;
|
|
case 1:
|
|
o_color->r = mAnmCRegDataR[entry->mRTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
|
|
&mAnmCRegDataR[entry->mRTable.mOffset]);
|
|
if (col < -0x400) {
|
|
o_color->r = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
o_color->r = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &o_color->r);
|
|
}
|
|
}
|
|
switch (entry->mGTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->g = 0;
|
|
break;
|
|
case 1:
|
|
o_color->g = mAnmCRegDataG[entry->mGTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
|
|
&mAnmCRegDataG[entry->mGTable.mOffset]);
|
|
if (col < -0x400) {
|
|
o_color->g = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
o_color->g = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &o_color->g);
|
|
}
|
|
}
|
|
switch (entry->mBTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->b = 0;
|
|
break;
|
|
case 1:
|
|
o_color->b = mAnmCRegDataB[entry->mBTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
|
|
&mAnmCRegDataB[entry->mBTable.mOffset]);
|
|
if (col < -0x400) {
|
|
o_color->b = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
o_color->b = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &o_color->b);
|
|
}
|
|
}
|
|
switch (entry->mATable.mMaxFrame) {
|
|
case 0:
|
|
o_color->a = 0;
|
|
break;
|
|
case 1:
|
|
o_color->a = mAnmCRegDataA[entry->mATable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
|
|
&mAnmCRegDataA[entry->mATable.mOffset]);
|
|
if (col < -0x400) {
|
|
o_color->a = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
o_color->a = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &o_color->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];
|
|
f32 col;
|
|
switch (entry->mRTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->r = 0;
|
|
break;
|
|
case 1:
|
|
o_color->r = mAnmKRegDataR[entry->mRTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
|
|
&mAnmKRegDataR[entry->mRTable.mOffset]);
|
|
if (col < 0) {
|
|
o_color->r = 0;
|
|
} else if (col > 0xFF) {
|
|
o_color->r = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->r);
|
|
}
|
|
}
|
|
switch (entry->mGTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->g = 0;
|
|
break;
|
|
case 1:
|
|
o_color->g = mAnmKRegDataG[entry->mGTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
|
|
&mAnmKRegDataG[entry->mGTable.mOffset]);
|
|
if (col < 0) {
|
|
o_color->g = 0;
|
|
} else if (col > 0xFF) {
|
|
o_color->g = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->g);
|
|
}
|
|
}
|
|
switch (entry->mBTable.mMaxFrame) {
|
|
case 0:
|
|
o_color->b = 0;
|
|
break;
|
|
case 1:
|
|
o_color->b = mAnmKRegDataB[entry->mBTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
|
|
&mAnmKRegDataB[entry->mBTable.mOffset]);
|
|
if (col < 0) {
|
|
o_color->b = 0;
|
|
} else if (col > 0xFF) {
|
|
o_color->b = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->b);
|
|
}
|
|
}
|
|
switch (entry->mATable.mMaxFrame) {
|
|
case 0:
|
|
o_color->a = 0;
|
|
break;
|
|
case 1:
|
|
o_color->a = mAnmKRegDataA[entry->mATable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
|
|
&mAnmKRegDataA[entry->mATable.mOffset]);
|
|
if (col < 0) {
|
|
o_color->a = 0;
|
|
} else if (col > 0xFF) {
|
|
o_color->a = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &o_color->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.");
|
|
for (u16 i = 0; i < mCRegUpdateMaterialNum; i++) {
|
|
s32 index = i_materialTable->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));
|
|
if (index != -1) {
|
|
mKRegUpdateMaterialID[i] = index;
|
|
} else {
|
|
mKRegUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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());
|
|
}
|