mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-06-23 23:35:16 -04:00
Reorganize library code into libs/ (#3119)
* Reorganize files into libs/{dolphin,JSystem,PowerPC_EABI_Support,revolution,TRK_MINNOW_DOLPHIN}
* Update configure.py and project.py for new libs structure
* Refactor `#include <dolphin/x.h>` -> `<x.h>`
* Remove `__REVOLUTION_SDK__` forwards from dolphin
* Fix dolphin/ references in revolution
* Wrap `#include <dolphin.h>` in `!__REVOLUTION_SDK__`
* Always build TRK against dolphin headers
* Resolve revolution SDK header resolution issues
This commit is contained in:
Luke Street
@@ -0,0 +1,982 @@
|
||||
#ifndef J3DANIMATION_H
|
||||
#define J3DANIMATION_H
|
||||
|
||||
#include "JSystem/J3DAssert.h"
|
||||
#include "JSystem/JUtility/JUTNameTab.h"
|
||||
#include <mtx.h>
|
||||
#include "global.h"
|
||||
|
||||
struct J3DTransformInfo;
|
||||
|
||||
struct JUTDataBlockHeader {
|
||||
/* 0x0 */ u32 mType;
|
||||
/* 0x4 */ u32 mSize;
|
||||
|
||||
const JUTDataBlockHeader* getNext() const { // fake inline
|
||||
return reinterpret_cast<const JUTDataBlockHeader*>(reinterpret_cast<const u8*>(this) +
|
||||
mSize);
|
||||
}
|
||||
};
|
||||
|
||||
struct JUTDataFileHeader { // actual struct name unknown
|
||||
/* 0x00 */ u32 mMagic;
|
||||
/* 0x04 */ u32 mType;
|
||||
/* 0x08 */ u32 mFileSize;
|
||||
/* 0x0C */ u32 mBlockNum;
|
||||
/* 0x10 */ u8 _10[0x1C - 0x10];
|
||||
/* 0x1C */ u32 mSeAnmOffset; // Only exists for some BCKs
|
||||
/* 0x20 */ JUTDataBlockHeader mFirstBlock;
|
||||
};
|
||||
|
||||
// unknown name. refers to ANK1 chunk of BCK files
|
||||
struct J3DAnmTransform_ANK1 {
|
||||
/* 0x00 */ u32 magic;
|
||||
/* 0x04 */ u32 size;
|
||||
/* 0x08 */ u8 attribute;
|
||||
/* 0x09 */ u8 rotation_frac;
|
||||
/* 0x0A */ s16 duration;
|
||||
/* 0x0C */ s16 keyframe_num;
|
||||
/* 0x0E */ s16 scale_entries;
|
||||
/* 0x10 */ s16 rotation_entries;
|
||||
/* 0x12 */ s16 translation_entries;
|
||||
/* 0x14 */ u32 anm_data_offset;
|
||||
/* 0x18 */ u32 scale_data_offset;
|
||||
/* 0x1C */ u32 rotation_data_offset;
|
||||
/* 0x20 */ u32 translation_data_offset;
|
||||
};
|
||||
|
||||
typedef struct _GXColor GXColor;
|
||||
typedef struct _GXColorS10 GXColorS10;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmKeyTableBase {
|
||||
/* 0x00 */ u16 mMaxFrame;
|
||||
/* 0x02 */ u16 mOffset;
|
||||
/* 0x04 */ u16 mType;
|
||||
}; // Size = 0x6
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmColorKeyTable {
|
||||
J3DAnmKeyTableBase mRInfo;
|
||||
J3DAnmKeyTableBase mGInfo;
|
||||
J3DAnmKeyTableBase mBInfo;
|
||||
J3DAnmKeyTableBase mAInfo;
|
||||
}; // Size = 0x18
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmVtxColorIndexData {
|
||||
/* 0x00 */ u16 mNum;
|
||||
/* 0x04 */ void* mpData;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmColorFullTable {
|
||||
/* 0x00 */ u16 mRMaxFrame;
|
||||
/* 0x02 */ u16 mROffset;
|
||||
/* 0x04 */ u16 mGMaxFrame;
|
||||
/* 0x06 */ u16 mGOffset;
|
||||
/* 0x08 */ u16 mBMaxFrame;
|
||||
/* 0x0A */ u16 mBOffset;
|
||||
/* 0x0C */ u16 mAMaxFrame;
|
||||
/* 0x0E */ u16 mAOffset;
|
||||
}; // Size = 0x10
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmVisibilityFullTable {
|
||||
u16 _0;
|
||||
u16 _2;
|
||||
}; // Size = 0x4
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTransformKeyTable {
|
||||
J3DAnmKeyTableBase mScaleInfo;
|
||||
J3DAnmKeyTableBase mRotationInfo;
|
||||
J3DAnmKeyTableBase mTranslateInfo;
|
||||
}; // Size = 0x12
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTransformFullTable {
|
||||
/* 0x00 */ u16 mScaleMaxFrame;
|
||||
/* 0x02 */ u16 mScaleOffset;
|
||||
/* 0x04 */ u16 mRotationMaxFrame;
|
||||
/* 0x06 */ u16 mRotationOffset;
|
||||
/* 0x08 */ u16 mTranslateMaxFrame;
|
||||
/* 0x0A */ u16 mTranslateOffset;
|
||||
}; // Size = 0xC
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTexPatternFullTable {
|
||||
/* 0x00 */ u16 mMaxFrame;
|
||||
/* 0x02 */ u16 mOffset;
|
||||
/* 0x04 */ u8 mTexNo;
|
||||
/* 0x06 */ u16 _6;
|
||||
}; // Size = 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmCRegKeyTable {
|
||||
/* 0x00 */ J3DAnmKeyTableBase mRTable;
|
||||
/* 0x06 */ J3DAnmKeyTableBase mGTable;
|
||||
/* 0x0C */ J3DAnmKeyTableBase mBTable;
|
||||
/* 0x12 */ J3DAnmKeyTableBase mATable;
|
||||
/* 0x18 */ u8 mColorId;
|
||||
u8 padding[3];
|
||||
}; // Size = 0x1C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmKRegKeyTable {
|
||||
/* 0x00 */ J3DAnmKeyTableBase mRTable;
|
||||
/* 0x06 */ J3DAnmKeyTableBase mGTable;
|
||||
/* 0x0C */ J3DAnmKeyTableBase mBTable;
|
||||
/* 0x12 */ J3DAnmKeyTableBase mATable;
|
||||
/* 0x18 */ u8 mColorId;
|
||||
u8 padding[3];
|
||||
}; // Size = 0x1C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmDataBlockHeader { // actual name unknown
|
||||
/* 0x0 */ u32 mType;
|
||||
/* 0x4 */ u32 mNextOffset;
|
||||
}; // Size = 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmDataHeader { // actual name unknown
|
||||
/* 0x00 */ u32 mMagic;
|
||||
/* 0x04 */ u32 mType;
|
||||
/* 0x08 */ u8 _8[4];
|
||||
/* 0x0C */ u32 mCount;
|
||||
/* 0x10 */ u8 _10[0x20 - 0x10];
|
||||
/* 0x20 */ J3DAnmDataBlockHeader mFirst;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmVtxColorFullData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9; // padding?
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 mAnmTableNum[2];
|
||||
/* 0x10 */ u8 field_0x10[0x18 - 0x10];
|
||||
/* 0x18 */ void* mTableOffsets[2];
|
||||
/* 0x20 */ void* mVtxColorIndexDataOffsets[2];
|
||||
/* 0x28 */ void* mVtxColorIndexPointerOffsets[2];
|
||||
/* 0x30 */ void* mRValuesOffset;
|
||||
/* 0x34 */ void* mGValuesOffset;
|
||||
/* 0x38 */ void* mBValuesOffset;
|
||||
/* 0x3C */ void* mAValuesOffset;
|
||||
}; // Size = 0x40
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmVtxColorFullData) == 0x40);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmVisibilityFullData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9; // padding?
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x0E */ u16 field_0xe;
|
||||
/* 0x10 */ void* mTableOffset;
|
||||
/* 0x14 */ void* mValuesOffset;
|
||||
}; // Size = 0x18
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmVisibilityFullData) == 0x18);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTransformFullData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x0E */ u8 field_0xe[0x14 - 0xe];
|
||||
/* 0x14 */ void* mTableOffset;
|
||||
/* 0x18 */ void* mScaleValOffset;
|
||||
/* 0x1C */ void* mRotValOffset;
|
||||
/* 0x20 */ void* mTransValOffset;
|
||||
}; // Size = 0x24
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmTransformFullData) == 0x24);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmColorKeyData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9[3];
|
||||
/* 0x0C */ s16 mFrameMax;
|
||||
/* 0x0E */ u16 mUpdateMaterialNum;
|
||||
/* 0x10 */ u16 field_0x10;
|
||||
/* 0x12 */ u16 field_0x12;
|
||||
/* 0x14 */ u16 field_0x14;
|
||||
/* 0x16 */ u16 field_0x16;
|
||||
/* 0x18 */ void* mTableOffset;
|
||||
/* 0x1C */ void* mUpdateMaterialIDOffset;
|
||||
/* 0x20 */ void* mNameTabOffset;
|
||||
/* 0x24 */ void* mRValOffset;
|
||||
/* 0x28 */ void* mGValOffset;
|
||||
/* 0x2C */ void* mBValOffset;
|
||||
/* 0x30 */ void* mAValOffset;
|
||||
}; // Size = 0x34
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmColorKeyData) == 0x34);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTextureSRTKeyData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9;
|
||||
/* 0x0A */ s16 field_0xa;
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x0E */ u16 field_0xe;
|
||||
/* 0x10 */ u16 field_0x10;
|
||||
/* 0x12 */ u16 field_0x12;
|
||||
/* 0x14 */ void* mTableOffset;
|
||||
/* 0x18 */ void* mUpdateMatIDOffset;
|
||||
/* 0x1C */ void* mNameTab1Offset;
|
||||
/* 0x20 */ void* mUpdateTexMtxIDOffset;
|
||||
/* 0x24 */ void* unkOffset;
|
||||
/* 0x28 */ void* mScaleValOffset;
|
||||
/* 0x2C */ void* mRotValOffset;
|
||||
/* 0x30 */ void* mTransValOffset;
|
||||
/* 0x34 */ u16 field_0x34;
|
||||
/* 0x36 */ u16 field_0x36;
|
||||
/* 0x38 */ u16 field_0x38;
|
||||
/* 0x3A */ u16 field_0x3a;
|
||||
/* 0x3C */ void* mInfoTable2Offset;
|
||||
/* 0x40 */ void* field_0x40;
|
||||
/* 0x44 */ void* mNameTab2Offset;
|
||||
/* 0x48 */ void* field_0x48;
|
||||
/* 0x4C */ void* field_0x4c;
|
||||
/* 0x50 */ void* field_0x50;
|
||||
/* 0x54 */ void* field_0x54;
|
||||
/* 0x58 */ void* field_0x58;
|
||||
/* 0x5C */ s32 field_0x5c;
|
||||
}; // Size = 0x60
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmTextureSRTKeyData) == 0x60);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmVtxColorKeyData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 mAnmTableNum[2];
|
||||
/* 0x10 */ u8 field_0x10[0x18 - 0x10];
|
||||
/* 0x18 */ void* mTableOffsets[2];
|
||||
/* 0x20 */ void* mVtxColoIndexDataOffset[2];
|
||||
/* 0x28 */ void* mVtxColoIndexPointerOffset[2];
|
||||
/* 0x30 */ void* mRValOffset;
|
||||
/* 0x34 */ void* mGValOffset;
|
||||
/* 0x38 */ void* mBValOffset;
|
||||
/* 0x3C */ void* mAValOffset;
|
||||
}; // Size = 0x40
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmVtxColorKeyData) == 0x40);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTexPatternFullData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x0E */ u16 field_0xe;
|
||||
/* 0x10 */ void* mTableOffset;
|
||||
/* 0x14 */ void* mValuesOffset;
|
||||
/* 0x18 */ void* mUpdateMaterialIDOffset;
|
||||
/* 0x1C */ void* mNameTabOffset;
|
||||
}; // Size = 0x20
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmTexPatternFullData) == 0x20);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTevRegKeyData {
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9; // maybe padding
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 mCRegUpdateMaterialNum;
|
||||
/* 0x0E */ u16 mKRegUpdateMaterialNum;
|
||||
/* 0x10 */ u16 field_0x10;
|
||||
/* 0x12 */ u16 field_0x12;
|
||||
/* 0x14 */ u16 field_0x14;
|
||||
/* 0x16 */ u16 field_0x16;
|
||||
/* 0x18 */ u16 field_0x18;
|
||||
/* 0x1A */ u16 field_0x1a;
|
||||
/* 0x1C */ u16 field_0x1c;
|
||||
/* 0x1E */ u16 field_0x1e;
|
||||
/* 0x20 */ void* mCRegTableOffset;
|
||||
/* 0x24 */ void* mKRegTableOffset;
|
||||
/* 0x28 */ void* mCRegUpdateMaterialIDOffset;
|
||||
/* 0x2C */ void* mKRegUpdateMaterialIDOffset;
|
||||
/* 0x30 */ void* mCRegNameTabOffset;
|
||||
/* 0x34 */ void* mKRegNameTabOffset;
|
||||
/* 0x38 */ void* mCRValuesOffset;
|
||||
/* 0x3C */ void* mCGValuesOffset;
|
||||
/* 0x40 */ void* mCBValuesOffset;
|
||||
/* 0x44 */ void* mCAValuesOffset;
|
||||
/* 0x48 */ void* mKRValuesOffset;
|
||||
/* 0x4C */ void* mKGValuesOffset;
|
||||
/* 0x50 */ void* mKBValuesOffset;
|
||||
/* 0x54 */ void* mKAValuesOffset;
|
||||
}; // Size = 0x58
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmTevRegKeyData) == 0x58);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmColorFullData { /* PlaceHolder Structure */
|
||||
/* 0x00 */ J3DAnmDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9[3];
|
||||
/* 0x0C */ s16 mFrameMax;
|
||||
/* 0x0E */ u16 mUpdateMaterialNum;
|
||||
/* 0x10 */ u8 field_0x10[0x18 - 0x10];
|
||||
/* 0x18 */ void* mTableOffset;
|
||||
/* 0x1C */ void* mUpdateMaterialIDOffset;
|
||||
/* 0x20 */ void* mNameTabOffset;
|
||||
/* 0x24 */ void* mRValuesOffset;
|
||||
/* 0x28 */ void* mGValuesOffset;
|
||||
/* 0x2C */ void* mBValuesOffset;
|
||||
/* 0x30 */ void* mAValuesOffset;
|
||||
}; // Size = 0x34
|
||||
|
||||
STATIC_ASSERT(sizeof(J3DAnmColorFullData) == 0x34);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmClusterKeyTable {
|
||||
/* 0x00 */ J3DAnmKeyTableBase mWeightTable;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmTransformKeyData {
|
||||
/* 0x00 */ JUTDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x09 */ u8 field_0x9;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x10 */ int field_0x10;
|
||||
/* 0x14 */ void* mTableOffset;
|
||||
/* 0x18 */ void* field_0x18;
|
||||
/* 0x1c */ void* field_0x1c;
|
||||
/* 0x20 */ void* field_0x20;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmClusterKeyData {
|
||||
/* 0x00 */ JUTDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ s32 field_0xc;
|
||||
/* 0x10 */ void* mTableOffset;
|
||||
/* 0x14 */ void* mWeightOffset;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmClusterFullData {
|
||||
/* 0x00 */ JUTDataBlockHeader mHeader;
|
||||
/* 0x08 */ u8 field_0x8;
|
||||
/* 0x0A */ s16 mFrameMax;
|
||||
/* 0x0C */ s32 field_0xc;
|
||||
/* 0x10 */ void* mTableOffset;
|
||||
/* 0x14 */ void* mWeightOffset;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DAnmClusterFullTable {
|
||||
u16 mMaxFrame;
|
||||
u16 mOffset;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmBase {
|
||||
public:
|
||||
J3DAnmBase() {
|
||||
mAttribute = 0;
|
||||
field_0x5 = 0;
|
||||
mFrameMax = 0;
|
||||
mFrame = 0.0f;
|
||||
}
|
||||
|
||||
J3DAnmBase(s16 frameMax) {
|
||||
mAttribute = 0;
|
||||
field_0x5 = 0;
|
||||
mFrameMax = frameMax;
|
||||
mFrame = 0.0f;
|
||||
}
|
||||
|
||||
virtual ~J3DAnmBase() {}
|
||||
virtual s32 getKind() const = 0;
|
||||
|
||||
u8 getAttribute() const { return mAttribute; }
|
||||
s16 getFrameMax() const { return mFrameMax; }
|
||||
f32 getFrame() const { return mFrame; }
|
||||
void setFrame(f32 frame) { mFrame = frame; }
|
||||
|
||||
/* 0x4 */ u8 mAttribute;
|
||||
/* 0x5 */ u8 field_0x5;
|
||||
/* 0x6 */ s16 mFrameMax;
|
||||
/* 0x8 */ f32 mFrame;
|
||||
}; // Size: 0xC
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTransform : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmTransform(s16, f32*, s16*, f32*);
|
||||
|
||||
virtual ~J3DAnmTransform() {}
|
||||
virtual s32 getKind() const { return 0; }
|
||||
virtual void getTransform(u16, J3DTransformInfo*) const = 0;
|
||||
|
||||
/* 0x0C */ f32* mScaleData;
|
||||
/* 0x10 */ s16* mRotData;
|
||||
/* 0x14 */ f32* mTransData;
|
||||
/* 0x18 */ s16 field_0x18;
|
||||
/* 0x1A */ s16 field_0x1a;
|
||||
/* 0x1C */ u16 field_0x1c;
|
||||
/* 0x1E */ u16 field_0x1e;
|
||||
}; // Size: 0x20
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTransformKey : public J3DAnmTransform {
|
||||
public:
|
||||
J3DAnmTransformKey() : J3DAnmTransform(0, NULL, NULL, NULL) {
|
||||
mDecShift = 0;
|
||||
mAnmTable = 0;
|
||||
}
|
||||
|
||||
void calcTransform(f32, u16, J3DTransformInfo*) const;
|
||||
|
||||
virtual ~J3DAnmTransformKey() {}
|
||||
virtual s32 getKind() const { return 8; }
|
||||
virtual void getTransform(u16 jointNo, J3DTransformInfo* pTransform) const {
|
||||
calcTransform(getFrame(), jointNo, pTransform);
|
||||
}
|
||||
|
||||
/* 0x20 */ int mDecShift;
|
||||
/* 0x24 */ J3DAnmTransformKeyTable* mAnmTable;
|
||||
}; // Size: 0x28
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTransformFull : public J3DAnmTransform {
|
||||
public:
|
||||
J3DAnmTransformFull() : J3DAnmTransform(0, NULL, NULL, NULL) { mAnmTable = NULL; }
|
||||
|
||||
virtual ~J3DAnmTransformFull() {}
|
||||
virtual s32 getKind() const { return 9; }
|
||||
virtual void getTransform(u16, J3DTransformInfo*) const;
|
||||
|
||||
/* 0x20 */ J3DAnmTransformFullTable* mAnmTable;
|
||||
}; // Size: 0x24
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTransformFullWithLerp : public J3DAnmTransformFull {
|
||||
public:
|
||||
virtual ~J3DAnmTransformFullWithLerp() {}
|
||||
virtual s32 getKind() const { return 16; }
|
||||
virtual void getTransform(u16, J3DTransformInfo*) const;
|
||||
}; // Size: 0x24
|
||||
|
||||
struct J3DTextureSRTInfo;
|
||||
class J3DModelData;
|
||||
class J3DMaterialTable;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTextureSRTKey : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmTextureSRTKey();
|
||||
void calcTransform(f32, u16, J3DTextureSRTInfo*) const;
|
||||
void searchUpdateMaterialID(J3DMaterialTable*);
|
||||
void searchUpdateMaterialID(J3DModelData*);
|
||||
|
||||
virtual ~J3DAnmTextureSRTKey() {}
|
||||
virtual s32 getKind() const { return 4; }
|
||||
|
||||
void getTransform(u16 jointNo, J3DTextureSRTInfo* pSRTInfo) const {
|
||||
calcTransform(getFrame(), jointNo, pSRTInfo);
|
||||
}
|
||||
|
||||
u16 getUpdateMaterialID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(1029, idx < mTrackNum / 3);
|
||||
return mUpdateMaterialID[idx];
|
||||
}
|
||||
u16 getUpdateMaterialNum() const { return mTrackNum / 3; }
|
||||
u16 getPostUpdateMaterialNum() const { return field_0x4a / 3; }
|
||||
|
||||
int getUpdateTexMtxID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(1017, idx < mTrackNum / 3);
|
||||
return mUpdateTexMtxID[idx];
|
||||
}
|
||||
bool isValidUpdateMaterialID(u16 idx) const { return mUpdateMaterialID[idx] != 0xffff; }
|
||||
u32 getTexMtxCalcType() { return mTexMtxCalcType; }
|
||||
Vec* getSRTCenter(u16 idx) {
|
||||
J3D_ASSERT_RANGE(1047, idx < mTrackNum / 3);
|
||||
return &mSRTCenter[idx];
|
||||
}
|
||||
|
||||
/* 0x0C */ int mDecShift;
|
||||
/* 0x10 */ J3DAnmTransformKeyTable* mAnmTable;
|
||||
/* 0x14 */ u16 mTrackNum;
|
||||
/* 0x16 */ u16 mScaleNum;
|
||||
/* 0x18 */ u16 mRotNum;
|
||||
/* 0x1A */ u16 mTransNum;
|
||||
/* 0x1C */ f32* mScaleData;
|
||||
/* 0x20 */ s16* mRotData;
|
||||
/* 0x24 */ f32* mTransData;
|
||||
/* 0x28 */ u8* mUpdateTexMtxID;
|
||||
/* 0x2C */ u16* mUpdateMaterialID;
|
||||
/* 0x30 */ JUTNameTab mUpdateMaterialName;
|
||||
/* 0x40 */ Vec* mSRTCenter;
|
||||
/* 0x44 */ u16 field_0x44;
|
||||
/* 0x46 */ u16 field_0x46;
|
||||
/* 0x48 */ u16 field_0x48;
|
||||
/* 0x4A */ u16 field_0x4a;
|
||||
/* 0x4C */ void* field_0x4c;
|
||||
/* 0x50 */ void* field_0x50;
|
||||
/* 0x54 */ void* field_0x54;
|
||||
/* 0x58 */ void* field_0x58;
|
||||
/* 0x5C */ u8* mPostUpdateTexMtxID;
|
||||
/* 0x60 */ u16* mPostUpdateMaterialID;
|
||||
/* 0x64 */ JUTNameTab mPostUpdateMaterialName;
|
||||
/* 0x74 */ Vec* mPostSRTCenter;
|
||||
/* 0x78 */ u32 mTexMtxCalcType;
|
||||
}; // Size: 0x7C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmCluster : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmCluster(s16 frameMax, f32* pWeight) : J3DAnmBase(frameMax) { mWeight = pWeight; }
|
||||
|
||||
virtual ~J3DAnmCluster() {}
|
||||
virtual s32 getKind() const { return 3; }
|
||||
virtual f32 getWeight(u16) const { return 1.0f; }
|
||||
|
||||
/* 0x0C */ f32* mWeight;
|
||||
}; // Size: 0x10
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmClusterFull : public J3DAnmCluster {
|
||||
public:
|
||||
J3DAnmClusterFull() : J3DAnmCluster(0, NULL) { mAnmTable = NULL; }
|
||||
|
||||
virtual ~J3DAnmClusterFull() {}
|
||||
virtual s32 getKind() const { return 12; }
|
||||
virtual f32 getWeight(u16) const;
|
||||
|
||||
/* 0x10 */ J3DAnmClusterFullTable* mAnmTable;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmClusterKey : public J3DAnmCluster {
|
||||
public:
|
||||
J3DAnmClusterKey() : J3DAnmCluster(0, NULL) { mAnmTable = NULL; }
|
||||
|
||||
virtual ~J3DAnmClusterKey() {}
|
||||
virtual s32 getKind() const { return 13; }
|
||||
virtual f32 getWeight(u16) const;
|
||||
|
||||
/* 0x10 */ J3DAnmClusterKeyTable* mAnmTable;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmVtxColor : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmVtxColor();
|
||||
|
||||
virtual ~J3DAnmVtxColor() {}
|
||||
virtual s32 getKind() const { return 7; }
|
||||
virtual void getColor(u8, u16, GXColor*) const {}
|
||||
|
||||
u16 getAnmTableNum(u8 idx) {
|
||||
J3D_ASSERT_RANGE(1333, idx < 2);
|
||||
return mAnmTableNum[idx];
|
||||
}
|
||||
|
||||
J3DAnmVtxColorIndexData* getAnmVtxColorIndexData(u8 p1, u16 p2) {
|
||||
J3D_ASSERT_RANGE(1339, p1 < 2);
|
||||
J3D_ASSERT_RANGE(1340, p2 < mAnmTableNum[p1]);
|
||||
return mAnmVtxColorIndexData[p1] + p2;
|
||||
}
|
||||
|
||||
/* 0x0C */ u16 mAnmTableNum[2];
|
||||
/* 0x10 */ J3DAnmVtxColorIndexData* mAnmVtxColorIndexData[2];
|
||||
}; // Size: 0x18
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmVtxColorFull : public J3DAnmVtxColor {
|
||||
public:
|
||||
J3DAnmVtxColorFull();
|
||||
|
||||
virtual ~J3DAnmVtxColorFull() {}
|
||||
virtual s32 getKind() const { return 14; }
|
||||
virtual void getColor(u8, u16, GXColor*) const;
|
||||
|
||||
/* 0x18 */ J3DAnmColorFullTable* mpTable[2];
|
||||
/* 0x20 */ u8* mColorR;
|
||||
/* 0x24 */ u8* mColorG;
|
||||
/* 0x28 */ u8* mColorB;
|
||||
/* 0x2C */ u8* mColorA;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmVtxColorKey : public J3DAnmVtxColor {
|
||||
public:
|
||||
J3DAnmVtxColorKey();
|
||||
|
||||
virtual ~J3DAnmVtxColorKey() {}
|
||||
virtual s32 getKind() const { return 15; }
|
||||
virtual void getColor(u8, u16, GXColor*) const;
|
||||
|
||||
/* 0x18 */ J3DAnmColorKeyTable* mpTable[2];
|
||||
/* 0x20 */ s16* mColorR;
|
||||
/* 0x24 */ s16* mColorG;
|
||||
/* 0x28 */ s16* mColorB;
|
||||
/* 0x2C */ s16* mColorA;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmColor : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmColor();
|
||||
void searchUpdateMaterialID(J3DMaterialTable*);
|
||||
|
||||
virtual ~J3DAnmColor() {}
|
||||
virtual s32 getKind() const { return 1; }
|
||||
virtual void getColor(u16, GXColor*) const {}
|
||||
|
||||
u16 getUpdateMaterialNum() const { return mUpdateMaterialNum; }
|
||||
bool isValidUpdateMaterialID(u16 id) const { return mUpdateMaterialID[id] != 0xFFFF; }
|
||||
u16 getUpdateMaterialID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(1578, idx < mUpdateMaterialNum);
|
||||
return mUpdateMaterialID[idx];
|
||||
}
|
||||
|
||||
/* 0x0C */ u16 field_0xc;
|
||||
/* 0x0E */ u16 field_0xe;
|
||||
/* 0x10 */ u16 field_0x10;
|
||||
/* 0x12 */ u16 field_0x12;
|
||||
/* 0x14 */ u16 mUpdateMaterialNum;
|
||||
/* 0x18 */ u16* mUpdateMaterialID;
|
||||
/* 0x1C */ JUTNameTab mUpdateMaterialName;
|
||||
}; // Size: 0x2C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmColorFull : public J3DAnmColor {
|
||||
public:
|
||||
J3DAnmColorFull();
|
||||
|
||||
virtual ~J3DAnmColorFull() {}
|
||||
virtual s32 getKind() const { return 10; }
|
||||
virtual void getColor(u16, GXColor*) const;
|
||||
|
||||
/* 0x2C */ u8* mColorR;
|
||||
/* 0x30 */ u8* mColorG;
|
||||
/* 0x34 */ u8* mColorB;
|
||||
/* 0x38 */ u8* mColorA;
|
||||
/* 0x3C */ J3DAnmColorFullTable* mAnmTable;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmColorKey : public J3DAnmColor {
|
||||
public:
|
||||
J3DAnmColorKey();
|
||||
|
||||
virtual ~J3DAnmColorKey() {}
|
||||
virtual s32 getKind() const { return 11; }
|
||||
virtual void getColor(u16, GXColor*) const;
|
||||
|
||||
/* 0x2C */ s16* mColorR;
|
||||
/* 0x30 */ s16* mColorG;
|
||||
/* 0x34 */ s16* mColorB;
|
||||
/* 0x38 */ s16* mColorA;
|
||||
/* 0x3C */ J3DAnmColorKeyTable* mAnmTable;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTevRegKey : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmTevRegKey();
|
||||
void getTevColorReg(u16, _GXColorS10*) const;
|
||||
void getTevKonstReg(u16, _GXColor*) const;
|
||||
void searchUpdateMaterialID(J3DMaterialTable*);
|
||||
void searchUpdateMaterialID(J3DModelData*);
|
||||
|
||||
virtual ~J3DAnmTevRegKey() {}
|
||||
virtual s32 getKind() const { return 5; }
|
||||
|
||||
u16 getCRegUpdateMaterialNum() const { return mCRegUpdateMaterialNum; }
|
||||
u16 getKRegUpdateMaterialNum() const { return mKRegUpdateMaterialNum; }
|
||||
|
||||
u16 getCRegUpdateMaterialID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(2100, idx < mCRegUpdateMaterialNum);
|
||||
return mCRegUpdateMaterialID[idx];
|
||||
}
|
||||
u16 getKRegUpdateMaterialID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(2140, idx < mKRegUpdateMaterialNum);
|
||||
return mKRegUpdateMaterialID[idx];
|
||||
}
|
||||
|
||||
const J3DAnmCRegKeyTable* getAnmCRegKeyTable() { return mAnmCRegKeyTable; }
|
||||
const J3DAnmKRegKeyTable* getAnmKRegKeyTable() { return mAnmKRegKeyTable; }
|
||||
|
||||
bool isValidCRegUpdateMaterialID(u16 idx) const { return mCRegUpdateMaterialID[idx] != 0xffff; }
|
||||
bool isValidKRegUpdateMaterialID(u16 idx) const { return mKRegUpdateMaterialID[idx] != 0xffff; }
|
||||
|
||||
/* 0x0C */ u16 mCRegUpdateMaterialNum;
|
||||
/* 0x0E */ u16 mKRegUpdateMaterialNum;
|
||||
/* 0x10 */ u16 mCRegDataCountR;
|
||||
/* 0x12 */ u16 mCRegDataCountG;
|
||||
/* 0x14 */ u16 mCRegDataCountB;
|
||||
/* 0x16 */ u16 mCRegDataCountA;
|
||||
/* 0x18 */ u16 mKRegDataCountR;
|
||||
/* 0x1A */ u16 mKRegDataCountG;
|
||||
/* 0x1C */ u16 mKRegDataCountB;
|
||||
/* 0x1E */ u16 mKRegDataCountA;
|
||||
/* 0x20 */ u16* mCRegUpdateMaterialID;
|
||||
/* 0x24 */ JUTNameTab mCRegUpdateMaterialName;
|
||||
/* 0x34 */ u16* mKRegUpdateMaterialID;
|
||||
/* 0x38 */ JUTNameTab mKRegUpdateMaterialName;
|
||||
/* 0x48 */ J3DAnmCRegKeyTable* mAnmCRegKeyTable;
|
||||
/* 0x4C */ J3DAnmKRegKeyTable* mAnmKRegKeyTable;
|
||||
/* 0x50 */ s16* mAnmCRegDataR;
|
||||
/* 0x54 */ s16* mAnmCRegDataG;
|
||||
/* 0x58 */ s16* mAnmCRegDataB;
|
||||
/* 0x5C */ s16* mAnmCRegDataA;
|
||||
/* 0x60 */ s16* mAnmKRegDataR;
|
||||
/* 0x64 */ s16* mAnmKRegDataG;
|
||||
/* 0x68 */ s16* mAnmKRegDataB;
|
||||
/* 0x6C */ s16* mAnmKRegDataA;
|
||||
}; // Size: 0x70
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmTexPattern : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmTexPattern();
|
||||
void getTexNo(u16, u16*) const;
|
||||
void searchUpdateMaterialID(J3DMaterialTable*);
|
||||
void searchUpdateMaterialID(J3DModelData*);
|
||||
|
||||
virtual ~J3DAnmTexPattern() {}
|
||||
virtual s32 getKind() const { return 2; }
|
||||
|
||||
u16 getUpdateMaterialID(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(2288, idx < mUpdateMaterialNum);
|
||||
return mUpdateMaterialID[idx];
|
||||
}
|
||||
u16 getUpdateMaterialNum() const { return mUpdateMaterialNum; }
|
||||
bool isValidUpdateMaterialID(u16 id) const { return mUpdateMaterialID[id] != 0xFFFF; }
|
||||
J3DAnmTexPatternFullTable* getAnmTable() { return mAnmTable; }
|
||||
|
||||
/* 0x0C */ u16* mTextureIndex;
|
||||
/* 0x10 */ J3DAnmTexPatternFullTable* mAnmTable;
|
||||
/* 0x14 */ u16 field_0x14;
|
||||
/* 0x16 */ u16 mUpdateMaterialNum;
|
||||
/* 0x18 */ u16* mUpdateMaterialID;
|
||||
/* 0x1C */ JUTNameTab mUpdateMaterialName;
|
||||
}; // Size: 0x2C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DAnmVisibilityFull : public J3DAnmBase {
|
||||
public:
|
||||
J3DAnmVisibilityFull() : J3DAnmBase() {
|
||||
mUpdateMaterialNum = 0;
|
||||
field_0xe = 0;
|
||||
mAnmTable = NULL;
|
||||
mVisibility = NULL;
|
||||
}
|
||||
|
||||
virtual ~J3DAnmVisibilityFull() {}
|
||||
virtual s32 getKind() const { return 6; }
|
||||
|
||||
/* 0x0C */ u16 mUpdateMaterialNum;
|
||||
/* 0x0E */ u16 field_0xe;
|
||||
/* 0x10 */ J3DAnmVisibilityFullTable* mAnmTable;
|
||||
/* 0x14 */ u8* mVisibility;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DFrameCtrl {
|
||||
public:
|
||||
enum Attribute_e {
|
||||
/* -1 */ EMode_NULL = -1,
|
||||
/* 0x0 */ EMode_NONE,
|
||||
/* 0x1 */ EMode_RESET,
|
||||
/* 0x2 */ EMode_LOOP,
|
||||
/* 0x3 */ EMode_REVERSE,
|
||||
/* 0x4 */ EMode_LOOP_REVERSE,
|
||||
};
|
||||
|
||||
J3DFrameCtrl() { this->init(0); }
|
||||
void init(s16);
|
||||
void init(int endFrame) { init((s16)endFrame); }
|
||||
BOOL checkPass(f32);
|
||||
void update();
|
||||
virtual ~J3DFrameCtrl() {}
|
||||
|
||||
u8 getAttribute() const { return mAttribute; }
|
||||
void setAttribute(u8 attr) { mAttribute = attr; }
|
||||
u8 getState() const { return mState; }
|
||||
bool checkState(u8 state) const { return mState & state ? true : false; }
|
||||
s16 getStart() const { return mStart; }
|
||||
void setStart(s16 start) {
|
||||
mStart = start;
|
||||
mFrame = start;
|
||||
}
|
||||
s16 getEnd() const { return mEnd; }
|
||||
void setEnd(s16 end) { mEnd = end; }
|
||||
s16 getLoop() const { return mLoop; }
|
||||
void setLoop(s16 loop) { mLoop = loop; }
|
||||
f32 getRate() const { return mRate; }
|
||||
void setRate(f32 rate) { mRate = rate; }
|
||||
f32 getFrame() const { return mFrame; }
|
||||
void setFrame(f32 frame) { mFrame = frame; }
|
||||
void reset() {
|
||||
mFrame = mStart;
|
||||
mRate = 1.0f;
|
||||
mState = 0;
|
||||
}
|
||||
|
||||
/* 0x04 */ u8 mAttribute;
|
||||
/* 0x05 */ u8 mState;
|
||||
/* 0x06 */ s16 mStart;
|
||||
/* 0x08 */ s16 mEnd;
|
||||
/* 0x0A */ s16 mLoop;
|
||||
/* 0x0C */ f32 mRate;
|
||||
/* 0x10 */ f32 mFrame;
|
||||
}; // Size: 0x14
|
||||
|
||||
#endif /* J3DANIMATION_H */
|
||||
@@ -0,0 +1,129 @@
|
||||
#ifndef J3DCLUSTER_H
|
||||
#define J3DCLUSTER_H
|
||||
|
||||
#include "JSystem/J3DAssert.h"
|
||||
|
||||
class J3DDeformer;
|
||||
class J3DClusterKey;
|
||||
class J3DClusterVertex;
|
||||
class J3DVertexBuffer;
|
||||
class J3DModel;
|
||||
class J3DAnmCluster;
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DCluster {
|
||||
public:
|
||||
void operator=(const J3DCluster& other) {
|
||||
mMaxAngle = other.mMaxAngle;
|
||||
mMinAngle = other.mMinAngle;
|
||||
mClusterKey = other.mClusterKey;
|
||||
mFlags = other.mFlags;
|
||||
mKeyNum = other.mKeyNum;
|
||||
mPosNum = other.mPosNum;
|
||||
field_0x14 = other.field_0x14;
|
||||
field_0x16 = other.field_0x16;
|
||||
field_0x18 = other.field_0x18;
|
||||
mClusterVertex = other.mClusterVertex;
|
||||
mDeformer = other.mDeformer;
|
||||
}
|
||||
|
||||
J3DDeformer* getDeformer() { return mDeformer; }
|
||||
void setDeformer(J3DDeformer* deformer) {
|
||||
J3D_ASSERT_NULLPTR(111, deformer);
|
||||
mDeformer = deformer;
|
||||
}
|
||||
|
||||
/* 0x00 */ f32 mMaxAngle;
|
||||
/* 0x04 */ f32 mMinAngle;
|
||||
/* 0x08 */ J3DClusterKey* mClusterKey;
|
||||
/* 0x0C */ u8 mFlags;
|
||||
/* 0x0E */ u8 field_0xe[0x10 - 0xD];
|
||||
/* 0x10 */ u16 mKeyNum;
|
||||
/* 0x12 */ u16 mPosNum;
|
||||
/* 0x14 */ u16 field_0x14;
|
||||
/* 0x16 */ u16 field_0x16;
|
||||
/* 0x18 */ u16* field_0x18;
|
||||
/* 0x1C */ J3DClusterVertex* mClusterVertex;
|
||||
/* 0x20 */ J3DDeformer* mDeformer;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DClusterKey {
|
||||
public:
|
||||
void operator=(const J3DClusterKey& other) {
|
||||
mPosNum = other.mPosNum;
|
||||
mNrmNum = other.mNrmNum;
|
||||
field_0x4 = other.field_0x4;
|
||||
field_0x8 = other.field_0x8;
|
||||
}
|
||||
|
||||
/* 0x00 */ u16 mPosNum;
|
||||
/* 0x02 */ u16 mNrmNum;
|
||||
/* 0x04 */ void* field_0x4;
|
||||
/* 0x08 */ void* field_0x8;
|
||||
}; // Size: 0x0C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DDeformData {
|
||||
public:
|
||||
J3DDeformData();
|
||||
void offAllFlag(u32);
|
||||
void deform(J3DVertexBuffer*);
|
||||
void deform(J3DModel*);
|
||||
void setAnm(J3DAnmCluster*);
|
||||
|
||||
J3DCluster* getClusterPointer(u16 index) {
|
||||
J3D_ASSERT_RANGE(186, (index < mClusterNum));
|
||||
return &mClusterPointer[index];
|
||||
}
|
||||
u16 getClusterNum() const { return mClusterNum; }
|
||||
u16 getClusterKeyNum() const { return mClusterKeyNum; }
|
||||
J3DClusterKey* getClusterKeyPointer(u16 i) {
|
||||
J3D_ASSERT_RANGE(199, (i < mClusterKeyNum));
|
||||
return &mClusterKeyPointer[i];
|
||||
}
|
||||
f32* getVtxPos() { return mVtxPos; }
|
||||
f32* getVtxNrm() { return mVtxNrm; }
|
||||
|
||||
/* 0x00 */ u16 mClusterNum;
|
||||
/* 0x02 */ u16 mClusterKeyNum;
|
||||
/* 0x04 */ u16 mClusterVertexNum;
|
||||
/* 0x08 */ J3DCluster* mClusterPointer;
|
||||
/* 0x0C */ J3DClusterKey* mClusterKeyPointer;
|
||||
/* 0x10 */ J3DClusterVertex* mClusterVertex;
|
||||
/* 0x14 */ u16 mVtxPosNum;
|
||||
/* 0x16 */ u16 mVtxNrmNum;
|
||||
/* 0x18 */ f32* mVtxPos;
|
||||
/* 0x1C */ f32* mVtxNrm;
|
||||
/* 0x20 */ JUTNameTab* mClusterName;
|
||||
/* 0x24 */ JUTNameTab* mClusterKeyName;
|
||||
}; // Size: 0x28
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DClusterVertex {
|
||||
public:
|
||||
void operator=(const J3DClusterVertex& other) {
|
||||
mNum = other.mNum;
|
||||
field_0x4 = other.field_0x4;
|
||||
field_0x8 = other.field_0x8;
|
||||
}
|
||||
|
||||
/* 0x00 */ u16 mNum;
|
||||
/* 0x04 */ u16* field_0x4;
|
||||
/* 0x08 */ u16* field_0x8;
|
||||
}; // Size: 0x0C
|
||||
|
||||
#endif /* J3DCLUSTER_H */
|
||||
@@ -0,0 +1,248 @@
|
||||
#ifndef J3DJOINT_H
|
||||
#define J3DJOINT_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
|
||||
#include "JSystem/J3DGraphBase/J3DTransform.h"
|
||||
#include "JSystem/J3DGraphBase/J3DMaterial.h"
|
||||
|
||||
class J3DAnmTransform;
|
||||
class J3DJoint;
|
||||
class J3DMaterial;
|
||||
class J3DMtxBuffer;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMtxCalc {
|
||||
public:
|
||||
static void setMtxBuffer(J3DMtxBuffer*);
|
||||
|
||||
virtual ~J3DMtxCalc() {}
|
||||
virtual void setAnmTransform(J3DAnmTransform*) {
|
||||
JUT_ASSERT_MSG(127, FALSE, "You cannot use this method");
|
||||
}
|
||||
virtual J3DAnmTransform* getAnmTransform() {
|
||||
JUT_ASSERT_MSG(131, FALSE, "You cannot use this method");
|
||||
return NULL;
|
||||
}
|
||||
virtual void setAnmTransform(u8, J3DAnmTransform*) {
|
||||
JUT_ASSERT_MSG(137, FALSE, "You cannot use this method");
|
||||
}
|
||||
virtual J3DAnmTransform* getAnmTransform(u8) {
|
||||
JUT_ASSERT_MSG(141, FALSE, "You cannot use this method");
|
||||
return NULL;
|
||||
}
|
||||
virtual void setWeight(u8, f32) {
|
||||
JUT_ASSERT_MSG(147, FALSE, "You cannot use this method");
|
||||
}
|
||||
virtual f32 getWeight(u8) const {
|
||||
JUT_ASSERT_MSG(152, FALSE, "You cannot use this method");
|
||||
return 0.0f;
|
||||
}
|
||||
virtual void init(const Vec& param_0, const Mtx&) = 0;
|
||||
virtual void calc() = 0;
|
||||
|
||||
static J3DMtxBuffer* getMtxBuffer() {
|
||||
J3D_ASSERT_NULLPTR(174, mMtxBuffer != NULL)
|
||||
return mMtxBuffer;
|
||||
}
|
||||
static J3DJoint* getJoint() {
|
||||
J3D_ASSERT_NULLPTR(185, mJoint != NULL)
|
||||
return mJoint;
|
||||
}
|
||||
static void setJoint(J3DJoint* joint) { mJoint = joint; }
|
||||
|
||||
static J3DMtxBuffer* mMtxBuffer;
|
||||
static J3DJoint* mJoint;
|
||||
}; // Size: 0x4
|
||||
|
||||
typedef int (*J3DJointCallBack)(J3DJoint*, int);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DJoint {
|
||||
public:
|
||||
void appendChild(J3DJoint*);
|
||||
J3DJoint();
|
||||
void entryIn();
|
||||
void recursiveCalc();
|
||||
|
||||
u32 getType() const { return 'NJNT'; }
|
||||
|
||||
J3DMaterial* getMesh() { return mMesh; }
|
||||
void addMesh(J3DMaterial* pMesh) {
|
||||
if (mMesh != NULL) {
|
||||
pMesh->setNext(mMesh);
|
||||
}
|
||||
|
||||
mMesh = pMesh;
|
||||
}
|
||||
|
||||
u16 getJntNo() const { return mJntNo; }
|
||||
u8 getScaleCompensate() const { return mScaleCompensate; }
|
||||
J3DJoint* getYounger() { return mYounger; }
|
||||
void setYounger(J3DJoint* pYounger) { mYounger = pYounger; }
|
||||
void setCurrentMtxCalc(J3DMtxCalc* pMtxCalc) { mCurrentMtxCalc = pMtxCalc; }
|
||||
J3DTransformInfo& getTransformInfo() { return mTransformInfo; }
|
||||
void setTransformInfo(const J3DTransformInfo& i_info) { mTransformInfo = i_info; }
|
||||
Vec* getMax() { return &mMax; }
|
||||
Vec* getMin() { return &mMin; }
|
||||
void setCallBack(J3DJointCallBack callback) { mCallBack = callback; }
|
||||
J3DJointCallBack getCallBack() { return mCallBack; }
|
||||
void setMtxCalc(J3DMtxCalc* i_mtxCalc) { mMtxCalc = i_mtxCalc; }
|
||||
J3DMtxCalc* getMtxCalc() { return mMtxCalc; }
|
||||
J3DMtxCalc* getCurrentMtxCalc() { return mCurrentMtxCalc; };
|
||||
J3DJoint* getChild() { return mChild; }
|
||||
u8 getMtxType() const { return (mKind & 0xf0) >> 4; }
|
||||
void setMtxType(u8 type) { mKind = (mKind & ~0xf0) | (type << 4); }
|
||||
f32 getRadius() const { return mBoundingSphereRadius; }
|
||||
|
||||
static J3DMtxCalc* mCurrentMtxCalc;
|
||||
|
||||
u8 getKind() const { return mKind & 15; }
|
||||
|
||||
private:
|
||||
friend struct J3DJointFactory;
|
||||
friend class J3DJointTree;
|
||||
|
||||
/* 0x00 */ void* mCallBackUserData;
|
||||
/* 0x04 */ J3DJointCallBack mCallBack;
|
||||
/* 0x08 */ void* field_0x8;
|
||||
/* 0x0C */ J3DJoint* mChild;
|
||||
/* 0x10 */ J3DJoint* mYounger;
|
||||
/* 0x14 */ u16 mJntNo;
|
||||
/* 0x16 */ u8 mKind;
|
||||
/* 0x17 */ u8 mScaleCompensate;
|
||||
/* 0x18 */ J3DTransformInfo mTransformInfo;
|
||||
/* 0x38 */ f32 mBoundingSphereRadius;
|
||||
/* 0x3C */ Vec mMin;
|
||||
/* 0x48 */ Vec mMax;
|
||||
/* 0x54 */ J3DMtxCalc* mMtxCalc;
|
||||
/* 0x58 */ J3DMaterial* mMesh;
|
||||
}; // Size: 0x5C
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMtxCalcNoAnmBase : public J3DMtxCalc {
|
||||
public:
|
||||
virtual ~J3DMtxCalcNoAnmBase() {}
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
template <class A, class B>
|
||||
class J3DMtxCalcNoAnm : public J3DMtxCalcNoAnmBase {
|
||||
public:
|
||||
J3DMtxCalcNoAnm() {}
|
||||
virtual ~J3DMtxCalcNoAnm() {}
|
||||
virtual void init(const Vec& param_0, const Mtx& param_1) { B::init(param_0, param_1); }
|
||||
virtual void calc() {
|
||||
J3DTransformInfo& transInfo = getJoint()->getTransformInfo();
|
||||
A::calcTransform(transInfo);
|
||||
}
|
||||
};
|
||||
|
||||
struct J3DMtxCalcAnmBase: public J3DMtxCalc {
|
||||
J3DMtxCalcAnmBase(J3DAnmTransform* pAnmTransform) { mAnmTransform = pAnmTransform; }
|
||||
~J3DMtxCalcAnmBase() {}
|
||||
J3DAnmTransform* getAnmTransform() { return mAnmTransform; }
|
||||
void setAnmTransform(J3DAnmTransform* pAnmTransform) { mAnmTransform = pAnmTransform; }
|
||||
|
||||
J3DAnmTransform* mAnmTransform;
|
||||
};
|
||||
|
||||
struct J3DMtxCalcAnimationAdaptorBase {
|
||||
J3DMtxCalcAnimationAdaptorBase() {}
|
||||
void change(J3DAnmTransform*) {}
|
||||
};
|
||||
|
||||
template <typename A0>
|
||||
struct J3DMtxCalcAnimationAdaptorDefault : public J3DMtxCalcAnimationAdaptorBase {
|
||||
J3DMtxCalcAnimationAdaptorDefault(J3DAnmTransform* pAnmTransform) {}
|
||||
|
||||
void calc(J3DMtxCalcAnmBase* pMtxCalc) {
|
||||
J3DTransformInfo transform;
|
||||
J3DTransformInfo* transform_p;
|
||||
if (pMtxCalc->getAnmTransform() != NULL) {
|
||||
pMtxCalc->getAnmTransform()->getTransform(J3DMtxCalc::getJoint()->getJntNo(), &transform);
|
||||
transform_p = &transform;
|
||||
} else {
|
||||
transform_p = &J3DMtxCalc::getJoint()->getTransformInfo();
|
||||
}
|
||||
|
||||
A0::calcTransform(*transform_p);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename A0, typename B0>
|
||||
struct J3DMtxCalcAnimation : public J3DMtxCalcAnmBase {
|
||||
J3DMtxCalcAnimation(J3DAnmTransform* pAnmTransform) : J3DMtxCalcAnmBase(pAnmTransform), field_0x8(pAnmTransform) {}
|
||||
~J3DMtxCalcAnimation() {}
|
||||
|
||||
void setAnmTransform(J3DAnmTransform* pAnmTransform) {
|
||||
mAnmTransform = pAnmTransform;
|
||||
field_0x8.change(pAnmTransform);
|
||||
}
|
||||
|
||||
void init(const Vec& param_0, const Mtx& param_1) { B0::init(param_0, param_1); }
|
||||
void calc() { field_0x8.calc(this); }
|
||||
|
||||
A0 field_0x8;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DMtxCalcJ3DSysInitMaya {
|
||||
static void init(const Vec&, const Mtx& param_1);
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DMtxCalcJ3DSysInitBasic {
|
||||
static void init(const Vec&, const Mtx& param_1);
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DMtxCalcCalcTransformSoftimage {
|
||||
static void calcTransform(J3DTransformInfo const&);
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DMtxCalcCalcTransformMaya {
|
||||
static void calcTransform(J3DTransformInfo const&);
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DMtxCalcCalcTransformBasic {
|
||||
static void calcTransform(J3DTransformInfo const&);
|
||||
};
|
||||
|
||||
inline s32 checkScaleOne(const Vec& param_0) {
|
||||
if (param_0.x == 1.0f && param_0.y == 1.0f && param_0.z == 1.0f) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* J3DJOINT_H */
|
||||
@@ -0,0 +1,102 @@
|
||||
#ifndef J3DJOINTTREE_H
|
||||
#define J3DJOINTTREE_H
|
||||
|
||||
#include "JSystem/J3DAssert.h"
|
||||
#include "JSystem/J3DGraphBase/J3DTransform.h"
|
||||
|
||||
class J3DJoint;
|
||||
class J3DMtxBuffer;
|
||||
class J3DMtxCalc;
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DModelHierarchy {
|
||||
/* 0x0 */ u16 mType;
|
||||
/* 0x2 */ u16 mValue;
|
||||
};
|
||||
|
||||
class J3DMaterialTable;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DDrawMtxData {
|
||||
J3DDrawMtxData();
|
||||
~J3DDrawMtxData();
|
||||
|
||||
/* 0x0 */ u16 mEntryNum;
|
||||
/* 0x2 */ u16 mDrawFullWgtMtxNum;
|
||||
/* 0x4 */ u8* mDrawMtxFlag;
|
||||
/* 0x8 */ u16* mDrawMtxIndex;
|
||||
}; // Size: 0xC
|
||||
|
||||
class J3DShapeTable;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DJointTree {
|
||||
public:
|
||||
J3DJointTree();
|
||||
void makeHierarchy(J3DJoint*, J3DModelHierarchy const**, J3DMaterialTable*,
|
||||
J3DShapeTable*);
|
||||
void findImportantMtxIndex();
|
||||
|
||||
virtual void calc(J3DMtxBuffer*, Vec const&, f32 const (&)[3][4]);
|
||||
virtual ~J3DJointTree() {}
|
||||
|
||||
const J3DModelHierarchy* getHierarchy() const { return mHierarchy; }
|
||||
void setHierarchy(J3DModelHierarchy* hierarchy) { mHierarchy = hierarchy; }
|
||||
void setBasicMtxCalc(J3DMtxCalc* calc) { mBasicMtxCalc = calc; }
|
||||
u16 getWEvlpMtxNum() const { return mWEvlpMtxNum; }
|
||||
u16* getWEvlpMixIndex() const { return mWEvlpMixMtxIndex; }
|
||||
u8 getWEvlpMixMtxNum(u16 idx) const { return mWEvlpMixMtxNum[idx]; }
|
||||
u16 * getWEvlpMixMtxIndex() const { return mWEvlpMixMtxIndex; }
|
||||
f32 * getWEvlpMixWeight() const { return mWEvlpMixWeight; }
|
||||
u16 * getWEvlpImportantMtxIndex() const { return mWEvlpImportantMtxIdx; }
|
||||
u16 getDrawFullWgtMtxNum() const { return mDrawMtxData.mDrawFullWgtMtxNum; }
|
||||
u16 getJointNum() const { return mJointNum; }
|
||||
u16 getDrawMtxNum() const { return mDrawMtxData.mEntryNum; }
|
||||
u8 getDrawMtxFlag(u16 idx) const { return mDrawMtxData.mDrawMtxFlag[idx]; }
|
||||
u16 getDrawMtxIndex(u16 idx) const { return mDrawMtxData.mDrawMtxIndex[idx]; }
|
||||
J3DDrawMtxData* getDrawMtxData() { return &mDrawMtxData; }
|
||||
JUTNameTab* getJointName() const { return mJointName; }
|
||||
J3DJoint* getRootNode() { return mRootNode; }
|
||||
J3DJoint* getJointNodePointer(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(139, idx < mJointNum);
|
||||
return mJointNodePointer[idx];
|
||||
}
|
||||
J3DMtxCalc* getBasicMtxCalc() { return mBasicMtxCalc; }
|
||||
Mtx& getInvJointMtx(int idx) { return mInvJointMtx[idx]; }
|
||||
u32 getModelDataType() const { return mModelDataType; }
|
||||
void setModelDataType(u32 type) { mModelDataType = type; }
|
||||
bool checkFlag(u32 flag) const { return mFlags & flag ? true : false; }
|
||||
void setFlag(u32 flag) { mFlags = flag; }
|
||||
|
||||
private:
|
||||
friend class J3DModelLoader;
|
||||
|
||||
/* 0x04 */ J3DModelHierarchy* mHierarchy;
|
||||
/* 0x08 */ u32 mFlags;
|
||||
/* 0x0C */ u32 mModelDataType;
|
||||
/* 0x10 */ J3DJoint* mRootNode;
|
||||
/* 0x14 */ J3DMtxCalc* mBasicMtxCalc;
|
||||
/* 0x18 */ J3DJoint** mJointNodePointer;
|
||||
/* 0x1C */ u16 mJointNum;
|
||||
/* 0x1E */ u16 mWEvlpMtxNum;
|
||||
/* 0x20 */ u8* mWEvlpMixMtxNum;
|
||||
/* 0x24 */ u16* mWEvlpMixMtxIndex;
|
||||
/* 0x28 */ f32* mWEvlpMixWeight;
|
||||
/* 0x2C */ Mtx* mInvJointMtx;
|
||||
/* 0x30 */ u16* mWEvlpImportantMtxIdx;
|
||||
/* 0x34 */ J3DDrawMtxData mDrawMtxData;
|
||||
/* 0x40 */ u32 field_0x40;
|
||||
/* 0x44 */ JUTNameTab* mJointName;
|
||||
}; // Size: 0x48
|
||||
|
||||
#endif /* J3DJOINTTREE_H */
|
||||
@@ -0,0 +1,217 @@
|
||||
#ifndef J3DMATERIALANM_H
|
||||
#define J3DMATERIALANM_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DAnimation.h"
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMatColorAnm {
|
||||
public:
|
||||
~J3DMatColorAnm() {}
|
||||
|
||||
J3DMatColorAnm() : field_0x0(0), mAnmFlag(1), mAnmColor(NULL) {}
|
||||
|
||||
J3DMatColorAnm(u16 param_1, J3DAnmColor* pAnmColor) {
|
||||
field_0x0 = param_1;
|
||||
mAnmFlag = 1;
|
||||
mAnmColor = pAnmColor;
|
||||
J3D_ASSERT_NULLPTR(56, pAnmColor != NULL);
|
||||
}
|
||||
|
||||
void operator=(J3DMatColorAnm const& other) {
|
||||
mAnmColor = other.mAnmColor;
|
||||
field_0x0 = other.field_0x0;
|
||||
mAnmFlag = other.mAnmFlag;
|
||||
}
|
||||
|
||||
void setAnmFlag(bool flag) { mAnmFlag = flag; }
|
||||
bool getAnmFlag() const { return mAnmFlag; }
|
||||
|
||||
void calc(GXColor* pColor) const {
|
||||
J3D_ASSERT_NULLPTR(507, pColor != NULL);
|
||||
mAnmColor->getColor(field_0x0, pColor);
|
||||
}
|
||||
|
||||
private:
|
||||
/* 0x0 */ u16 field_0x0;
|
||||
/* 0x2 */ u16 mAnmFlag;
|
||||
/* 0x4 */ J3DAnmColor* mAnmColor;
|
||||
}; // Size: 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DTexMtxAnm {
|
||||
public:
|
||||
~J3DTexMtxAnm() {}
|
||||
J3DTexMtxAnm() : field_0x0(0), mAnmFlag(1), mAnmTransform(NULL) {}
|
||||
|
||||
J3DTexMtxAnm(u16 param_1, J3DAnmTextureSRTKey* pSRTKey) {
|
||||
field_0x0 = param_1;
|
||||
mAnmFlag = 1;
|
||||
mAnmTransform = pSRTKey;
|
||||
J3D_ASSERT_NULLPTR(134, pSRTKey != NULL);
|
||||
}
|
||||
|
||||
void operator=(J3DTexMtxAnm const& other) {
|
||||
mAnmTransform = other.mAnmTransform;
|
||||
field_0x0 = other.field_0x0;
|
||||
mAnmFlag = other.mAnmFlag;
|
||||
}
|
||||
|
||||
void setAnmFlag(bool flag) { mAnmFlag = flag; }
|
||||
|
||||
void calc(J3DTextureSRTInfo* pSRTInfo) const {
|
||||
J3D_ASSERT_NULLPTR(519, pSRTInfo != NULL);
|
||||
mAnmTransform->getTransform(field_0x0, pSRTInfo);
|
||||
}
|
||||
|
||||
bool getAnmFlag() const { return mAnmFlag; }
|
||||
|
||||
private:
|
||||
/* 0x0 */ u16 field_0x0;
|
||||
/* 0x2 */ u16 mAnmFlag;
|
||||
/* 0x4 */ J3DAnmTextureSRTKey* mAnmTransform;
|
||||
}; // Size: 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DTexNoAnm {
|
||||
public:
|
||||
~J3DTexNoAnm() {}
|
||||
J3DTexNoAnm() : field_0x4(0), mAnmFlag(1), mAnmTexPattern(NULL) {}
|
||||
|
||||
J3DTexNoAnm(u16 param_1, J3DAnmTexPattern* pAnmTexPattern) {
|
||||
field_0x4 = param_1;
|
||||
mAnmFlag = 1;
|
||||
mAnmTexPattern = pAnmTexPattern;
|
||||
J3D_ASSERT_NULLPTR(214, pAnmTexPattern != NULL);
|
||||
}
|
||||
|
||||
virtual void calc(u16* param_0) const {
|
||||
J3D_ASSERT_NULLPTR(532, param_0);
|
||||
mAnmTexPattern->getTexNo(field_0x4, param_0);
|
||||
}
|
||||
|
||||
void operator=(J3DTexNoAnm const& other) {
|
||||
mAnmTexPattern = other.mAnmTexPattern;
|
||||
field_0x4 = other.field_0x4;
|
||||
mAnmFlag = other.mAnmFlag;
|
||||
}
|
||||
|
||||
void setAnmFlag(bool flag) { mAnmFlag = flag; }
|
||||
bool getAnmFlag() const { return mAnmFlag; }
|
||||
J3DAnmTexPattern* getAnmTexPattern() { return mAnmTexPattern; }
|
||||
|
||||
private:
|
||||
/* 0x4 */ u16 field_0x4;
|
||||
/* 0x6 */ u16 mAnmFlag;
|
||||
/* 0x8 */ J3DAnmTexPattern* mAnmTexPattern;
|
||||
}; // Size: 0xC
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DTevColorAnm {
|
||||
public:
|
||||
~J3DTevColorAnm() {}
|
||||
J3DTevColorAnm() : field_0x0(0), mAnmFlag(1), mAnmTevReg(NULL) {}
|
||||
|
||||
J3DTevColorAnm(u16 param_1, J3DAnmTevRegKey* pTevRegKey) {
|
||||
field_0x0 = param_1;
|
||||
mAnmFlag = 1;
|
||||
mAnmTevReg = pTevRegKey;
|
||||
J3D_ASSERT_NULLPTR(293, pTevRegKey != NULL);
|
||||
}
|
||||
|
||||
void operator=(J3DTevColorAnm const& other) {
|
||||
mAnmTevReg = other.mAnmTevReg;
|
||||
field_0x0 = other.field_0x0;
|
||||
mAnmFlag = other.mAnmFlag;
|
||||
}
|
||||
|
||||
void setAnmFlag(bool flag) { mAnmFlag = flag; }
|
||||
bool getAnmFlag() const { return mAnmFlag; }
|
||||
|
||||
void calc(GXColorS10* pColor) const {
|
||||
J3D_ASSERT_NULLPTR(545, pColor != NULL);
|
||||
mAnmTevReg->getTevColorReg(field_0x0, pColor);
|
||||
}
|
||||
|
||||
private:
|
||||
/* 0x0 */ u16 field_0x0;
|
||||
/* 0x2 */ u16 mAnmFlag;
|
||||
/* 0x4 */ J3DAnmTevRegKey* mAnmTevReg;
|
||||
}; // Size: 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DTevKColorAnm {
|
||||
public:
|
||||
~J3DTevKColorAnm() {}
|
||||
J3DTevKColorAnm() : field_0x0(0), mAnmFlag(1), mAnmTevReg(NULL) {}
|
||||
|
||||
J3DTevKColorAnm(u16 param_1, J3DAnmTevRegKey* pTevRegKey) {
|
||||
field_0x0 = param_1;
|
||||
mAnmFlag = 1;
|
||||
mAnmTevReg = pTevRegKey;
|
||||
J3D_ASSERT_NULLPTR(371, pTevRegKey != NULL);
|
||||
}
|
||||
|
||||
void operator=(J3DTevKColorAnm const& other) {
|
||||
mAnmTevReg = other.mAnmTevReg;
|
||||
field_0x0 = other.field_0x0;
|
||||
mAnmFlag = other.mAnmFlag;
|
||||
}
|
||||
|
||||
void setAnmFlag(bool flag) { mAnmFlag = flag; }
|
||||
bool getAnmFlag() const { return mAnmFlag; }
|
||||
|
||||
void calc(GXColor* pColor) const {
|
||||
J3D_ASSERT_NULLPTR(558, pColor != NULL);
|
||||
mAnmTevReg->getTevKonstReg(field_0x0, pColor);
|
||||
}
|
||||
|
||||
private:
|
||||
/* 0x0 */ u16 field_0x0;
|
||||
/* 0x2 */ u16 mAnmFlag;
|
||||
/* 0x4 */ J3DAnmTevRegKey* mAnmTevReg;
|
||||
}; // Size: 0x8
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMaterialAnm {
|
||||
public:
|
||||
J3DMaterialAnm() { initialize(); }
|
||||
|
||||
void initialize();
|
||||
void setMatColorAnm(int, J3DMatColorAnm*);
|
||||
void setTexMtxAnm(int, J3DTexMtxAnm*);
|
||||
void setTexNoAnm(int, J3DTexNoAnm*);
|
||||
void setTevColorAnm(int, J3DTevColorAnm*);
|
||||
void setTevKColorAnm(int, J3DTevKColorAnm*);
|
||||
|
||||
virtual ~J3DMaterialAnm() {}
|
||||
virtual void calc(J3DMaterial*) const;
|
||||
|
||||
const J3DTexMtxAnm& getTexMtxAnm(int i) const { return mTexMtxAnm[i]; }
|
||||
|
||||
private:
|
||||
/* 0x04 */ J3DMatColorAnm mMatColorAnm[2];
|
||||
/* 0x14 */ J3DTexMtxAnm mTexMtxAnm[8];
|
||||
/* 0x54 */ J3DTexNoAnm mTexNoAnm[8];
|
||||
/* 0xB4 */ J3DTevColorAnm mTevColorAnm[4];
|
||||
/* 0xD4 */ J3DTevKColorAnm mTevKColorAnm[4];
|
||||
}; // Size: 0xF4
|
||||
|
||||
#endif /* J3DMATERIALANM_H */
|
||||
@@ -0,0 +1,62 @@
|
||||
#ifndef J3DMATERIALATTACH_H
|
||||
#define J3DMATERIALATTACH_H
|
||||
|
||||
#include "JSystem/J3DAssert.h"
|
||||
|
||||
class J3DMaterial;
|
||||
class J3DTexture;
|
||||
class J3DAnmColor;
|
||||
class J3DAnmTexPattern;
|
||||
class J3DAnmTextureSRTKey;
|
||||
class J3DAnmTevRegKey;
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMaterialTable {
|
||||
public:
|
||||
void clear();
|
||||
J3DMaterialTable();
|
||||
int removeMatColorAnimator(J3DAnmColor*);
|
||||
int removeTexNoAnimator(J3DAnmTexPattern*);
|
||||
int removeTexMtxAnimator(J3DAnmTextureSRTKey*);
|
||||
int removeTevRegAnimator(J3DAnmTevRegKey*);
|
||||
int createTexMtxForAnimator(J3DAnmTextureSRTKey*);
|
||||
int entryMatColorAnimator(J3DAnmColor*);
|
||||
int entryTexNoAnimator(J3DAnmTexPattern*);
|
||||
int entryTexMtxAnimator(J3DAnmTextureSRTKey*);
|
||||
int entryTevRegAnimator(J3DAnmTevRegKey*);
|
||||
|
||||
virtual ~J3DMaterialTable();
|
||||
|
||||
J3DMaterial* getMaterialNodePointer(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(92, idx < mMaterialNum);
|
||||
return mMaterialNodePointer[idx];
|
||||
}
|
||||
|
||||
J3DTexture* getTexture() const { return mTexture; }
|
||||
JUTNameTab* getTextureName() const { return mTextureName; }
|
||||
|
||||
JUTNameTab* getMaterialName() const { return mMaterialName; }
|
||||
|
||||
u16 getMaterialNum() const { return mMaterialNum; }
|
||||
bool isLocked() const { return field_0x1c == 1; }
|
||||
|
||||
private:
|
||||
friend class J3DModelLoader;
|
||||
friend class J3DModelLoader_v26;
|
||||
friend class J3DModelLoader_v21;
|
||||
|
||||
/* 0x04 */ u16 mMaterialNum;
|
||||
/* 0x06 */ u16 mUniqueMatNum;
|
||||
/* 0x08 */ J3DMaterial** mMaterialNodePointer;
|
||||
/* 0x0C */ JUTNameTab* mMaterialName;
|
||||
/* 0x10 */ J3DMaterial* field_0x10;
|
||||
/* 0x14 */ J3DTexture* mTexture;
|
||||
/* 0x18 */ JUTNameTab* mTextureName;
|
||||
/* 0x1C */ u16 field_0x1c;
|
||||
}; // Size: 0x20
|
||||
|
||||
#endif /* J3DMATERIALATTACH_H */
|
||||
@@ -0,0 +1,128 @@
|
||||
#ifndef J3DMODEL_H
|
||||
#define J3DMODEL_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DSkinDeform.h"
|
||||
#include "JSystem/J3DGraphBase/J3DPacket.h"
|
||||
#include <types.h>
|
||||
|
||||
enum J3DMdlFlag {
|
||||
J3DMdlFlag_None = 0x0,
|
||||
/* 0x00001 */ J3DMdlFlag_Unk1 = 0x1,
|
||||
/* 0x00002 */ J3DMdlFlag_UseDefaultJ3D = 0x2,
|
||||
/* 0x00004 */ J3DMdlFlag_SkinPosCpu = 0x4,
|
||||
/* 0x00008 */ J3DMdlFlag_SkinNrmCpu = 0x8,
|
||||
/* 0x00010 */ J3DMdlFlag_EnableLOD = 0x10,
|
||||
/* 0x20000 */ J3DMdlFlag_UseSharedDL = 0x20000,
|
||||
/* 0x40000 */ J3DMdlFlag_UseSingleDL = 0x40000,
|
||||
/* 0x80000 */ J3DMdlFlag_DifferedDLBuffer = 0x80000,
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DUnkCalc1 {
|
||||
virtual void calc(J3DModel* model);
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DUnkCalc2 {
|
||||
virtual void unk();
|
||||
virtual void calc(J3DModelData* mpModelData);
|
||||
};
|
||||
|
||||
typedef void (*J3DCalcCallBack)(J3DModel*, u32 timing);
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DModel {
|
||||
public:
|
||||
J3DModel() {
|
||||
initialize();
|
||||
}
|
||||
|
||||
J3DModel(J3DModelData* pModelData, u32 mdlFlags, u32 mtxBufferFlag) {
|
||||
initialize();
|
||||
entryModelData(pModelData, mdlFlags, mtxBufferFlag);
|
||||
}
|
||||
|
||||
void initialize();
|
||||
s32 entryModelData(J3DModelData*, u32, u32);
|
||||
s32 createShapePacket(J3DModelData*);
|
||||
s32 createMatPacket(J3DModelData*, u32);
|
||||
s32 newDifferedDisplayList(u32);
|
||||
void lock();
|
||||
void unlock();
|
||||
void diff();
|
||||
s32 setDeformData(J3DDeformData*, u32);
|
||||
s32 setSkinDeform(J3DSkinDeform*, u32);
|
||||
void calcAnmMtx();
|
||||
void calcWeightEnvelopeMtx();
|
||||
void calcNrmMtx();
|
||||
void calcBumpMtx();
|
||||
void calcBBoardMtx();
|
||||
void prepareShapePackets();
|
||||
void ptrToIndex();
|
||||
void makeDL();
|
||||
|
||||
virtual void update();
|
||||
virtual void entry();
|
||||
virtual void calc();
|
||||
virtual void calcMaterial();
|
||||
virtual void calcDiffTexMtx();
|
||||
virtual void viewCalc();
|
||||
virtual ~J3DModel() {}
|
||||
|
||||
J3DModelData* getModelData() { return mModelData; }
|
||||
|
||||
void onFlag(u32 flag) { mFlags |= flag; }
|
||||
void offFlag(u32 flag) { mFlags &= ~flag; }
|
||||
bool checkFlag(u32 flag) const { return (mFlags & flag) ? true : false; }
|
||||
|
||||
bool isCpuSkinningOn() const { return (mFlags & J3DMdlFlag_SkinPosCpu) && (mFlags & J3DMdlFlag_SkinNrmCpu); }
|
||||
|
||||
Mtx& getBaseTRMtx() { return mBaseTransformMtx; }
|
||||
void setBaseTRMtx(Mtx m) { MTXCopy(m, mBaseTransformMtx); }
|
||||
u32 getMtxCalcMode() { return mFlags & (J3DMdlFlag_Unk1 | J3DMdlFlag_UseDefaultJ3D); }
|
||||
J3DVertexBuffer* getVertexBuffer() { return (J3DVertexBuffer*)&mVertexBuffer; }
|
||||
J3DMatPacket* getMatPacket(u16 idx) const { return &mMatPacket[idx]; }
|
||||
J3DShapePacket* getShapePacket(u16 idx) const { return &mShapePacket[idx]; }
|
||||
J3DMtxBuffer* getMtxBuffer() { return mMtxBuffer; }
|
||||
void setScaleFlag(int idx, u8 flag) { mMtxBuffer->setScaleFlag(idx, flag); }
|
||||
Mtx33* getBumpMtxPtr(int idx) { return mMtxBuffer->getBumpMtxPtr(idx); }
|
||||
Mtx33* getNrmMtxPtr() { return mMtxBuffer->getNrmMtxPtr(); }
|
||||
Mtx* getDrawMtxPtr() { return mMtxBuffer->getDrawMtxPtr(); }
|
||||
void setBaseScale(const Vec& scale) { mBaseScale = scale; }
|
||||
void setUserArea(uintptr_t area) { mUserArea = area; }
|
||||
uintptr_t getUserArea() const { return mUserArea; }
|
||||
Vec* getBaseScale() { return &mBaseScale; }
|
||||
void setAnmMtx(int jointNo, Mtx m) { mMtxBuffer->setAnmMtx(jointNo, m); }
|
||||
MtxP getAnmMtx(int jointNo) { return mMtxBuffer->getAnmMtx(jointNo); }
|
||||
MtxP getWeightAnmMtx(int i) { return mMtxBuffer->getWeightAnmMtx(i); }
|
||||
J3DSkinDeform* getSkinDeform() { return mSkinDeform; }
|
||||
|
||||
/* 0x04 */ J3DModelData* mModelData;
|
||||
/* 0x08 */ u32 mFlags;
|
||||
/* 0x0C */ u32 mDiffFlag;
|
||||
/* 0x10 */ J3DCalcCallBack mCalcCallBack;
|
||||
/* 0x14 */ uintptr_t mUserArea;
|
||||
/* 0x18 */ Vec mBaseScale;
|
||||
/* 0x24 */ Mtx mBaseTransformMtx;
|
||||
/* 0x54 */ Mtx mInternalView;
|
||||
/* 0x84 */ J3DMtxBuffer* mMtxBuffer;
|
||||
/* 0x88 */ J3DVertexBuffer mVertexBuffer;
|
||||
/* 0xC0 */ J3DMatPacket* mMatPacket;
|
||||
/* 0xC4 */ J3DShapePacket* mShapePacket;
|
||||
/* 0xC8 */ J3DDeformData* mDeformData;
|
||||
/* 0xCC */ J3DSkinDeform* mSkinDeform;
|
||||
/* 0xD0 */ J3DVtxColorCalc* mVtxColorCalc;
|
||||
/* 0xD4 */ J3DUnkCalc1* mUnkCalc1;
|
||||
/* 0xD8 */ J3DUnkCalc2* mUnkCalc2;
|
||||
};
|
||||
|
||||
#endif /* J3DMODEL_H */
|
||||
@@ -0,0 +1,119 @@
|
||||
#ifndef J3DMODELDATA_H
|
||||
#define J3DMODELDATA_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DJointTree.h"
|
||||
#include "JSystem/J3DGraphAnimator/J3DMaterialAttach.h"
|
||||
#include "JSystem/J3DGraphAnimator/J3DShapeTable.h"
|
||||
#include "JSystem/J3DGraphBase/J3DVertex.h"
|
||||
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DModelData {
|
||||
public:
|
||||
void clear();
|
||||
J3DModelData();
|
||||
s32 newSharedDisplayList(u32);
|
||||
void indexToPtr();
|
||||
void makeSharedDL();
|
||||
void simpleCalcMaterial(u16, Mtx);
|
||||
void syncJ3DSysPointers() const;
|
||||
void syncJ3DSysFlags() const;
|
||||
|
||||
virtual ~J3DModelData() {}
|
||||
|
||||
void simpleCalcMaterial(Mtx mtx) { simpleCalcMaterial(0, mtx); }
|
||||
J3DMaterialTable& getMaterialTable() { return mMaterialTable; }
|
||||
JUTNameTab* getMaterialName() const { return mMaterialTable.getMaterialName(); }
|
||||
J3DVertexData& getVertexData() { return mVertexData; }
|
||||
u16 getShapeNum() const { return mShapeTable.getShapeNum(); }
|
||||
u16 getMaterialNum() const { return mMaterialTable.getMaterialNum(); }
|
||||
u16 getJointNum() const { return mJointTree.getJointNum(); }
|
||||
u16 getDrawMtxNum() const { return mJointTree.getDrawMtxNum(); }
|
||||
J3DMaterial* getMaterialNodePointer(u16 idx) const {
|
||||
return mMaterialTable.getMaterialNodePointer(idx);
|
||||
}
|
||||
u32 getVtxNum() const { return mVertexData.getVtxNum(); }
|
||||
u32 getNrmNum() const { return mVertexData.getNrmNum(); }
|
||||
u8 getDrawMtxFlag(u16 idx) const { return mJointTree.getDrawMtxFlag(idx); }
|
||||
u16 getDrawMtxIndex(u16 idx) const { return mJointTree.getDrawMtxIndex(idx); }
|
||||
J3DDrawMtxData* getDrawMtxData() { return mJointTree.getDrawMtxData(); }
|
||||
J3DShapeTable* getShapeTable() { return &mShapeTable; }
|
||||
J3DShape* getShapeNodePointer(u16 idx) const { return mShapeTable.getShapeNodePointer(idx); }
|
||||
J3DJoint* getJointNodePointer(u16 idx) const { return mJointTree.getJointNodePointer(idx); }
|
||||
J3DJointTree& getJointTree() { return mJointTree; }
|
||||
const J3DModelHierarchy* getHierarchy() const { return mJointTree.getHierarchy(); }
|
||||
void setHierarchy(J3DModelHierarchy* hierarchy) { mJointTree.setHierarchy(hierarchy); }
|
||||
void setBasicMtxCalc(J3DMtxCalc* calc) { mJointTree.setBasicMtxCalc(calc); }
|
||||
JUTNameTab* getJointName() const { return mJointTree.getJointName(); }
|
||||
Mtx& getInvJointMtx(int idx) { return mJointTree.getInvJointMtx(idx); }
|
||||
J3DTexture* getTexture() const { return mMaterialTable.getTexture(); }
|
||||
JUTNameTab* getTextureName() const { return mMaterialTable.getTextureName(); }
|
||||
u16 getWEvlpMtxNum() const { return mJointTree.getWEvlpMtxNum(); }
|
||||
u16* getWEvlpMixMtxIndex() const { return mJointTree.getWEvlpMixMtxIndex(); }
|
||||
f32* getWEvlpMixWeight() const { return mJointTree.getWEvlpMixWeight(); }
|
||||
u8 getWEvlpMixMtxNum(u16 idx) const { return mJointTree.getWEvlpMixMtxNum(idx); }
|
||||
u16* getWEvlpImportantMtxIndex() const { return mJointTree.getWEvlpImportantMtxIndex(); }
|
||||
u32 getModelDataType() const { return mJointTree.getModelDataType(); }
|
||||
void setModelDataType(u32 type) { mJointTree.setModelDataType(type); }
|
||||
void* getVtxPosArray() const { return mVertexData.getVtxPosArray(); }
|
||||
void* getVtxNrmArray() const { return mVertexData.getVtxNrmArray(); }
|
||||
GXColor* getVtxColorArray(u8 idx) const { return mVertexData.getVtxColorArray(idx); }
|
||||
bool checkFlag(u32 flag) const { return (mFlags & flag) ? true : false; }
|
||||
u32 getFlag() const { return mFlags; }
|
||||
void const* getRawData() const { return mpRawData; }
|
||||
bool checkBumpFlag() const { return mbHasBumpArray == 1; }
|
||||
void setBumpFlag(u32 flag) { mbHasBumpArray = flag; }
|
||||
bool checkBBoardFlag() const { return mbHasBillboard == 1; }
|
||||
bool isLocked() { return mMaterialTable.isLocked(); }
|
||||
void entryTexMtxAnimator(J3DAnmTextureSRTKey* anm) { mMaterialTable.entryTexMtxAnimator(anm); }
|
||||
int entryTevRegAnimator(J3DAnmTevRegKey* anm) { return mMaterialTable.entryTevRegAnimator(anm); }
|
||||
void entryTexNoAnimator(J3DAnmTexPattern* anm) { mMaterialTable.entryTexNoAnimator(anm); }
|
||||
int removeTexNoAnimator(J3DAnmTexPattern* anm) {
|
||||
return mMaterialTable.removeTexNoAnimator(anm);
|
||||
}
|
||||
int removeTexMtxAnimator(J3DAnmTextureSRTKey* anm) {
|
||||
return mMaterialTable.removeTexMtxAnimator(anm);
|
||||
}
|
||||
int removeTevRegAnimator(J3DAnmTevRegKey* anm) {
|
||||
return mMaterialTable.removeTevRegAnimator(anm);
|
||||
}
|
||||
int removeMatColorAnimator(J3DAnmColor* anm) {
|
||||
return mMaterialTable.removeMatColorAnimator(anm);
|
||||
}
|
||||
void syncJ3DSys() const {
|
||||
syncJ3DSysFlags();
|
||||
syncJ3DSysPointers();
|
||||
}
|
||||
void makeHierarchy(J3DJoint* joint, J3DModelHierarchy const** hierarchy) {
|
||||
mJointTree.makeHierarchy(joint, hierarchy, &mMaterialTable, &mShapeTable);
|
||||
mShapeTable.initShapeNodes(getDrawMtxData(), &getVertexData());
|
||||
}
|
||||
void show() {
|
||||
mShapeTable.show();
|
||||
}
|
||||
void hide() {
|
||||
mShapeTable.hide();
|
||||
}
|
||||
|
||||
const void* getBinary() {
|
||||
return mpRawData;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class J3DModelLoader;
|
||||
|
||||
/* 0x04 */ void const* mpRawData;
|
||||
/* 0x08 */ u32 mFlags;
|
||||
/* 0x0C */ u16 mbHasBumpArray;
|
||||
/* 0x0E */ u16 mbHasBillboard;
|
||||
/* 0x10 */ J3DJointTree mJointTree;
|
||||
/* 0x58 */ J3DMaterialTable mMaterialTable;
|
||||
/* 0x78 */ J3DShapeTable mShapeTable;
|
||||
/* 0x88 */ J3DVertexData mVertexData;
|
||||
}; // Size: 0xE4
|
||||
|
||||
#endif /* J3DMODELDATA_H */
|
||||
@@ -0,0 +1,89 @@
|
||||
#ifndef J3DMTXBUFFER_H
|
||||
#define J3DMTXBUFFER_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
|
||||
#include "JSystem/J3DGraphBase/J3DEnum.h"
|
||||
|
||||
class J3DModelData;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DMtxBuffer {
|
||||
public:
|
||||
J3DMtxBuffer() { initialize(); }
|
||||
|
||||
void initialize();
|
||||
s32 create(J3DModelData*, u32);
|
||||
J3DError createAnmMtx(J3DModelData*);
|
||||
s32 createWeightEnvelopeMtx(J3DModelData*);
|
||||
s32 setNoUseDrawMtx();
|
||||
s32 createDoubleDrawMtx(J3DModelData*, u32);
|
||||
s32 createBumpMtxArray(J3DModelData*, u32);
|
||||
void calcWeightEnvelopeMtx();
|
||||
void calcDrawMtx(u32, Vec const&, f32 const (&)[3][4]);
|
||||
void calcNrmMtx();
|
||||
void calcBBoardMtx();
|
||||
|
||||
MtxP getAnmMtx(int idx) { return mpAnmMtx[idx]; }
|
||||
void setAnmMtx(int i, Mtx m) { MTXCopy(m, (MtxP)mpAnmMtx[i]); }
|
||||
MtxP getWeightAnmMtx(int idx) { return mpWeightEvlpMtx[idx]; }
|
||||
MtxP getUserAnmMtx(int idx) { return mpUserAnmMtx[idx]; }
|
||||
|
||||
void setScaleFlag(int idx, u8 flag) { mpScaleFlagArr[idx] = flag; }
|
||||
u32* getCurrentViewNoPtr() { return &mCurrentViewNo; }
|
||||
u8* getScaleFlagArray() const { return mpScaleFlagArr; }
|
||||
u8 getScaleFlag(int idx) const { return mpScaleFlagArr[idx]; }
|
||||
u8 getEnvScaleFlag(int idx) const { return mpEvlpScaleFlagArr[idx]; }
|
||||
Mtx** getDrawMtxPtrPtr() { return mpDrawMtxArr[1]; }
|
||||
Mtx* getDrawMtxPtr() { return mpDrawMtxArr[1][mCurrentViewNo]; }
|
||||
Mtx* getDrawMtx(int idx) { return &mpDrawMtxArr[1][mCurrentViewNo][idx]; }
|
||||
Mtx33** getNrmMtxPtrPtr() { return mpNrmMtxArr[1]; }
|
||||
Mtx33* getNrmMtxPtr() { return mpNrmMtxArr[1][mCurrentViewNo]; }
|
||||
Mtx33* getNrmMtx(int idx) { return &mpNrmMtxArr[1][mCurrentViewNo][idx]; }
|
||||
Mtx33*** getBumpMtxPtrPtr() const { return mpBumpMtxArr[1]; }
|
||||
Mtx33* getBumpMtxPtr(int idx) { return mpBumpMtxArr[1][idx][mCurrentViewNo]; }
|
||||
J3DJointTree* getJointTree() const { return mJointTree; }
|
||||
|
||||
void setNrmMtx(int idx, Mtx mtx) {
|
||||
J3DPSMtx33CopyFrom34(mtx, mpNrmMtxArr[1][mCurrentViewNo][idx]);
|
||||
}
|
||||
|
||||
void swapDrawMtx() {
|
||||
Mtx* tmp = mpDrawMtxArr[0][mCurrentViewNo];
|
||||
mpDrawMtxArr[0][mCurrentViewNo] = mpDrawMtxArr[1][mCurrentViewNo];
|
||||
mpDrawMtxArr[1][mCurrentViewNo] = tmp;
|
||||
}
|
||||
|
||||
void swapNrmMtx() {
|
||||
Mtx33* tmp = mpNrmMtxArr[0][mCurrentViewNo];
|
||||
mpNrmMtxArr[0][mCurrentViewNo] = mpNrmMtxArr[1][mCurrentViewNo];
|
||||
mpNrmMtxArr[1][mCurrentViewNo] = tmp;
|
||||
}
|
||||
|
||||
static Mtx sNoUseDrawMtx;
|
||||
static Mtx33 sNoUseNrmMtx;
|
||||
static Mtx* sNoUseDrawMtxPtr;
|
||||
static Mtx33* sNoUseNrmMtxPtr;
|
||||
|
||||
/* 0x00 */ J3DJointTree* mJointTree;
|
||||
/* 0x04 */ u8* mpScaleFlagArr;
|
||||
/* 0x08 */ u8* mpEvlpScaleFlagArr;
|
||||
/* 0x0C */ Mtx* mpAnmMtx;
|
||||
/* 0x10 */ Mtx* mpWeightEvlpMtx;
|
||||
/* 0x14 */ Mtx** mpDrawMtxArr[2];
|
||||
/* 0x1C */ Mtx33** mpNrmMtxArr[2];
|
||||
/* 0x24 */ Mtx33*** mpBumpMtxArr[2];
|
||||
/* 0x2C */ u32 mMtxNum;
|
||||
/* 0x30 */ u32 mCurrentViewNo;
|
||||
/* 0x34 */ Mtx* mpUserAnmMtx;
|
||||
|
||||
public:
|
||||
virtual ~J3DMtxBuffer() {}
|
||||
};
|
||||
|
||||
void J3DCalcViewBaseMtx(f32 (*param_0)[4], Vec const& param_1, f32 const (¶m_2)[3][4],
|
||||
f32 (*param_3)[4]);
|
||||
|
||||
#endif /* J3DMTXBUFFER_H */
|
||||
@@ -0,0 +1,44 @@
|
||||
#ifndef J3DSHAPETABLE_H
|
||||
#define J3DSHAPETABLE_H
|
||||
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
|
||||
class J3DVertexData;
|
||||
struct J3DDrawMtxData;
|
||||
class J3DShape;
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DShapeTable {
|
||||
public:
|
||||
J3DShapeTable() {
|
||||
mShapeNum = 0;
|
||||
mShapeNodePointer = NULL;
|
||||
mShapeName = NULL;
|
||||
}
|
||||
|
||||
void hide();
|
||||
void show();
|
||||
void initShapeNodes(J3DDrawMtxData*, J3DVertexData*);
|
||||
void sortVcdVatCmd();
|
||||
|
||||
virtual ~J3DShapeTable() {}
|
||||
|
||||
u16 getShapeNum() const { return mShapeNum; }
|
||||
J3DShape* getShapeNodePointer(u16 idx) const {
|
||||
J3D_ASSERT_RANGE(85, idx < mShapeNum);
|
||||
return mShapeNodePointer[idx];
|
||||
}
|
||||
|
||||
private:
|
||||
friend class J3DModelLoader;
|
||||
|
||||
/* 0x4 */ u16 mShapeNum;
|
||||
/* 0x8 */ J3DShape** mShapeNodePointer;
|
||||
/* 0xC */ JUTNameTab* mShapeName;
|
||||
}; // Size: 0x10
|
||||
|
||||
#endif /* J3DSHAPETABLE_H */
|
||||
@@ -0,0 +1,116 @@
|
||||
#ifndef J3DSKINDEFORM_H
|
||||
#define J3DSKINDEFORM_H
|
||||
|
||||
#include "JSystem/J3DGraphAnimator/J3DCluster.h"
|
||||
#include "JSystem/J3DGraphAnimator/J3DMtxBuffer.h"
|
||||
#include <types.h>
|
||||
|
||||
class J3DModel;
|
||||
class J3DAnmCluster;
|
||||
class J3DClusterVertex;
|
||||
class JUTNameTab;
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
struct J3DSkinNList {
|
||||
J3DSkinNList();
|
||||
void calcSkin_VtxPosF32(f32 (*)[4], void*, void*);
|
||||
void calcSkin_VtxNrmF32(f32 (*)[4], void*, void*);
|
||||
|
||||
/* 0x00 */ u16* field_0x0;
|
||||
/* 0x04 */ u16* field_0x4;
|
||||
/* 0x08 */ f32* field_0x8;
|
||||
/* 0x0C */ f32* field_0xc;
|
||||
/* 0x10 */ u16 field_0x10;
|
||||
/* 0x12 */ u16 field_0x12;
|
||||
}; // Size: 0x14
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DSkinDeform {
|
||||
public:
|
||||
J3DSkinDeform();
|
||||
void initSkinInfo(J3DModelData*);
|
||||
int initMtxIndexArray(J3DModelData*);
|
||||
void changeFastSkinDL(J3DModelData*);
|
||||
void calcNrmMtx(J3DMtxBuffer*);
|
||||
void transformVtxPosNrm(J3DModelData*);
|
||||
void calcAnmInvJointMtx(J3DMtxBuffer*);
|
||||
void deformFastVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
|
||||
void deformFastVtxNrm_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
|
||||
void deformVtxPos_F32(J3DVertexBuffer*, J3DMtxBuffer*) const;
|
||||
void deformVtxPos_S16(J3DVertexBuffer*, J3DMtxBuffer*) const;
|
||||
void deformVtxNrm_F32(J3DVertexBuffer*) const;
|
||||
void deformVtxNrm_S16(J3DVertexBuffer*) const;
|
||||
void deform(J3DModel*);
|
||||
void setNrmMtx(int i, MtxP mtx) {
|
||||
J3DPSMtx33CopyFrom34(mtx, (Mtx3P)mNrmMtx[i]);
|
||||
}
|
||||
Mtx3P getNrmMtx(int i) { return mNrmMtx[i]; }
|
||||
void onFlag(u32 flag) { mFlags |= flag; }
|
||||
void offFlag(u32 flag) { mFlags &= ~flag; }
|
||||
bool checkFlag(u32 flag) { return mFlags & flag ? true : false; }
|
||||
|
||||
virtual void deform(J3DVertexBuffer*, J3DMtxBuffer*);
|
||||
virtual ~J3DSkinDeform();
|
||||
|
||||
static u16* sWorkArea_WEvlpMixMtx[1024];
|
||||
static f32* sWorkArea_WEvlpMixWeight[1024];
|
||||
static u16 sWorkArea_MtxReg[1024];
|
||||
|
||||
private:
|
||||
/* 0x04 */ u16* mPosData;
|
||||
/* 0x08 */ u16* mNrmData;
|
||||
/* 0x0C */ Mtx* mPosMtx;
|
||||
/* 0x10 */ Mtx33* mNrmMtx;
|
||||
/* 0x14 */ u32 mFlags;
|
||||
/* 0x18 */ u8 field_0x18;
|
||||
/* 0x19 */ u8 field_0x19;
|
||||
/* 0x1C */ int field_0x1c;
|
||||
/* 0x20 */ int field_0x20;
|
||||
/* 0x24 */ J3DSkinNList* mSkinNList;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-j3d
|
||||
*
|
||||
*/
|
||||
class J3DDeformer {
|
||||
public:
|
||||
J3DDeformer(J3DDeformData*);
|
||||
void deform(J3DVertexBuffer*, u16, f32*);
|
||||
void deform(J3DVertexBuffer*, u16);
|
||||
void deform_VtxPosF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
|
||||
void deform_VtxNrmF32(J3DVertexBuffer*, J3DCluster*, J3DClusterKey*, f32*);
|
||||
void normalizeWeight(int, f32*);
|
||||
|
||||
void offFlag(u32 i_flag) { mFlags &= ~i_flag; }
|
||||
bool checkFlag(u32 i_flag) { return mFlags & i_flag ? true : false; }
|
||||
void setAnmCluster(J3DAnmCluster* anm) { mAnmCluster = anm; }
|
||||
void normalize(f32* i_vec) { VECNormalize((Vec*)i_vec, (Vec*)i_vec); }
|
||||
|
||||
/* 0x00 */ J3DDeformData* mDeformData;
|
||||
/* 0x04 */ J3DAnmCluster* mAnmCluster;
|
||||
/* 0x08 */ f32* field_0x8;
|
||||
/* 0x0C */ f32* field_0xc;
|
||||
/* 0x10 */ u32 mFlags;
|
||||
}; // Size: 0x14
|
||||
|
||||
inline void J3DFillZero32B(__REGISTER void* param_0, __REGISTER u32 param_1) {
|
||||
#ifdef __MWERKS__
|
||||
asm {
|
||||
srwi param_1, param_1, 5
|
||||
mtctr param_1
|
||||
lbl_8032D948:
|
||||
dcbz 0, param_0
|
||||
addi param_0, param_0, 0x20
|
||||
bdnz lbl_8032D948
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* J3DSKINDEFORM_H */
|
||||
Reference in New Issue
Block a user