some J3D/misc cleanup (#2628)

* some j3d cleanup

* begin using uintptr_t

* j3dgraphbase cleanup

* j3dgraphanimator cleanup

14 files changed, 670 insertions, 487 deletions

diff --git a/include/JSystem/J3DGraphBase/J3DDrawBuffer.h b/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
index e58be9e6a9..1cc88b4079 100644
--- a/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
+++ b/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
@@ -33,8 +33,23 @@ class J3DDrawPacket;
 class J3DMatPacket;
 class J3DShapePacket;
 
-typedef int (J3DDrawBuffer::*sortFunc)(J3DMatPacket*);
-typedef void (J3DDrawBuffer::*drawFunc)() const;
+enum J3DDrawBufDrawMode {
+    J3DDrawBufDrawMode_Head,
+    J3DDrawBufDrawMode_Tail,
+
+    J3DDrawBufDrawMode_MAX,
+};
+
+enum J3DDrawBufSortMode {
+    J3DDrawBufSortMode_Mat,
+    J3DDrawBufSortMode_MatAnm,
+    J3DDrawBufSortMode_Z,
+    J3DDrawBufSortMode_Model,
+    J3DDrawBufSortMode_Invalid,
+    J3DDrawBufSortMode_Non,
+
+    J3DDrawBufSortMode_MAX,
+};
 
 /**
  * @ingroup jsystem-j3d
@@ -42,24 +57,13 @@ typedef void (J3DDrawBuffer::*drawFunc)() const;
  */
 class J3DDrawBuffer {
 public:
-    enum EDrawType {
-        DRAW_HEAD,
-        DRAW_TAIL,
-    };
-
-    enum ESortType {
-        SORT_MAT,
-        SORT_MAT_ANM,
-        SORT_Z,
-        SORT_MODEL,
-        SORT_INVALID,
-        SORT_NON,
-    };
+    typedef int (J3DDrawBuffer::*sortFunc)(J3DMatPacket*);
+    typedef void (J3DDrawBuffer::*drawFunc)() const;
 
     J3DDrawBuffer() { initialize(); }
     ~J3DDrawBuffer();
     void initialize();
-    J3DError allocBuffer(u32);
+    int allocBuffer(u32);
     void frameInit();
     int entryMatSort(J3DMatPacket*);
     int entryMatAnmSort(J3DMatPacket*);
@@ -72,18 +76,19 @@ public:
     void drawHead() const;
     void drawTail() const;
 
-    u32 getEntryTableSize() { return mBufSize; }
+    u32 getEntryTableSize() { return mEntryTableSize; }
+    int getSortMode() { return mSortMode; }
 
     inline void calcZRatio();
-    void setNonSort() { mSortType = 5; }
-    void setZSort() { mSortType = 2; }
+    void setNonSort() { mSortMode = J3DDrawBufSortMode_Non; }
+    void setZSort() { mSortMode = J3DDrawBufSortMode_Z; }
     void setZMtx(MtxP mtx) { mpZMtx = mtx; }
 
 public:
-    /* 0x00 */ J3DPacket** mpBuf;
-    /* 0x04 */ u32 mBufSize;
-    /* 0x08 */ u32 mDrawType;
-    /* 0x0C */ u32 mSortType;
+    /* 0x00 */ J3DPacket** mpBuffer;
+    /* 0x04 */ u32 mEntryTableSize;
+    /* 0x08 */ u32 mDrawMode;
+    /* 0x0C */ u32 mSortMode;
     /* 0x10 */ f32 mZNear;
     /* 0x14 */ f32 mZFar;
     /* 0x18 */ f32 mZRatio;
diff --git a/include/JSystem/J3DGraphBase/J3DFifo.h b/include/JSystem/J3DGraphBase/J3DFifo.h
new file mode 100644
index 0000000000..c93943864c
--- /dev/null
+++ b/include/JSystem/J3DGraphBase/J3DFifo.h
@@ -0,0 +1,67 @@
+#ifndef J3DFIFO_H
+#define J3DFIFO_H
+
+#include <dolphin/gx.h>
+#include <dolphin/gd.h>
+
+inline void J3DFifoLoadBPCmd(u32 regval) {
+    GXCmd1u8(GX_LOAD_BP_REG);
+    GXCmd1u32(regval);
+}
+
+inline void J3DFifoWriteXFCmdHdr(u16 addr, u8 len) {
+    GXCmd1u8(GX_LOAD_XF_REG);
+    GXCmd1u16(len - 1);
+    GXCmd1u16(addr);
+}
+
+inline void J3DFifoLoadIndx(u8 cmd, u16 indx, u16 addr) {
+    GXWGFifo.u8 = cmd;
+    GXWGFifo.u16 = indx;
+    GXWGFifo.u16 = addr;
+}
+
+inline void J3DFifoWriteCPCmd(u8 cmd, u32 param) {
+    GXWGFifo.u8 = GX_LOAD_CP_REG;
+    GXWGFifo.u8 = cmd;
+    GXWGFifo.u32 = param;
+}
+
+inline void J3DFifoLoadCPCmd(u8 reg, u32 value) {
+    GXCmd1u8(GX_LOAD_CP_REG);
+    GXCmd1u8(reg);
+    GXCmd1u32(value);
+}
+
+inline void J3DFifoWriteXFCmd(u16 cmd, u16 len) {
+    GXWGFifo.u8 = GX_LOAD_XF_REG;
+    GXWGFifo.u16 = (len - 1);
+    GXWGFifo.u16 = cmd;
+}
+
+inline void J3DFifoLoadXFCmdHdr(u16 addr, u8 len) {
+    GXCmd1u8(GX_LOAD_XF_REG);
+    GXCmd1u16(len - 1);
+    GXCmd1u16(addr);
+}
+
+inline void J3DFifoLoadPosMtxIndx(u16 index, u32 addr) {
+    GXCmd1u8(GX_LOAD_INDX_A);
+    GXCmd1u16(index);
+    GXCmd1u16(((sizeof(Vec) - 1) << 12) | (u16)(addr * 4));
+}
+
+inline void J3DFifoLoadNrmMtxIndx3x3(u16 index, u32 addr) {
+    GXCmd1u8(GX_LOAD_INDX_B);
+    GXCmd1u16(index);
+    GXCmd1u16(((9 - 1) << 12) | (u16)((addr * 3) + 0x400));
+}
+
+void J3DFifoLoadPosMtxImm(f32 (*)[4], u32);
+void J3DFifoLoadNrmMtxImm(f32 (*)[4], u32);
+void J3DFifoLoadNrmMtxImm3x3(f32 (*)[3], u32);
+void J3DFifoLoadNrmMtxToTexMtx(f32 (*)[4], u32);
+void J3DFifoLoadNrmMtxToTexMtx3x3(f32 (*)[3], u32);
+void J3DFifoLoadTexCached(GXTexMapID, u32, GXTexCacheSize, u32, GXTexCacheSize);
+
+#endif /* J3DFIFO_H */
diff --git a/include/JSystem/J3DGraphBase/J3DGD.h b/include/JSystem/J3DGraphBase/J3DGD.h
index 854cecef65..b01dc7187f 100644
--- a/include/JSystem/J3DGraphBase/J3DGD.h
+++ b/include/JSystem/J3DGraphBase/J3DGD.h
@@ -2,64 +2,62 @@
 #define J3DGD_H
 
 #include <dolphin/gx.h>
-#include "dolphin/gd/GDBase.h"
+#include <dolphin/gd.h>
 
-inline void J3DGDWrite_u8(u8 param) {
-    __GDWrite(param);
+inline void J3DGDWrite_u8(u8 data) {
+    __GDWrite(data);
 }
 
-inline void J3DGDWrite_u16(u16 param) {
-    __GDWrite((param & 0xffff) >> 8);
-    __GDWrite(param & 0xff);
+inline void J3DGDWrite_u16(u16 data) {
+    __GDWrite((u8)((data >> 8)));
+    __GDWrite((u8)((data >> 0) & 0xFF));
 }
 
-inline void J3DGDWrite_u32(u32 param) {
-    __GDWrite((param >> 24) & 0xff);
-    __GDWrite((param >> 16) & 0xff);
-    __GDWrite((param >> 8) & 0xff);
-    __GDWrite(param & 0xff);
+inline void J3DGDWrite_u32(u32 data) {
+    __GDWrite((u8)((data >> 24) & 0xFF));
+    __GDWrite((u8)((data >> 16) & 0xFF));
+    __GDWrite((u8)((data >> 8) & 0xFF));
+    __GDWrite((u8)((data >> 0) & 0xFF));
 }
 
-inline void J3DGDWrite_f32(f32 param) {
-    u32 tmp = *(u32*)&param;
-    J3DGDWrite_u32(tmp);
+inline void J3DGDWrite_f32(f32 data) {
+    union {
+        f32 f;
+        u32 u;
+    } fid;
+    fid.f = data;
+    J3DGDWrite_u32(fid.u);
 }
 
-inline void J3DGDWriteBPCmd(u32 cmd) {
-    J3DGDWrite_u8(0x61);
-    J3DGDWrite_u32(cmd);
+inline void J3DGDWriteBPCmd(u32 regval) {
+    J3DGDWrite_u8(GX_LOAD_BP_REG);
+    J3DGDWrite_u32(regval);
 }
 
-inline void J3DFifoLoadBPCmd(u32 cmd) {
-    GXWGFifo.u8 = 0x61;
-    GXWGFifo.u32 = cmd;
-}
-
-inline void J3DGDWriteXFCmd(u16 addr, u32 cmd) {
-    J3DGDWrite_u8(0x10);
+inline void J3DGDWriteXFCmd(u16 addr, u32 val) {
+    J3DGDWrite_u8(GX_LOAD_XF_REG);
     J3DGDWrite_u16(0);
     J3DGDWrite_u16(addr);
-    J3DGDWrite_u32(cmd);
+    J3DGDWrite_u32(val);
 }
 
 inline void J3DGDWriteXFCmdHdr(u16 addr, u8 len) {
-    J3DGDWrite_u8(0x10);
+    J3DGDWrite_u8(GX_LOAD_XF_REG);
     J3DGDWrite_u16(len - 1);
     J3DGDWrite_u16(addr);
 }
 
-inline void J3DFifoWriteXFCmdHdr(u16 addr, u8 len) {
-    GXWGFifo.u8 = 0x10;
-    GXWGFifo.u16 = len - 1;
-    GXWGFifo.u16 = addr;
+inline void J3DGXCmd1f32ptr(f32* data) {
+    GXCmd1u32(*(u32*)data);
 }
 
-inline void J3DGXCmd1f32ptr(f32* value) {
-    GXWGFifo.u32 = *(u32*)value;
-}
-
-inline void J3DGXCmd1f32(f32 value) {
-    GXWGFifo.u32 = *(u32*)&value;
+inline void J3DGXCmd1f32(f32 data) {
+    union {
+        f32 f;
+        u32 u;
+    } fid;
+    fid.f = data;
+    GXCmd1u32(fid.u);
 }
 
 inline void J3DGDWriteCPCmd(u8 reg, u32 value) {
@@ -96,18 +94,6 @@ void J3DGDSetTevKColor(GXTevKColorID, GXColor);
 void J3DGDSetTevColorS10(GXTevRegID, GXColorS10);
 void J3DGDSetFog(GXFogType, f32, f32, f32, f32, GXColor);
 void J3DGDSetFogRangeAdj(u8, u16, _GXFogAdjTable*);
-void J3DFifoLoadPosMtxImm(f32 (*)[4], u32);
-void J3DFifoLoadNrmMtxImm(f32 (*)[4], u32);
-void J3DFifoLoadNrmMtxImm3x3(f32 (*)[3], u32);
-void J3DFifoLoadNrmMtxToTexMtx(f32 (*)[4], u32);
-void J3DFifoLoadNrmMtxToTexMtx3x3(f32 (*)[3], u32);
-void J3DFifoLoadTexCached(GXTexMapID, u32, GXTexCacheSize, u32, GXTexCacheSize);
-
-static inline void J3DFifoLoadIndx(u8 cmd, u16 indx, u16 addr) {
-    GXWGFifo.u8 = cmd;
-    GXWGFifo.u16 = indx;
-    GXWGFifo.u16 = addr;
-}
 
 inline void J3DGDSetNumChans(u8 numChans) {
     J3DGDWriteXFCmd(0x1009, numChans);
diff --git a/include/JSystem/J3DGraphBase/J3DMatBlock.h b/include/JSystem/J3DGraphBase/J3DMatBlock.h
index cf3e76d9d3..6d019321c5 100644
--- a/include/JSystem/J3DGraphBase/J3DMatBlock.h
+++ b/include/JSystem/J3DGraphBase/J3DMatBlock.h
@@ -4,8 +4,7 @@
 #include "JSystem/J3DGraphBase/J3DGD.h"
 #include "JSystem/J3DGraphBase/J3DTevs.h"
 #include "JSystem/J3DGraphBase/J3DTexture.h"
-#include "JSystem/JUtility/JUTAssert.h"
-#include "dolphin/types.h"
+#include "JSystem/J3DAssert.h"
 #include "global.h"
 
 /**
@@ -46,21 +45,28 @@ struct J3DGXColor : public GXColor {
     }
 };
 
+extern const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
+
 /**
  * @ingroup jsystem-j3d
  *
  */
 struct J3DNBTScale : public J3DNBTScaleInfo {
-    J3DNBTScale() {}
+    J3DNBTScale() {
+        mbHasScale = j3dDefaultNBTScaleInfo.mbHasScale;
+        mScale.x = j3dDefaultNBTScaleInfo.mScale.x;
+        mScale.y = j3dDefaultNBTScaleInfo.mScale.y;
+        mScale.z = j3dDefaultNBTScaleInfo.mScale.z;
+    }
+
     J3DNBTScale(J3DNBTScaleInfo const& info) {
         mbHasScale = info.mbHasScale;
         mScale = info.mScale;
     }
+
     Vec* getScale() { return &mScale; }
 };
 
-extern const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
-
 /**
  * @ingroup jsystem-j3d
  *
@@ -222,39 +228,39 @@ public:
     /* 80319D30 */ virtual void diffColorChan();
     /* 80323560 */ virtual u32 getType() { return 'CLOF'; }
     /* 80323184 */ virtual void setMatColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x121, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
-        J3D_ASSERT(0x122, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x121, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
+        J3D_ASSERT_NULLPTR(0x122, color != 0);
         mMatColor[idx] = *color;
     }
     /* 80323158 */ virtual void setMatColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x128, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x128, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
         mMatColor[idx] = color;
     }
     /* 803231B0 */ virtual J3DGXColor* getMatColor(u32 idx) {
-        J3D_ASSERT(0x12d, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x12d, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
         return &mMatColor[idx];
     }
     /* 803231D0 */ virtual void setColorChanNum(u8 num) { mColorChanNum = num; }
     /* 803231C4 */ virtual void setColorChanNum(u8 const* num) {
-        J3D_ASSERT(0x137, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x137, num != 0);
         mColorChanNum = *num;
     }
     /* 803231D8 */ virtual u8 getColorChanNum() const { return mColorChanNum; }
     /* 803231F4 */ virtual void setColorChan(u32 idx, J3DColorChan const& chan) {
-        J3D_ASSERT(0x142, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
+        J3D_ASSERT_RANGE(0x142, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
         mColorChan[idx] = chan;
     }
     /* 803231E0 */ virtual void setColorChan(u32 idx, J3DColorChan const* chan) {
-        J3D_ASSERT(0x148, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
-        J3D_ASSERT(0x149, chan != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x148, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
+        J3D_ASSERT_NULLPTR(0x149, chan != 0);
         mColorChan[idx] = *chan;
     }
     /* 80323208 */ virtual J3DColorChan* getColorChan(u32 idx) {
-        J3D_ASSERT(0x14e, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
+        J3D_ASSERT_RANGE(0x14e, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
         return &mColorChan[idx];
     }
     /* 80323224 */ virtual void setCullMode(u8 const* mode) {
-        J3D_ASSERT(0x154, mode != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x154, mode != 0);
         mCullMode = *mode;
     }
     /* 8032321C */ virtual void setCullMode(u8 mode) { mCullMode = mode; }
@@ -289,16 +295,16 @@ public:
     /* 80317B8C */ virtual s32 countDLSize();
     /* 80323074 */ virtual u32 getType() { return 'CLAB'; }
     /* 803230AC */ virtual void setAmbColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x1a3, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
-        J3D_ASSERT(0x1a4, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x1a3, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
+        J3D_ASSERT_NULLPTR(0x1a4, color != 0);
         mAmbColor[idx] = *color;
     }
     /* 80323080 */ virtual void setAmbColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x1aa, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x1aa, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
         mAmbColor[idx] = color;
     }
     /* 803230D8 */ virtual J3DGXColor* getAmbColor(u32 idx) {
-        J3D_ASSERT(0x1af, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x1af, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
         return &mAmbColor[idx];
     }
     /* 803230EC */ virtual ~J3DColorBlockAmbientOn() {}
@@ -330,60 +336,60 @@ public:
     /* 80317B94 */ virtual s32 countDLSize();
     /* 80322E80 */ virtual u32 getType() { return 'CLON'; }
     /* 80322EB8 */ virtual void setMatColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x1e9, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
-        J3D_ASSERT(0x1ea, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x1e9, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
+        J3D_ASSERT_NULLPTR(0x1ea, color != 0);
         mMatColor[idx] = *color;
     }
     /* 80322E8C */ virtual void setMatColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x1f0, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x1f0, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
         mMatColor[idx] = color;
     }
     /* 80322EE4 */ virtual J3DGXColor* getMatColor(u32 idx) {
-        J3D_ASSERT(0x1f5, idx >= 0 && idx < ARRAY_SIZE(mMatColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x1f5, idx >= 0 && idx < ARRAY_SIZEU(mMatColor));
         return &mMatColor[idx];
     }
     /* 80322F24 */ virtual void setAmbColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x1fc, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
-        J3D_ASSERT(0x1fd, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x1fc, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
+        J3D_ASSERT_NULLPTR(0x1fd, color != 0);
         mAmbColor[idx] = *color;
     }
     /* 80322EF8 */ virtual void setAmbColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x203, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x203, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
         mAmbColor[idx] = color;
     }
     /* 80322F50 */ virtual J3DGXColor* getAmbColor(u32 idx) {
-        J3D_ASSERT(0x208, idx >= 0 && idx < ARRAY_SIZE(mAmbColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x208, idx >= 0 && idx < ARRAY_SIZEU(mAmbColor));
         return &mAmbColor[idx];
     }
     /* 80322F70 */ virtual void setColorChanNum(u8 num) { mColorChanNum = num; }
     /* 80322F64 */ virtual void setColorChanNum(u8 const* num) {
-        J3D_ASSERT(0x212, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x212, num != 0);
         mColorChanNum = *num;
     }
     /* 80322F78 */ virtual u8 getColorChanNum() const { return mColorChanNum; }
     /* 80322F94 */ virtual void setColorChan(u32 idx, J3DColorChan const& chan) {
-        J3D_ASSERT(0x21d, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
+        J3D_ASSERT_RANGE(0x21d, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
         mColorChan[idx] = chan;
     }
     /* 80322F80 */ virtual void setColorChan(u32 idx, J3DColorChan const* chan) {
-        J3D_ASSERT(0x223, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
-        J3D_ASSERT(0x224, chan != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x223, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
+        J3D_ASSERT_NULLPTR(0x224, chan != 0);
         mColorChan[idx] = *chan;
     }
     /* 80322FA8 */ virtual J3DColorChan* getColorChan(u32 idx) {
-        J3D_ASSERT(0x229, idx >= 0 && idx < ARRAY_SIZE(mColorChan), "Error : range over.");
+        J3D_ASSERT_RANGE(0x229, idx >= 0 && idx < ARRAY_SIZEU(mColorChan));
         return &mColorChan[idx];
     }
     /* 80322FBC */ virtual void setLight(u32 idx, J3DLightObj* light) {
-        J3D_ASSERT(0x230, idx >= 0 && idx < ARRAY_SIZE(mLight), "Error : range over.");
+        J3D_ASSERT_RANGE(0x230, idx >= 0 && idx < ARRAY_SIZEU(mLight));
         mLight[idx] = light;
     }
     /* 80322FCC */ virtual J3DLightObj* getLight(u32 idx) {
-        J3D_ASSERT(0x235, idx >= 0 && idx < ARRAY_SIZE(mLight), "Error : range over.");
+        J3D_ASSERT_RANGE(0x235, idx >= 0 && idx < ARRAY_SIZEU(mLight));
         return mLight[idx];
     }
     /* 80322FE4 */ virtual void setCullMode(u8 const* mode) {
-        J3D_ASSERT(0x23b, mode != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x23b, mode != 0);
         mCullMode = *mode;
     }
     /* 80322FDC */ virtual void setCullMode(u8 mode) {
@@ -479,26 +485,26 @@ public:
     /* 80317B9C */ virtual s32 countDLSize();
     /* 80322E74 */ virtual u32 getType() { return 'TGPT'; }
     /* 80322D3C */ virtual void setTexGenNum(u32 const* num) {
-        J3D_ASSERT(0x335, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x335, num != 0);
         mTexGenNum = *num;
     }
     /* 80322D34 */ virtual void setTexGenNum(u32 num) { mTexGenNum = num; }
     /* 80322D48 */ virtual u32 getTexGenNum() const { return mTexGenNum; }
     /* 80322D50 */ virtual void setTexCoord(u32 idx, J3DTexCoord const* coord) {
-        J3D_ASSERT(0x344, idx >= 0 && idx < ARRAY_SIZE(mTexCoord), "Error : range over.");
-        J3D_ASSERT(0x345, coord != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x344, idx >= 0 && idx < ARRAY_SIZEU(mTexCoord));
+        J3D_ASSERT_NULLPTR(0x345, coord != 0);
         mTexCoord[idx] = *coord;
     }
     /* 80322D64 */ virtual J3DTexCoord* getTexCoord(u32 idx) {
-        J3D_ASSERT(0x34a, idx >= 0 && idx < ARRAY_SIZE(mTexCoord), "Error : range over.");
+        J3D_ASSERT_RANGE(0x34a, idx >= 0 && idx < ARRAY_SIZEU(mTexCoord));
         return &mTexCoord[idx];
     }
     /* 80322D78 */ virtual void setTexMtx(u32 idx, J3DTexMtx* mtx) {
-        J3D_ASSERT(0x351, idx >= 0 && idx < ARRAY_SIZE(mTexMtx), "Error : range over.");
+        J3D_ASSERT_RANGE(0x351, idx >= 0 && idx < ARRAY_SIZEU(mTexMtx));
         mTexMtx[idx] = mtx;
     }
     /* 80322D88 */ virtual J3DTexMtx* getTexMtx(u32 idx) {
-        J3D_ASSERT(0x356, idx >= 0 && idx < ARRAY_SIZE(mTexMtx), "Error : range over.");
+        J3D_ASSERT_RANGE(0x356, idx >= 0 && idx < ARRAY_SIZEU(mTexMtx));
         return mTexMtx[idx];
     }
     /* 80322D98 */ virtual u32 getTexMtxOffset() const { return mTexMtxOffset; }
@@ -517,7 +523,7 @@ public:
  */
 class J3DTexGenBlock4 : public J3DTexGenBlockPatched {
 public:
-    J3DTexGenBlock4() : mNBTScale(j3dDefaultNBTScaleInfo) {
+    J3DTexGenBlock4() : mNBTScale() {
         initialize();
     }
     /* 80317674 */ void initialize();
@@ -528,7 +534,7 @@ public:
     /* 80317BA4 */ virtual s32 countDLSize();
     /* 80322DA8 */ virtual u32 getType() { return 'TGB4'; }
     /* 80322DD8 */ virtual void setNBTScale(J3DNBTScale const* scale) {
-        J3D_ASSERT(0x393, scale != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x393, scale != 0);
         mNBTScale = *scale;
     }
     /* 80322DB4 */ virtual void setNBTScale(J3DNBTScale scale) { mNBTScale = scale; }
@@ -544,7 +550,7 @@ public:
  */
 class J3DTexGenBlockBasic : public J3DTexGenBlockPatched {
 public:
-    J3DTexGenBlockBasic() : mNBTScale(j3dDefaultNBTScaleInfo) {
+    J3DTexGenBlockBasic() : mNBTScale() {
         initialize();
     }
     /* 803176A4 */ void initialize();
@@ -555,7 +561,7 @@ public:
     /* 80317BAC */ virtual s32 countDLSize();
     /* 80322C6C */ virtual u32 getType() { return 'TGBC'; }
     /* 80322C9C */ virtual void setNBTScale(J3DNBTScale const* scale) {
-        J3D_ASSERT(0x3ca, scale != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x3ca, scale != 0);
         mNBTScale = *scale;
     }
     /* 80322C78 */ virtual void setNBTScale(J3DNBTScale scale) { mNBTScale = scale; }
@@ -672,107 +678,107 @@ public:
     /* 80322974 */ virtual void indexToPtr() { indexToPtr_private(mTexNoOffset); }
     /* 80322998 */ virtual u32 getType() { return 'TVPT'; }
     /* 803229AC */ virtual void setTevStageNum(u8 const* num) {
-        J3D_ASSERT(0x52c, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x52c, num != 0);
         mTevStageNum = *num;
     }
     /* 803229A4 */ virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
     /* 803229B8 */ virtual u8 getTevStageNum() const { return mTevStageNum; }
     /* 80317BB4 */ virtual s32 countDLSize();
     /* 803229D0 */ virtual void setTexNo(u32 idx, u16 const* texNo) {
-        J3D_ASSERT(0x53b, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
-        J3D_ASSERT(0x53c, texNo != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x53b, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
+        J3D_ASSERT_NULLPTR(0x53c, texNo != 0);
         mTexNo[idx] = *texNo;
     }
     /* 803229C0 */ virtual void setTexNo(u32 idx, u16 texNo) {
-        J3D_ASSERT(0x542, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
+        J3D_ASSERT_RANGE(0x542, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
         mTexNo[idx] = texNo;
     }
     /* 803229E4 */ virtual u16 getTexNo(u32 idx) const {
-        J3D_ASSERT(1353, idx >= 0 && idx < 8, "Error : range over.");
+        J3D_ASSERT_RANGE(1353, idx >= 0 && idx < 8);
         return mTexNo[idx];
     }
     /* 80322A08 */ virtual void setTevOrder(u32 idx, J3DTevOrder const* order) {
-        J3D_ASSERT(0x550, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
-        J3D_ASSERT(0x551, order != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x550, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
+        J3D_ASSERT_NULLPTR(0x551, order != 0);
         mTevOrder[idx] = *order;
     }
     /* 803229F4 */ virtual void setTevOrder(u32 idx, J3DTevOrder order) {
-        J3D_ASSERT(0x557, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x557, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         mTevOrder[idx] = order;
     }
     /* 80322A1C */ virtual J3DTevOrder* getTevOrder(u32 idx) {
-        J3D_ASSERT(0x55c, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x55c, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         return &mTevOrder[idx];
     }
     /* 80322A6C */ virtual void setTevStage(u32 idx, J3DTevStage const* stage) {
-        J3D_ASSERT(0x563, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x564, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x563, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x564, stage != 0);
         mTevStage[idx] = *stage;
     }
     /* 80322A30 */ virtual void setTevStage(u32 idx, J3DTevStage stage) {
-        J3D_ASSERT(0x56a, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x56a, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx] = stage;
     }
     /* 80322AA8 */ virtual J3DTevStage* getTevStage(u32 idx) {
-        J3D_ASSERT(0x56f, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x56f, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         return &mTevStage[idx];
     }
     /* 80322AD0 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage const* stage) {
-        J3D_ASSERT(0x576, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
-        J3D_ASSERT(0x577, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x576, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
+        J3D_ASSERT_NULLPTR(0x577, stage != 0);
         mIndTevStage[idx] = *stage;
     }
     /* 80322ABC */ virtual void setIndTevStage(u32 idx, J3DIndTevStage stage) {
-        J3D_ASSERT(0x57d, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x57d, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         mIndTevStage[idx] = stage;
     }
     /* 80322AE4 */ virtual J3DIndTevStage* getIndTevStage(u32 idx) {
-        J3D_ASSERT(0x582, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x582, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         return &mIndTevStage[idx];
     }
     /* 80322B24 */ virtual void setTevColor(u32 idx, J3DGXColorS10 const* color) {
-        J3D_ASSERT(0x589, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
-        J3D_ASSERT(0x58a, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x589, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
+        J3D_ASSERT_NULLPTR(0x58a, color != 0);
         mTevColor[idx] = *color;
     }
     /* 80322AF8 */ virtual void setTevColor(u32 idx, J3DGXColorS10 color) {
-        J3D_ASSERT(0x590, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x590, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         mTevColor[idx] = color;
     }
     /* 80322B50 */ virtual J3DGXColorS10* getTevColor(u32 idx) {
-        J3D_ASSERT(0x595, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x595, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         return &mTevColor[idx];
     }
     /* 80322B90 */ virtual void setTevKColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x59c, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
-        J3D_ASSERT(0x59d, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x59c, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
+        J3D_ASSERT_NULLPTR(0x59d, color != 0);
         mTevKColor[idx] = *color;
     }
     /* 80322B64 */ virtual void setTevKColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x5a3, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x5a3, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         mTevKColor[idx] = color;
     }
     /* 80322BBC */ virtual J3DGXColor* getTevKColor(u32 idx) {
-        J3D_ASSERT(0x5a8, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x5a8, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         return &mTevKColor[idx];
     }
     /* 80322BDC */ virtual void setTevKColorSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x5af, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
-        J3D_ASSERT(0x5b0, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x5af, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
+        J3D_ASSERT_NULLPTR(0x5b0, sel != 0);
         mTevKColorSel[idx] = *sel;
     }
     /* 80322BD0 */ virtual void setTevKColorSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x5b6, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x5b6, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         mTevKColorSel[idx] = sel;
     }
     /* 80322BEC */ virtual u8 getTevKColorSel(u32 idx) {
-        J3D_ASSERT(0x5bb, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x5bb, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         return mTevKColorSel[idx];
     }
     /* 80322BF8 */ virtual u32 getTexNoOffset() const { return mTexNoOffset; }
     /* 80322C00 */ virtual u32 getTevRegOffset() const { return mTevRegOffset; }
     /* 80322C08 */ virtual void setTevRegOffset(u32 offset) {
-        J3D_ASSERT(0x53b, offset >= 0, "Error : range over.");
+        J3D_ASSERT_RANGE(0x53b, offset >= 0);
         mTevRegOffset = offset;
     }
     /* 80322C10 */ virtual ~J3DTevBlockPatched() {}
@@ -815,58 +821,58 @@ public:
     /* 80322798 */ virtual u32 getType() { return 'TVB1'; }
     /* 80317BBC */ virtual s32 countDLSize();
     /* 803227B4 */ virtual void setTexNo(u32 idx, u16 const* no) {
-        J3D_ASSERT(0x618, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
-        J3D_ASSERT(0x619, no != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x618, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
+        J3D_ASSERT_NULLPTR(0x619, no != 0);
         mTexNo[idx] = *no;
     }
     /* 803227A4 */ virtual void setTexNo(u32 idx, u16 no) {
-        J3D_ASSERT(0x61f, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
+        J3D_ASSERT_RANGE(0x61f, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
         mTexNo[idx] = no;
     }
     /* 803227C8 */ virtual u16 getTexNo(u32 idx) const {
-        J3D_ASSERT(1574, idx >= 0 && idx < 1, "Error : range over.");
+        J3D_ASSERT_RANGE(1574, idx >= 0 && idx < 1);
         return mTexNo[idx];
     }
     /* 803227EC */ virtual void setTevOrder(u32 idx, J3DTevOrder const* order) {
-        J3D_ASSERT(0x62d, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
-        J3D_ASSERT(0x62e, order != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x62d, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
+        J3D_ASSERT_NULLPTR(0x62e, order != 0);
         mTevOrder[idx] = *order;
     }
     /* 803227D8 */ virtual void setTevOrder(u32 idx, J3DTevOrder order) {
-        J3D_ASSERT(0x634, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x634, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         mTevOrder[idx] = order;
     }
     /* 80322800 */ virtual J3DTevOrder* getTevOrder(u32 idx) {
-        J3D_ASSERT(0x639, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x639, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         return &mTevOrder[idx];
     }
     /* 80322818 */ virtual void setTevStageNum(u8 const* num) {}
     /* 80322814 */ virtual void setTevStageNum(u8 num) {}
     /* 8032281C */ virtual u8 getTevStageNum() const { return 1; }
     /* 80322860 */ virtual void setTevStage(u32 idx, J3DTevStage const* stage) {
-        J3D_ASSERT(0x64b, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x64c, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x64b, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x64c, stage != 0);
         mTevStage[idx] = *stage;
     }
     /* 80322824 */ virtual void setTevStage(u32 idx, J3DTevStage stage) {
-        J3D_ASSERT(0x652, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x652, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx] = stage;
     }
     /* 8032289C */ virtual J3DTevStage* getTevStage(u32 idx) {
-        J3D_ASSERT(0x657, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x657, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         return &mTevStage[idx];
     }
     /* 803228C4 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage const* stage) {
-        J3D_ASSERT(0x65e, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
-        J3D_ASSERT(0x65f, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x65e, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
+        J3D_ASSERT_NULLPTR(0x65f, stage != 0);
         mIndTevStage[idx] = *stage;
     }
     /* 803228B0 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage stage) {
-        J3D_ASSERT(0x665, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x665, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         mIndTevStage[idx] = stage;
     }
     /* 803228D8 */ virtual J3DIndTevStage* getIndTevStage(u32 idx) {
-        J3D_ASSERT(0x66a, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x66a, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         return &mIndTevStage[idx];
     }
     /* 803228EC */ virtual u32 getTexNoOffset() const { return mTexNoOffset; }
@@ -905,135 +911,135 @@ public:
     /* 803223D4 */ virtual u32 getType() { return 'TVB2'; }
     /* 80317BC4 */ virtual s32 countDLSize();
     /* 803223F0 */ virtual void setTexNo(u32 idx, u16 const* texNo) {
-        J3D_ASSERT(0x6b4, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
-        J3D_ASSERT(0x6b5, texNo != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x6b4, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
+        J3D_ASSERT_NULLPTR(0x6b5, texNo != 0);
         mTexNo[idx] = *texNo;
     }
     /* 803223E0 */ virtual void setTexNo(u32 idx, u16 texNo) {
-        J3D_ASSERT(0x6bb, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6bb, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
         mTexNo[idx] = texNo;
     }
     /* 80322404 */ virtual u16 getTexNo(u32 idx) const {
-        J3D_ASSERT(0x6c2, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6c2, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
         return mTexNo[idx];
     }
     /* 80322428 */ virtual void setTevOrder(u32 idx, J3DTevOrder const* order) {
-        J3D_ASSERT(0x6c9, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
-        J3D_ASSERT(0x6ca, order != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x6c9, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
+        J3D_ASSERT_NULLPTR(0x6ca, order != 0);
         mTevOrder[idx] = *order;
     }
     /* 80322414 */ virtual void setTevOrder(u32 idx, J3DTevOrder order) {
-        J3D_ASSERT(0x6d0, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6d0, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         mTevOrder[idx] = order;
     }
     /* 8032243C */ virtual J3DTevOrder* getTevOrder(u32 idx) {
-        J3D_ASSERT(0x6d5, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6d5, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         return &mTevOrder[idx];
     }
     /* 8032247C */ virtual void setTevColor(u32 idx, J3DGXColorS10 const* color) {
-        J3D_ASSERT(0x6dc, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
-        J3D_ASSERT(0x6dd, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x6dc, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
+        J3D_ASSERT_NULLPTR(0x6dd, color != 0);
         mTevColor[idx] = *color;
     }
     /* 80322450 */ virtual void setTevColor(u32 idx, J3DGXColorS10 color) {
-        J3D_ASSERT(0x6e3, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6e3, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         mTevColor[idx] = color;
     }
     /* 803224A8 */ virtual J3DGXColorS10* getTevColor(u32 idx) {
-        J3D_ASSERT(0x6e8, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6e8, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         return &mTevColor[idx];
     }
     /* 803224E8 */ virtual void setTevKColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x6ef, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
-        J3D_ASSERT(0x6f0, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x6ef, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
+        J3D_ASSERT_NULLPTR(0x6f0, color != 0);
         mTevKColor[idx] = *color;
     }
     /* 803224BC */ virtual void setTevKColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x6f6, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6f6, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         mTevKColor[idx] = color;
     }
     /* 80322514 */ virtual J3DGXColor* getTevKColor(u32 idx) {
-        J3D_ASSERT(0x6fb, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x6fb, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         return &mTevKColor[idx];
     }
     /* 80322534 */ virtual void setTevKColorSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x702, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
-        J3D_ASSERT(0x703, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x702, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
+        J3D_ASSERT_NULLPTR(0x703, sel != 0);
         mTevKColorSel[idx] = *sel;
     }
     /* 80322528 */ virtual void setTevKColorSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x709, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x709, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         mTevKColorSel[idx] = sel;
     }
     /* 80322544 */ virtual u8 getTevKColorSel(u32 idx) {
-        J3D_ASSERT(0x70e, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x70e, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         return mTevKColorSel[idx];
     }
     /* 8032255C */ virtual void setTevKAlphaSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x715, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
-        J3D_ASSERT(0x716, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x715, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
+        J3D_ASSERT_NULLPTR(0x716, sel != 0);
         mTevKAlphaSel[idx] = *sel;
     }
     /* 80322550 */ virtual void setTevKAlphaSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x71c, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x71c, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         mTevKAlphaSel[idx] = sel;
     }
     /* 8032256C */ virtual u8 getTevKAlphaSel(u32 idx) {
-        J3D_ASSERT(0x721, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x721, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         return mTevKAlphaSel[idx];
     }
     /* 80322580 */ virtual void setTevStageNum(u8 const* num) {
-        J3D_ASSERT(0x727, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x727, num != 0);
         mTevStageNum = *num;
     }
     /* 80322578 */ virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
     /* 8032258C */ virtual u8 getTevStageNum() const { return mTevStageNum; }
     /* 803225D0 */ virtual void setTevStage(u32 idx, J3DTevStage const* stage) {
-        J3D_ASSERT(0x736, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x737, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x736, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x737, stage != 0);
         mTevStage[idx] = *stage;
     }
     /* 80322594 */ virtual void setTevStage(u32 idx, J3DTevStage stage) {
-        J3D_ASSERT(0x73d, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x73d, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx] = stage;
     }
     /* 8032260C */ virtual J3DTevStage* getTevStage(u32 idx) {
-        J3D_ASSERT(0x742, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x742, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         return &mTevStage[idx];
     }
     /* 80322658 */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo const* info) {
-        J3D_ASSERT(0x749, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x74a, info != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x749, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x74a, info != 0);
         mTevStage[idx].setTevSwapModeInfo(*info);
     }
     /* 80322620 */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo info) {
-        J3D_ASSERT(0x750, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x750, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx].setTevSwapModeInfo(info);
     }
     /* 803226A0 */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable const* table) {
-        J3D_ASSERT(0x757, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
-        J3D_ASSERT(0x758, table != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x757, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
+        J3D_ASSERT_NULLPTR(0x758, table != 0);
         mTevSwapModeTable[idx] = *table;
     }
     /* 80322690 */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable table) {
-        J3D_ASSERT(0x75e, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x75e, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         mTevSwapModeTable[idx] = table;
     }
     /* 803226B0 */ virtual J3DTevSwapModeTable* getTevSwapModeTable(u32 idx) {
-        J3D_ASSERT(0x763, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x763, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         return &mTevSwapModeTable[idx];
     }
     /* 803226D4 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage const* stage) {
-        J3D_ASSERT(0x76a, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
-        J3D_ASSERT(0x76b, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x76a, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
+        J3D_ASSERT_NULLPTR(0x76b, stage != 0);
         mIndTevStage[idx] = *stage;
     }
     /* 803226C0 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage stage) {
-        J3D_ASSERT(0x771, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x771, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         mIndTevStage[idx] = stage;
     }
     /* 803226E8 */ virtual J3DIndTevStage* getIndTevStage(u32 idx) {
-        J3D_ASSERT(0x776, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x776, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         return &mIndTevStage[idx];
     }
     /* 803226FC */ virtual u32 getTexNoOffset() const { return mTexNoOffset; }
@@ -1081,135 +1087,135 @@ public:
     /* 80322010 */ virtual u32 getType() { return 'TVB4'; }
     /* 80317BCC */ virtual s32 countDLSize();
     /* 8032202C */ virtual void setTexNo(u32 idx, u16 const* texNo) {
-        J3D_ASSERT(0x7d5, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
-        J3D_ASSERT(0x7d6, texNo != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x7d5, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
+        J3D_ASSERT_NULLPTR(0x7d6, texNo != 0);
         mTexNo[idx] = *texNo;
     }
     /* 8032201C */ virtual void setTexNo(u32 idx, u16 texNo) {
-        J3D_ASSERT(0x7dc, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
+        J3D_ASSERT_RANGE(0x7dc, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
         mTexNo[idx] = texNo;
     }
     /* 80322040 */ virtual u16 getTexNo(u32 idx) const {
-        J3D_ASSERT(2019, idx >= 0 && idx < 4, "Error : range over.");
+        J3D_ASSERT_RANGE(2019, idx >= 0 && idx < 4);
         return mTexNo[idx];
     }
     /* 80322064 */ virtual void setTevOrder(u32 idx, J3DTevOrder const* order) {
-        J3D_ASSERT(0x7ea, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
-        J3D_ASSERT(0x7eb, order != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x7ea, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
+        J3D_ASSERT_NULLPTR(0x7eb, order != 0);
         mTevOrder[idx] = *order;
     }
     /* 80322050 */ virtual void setTevOrder(u32 idx, J3DTevOrder order) {
-        J3D_ASSERT(0x7f1, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x7f1, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         mTevOrder[idx] = order;
     }
     /* 80322078 */ virtual J3DTevOrder* getTevOrder(u32 idx) {
-        J3D_ASSERT(0x7f6, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x7f6, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         return &mTevOrder[idx];
     }
     /* 803220B8 */ virtual void setTevColor(u32 idx, J3DGXColorS10 const* color) {
-        J3D_ASSERT(0x7fd, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
-        J3D_ASSERT(0x7fe, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x7fd, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
+        J3D_ASSERT_NULLPTR(0x7fe, color != 0);
         mTevColor[idx] = *color;
     }
     /* 8032208C */ virtual void setTevColor(u32 idx, J3DGXColorS10 color) {
-        J3D_ASSERT(0x804, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x804, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         mTevColor[idx] = color;
     }
     /* 803220E4 */ virtual J3DGXColorS10* getTevColor(u32 idx) {
-        J3D_ASSERT(0x809, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x809, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         return &mTevColor[idx];
     }
     /* 80322124 */ virtual void setTevKColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x810, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
-        J3D_ASSERT(0x811, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x810, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
+        J3D_ASSERT_NULLPTR(0x811, color != 0);
         mTevKColor[idx] = *color;
     }
     /* 803220F8 */ virtual void setTevKColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x817, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x817, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         mTevKColor[idx] = color;
     }
     /* 80322150 */ virtual J3DGXColor* getTevKColor(u32 idx) {
-        J3D_ASSERT(0x81c, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x81c, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         return &mTevKColor[idx];
     }
     /* 80322170 */ virtual void setTevKColorSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x823, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
-        J3D_ASSERT(0x824, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x823, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
+        J3D_ASSERT_NULLPTR(0x824, sel != 0);
         mTevKColorSel[idx] = *sel;
     }
     /* 80322164 */ virtual void setTevKColorSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x82a, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x82a, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         mTevKColorSel[idx] = sel;
     }
     /* 80322180 */ virtual u8 getTevKColorSel(u32 idx) {
-        J3D_ASSERT(0x82f, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x82f, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         return mTevKColorSel[idx];
     }
     /* 80322198 */ virtual void setTevKAlphaSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x836, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
-        J3D_ASSERT(0x837, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x836, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
+        J3D_ASSERT_NULLPTR(0x837, sel != 0);
         mTevKAlphaSel[idx] = *sel;
     }
     /* 8032218C */ virtual void setTevKAlphaSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x83d, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x83d, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         mTevKAlphaSel[idx] = sel;
     }
     /* 803221A8 */ virtual u8 getTevKAlphaSel(u32 idx) {
-        J3D_ASSERT(0x842, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x842, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         return mTevKAlphaSel[idx];
     }
     /* 803221BC */ virtual void setTevStageNum(u8 const* num) {
-        J3D_ASSERT(0x848, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x848, num != 0);
         mTevStageNum = *num;
     }
     /* 803221B4 */ virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
     /* 803221C8 */ virtual u8 getTevStageNum() const { return mTevStageNum; }
     /* 8032220C */ virtual void setTevStage(u32 idx, J3DTevStage const* stage) {
-        J3D_ASSERT(0x857, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x858, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x857, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x858, stage != 0);
         mTevStage[idx] = *stage;
     }
     /* 803221D0 */ virtual void setTevStage(u32 idx, J3DTevStage stage) {
-        J3D_ASSERT(0x85e, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x85e, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx] = stage;
     }
     /* 80322248 */ virtual J3DTevStage* getTevStage(u32 idx) {
-        J3D_ASSERT(0x863, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x863, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         return &mTevStage[idx];
     }
     /* 80322294 */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo const* info) {
-        J3D_ASSERT(0x86a, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x86b, info != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x86a, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x86b, info != 0);
         mTevStage[idx].setTevSwapModeInfo(*info);
     }
     /* 8032225C */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo info) {
-        J3D_ASSERT(0x871, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x871, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx].setTevSwapModeInfo(info);
     }
     /* 803222DC */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable const* table) {
-        J3D_ASSERT(0x878, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
-        J3D_ASSERT(0x879, table != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x878, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
+        J3D_ASSERT_NULLPTR(0x879, table != 0);
         mTevSwapModeTable[idx] = *table;
     }
     /* 803222CC */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable table) {
-        J3D_ASSERT(0x87f, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x87f, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         mTevSwapModeTable[idx] = table;
     }
     /* 803222EC */ virtual J3DTevSwapModeTable* getTevSwapModeTable(u32 idx) {
-        J3D_ASSERT(0x884, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x884, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         return &mTevSwapModeTable[idx];
     }
     /* 80322310 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage const* stage) {
-        J3D_ASSERT(0x88b, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
-        J3D_ASSERT(0x88c, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x88b, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
+        J3D_ASSERT_NULLPTR(0x88c, stage != 0);
         mIndTevStage[idx] = *stage;
     }
     /* 803222FC */ virtual void setIndTevStage(u32 idx, J3DIndTevStage stage) {
-        J3D_ASSERT(0x892, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x892, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         mIndTevStage[idx] = stage;
     }
     /* 80322324 */ virtual J3DIndTevStage* getIndTevStage(u32 idx) {
-        J3D_ASSERT(0x897, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x897, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         return &mIndTevStage[idx];
     }
     /* 80322338 */ virtual u32 getTexNoOffset() const { return mTexNoOffset; }
@@ -1257,135 +1263,135 @@ public:
     /* 80321C44 */ virtual u32 getType() { return 'TV16'; }
     /* 80317BD4 */ virtual s32 countDLSize();
     /* 80321C60 */ virtual void setTexNo(u32 idx, u16 const* texNo) {
-        J3D_ASSERT(0x8f6, idx >= 0 && idx < ARRAY_SIZE(mTexNo), "Error : range over.");
-        J3D_ASSERT(0x8f7, texNo != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x8f6, idx >= 0 && idx < ARRAY_SIZEU(mTexNo));
+        J3D_ASSERT_NULLPTR(0x8f7, texNo != 0);
         mTexNo[idx] = *texNo;
     }
     /* 80321C50 */ virtual void setTexNo(u32 idx, u16 texNo) {
-        J3D_ASSERT(0x8fd, idx >= 0 && idx < 8, "Error : range over.");
+        J3D_ASSERT_RANGE(0x8fd, idx >= 0 && idx < 8);
         mTexNo[idx] = texNo;
     }
     /* 80321C74 */ virtual u16 getTexNo(u32 idx) const {
-        J3D_ASSERT(2308, idx >= 0 && idx < 8, "Error : range over.");
+        J3D_ASSERT_RANGE(2308, idx >= 0 && idx < 8);
         return mTexNo[idx];
     }
     /* 80321C98 */ virtual void setTevOrder(u32 idx, J3DTevOrder const* order) {
-        J3D_ASSERT(0x90b, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
-        J3D_ASSERT(0x90c, order != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x90b, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
+        J3D_ASSERT_NULLPTR(0x90c, order != 0);
         mTevOrder[idx] = *order;
     }
     /* 80321C84 */ virtual void setTevOrder(u32 idx, J3DTevOrder order) {
-        J3D_ASSERT(0x912, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x912, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         mTevOrder[idx] = order;
     }
     /* 80321CAC */ virtual J3DTevOrder* getTevOrder(u32 idx) {
-        J3D_ASSERT(0x917, idx >= 0 && idx < ARRAY_SIZE(mTevOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0x917, idx >= 0 && idx < ARRAY_SIZEU(mTevOrder));
         return &mTevOrder[idx];
     }
     /* 80321CEC */ virtual void setTevColor(u32 idx, J3DGXColorS10 const* color) {
-        J3D_ASSERT(0x91e, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
-        J3D_ASSERT(0x91f, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x91e, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
+        J3D_ASSERT_NULLPTR(0x91f, color != 0);
         mTevColor[idx] = *color;
     }
     /* 80321CC0 */ virtual void setTevColor(u32 idx, J3DGXColorS10 color) {
-        J3D_ASSERT(0x925, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x925, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         mTevColor[idx] = color;
     }
     /* 80321D18 */ virtual J3DGXColorS10* getTevColor(u32 idx) {
-        J3D_ASSERT(0x92a, idx >= 0 && idx < ARRAY_SIZE(mTevColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x92a, idx >= 0 && idx < ARRAY_SIZEU(mTevColor));
         return &mTevColor[idx];
     }
     /* 80321D58 */ virtual void setTevKColor(u32 idx, J3DGXColor const* color) {
-        J3D_ASSERT(0x931, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
-        J3D_ASSERT(0x932, color != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x931, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
+        J3D_ASSERT_NULLPTR(0x932, color != 0);
         mTevKColor[idx] = *color;
     }
     /* 80321D2C */ virtual void setTevKColor(u32 idx, J3DGXColor color) {
-        J3D_ASSERT(0x938, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x938, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         mTevKColor[idx] = color;
     }
     /* 80321D84 */ virtual J3DGXColor* getTevKColor(u32 idx) {
-        J3D_ASSERT(0x93d, idx >= 0 && idx < ARRAY_SIZE(mTevKColor), "Error : range over.");
+        J3D_ASSERT_RANGE(0x93d, idx >= 0 && idx < ARRAY_SIZEU(mTevKColor));
         return &mTevKColor[idx];
     }
     /* 80321DA4 */ virtual void setTevKColorSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x944, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
-        J3D_ASSERT(0x945, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x944, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
+        J3D_ASSERT_NULLPTR(0x945, sel != 0);
         mTevKColorSel[idx] = *sel;
     }
     /* 80321D98 */ virtual void setTevKColorSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x94b, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x94b, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         mTevKColorSel[idx] = sel;
     }
     /* 80321DB4 */ virtual u8 getTevKColorSel(u32 idx) {
-        J3D_ASSERT(0x950, idx >= 0 && idx < ARRAY_SIZE(mTevKColorSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x950, idx >= 0 && idx < ARRAY_SIZEU(mTevKColorSel));
         return mTevKColorSel[idx];
     }
     /* 80321DCC */ virtual void setTevKAlphaSel(u32 idx, u8 const* sel) {
-        J3D_ASSERT(0x957, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
-        J3D_ASSERT(0x958, sel != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x957, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
+        J3D_ASSERT_NULLPTR(0x958, sel != 0);
         mTevKAlphaSel[idx] = *sel;
     }
     /* 80321DC0 */ virtual void setTevKAlphaSel(u32 idx, u8 sel) {
-        J3D_ASSERT(0x95e, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x95e, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         mTevKAlphaSel[idx] = sel;
     }
     /* 80321DDC */ virtual u8 getTevKAlphaSel(u32 idx) {
-        J3D_ASSERT(0x963, idx >= 0 && idx < ARRAY_SIZE(mTevKAlphaSel), "Error : range over.");
+        J3D_ASSERT_RANGE(0x963, idx >= 0 && idx < ARRAY_SIZEU(mTevKAlphaSel));
         return mTevKAlphaSel[idx];
     }
     /* 80321DF0 */ virtual void setTevStageNum(u8 const* num) {
-        J3D_ASSERT(0x969, num != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0x969, num != 0);
         mTevStageNum = *num;
     }
     /* 80321DE8 */ virtual void setTevStageNum(u8 num) { mTevStageNum = num; }
     /* 80321DFC */ virtual u8 getTevStageNum() const { return mTevStageNum; }
     /* 80321E40 */ virtual void setTevStage(u32 idx, J3DTevStage const* stage) {
-        J3D_ASSERT(0x978, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x979, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x978, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x979, stage != 0);
         mTevStage[idx] = *stage;
     }
     /* 80321E04 */ virtual void setTevStage(u32 idx, J3DTevStage stage) {
-        J3D_ASSERT(0x97f, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x97f, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx] = stage;
     }
     /* 80321E7C */ virtual J3DTevStage* getTevStage(u32 idx) {
-        J3D_ASSERT(0x984, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x984, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         return &mTevStage[idx];
     }
     /* 80321EC8 */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo const* info) {
-        J3D_ASSERT(0x98b, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
-        J3D_ASSERT(0x98c, info != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x98b, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
+        J3D_ASSERT_NULLPTR(0x98c, info != 0);
         mTevStage[idx].setTevSwapModeInfo(*info);
     }
     /* 80321E90 */ virtual void setTevSwapModeInfo(u32 idx, J3DTevSwapModeInfo info) {
-        J3D_ASSERT(0x992, idx >= 0 && idx < ARRAY_SIZE(mTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x992, idx >= 0 && idx < ARRAY_SIZEU(mTevStage));
         mTevStage[idx].setTevSwapModeInfo(info);
     }
     /* 80321F10 */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable const* table) {
-        J3D_ASSERT(0x999, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
-        J3D_ASSERT(0x99a, table != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x999, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
+        J3D_ASSERT_NULLPTR(0x99a, table != 0);
         mTevSwapModeTable[idx] = *table;
     }
     /* 80321F00 */ virtual void setTevSwapModeTable(u32 idx, J3DTevSwapModeTable table) {
-        J3D_ASSERT(0x9a0, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x9a0, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         mTevSwapModeTable[idx] = table;
     }
     /* 80321F20 */ virtual J3DTevSwapModeTable* getTevSwapModeTable(u32 idx) {
-        J3D_ASSERT(0x9a5, idx >= 0 && idx < ARRAY_SIZE(mTevSwapModeTable), "Error : range over.");
+        J3D_ASSERT_RANGE(0x9a5, idx >= 0 && idx < ARRAY_SIZEU(mTevSwapModeTable));
         return &mTevSwapModeTable[idx];
     }
     /* 80321F44 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage const* stage) {
-        J3D_ASSERT(0x9ac, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
-        J3D_ASSERT(0x9ad, stage != 0, "Error : null pointer.");
+        J3D_ASSERT_RANGE(0x9ac, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
+        J3D_ASSERT_NULLPTR(0x9ad, stage != 0);
         mIndTevStage[idx] = *stage;
     }
     /* 80321F30 */ virtual void setIndTevStage(u32 idx, J3DIndTevStage stage) {
-        J3D_ASSERT(0x9b3, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x9b3, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         mIndTevStage[idx] = stage;
     }
     /* 80321F58 */ virtual J3DIndTevStage* getIndTevStage(u32 idx) {
-        J3D_ASSERT(0x9b8, idx >= 0 && idx < ARRAY_SIZE(mIndTevStage), "Error : range over.");
+        J3D_ASSERT_RANGE(0x9b8, idx >= 0 && idx < ARRAY_SIZEU(mIndTevStage));
         return &mIndTevStage[idx];
     }
     /* 80321F6C */ virtual u32 getTexNoOffset() const { return mTexNoOffset; }
@@ -1568,20 +1574,27 @@ struct J3DAlphaComp {
         return *this;
     }
 
+    J3DAlphaComp& operator=(J3DAlphaComp& rhs) {
+        mID = rhs.mID;
+        mRef0 = rhs.mRef0;
+        mRef1 = rhs.mRef1;
+        return *this;
+    }
+
     void setAlphaCompInfo(const J3DAlphaCompInfo& info) {
         mRef0 = info.mRef0;
         mRef1 = info.mRef1;
         mID = calcAlphaCmpID(info.mComp0, info.mOp, info.mComp1);
     }
 
-    GXCompare getComp0() const { return GXCompare(*(&j3dAlphaCmpTable[mID * 3] + 0)); }
-    GXAlphaOp getOp() const { return GXAlphaOp(*(&j3dAlphaCmpTable[mID * 3] + 1)); }
-    GXCompare getComp1() const { return GXCompare(*(&j3dAlphaCmpTable[mID * 3] + 2)); }
+    u8 getComp0() const { return *(&j3dAlphaCmpTable[mID * 3] + 0); }
+    u8 getOp() const { return *(&j3dAlphaCmpTable[mID * 3] + 1); }
+    u8 getComp1() const { return *(&j3dAlphaCmpTable[mID * 3] + 2); }
     u8 getRef0() const { return mRef0; }
     u8 getRef1() const { return mRef1; }
 
     void load() const {
-        J3DGDSetAlphaCompare(getComp0(), mRef0, getOp(), getComp1(), mRef1);
+        J3DGDSetAlphaCompare((GXCompare)getComp0(), mRef0, (GXAlphaOp)getOp(), (GXCompare)getComp1(), mRef1);
     }
 
     /* 0x00 */ u16 mID;
@@ -1720,42 +1733,42 @@ public:
     /* 8032339C */ virtual void setIndTexStageNum(u8 num) { mIndTexStageNum = num; }
     /* 803233A4 */ virtual u8 getIndTexStageNum() const { return mIndTexStageNum; }
     /* 803233C0 */ virtual void setIndTexOrder(u32 idx, J3DIndTexOrder const* order) {
-        J3D_ASSERT(0xa94, order != 0, "Error : null pointer.");
-        J3D_ASSERT(0xa95, idx >= 0 && idx < ARRAY_SIZE(mIndTexOrder), "Error : range over.");
+        J3D_ASSERT_NULLPTR(0xa94, order != 0);
+        J3D_ASSERT_RANGE(0xa95, idx >= 0 && idx < ARRAY_SIZEU(mIndTexOrder));
         mIndTexOrder[idx] = *order;
     }
     /* 803233AC */ virtual void setIndTexOrder(u32 idx, J3DIndTexOrder order) {
-        J3D_ASSERT(0xa9b, idx >= 0 && idx < ARRAY_SIZE(mIndTexOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0xa9b, idx >= 0 && idx < ARRAY_SIZEU(mIndTexOrder));
         mIndTexOrder[idx] = order;
     }
     /* 803233D4 */ virtual J3DIndTexOrder* getIndTexOrder(u32 idx) {
-        J3D_ASSERT(0xaa0, idx >= 0 && idx < ARRAY_SIZE(mIndTexOrder), "Error : range over.");
+        J3D_ASSERT_RANGE(0xaa0, idx >= 0 && idx < ARRAY_SIZEU(mIndTexOrder));
         return &mIndTexOrder[idx];
     }
     /* 8032341C */ virtual void setIndTexMtx(u32 idx, J3DIndTexMtx const* mtx) {
-        J3D_ASSERT(0xaa7, mtx != 0, "Error : null pointer.");
-        J3D_ASSERT(0xaa8, idx >= 0 && idx < ARRAY_SIZE(mIndTexMtx), "Error : range over.");
+        J3D_ASSERT_NULLPTR(0xaa7, mtx != 0);
+        J3D_ASSERT_RANGE(0xaa8, idx >= 0 && idx < ARRAY_SIZEU(mIndTexMtx));
         mIndTexMtx[idx] = *mtx;
     }
     /* 803233E8 */ virtual void setIndTexMtx(u32 idx, J3DIndTexMtx mtx) {
-        J3D_ASSERT(0xaae, idx >= 0 && idx < ARRAY_SIZE(mIndTexMtx), "Error : range over.");
+        J3D_ASSERT_RANGE(0xaae, idx >= 0 && idx < ARRAY_SIZEU(mIndTexMtx));
         mIndTexMtx[idx] = mtx;
     }
     /* 80323450 */ virtual J3DIndTexMtx* getIndTexMtx(u32 idx) {
-        J3D_ASSERT(0xab3, idx >= 0 && idx < ARRAY_SIZE(mIndTexMtx), "Error : range over.");
+        J3D_ASSERT_RANGE(0xab3, idx >= 0 && idx < ARRAY_SIZEU(mIndTexMtx));
         return &mIndTexMtx[idx];
     }
     /* 80323478 */ virtual void setIndTexCoordScale(u32 idx, J3DIndTexCoordScale const* scale) {
-        J3D_ASSERT(0xaba, scale != 0, "Error : null pointer.");
-        J3D_ASSERT(0xabb, idx >= 0 && idx < ARRAY_SIZE(mIndTexCoordScale), "Error : range over.");
+        J3D_ASSERT_NULLPTR(0xaba, scale != 0);
+        J3D_ASSERT_RANGE(0xabb, idx >= 0 && idx < ARRAY_SIZEU(mIndTexCoordScale));
         mIndTexCoordScale[idx] = *scale;
     }
     /* 80323464 */ virtual void setIndTexCoordScale(u32 idx, J3DIndTexCoordScale scale) {
-        J3D_ASSERT(0xac1, idx >= 0 && idx < ARRAY_SIZE(mIndTexCoordScale), "Error : range over.");
+        J3D_ASSERT_RANGE(0xac1, idx >= 0 && idx < ARRAY_SIZEU(mIndTexCoordScale));
         mIndTexCoordScale[idx] = scale;
     }
     /* 8032348C */ virtual J3DIndTexCoordScale* getIndTexCoordScale(u32 idx) {
-        J3D_ASSERT(0xac6, idx >= 0 && idx < ARRAY_SIZE(mIndTexCoordScale), "Error : range over.");
+        J3D_ASSERT_RANGE(0xac6, idx >= 0 && idx < ARRAY_SIZEU(mIndTexCoordScale));
         return &mIndTexCoordScale[idx];
     }
     /* 803234A0 */ virtual ~J3DIndBlockFull() {}
@@ -1867,31 +1880,31 @@ public:
     /* 80317BFC */ virtual s32 countDLSize();
     /* 80321B00 */ virtual u32 getType() { return 'PEFG'; }
     /* 80321B28 */ virtual void setAlphaComp(J3DAlphaComp const* alphaComp) {
-        J3D_ASSERT(0xbf9, alphaComp != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xbf9, alphaComp != 0);
         mAlphaComp = *alphaComp;
     }
     /* 80321B0C */ virtual void setAlphaComp(J3DAlphaComp const& alphaComp) { mAlphaComp = alphaComp; }
     /* 80321B44 */ virtual J3DAlphaComp* getAlphaComp() { return &mAlphaComp; }
     /* 80321B58 */ virtual void setBlend(J3DBlend const* blend) {
-        J3D_ASSERT(0xc07, blend != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc07, blend != 0);
         mBlend = *blend;
     }
     /* 80321B4C */ virtual void setBlend(J3DBlend const& blend) { mBlend = blend; }
     /* 80321B64 */ virtual J3DBlend* getBlend() { return &mBlend; }
     /* 80321B78 */ virtual void setZMode(J3DZMode const* zMode) {
-        J3D_ASSERT(0xc15, zMode != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc15, zMode != 0);
         mZMode = *zMode;
     }
     /* 80321B6C */ virtual void setZMode(J3DZMode zMode) { mZMode = zMode; }
     /* 80321B84 */ virtual J3DZMode* getZMode() { return &mZMode; }
     /* 80321B94 */ virtual void setZCompLoc(u8 const* zCompLoc) {
-        J3D_ASSERT(0xc23, zCompLoc != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc23, zCompLoc != 0);
         mZCompLoc = *zCompLoc;
     }
     /* 80321B8C */ virtual void setZCompLoc(u8 zCompLoc) { mZCompLoc = zCompLoc; }
     /* 80321BA0 */ virtual u8 getZCompLoc() const { return mZCompLoc; }
     /* 80321BB0 */ virtual void setDither(u8 const* dither) {
-        J3D_ASSERT(0xc31, dither != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc31, dither != 0);
         mDither = *dither;
     }
     /* 80321BA8 */ virtual void setDither(u8 dither) { mDither = dither; }
@@ -1928,31 +1941,31 @@ public:
     /* 80321958 */ virtual void setFog(J3DFog* pFog) { mFog.setFogInfo(pFog->getFogInfo()); }
     /* 803219A0 */ virtual J3DFog* getFog() { return &mFog; }
     /* 803219C4 */ virtual void setAlphaComp(J3DAlphaComp const* alphaComp) {
-        J3D_ASSERT(0xc7d, alphaComp != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc7d, alphaComp != 0);
         mAlphaComp = *alphaComp;
     }
     /* 803219A8 */ virtual void setAlphaComp(J3DAlphaComp const& alphaComp) { mAlphaComp = alphaComp; }
     /* 803219E0 */ virtual J3DAlphaComp* getAlphaComp() { return &mAlphaComp; }
     /* 803219F4 */ virtual void setBlend(J3DBlend const* blend) {
-        J3D_ASSERT(0xc8b, blend != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc8b, blend != 0);
         mBlend = *blend;
     }
     /* 803219E8 */ virtual void setBlend(J3DBlend const& blend) { mBlend = blend; }
     /* 80321A00 */ virtual J3DBlend* getBlend() { return &mBlend; }
     /* 80321A14 */ virtual void setZMode(J3DZMode const* zMode) {
-        J3D_ASSERT(0xc99, zMode != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xc99, zMode != 0);
         mZMode = *zMode;
     }
     /* 80321A08 */ virtual void setZMode(J3DZMode zMode) { mZMode = zMode; }
     /* 80321A20 */ virtual J3DZMode* getZMode() { return &mZMode; }
     /* 80321A30 */ virtual void setZCompLoc(u8 const* zCompLoc) {
-        J3D_ASSERT(0xca7, zCompLoc != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xca7, zCompLoc != 0);
         mZCompLoc = *zCompLoc;
     }
     /* 80321A28 */ virtual void setZCompLoc(u8 zCompLoc) { mZCompLoc = zCompLoc; }
     /* 80321A3C */ virtual u8 getZCompLoc() const { return mZCompLoc; }
     /* 80321A4C */ virtual void setDither(u8 const* dither) {
-        J3D_ASSERT(0xcb5, dither != 0, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(0xcb5, dither != 0);
         mDither = *dither;
     }
     /* 80321A44 */ virtual void setDither(u8 dither) { mDither = dither; }
diff --git a/include/JSystem/J3DGraphBase/J3DMaterial.h b/include/JSystem/J3DGraphBase/J3DMaterial.h
index b32bac6ff1..e3f7e7dab8 100644
--- a/include/JSystem/J3DGraphBase/J3DMaterial.h
+++ b/include/JSystem/J3DGraphBase/J3DMaterial.h
@@ -4,7 +4,7 @@
 #include "JSystem/J3DGraphBase/J3DMatBlock.h"
 #include "JSystem/J3DGraphBase/J3DPacket.h"
 #include "JSystem/J3DGraphBase/J3DShape.h"
-#include "dolphin/types.h"
+#include <stdint.h>
 
 class J3DJoint;
 class J3DMaterialAnm;
@@ -56,7 +56,7 @@ public:
     J3DIndBlock* getIndBlock() { return mIndBlock; }
     J3DJoint* getJoint() { return mJoint; }
     J3DMaterialAnm* getMaterialAnm() {
-        if ((u32)mMaterialAnm < 0xC0000000) {
+        if ((uintptr_t)mMaterialAnm < 0xC0000000) {
             return mMaterialAnm;
         } else {
             return NULL;
@@ -89,6 +89,21 @@ public:
     void setZCompLoc(u8 i_comploc) { mPEBlock->setZCompLoc(i_comploc); }
     void setMaterialMode(u32 i_mode) { mMaterialMode = i_mode; }
 
+    void addShape(J3DShape* pShape) {
+        J3D_ASSERT_NULLPTR(618, pShape != NULL);
+        mShape = pShape;
+    }
+
+    void setNext(J3DMaterial* pMaterial) {
+        J3D_ASSERT_NULLPTR(623, pMaterial != NULL);
+        mNext = pMaterial;
+    }
+
+    void setJoint(J3DJoint* pJoint) {
+        J3D_ASSERT_NULLPTR(628, pJoint != NULL);
+        mJoint = pJoint;
+    }
+
 public:
     /* 0x04 */ J3DMaterial* mNext;
     /* 0x08 */ J3DShape* mShape;
diff --git a/include/JSystem/J3DGraphBase/J3DPacket.h b/include/JSystem/J3DGraphBase/J3DPacket.h
index ce01c85b1e..177c8de837 100644
--- a/include/JSystem/J3DGraphBase/J3DPacket.h
+++ b/include/JSystem/J3DGraphBase/J3DPacket.h
@@ -3,6 +3,7 @@
 
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "dolphin/gd/GDBase.h"
+#include <stdint.h>
 
 class J3DMatPacket;
 
@@ -16,27 +17,42 @@ class J3DTexMtx;
 class J3DTexMtxObj;
 class J3DTexture;
 
-inline u32 getDiffFlag_LightObjNum(u32 param_1) {
-    return (param_1 & 0xf0) >> 4;
+enum J3DDiffFlag {
+    J3DDiffFlag_MatColor         = 0x1,
+    J3DDiffFlag_ColorChan        = 0x2,
+    J3DDiffFlag_AmbColor         = 0x4,
+    J3DDiffFlag_TexGen           = 0x1000,
+    J3DDiffFlag_TevReg           = 0x1000000,
+    J3DDiffFlag_KonstColor       = 0x2000000,  // is this right?
+    J3DDiffFlag_TexCoordScale    = 0x4000000,
+    J3DDiffFlag_TevStageIndirect = 0x8000000,
+    J3DDiffFlag_Fog              = 0x10000000,
+    J3DDiffFlag_Blend            = 0x20000000,
+    J3DDiffFlag_Unk40000000      = 0x40000000,
+    J3DDiffFlag_Changed          = 0x80000000,
+};
+
+inline u32 getDiffFlag_LightObjNum(u32 diffFlags) {
+    return (diffFlags & 0xf0) >> 4;
 }
 
-inline u32 getDiffFlag_TexGenNum(u32 param_1) {
-    return (param_1 & 0xf00) >> 8;
+inline u32 getDiffFlag_TexGenNum(u32 diffFlags) {
+    return (diffFlags & 0xf00) >> 8;
 }
 
-inline int calcDifferedBufferSize_TexMtxSize(int param_1) {
+inline int calcDifferedBufferSize_TexMtxSize(u32 param_1) {
   return param_1 * 0x35;
 }
 
-inline int calcDifferedBufferSize_TexGenSize(int param_1) {
+inline int calcDifferedBufferSize_TexGenSize(u32 param_1) {
     return param_1 * 0x3d + 10;
 }
 
-inline u32 getDiffFlag_TexNoNum(u32 param_1) {
-    return (param_1 & 0xf0000) >> 0x10;
+inline u32 getDiffFlag_TexNoNum(u32 diffFlags) {
+    return (diffFlags & 0xf0000) >> 0x10;
 }
 
-inline int calcDifferedBufferSize_TexNoSize(int param_1) {
+inline int calcDifferedBufferSize_TexNoSize(u32 param_1) {
     return param_1 * 0x37;
 }
 
@@ -46,15 +62,15 @@ inline u32 calcDifferedBufferSize_TexNoAndTexCoordScaleSize(u32 param_1) {
     return res;
 }
 
-inline u32 getDiffFlag_TevStageNum(u32 param_1) {
-    return (param_1 & 0xf00000) >> 0x14;
+inline u32 getDiffFlag_TevStageNum(u32 diffFlags) {
+    return (diffFlags & 0xf00000) >> 0x14;
 }
 
-inline int calcDifferedBufferSize_TevStageSize(int param_1) {
+inline int calcDifferedBufferSize_TevStageSize(u32 param_1) {
     return param_1 * 10;
 }
 
-inline int calcDifferedBufferSize_TevStageDirectSize(int param_1) {
+inline int calcDifferedBufferSize_TevStageDirectSize(u32 param_1) {
     return param_1 * 5;
 }
 
@@ -65,15 +81,15 @@ inline int calcDifferedBufferSize_TevStageDirectSize(int param_1) {
 class J3DDisplayListObj {
 public:
     J3DDisplayListObj() {
-        mpData[0] = NULL;
-        mpData[1] = NULL;
+        mpDisplayList[0] = NULL;
+        mpDisplayList[1] = NULL;
         mSize = 0;
-        mCapacity = 0;
+        mMaxSize = 0;
     }
 
     J3DError newDisplayList(u32);
     J3DError newSingleDisplayList(u32);
-    J3DError single_To_Double();
+    int single_To_Double();
     void setSingleDisplayList(void*, u32);
     void swapBuffer();
     void callDL() const;
@@ -82,15 +98,15 @@ public:
     void beginPatch();
     u32 endPatch();
 
-    u8* getDisplayList(int idx) const { return (u8*)mpData[idx]; }
-    u32 getDisplayListSize() const { return mSize; }
+    u8* getDisplayList(int idx) { return (u8*)mpDisplayList[idx]; }
+    u32 getDisplayListSize() { return mSize; }
 
     static GDLObj sGDLObj;
     static s32 sInterruptFlag;
 
-    /* 0x0 */ void* mpData[2];
+    /* 0x0 */ void* mpDisplayList[2];
     /* 0x8 */ u32 mSize;
-    /* 0xC */ u32 mCapacity;
+    /* 0xC */ u32 mMaxSize;
 };  // Size: 0x10
 
 /**
@@ -102,7 +118,7 @@ public:
     J3DPacket() {
         mpNextPacket = NULL;
         mpFirstChild = NULL;
-        mpUserData = NULL;
+        mpUserArea = NULL;
     }
 
     void addChildPacket(J3DPacket*);
@@ -115,8 +131,8 @@ public:
         mpFirstChild = NULL;
     }
 
-    void* getUserArea() { return mpUserData; }
-    void setUserArea(u32 area) { mpUserData = (void*)area; }
+    void* getUserArea() const { return mpUserArea; }
+    void setUserArea(uintptr_t area) { mpUserArea = (void*)area; }
 
     virtual int entry(J3DDrawBuffer*);
     virtual void draw();
@@ -125,7 +141,7 @@ public:
 public:
     /* 0x04 */ J3DPacket* mpNextPacket;
     /* 0x08 */ J3DPacket* mpFirstChild;
-    /* 0x0C */ void* mpUserData;
+    /* 0x0C */ void* mpUserArea;
 };  // Size: 0x10
 
 /**
@@ -140,29 +156,34 @@ public:
     J3DError newSingleDisplayList(u32);
     virtual void draw();
 
-    J3DDisplayListObj* getDisplayListObj() const { return mpDisplayListObj; }
+    J3DDisplayListObj* getDisplayListObj() { return mpDisplayListObj; }
     void setDisplayListObj(J3DDisplayListObj* pObj) { mpDisplayListObj = pObj; }
 
     void beginPatch() { mpDisplayListObj->beginPatch(); }
     void endPatch() { mpDisplayListObj->endPatch(); }
 
-    void callDL() const { getDisplayListObj()->callDL(); }
+    void callDL() const { mpDisplayListObj->callDL(); }
+    void beginDL() { mpDisplayListObj->beginDL(); }
+    void endDL() { mpDisplayListObj->endDL(); }
+
+    void* getDisplayList(int i) { return mpDisplayListObj->mpDisplayList[i]; }
+    u32 getDisplayListSize() const { return mpDisplayListObj->mSize; } 
 
     enum {
         LOCKED = 0x01,
     };
 
-    bool checkFlag(u32 flag) const { return (mFlags & flag) != 0; }
+    bool checkFlag(u32 flag) const { return (mFlags & flag) ? true : false; }
     void onFlag(u32 flag) { mFlags |= flag; }
     void offFlag(u32 flag) { mFlags &= ~flag; }
     void lock() { onFlag(LOCKED); }
     void unlock() { offFlag(LOCKED); }
-    J3DTexMtxObj* getTexMtxObj() const { return mpTexMtxObj; }
+    J3DTexMtxObj* getTexMtxObj() { return mpTexMtxObj; }
     bool isLocked() const { return checkFlag(1); }
 
 public:
     /* 0x10 */ u32 mFlags;
-    /* 0x14 */ char mPad0[0x0C];  // unk
+    /* 0x14 */ char unk_0x14[0x20 - 0x14];
     /* 0x20 */ J3DDisplayListObj* mpDisplayListObj;
     /* 0x24 */ J3DTexMtxObj* mpTexMtxObj;
 };  // Size: 0x28
@@ -175,15 +196,23 @@ class J3DShapePacket : public J3DDrawPacket {
 public:
     J3DShapePacket();
     u32 calcDifferedBufferSize(u32);
-    J3DError newDifferedDisplayList(u32);
+    int newDifferedDisplayList(u32);
     void prepareDraw() const;
     void drawFast();
 
     virtual ~J3DShapePacket();
     virtual void draw();
 
-    void setShape(J3DShape* pShape) { mpShape = pShape; }
-    void setModel(J3DModel* pModel) { mpModel = pModel; }
+    void setShape(J3DShape* pShape) {
+        J3D_ASSERT_NULLPTR(523, pShape != NULL);
+        mpShape = pShape;
+    }
+
+    void setModel(J3DModel* pModel) {
+        J3D_ASSERT_NULLPTR(533, pModel != NULL);
+        mpModel = pModel;
+    }
+
     void setMtxBuffer(J3DMtxBuffer* pMtxBuffer) { mpMtxBuffer = pMtxBuffer; }
     void setBaseMtxPtr(Mtx* pMtx) { mpBaseMtxPtr = pMtx; }
 
@@ -214,13 +243,22 @@ public:
     J3DMaterial* getMaterial() const { return mpMaterial; }
     J3DShapePacket* getShapePacket() const { return mpShapePacket; }
     void setShapePacket(J3DShapePacket* packet) { mpShapePacket = packet; }
-    void setMaterial(J3DMaterial* pMaterial) { mpMaterial = pMaterial; }
-    void setTexture(J3DTexture* pTexture) { mpTexture = pTexture; }
+
+    void setMaterial(J3DMaterial* pMaterial) {
+        J3D_ASSERT_NULLPTR(646, pMaterial != NULL);
+        mpMaterial = pMaterial;
+    }
+
+    void setTexture(J3DTexture* pTexture) {
+        J3D_ASSERT_NULLPTR(651, pTexture != NULL);
+        mpTexture = pTexture;
+    }
+
     void setInitShapePacket(J3DShapePacket* packet) { mpInitShapePacket = packet; }
     void setMaterialID(u32 id) { mDiffFlag = id; }
     void setMaterialAnmID(J3DMaterialAnm* materialAnm) { mpMaterialAnm = materialAnm; }
-    bool isChanged() const { return mDiffFlag & 0x80000000; }
-    bool isEnabled_Diff() const { return mpInitShapePacket->getDisplayListObj() != NULL; }
+    BOOL isChanged() { return mDiffFlag & J3DDiffFlag_Changed; }
+    bool isEnabled_Diff() { return mpInitShapePacket->getDisplayListObj() != NULL; }
 
     virtual ~J3DMatPacket();
     virtual int entry(J3DDrawBuffer*);
diff --git a/include/JSystem/J3DGraphBase/J3DShape.h b/include/JSystem/J3DGraphBase/J3DShape.h
index 383afb3703..8524af4cf9 100644
--- a/include/JSystem/J3DGraphBase/J3DShape.h
+++ b/include/JSystem/J3DGraphBase/J3DShape.h
@@ -2,9 +2,9 @@
 #define J3DSHAPE_H
 
 #include "JSystem/J3DGraphBase/J3DShapeDraw.h"
-#include "JSystem/JUtility/JUTAssert.h"
-#include "dolphin/gx.h"
-#include "mtx.h"
+#include "JSystem/J3DAssert.h"
+#include "JSystem/J3DGraphBase/J3DFifo.h"
+#include <dolphin/mtx.h>
 
 class J3DShapeMtx;
 
@@ -18,18 +18,6 @@ public:
     u32 mMtxIdxRegB;
 };
 
-static inline void J3DFifoWriteCPCmd(u8 cmd, u32 param) {
-    GXWGFifo.u8 = GX_LOAD_CP_REG;
-    GXWGFifo.u8 = cmd;
-    GXWGFifo.u32 = param;
-}
-
-static inline void J3DFifoWriteXFCmd(u16 cmd, u16 len) {
-    GXWGFifo.u8 = GX_LOAD_XF_REG;
-    GXWGFifo.u16 = (len - 1);
-    GXWGFifo.u16 = cmd;
-}
-
 /**
  * @ingroup jsystem-j3d
  * 
@@ -50,10 +38,10 @@ public:
     u32 getMtxIdxRegA() const { return mMtxIdxRegA; }
     u32 getMtxIdxRegB() const { return mMtxIdxRegB; }
 
-    inline void load() const {
-        J3DFifoWriteCPCmd(0x30, mMtxIdxRegA);  // CP_MATINDEX_A
-        J3DFifoWriteCPCmd(0x40, mMtxIdxRegB);  // CP_MATINDEX_B
-        J3DFifoWriteXFCmd(0x1018, 2);
+    void load() const {
+        J3DFifoLoadCPCmd(CP_REG_MTXIDXA_ID, mMtxIdxRegA);
+        J3DFifoLoadCPCmd(CP_REG_MTXIDXB_ID, mMtxIdxRegB);
+        J3DFifoLoadXFCmdHdr(GX_XF_REG_MATRIXINDEX0, 2);
         GXCmd1u32(mMtxIdxRegA);
         GXCmd1u32(mMtxIdxRegB);
     }
@@ -65,17 +53,62 @@ public:
     }
 };
 
+typedef void (J3DShapeMtx::*J3DShapeMtx_LoadFunc)(int, u16) const;
+
+/**
+ * @ingroup jsystem-j3d
+ * 
+ */
+class J3DShapeMtx {
+public:
+    J3DShapeMtx(u16 useMtxIndex)
+        : mUseMtxIndex(useMtxIndex)
+    {}
+
+    /* 803130E4 */ void loadMtxIndx_PNGP(int, u16) const;
+    /* 80313128 */ void loadMtxIndx_PCPU(int, u16) const;
+    /* 80313188 */ void loadMtxIndx_NCPU(int, u16) const;
+    /* 803131D4 */ void loadMtxIndx_PNCPU(int, u16) const;
+
+    /* 80314798 */ virtual ~J3DShapeMtx() {}
+    /* 803147E0 */ virtual u32 getType() const { return 'SMTX'; }
+    /* 80273E08 */ virtual u16 getUseMtxNum() const { return 1; }
+    /* 8031459C */ virtual u16 getUseMtxIndex(u16) const { return mUseMtxIndex; }
+    /* 80313B94 */ virtual void load() const;
+    /* 80313BF0 */ virtual void calcNBTScale(Vec const&, f32 (*)[3][3], f32 (*)[3][3]);
+
+    static J3DShapeMtx_LoadFunc sMtxLoadPipeline[4];
+    static u16 sMtxLoadCache[10];
+    static u32 sCurrentPipeline;
+    static u8* sCurrentScaleFlag;
+    static bool sNBTFlag;
+    static bool sLODFlag;
+    static u32 sTexMtxLoadType;
+
+    static void setCurrentPipeline(u32 pipeline) {
+        J3D_ASSERT_RANGE(91, pipeline < 4);
+        sCurrentPipeline = pipeline;
+    }
+
+    static void setLODFlag(bool flag) { sLODFlag = flag; }
+    static u32 getLODFlag() { return sLODFlag; }
+    static void resetMtxLoadCache();
+
+protected:
+    /* 0x04 */ u16 mUseMtxIndex;
+};
+
 class J3DMaterial;
 class J3DVertexData;
 class J3DDrawMtxData;
 
 enum J3DShpFlag {
-    J3DShpFlag_Visible = 0x0001,
+    J3DShpFlag_Visible    = 0x0001,
     J3DShpFlag_SkinPosCpu = 0x0004,
     J3DShpFlag_SkinNrmCpu = 0x0008,
-    J3DShpFlag_Hidden = 0x0010,
-    J3DShpFlag_EnableLod = 0x0100,
-    J3DShpFlag_NoMtx = 0x0200,
+    J3DShpFlag_Hidden     = 0x0010,
+    J3DShpFlag_EnableLod  = 0x0100,
+    J3DShpFlag_NoMtx      = 0x0200,
 };
 
 /**
@@ -88,9 +121,7 @@ public:
         initialize();
     }
 
-    enum {
-        kVcdVatDLSize = 0xC0,
-    };
+    static const int kVcdVatDLSize = 0xC0;
 
     /* 80314B48 */ void initialize();
     /* 80314BB8 */ void addTexMtxIndexInDL(_GXAttr, u32);
@@ -109,18 +140,44 @@ public:
     /* 80315628 */ virtual void simpleDraw() const;
     /* 803156AC */ virtual void simpleDrawCache() const;
 
+    void loadCurrentMtx() const;
+
     void onFlag(u32 flag) { mFlags |= flag; }
     void offFlag(u32 flag) { mFlags &= ~flag; }
-    bool checkFlag(u32 flag) const { return !!(mFlags & flag); }
-    void setDrawMtxDataPointer(J3DDrawMtxData* pMtxData) { mDrawMtxData = pMtxData; }
-    void setVertexDataPointer(J3DVertexData* pVtxData) { mVertexData = pVtxData; }
+    bool checkFlag(u32 flag) const { return (mFlags & flag) != 0; }
+
+    void setMaterial(J3DMaterial* pMaterial) {
+        J3D_ASSERT_NULLPTR(509, pMaterial != NULL);
+        mMaterial = pMaterial;
+    }
+
+    void setDrawMtxDataPointer(J3DDrawMtxData* pMtxData) {
+        J3D_ASSERT_NULLPTR(554, pMtxData != NULL);
+        mDrawMtxData = pMtxData;
+    }
+
+    void setVertexDataPointer(J3DVertexData* pVtxData) {
+        J3D_ASSERT_NULLPTR(657, pVtxData != NULL);
+        mVertexData = pVtxData;
+    }
+
     void* getVcdVatCmd() { return mVcdVatCmd; }
     void setVcdVatCmd(void* pVatCmd) { mVcdVatCmd = (u8*)pVatCmd; }
     void show() { offFlag(J3DShpFlag_Visible); }
     void hide() { onFlag(J3DShpFlag_Visible); }
-    void setCurrentViewNoPtr(u32* pViewNoPtr) { mCurrentViewNo = pViewNoPtr; }
+
+    void setCurrentViewNoPtr(u32* pViewNoPtr) {
+        J3D_ASSERT_NULLPTR(584, pViewNoPtr != NULL);
+        mCurrentViewNo = pViewNoPtr;
+    }
+
     void setCurrentMtx(J3DCurrentMtx& mtx) { mCurrentMtx = mtx; }
-    void setScaleFlagArray(u8* pScaleFlagArray) { mScaleFlagArray = pScaleFlagArray; }
+
+    void setScaleFlagArray(u8* pScaleFlagArray) {
+        J3D_ASSERT_NULLPTR(595, pScaleFlagArray != NULL);
+        mScaleFlagArray = pScaleFlagArray;
+    }
+
     void setDrawMtx(Mtx** pDrawMtx) { mDrawMtx = pDrawMtx; }
     void setNrmMtx(Mtx33** pNrmMtx) { mNrmMtx = pNrmMtx; }
     void setTexMtxLoadType(u32 type) { mFlags = (mFlags & 0xFFFF0FFF) | type; }
@@ -141,6 +198,7 @@ public:
     static void resetVcdVatCache() { sOldVcdVatCmd = NULL; }
 
     static void* sOldVcdVatCmd;
+    static bool sEnvelopeFlag;
 
 private:
     friend struct J3DShapeFactory;
@@ -169,48 +227,4 @@ private:
     /* 0x64 */ u32 mBumpMtxOffset;
 };
 
-typedef void (J3DShapeMtx::*J3DShapeMtx_LoadFunc)(int, u16) const;
-
-/**
- * @ingroup jsystem-j3d
- * 
- */
-class J3DShapeMtx {
-public:
-    J3DShapeMtx(u16 useMtxIndex)
-        : mUseMtxIndex(useMtxIndex)
-    {}
-
-    /* 803130E4 */ void loadMtxIndx_PNGP(int, u16) const;
-    /* 80313128 */ void loadMtxIndx_PCPU(int, u16) const;
-    /* 80313188 */ void loadMtxIndx_NCPU(int, u16) const;
-    /* 803131D4 */ void loadMtxIndx_PNCPU(int, u16) const;
-
-    /* 80314798 */ virtual ~J3DShapeMtx() {}
-    /* 803147E0 */ virtual u32 getType() const { return 'SMTX'; }
-    /* 80273E08 */ virtual u16 getUseMtxNum() const { return 1; }
-    /* 8031459C */ virtual u16 getUseMtxIndex(u16) const { return mUseMtxIndex; }
-    /* 80313B94 */ virtual void load() const;
-    /* 80313BF0 */ virtual void calcNBTScale(Vec const&, f32 (*)[3][3], f32 (*)[3][3]);
-
-    static J3DShapeMtx_LoadFunc sMtxLoadPipeline[4];
-    static u16 sMtxLoadCache[10];
-    static u32 sCurrentPipeline;
-    static u8* sCurrentScaleFlag;
-    static u8 sNBTFlag;
-    static u8 sLODFlag;
-    static u32 sTexMtxLoadType;
-
-    static void setCurrentPipeline(u32 pipeline) {
-        J3D_ASSERT(91, pipeline < 4, "Error : range over.");
-        sCurrentPipeline = pipeline;
-    }
-    static void setLODFlag(u8 flag) { sLODFlag = flag; }
-    static u32 getLODFlag() { return sLODFlag; }
-    static void resetMtxLoadCache();
-
-protected:
-    /* 0x04 */ u16 mUseMtxIndex;
-};
-
 #endif /* J3DSHAPE_H */
diff --git a/include/JSystem/J3DGraphBase/J3DShapeMtx.h b/include/JSystem/J3DGraphBase/J3DShapeMtx.h
index bf15ff84e4..f269c0594b 100644
--- a/include/JSystem/J3DGraphBase/J3DShapeMtx.h
+++ b/include/JSystem/J3DGraphBase/J3DShapeMtx.h
@@ -2,6 +2,7 @@
 #define J3DSHAPEMTX_H
 
 #include "JSystem/J3DGraphBase/J3DShape.h"
+#include "JSystem/J3DAssert.h"
 #include "dolphin/mtx.h"
 
 class J3DTexMtx;
@@ -14,15 +15,21 @@ class J3DTexGenBlock;
 class J3DTexMtxObj {
 public:
     Mtx& getMtx(u16 idx) {
-        J3D_ASSERT(0x113, idx <= mTexMtxNum, "Error : range over");
+        J3D_ASSERT_RANGE(275, idx < mTexMtxNum);
         return mpTexMtx[idx];
     }
+
+    void setMtx(u16 idx, const Mtx mtx) {
+        J3D_ASSERT_RANGE(288, idx < mTexMtxNum);
+        MTXCopy(mtx, mpTexMtx[idx]);
+    }
+
     Mtx44& getEffectMtx(u16 idx) {
-        J3D_ASSERT(0x125, idx <= mTexMtxNum, "Error : range over");
+        J3D_ASSERT_RANGE(293, idx < mTexMtxNum);
         return mpEffectMtx[idx];
     }
+
     u16 getNumTexMtx() const { return mTexMtxNum; }
-    void setMtx(u16 idx, Mtx const* mtx) { MTXCopy(*mtx, mpTexMtx[idx]); }
 
     /* 0x00 */ Mtx* mpTexMtx;
     /* 0x04 */ Mtx44* mpEffectMtx;
@@ -37,7 +44,7 @@ class J3DDifferedTexMtx {
 public:
     /* 8031322C */ static void loadExecute(f32 const (*)[4]);
 
-    static inline void load(Mtx m) {
+    static inline void load(const Mtx m) {
         if (sTexGenBlock != NULL)
             loadExecute(m);
     }
diff --git a/include/JSystem/J3DGraphBase/J3DStruct.h b/include/JSystem/J3DGraphBase/J3DStruct.h
index 4e483ddb11..c8bff4d49f 100644
--- a/include/JSystem/J3DGraphBase/J3DStruct.h
+++ b/include/JSystem/J3DGraphBase/J3DStruct.h
@@ -142,7 +142,7 @@ struct J3DFogInfo {
 struct J3DNBTScaleInfo {
     /* 8032587C */ J3DNBTScaleInfo& operator=(J3DNBTScaleInfo const&);
 
-    /* 0x0 */ bool mbHasScale;
+    /* 0x0 */ u8 mbHasScale;
     /* 0x4 */ Vec mScale;
 };  // Size: 0x10
 
diff --git a/include/JSystem/J3DGraphBase/J3DSys.h b/include/JSystem/J3DGraphBase/J3DSys.h
index 61609050c5..141ec0296e 100644
--- a/include/JSystem/J3DGraphBase/J3DSys.h
+++ b/include/JSystem/J3DGraphBase/J3DSys.h
@@ -3,7 +3,7 @@
 
 #include <dolphin/gx.h>
 #include <dolphin/mtx.h>
-#include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/J3DAssert.h"
 
 // Perhaps move to a new J3DEnum.h?
 enum J3DError {
@@ -11,9 +11,11 @@ enum J3DError {
     kJ3DError_Alloc = 4,
 };
 
-enum J3DSysDrawBuffer {
-    /* 0x0 */ J3DSys_OPA_BUFFER_e,
-    /* 0x1 */ J3DSys_XLU_BUFFER_e
+enum J3DSysDrawBuf {
+    /* 0x0 */ J3DSysDrawBuf_Opa,
+    /* 0x1 */ J3DSysDrawBuf_Xlu,
+
+    /* 0x2 */ J3DSysDrawBuf_MAX
 };
 
 class J3DMtxCalc;
@@ -53,25 +55,25 @@ struct J3DSys {
     /* 0x03C */ J3DMatPacket* mMatPacket;
     /* 0x040 */ J3DShapePacket* mShapePacket;
     /* 0x044 */ J3DShape* mShape;
-    /* 0x048 */ J3DDrawBuffer* mDrawBuffer[2];
+    /* 0x048 */ J3DDrawBuffer* mDrawBuffer[J3DSysDrawBuf_MAX];
     /* 0x050 */ u32 mDrawMode;
     /* 0x054 */ u32 mMaterialMode;
     /* 0x058 */ J3DTexture* mTexture;
-    /* 0x05C */ u8 field_0x5c[0x04];
+    /* 0x05C */ u8 unk_0x5c[0x60 - 0x5C];
     /* 0x060 */ u32 mTexCacheRegionNum;
     /* 0x064 */ GXTexRegion mTexCacheRegion[8];
-    /* 0x0E4 */ u8 field_0xe4[0x20];
+    /* 0x0E4 */ u8 unk_0xe4[0x104 - 0xE4];
     /* 0x104 */ Mtx* mModelDrawMtx;
     /* 0x108 */ Mtx33* mModelNrmMtx;
     /* 0x10C */ void* mVtxPos;
     /* 0x110 */ void* mVtxNrm;
-    /* 0x114 */ _GXColor* mVtxCol;
+    /* 0x114 */ GXColor* mVtxCol;
     /* 0x118 */ Vec* mNBTScale;
 
     /* 8030FDE8 */ J3DSys();
     /* 8030FEC0 */ void loadPosMtxIndx(int, u16) const;
     /* 8030FEE4 */ void loadNrmMtxIndx(int, u16) const;
-    /* 8030FF0C */ void setTexCacheRegion(_GXTexCacheSize);
+    /* 8030FF0C */ void setTexCacheRegion(GXTexCacheSize);
     /* 803100BC */ void drawInit();
     /* 8031073C */ void reinitGX();
     /* 8031079C */ void reinitGenMode();
@@ -82,16 +84,15 @@ struct J3DSys {
     /* 80310D44 */ void reinitIndStages();
     /* 80310E3C */ void reinitPixelProc();
 
-    enum DrawMode {
-        /* 0x3 */ OPA_TEX_EDGE = 3,
-        /* 0x4 */ XLU,
+    enum J3DSysDrawMode {
+        J3DSysDrawMode_OpaTexEdge = 3,
+        J3DSysDrawMode_Xlu
     };
 
     MtxP getViewMtx() { return mViewMtx; }
 
-    void setDrawModeOpaTexEdge() { mDrawMode = OPA_TEX_EDGE; }
-
-    void setDrawModeXlu() { mDrawMode = XLU; }
+    void setDrawModeOpaTexEdge() { mDrawMode = J3DSysDrawMode_OpaTexEdge; }
+    void setDrawModeXlu() { mDrawMode = J3DSysDrawMode_Xlu; }
 
     void* getVtxPos() { return mVtxPos; }
     void setVtxPos(void* pVtxPos) { mVtxPos = pVtxPos; }
@@ -99,15 +100,35 @@ struct J3DSys {
     void* getVtxNrm() { return mVtxNrm; }
     void setVtxNrm(void* pVtxNrm) { mVtxNrm = pVtxNrm; }
 
-    void* getVtxCol() const { return mVtxCol; }
-    void setVtxCol(_GXColor* pVtxCol) { mVtxCol = pVtxCol; }
+    void* getVtxCol() { return mVtxCol; }
+    void setVtxCol(GXColor* pVtxCol) { mVtxCol = pVtxCol; }
+
+    void setDrawBuffer(J3DDrawBuffer* buffer, int type) {
+        J3D_ASSERT_RANGE(114, type >= 0 && type < J3DSysDrawBuf_MAX);
+        J3D_ASSERT_NULLPTR(115, buffer);
+        mDrawBuffer[type] = buffer;
+    }
+
+    J3DDrawBuffer* getDrawBuffer(int type) {
+        J3D_ASSERT_RANGE(121, type >= 0 && type < J3DSysDrawBuf_MAX);
+        return mDrawBuffer[type];
+    }
+
+    void setMatPacket(J3DMatPacket* pPacket) {
+        J3D_ASSERT_NULLPTR(162, pPacket != NULL);
+        mMatPacket = pPacket;
+    }
+
+    void setShapePacket(J3DShapePacket* pPacket) {
+        J3D_ASSERT_NULLPTR(172, pPacket != NULL);
+        mShapePacket = pPacket;
+    }
 
     void setModel(J3DModel* pModel) {
-        J3D_ASSERT(200, pModel, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(200, pModel != NULL);
         mModel = pModel;
     }
-    void setShapePacket(J3DShapePacket* pPacket) { mShapePacket = pPacket; }
-    void setMatPacket(J3DMatPacket* pPacket) { mMatPacket = pPacket; }
+
     J3DMatPacket* getMatPacket() { return mMatPacket; }
     void setMaterialMode(u32 mode) { mMaterialMode = mode; }
 
@@ -124,34 +145,20 @@ struct J3DSys {
 
     void offFlag(u32 flag) { mFlags &= ~flag; }
 
-    bool checkFlag(u32 flag) { return mFlags & flag; }
+    bool checkFlag(u32 flag) { return mFlags & flag ? true : false; }
 
     void setModelDrawMtx(Mtx* pMtxArr) {
+        J3D_ASSERT_NULLPTR(230, pMtxArr);
         mModelDrawMtx = pMtxArr;
         GXSetArray(GX_POS_MTX_ARRAY, mModelDrawMtx, sizeof(*mModelDrawMtx));
     }
 
     void setModelNrmMtx(Mtx33* pMtxArr) {
-        JUT_ASSERT_MSG(241, pMtxArr, "Error : null pointer.");
+        J3D_ASSERT_NULLPTR(241, pMtxArr);
         mModelNrmMtx = pMtxArr;
         GXSetArray(GX_NRM_MTX_ARRAY, mModelNrmMtx, sizeof(*mModelNrmMtx));
     }
 
-    // Type 0: Opa Buffer
-    // Type 1: Xlu Buffer
-    void setDrawBuffer(J3DDrawBuffer* buffer, int type) {
-        J3D_ASSERT(114, type >= 0 && type < 2, "Error : range over.");
-        J3D_ASSERT(115, buffer, "Error : null pointer.");
-        mDrawBuffer[type] = buffer;
-    }
-
-    // Type 0: Opa Buffer
-    // Type 1: Xlu Buffer
-    J3DDrawBuffer* getDrawBuffer(int type) {
-        J3D_ASSERT(121, type >= 0 && type < 2, "Error : range over.");
-        return mDrawBuffer[type];
-    }
-
     Mtx& getModelDrawMtx(u16 no) { return mModelDrawMtx[no]; }
     J3DShapePacket* getShapePacket() { return mShapePacket; }
 
diff --git a/include/JSystem/J3DGraphBase/J3DTevs.h b/include/JSystem/J3DGraphBase/J3DTevs.h
index 23ddda86de..e5c06c97c7 100644
--- a/include/JSystem/J3DGraphBase/J3DTevs.h
+++ b/include/JSystem/J3DGraphBase/J3DTevs.h
@@ -153,6 +153,16 @@ struct J3DTevStage {
         return *this;
     }
 
+    J3DTevStage& operator=(J3DTevStage& other) {
+        mTevColorOp = other.mTevColorOp;
+        mTevColorAB = other.mTevColorAB;
+        mTevColorCD = other.mTevColorCD;
+        mTevAlphaOp = other.mTevAlphaOp;
+        mTevAlphaAB = other.mTevAlphaAB;
+        mTevSwapModeInfo = other.mTevSwapModeInfo;
+        return *this;
+    }
+
     /* 0x0 */ u8 field_0x0;
     /* 0x1 */ u8 mTevColorOp;
     /* 0x2 */ u8 mTevColorAB;
@@ -214,6 +224,16 @@ struct J3DIndTevStage {
         J3DGDWriteBPCmd(mInfo | (param_1 + 0x10) * 0x1000000);
     }
 
+    J3DIndTevStage& operator=(const J3DIndTevStage& other) {
+        mInfo = other.mInfo;
+        return *this;
+    }
+
+    J3DIndTevStage& operator=(J3DIndTevStage& other) {
+        mInfo = other.mInfo;
+        return *this;
+    }
+
     /* 0x0 */ u32 mInfo;
 };
 
@@ -264,6 +284,11 @@ struct J3DTevSwapModeTable {
         return *this;
     }
 
+    J3DTevSwapModeTable& operator=(J3DTevSwapModeTable& other) {
+        mIdx = other.mIdx;
+        return *this;
+    }
+
     u8 calcTevSwapTableID(u8 param_0, u8 param_1, u8 param_2, u8 param_3) {
         return 0x40 * param_0 + 0x10 * param_1 + 4 * param_2 + param_3;
     }
@@ -281,6 +306,7 @@ extern const GXColor j3dDefaultAmbInfo;
 extern const GXColorS10 j3dDefaultTevColor;
 extern const GXColor j3dDefaultTevKColor;
 extern u8 j3dAlphaCmpTable[768];
+extern const u8 j3dDefaultNumChans;
 
 struct J3DNBTScale;
 struct J3DTexCoord;
@@ -290,5 +316,9 @@ void loadTexNo(u32 param_0, u16 const& param_1);
 void patchTexNo_PtrToIdx(u32 texID, u16 const& idx);
 bool isTexNoReg(void* param_0);
 u16 getTexNoReg(void* param_0);
+void makeTexCoordTable();
+void makeAlphaCmpTable();
+void makeZModeTable();
+void makeTevSwapTable();
 
 #endif /* J3DTEVS_H */
diff --git a/include/JSystem/J3DGraphBase/J3DTexture.h b/include/JSystem/J3DGraphBase/J3DTexture.h
index 98b1a92295..66b6df3a40 100644
--- a/include/JSystem/J3DGraphBase/J3DTexture.h
+++ b/include/JSystem/J3DGraphBase/J3DTexture.h
@@ -2,9 +2,9 @@
 #define J3DTEXTURE_H
 
 #include "JSystem/J3DGraphBase/J3DStruct.h"
-#include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/J3DAssert.h"
 #include "JSystem/JUtility/JUTTexture.h"
-#include "dolphin/types.h"
+#include <stdint.h>
 
 /**
  * @ingroup jsystem-j3d
@@ -13,25 +13,28 @@
 class J3DTexture {
 private:
     /* 0x0 */ u16 mNum;
-    /* 0x2 */ u16 field_0x2;
+    /* 0x2 */ u16 unk_0x2;
     /* 0x4 */ ResTIMG* mpRes;
 
 public:
-    J3DTexture(u16 num, ResTIMG* res) : mNum(num), field_0x2(0), mpRes(res) {}
-    /* 8031204C */ void loadGX(u16, _GXTexMapID) const;
+    J3DTexture(u16 num, ResTIMG* res) : mNum(num), unk_0x2(0), mpRes(res) {}
+
+    /* 8031204C */ void loadGX(u16, GXTexMapID) const;
     /* 803121A4 */ void entryNum(u16);
     /* 8031221C */ void addResTIMG(u16, ResTIMG const*);
     /* 803366A4 */ virtual ~J3DTexture() {}
 
     u16 getNum() const { return mNum; }
-    ResTIMG* getResTIMG(u16 entry) const {
-        J3D_ASSERT(72, entry < mNum, "Error : range over.");
-        return &mpRes[entry];   
+
+    ResTIMG* getResTIMG(u16 index) const {
+        J3D_ASSERT_RANGE(72, index < mNum);
+        return &mpRes[index];   
     }
-    void setResTIMG(u16 entry, const ResTIMG& timg) {
-        mpRes[entry] = timg;
-        mpRes[entry].imageOffset = ((mpRes[entry].imageOffset + (u32)&timg - (u32)(mpRes + entry)));
-        mpRes[entry].paletteOffset = ((mpRes[entry].paletteOffset + (u32)&timg - (u32)(mpRes + entry)));
+
+    void setResTIMG(u16 index, const ResTIMG& timg) {
+        mpRes[index] = timg;
+        mpRes[index].imageOffset = ((mpRes[index].imageOffset + (uintptr_t)&timg - (uintptr_t)(mpRes + index)));
+        mpRes[index].paletteOffset = ((mpRes[index].paletteOffset + (uintptr_t)&timg - (uintptr_t)(mpRes + index)));
     }
 };
 
@@ -46,9 +49,11 @@ public:
     J3DTexMtx() {
         mTexMtxInfo = j3dDefaultTexMtxInfo;
     }
+
     J3DTexMtx(const J3DTexMtxInfo& info) {
         mTexMtxInfo = info;
     }
+
     /* 803238C4 */ void load(u32) const;
     /* 80323900 */ void calc(const Mtx);
     /* 80323920 */ void calcTexMtx(const Mtx);
@@ -103,7 +108,7 @@ struct J3DTexCoord : public J3DTexCoordInfo {
     void setTexMtxReg(u16 reg) { mTexMtxReg = reg; }
     J3DTexCoord& operator=(const J3DTexCoord& other) {
         // Fake match (__memcpy or = doesn't match)
-        *(u32*)this = *(u32*)&other;
+        *(uintptr_t*)this = *(uintptr_t*)&other;
         return *this;
     }
 
diff --git a/include/JSystem/J3DGraphBase/J3DTransform.h b/include/JSystem/J3DGraphBase/J3DTransform.h
index 384e132385..45e79de06f 100644
--- a/include/JSystem/J3DGraphBase/J3DTransform.h
+++ b/include/JSystem/J3DGraphBase/J3DTransform.h
@@ -1,8 +1,7 @@
 #ifndef J3DTRANSFORM_H
 #define J3DTRANSFORM_H
 
-#include "JSystem/JGeometry.h"
-#include "dolphin/mtx.h"
+#include <dolphin/mtx.h>
 
 struct J3DTextureSRTInfo;
 
diff --git a/include/JSystem/J3DGraphBase/J3DVertex.h b/include/JSystem/J3DGraphBase/J3DVertex.h
index 7c46b38a61..38b969f730 100644
--- a/include/JSystem/J3DGraphBase/J3DVertex.h
+++ b/include/JSystem/J3DGraphBase/J3DVertex.h
@@ -29,6 +29,7 @@ struct J3DVtxColorCalc {
 class J3DVertexData {
 public:
     J3DVertexData();
+    ~J3DVertexData() {}
 
     void* getVtxPosArray() const { return mVtxPosArray; }
     void* getVtxNrmArray() const { return mVtxNrmArray; }
@@ -38,10 +39,10 @@ public:
     u32 getNrmNum() const { return mNrmNum; }
     u32 getVtxNum() const { return mVtxNum; }
     GXVtxAttrFmtList* getVtxAttrFmtList() const { return mVtxAttrFmtList; }
-    u8 getVtxPosFrac() { return mVtxPosFrac; }
-    u8 getVtxNrmFrac() { return mVtxNrmFrac; }
-    int getVtxPosType() { return mVtxPosType; }
-    int getVtxNrmType() { return mVtxNrmType; }
+    u8 getVtxPosFrac() const { return mVtxPosFrac; }
+    u8 getVtxNrmFrac() const { return mVtxNrmFrac; }
+    int getVtxPosType() const { return mVtxPosType; }
+    int getVtxNrmType() const { return mVtxNrmType; }
 
     void setVtxPosFrac(u8 frac) { mVtxPosFrac = frac; }
     void setVtxPosType(GXCompType type) { mVtxPosType = type; }
@@ -148,8 +149,4 @@ private:
     /* 0x34 */ GXColor* mCurrentVtxCol;
 };  // Size: 0x38
 
-struct VertexNormal {
-    Vec data;
-};
-
 #endif /* J3DVERTEX_H */