some J3D/misc cleanup (#2628)

* some j3d cleanup

* begin using uintptr_t

* j3dgraphbase cleanup

* j3dgraphanimator cleanup

1 files changed, 570 insertions, 457 deletions

diff --git a/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp b/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
index 78f0cd70ab..caf7a91a91 100644
--- a/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
+++ b/src/JSystem/J3DGraphAnimator/J3DAnimation.cpp
@@ -1,19 +1,13 @@
-//
-// Generated By: dol2asm
-// Translation Unit: J3DAnimation
-//
-
 #include "JSystem/J3DGraphAnimator/J3DAnimation.h"
 #include "JSystem/J3DGraphBase/J3DStruct.h"
 #include "JSystem/JMath/JMath.h"
-#include "dolphin/os.h"
 
 /* 803283FC-8032842C 322D3C 0030+00 0/0 25/25 285/285 .text            init__12J3DFrameCtrlFs */
-void J3DFrameCtrl::init(s16 i_end) {
-    mAttribute = 2;
+void J3DFrameCtrl::init(s16 endFrame) {
+    mAttribute = EMode_LOOP;
     mState = 0;
     mStart = 0;
-    mEnd = i_end;
+    mEnd = endFrame;
     mLoop = 0;
     mRate = 1.0f;
     mFrame = 0.0f;
@@ -21,9 +15,8 @@ void J3DFrameCtrl::init(s16 i_end) {
 
 /* 8032842C-803289CC 322D6C 05A0+00 0/0 92/92 382/382 .text            checkPass__12J3DFrameCtrlFf
  */
-int J3DFrameCtrl::checkPass(f32 pass_frame) {
-    f32 cur_frame = mFrame;
-    f32 next_frame = cur_frame + mRate;
+int J3DFrameCtrl::checkPass(f32 passFrame) {
+    f32 next_frame = mFrame + mRate;
 
     switch (mAttribute) {
     case 0:
@@ -36,20 +29,20 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
             next_frame = mEnd - 0.001f;
         }
 
-        if (cur_frame <= next_frame) {
-            if (cur_frame <= pass_frame && pass_frame < next_frame) {
+        if (mFrame <= next_frame) {
+            if (mFrame <= passFrame && passFrame < next_frame) {
                 return true;
             } else {
                 return false;
             }
         }
 
-        if (next_frame <= pass_frame && pass_frame < cur_frame) {
+        if (next_frame <= passFrame && passFrame < mFrame) {
             return true;
         }
         return false;
     case 2:
-        if (cur_frame < mStart) {
+        if (mFrame < mStart) {
             while (next_frame < mStart) {
                 if (mLoop - mStart <= 0.0f) {
                     break;
@@ -57,12 +50,12 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
                 next_frame += mLoop - mStart;
             }
 
-            if (next_frame <= pass_frame && pass_frame < mLoop) {
+            if (next_frame <= passFrame && passFrame < mLoop) {
                 return true;
             } else {
                 return false;
             }
-        } else if (mEnd <= cur_frame) {
+        } else if (mEnd <= mFrame) {
             while (next_frame >= mEnd) {            
                 if (mEnd - mLoop <= 0.0f) {
                     break;
@@ -70,7 +63,7 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
                 next_frame -= mEnd - mLoop;
             }
 
-            if (mLoop <= pass_frame && pass_frame < next_frame) {
+            if (mLoop <= passFrame && passFrame < next_frame) {
                 return true;
             } else {
                 return false;
@@ -83,7 +76,7 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
                 next_frame += mLoop - mStart;
             }
 
-            if ((mStart <= pass_frame && pass_frame < cur_frame) || (next_frame <= pass_frame && pass_frame < mLoop)) {
+            if ((mStart <= passFrame && passFrame < mFrame) || (next_frame <= passFrame && passFrame < mLoop)) {
                 return true;
             } else {
                 return false;
@@ -97,18 +90,18 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
                 next_frame -= mEnd - mLoop;
             }
 
-            if ((cur_frame <= pass_frame && pass_frame < mEnd) || (mLoop <= pass_frame && pass_frame < next_frame)) {
+            if ((mFrame <= passFrame && passFrame < mEnd) || (mLoop <= passFrame && passFrame < next_frame)) {
                 return true;
             } else {
                 return false;
             }
-        } else if (cur_frame <= next_frame) {
-            if (cur_frame <= pass_frame && pass_frame < next_frame) {
+        } else if (mFrame <= next_frame) {
+            if (mFrame <= passFrame && passFrame < next_frame) {
                 return true;
             } else {
                 return false;
             }
-        } else if (next_frame <= pass_frame && pass_frame < cur_frame) {
+        } else if (next_frame <= passFrame && passFrame < mFrame) {
             return true;
         }
         return false;
@@ -122,15 +115,15 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
             next_frame = mStart;
         }
 
-        if (cur_frame <= next_frame) {
-            if (cur_frame <= pass_frame && pass_frame < next_frame) {
+        if (mFrame <= next_frame) {
+            if (mFrame <= passFrame && passFrame < next_frame) {
                 return true;
             } else {
                 return false;
             }
         }
 
-        if (next_frame <= pass_frame && pass_frame < cur_frame) {
+        if (next_frame <= passFrame && passFrame < mFrame) {
             return true;
         }
         return false;
@@ -144,48 +137,49 @@ int J3DFrameCtrl::checkPass(f32 pass_frame) {
 void J3DFrameCtrl::update() {
     mState = 0;
     mFrame += mRate;
+
     switch (mAttribute) {
-    case 0:
+    case EMode_NONE:
         if (mFrame < mStart) {
             mFrame = mStart;
             mRate = 0.0f;
-            mState |= 1;
+            mState |= (u8)1;
         }
         if (mFrame >= mEnd) {
             mFrame = mEnd - 0.001f;
             mRate = 0.0f;
-            mState |= 1;
+            mState |= (u8)1;
         }
         break;
-    case 1:
+    case EMode_RESET:
         if (mFrame < mStart) {
             mFrame = mStart;
             mRate = 0.0f;
-            mState |= 1;
+            mState |= (u8)1;
         }
         if (mFrame >= mEnd) {
             mFrame = mStart;
             mRate = 0.0f;
-            mState |= 1;
+            mState |= (u8)1;
         }
         break;
-    case 2:
+    case EMode_LOOP:
         while (mFrame < mStart) {
-            mState |= 2;
+            mState |= (u8)2;
             if (mLoop - mStart <= 0.0f) {
                 break;
             }
             mFrame += mLoop - mStart;
         }
         while (mFrame >= mEnd) {
-            mState |= 2;
+            mState |= (u8)2;
             if (mEnd - mLoop <= 0.0f) {
                 break;
             }
             mFrame -= mEnd - mLoop;
         }
         break;
-    case 3:
+    case EMode_REVERSE:
         if (mFrame >= mEnd) {
             mFrame = mEnd - (mFrame - mEnd);
             mRate = -mRate;
@@ -193,10 +187,10 @@ void J3DFrameCtrl::update() {
         if (mFrame < mStart) {
             mFrame = mStart - (mFrame - mStart);
             mRate = 0.0f;
-            mState |= 1;
+            mState |= (u8)1;
         }
         break;
-    case 4:
+    case EMode_LOOP_REVERSE:
         if (mFrame >= mEnd - 1.0f) {
             mFrame = (mEnd - 1.0f) - (mFrame - (mEnd - 1.0f));
             mRate = -mRate;
@@ -204,19 +198,18 @@ void J3DFrameCtrl::update() {
         if (mFrame < mStart) {
             mFrame = mStart - (mFrame - mStart);
             mRate = -mRate;
-            mState |= 2;
+            mState |= (u8)2;
         }
         break;
     }
 }
 
-
 /* 80328E40-80328E90 323780 0050+00 0/0 3/3 0/0 .text            __ct__15J3DAnmTransformFsPfPsPf */
-J3DAnmTransform::J3DAnmTransform(s16 param_0, f32* param_1, s16* param_2, f32* param_3)
- : J3DAnmBase(param_0) {
-    mScaleData = param_1;
-    mRotData = param_2;
-    mTransData = param_3;
+J3DAnmTransform::J3DAnmTransform(s16 frameMax, f32* pScaleData, s16* pRotData, f32* pTransData)
+ : J3DAnmBase(frameMax) {
+    mScaleData = pScaleData;
+    mRotData = pRotData;
+    mTransData = pTransData;
     field_0x18 = 0;
     field_0x1a = 0;
     field_0x1c = 0;
@@ -225,169 +218,207 @@ J3DAnmTransform::J3DAnmTransform(s16 param_0, f32* param_1, s16* param_2, f32* p
 
 /* 80328E90-803291F0 3237D0 0360+00 1/0 0/0 0/0 .text
  * getTransform__19J3DAnmTransformFullCFUsP16J3DTransformInfo   */
-void J3DAnmTransformFull::getTransform(u16 i_index, J3DTransformInfo* o_transform) const {
-    u16 idx = i_index * 3;
+void J3DAnmTransformFull::getTransform(u16 jointNo, J3DTransformInfo* pTransform) const {
+    J3D_ASSERT_RANGE(317, jointNo >= 0 && jointNo < field_0x1e);
+    J3D_ASSERT_NULLPTR(318, pTransform != NULL);
+
+    u16 idx = jointNo * 3;
     J3DAnmTransformFullTable* entryX = &mAnmTable[idx];
     J3DAnmTransformFullTable* entryY = &mAnmTable[idx + 1];
     J3DAnmTransformFullTable* entryZ = &mAnmTable[idx + 2];
+
     if (mFrame < 0.0f) {
-        o_transform->mScale.x = mScaleData[entryX->mScaleOffset];
-        o_transform->mScale.y = mScaleData[entryY->mScaleOffset];
-        o_transform->mScale.z = mScaleData[entryZ->mScaleOffset];
-        o_transform->mRotation.x = mRotData[entryX->mRotationOffset];
-        o_transform->mRotation.y = mRotData[entryY->mRotationOffset];
-        o_transform->mRotation.z = mRotData[entryZ->mRotationOffset];
-        o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset];
-        o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset];
-        o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
+        pTransform->mScale.x = mScaleData[entryX->mScaleOffset];
+        pTransform->mScale.y = mScaleData[entryY->mScaleOffset];
+        pTransform->mScale.z = mScaleData[entryZ->mScaleOffset];
+
+        pTransform->mRotation.x = mRotData[entryX->mRotationOffset];
+        pTransform->mRotation.y = mRotData[entryY->mRotationOffset];
+        pTransform->mRotation.z = mRotData[entryZ->mRotationOffset];
+
+        pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset];
+        pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset];
+        pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
     } else {
+        u32 frame_max;
         u32 frame = (int)(mFrame + 0.5f);
-        if (frame >= entryX->mScaleMaxFrame) {
-            o_transform->mScale.x = mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+
+        frame_max = entryX->mScaleMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
         } else {
-            o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
+            pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
         }
-        if (frame >= entryX->mRotationMaxFrame) {
-            o_transform->mRotation.x =
-                mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+        frame_max = entryX->mRotationMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
         } else {
-            o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
+            pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
         }
-        if (frame >= entryX->mTranslateMaxFrame) {
-            o_transform->mTranslate.x =
-                mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+        frame_max = entryX->mTranslateMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
         } else {
-            o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
+            pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
         }
-        if (frame >= entryY->mScaleMaxFrame) {
-            o_transform->mScale.y = mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+        frame_max = entryY->mScaleMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
         } else {
-            o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
+            pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
         }
-        if (frame >= entryY->mRotationMaxFrame) {
-            o_transform->mRotation.y =
-                mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+        frame_max = entryY->mRotationMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
         } else {
-            o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
+            pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
         }
-        if (frame >= entryY->mTranslateMaxFrame) {
-            o_transform->mTranslate.y =
-                mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+        frame_max = entryY->mTranslateMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
         } else {
-            o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
+            pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
         }
-        if (frame >= entryZ->mScaleMaxFrame) {
-            o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+        frame_max = entryZ->mScaleMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
         } else {
-            o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
+            pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
         }
-        if (frame >= entryZ->mRotationMaxFrame) {
-            o_transform->mRotation.z =
-                mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+        frame_max = entryZ->mRotationMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
         } else {
-            o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
+            pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
         }
-        if (frame >= entryZ->mTranslateMaxFrame) {
-            o_transform->mTranslate.z =
-                mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+        frame_max = entryZ->mTranslateMaxFrame;
+        if (frame >= frame_max) {
+            pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
         } else {
-            o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
+            pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
         }
     }
 }
 
 /* 803291F0-80329A34 323B30 0844+00 1/0 0/0 0/0 .text
  * getTransform__27J3DAnmTransformFullWithLerpCFUsP16J3DTransformInfo */
-void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_transform) const {
-    u16 idx = i_index * 3;
+void J3DAnmTransformFullWithLerp::getTransform(u16 jointNo, J3DTransformInfo* pTransform) const {
+    J3D_ASSERT_RANGE(421, jointNo >= 0 && jointNo < field_0x1e);
+    J3D_ASSERT_NULLPTR(422, pTransform != NULL);
+
+    u16 idx = jointNo * 3;
     J3DAnmTransformFullTable* entryX = &mAnmTable[idx];
     J3DAnmTransformFullTable* entryY = &mAnmTable[idx + 1];
     J3DAnmTransformFullTable* entryZ = &mAnmTable[idx + 2];
+
     if (mFrame < 0.0f) {
-        o_transform->mScale.x = mScaleData[entryX->mScaleOffset];
-        o_transform->mScale.y = mScaleData[entryY->mScaleOffset];
-        o_transform->mScale.z = mScaleData[entryZ->mScaleOffset];
-        o_transform->mRotation.x = mRotData[entryX->mRotationOffset];
-        o_transform->mRotation.y = mRotData[entryY->mRotationOffset];
-        o_transform->mRotation.z = mRotData[entryZ->mRotationOffset];
-        o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset];
-        o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset];
-        o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
+        pTransform->mScale.x = mScaleData[entryX->mScaleOffset];
+        pTransform->mScale.y = mScaleData[entryY->mScaleOffset];
+        pTransform->mScale.z = mScaleData[entryZ->mScaleOffset];
+
+        pTransform->mRotation.x = mRotData[entryX->mRotationOffset];
+        pTransform->mRotation.y = mRotData[entryY->mRotationOffset];
+        pTransform->mRotation.z = mRotData[entryZ->mRotationOffset];
+
+        pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset];
+        pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset];
+        pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset];
     } else {
-        int frame_ = (int)mFrame;
-        u32 frame = frame_;
-        if (frame_ == mFrame) {
-            if (frame >= entryX->mScaleMaxFrame) {
-                o_transform->mScale.x =
-                    mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+        u32 frame_max;
+        int frame = (int)mFrame;
+
+        if (frame == mFrame) {
+            frame_max = entryX->mScaleMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
+                pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame];
             }
-            if (frame >= entryX->mRotationMaxFrame) {
-                o_transform->mRotation.x =
-                    mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+            frame_max = entryX->mRotationMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
             } else {
-                o_transform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
+                pTransform->mRotation.x = mRotData[entryX->mRotationOffset + frame];
             }
-            if (frame >= entryX->mTranslateMaxFrame) {
-                o_transform->mTranslate.x =
-                    mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+            frame_max = entryX->mTranslateMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
+                pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame];
             }
-            if (frame >= entryY->mScaleMaxFrame) {
-                o_transform->mScale.y =
-                    mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+            frame_max = entryY->mScaleMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
+                pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame];
             }
-            if (frame >= entryY->mRotationMaxFrame) {
-                o_transform->mRotation.y =
-                    mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+            frame_max = entryY->mRotationMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
             } else {
-                o_transform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
+                pTransform->mRotation.y = mRotData[entryY->mRotationOffset + frame];
             }
-            if (frame >= entryY->mTranslateMaxFrame) {
-                o_transform->mTranslate.y =
-                    mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+            frame_max = entryY->mTranslateMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
+                pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame];
             }
-            if (frame >= entryZ->mScaleMaxFrame) {
-                o_transform->mScale.z =
-                    mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+            frame_max = entryZ->mScaleMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
+                pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame];
             }
-            if (frame >= entryZ->mRotationMaxFrame) {
-                o_transform->mRotation.z =
-                    mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+            frame_max = entryZ->mRotationMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
             } else {
-                o_transform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
+                pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + frame];
             }
-            if (frame >= entryZ->mTranslateMaxFrame) {
-                o_transform->mTranslate.z =
-                    mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+            frame_max = entryZ->mTranslateMaxFrame;
+            if (frame >= frame_max) {
+                pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
+                pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame];
             }
         } else {
-            f32 rate = mFrame - frame_;
-            u32 frame2 = frame + 1;
-            if (frame2 >= entryX->mScaleMaxFrame) {
-                o_transform->mScale.x =
-                    mScaleData[entryX->mScaleOffset + (entryX->mScaleMaxFrame - 1)];
+            f32 rate = mFrame - frame;
+            f32 var_f30 = 1.0f - rate;
+
+            u32 next_frame = frame + 1;
+
+            frame_max = entryX->mScaleMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mScale.x = mScaleData[entryX->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
-                    + rate * (mScaleData[entryX->mScaleOffset + frame2]
+                pTransform->mScale.x = mScaleData[entryX->mScaleOffset + frame]
+                    + rate * (mScaleData[entryX->mScaleOffset + next_frame]
                             - mScaleData[entryX->mScaleOffset + frame]);
             }
-            if (frame2 >= entryX->mRotationMaxFrame) {
-                o_transform->mRotation.x =
-                    mRotData[entryX->mRotationOffset + (entryX->mRotationMaxFrame - 1)];
+
+            frame_max = entryX->mRotationMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mRotation.x = mRotData[entryX->mRotationOffset + (frame_max - 1)];
             } else {
                 u32 rot1 = (u16)mRotData[entryX->mRotationOffset + frame];
-                u32 rot2 = (u16)mRotData[entryX->mRotationOffset + frame2];
+                u32 rot2 = (u16)mRotData[entryX->mRotationOffset + next_frame];
                 int delta = rot2 - rot1;
                 if (delta > 0x8000) {
                     rot1 += 0x10000;
@@ -395,30 +426,33 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
                 } else if (-delta > 0x8000) {
                     delta += 0x10000;
                 }
-                o_transform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
+                pTransform->mRotation.x = (u32)((f32)rot1 + rate * (f32)delta);
             }
-            if (frame2 >= entryX->mTranslateMaxFrame) {
-                o_transform->mTranslate.x =
-                    mTransData[entryX->mTranslateOffset + (entryX->mTranslateMaxFrame - 1)];
+
+            frame_max = entryX->mTranslateMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
-                    + rate * (mTransData[entryX->mTranslateOffset + frame2]
+                pTransform->mTranslate.x = mTransData[entryX->mTranslateOffset + frame]
+                    + rate * (mTransData[entryX->mTranslateOffset + next_frame]
                             - mTransData[entryX->mTranslateOffset + frame]);
             }
-            if (frame2 >= entryY->mScaleMaxFrame) {
-                o_transform->mScale.y =
-                    mScaleData[entryY->mScaleOffset + (entryY->mScaleMaxFrame - 1)];
+
+            frame_max = entryY->mScaleMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mScale.y = mScaleData[entryY->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
-                    + rate * (mScaleData[entryY->mScaleOffset + frame2]
+                pTransform->mScale.y = mScaleData[entryY->mScaleOffset + frame]
+                    + rate * (mScaleData[entryY->mScaleOffset + next_frame]
                             - mScaleData[entryY->mScaleOffset + frame]);
             }
-            if (frame2 >= entryY->mRotationMaxFrame) {
-                o_transform->mRotation.y =
-                    mRotData[entryY->mRotationOffset + (entryY->mRotationMaxFrame - 1)];
+
+            frame_max = entryY->mRotationMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mRotation.y = mRotData[entryY->mRotationOffset + (frame_max - 1)];
             } else {
                 u32 rot1 = (u16)mRotData[entryY->mRotationOffset + frame];
-                u32 rot2 = (u16)mRotData[entryY->mRotationOffset + frame2];
+                u32 rot2 = (u16)mRotData[entryY->mRotationOffset + next_frame];
                 int delta = rot2 - rot1;
                 if (delta > 0x8000) {
                     rot1 += 0x10000;
@@ -426,30 +460,33 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
                 } else if (-delta > 0x8000) {
                     delta += 0x10000;
                 }
-                o_transform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
+                pTransform->mRotation.y = (u32)((f32)rot1 + rate * (f32)delta);
             }
-            if (frame2 >= entryY->mTranslateMaxFrame) {
-                o_transform->mTranslate.y =
-                    mTransData[entryY->mTranslateOffset + (entryY->mTranslateMaxFrame - 1)];
+
+            frame_max = entryY->mTranslateMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
-                    + rate * (mTransData[entryY->mTranslateOffset + frame2]
+                pTransform->mTranslate.y = mTransData[entryY->mTranslateOffset + frame]
+                    + rate * (mTransData[entryY->mTranslateOffset + next_frame]
                             - mTransData[entryY->mTranslateOffset + frame]);
             }
-            if (frame2 >= entryZ->mScaleMaxFrame) {
-                o_transform->mScale.z =
-                    mScaleData[entryZ->mScaleOffset + (entryZ->mScaleMaxFrame - 1)];
+
+            frame_max = entryZ->mScaleMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + (frame_max - 1)];
             } else {
-                o_transform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
-                    + rate * (mScaleData[entryZ->mScaleOffset + frame2]
+                pTransform->mScale.z = mScaleData[entryZ->mScaleOffset + frame]
+                    + rate * (mScaleData[entryZ->mScaleOffset + next_frame]
                             - mScaleData[entryZ->mScaleOffset + frame]);
             }
-            if (frame2 >= entryZ->mRotationMaxFrame) {
-                o_transform->mRotation.z =
-                    mRotData[entryZ->mRotationOffset + (entryZ->mRotationMaxFrame - 1)];
+
+            frame_max = entryZ->mRotationMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mRotation.z = mRotData[entryZ->mRotationOffset + (frame_max - 1)];
             } else {
                 u32 rot1 = (u16)mRotData[entryZ->mRotationOffset + frame];
-                u32 rot2 = (u16)mRotData[entryZ->mRotationOffset + frame2];
+                u32 rot2 = (u16)mRotData[entryZ->mRotationOffset + next_frame];
                 int delta = rot2 - rot1;
                 if (delta > 0x8000) {
                     rot1 += 0x10000;
@@ -457,14 +494,15 @@ void J3DAnmTransformFullWithLerp::getTransform(u16 i_index, J3DTransformInfo* o_
                 } else if (-delta > 0x8000) {
                     delta += 0x10000;
                 }
-                o_transform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
+                pTransform->mRotation.z = (u32)((f32)rot1 + rate * (f32)delta);
             }
-            if (frame2 >= entryZ->mTranslateMaxFrame) {
-                o_transform->mTranslate.z =
-                    mTransData[entryZ->mTranslateOffset + (entryZ->mTranslateMaxFrame - 1)];
+
+            frame_max = entryZ->mTranslateMaxFrame;
+            if (next_frame >= frame_max) {
+                pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + (frame_max - 1)];
             } else {
-                o_transform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
-                    + rate * (mTransData[entryZ->mTranslateOffset + frame2]
+                pTransform->mTranslate.z = mTransData[entryZ->mTranslateOffset + frame]
+                    + rate * (mTransData[entryZ->mTranslateOffset + next_frame]
                             - mTransData[entryZ->mTranslateOffset + frame]);
             }
         }
@@ -524,275 +562,294 @@ inline f32 J3DHermiteInterpolation(register f32 pp1, register s16 const* pp2,
 }
 
 template<typename T>
-f32 J3DGetKeyFrameInterpolation(f32 i_frame, J3DAnmKeyTableBase* i_entry, T* i_data) {
-    if (i_frame < i_data[0]) {
-        return i_data[1];
+f32 J3DGetKeyFrameInterpolation(f32 frame, J3DAnmKeyTableBase* pKeyTable, T* pData) {
+    J3D_ASSERT_NULLPTR(740, pData != NULL);
+
+    if (frame < pData[0]) {
+        return pData[1];
     }
-    if (i_entry->mType == 0) {
-        u32 idx = i_entry->mMaxFrame - 1;
-        if (i_data[idx * 3] <= i_frame) {
-            return i_data[idx * 3 + 1];
+
+    if (pKeyTable->mType == 0) {
+        u32 idx = pKeyTable->mMaxFrame - 1;
+        if (pData[idx * 3] <= frame) {
+            return pData[idx * 3 + 1];
         }
-        u32 uVar7 = i_entry->mMaxFrame;
+
+        u32 uVar7 = pKeyTable->mMaxFrame;
         while (uVar7 > 1) {
             u32 uVar2 = uVar7 >> 1;
             u32 tmp = uVar2 * 3;
-            if (i_frame >= i_data[tmp]) {
-                i_data += tmp;
+            if (frame >= pData[tmp]) {
+                pData += tmp;
                 uVar7 = uVar7 - uVar2;
             } else {
                 uVar7 = uVar2;
             }
         }
-        return J3DHermiteInterpolation(i_frame, &i_data[0], &i_data[1], &i_data[2],
-                                       &i_data[3], &i_data[4], &i_data[5]);
+
+        f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[2], &pData[3], &pData[4], &pData[5]);
+        return interpolated;
     } else {
-        u32 idx = i_entry->mMaxFrame - 1;
-        if (i_data[idx * 4] <= i_frame) {
-            return i_data[idx * 4 + 1];
+        u32 idx = pKeyTable->mMaxFrame - 1;
+        if (pData[idx * 4] <= frame) {
+            return pData[idx * 4 + 1];
         }
-        u32 uVar7 = i_entry->mMaxFrame;
-        while (uVar7 > 1) {
-            u32 uVar2 = uVar7 >> 1;
-            if (i_frame >= i_data[uVar2 * 4]) {
-                i_data += uVar2 * 4;
-                uVar7 = uVar7 - uVar2;
+
+        u32 var_r27 = pKeyTable->mMaxFrame;
+        while (var_r27 > 1) {
+            u32 var_r25 = var_r27 >> 1;
+            u32 var_r23 = var_r25 * 4;
+            if (frame >= pData[var_r23]) {
+                pData += var_r23;
+                var_r27 = var_r27 - var_r25;
             } else {
-                uVar7 = uVar2;
+                var_r27 = var_r25;
             }
         }
-        return J3DHermiteInterpolation(i_frame, &i_data[0], &i_data[1], &i_data[3],
-                                       &i_data[4], &i_data[5], &i_data[6]);
+
+        f32 interpolated = J3DHermiteInterpolation(frame, &pData[0], &pData[1], &pData[3], &pData[4], &pData[5], &pData[6]);
+        return interpolated;
     }
 }
 
 /* 80329A34-80329E5C 324374 0428+00 0/0 1/1 0/0 .text
  * calcTransform__18J3DAnmTransformKeyCFfUsP16J3DTransformInfo  */
-void J3DAnmTransformKey::calcTransform(f32 i_frame, u16 i_index,
-                                       J3DTransformInfo* o_transform) const {
-    u16 idx = i_index * 3;
+void J3DAnmTransformKey::calcTransform(f32 frame, u16 jointNo, J3DTransformInfo* pTransform) const {
+    J3D_ASSERT_RANGE(829, jointNo >= 0 && jointNo < field_0x1e);
+    J3D_ASSERT_NULLPTR(830, pTransform != NULL);
+
+    u16 idx = jointNo * 3;
     J3DAnmTransformKeyTable* entryX = &mAnmTable[idx];
     J3DAnmTransformKeyTable* entryY = &mAnmTable[idx + 1];
     J3DAnmTransformKeyTable* entryZ = &mAnmTable[idx + 2];
+
     switch (entryX->mScaleInfo.mMaxFrame) {
     case 0:
-        o_transform->mScale.x = 1.0f;
+        pTransform->mScale.x = 1.0f;
         break;
     case 1:
-        o_transform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
+        pTransform->mScale.x = mScaleData[entryX->mScaleInfo.mOffset];
         break;
     default:
-        o_transform->mScale.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
+        pTransform->mScale.x = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
                                                 &mScaleData[entryX->mScaleInfo.mOffset]);
     }
+
     switch (entryY->mScaleInfo.mMaxFrame) {
     case 0:
-        o_transform->mScale.y = 1.0f;
+        pTransform->mScale.y = 1.0f;
         break;
     case 1:
-        o_transform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
+        pTransform->mScale.y = mScaleData[entryY->mScaleInfo.mOffset];
         break;
     default:
-        o_transform->mScale.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
+        pTransform->mScale.y = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
                                                 &mScaleData[entryY->mScaleInfo.mOffset]);
     }
+
     switch (entryZ->mScaleInfo.mMaxFrame) {
     case 0:
-        o_transform->mScale.z = 1.0f;
+        pTransform->mScale.z = 1.0f;
         break;
     case 1:
-        o_transform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
+        pTransform->mScale.z = mScaleData[entryZ->mScaleInfo.mOffset];
         break;
     default:
-        o_transform->mScale.z = J3DGetKeyFrameInterpolation(i_frame, &entryZ->mScaleInfo,
+        pTransform->mScale.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mScaleInfo,
                                                 &mScaleData[entryZ->mScaleInfo.mOffset]);
     }
+
     switch (entryX->mRotationInfo.mMaxFrame) {
     case 0:
-        o_transform->mRotation.x = 0;
+        pTransform->mRotation.x = 0;
         break;
     case 1:
-        o_transform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
+        pTransform->mRotation.x = mRotData[entryX->mRotationInfo.mOffset] << mDecShift;
         break;
     default:
-        o_transform->mRotation.x = (int)J3DGetKeyFrameInterpolation(i_frame, &entryX->mRotationInfo,
+        pTransform->mRotation.x = (int)J3DGetKeyFrameInterpolation(frame, &entryX->mRotationInfo,
                                             &mRotData[entryX->mRotationInfo.mOffset]) << mDecShift;
     }
+
     switch (entryY->mRotationInfo.mMaxFrame) {
     case 0:
-        o_transform->mRotation.y = 0;
+        pTransform->mRotation.y = 0;
         break;
     case 1:
-        o_transform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
+        pTransform->mRotation.y = mRotData[entryY->mRotationInfo.mOffset] << mDecShift;
         break;
     default:
-        o_transform->mRotation.y = (int)J3DGetKeyFrameInterpolation(i_frame, &entryY->mRotationInfo,
+        pTransform->mRotation.y = (int)J3DGetKeyFrameInterpolation(frame, &entryY->mRotationInfo,
                                             &mRotData[entryY->mRotationInfo.mOffset]) << mDecShift;
     }
+
     switch (entryZ->mRotationInfo.mMaxFrame) {
     case 0:
-        o_transform->mRotation.z = 0;
+        pTransform->mRotation.z = 0;
         break;
     case 1:
-        o_transform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
+        pTransform->mRotation.z = mRotData[entryZ->mRotationInfo.mOffset] << mDecShift;
         break;
     default:
-        o_transform->mRotation.z = (int)J3DGetKeyFrameInterpolation(i_frame, &entryZ->mRotationInfo,
+        pTransform->mRotation.z = (int)J3DGetKeyFrameInterpolation(frame, &entryZ->mRotationInfo,
                                             &mRotData[entryZ->mRotationInfo.mOffset]) << mDecShift;
     }
+
     switch (entryX->mTranslateInfo.mMaxFrame) {
     case 0:
-        o_transform->mTranslate.x = 0.0f;
+        pTransform->mTranslate.x = 0.0f;
         break;
     case 1:
-        o_transform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
+        pTransform->mTranslate.x = mTransData[entryX->mTranslateInfo.mOffset];
         break;
     default:
-        o_transform->mTranslate.x = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
+        pTransform->mTranslate.x = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
                                                     &mTransData[entryX->mTranslateInfo.mOffset]);
     }
+
     switch (entryY->mTranslateInfo.mMaxFrame) {
     case 0:
-        o_transform->mTranslate.y = 0.0f;
+        pTransform->mTranslate.y = 0.0f;
         break;
     case 1:
-        o_transform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
+        pTransform->mTranslate.y = mTransData[entryY->mTranslateInfo.mOffset];
         break;
     default:
-        o_transform->mTranslate.y = J3DGetKeyFrameInterpolation(i_frame, &entryY->mTranslateInfo,
+        pTransform->mTranslate.y = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
                                                     &mTransData[entryY->mTranslateInfo.mOffset]);
     }
+
     switch (entryZ->mTranslateInfo.mMaxFrame) {
     case 0:
-        o_transform->mTranslate.z = 0.0f;
+        pTransform->mTranslate.z = 0.0f;
         break;
     case 1:
-        o_transform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
+        pTransform->mTranslate.z = mTransData[entryZ->mTranslateInfo.mOffset];
         break;
     default:
-        o_transform->mTranslate.z = J3DGetKeyFrameInterpolation(i_frame, &entryZ->mTranslateInfo,
+        pTransform->mTranslate.z = J3DGetKeyFrameInterpolation(frame, &entryZ->mTranslateInfo,
                                                     &mTransData[entryZ->mTranslateInfo.mOffset]);
     }
 }
 
 /* 80329E5C-80329F14 32479C 00B8+00 0/0 2/2 0/0 .text            __ct__19J3DAnmTextureSRTKeyFv */
-J3DAnmTextureSRTKey::J3DAnmTextureSRTKey() : J3DAnmBase(0) {
+J3DAnmTextureSRTKey::J3DAnmTextureSRTKey() {
     mDecShift = 0;
-    mTransNum = 0;
-    mRotNum = 0;
-    mScaleNum = 0;
-    mTrackNum = 0;
+    mTrackNum = mScaleNum = mRotNum = mTransNum = 0;
     mAnmTable = NULL;
-    mTransData = NULL;
-    mScaleData = NULL;
+    mScaleData = mTransData = NULL;
     mRotData = NULL;
-    field_0x48 = 0;
-    field_0x46 = 0;
-    field_0x44 = 0;
-    field_0x4a = 0;
+    field_0x4a = field_0x44 = field_0x46 = field_0x48 = 0;
     field_0x58 = NULL;
-    field_0x54 = NULL;
-    field_0x4c = NULL;
+    field_0x4c = field_0x54 = NULL;
     field_0x50 = NULL;
     mTexMtxCalcType = 0;
 }
 
-
 /* 80329F14-8032A184 324854 0270+00 0/0 1/1 0/0 .text
  * calcTransform__19J3DAnmTextureSRTKeyCFfUsP17J3DTextureSRTInfo */
-void J3DAnmTextureSRTKey::calcTransform(f32 i_frame, u16 i_index,
-                                        J3DTextureSRTInfo* o_texinfo) const {
-    u16 idx = i_index * 3;
+void J3DAnmTextureSRTKey::calcTransform(f32 frame, u16 jointNo, J3DTextureSRTInfo* pTexSRTInfo) const {
+    J3D_ASSERT_RANGE(992, jointNo >= 0 && jointNo < mTrackNum);
+    J3D_ASSERT_NULLPTR(993, pTexSRTInfo != NULL);
+
+    u16 idx = jointNo * 3;
     J3DAnmTransformKeyTable* entryX = &mAnmTable[idx];
     J3DAnmTransformKeyTable* entryY = &mAnmTable[idx + 1];
     J3DAnmTransformKeyTable* entryRot = &mAnmTable[idx + 2];
+
     switch (entryX->mScaleInfo.mMaxFrame) {
     case 0:
-        o_texinfo->mScaleX = 1.0f;
+        pTexSRTInfo->mScaleX = 1.0f;
         break;
     case 1:
-        o_texinfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
+        pTexSRTInfo->mScaleX = mScaleData[entryX->mScaleInfo.mOffset];
         break;
     default:
-        o_texinfo->mScaleX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mScaleInfo,
+        pTexSRTInfo->mScaleX = J3DGetKeyFrameInterpolation(frame, &entryX->mScaleInfo,
                                                 &mScaleData[entryX->mScaleInfo.mOffset]);
     }
+
     switch (entryY->mScaleInfo.mMaxFrame) {
     case 0:
-        o_texinfo->mScaleY = 1.0f;
+        pTexSRTInfo->mScaleY = 1.0f;
         break;
     case 1:
-        o_texinfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
+        pTexSRTInfo->mScaleY = mScaleData[entryY->mScaleInfo.mOffset];
         break;
     default:
-        o_texinfo->mScaleY = J3DGetKeyFrameInterpolation(i_frame, &entryY->mScaleInfo,
+        pTexSRTInfo->mScaleY = J3DGetKeyFrameInterpolation(frame, &entryY->mScaleInfo,
                                                 &mScaleData[entryY->mScaleInfo.mOffset]);
     }
+
     switch (entryRot->mRotationInfo.mMaxFrame) {
     case 0:
-        o_texinfo->mRotation = 0;
+        pTexSRTInfo->mRotation = 0;
         break;
     case 1:
-        o_texinfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
+        pTexSRTInfo->mRotation = mRotData[entryRot->mRotationInfo.mOffset] << mDecShift;
         break;
     default:
-        o_texinfo->mRotation = (int)J3DGetKeyFrameInterpolation(i_frame, &entryRot->mRotationInfo,
+        pTexSRTInfo->mRotation = (int)J3DGetKeyFrameInterpolation(frame, &entryRot->mRotationInfo,
                                         &mRotData[entryRot->mRotationInfo.mOffset]) << mDecShift;
     }
+
     switch (entryX->mTranslateInfo.mMaxFrame) {
     case 0:
-        o_texinfo->mTranslationX = 0.0f;
+        pTexSRTInfo->mTranslationX = 0.0f;
         break;
     case 1:
-        o_texinfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
+        pTexSRTInfo->mTranslationX = mTransData[entryX->mTranslateInfo.mOffset];
         break;
     default:
-        o_texinfo->mTranslationX = J3DGetKeyFrameInterpolation(i_frame, &entryX->mTranslateInfo,
+        pTexSRTInfo->mTranslationX = J3DGetKeyFrameInterpolation(frame, &entryX->mTranslateInfo,
                                                     &mTransData[entryX->mTranslateInfo.mOffset]);
     }
+
     switch (entryY->mTranslateInfo.mMaxFrame) {
     case 0:
-        o_texinfo->mTranslationY = 0.0f;
+        pTexSRTInfo->mTranslationY = 0.0f;
         break;
     case 1:
-        o_texinfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
+        pTexSRTInfo->mTranslationY = mTransData[entryY->mTranslateInfo.mOffset];
         break;
     default:
-        o_texinfo->mTranslationY = J3DGetKeyFrameInterpolation(i_frame, &entryY->mTranslateInfo,
+        pTexSRTInfo->mTranslationY = J3DGetKeyFrameInterpolation(frame, &entryY->mTranslateInfo,
                                                     &mTransData[entryY->mTranslateInfo.mOffset]);
     }
 }
 
 /* 8032A184-8032A218 324AC4 0094+00 1/0 0/0 0/0 .text            getWeight__17J3DAnmClusterFullCFUs
  */
-f32 J3DAnmClusterFull::getWeight(u16 i_index) const {
-    int maxFrame = mAnmTable[i_index].mMaxFrame;
+f32 J3DAnmClusterFull::getWeight(u16 index) const {
+    int maxFrame = mAnmTable[index].mMaxFrame;
     int frame = (int)(mFrame + 0.5f);
+
     if (mFrame < 0.0f) {
-        return mWeight[mAnmTable[i_index].mOffset];
-    } else if (frame >= maxFrame) {
-        return mWeight[mAnmTable[i_index].mOffset + (maxFrame - 1)];
+        return mWeight[mAnmTable[index].mOffset];
+    } else if (frame >= (u16)maxFrame) {
+        return mWeight[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
     } else {
-        return mWeight[mAnmTable[i_index].mOffset + frame];
+        return mWeight[mAnmTable[index].mOffset + frame];
     }
 }
 
 /* 8032A218-8032A29C 324B58 0084+00 1/0 0/0 0/0 .text            getWeight__16J3DAnmClusterKeyCFUs
  */
-f32 J3DAnmClusterKey::getWeight(u16 i_index) const {
-    switch (mAnmTable[i_index].mWeightTable.mMaxFrame) {
+f32 J3DAnmClusterKey::getWeight(u16 index) const {
+    int maxFrame = (u16)mAnmTable[index].mWeightTable.mMaxFrame;
+    switch (maxFrame) {
     case 0:
         return 1.0f;
     case 1:
-        return mWeight[mAnmTable[i_index].mWeightTable.mOffset];
+        return mWeight[mAnmTable[index].mWeightTable.mOffset];
     default:
-        return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[i_index].mWeightTable,
-                                           &mWeight[mAnmTable[i_index].mWeightTable.mOffset]);
+        return J3DGetKeyFrameInterpolation(mFrame, &mAnmTable[index].mWeightTable,
+                                           &mWeight[mAnmTable[index].mWeightTable.mOffset]);
     }
 }
 
 /* 8032A29C-8032A30C 324BDC 0070+00 2/2 0/0 0/0 .text            __ct__14J3DAnmVtxColorFv */
-J3DAnmVtxColor::J3DAnmVtxColor() : J3DAnmBase(0) {
+J3DAnmVtxColor::J3DAnmVtxColor() {
     for (int i = 0; i < 2; i++) {
         mAnmTableNum[i] = 0;
     }
@@ -801,7 +858,6 @@ J3DAnmVtxColor::J3DAnmVtxColor() : J3DAnmBase(0) {
     }
 }
 
-
 /* 8032A30C-8032A368 324C4C 005C+00 0/0 1/1 0/0 .text            __ct__18J3DAnmVtxColorFullFv */
 J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
     for (int i = 0; i < 2; i++) {
@@ -811,34 +867,45 @@ J3DAnmVtxColorFull::J3DAnmVtxColorFull() {
 
 /* 8032A368-8032A4E0 324CA8 0178+00 1/0 0/0 0/0 .text
  * getColor__18J3DAnmVtxColorFullCFUcUsP8_GXColor               */
-void J3DAnmVtxColorFull::getColor(u8 i_table, u16 i_index, GXColor* o_color) const {
-    J3DAnmColorFullTable* entry = &mpTable[i_table][i_index];
+void J3DAnmVtxColorFull::getColor(u8 tableNo, u16 index, GXColor* pColor) const {
+    J3D_ASSERT_NULLPTR(1254, pColor != NULL);
+    J3DAnmColorFullTable* entry = &mpTable[tableNo][index];
+
     if (mFrame < 0.0f) {
-        o_color->r = mColorR[entry->mROffset];
-        o_color->g = mColorG[entry->mGOffset];
-        o_color->b = mColorB[entry->mBOffset];
-        o_color->a = mColorA[entry->mAOffset];
+        pColor->r = mColorR[entry->mROffset];
+        pColor->g = mColorG[entry->mGOffset];
+        pColor->b = mColorB[entry->mBOffset];
+        pColor->a = mColorA[entry->mAOffset];
     } else {
         int frame = (int)(mFrame + 0.5f);
-        if (frame >= entry->mRMaxFrame) {
-            o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
+        u16 maxFrame;
+
+        maxFrame = entry->mRMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
         } else {
-            o_color->r = mColorR[entry->mROffset + frame];
+            pColor->r = mColorR[entry->mROffset + frame];
         }
-        if (frame >= entry->mGMaxFrame) {
-            o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
+
+        maxFrame = entry->mGMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
         } else {
-            o_color->g = mColorG[entry->mGOffset + frame];
+            pColor->g = mColorG[entry->mGOffset + frame];
         }
-        if (frame >= entry->mBMaxFrame) {
-            o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
+
+        maxFrame = entry->mBMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
         } else {
-            o_color->b = mColorB[entry->mBOffset + frame];
+            pColor->b = mColorB[entry->mBOffset + frame];
         }
-        if (frame >= entry->mAMaxFrame) {
-            o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
+
+        maxFrame = entry->mAMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
         } else {
-            o_color->a = mColorA[entry->mAOffset + frame];
+            pColor->a = mColorA[entry->mAOffset + frame];
         }
     }
 }
@@ -852,93 +919,98 @@ J3DAnmVtxColorKey::J3DAnmVtxColorKey() {
 
 /* 8032A53C-8032A828 324E7C 02EC+00 1/0 0/0 0/0 .text
  * getColor__17J3DAnmVtxColorKeyCFUcUsP8_GXColor                */
-void J3DAnmVtxColorKey::getColor(u8 i_table, u16 i_index, GXColor* o_color) const {
-    J3DAnmColorKeyTable* entry = &mpTable[i_table][i_index];
+void J3DAnmVtxColorKey::getColor(u8 tableNo, u16 index, GXColor* pColor) const {
+    J3D_ASSERT_NULLPTR(1338, pColor != NULL);
+    J3DAnmColorKeyTable* entry = &mpTable[tableNo][index];
+
     f32 col;
     switch (entry->mRInfo.mMaxFrame) {
     case 0:
-        o_color->r = 0;
+        pColor->r = 0;
         break;
     case 1:
-        o_color->r = mColorR[entry->mRInfo.mOffset];
+        pColor->r = mColorR[entry->mRInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
                                           &mColorR[entry->mRInfo.mOffset]);
         if (col <= 0.0f) {
-            o_color->r = 0;
+            pColor->r = 0;
         } else if (col <= 255.0f) {
-            OSf32tou8(&col, &o_color->r);
+            OSf32tou8(&col, &pColor->r);
         } else {
-            o_color->r = 255;
+            pColor->r = 255;
         }
     }
+
     switch (entry->mGInfo.mMaxFrame) {
     case 0:
-        o_color->g = 0;
+        pColor->g = 0;
         break;
     case 1:
-        o_color->g = mColorG[entry->mGInfo.mOffset];
+        pColor->g = mColorG[entry->mGInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
                                           &mColorG[entry->mGInfo.mOffset]);
         if (col <= 0.0f) {
-            o_color->g = 0;
+            pColor->g = 0;
         } else if (col <= 255.0f) {
-            OSf32tou8(&col, &o_color->g);
+            OSf32tou8(&col, &pColor->g);
         } else {
-            o_color->g = 255;
+            pColor->g = 255;
         }
     }
+
     switch (entry->mBInfo.mMaxFrame) {
     case 0:
-        o_color->b = 0;
+        pColor->b = 0;
         break;
     case 1:
-        o_color->b = mColorB[entry->mBInfo.mOffset];
+        pColor->b = mColorB[entry->mBInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
                                           &mColorB[entry->mBInfo.mOffset]);
         if (col <= 0.0f) {
-            o_color->b = 0;
+            pColor->b = 0;
         } else if (col <= 255.0f) {
-            OSf32tou8(&col, &o_color->b);
+            OSf32tou8(&col, &pColor->b);
         } else {
-            o_color->b = 255;
+            pColor->b = 255;
         }
     }
+
     switch (entry->mAInfo.mMaxFrame) {
     case 0:
-        o_color->a = 0;
+        pColor->a = 0;
         break;
     case 1:
-        o_color->a = mColorA[entry->mAInfo.mOffset];
+        pColor->a = mColorA[entry->mAInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
                                           &mColorA[entry->mAInfo.mOffset]);
         if (col <= 0.0f) {
-            o_color->a = 0;
+            pColor->a = 0;
         } else if (col <= 255.0f) {
-            OSf32tou8(&col, &o_color->a);
+            OSf32tou8(&col, &pColor->a);
         } else {
-            o_color->a = 255;
+            pColor->a = 255;
         }
     }
 }
 
 /* 8032A828-8032A8A4 325168 007C+00 2/2 0/0 0/0 .text            __ct__11J3DAnmColorFv */
-J3DAnmColor::J3DAnmColor() : J3DAnmBase(0), field_0xc(0), field_0xe(0), field_0x10(0),
+J3DAnmColor::J3DAnmColor() : field_0xc(0), field_0xe(0), field_0x10(0),
     field_0x12(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
 
 
 /* 8032A8A4-8032A93C 3251E4 0098+00 0/0 1/1 0/0 .text
  * searchUpdateMaterialID__11J3DAnmColorFP16J3DMaterialTable    */
-void J3DAnmColor::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
+void J3DAnmColor::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
     for (u16 i = 0; i < mUpdateMaterialNum; i++) {
-        int index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+        int index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
         if (index != -1) {
             mUpdateMaterialID[i] = index;
         } else {
@@ -957,34 +1029,46 @@ J3DAnmColorFull::J3DAnmColorFull() {
 }
 
 /* 8032A990-8032AB00 3252D0 0170+00 1/0 0/0 0/0 .text getColor__15J3DAnmColorFullCFUsP8_GXColor */
-void J3DAnmColorFull::getColor(u16 i_index, GXColor* o_color) const {
-    J3DAnmColorFullTable* entry = &mAnmTable[i_index];
+void J3DAnmColorFull::getColor(u16 index, GXColor* pColor) const {
+    J3D_ASSERT_RANGE(1537, index >= 0 && index < mUpdateMaterialNum);
+    J3D_ASSERT_NULLPTR(1538, pColor != NULL);
+    J3DAnmColorFullTable* entry = &mAnmTable[index];
+
     if (mFrame < 0.0f) {
-        o_color->r = mColorR[entry->mROffset];
-        o_color->g = mColorG[entry->mGOffset];
-        o_color->b = mColorB[entry->mBOffset];
-        o_color->a = mColorA[entry->mAOffset];
+        pColor->r = mColorR[entry->mROffset];
+        pColor->g = mColorG[entry->mGOffset];
+        pColor->b = mColorB[entry->mBOffset];
+        pColor->a = mColorA[entry->mAOffset];
     } else {
         int frame = (int)(mFrame + 0.5f);
-        if (frame >= entry->mRMaxFrame) {
-            o_color->r = mColorR[entry->mROffset + (entry->mRMaxFrame - 1)];
+        u16 maxFrame;
+
+        maxFrame = entry->mRMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->r = mColorR[entry->mROffset + (maxFrame - 1)];
         } else {
-            o_color->r = mColorR[entry->mROffset + frame];
+            pColor->r = mColorR[entry->mROffset + frame];
         }
-        if (frame >= entry->mGMaxFrame) {
-            o_color->g = mColorG[entry->mGOffset + (entry->mGMaxFrame - 1)];
+
+        maxFrame = entry->mGMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->g = mColorG[entry->mGOffset + (maxFrame - 1)];
         } else {
-            o_color->g = mColorG[entry->mGOffset + frame];
+            pColor->g = mColorG[entry->mGOffset + frame];
         }
-        if (frame >= entry->mBMaxFrame) {
-            o_color->b = mColorB[entry->mBOffset + (entry->mBMaxFrame - 1)];
+
+        maxFrame = entry->mBMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->b = mColorB[entry->mBOffset + (maxFrame - 1)];
         } else {
-            o_color->b = mColorB[entry->mBOffset + frame];
+            pColor->b = mColorB[entry->mBOffset + frame];
         }
-        if (frame >= entry->mAMaxFrame) {
-            o_color->a = mColorA[entry->mAOffset + (entry->mAMaxFrame - 1)];
+
+        maxFrame = entry->mAMaxFrame;
+        if (frame >= maxFrame) {
+            pColor->a = mColorA[entry->mAOffset + (maxFrame - 1)];
         } else {
-            o_color->a = mColorA[entry->mAOffset + frame];
+            pColor->a = mColorA[entry->mAOffset + frame];
         }
     }
 }
@@ -999,130 +1083,143 @@ J3DAnmColorKey::J3DAnmColorKey() {
 }
 
 /* 8032AB54-8032AE18 325494 02C4+00 1/0 0/0 0/0 .text getColor__14J3DAnmColorKeyCFUsP8_GXColor */
-void J3DAnmColorKey::getColor(u16 i_index, GXColor* o_color) const {
-    J3DAnmColorKeyTable* entry = &mAnmTable[i_index];
+void J3DAnmColorKey::getColor(u16 index, GXColor* pColor) const {
+    J3D_ASSERT_RANGE(1614, index >= 0 && index < mUpdateMaterialNum);
+    J3D_ASSERT_NULLPTR(1615, pColor != NULL);
+    J3DAnmColorKeyTable* entry = &mAnmTable[index];
+
     f32 col;
     switch (entry->mRInfo.mMaxFrame) {
     case 0:
-        o_color->r = 0;
+        pColor->r = 0;
         break;
     case 1:
-        o_color->r = mColorR[entry->mRInfo.mOffset];
+        pColor->r = mColorR[entry->mRInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRInfo,
                                           &mColorR[entry->mRInfo.mOffset]);
         if (col < 0.0f) {
-            o_color->r = 0;
+            pColor->r = 0;
         } else if (col > 255.0f) {
-            o_color->r = 255;
+            pColor->r = 255;
         } else {
-            OSf32tou8(&col, &o_color->r);
+            OSf32tou8(&col, &pColor->r);
         }
     }
+
     switch (entry->mGInfo.mMaxFrame) {
     case 0:
-        o_color->g = 0;
+        pColor->g = 0;
         break;
     case 1:
-        o_color->g = mColorG[entry->mGInfo.mOffset];
+        pColor->g = mColorG[entry->mGInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGInfo,
                                           &mColorG[entry->mGInfo.mOffset]);
         if (col < 0.0f) {
-            o_color->g = 0;
+            pColor->g = 0;
         } else if (col > 255.0f) {
-            o_color->g = 255;
+            pColor->g = 255;
         } else {
-            OSf32tou8(&col, &o_color->g);
+            OSf32tou8(&col, &pColor->g);
         }
     }
+
     switch (entry->mBInfo.mMaxFrame) {
     case 0:
-        o_color->b = 0;
+        pColor->b = 0;
         break;
     case 1:
-        o_color->b = mColorB[entry->mBInfo.mOffset];
+        pColor->b = mColorB[entry->mBInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBInfo,
                                           &mColorB[entry->mBInfo.mOffset]);
         if (col < 0.0f) {
-            o_color->b = 0;
+            pColor->b = 0;
         } else if (col > 255.0f) {
-            o_color->b = 255;
+            pColor->b = 255;
         } else {
-            OSf32tou8(&col, &o_color->b);
+            OSf32tou8(&col, &pColor->b);
         }
     }
+
     switch (entry->mAInfo.mMaxFrame) {
     case 0:
-        o_color->a = 0;
+        pColor->a = 0;
         break;
     case 1:
-        o_color->a = mColorA[entry->mAInfo.mOffset];
+        pColor->a = mColorA[entry->mAInfo.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mAInfo,
                                           &mColorA[entry->mAInfo.mOffset]);
         if (col < 0.0f) {
-            o_color->a = 0;
+            pColor->a = 0;
         } else if (col > 255.0f) {
-            o_color->a = 255;
+            pColor->a = 255;
         } else {
-            OSf32tou8(&col, &o_color->a);
+            OSf32tou8(&col, &pColor->a);
         }
     }
 }
 
 /* 8032AE18-8032AED8 325758 00C0+00 0/0 1/1 0/0 .text            __ct__15J3DAnmTevRegKeyFv */
-J3DAnmTevRegKey::J3DAnmTevRegKey() : J3DAnmBase(0) {
-    mKRegUpdateMaterialNum = 0;
-    mCRegUpdateMaterialNum = 0;
+J3DAnmTevRegKey::J3DAnmTevRegKey() {
+    mCRegUpdateMaterialNum = mKRegUpdateMaterialNum = 0;
+
+    mCRegDataCountR =
+    mCRegDataCountG =
+    mCRegDataCountB =
     mCRegDataCountA = 0;
-    mCRegDataCountB = 0;
-    mCRegDataCountG = 0;
-    mCRegDataCountR = 0;
+
+    mKRegDataCountR =
+    mKRegDataCountG =
+    mKRegDataCountB =
     mKRegDataCountA = 0;
-    mKRegDataCountB = 0;
-    mKRegDataCountG = 0;
-    mKRegDataCountR = 0;
-    mKRegUpdateMaterialID = NULL;
-    mCRegUpdateMaterialID = NULL;
+
+    mCRegUpdateMaterialID = mKRegUpdateMaterialID = NULL;
+    
+    mAnmCRegDataR =
+    mAnmCRegDataG =
+    mAnmCRegDataB =
     mAnmCRegDataA = NULL;
-    mAnmCRegDataB = NULL;
-    mAnmCRegDataG = NULL;
-    mAnmCRegDataR = NULL;
+
+    mAnmKRegDataR =
+    mAnmKRegDataG =
+    mAnmKRegDataB =
     mAnmKRegDataA = NULL;
-    mAnmKRegDataB = NULL;
-    mAnmKRegDataG = NULL;
-    mAnmKRegDataR = NULL;
 }
 
 
 /* 8032AED8-8032AF50 325818 0078+00 0/0 2/2 0/0 .text            __ct__16J3DAnmTexPatternFv */
-J3DAnmTexPattern::J3DAnmTexPattern() : J3DAnmBase(0), mTextureIndex(NULL), mAnmTable(NULL),
+J3DAnmTexPattern::J3DAnmTexPattern() : mTextureIndex(NULL), mAnmTable(NULL),
     field_0x14(0), mUpdateMaterialNum(0), mUpdateMaterialID(NULL) {}
 
 /* 8032AF50-8032B004 325890 00B4+00 0/0 1/1 72/72 .text getTexNo__16J3DAnmTexPatternCFUsPUs */
-void J3DAnmTexPattern::getTexNo(u16 i_index, u16* o_texNo) const {
-    u32 maxFrame = mAnmTable[i_index].mMaxFrame;
+void J3DAnmTexPattern::getTexNo(u16 index, u16* pTexNo) const {
+    u32 maxFrame = mAnmTable[index].mMaxFrame;
+    J3D_ASSERT_RANGE(1743, index >= 0 && index < mUpdateMaterialNum);
+    J3D_ASSERT_NULLPTR(1744, pTexNo != NULL);
+
     if (mFrame < 0.0f) {
-        *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset];
-    } else if (mFrame >= maxFrame) {
-        *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset + (maxFrame - 1)];
+        *pTexNo = mTextureIndex[mAnmTable[index].mOffset];
+    } else if (mFrame >= (u16)maxFrame) {
+        *pTexNo = mTextureIndex[mAnmTable[index].mOffset + ((u16)maxFrame - 1)];
     } else {
-        *o_texNo = mTextureIndex[mAnmTable[i_index].mOffset + (int)mFrame];
+        *pTexNo = mTextureIndex[mAnmTable[index].mOffset + (int)mFrame];
     }
 }
 
 /* 8032B004-8032B09C 325944 0098+00 1/1 1/1 0/0 .text
  * searchUpdateMaterialID__16J3DAnmTexPatternFP16J3DMaterialTable */
-void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
-    J3D_ASSERT(1790, i_materialTable, "Error : null pointer.");
+void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+    J3D_ASSERT_NULLPTR(1790, pMatTable != NULL);
+
     for (u16 i = 0; i < mUpdateMaterialNum; i++) {
-        s32 index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+        s32 index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
         if (index != -1) {
             mUpdateMaterialID[i] = index;
         } else {
@@ -1133,25 +1230,27 @@ void J3DAnmTexPattern::searchUpdateMaterialID(J3DMaterialTable* i_materialTable)
 
 /* 8032B09C-8032B0C0 3259DC 0024+00 0/0 4/4 1/1 .text
  * searchUpdateMaterialID__16J3DAnmTexPatternFP12J3DModelData   */
-void J3DAnmTexPattern::searchUpdateMaterialID(J3DModelData* i_modelData) {
-    J3D_ASSERT(1813, i_modelData, "Error : null pointer.");
-    searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTexPattern::searchUpdateMaterialID(J3DModelData* pModelData) {
+    J3D_ASSERT_NULLPTR(1813, pModelData != NULL);
+    searchUpdateMaterialID(&pModelData->getMaterialTable());
 }
 
 /* 8032B0C0-8032B1D4 325A00 0114+00 1/1 1/1 0/0 .text
  * searchUpdateMaterialID__19J3DAnmTextureSRTKeyFP16J3DMaterialTable */
-void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
-    J3D_ASSERT(1832, i_materialTable, "Error : null pointer.");
+void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+    J3D_ASSERT_NULLPTR(1832, pMatTable != NULL);
+
     for (u16 i = 0; i < getUpdateMaterialNum(); i++) {
-        s32 index = i_materialTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
+        s32 index = pMatTable->getMaterialName()->getIndex(mUpdateMaterialName.getName(i));
         if (index != -1) {
             mUpdateMaterialID[i] = index;
         } else {
             mUpdateMaterialID[i] = -1;
         }
     }
+
     for (u16 i = 0; i < getPostUpdateMaterialNum(); i++) {
-        s32 index = i_materialTable->getMaterialName()->getIndex(mPostUpdateMaterialName.getName(i));
+        s32 index = pMatTable->getMaterialName()->getIndex(mPostUpdateMaterialName.getName(i));
         if (index != -1) {
             mPostUpdateMaterialID[i] = index;
         } else {
@@ -1162,183 +1261,197 @@ void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTab
 
 /* 8032B1D4-8032B1F8 325B14 0024+00 0/0 8/8 6/6 .text
  * searchUpdateMaterialID__19J3DAnmTextureSRTKeyFP12J3DModelData */
-void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DModelData* i_modelData) {
-    J3D_ASSERT(1871, i_modelData, "Error : null pointer.");
-    searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTextureSRTKey::searchUpdateMaterialID(J3DModelData* pModelData) {
+    J3D_ASSERT_NULLPTR(1871, pModelData != NULL);
+    searchUpdateMaterialID(&pModelData->getMaterialTable());
 }
 
 /* 8032B1F8-8032B4BC 325B38 02C4+00 0/0 2/2 1/1 .text
  * getTevColorReg__15J3DAnmTevRegKeyCFUsP11_GXColorS10          */
-void J3DAnmTevRegKey::getTevColorReg(u16 i_index, GXColorS10* o_color) const {
-    J3DAnmCRegKeyTable* entry = &mAnmCRegKeyTable[i_index];
+void J3DAnmTevRegKey::getTevColorReg(u16 index, GXColorS10* pColor) const {
+    J3D_ASSERT_RANGE(1887, index >= 0 && index < mCRegUpdateMaterialNum);
+    J3D_ASSERT_NULLPTR(1888, pColor != NULL);
+    J3DAnmCRegKeyTable* entry = &mAnmCRegKeyTable[index];
+
     f32 col;
     switch (entry->mRTable.mMaxFrame) {
     case 0:
-        o_color->r = 0;
+        pColor->r = 0;
         break;
     case 1:
-        o_color->r = mAnmCRegDataR[entry->mRTable.mOffset];
+        pColor->r = mAnmCRegDataR[entry->mRTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
                                           &mAnmCRegDataR[entry->mRTable.mOffset]);
         if (col < -0x400) {
-            o_color->r = -0x400;
+            pColor->r = -0x400;
         } else if (col > 0x3FF) {
-            o_color->r = 0x3FF;
+            pColor->r = 0x3FF;
         } else {
-            OSf32tos16(&col, &o_color->r);
+            OSf32tos16(&col, &pColor->r);
         }
     }
+
     switch (entry->mGTable.mMaxFrame) {
     case 0:
-        o_color->g = 0;
+        pColor->g = 0;
         break;
     case 1:
-        o_color->g = mAnmCRegDataG[entry->mGTable.mOffset];
+        pColor->g = mAnmCRegDataG[entry->mGTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
                                           &mAnmCRegDataG[entry->mGTable.mOffset]);
         if (col < -0x400) {
-            o_color->g = -0x400;
+            pColor->g = -0x400;
         } else if (col > 0x3FF) {
-            o_color->g = 0x3FF;
+            pColor->g = 0x3FF;
         } else {
-            OSf32tos16(&col, &o_color->g);
+            OSf32tos16(&col, &pColor->g);
         }
     }
+
     switch (entry->mBTable.mMaxFrame) {
     case 0:
-        o_color->b = 0;
+        pColor->b = 0;
         break;
     case 1:
-        o_color->b = mAnmCRegDataB[entry->mBTable.mOffset];
+        pColor->b = mAnmCRegDataB[entry->mBTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
                                           &mAnmCRegDataB[entry->mBTable.mOffset]);
         if (col < -0x400) {
-            o_color->b = -0x400;
+            pColor->b = -0x400;
         } else if (col > 0x3FF) {
-            o_color->b = 0x3FF;
+            pColor->b = 0x3FF;
         } else {
-            OSf32tos16(&col, &o_color->b);
+            OSf32tos16(&col, &pColor->b);
         }
     }
+
     switch (entry->mATable.mMaxFrame) {
     case 0:
-        o_color->a = 0;
+        pColor->a = 0;
         break;
     case 1:
-        o_color->a = mAnmCRegDataA[entry->mATable.mOffset];
+        pColor->a = mAnmCRegDataA[entry->mATable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
                                           &mAnmCRegDataA[entry->mATable.mOffset]);
         if (col < -0x400) {
-            o_color->a = -0x400;
+            pColor->a = -0x400;
         } else if (col > 0x3FF) {
-            o_color->a = 0x3FF;
+            pColor->a = 0x3FF;
         } else {
-            OSf32tos16(&col, &o_color->a);
+            OSf32tos16(&col, &pColor->a);
         }
     }
 }
 
 /* 8032B4BC-8032B780 325DFC 02C4+00 0/0 1/1 1/1 .text
  * getTevKonstReg__15J3DAnmTevRegKeyCFUsP8_GXColor              */
-void J3DAnmTevRegKey::getTevKonstReg(u16 i_index, GXColor* o_color) const {
-    J3DAnmKRegKeyTable* entry = &mAnmKRegKeyTable[i_index];
+void J3DAnmTevRegKey::getTevKonstReg(u16 index, GXColor* pColor) const {
+    J3D_ASSERT_RANGE(1989, index >= 0 && index < mKRegUpdateMaterialNum);
+    J3D_ASSERT_NULLPTR(1990, pColor != NULL);
+    J3DAnmKRegKeyTable* entry = &mAnmKRegKeyTable[index];
+
     f32 col;
     switch (entry->mRTable.mMaxFrame) {
     case 0:
-        o_color->r = 0;
+        pColor->r = 0;
         break;
     case 1:
-        o_color->r = mAnmKRegDataR[entry->mRTable.mOffset];
+        pColor->r = mAnmKRegDataR[entry->mRTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mRTable,
                                           &mAnmKRegDataR[entry->mRTable.mOffset]);
         if (col < 0) {
-            o_color->r = 0;
+            pColor->r = 0;
         } else if (col > 0xFF) {
-            o_color->r = 0xFF;
+            pColor->r = 0xFF;
         } else {
-            OSf32tou8(&col, &o_color->r);
+            OSf32tou8(&col, &pColor->r);
         }
     }
+
     switch (entry->mGTable.mMaxFrame) {
     case 0:
-        o_color->g = 0;
+        pColor->g = 0;
         break;
     case 1:
-        o_color->g = mAnmKRegDataG[entry->mGTable.mOffset];
+        pColor->g = mAnmKRegDataG[entry->mGTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mGTable,
                                           &mAnmKRegDataG[entry->mGTable.mOffset]);
         if (col < 0) {
-            o_color->g = 0;
+            pColor->g = 0;
         } else if (col > 0xFF) {
-            o_color->g = 0xFF;
+            pColor->g = 0xFF;
         } else {
-            OSf32tou8(&col, &o_color->g);
+            OSf32tou8(&col, &pColor->g);
         }
     }
+
     switch (entry->mBTable.mMaxFrame) {
     case 0:
-        o_color->b = 0;
+        pColor->b = 0;
         break;
     case 1:
-        o_color->b = mAnmKRegDataB[entry->mBTable.mOffset];
+        pColor->b = mAnmKRegDataB[entry->mBTable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mBTable,
                                           &mAnmKRegDataB[entry->mBTable.mOffset]);
         if (col < 0) {
-            o_color->b = 0;
+            pColor->b = 0;
         } else if (col > 0xFF) {
-            o_color->b = 0xFF;
+            pColor->b = 0xFF;
         } else {
-            OSf32tou8(&col, &o_color->b);
+            OSf32tou8(&col, &pColor->b);
         }
     }
+
     switch (entry->mATable.mMaxFrame) {
     case 0:
-        o_color->a = 0;
+        pColor->a = 0;
         break;
     case 1:
-        o_color->a = mAnmKRegDataA[entry->mATable.mOffset];
+        pColor->a = mAnmKRegDataA[entry->mATable.mOffset];
         break;
     default:
         col = J3DGetKeyFrameInterpolation(mFrame, &entry->mATable,
                                           &mAnmKRegDataA[entry->mATable.mOffset]);
         if (col < 0) {
-            o_color->a = 0;
+            pColor->a = 0;
         } else if (col > 0xFF) {
-            o_color->a = 0xFF;
+            pColor->a = 0xFF;
         } else {
-            OSf32tou8(&col, &o_color->a);
+            OSf32tou8(&col, &pColor->a);
         }
     }
 }
 
 /* 8032B780-8032B87C 3260C0 00FC+00 1/1 1/1 0/0 .text
  * searchUpdateMaterialID__15J3DAnmTevRegKeyFP16J3DMaterialTable */
-void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable) {
-    J3D_ASSERT(2083, i_materialTable, "Error : null pointer.");
+void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* pMatTable) {
+    J3D_ASSERT_NULLPTR(2083, pMatTable != NULL);
+
     for (u16 i = 0; i < mCRegUpdateMaterialNum; i++) {
-        s32 index = i_materialTable->getMaterialName()->getIndex(mCRegUpdateMaterialName.getName(i));
+        s32 index = pMatTable->getMaterialName()->getIndex(mCRegUpdateMaterialName.getName(i));
         if (index != -1) {
             mCRegUpdateMaterialID[i] = index;
         } else {
             mCRegUpdateMaterialID[i] = -1;
         }
     }
+
     for (u16 i = 0; i < mKRegUpdateMaterialNum; i++) {
-        s32 index = i_materialTable->getMaterialName()->getIndex(mKRegUpdateMaterialName.getName(i));
+        s32 index = pMatTable->getMaterialName()->getIndex(mKRegUpdateMaterialName.getName(i));
         if (index != -1) {
             mKRegUpdateMaterialID[i] = index;
         } else {
@@ -1349,7 +1462,7 @@ void J3DAnmTevRegKey::searchUpdateMaterialID(J3DMaterialTable* i_materialTable)
 
 /* 8032B87C-8032B8A0 3261BC 0024+00 0/0 9/9 4/4 .text
  * searchUpdateMaterialID__15J3DAnmTevRegKeyFP12J3DModelData    */
-void J3DAnmTevRegKey::searchUpdateMaterialID(J3DModelData* i_modelData) {
-    J3D_ASSERT(2119, i_modelData, "Error : null pointer.");
-    searchUpdateMaterialID(&i_modelData->getMaterialTable());
+void J3DAnmTevRegKey::searchUpdateMaterialID(J3DModelData* pModelData) {
+    J3D_ASSERT_NULLPTR(2119, pModelData != NULL);
+    searchUpdateMaterialID(&pModelData->getMaterialTable());
 }