mirror of https://github.com/zeldaret/tp.git
1098 lines
36 KiB
C++
1098 lines
36 KiB
C++
#ifndef J2DMATBLOCK_H
|
|
#define J2DMATBLOCK_H
|
|
|
|
#include "JSystem/J2DGraph/J2DTevs.h"
|
|
#include "JSystem/JUtility/JUTAssert.h"
|
|
#include "JSystem/JUtility/TColor.h"
|
|
|
|
class JUTFont;
|
|
class JUTPalette;
|
|
class JUTResFont;
|
|
class JUTTexture;
|
|
struct ResFONT;
|
|
struct ResTIMG;
|
|
struct ResTLUT;
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
struct J2DGXColorS10 : public GXColorS10 {
|
|
J2DGXColorS10() {}
|
|
|
|
#if PLATFORM_GCN && __MWERKS__
|
|
J2DGXColorS10(J2DGXColorS10& other) {
|
|
r = other.r;
|
|
g = other.g;
|
|
b = other.b;
|
|
a = other.a;
|
|
}
|
|
|
|
J2DGXColorS10(GXColorS10& other) {
|
|
r = other.r;
|
|
g = other.g;
|
|
b = other.b;
|
|
a = other.a;
|
|
}
|
|
#else
|
|
J2DGXColorS10(const J2DGXColorS10& other) {
|
|
r = other.r;
|
|
g = other.g;
|
|
b = other.b;
|
|
a = other.a;
|
|
}
|
|
|
|
J2DGXColorS10(const GXColorS10& other) {
|
|
r = other.r;
|
|
g = other.g;
|
|
b = other.b;
|
|
a = other.a;
|
|
}
|
|
#endif
|
|
|
|
J2DGXColorS10& operator=(const GXColorS10& other) {
|
|
r = other.r;
|
|
g = other.g;
|
|
b = other.b;
|
|
a = other.a;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
struct J2DTevSwapModeInfo;
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock {
|
|
public:
|
|
virtual void initialize() {}
|
|
virtual void setGX() {}
|
|
virtual void loadTexture(_GXTexMapID, u32) {}
|
|
virtual u32 getType() = 0;
|
|
virtual u8 getMaxStage() = 0;
|
|
virtual void setTexNo(u32, u16) {}
|
|
virtual u16 getTexNo(u32) const { return 0xFFFF; }
|
|
virtual void setFontNo(u16) {}
|
|
virtual u16 getFontNo() const { return 0xFFFF; }
|
|
virtual void setTevOrder(u32, J2DTevOrder) {}
|
|
virtual J2DTevOrder* getTevOrder(u32) { return NULL; }
|
|
virtual void setTevColor(u32, J2DGXColorS10) {}
|
|
virtual J2DGXColorS10* getTevColor(u32) { return NULL; }
|
|
virtual void setTevKColor(u32, JUtility::TColor) {}
|
|
virtual JUtility::TColor* getTevKColor(u32) { return NULL; }
|
|
virtual void setTevKColorSel(u32, u8) {}
|
|
virtual u8 getTevKColorSel(u32) { return 0; }
|
|
virtual void setTevKAlphaSel(u32, u8) {}
|
|
virtual u8 getTevKAlphaSel(u32) { return 0; }
|
|
virtual void setTevStageNum(u8) {}
|
|
virtual u8 getTevStageNum() const { return 1; }
|
|
virtual void setTevStage(u32, J2DTevStage) {}
|
|
virtual J2DTevStage* getTevStage(u32) { return NULL; }
|
|
virtual void setTevSwapModeInfo(u32, J2DTevSwapModeInfo) {}
|
|
virtual void setTevSwapModeTable(u32, J2DTevSwapModeTable) {}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32) { return NULL; }
|
|
virtual void setIndTevStage(u32, J2DIndTevStage) {}
|
|
virtual J2DIndTevStage* getIndTevStage(u32) { return NULL; }
|
|
virtual bool insertTexture(u32, ResTIMG const*) { return false; }
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*) { return false; }
|
|
virtual bool insertTexture(u32, JUTTexture*) { return false; }
|
|
virtual bool setTexture(u32, ResTIMG const*) { return false; }
|
|
virtual bool setTexture(u32, JUTTexture*) { return false; }
|
|
virtual bool removeTexture(u32) { return false; }
|
|
virtual bool setFont(ResFONT*) { return false; }
|
|
virtual bool setFont(JUTFont*) { return false; }
|
|
virtual bool setPalette(u32, ResTLUT const*) { return false; }
|
|
virtual bool prepareTexture(u8) { return false; }
|
|
virtual JUTTexture* getTexture(u32);
|
|
virtual JUTPalette* getPalette(u32);
|
|
virtual JUTFont* getFont() { return NULL; }
|
|
virtual void shiftDeleteFlag(u8, bool) {}
|
|
virtual void setUndeleteFlag(u8) {}
|
|
virtual void setFontUndeleteFlag() {}
|
|
virtual ~J2DTevBlock() {}
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock1 : public J2DTevBlock {
|
|
public:
|
|
J2DTevBlock1();
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual void loadTexture(_GXTexMapID, u32);
|
|
virtual u32 getType() { return 'TVB1'; }
|
|
virtual u8 getMaxStage() { return 1; }
|
|
virtual void setTexNo(u32 index, u16 texNo) {
|
|
J3D_PANIC(241, index < 1, "Error : range over.");
|
|
mTexNo[index] = texNo;
|
|
}
|
|
virtual u16 getTexNo(u32 index) const {
|
|
J3D_PANIC(242, index < 1, "Error : range over.");
|
|
return mTexNo[index];
|
|
}
|
|
virtual void setFontNo(u16 fontNo) { mFontNo = fontNo; }
|
|
virtual u16 getFontNo() const { return mFontNo; }
|
|
virtual void setTevOrder(u32 index, J2DTevOrder order) {
|
|
J3D_PANIC(247, index < 1, "Error : range over.");
|
|
mTevOrder[index] = order;
|
|
}
|
|
virtual J2DTevOrder* getTevOrder(u32 index) {
|
|
J3D_PANIC(248, index < 1, "Error : range over.");
|
|
return &mTevOrder[index];
|
|
}
|
|
virtual void setTevColor(u32 index, J2DGXColorS10 color) {
|
|
J3D_PANIC(250, index < 4, "Error : range over.");
|
|
mTevColor[index] = color;
|
|
}
|
|
virtual J2DGXColorS10* getTevColor(u32 index) {
|
|
J3D_PANIC(251, index < 4, "Error : range over.");
|
|
return &mTevColor[index];
|
|
}
|
|
virtual void setTevKColor(u32 index, JUtility::TColor color) {
|
|
J3D_PANIC(253, index < 4, "Error : range over.");
|
|
mTevKColor[index] = color;
|
|
}
|
|
virtual JUtility::TColor* getTevKColor(u32 index) {
|
|
J3D_PANIC(254, index < 4, "Error : range over.");
|
|
return &mTevKColor[index];
|
|
}
|
|
virtual void setTevKColorSel(u32 index, u8 sel) {
|
|
J3D_PANIC(256, index < 1, "Error : range over.");
|
|
mTevKColorSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKColorSel(u32 index) {
|
|
J3D_PANIC(257, index < 1, "Error : range over.");
|
|
return mTevKColorSel[index];
|
|
}
|
|
virtual void setTevKAlphaSel(u32 index, u8 sel) {
|
|
J3D_PANIC(259, index < 1, "Error : range over.");
|
|
mTevKAlphaSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKAlphaSel(u32 index) {
|
|
J3D_PANIC(260, index < 1, "Error : range over.");
|
|
return mTevKAlphaSel[index];
|
|
}
|
|
virtual void setTevStageNum(u8 num) {}
|
|
virtual u8 getTevStageNum() const { return 1; }
|
|
virtual void setTevStage(u32 index, J2DTevStage stage) {
|
|
J3D_PANIC(265, index < 1, "Error : range over.");
|
|
mTevStage[index] = stage;
|
|
}
|
|
virtual J2DTevStage* getTevStage(u32 index) {
|
|
J3D_PANIC(266, index < 1, "Error : range over.");
|
|
return &mTevStage[index];
|
|
}
|
|
virtual void setTevSwapModeInfo(u32 index, J2DTevSwapModeInfo info) {
|
|
J3D_PANIC(268, index < 1, "Error : range over.");
|
|
mTevStage[index].setTevSwapModeInfo(info);
|
|
}
|
|
virtual void setTevSwapModeTable(u32 index, J2DTevSwapModeTable table) {
|
|
J3D_PANIC(270, index < 4, "Error : range over.");
|
|
mTevSwapModeTable[index] = table;
|
|
}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32 index) {
|
|
J3D_PANIC(271, index < 4, "Error : range over.");
|
|
return &mTevSwapModeTable[index];
|
|
}
|
|
virtual void setIndTevStage(u32 index, J2DIndTevStage stage) {
|
|
J3D_PANIC(273, index < 1, "Error : range over.");
|
|
mIndTevStage[index] = stage;
|
|
}
|
|
virtual J2DIndTevStage* getIndTevStage(u32 index) {
|
|
J3D_PANIC(274, index < 1, "Error : range over.");
|
|
return &mIndTevStage[index];
|
|
}
|
|
virtual bool insertTexture(u32 index, ResTIMG const* p_timg) {
|
|
return insertTexture(index, p_timg, NULL);
|
|
}
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*);
|
|
virtual bool insertTexture(u32, JUTTexture*);
|
|
virtual bool setTexture(u32, ResTIMG const*);
|
|
virtual bool setTexture(u32, JUTTexture*);
|
|
virtual bool removeTexture(u32);
|
|
virtual bool setFont(ResFONT*);
|
|
virtual bool setFont(JUTFont*);
|
|
virtual bool setPalette(u32, ResTLUT const*);
|
|
virtual bool prepareTexture(u8);
|
|
virtual JUTTexture* getTexture(u32 index) {
|
|
if (index >= 1) {
|
|
return NULL;
|
|
}
|
|
return mTexture[index];
|
|
}
|
|
virtual JUTPalette* getPalette(u32 index) {
|
|
if (index >= 1) {
|
|
return NULL;
|
|
}
|
|
return mPalette[index];
|
|
}
|
|
virtual JUTFont* getFont() { return mFont; }
|
|
virtual void shiftDeleteFlag(u8, bool);
|
|
virtual void setUndeleteFlag(u8 flag) { mUndeleteFlag = mUndeleteFlag & flag; }
|
|
virtual void setFontUndeleteFlag() { mUndeleteFlag &= 0x7F; }
|
|
virtual ~J2DTevBlock1();
|
|
|
|
private:
|
|
/* 0x004 */ u16 mTexNo[1];
|
|
/* 0x006 */ u16 mFontNo;
|
|
/* 0x008 */ J2DTevOrder mTevOrder[1];
|
|
/* 0x00C */ J2DGXColorS10 mTevColor[4];
|
|
/* 0x02C */ J2DTevStage mTevStage[1];
|
|
/* 0x034 */ JUtility::TColor mTevKColor[4];
|
|
/* 0x044 */ u8 mTevKColorSel[1];
|
|
/* 0x045 */ u8 mTevKAlphaSel[1];
|
|
/* 0x046 */ J2DTevSwapModeTable mTevSwapModeTable[4];
|
|
/* 0x04C */ J2DIndTevStage mIndTevStage[1];
|
|
/* 0x050 */ JUTTexture* mTexture[1];
|
|
/* 0x054 */ JUTPalette* mPalette[1];
|
|
/* 0x058 */ JUTFont* mFont;
|
|
/* 0x05C */ u8 mUndeleteFlag;
|
|
}; // Size: 0x60
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock2 : public J2DTevBlock {
|
|
public:
|
|
J2DTevBlock2();
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual void loadTexture(_GXTexMapID, u32);
|
|
virtual u32 getType() { return 'TVB2'; }
|
|
virtual u8 getMaxStage() { return 2; }
|
|
virtual void setTexNo(u32 index, u16 texNo) {
|
|
J3D_PANIC(351, index < 2, "Error : range over.");
|
|
mTexNo[index] = texNo;
|
|
}
|
|
virtual u16 getTexNo(u32 index) const {
|
|
J3D_PANIC(352, index < 2, "Error : range over.");
|
|
return mTexNo[index];
|
|
}
|
|
virtual void setFontNo(u16 fontNo) { mFontNo = fontNo; }
|
|
virtual u16 getFontNo() const { return mFontNo; }
|
|
virtual void setTevOrder(u32 index, J2DTevOrder order) {
|
|
J3D_PANIC(357, index < 2, "Error : range over.");
|
|
mTevOrder[index] = order;
|
|
}
|
|
virtual J2DTevOrder* getTevOrder(u32 index) {
|
|
J3D_PANIC(358, index < 2, "Error : range over.");
|
|
return &mTevOrder[index];
|
|
}
|
|
virtual void setTevColor(u32 index, J2DGXColorS10 color) {
|
|
J3D_PANIC(360, index < 4, "Error : range over.");
|
|
mTevColor[index] = color;
|
|
}
|
|
virtual J2DGXColorS10* getTevColor(u32 index) {
|
|
J3D_PANIC(361, index < 4, "Error : range over.");
|
|
return &mTevColor[index];
|
|
}
|
|
virtual void setTevKColor(u32 index, JUtility::TColor color) {
|
|
J3D_PANIC(363, index < 4, "Error : range over.");
|
|
mTevKColor[index] = color;
|
|
}
|
|
virtual JUtility::TColor* getTevKColor(u32 index) {
|
|
J3D_PANIC(364, index < 4, "Error : range over.");
|
|
return &mTevKColor[index];
|
|
}
|
|
virtual void setTevKColorSel(u32 index, u8 sel) {
|
|
J3D_PANIC(366, index < 2, "Error : range over.");
|
|
mTevKColorSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKColorSel(u32 index) {
|
|
J3D_PANIC(367, index < 2, "Error : range over.");
|
|
return mTevKColorSel[index];
|
|
}
|
|
virtual void setTevKAlphaSel(u32 index, u8 sel) {
|
|
J3D_PANIC(369, index < 2, "Error : range over.");
|
|
mTevKAlphaSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKAlphaSel(u32 index) {
|
|
J3D_PANIC(370, index < 2, "Error : range over.");
|
|
return mTevKAlphaSel[index];
|
|
}
|
|
virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
|
|
virtual u8 getTevStageNum() const { return mTevStageNum; }
|
|
virtual void setTevStage(u32 index, J2DTevStage stage) {
|
|
J3D_PANIC(375, index < 2, "Error : range over.");
|
|
mTevStage[index] = stage;
|
|
}
|
|
virtual J2DTevStage* getTevStage(u32 index) {
|
|
J3D_PANIC(376, index < 2, "Error : range over.");
|
|
return &mTevStage[index];
|
|
}
|
|
virtual void setTevSwapModeInfo(u32 index, J2DTevSwapModeInfo info) {
|
|
J3D_PANIC(378, index < 2, "Error : range over.");
|
|
mTevStage[index].setTevSwapModeInfo(info);
|
|
}
|
|
virtual void setTevSwapModeTable(u32 index, J2DTevSwapModeTable table) {
|
|
J3D_PANIC(380, index < 4, "Error : range over.");
|
|
mTevSwapModeTable[index] = table;
|
|
}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32 index) {
|
|
J3D_PANIC(381, index < 4, "Error : range over.");
|
|
return &mTevSwapModeTable[index];
|
|
}
|
|
virtual void setIndTevStage(u32 index, J2DIndTevStage stage) {
|
|
J3D_PANIC(383, index < 2, "Error : range over.");
|
|
mIndTevStage[index] = stage;
|
|
}
|
|
virtual J2DIndTevStage* getIndTevStage(u32 index) {
|
|
J3D_PANIC(384, index < 2, "Error : range over.");
|
|
return &mIndTevStage[index];
|
|
}
|
|
virtual bool insertTexture(u32 index, ResTIMG const* p_timg) {
|
|
return insertTexture(index, p_timg, NULL);
|
|
}
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*);
|
|
virtual bool insertTexture(u32, JUTTexture*);
|
|
virtual bool setTexture(u32, ResTIMG const*);
|
|
virtual bool setTexture(u32, JUTTexture*);
|
|
virtual bool removeTexture(u32);
|
|
virtual bool setFont(ResFONT*);
|
|
virtual bool setFont(JUTFont*);
|
|
virtual bool setPalette(u32, ResTLUT const*);
|
|
virtual bool prepareTexture(u8);
|
|
virtual JUTTexture* getTexture(u32 index) {
|
|
if (index >= 2) {
|
|
return NULL;
|
|
}
|
|
return mTexture[index];
|
|
}
|
|
virtual JUTPalette* getPalette(u32 index) {
|
|
if (index >= 2) {
|
|
return NULL;
|
|
}
|
|
return mPalette[index];
|
|
}
|
|
virtual JUTFont* getFont() { return mFont; }
|
|
virtual void shiftDeleteFlag(u8, bool);
|
|
virtual void setUndeleteFlag(u8 flag) { mUndeleteFlag = mUndeleteFlag & flag; }
|
|
virtual void setFontUndeleteFlag() { mUndeleteFlag &= 0x7F; }
|
|
virtual ~J2DTevBlock2();
|
|
|
|
private:
|
|
/* 0x004 */ u16 mTexNo[2];
|
|
/* 0x008 */ u16 mFontNo;
|
|
/* 0x00A */ J2DTevOrder mTevOrder[2];
|
|
/* 0x012 */ J2DGXColorS10 mTevColor[4];
|
|
/* 0x032 */ u8 mTevStageNum;
|
|
/* 0x033 */ J2DTevStage mTevStage[2];
|
|
/* 0x043 */ u8 field_0x43;
|
|
/* 0x044 */ JUtility::TColor mTevKColor[4];
|
|
/* 0x054 */ u8 mTevKColorSel[2];
|
|
/* 0x056 */ u8 mTevKAlphaSel[2];
|
|
/* 0x058 */ J2DTevSwapModeTable mTevSwapModeTable[4];
|
|
/* 0x05C */ J2DIndTevStage mIndTevStage[2];
|
|
/* 0x064 */ JUTTexture* mTexture[2];
|
|
/* 0x06C */ JUTPalette* mPalette[2];
|
|
/* 0x074 */ JUTFont* mFont;
|
|
/* 0x078 */ u8 mUndeleteFlag;
|
|
}; // Size: 0x7C
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock4 : public J2DTevBlock {
|
|
public:
|
|
J2DTevBlock4();
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual void loadTexture(_GXTexMapID, u32);
|
|
virtual u32 getType() { return 'TVB4'; }
|
|
virtual u8 getMaxStage() { return 4; }
|
|
virtual void setTexNo(u32 index, u16 texNo) {
|
|
J3D_PANIC(459, index < 4, "Error : range over.");
|
|
mTexNo[index] = texNo;
|
|
}
|
|
virtual u16 getTexNo(u32 index) const {
|
|
J3D_PANIC(460, index < 4, "Error : range over.");
|
|
return mTexNo[index];
|
|
}
|
|
virtual void setFontNo(u16 fontNo) { mFontNo = fontNo; }
|
|
virtual u16 getFontNo() const { return mFontNo; }
|
|
virtual void setTevOrder(u32 index, J2DTevOrder order) {
|
|
J3D_PANIC(465, index < 4, "Error : range over.");
|
|
mTevOrder[index] = order;
|
|
}
|
|
virtual J2DTevOrder* getTevOrder(u32 index) {
|
|
J3D_PANIC(466, index < 4, "Error : range over.");
|
|
return &mTevOrder[index];
|
|
}
|
|
virtual void setTevColor(u32 index, J2DGXColorS10 color) {
|
|
J3D_PANIC(468, index < 4, "Error : range over.");
|
|
mTevColor[index] = color;
|
|
}
|
|
virtual J2DGXColorS10* getTevColor(u32 index) {
|
|
J3D_PANIC(469, index < 4, "Error : range over.");
|
|
return &mTevColor[index];
|
|
}
|
|
virtual void setTevKColor(u32 index, JUtility::TColor color) {
|
|
J3D_PANIC(471, index < 4, "Error : range over.");
|
|
mTevKColor[index] = color;
|
|
}
|
|
virtual JUtility::TColor* getTevKColor(u32 index) {
|
|
J3D_PANIC(472, index < 4, "Error : range over.");
|
|
return &mTevKColor[index];
|
|
}
|
|
virtual void setTevKColorSel(u32 index, u8 sel) {
|
|
J3D_PANIC(474, index < 4, "Error : range over.");
|
|
mTevKColorSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKColorSel(u32 index) {
|
|
J3D_PANIC(475, index < 4, "Error : range over.");
|
|
return mTevKColorSel[index];
|
|
}
|
|
virtual void setTevKAlphaSel(u32 index, u8 sel) {
|
|
J3D_PANIC(477, index < 4, "Error : range over.");
|
|
mTevKAlphaSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKAlphaSel(u32 index) {
|
|
J3D_PANIC(478, index < 4, "Error : range over.");
|
|
return mTevKAlphaSel[index];
|
|
}
|
|
virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
|
|
virtual u8 getTevStageNum() const { return mTevStageNum; }
|
|
virtual void setTevStage(u32 index, J2DTevStage stage) {
|
|
J3D_PANIC(483, index < 4, "Error : range over.");
|
|
mTevStage[index] = stage;
|
|
}
|
|
virtual J2DTevStage* getTevStage(u32 index) {
|
|
J3D_PANIC(484, index < 4, "Error : range over.");
|
|
return &mTevStage[index];
|
|
}
|
|
virtual void setTevSwapModeInfo(u32 index, J2DTevSwapModeInfo info) {
|
|
J3D_PANIC(486, index < 4, "Error : range over.");
|
|
mTevStage[index].setTevSwapModeInfo(info);
|
|
}
|
|
virtual void setTevSwapModeTable(u32 index, J2DTevSwapModeTable table) {
|
|
J3D_PANIC(488, index < 4, "Error : range over.");
|
|
mTevSwapModeTable[index] = table;
|
|
}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32 index) {
|
|
J3D_PANIC(489, index < 4, "Error : range over.");
|
|
return &mTevSwapModeTable[index];
|
|
}
|
|
virtual void setIndTevStage(u32 index, J2DIndTevStage stage) {
|
|
J3D_PANIC(491, index < 4, "Error : range over.");
|
|
mIndTevStage[index] = stage;
|
|
}
|
|
virtual J2DIndTevStage* getIndTevStage(u32 index) {
|
|
J3D_PANIC(492, index < 4, "Error : range over.");
|
|
return &mIndTevStage[index];
|
|
}
|
|
virtual bool insertTexture(u32 index, ResTIMG const* p_timg) {
|
|
return insertTexture(index, p_timg, NULL);
|
|
}
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*);
|
|
virtual bool insertTexture(u32, JUTTexture*);
|
|
virtual bool setTexture(u32, ResTIMG const*);
|
|
virtual bool setTexture(u32, JUTTexture*);
|
|
virtual bool removeTexture(u32);
|
|
virtual bool setFont(ResFONT*);
|
|
virtual bool setFont(JUTFont*);
|
|
virtual bool setPalette(u32, ResTLUT const*);
|
|
virtual bool prepareTexture(u8);
|
|
virtual JUTTexture* getTexture(u32 index) {
|
|
if (index >= 4) {
|
|
return NULL;
|
|
}
|
|
return mTexture[index];
|
|
}
|
|
virtual JUTPalette* getPalette(u32 index) {
|
|
if (index >= 4) {
|
|
return NULL;
|
|
}
|
|
return mPalette[index];
|
|
}
|
|
virtual JUTFont* getFont() { return mFont; }
|
|
virtual void shiftDeleteFlag(u8, bool);
|
|
virtual void setUndeleteFlag(u8 flag) { mUndeleteFlag = mUndeleteFlag & flag; }
|
|
virtual void setFontUndeleteFlag() { mUndeleteFlag &= 0x7F; }
|
|
virtual ~J2DTevBlock4();
|
|
|
|
private:
|
|
/* 0x004 */ u16 mTexNo[4];
|
|
/* 0x00C */ u16 mFontNo;
|
|
/* 0x00E */ J2DTevOrder mTevOrder[4];
|
|
/* 0x01E */ J2DGXColorS10 mTevColor[4];
|
|
/* 0x03E */ u8 mTevStageNum;
|
|
/* 0x03F */ J2DTevStage mTevStage[4];
|
|
/* 0x05F */ u8 field_0x5f;
|
|
/* 0x060 */ JUtility::TColor mTevKColor[4];
|
|
/* 0x070 */ u8 mTevKColorSel[4];
|
|
/* 0x074 */ u8 mTevKAlphaSel[4];
|
|
/* 0x078 */ J2DTevSwapModeTable mTevSwapModeTable[4];
|
|
/* 0x07C */ J2DIndTevStage mIndTevStage[4];
|
|
/* 0x08C */ JUTTexture* mTexture[4];
|
|
/* 0x09C */ JUTPalette* mPalette[4];
|
|
/* 0x0AC */ JUTFont* mFont;
|
|
/* 0x0B0 */ u8 mUndeleteFlag;
|
|
}; // Size: 0xB4
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock8 : public J2DTevBlock {
|
|
public:
|
|
J2DTevBlock8();
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual void loadTexture(_GXTexMapID, u32);
|
|
virtual u32 getType() { return 'TVB8'; }
|
|
virtual u8 getMaxStage() { return 8; }
|
|
virtual void setTexNo(u32 index, u16 texNo) {
|
|
J3D_PANIC(570, index < 8, "Error : range over.");
|
|
mTexNo[index] = texNo;
|
|
}
|
|
virtual u16 getTexNo(u32 index) const {
|
|
J3D_PANIC(571, index < 8, "Error : range over.");
|
|
return mTexNo[index];
|
|
}
|
|
virtual void setFontNo(u16 fontNo) { mFontNo = fontNo; }
|
|
virtual u16 getFontNo() const { return mFontNo; }
|
|
virtual void setTevOrder(u32 index, J2DTevOrder order) {
|
|
J3D_PANIC(576, index < 8, "Error : range over.");
|
|
mTevOrder[index] = order;
|
|
}
|
|
virtual J2DTevOrder* getTevOrder(u32 index) {
|
|
J3D_PANIC(577, index < 8, "Error : range over.");
|
|
return &mTevOrder[index];
|
|
}
|
|
virtual void setTevColor(u32 index, J2DGXColorS10 color) {
|
|
J3D_PANIC(579, index < 4, "Error : range over.");
|
|
mTevColor[index] = color;
|
|
}
|
|
virtual J2DGXColorS10* getTevColor(u32 index) {
|
|
J3D_PANIC(580, index < 4, "Error : range over.");
|
|
return &mTevColor[index];
|
|
}
|
|
virtual void setTevKColor(u32 index, JUtility::TColor color) {
|
|
J3D_PANIC(582, index < 4, "Error : range over.");
|
|
mTevKColor[index] = color;
|
|
}
|
|
virtual JUtility::TColor* getTevKColor(u32 index) {
|
|
J3D_PANIC(583, index < 4, "Error : range over.");
|
|
return &mTevKColor[index];
|
|
}
|
|
virtual void setTevKColorSel(u32 index, u8 sel) {
|
|
J3D_PANIC(585, index < 8, "Error : range over.");
|
|
mTevKColorSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKColorSel(u32 index) {
|
|
J3D_PANIC(586, index < 8, "Error : range over.");
|
|
return mTevKColorSel[index];
|
|
}
|
|
virtual void setTevKAlphaSel(u32 index, u8 sel) {
|
|
J3D_PANIC(588, index < 8, "Error : range over.");
|
|
mTevKAlphaSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKAlphaSel(u32 index) {
|
|
J3D_PANIC(589, index < 8, "Error : range over.");
|
|
return mTevKAlphaSel[index];
|
|
}
|
|
virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
|
|
virtual u8 getTevStageNum() const { return mTevStageNum; }
|
|
virtual void setTevStage(u32 index, J2DTevStage stage) {
|
|
J3D_PANIC(594, index < 8, "Error : range over.");
|
|
mTevStage[index] = stage;
|
|
}
|
|
virtual J2DTevStage* getTevStage(u32 index) {
|
|
J3D_PANIC(595, index < 8, "Error : range over.");
|
|
return &mTevStage[index];
|
|
}
|
|
virtual void setTevSwapModeInfo(u32 index, J2DTevSwapModeInfo info) {
|
|
J3D_PANIC(597, index < 8, "Error : range over.");
|
|
mTevStage[index].setTevSwapModeInfo(info);
|
|
}
|
|
virtual void setTevSwapModeTable(u32 index, J2DTevSwapModeTable table) {
|
|
J3D_PANIC(599, index < 4, "Error : range over.");
|
|
mTevSwapModeTable[index] = table;
|
|
}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32 index) {
|
|
J3D_PANIC(600, index < 4, "Error : range over.");
|
|
return &mTevSwapModeTable[index];
|
|
}
|
|
virtual void setIndTevStage(u32 index, J2DIndTevStage stage) {
|
|
J3D_PANIC(602, index < 8, "Error : range over.");
|
|
mIndTevStage[index] = stage;
|
|
}
|
|
virtual J2DIndTevStage* getIndTevStage(u32 index) {
|
|
J3D_PANIC(603, index < 8, "Error : range over.");
|
|
return &mIndTevStage[index];
|
|
}
|
|
virtual bool insertTexture(u32 index, ResTIMG const* p_timg) {
|
|
return insertTexture(index, p_timg, NULL);
|
|
}
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*);
|
|
virtual bool insertTexture(u32, JUTTexture*);
|
|
virtual bool setTexture(u32, ResTIMG const*);
|
|
virtual bool setTexture(u32, JUTTexture*);
|
|
virtual bool removeTexture(u32);
|
|
virtual bool setFont(ResFONT*);
|
|
virtual bool setFont(JUTFont*);
|
|
virtual bool setPalette(u32, ResTLUT const*);
|
|
virtual bool prepareTexture(u8);
|
|
virtual JUTTexture* getTexture(u32 index) {
|
|
if (index >= 8) {
|
|
return NULL;
|
|
}
|
|
return mTexture[index];
|
|
}
|
|
virtual JUTPalette* getPalette(u32 index) {
|
|
if (index >= 8) {
|
|
return NULL;
|
|
}
|
|
return mPalette[index];
|
|
}
|
|
virtual JUTFont* getFont() { return mFont; }
|
|
virtual void shiftDeleteFlag(u8, bool);
|
|
virtual void setUndeleteFlag(u8 flag) { mUndeleteFlag = mUndeleteFlag & flag; }
|
|
virtual void setFontUndeleteFlag() { mFontUndeleteFlag = false; }
|
|
virtual ~J2DTevBlock8();
|
|
|
|
private:
|
|
/* 0x004 */ u16 mTexNo[8];
|
|
/* 0x014 */ u16 mFontNo;
|
|
/* 0x016 */ J2DTevOrder mTevOrder[8];
|
|
/* 0x036 */ J2DGXColorS10 mTevColor[4];
|
|
/* 0x056 */ u8 mTevStageNum;
|
|
/* 0x057 */ J2DTevStage mTevStage[8];
|
|
/* 0x097 */ u8 field_0x97;
|
|
/* 0x098 */ JUtility::TColor mTevKColor[4];
|
|
/* 0x0A8 */ u8 mTevKColorSel[8];
|
|
/* 0x0B0 */ u8 mTevKAlphaSel[8];
|
|
/* 0x0B8 */ J2DTevSwapModeTable mTevSwapModeTable[4];
|
|
/* 0x0BC */ J2DIndTevStage mIndTevStage[8];
|
|
/* 0x0DC */ JUTTexture* mTexture[8];
|
|
/* 0x0FC */ JUTPalette* mPalette[8];
|
|
/* 0x11C */ JUTFont* mFont;
|
|
/* 0x120 */ u8 mUndeleteFlag;
|
|
/* 0x121 */ bool mFontUndeleteFlag;
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTevBlock16 : public J2DTevBlock {
|
|
public:
|
|
J2DTevBlock16();
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual void loadTexture(_GXTexMapID, u32);
|
|
virtual u32 getType() { return 'TV16'; }
|
|
virtual u8 getMaxStage() { return 16; }
|
|
virtual void setTexNo(u32 index, u16 texNo) {
|
|
J3D_PANIC(682, index < 8, "Error : range over.");
|
|
mTexNo[index] = texNo;
|
|
}
|
|
virtual u16 getTexNo(u32 index) const {
|
|
J3D_PANIC(683, index < 8, "Error : range over.");
|
|
return mTexNo[index];
|
|
}
|
|
virtual void setFontNo(u16 fontNo) { mFontNo = fontNo; }
|
|
virtual u16 getFontNo() const { return mFontNo; }
|
|
virtual void setTevOrder(u32 index, J2DTevOrder order) {
|
|
J3D_PANIC(688, index < 16, "Error : range over.");
|
|
mTevOrder[index] = order;
|
|
}
|
|
virtual J2DTevOrder* getTevOrder(u32 index) {
|
|
J3D_PANIC(689, index < 16, "Error : range over.");
|
|
return &mTevOrder[index];
|
|
}
|
|
virtual void setTevColor(u32 index, J2DGXColorS10 color) {
|
|
J3D_PANIC(691, index < 4, "Error : range over.");
|
|
mTevColor[index] = color;
|
|
}
|
|
virtual J2DGXColorS10* getTevColor(u32 index) {
|
|
J3D_PANIC(692, index < 4, "Error : range over.");
|
|
return &mTevColor[index];
|
|
}
|
|
virtual void setTevKColor(u32 index, JUtility::TColor color) {
|
|
J3D_PANIC(694, index < 4, "Error : range over.");
|
|
mTevKColor[index] = color;
|
|
}
|
|
virtual JUtility::TColor* getTevKColor(u32 index) {
|
|
J3D_PANIC(695, index < 4, "Error : range over.");
|
|
return &mTevKColor[index];
|
|
}
|
|
virtual void setTevKColorSel(u32 index, u8 sel) {
|
|
J3D_PANIC(697, index < 16, "Error : range over.");
|
|
mTevKColorSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKColorSel(u32 index) {
|
|
J3D_PANIC(698, index < 16, "Error : range over.");
|
|
return mTevKColorSel[index];
|
|
}
|
|
virtual void setTevKAlphaSel(u32 index, u8 sel) {
|
|
J3D_PANIC(700, index < 16, "Error : range over.");
|
|
mTevKAlphaSel[index] = sel;
|
|
}
|
|
virtual u8 getTevKAlphaSel(u32 index) {
|
|
J3D_PANIC(701, index < 16, "Error : range over.");
|
|
return mTevKAlphaSel[index];
|
|
}
|
|
virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
|
|
virtual u8 getTevStageNum() const { return mTevStageNum; }
|
|
virtual void setTevStage(u32 index, J2DTevStage stage) {
|
|
J3D_PANIC(706, index < 16, "Error : range over.");
|
|
mTevStage[index] = stage;
|
|
}
|
|
virtual J2DTevStage* getTevStage(u32 index) {
|
|
J3D_PANIC(707, index < 16, "Error : range over.");
|
|
return &mTevStage[index];
|
|
}
|
|
virtual void setTevSwapModeInfo(u32 index, J2DTevSwapModeInfo info) {
|
|
J3D_PANIC(709, index < 16, "Error : range over.");
|
|
mTevStage[index].setTevSwapModeInfo(info);
|
|
}
|
|
virtual void setTevSwapModeTable(u32 index, J2DTevSwapModeTable table) {
|
|
J3D_PANIC(711, index < 4, "Error : range over.");
|
|
mTevSwapModeTable[index] = table;
|
|
}
|
|
virtual J2DTevSwapModeTable* getTevSwapModeTable(u32 index) {
|
|
J3D_PANIC(712, index < 4, "Error : range over.");
|
|
return &mTevSwapModeTable[index];
|
|
}
|
|
virtual void setIndTevStage(u32 index, J2DIndTevStage stage) {
|
|
J3D_PANIC(714, index < 16, "Error : range over.");
|
|
mIndTevStage[index] = stage;
|
|
}
|
|
virtual J2DIndTevStage* getIndTevStage(u32 index) {
|
|
J3D_PANIC(715, index < 16, "Error : range over.");
|
|
return &mIndTevStage[index];
|
|
}
|
|
virtual bool insertTexture(u32 index, ResTIMG const* p_timg) {
|
|
return insertTexture(index, p_timg, NULL);
|
|
}
|
|
virtual bool insertTexture(u32, ResTIMG const*, JUTPalette*);
|
|
virtual bool insertTexture(u32, JUTTexture*);
|
|
virtual bool setTexture(u32, ResTIMG const*);
|
|
virtual bool setTexture(u32, JUTTexture*);
|
|
virtual bool removeTexture(u32);
|
|
virtual bool setFont(ResFONT*);
|
|
virtual bool setFont(JUTFont*);
|
|
virtual bool setPalette(u32, ResTLUT const*);
|
|
virtual bool prepareTexture(u8);
|
|
virtual JUTTexture* getTexture(u32 index) {
|
|
if (index >= 8) {
|
|
return NULL;
|
|
}
|
|
return mTexture[index];
|
|
}
|
|
virtual JUTPalette* getPalette(u32 index) {
|
|
if (index >= 8) {
|
|
return NULL;
|
|
}
|
|
return mPalette[index];
|
|
}
|
|
virtual JUTFont* getFont() { return mFont; }
|
|
virtual void shiftDeleteFlag(u8, bool);
|
|
virtual void setUndeleteFlag(u8 flag) { mUndeleteFlag = mUndeleteFlag & flag; }
|
|
virtual void setFontUndeleteFlag() { mFontUndeleteFlag = false; }
|
|
virtual ~J2DTevBlock16();
|
|
|
|
public:
|
|
/* 0x004 */ u16 mTexNo[8];
|
|
/* 0x014 */ u16 mFontNo;
|
|
/* 0x016 */ J2DTevOrder mTevOrder[16];
|
|
/* 0x056 */ J2DGXColorS10 mTevColor[4];
|
|
/* 0x076 */ u8 mTevStageNum;
|
|
/* 0x077 */ J2DTevStage mTevStage[16];
|
|
/* 0x0F7 */ u8 field_0xf7;
|
|
/* 0x0F8 */ JUtility::TColor mTevKColor[4];
|
|
/* 0x108 */ u8 mTevKColorSel[16];
|
|
/* 0x118 */ u8 mTevKAlphaSel[16];
|
|
/* 0x128 */ J2DTevSwapModeTable mTevSwapModeTable[4];
|
|
/* 0x12C */ J2DIndTevStage mIndTevStage[16];
|
|
/* 0x16C */ JUTTexture* mTexture[8];
|
|
/* 0x18C */ JUTPalette* mPalette[8];
|
|
/* 0x1AC */ JUTFont* mFont;
|
|
/* 0x1B0 */ u8 mUndeleteFlag;
|
|
/* 0x1B1 */ bool mFontUndeleteFlag;
|
|
}; // Size: 0x1B4
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
struct J2DAlphaCompInfo {
|
|
/* 0x0 */ u8 field_0x0;
|
|
/* 0x1 */ u8 field_0x1;
|
|
/* 0x2 */ u8 mRef0;
|
|
/* 0x3 */ u8 mRef1;
|
|
/* 0x4 */ u8 field_0x4;
|
|
/* 0x5 */ u8 field_0x5;
|
|
/* 0x6 */ u8 field_0x6;
|
|
/* 0x7 */ u8 field_0x7;
|
|
};
|
|
|
|
inline u16 J2DCalcAlphaCmp(u8 param_1, u8 param_2, u8 param_3) {
|
|
return (param_1 << 5) | (param_2 << 3) | param_3;
|
|
}
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
struct J2DAlphaComp {
|
|
J2DAlphaComp() {
|
|
mAlphaCmp = j2dDefaultAlphaCmp;
|
|
mRef0 = 0;
|
|
mRef1 = 0;
|
|
}
|
|
J2DAlphaComp(const J2DAlphaCompInfo& info) {
|
|
mAlphaCmp = J2DCalcAlphaCmp(info.field_0x0, info.mRef0, info.mRef1);
|
|
mRef0 = info.field_0x1;
|
|
mRef1 = info.field_0x4;
|
|
}
|
|
void operator=(const J2DAlphaComp& other) {
|
|
mAlphaCmp = other.mAlphaCmp;
|
|
mRef0 = other.mRef0;
|
|
mRef1 = other.mRef1;
|
|
}
|
|
u8 getComp0() const { return mAlphaCmp >> 5 & 7; }
|
|
u8 getRef0() const { return mRef0; }
|
|
u8 getOp() const { return mAlphaCmp >> 3 & 3; }
|
|
u8 getComp1() const { return mAlphaCmp & 7; }
|
|
u8 getRef1() const { return mRef1; }
|
|
|
|
/* 0x0 */ u16 mAlphaCmp;
|
|
/* 0x2 */ u8 mRef0;
|
|
/* 0x3 */ u8 mRef1;
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
struct J2DBlendInfo {
|
|
void operator=(J2DBlendInfo const& other) {
|
|
mType = other.mType;
|
|
mSrcFactor = other.mSrcFactor;
|
|
mDstFactor = other.mDstFactor;
|
|
mOp = other.mOp;
|
|
}
|
|
|
|
/* 0x0 */ u8 mType;
|
|
/* 0x1 */ u8 mSrcFactor;
|
|
/* 0x2 */ u8 mDstFactor;
|
|
/* 0x3 */ u8 mOp;
|
|
};
|
|
|
|
extern const J2DBlendInfo j2dDefaultBlendInfo;
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
struct J2DBlend {
|
|
J2DBlend() { mBlendInfo = j2dDefaultBlendInfo; }
|
|
J2DBlend(const J2DBlendInfo& info) { mBlendInfo = info; }
|
|
void setBlendInfo(const J2DBlendInfo& info) { mBlendInfo = info; }
|
|
u8 getType() const { return mBlendInfo.mType; }
|
|
u8 getSrcFactor() const { return mBlendInfo.mSrcFactor; }
|
|
u8 getDstFactor() const { return mBlendInfo.mDstFactor; }
|
|
u8 getOp() const { return mBlendInfo.mOp; }
|
|
|
|
/* 0x0 */ J2DBlendInfo mBlendInfo;
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DPEBlock {
|
|
public:
|
|
J2DPEBlock() { initialize(); }
|
|
~J2DPEBlock() {}
|
|
|
|
void initialize();
|
|
void setGX();
|
|
void setAlphaComp(J2DAlphaComp comp) { mAlphaComp = comp; }
|
|
void setBlend(J2DBlend blend) { mBlend = blend; }
|
|
void setDither(u8 dither) { mDither = dither; }
|
|
|
|
private:
|
|
/* 0x0 */ J2DAlphaComp mAlphaComp;
|
|
/* 0x4 */ J2DBlend mBlend;
|
|
/* 0x8 */ u8 mDither;
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DIndBlock {
|
|
public:
|
|
virtual void initialize() {}
|
|
virtual void setGX() {}
|
|
virtual u32 getType() = 0;
|
|
virtual void setIndTexStageNum(u8) {}
|
|
virtual u8 getIndTexStageNum() const { return 0; }
|
|
virtual void setIndTexOrder(u32, J2DIndTexOrder) {}
|
|
virtual J2DIndTexOrder* getIndTexOrder(u32) { return NULL; }
|
|
virtual void setIndTexMtx(u32, J2DIndTexMtx) {}
|
|
virtual J2DIndTexMtx* getIndTexMtx(u32) { return NULL; }
|
|
virtual void setIndTexCoordScale(u32, J2DIndTexCoordScale) {}
|
|
virtual J2DIndTexCoordScale* getIndTexCoordScale(u32) { return NULL; }
|
|
virtual ~J2DIndBlock() {}
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DIndBlockFull : public J2DIndBlock {
|
|
public:
|
|
J2DIndBlockFull() { initialize(); }
|
|
|
|
virtual void initialize();
|
|
virtual void setGX();
|
|
virtual u32 getType() { return 'IBLF'; }
|
|
virtual void setIndTexStageNum(u8 num) { mIndTexStageNum = num; }
|
|
virtual u8 getIndTexStageNum() const { return mIndTexStageNum; }
|
|
virtual void setIndTexOrder(u32 index, J2DIndTexOrder order) {
|
|
J3D_PANIC(856, index < 4, "Error : range over.");
|
|
mIndTexOrder[index] = order;
|
|
}
|
|
virtual J2DIndTexOrder* getIndTexOrder(u32 index) {
|
|
J3D_PANIC(857, index < 4, "Error : range over.");
|
|
return &mIndTexOrder[index];
|
|
}
|
|
virtual void setIndTexMtx(u32 index, J2DIndTexMtx mtx) {
|
|
J3D_PANIC(859, index < 3, "Error : range over.");
|
|
mIndTexMtx[index] = mtx;
|
|
}
|
|
virtual J2DIndTexMtx* getIndTexMtx(u32 index) {
|
|
J3D_PANIC(860, index < 3, "Error : range over.");
|
|
return &mIndTexMtx[index];
|
|
}
|
|
virtual void setIndTexCoordScale(u32 index, J2DIndTexCoordScale scale) {
|
|
J3D_PANIC(862, index < 4, "Error : range over.");
|
|
mTexCoordScale[index] = scale;
|
|
}
|
|
virtual J2DIndTexCoordScale* getIndTexCoordScale(u32 index) {
|
|
J3D_PANIC(863, index < 4, "Error : range over.");
|
|
return &mTexCoordScale[index];
|
|
}
|
|
virtual ~J2DIndBlockFull() {}
|
|
|
|
private:
|
|
/* 0x04 */ u8 mIndTexStageNum;
|
|
/* 0x05 */ J2DIndTexOrder mIndTexOrder[4];
|
|
/* 0x10 */ J2DIndTexMtx mIndTexMtx[3];
|
|
/* 0x64 */ J2DIndTexCoordScale mTexCoordScale[4];
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DIndBlockNull : public J2DIndBlock {
|
|
public:
|
|
J2DIndBlockNull() {}
|
|
|
|
virtual void setGX() {}
|
|
virtual u32 getType() { return 'IBLN'; }
|
|
virtual ~J2DIndBlockNull() {}
|
|
};
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DTexGenBlock {
|
|
private:
|
|
/* 0x00 */ u32 mTexGenNum;
|
|
/* 0x04 */ J2DTexCoord mTexGenCoord[8];
|
|
/* 0x24 */ J2DTexMtx* mTexMtx[8];
|
|
|
|
public:
|
|
J2DTexGenBlock() { initialize(); }
|
|
|
|
void initialize();
|
|
void setGX();
|
|
void setTexMtx(u32, J2DTexMtx&);
|
|
void getTexMtx(u32, J2DTexMtx&);
|
|
|
|
u32 getTexGenNum() const { return mTexGenNum; }
|
|
void setTexGenNum(u32 num) { mTexGenNum = num; }
|
|
void setTexCoord(u32 i, J2DTexCoord coord) {
|
|
J3D_PANIC(101, i < 8, "Error : range over.");
|
|
mTexGenCoord[i] = coord;
|
|
}
|
|
void setTexCoord(u32 i, const J2DTexCoord* coord) {
|
|
J3D_PANIC(98, i < 8, "Error : range over.");
|
|
J3D_PANIC(99, coord, "Error : null pointer.");
|
|
mTexGenCoord[i] = *coord;
|
|
}
|
|
void setTexMtx(u32 i, J2DTexMtx* mtx) {
|
|
J3D_PANIC(120, i < 8, "Error : range over.");
|
|
mTexMtx[i] = mtx;
|
|
}
|
|
J2DTexMtx& getTexMtx(u32 i) {
|
|
J3D_PANIC(108, i < 8, "Error : range over.");
|
|
return *mTexMtx[i];
|
|
}
|
|
J2DTexCoord& getTexCoord(u32 i) {
|
|
J3D_PANIC(102, i < 8, "Error : range over.");
|
|
return mTexGenCoord[i];
|
|
}
|
|
|
|
virtual ~J2DTexGenBlock();
|
|
}; // Size: 0x48
|
|
|
|
/**
|
|
* @ingroup jsystem-j2d
|
|
*
|
|
*/
|
|
class J2DColorBlock {
|
|
private:
|
|
/* 0x00 */ JUtility::TColor mMatColor[2];
|
|
/* 0x08 */ u8 mColorChanNum;
|
|
/* 0x0A */ J2DColorChan mColorChan[4];
|
|
/* 0x12 */ u8 mCullMode;
|
|
|
|
public:
|
|
J2DColorBlock() { initialize(); }
|
|
|
|
void initialize();
|
|
void setGX();
|
|
|
|
virtual ~J2DColorBlock() {}
|
|
|
|
JUtility::TColor* getMatColor(u32 i) {
|
|
J3D_PANIC(49, i < 2, "Error : range over.");
|
|
return &mMatColor[i];
|
|
}
|
|
J2DColorChan* getColorChan(u32 i) {
|
|
J3D_PANIC(55, i < 4, "Error : range over.");
|
|
return &mColorChan[i];
|
|
}
|
|
void setCullMode(u8 mode) { mCullMode = mode; }
|
|
void setColorChanNum(u8 num) { mColorChanNum = num; }
|
|
void setMatColor(u32 i, JUtility::TColor color) {
|
|
J3D_PANIC(48, i < 2, "Error : range over.");
|
|
mMatColor[i] = color;
|
|
}
|
|
void setColorChan(u32 i, const J2DColorChan& color) {
|
|
J3D_PANIC(54, i < 4, "Error : range over.");
|
|
mColorChan[i] = color;
|
|
}
|
|
};
|
|
|
|
#endif /* J2DMATBLOCK_H */
|