mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-06-10 04:15:39 -04:00
Pieter-Jan Briers
b289dece80
* fix kankyo UB
* Fix TEV Stage DL writing
BE issue
* BE Fixes in materials/shapes
* Move to Aurora GD impl
* JUTDataFileHeader
* j3d: load vertex and texture not through GD
* Endian swap vertex data (mostly)
* Just exit(0) when closing the game
Fix crashes :godo:
* fix fopAcM_ct_placement and remove memcpy
* J3D: track vertex arrays correctly, swap work
* fix visibility, turn off overridden new/delete when we call into aurora
* event: cut name be
* Default window improvements
Double size, allow OS to decide position
* survive TParse::parseHeader_next
* color swap fix
* swap endian/fixes oob function pointer
* Remove GXGetViewportv stub
Aurora has it now
* Set array pointers via GD again
Relies on https://github.com/encounter/aurora/pull/35
* Let Aurora decide graphics backend
* disable procbar drawing
* Fix TColor endianness conversion issues
Fixes the wrong color for the flashing logo
* cam param swap
* simplify vtx loading, mat/amb color fix
* endian swap stb/fvb data
* aurora stat changes
* fix storage buffer crash
dont unnecessarily reassign vertex buffers in a way that forces aurora to recache things
* set bgobj spec fix
* add camera debug, endian swap more stb data, d_a_bg_obj::spec_data_c swapped
* JKRExpHeap: fix bad allocator slowdown
* solid tex
* texture caching
* log level
* fix window aspect ratio, disable bloom, endian swap camera type data
camera is now actually playing opening cutscene!!!!
* add GXDestroyTexObj to a couple stack init'd GXTexObjs, remove some diag printfs
* endian swap joint weight envelope data
* move to dusk config
* verbose arg errors
* better stub logging (for now)
* less logging, more BE
* more stubbing, move logging stuff around
* move all logging to aurora logging
* fix STUB_LOG, __FUNCTION__ isn't a string literal, wasn't building as it
was.
* update aurora
* fix heap alignment mismatch and always head align for now
* prevent them from fucking up my shit
* forward jut warning to DuskLog
* remove report logging
* maybe and i must emphasize maybe fix JMessage parsing
* this was a dumb idea
* preserve negative alignment for JKRHeap
* use normal free on macos and linux
* ^
* fix JMAHermiteInterpolation c impl
* endian swap J2DScreen mColor (oops)
* swap more J3D anim data, remove weird pointer addr check in J3DMaterial getMaterialAnm
* typo fix
* Fix aligned_alloc() size issues on POSIX
aligned_alloc() requires its input size to be a multiple of alignment. This wasn't being upheld so there were allocation failures in init code that made the game fail to start outside Windows.
Also just cleaned up some of this code a bit and removed fallback cases that *shouldn't* get hit.
* _Exit instead of exit()
Seriously I don't want destructors to run. Let the OS reclaim that shit.
* Reapply "Isolate JKRHeap operator overloads" (#39)
This reverts commit 3623b27f37.
* Fix some oopsies
* Fix hardcoded pointer size in JUTCacheFont::allocArray
* More operator overload fixes
Add void template specialization for jkrDelete
Add new[] placement overload. Apparently.
* Fix delete macros on nullptr
TIL C++ allows that.
* fix delete[]
* fix new(std::nothrow) overload
* fix avoid ub
* swap remaining anim data needed for title logo
* get rid of op 7
* move aurora_end_frame to correct spot
* juttexture destroy tex
* j2d animation be
* shutdown crash
* link warp material fix
* mDoExt_3DlineMat1_c fix
* hacky keyboard controls
* endian swap J2DResReference, add kb_pad to files.cmake
* fix some missing endian swaps in J2D, remove addr alignment check
* Remove heap unsetting in aurora calls
Never worked properly and not the right solution even if it did
* Don't print in DC stubs
They're fine to never implement
* Fix alignment stuff again
* Compile GF from dolphin lib
Doesn't seem to break anything and shuts up some stub warnings
* j3dtexture tlut obj fix
* addTexMtxIndexInDL fix
* don't recreate null tex data every frame
* the actual fix i wanted to push
* its kinda fakematch city over here
* insert hte efb copy
* limited window size / viewport support
* IsDelete FIX
---------
Co-authored-by: madeline <qwertytrogi@gmail.com>
Co-authored-by: Jasper St. Pierre <jstpierre@mecheye.net>
Co-authored-by: Jeffrey Crowell <jeff@crowell.biz>
Co-authored-by: TakaRikka <takarikka@outlook.com>
Co-authored-by: CraftyBoss <talibabdulmaalik@gmail.com>
Co-authored-by: Lurs <2795933+Lurs@users.noreply.github.com>
1459 lines
47 KiB
C++
1459 lines
47 KiB
C++
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
|
|
|
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
|
|
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
|
|
#include "JSystem/J3DGraphBase/J3DStruct.h"
|
|
#include "JSystem/JMath/JMath.h"
|
|
|
|
void J3DFrameCtrl::init(s16 endFrame) {
|
|
mAttribute = EMode_LOOP;
|
|
mState = 0;
|
|
mStart = 0;
|
|
mEnd = endFrame;
|
|
mLoop = 0;
|
|
mRate = 1.0f;
|
|
mFrame = 0.0f;
|
|
}
|
|
|
|
int J3DFrameCtrl::checkPass(f32 passFrame) {
|
|
f32 next_frame = mFrame + mRate;
|
|
|
|
switch (mAttribute) {
|
|
case 0:
|
|
case 1:
|
|
if (next_frame < mStart) {
|
|
next_frame = mStart;
|
|
}
|
|
|
|
if (next_frame >= mEnd) {
|
|
next_frame = mEnd - 0.001f;
|
|
}
|
|
|
|
if (mFrame <= next_frame) {
|
|
if (mFrame <= passFrame && passFrame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (next_frame <= passFrame && passFrame < mFrame) {
|
|
return true;
|
|
}
|
|
return false;
|
|
case 2:
|
|
if (mFrame < mStart) {
|
|
while (next_frame < mStart) {
|
|
if (mLoop - mStart <= 0.0f) {
|
|
break;
|
|
}
|
|
next_frame += mLoop - mStart;
|
|
}
|
|
|
|
if (next_frame <= passFrame && passFrame < mLoop) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (mEnd <= mFrame) {
|
|
while (next_frame >= mEnd) {
|
|
if (mEnd - mLoop <= 0.0f) {
|
|
break;
|
|
}
|
|
next_frame -= mEnd - mLoop;
|
|
}
|
|
|
|
if (mLoop <= passFrame && passFrame < 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 <= passFrame && passFrame < mFrame) || (next_frame <= passFrame && passFrame < 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 ((mFrame <= passFrame && passFrame < mEnd) || (mLoop <= passFrame && passFrame < next_frame)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (mFrame <= next_frame) {
|
|
if (mFrame <= passFrame && passFrame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else if (next_frame <= passFrame && passFrame < mFrame) {
|
|
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 (mFrame <= next_frame) {
|
|
if (mFrame <= passFrame && passFrame < next_frame) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (next_frame <= passFrame && passFrame < mFrame) {
|
|
return true;
|
|
}
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
void J3DFrameCtrl::update() {
|
|
mState = 0;
|
|
mFrame += mRate;
|
|
|
|
switch (mAttribute) {
|
|
case EMode_NONE:
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= (u8)1;
|
|
}
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mEnd - 0.001f;
|
|
mRate = 0.0f;
|
|
mState |= (u8)1;
|
|
}
|
|
break;
|
|
case EMode_RESET:
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= (u8)1;
|
|
}
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mStart;
|
|
mRate = 0.0f;
|
|
mState |= (u8)1;
|
|
}
|
|
break;
|
|
case EMode_LOOP:
|
|
while (mFrame < mStart) {
|
|
mState |= (u8)2;
|
|
if (mLoop - mStart <= 0.0f) {
|
|
break;
|
|
}
|
|
mFrame += mLoop - mStart;
|
|
}
|
|
while (mFrame >= mEnd) {
|
|
mState |= (u8)2;
|
|
if (mEnd - mLoop <= 0.0f) {
|
|
break;
|
|
}
|
|
mFrame -= mEnd - mLoop;
|
|
}
|
|
break;
|
|
case EMode_REVERSE:
|
|
if (mFrame >= mEnd) {
|
|
mFrame = mEnd - (mFrame - mEnd);
|
|
mRate = -mRate;
|
|
}
|
|
if (mFrame < mStart) {
|
|
mFrame = mStart - (mFrame - mStart);
|
|
mRate = 0.0f;
|
|
mState |= (u8)1;
|
|
}
|
|
break;
|
|
case EMode_LOOP_REVERSE:
|
|
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 |= (u8)2;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
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;
|
|
field_0x1e = 0;
|
|
}
|
|
|
|
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) {
|
|
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);
|
|
|
|
frame_max = entryX->mScaleMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryX->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryX->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mScaleMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mScaleMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
|
|
}
|
|
}
|
|
}
|
|
|
|
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) {
|
|
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;
|
|
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 {
|
|
pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryX->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryX->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mScaleMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryY->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mScaleMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mRotationMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
|
|
}
|
|
|
|
frame_max = entryZ->mTranslateMaxFrame;
|
|
if (frame >= frame_max) {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
|
|
}
|
|
} else {
|
|
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 {
|
|
pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryX->mScaleOffset + next_frame]
|
|
- mScaleData[entryX->mScaleOffset + frame]);
|
|
}
|
|
|
|
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 + next_frame];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
pTransform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
|
|
frame_max = entryX->mTranslateMaxFrame;
|
|
if (next_frame >= frame_max) {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryX->mTranslateOffset + next_frame]
|
|
- mTransData[entryX->mTranslateOffset + frame]);
|
|
}
|
|
|
|
frame_max = entryY->mScaleMaxFrame;
|
|
if (next_frame >= frame_max) {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryY->mScaleOffset + next_frame]
|
|
- mScaleData[entryY->mScaleOffset + frame]);
|
|
}
|
|
|
|
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 + next_frame];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
pTransform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
|
|
frame_max = entryY->mTranslateMaxFrame;
|
|
if (next_frame >= frame_max) {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryY->mTranslateOffset + next_frame]
|
|
- mTransData[entryY->mTranslateOffset + frame]);
|
|
}
|
|
|
|
frame_max = entryZ->mScaleMaxFrame;
|
|
if (next_frame >= frame_max) {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
|
|
+ rate * (mScaleData[entryZ->mScaleOffset + next_frame]
|
|
- mScaleData[entryZ->mScaleOffset + frame]);
|
|
}
|
|
|
|
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 + next_frame];
|
|
int delta = rot2 - rot1;
|
|
if (delta > 0x8000) {
|
|
rot1 += 0x10000;
|
|
delta -= 0x10000;
|
|
} else if (-delta > 0x8000) {
|
|
delta += 0x10000;
|
|
}
|
|
pTransform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
|
|
}
|
|
|
|
frame_max = entryZ->mTranslateMaxFrame;
|
|
if (next_frame >= frame_max) {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
|
|
} else {
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
|
|
+ rate * (mTransData[entryZ->mTranslateOffset + next_frame]
|
|
- 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) {
|
|
#ifdef __MWERKS__
|
|
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;
|
|
#else
|
|
f32 time1 = (f32)*pp2;
|
|
f32 value1 = (f32)*pp3;
|
|
f32 tangent1 = (f32)*pp4;
|
|
f32 time2 = (f32)*pp5;
|
|
f32 value2 = (f32)*pp6;
|
|
f32 tangent2 = (f32)*pp7;
|
|
|
|
f32 duration = time2 - time1;
|
|
f32 t = (pp1 - time1) / duration;
|
|
f32 t2 = t * t;
|
|
|
|
f32 dv = value2 - value1;
|
|
f32 ff4 = dv - duration * tangent1;
|
|
|
|
f32 ff0 = tangent2 * duration + value1;
|
|
ff0 = ff0 - value2;
|
|
ff0 = ff0 - ff4;
|
|
ff0 = t2 * ff0;
|
|
|
|
f32 fout = duration * tangent1 + ff0;
|
|
fout = fout * t + value1;
|
|
fout = ff4 * t2 + fout;
|
|
fout = fout - ff0;
|
|
|
|
return fout;
|
|
#endif
|
|
}
|
|
|
|
inline f32 J3DHermiteInterpolation(f32 p1, BE(f32) const* p2, BE(f32) const* p3, BE(f32) const* p4,
|
|
BE(f32) const* p5, BE(f32) const* p6, BE(f32) const* p7) {
|
|
return JMAHermiteInterpolation(p1, *p2, *p3, *p4, *p5, *p6, *p7);
|
|
}
|
|
|
|
inline f32 J3DHermiteInterpolation(f32 pp1, BE(s16) const* pp2,
|
|
BE(s16) const* pp3, BE(s16) const* pp4,
|
|
BE(s16) const* pp5, BE(s16) const* pp6,
|
|
BE(s16) const* pp7) {
|
|
return JMAHermiteInterpolation(pp1, *pp2, *pp3, *pp4, *pp5, *pp6, *pp7);
|
|
}
|
|
|
|
template<typename T>
|
|
f32 J3DGetKeyFrameInterpolation(f32 frame, J3DAnmKeyTableBase* pKeyTable, T* pData) {
|
|
J3D_ASSERT_NULLPTR(740, pData != NULL);
|
|
|
|
if (frame < pData[0]) {
|
|
return pData[1];
|
|
}
|
|
|
|
if (pKeyTable->mType == 0) {
|
|
if (pData[(pKeyTable->mMaxFrame - 1) * 3] <= frame) {
|
|
return pData[(pKeyTable->mMaxFrame - 1) * 3 + 1];
|
|
}
|
|
|
|
u32 uVar7 = pKeyTable->mMaxFrame;
|
|
while (uVar7 > 1) {
|
|
u32 uVar2 = uVar7 >> 1;
|
|
u32 tmp = uVar2 * 3;
|
|
if (frame >= pData[tmp]) {
|
|
pData += tmp;
|
|
uVar7 = uVar7 - uVar2;
|
|
} else {
|
|
uVar7 = uVar2;
|
|
}
|
|
}
|
|
|
|
f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[2], &pData[3], &pData[4], &pData[5]);
|
|
return interpolated;
|
|
} else {
|
|
if (pData[(pKeyTable->mMaxFrame - 1) * 4] <= frame) {
|
|
return pData[(pKeyTable->mMaxFrame - 1) * 4 + 1];
|
|
}
|
|
|
|
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 {
|
|
var_r27 = var_r25;
|
|
}
|
|
}
|
|
|
|
f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[3], &pData[4], &pData[5], &pData[6]);
|
|
return interpolated;
|
|
}
|
|
}
|
|
|
|
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:
|
|
pTransform->mScale.x = 1.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mScale.x = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
|
|
&mScaleData[entryX->mScaleInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryY->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mScale.y = 1.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mScale.y = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
|
|
&mScaleData[entryY->mScaleInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryZ->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mScale.z = 1.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mScale.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mScaleInfo,
|
|
&mScaleData[entryZ->mScaleInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryX->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mRotation.x = 0;
|
|
break;
|
|
case 1:
|
|
pTransform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
pTransform->mRotation.x = (int)J3DGetKeyFrameInterpolation(frame, &entryX->mRotationInfo,
|
|
&mRotData[entryX->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
|
|
switch (entryY->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mRotation.y = 0;
|
|
break;
|
|
case 1:
|
|
pTransform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
pTransform->mRotation.y = (int)J3DGetKeyFrameInterpolation(frame, &entryY->mRotationInfo,
|
|
&mRotData[entryY->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
|
|
switch (entryZ->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mRotation.z = 0;
|
|
break;
|
|
case 1:
|
|
pTransform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
pTransform->mRotation.z = (int)J3DGetKeyFrameInterpolation(frame, &entryZ->mRotationInfo,
|
|
&mRotData[entryZ->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
|
|
switch (entryX->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mTranslate.x = 0.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mTranslate.x = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
|
|
&mTransData[entryX->mTranslateInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryY->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mTranslate.y = 0.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mTranslate.y = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
|
|
&mTransData[entryY->mTranslateInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryZ->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
pTransform->mTranslate.z = 0.0f;
|
|
break;
|
|
case 1:
|
|
pTransform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTransform->mTranslate.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mTranslateInfo,
|
|
&mTransData[entryZ->mTranslateInfo.mOffset]);
|
|
}
|
|
}
|
|
|
|
J3DAnmTextureSRTKey::J3DAnmTextureSRTKey() {
|
|
mDecShift = 0;
|
|
mTrackNum = mScaleNum = mRotNum = mTransNum = 0;
|
|
mAnmTable = NULL;
|
|
mScaleData = mTransData = NULL;
|
|
mRotData = NULL;
|
|
field_0x4a = field_0x44 = field_0x46 = field_0x48 = 0;
|
|
field_0x58 = NULL;
|
|
field_0x4c = field_0x54 = NULL;
|
|
field_0x50 = NULL;
|
|
mTexMtxCalcType = 0;
|
|
}
|
|
|
|
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:
|
|
pTexSRTInfo->mScaleX = 1.0f;
|
|
break;
|
|
case 1:
|
|
pTexSRTInfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTexSRTInfo->mScaleX = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
|
|
&mScaleData[entryX->mScaleInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryY->mScaleInfo.mMaxFrame) {
|
|
case 0:
|
|
pTexSRTInfo->mScaleY = 1.0f;
|
|
break;
|
|
case 1:
|
|
pTexSRTInfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTexSRTInfo->mScaleY = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
|
|
&mScaleData[entryY->mScaleInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryRot->mRotationInfo.mMaxFrame) {
|
|
case 0:
|
|
pTexSRTInfo->mRotation = 0;
|
|
break;
|
|
case 1:
|
|
pTexSRTInfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
|
|
break;
|
|
default:
|
|
pTexSRTInfo->mRotation = (int)J3DGetKeyFrameInterpolation(frame, &entryRot->mRotationInfo,
|
|
&mRotData[entryRot->mRotationInfo.mOffset]) << mDecShift;
|
|
}
|
|
|
|
switch (entryX->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
pTexSRTInfo->mTranslationX = 0.0f;
|
|
break;
|
|
case 1:
|
|
pTexSRTInfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTexSRTInfo->mTranslationX = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
|
|
&mTransData[entryX->mTranslateInfo.mOffset]);
|
|
}
|
|
|
|
switch (entryY->mTranslateInfo.mMaxFrame) {
|
|
case 0:
|
|
pTexSRTInfo->mTranslationY = 0.0f;
|
|
break;
|
|
case 1:
|
|
pTexSRTInfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
|
|
break;
|
|
default:
|
|
pTexSRTInfo->mTranslationY = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
|
|
&mTransData[entryY->mTranslateInfo.mOffset]);
|
|
}
|
|
}
|
|
|
|
f32 J3DAnmClusterFull::getWeight(u16 index) const {
|
|
int maxFrame = mAnmTable[index].mMaxFrame;
|
|
int frame = (int)(mFrame + 0.5f);
|
|
|
|
if (mFrame < 0.0f) {
|
|
return mWeight[mAnmTable[index].mOffset];
|
|
} else if (frame >= (u16)maxFrame) {
|
|
return mWeight[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
|
|
} else {
|
|
return mWeight[mAnmTable[index].mOffset + frame];
|
|
}
|
|
}
|
|
|
|
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[index].mWeightTable.mOffset];
|
|
default:
|
|
return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[index].mWeightTable,
|
|
&mWeight[mAnmTable[index].mWeightTable.mOffset]);
|
|
}
|
|
}
|
|
|
|
J3DAnmVtxColor::J3DAnmVtxColor() {
|
|
for (int i = 0; i < 2; i++) {
|
|
mAnmTableNum[i] = 0;
|
|
}
|
|
for (int i = 0; i < 2; i++) {
|
|
mAnmVtxColorIndexData[i] = NULL;
|
|
}
|
|
}
|
|
|
|
J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
|
|
for (int i = 0; i < 2; i++) {
|
|
mpTable[i] = NULL;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
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);
|
|
u16 maxFrame;
|
|
|
|
maxFrame = entry->mRMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->r = mColorR[entry->mROffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mGMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->g = mColorG[entry->mGOffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mBMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->b = mColorB[entry->mBOffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mAMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->a = mColorA[entry->mAOffset + frame];
|
|
}
|
|
}
|
|
}
|
|
|
|
J3DAnmVtxColorKey::J3DAnmVtxColorKey() {
|
|
for (int i = 0; i < 2; i++) {
|
|
mpTable[i] = 0;
|
|
}
|
|
}
|
|
|
|
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:
|
|
pColor->r = 0;
|
|
break;
|
|
case 1:
|
|
pColor->r = mColorR[entry->mRInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
|
|
&mColorR[entry->mRInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
pColor->r = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &pColor->r);
|
|
} else {
|
|
pColor->r = 255;
|
|
}
|
|
}
|
|
|
|
switch (entry->mGInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->g = 0;
|
|
break;
|
|
case 1:
|
|
pColor->g = mColorG[entry->mGInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
|
|
&mColorG[entry->mGInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
pColor->g = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &pColor->g);
|
|
} else {
|
|
pColor->g = 255;
|
|
}
|
|
}
|
|
|
|
switch (entry->mBInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->b = 0;
|
|
break;
|
|
case 1:
|
|
pColor->b = mColorB[entry->mBInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
|
|
&mColorB[entry->mBInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
pColor->b = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &pColor->b);
|
|
} else {
|
|
pColor->b = 255;
|
|
}
|
|
}
|
|
|
|
switch (entry->mAInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->a = 0;
|
|
break;
|
|
case 1:
|
|
pColor->a = mColorA[entry->mAInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
|
|
&mColorA[entry->mAInfo.mOffset]);
|
|
if (col <= 0.0f) {
|
|
pColor->a = 0;
|
|
} else if (col <= 255.0f) {
|
|
OSf32tou8(&col, &pColor->a);
|
|
} else {
|
|
pColor->a = 255;
|
|
}
|
|
}
|
|
}
|
|
|
|
J3DAnmColor::J3DAnmColor() : field_0xc(0), field_0xe(0), field_0x10(0),
|
|
field_0x12(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
|
|
|
|
|
|
void J3DAnmColor::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
|
|
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
|
|
int index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mUpdateMaterialID[i] = index;
|
|
} else {
|
|
mUpdateMaterialID[i] = 0xffff;
|
|
}
|
|
}
|
|
}
|
|
|
|
J3DAnmColorFull::J3DAnmColorFull() {
|
|
mColorR = NULL;
|
|
mColorG = NULL;
|
|
mColorB = NULL;
|
|
mColorA = NULL;
|
|
mAnmTable = NULL;
|
|
}
|
|
|
|
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) {
|
|
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);
|
|
u16 maxFrame;
|
|
|
|
maxFrame = entry->mRMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->r = mColorR[entry->mROffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mGMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->g = mColorG[entry->mGOffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mBMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->b = mColorB[entry->mBOffset + frame];
|
|
}
|
|
|
|
maxFrame = entry->mAMaxFrame;
|
|
if (frame >= maxFrame) {
|
|
pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
|
|
} else {
|
|
pColor->a = mColorA[entry->mAOffset + frame];
|
|
}
|
|
}
|
|
}
|
|
|
|
J3DAnmColorKey::J3DAnmColorKey() {
|
|
mColorR = NULL;
|
|
mColorG = NULL;
|
|
mColorB = NULL;
|
|
mColorA = NULL;
|
|
mAnmTable = NULL;
|
|
}
|
|
|
|
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:
|
|
pColor->r = 0;
|
|
break;
|
|
case 1:
|
|
pColor->r = mColorR[entry->mRInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
|
|
&mColorR[entry->mRInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
pColor->r = 0;
|
|
} else if (col > 255.0f) {
|
|
pColor->r = 255;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->r);
|
|
}
|
|
}
|
|
|
|
switch (entry->mGInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->g = 0;
|
|
break;
|
|
case 1:
|
|
pColor->g = mColorG[entry->mGInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
|
|
&mColorG[entry->mGInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
pColor->g = 0;
|
|
} else if (col > 255.0f) {
|
|
pColor->g = 255;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->g);
|
|
}
|
|
}
|
|
|
|
switch (entry->mBInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->b = 0;
|
|
break;
|
|
case 1:
|
|
pColor->b = mColorB[entry->mBInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
|
|
&mColorB[entry->mBInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
pColor->b = 0;
|
|
} else if (col > 255.0f) {
|
|
pColor->b = 255;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->b);
|
|
}
|
|
}
|
|
|
|
switch (entry->mAInfo.mMaxFrame) {
|
|
case 0:
|
|
pColor->a = 0;
|
|
break;
|
|
case 1:
|
|
pColor->a = mColorA[entry->mAInfo.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
|
|
&mColorA[entry->mAInfo.mOffset]);
|
|
if (col < 0.0f) {
|
|
pColor->a = 0;
|
|
} else if (col > 255.0f) {
|
|
pColor->a = 255;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->a);
|
|
}
|
|
}
|
|
}
|
|
|
|
J3DAnmTevRegKey::J3DAnmTevRegKey() {
|
|
mCRegUpdateMaterialNum = mKRegUpdateMaterialNum = 0;
|
|
|
|
mCRegDataCountR =
|
|
mCRegDataCountG =
|
|
mCRegDataCountB =
|
|
mCRegDataCountA = 0;
|
|
|
|
mKRegDataCountR =
|
|
mKRegDataCountG =
|
|
mKRegDataCountB =
|
|
mKRegDataCountA = 0;
|
|
|
|
mCRegUpdateMaterialID = mKRegUpdateMaterialID = NULL;
|
|
|
|
mAnmCRegDataR =
|
|
mAnmCRegDataG =
|
|
mAnmCRegDataB =
|
|
mAnmCRegDataA = NULL;
|
|
|
|
mAnmKRegDataR =
|
|
mAnmKRegDataG =
|
|
mAnmKRegDataB =
|
|
mAnmKRegDataA = NULL;
|
|
}
|
|
|
|
|
|
J3DAnmTexPattern::J3DAnmTexPattern() : mTextureIndex(NULL), mAnmTable(NULL),
|
|
field_0x14(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
|
|
|
|
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) {
|
|
*pTexNo = mTextureIndex[mAnmTable[index].mOffset];
|
|
} else if (mFrame >= (u16)maxFrame) {
|
|
*pTexNo = mTextureIndex[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
|
|
} else {
|
|
*pTexNo = mTextureIndex[mAnmTable[index].mOffset + (int)mFrame];
|
|
}
|
|
}
|
|
|
|
void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
|
|
J3D_ASSERT_NULLPTR(1790, pMatTable != NULL);
|
|
|
|
for (u16 i = 0; i < mUpdateMaterialNum; i++) {
|
|
s32 index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mUpdateMaterialID[i] = index;
|
|
} else {
|
|
mUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void J3DAnmTexPattern::searchUpdateMaterialID(J3DModelData* pModelData) {
|
|
J3D_ASSERT_NULLPTR(1813, pModelData != NULL);
|
|
searchUpdateMaterialID(&pModelData->getMaterialTable());
|
|
}
|
|
|
|
void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
|
|
J3D_ASSERT_NULLPTR(1832, pMatTable != NULL);
|
|
|
|
for (u16 i = 0; i < getUpdateMaterialNum(); 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 = pMatTable->getMaterialName()->getIndex(mPostUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mPostUpdateMaterialID[i] = index;
|
|
} else {
|
|
mPostUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DModelData* pModelData) {
|
|
J3D_ASSERT_NULLPTR(1871, pModelData != NULL);
|
|
searchUpdateMaterialID(&pModelData->getMaterialTable());
|
|
}
|
|
|
|
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:
|
|
pColor->r = 0;
|
|
break;
|
|
case 1:
|
|
pColor->r = mAnmCRegDataR[entry->mRTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
|
|
&mAnmCRegDataR[entry->mRTable.mOffset]);
|
|
if (col < -0x400) {
|
|
pColor->r = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
pColor->r = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &pColor->r);
|
|
}
|
|
}
|
|
|
|
switch (entry->mGTable.mMaxFrame) {
|
|
case 0:
|
|
pColor->g = 0;
|
|
break;
|
|
case 1:
|
|
pColor->g = mAnmCRegDataG[entry->mGTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
|
|
&mAnmCRegDataG[entry->mGTable.mOffset]);
|
|
if (col < -0x400) {
|
|
pColor->g = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
pColor->g = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &pColor->g);
|
|
}
|
|
}
|
|
|
|
switch (entry->mBTable.mMaxFrame) {
|
|
case 0:
|
|
pColor->b = 0;
|
|
break;
|
|
case 1:
|
|
pColor->b = mAnmCRegDataB[entry->mBTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
|
|
&mAnmCRegDataB[entry->mBTable.mOffset]);
|
|
if (col < -0x400) {
|
|
pColor->b = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
pColor->b = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &pColor->b);
|
|
}
|
|
}
|
|
|
|
switch (entry->mATable.mMaxFrame) {
|
|
case 0:
|
|
pColor->a = 0;
|
|
break;
|
|
case 1:
|
|
pColor->a = mAnmCRegDataA[entry->mATable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
|
|
&mAnmCRegDataA[entry->mATable.mOffset]);
|
|
if (col < -0x400) {
|
|
pColor->a = -0x400;
|
|
} else if (col > 0x3FF) {
|
|
pColor->a = 0x3FF;
|
|
} else {
|
|
OSf32tos16(&col, &pColor->a);
|
|
}
|
|
}
|
|
}
|
|
|
|
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:
|
|
pColor->r = 0;
|
|
break;
|
|
case 1:
|
|
pColor->r = mAnmKRegDataR[entry->mRTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
|
|
&mAnmKRegDataR[entry->mRTable.mOffset]);
|
|
if (col < 0) {
|
|
pColor->r = 0;
|
|
} else if (col > 0xFF) {
|
|
pColor->r = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->r);
|
|
}
|
|
}
|
|
|
|
switch (entry->mGTable.mMaxFrame) {
|
|
case 0:
|
|
pColor->g = 0;
|
|
break;
|
|
case 1:
|
|
pColor->g = mAnmKRegDataG[entry->mGTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
|
|
&mAnmKRegDataG[entry->mGTable.mOffset]);
|
|
if (col < 0) {
|
|
pColor->g = 0;
|
|
} else if (col > 0xFF) {
|
|
pColor->g = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->g);
|
|
}
|
|
}
|
|
|
|
switch (entry->mBTable.mMaxFrame) {
|
|
case 0:
|
|
pColor->b = 0;
|
|
break;
|
|
case 1:
|
|
pColor->b = mAnmKRegDataB[entry->mBTable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
|
|
&mAnmKRegDataB[entry->mBTable.mOffset]);
|
|
if (col < 0) {
|
|
pColor->b = 0;
|
|
} else if (col > 0xFF) {
|
|
pColor->b = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->b);
|
|
}
|
|
}
|
|
|
|
switch (entry->mATable.mMaxFrame) {
|
|
case 0:
|
|
pColor->a = 0;
|
|
break;
|
|
case 1:
|
|
pColor->a = mAnmKRegDataA[entry->mATable.mOffset];
|
|
break;
|
|
default:
|
|
col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
|
|
&mAnmKRegDataA[entry->mATable.mOffset]);
|
|
if (col < 0) {
|
|
pColor->a = 0;
|
|
} else if (col > 0xFF) {
|
|
pColor->a = 0xFF;
|
|
} else {
|
|
OSf32tou8(&col, &pColor->a);
|
|
}
|
|
}
|
|
}
|
|
|
|
void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
|
|
J3D_ASSERT_NULLPTR(2083, pMatTable != NULL);
|
|
|
|
for (u16 i = 0; i < mCRegUpdateMaterialNum; 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 = pMatTable->getMaterialName()->getIndex(mKRegUpdateMaterialName.getName(i));
|
|
if (index != -1) {
|
|
mKRegUpdateMaterialID[i] = index;
|
|
} else {
|
|
mKRegUpdateMaterialID[i] = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
void J3DAnmTevRegKey::searchUpdateMaterialID(J3DModelData* pModelData) {
|
|
J3D_ASSERT_NULLPTR(2119, pModelData != NULL);
|
|
searchUpdateMaterialID(&pModelData->getMaterialTable());
|
|
}
|