Fix linker errors.

Stubbing out all OS* functions to stubs.cpp, these will likely have to
be replaced with the operating system's primitives for
locking/heaps/threads/etc.

Moved some generic globals into globals.cpp, not sure where they're
actually to be used.

Stub DSP functions

Stub JSUMemoryOutputStream, JORServer, Z2Audio

mDoExt stubs

add memcpy

add some more stubs, add extras c++ mangled functions

add extras.cpp

AR/AQ stubbing

stub DVD

stub CARD

more stubs, more extras

add missing mtx functions to dusk file

finish mtx

stub GX

KPAD and LC, also do pragma marks for better visualization

finish mtx, add a few more stubs

gf/wpad/vi

translate some matrix math from ppc to C

jorserver/debugpad/fap/dmsgobject

add m_Do_ext functions from debug block to separate file

make small janges to JSystem, does this need upstreaming

reorg DVD stubs

reorganize stubs by mark

CMakeLists.txt

@@ -1338,8 +1338,13 @@ set(REL_FILES
 
 set(DUSK_FILES
     #src/dusk/imgui.cpp
-    #src/dusk/stubs.c
+    src/dusk/stubs.cpp
     src/dusk/extras.c
+    src/dusk/extras.cpp
+    src/dusk/globals.cpp
+    src/dusk/mtx.cpp
+    src/dusk/J3DTransforms_C.cpp
+    src/dusk/m_Do_ext_dusk.cpp
     )
 
 source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${SSYSTEM_FILES} ${JSYSTEM_FILES} ${REL_FILES})
@@ -1350,7 +1355,7 @@ target_compile_definitions(game PRIVATE TARGET_PC VERSION=0 NDEBUG=1 NDEBUG_DEFI
 # TODO: version handling for res includes
 set(DUSK_TP_VERSION GZ2E01)
 target_include_directories(game PRIVATE include src assets/${DUSK_TP_VERSION} ${CMAKE_BINARY_DIR}/../${DUSK_TP_VERSION}/include)
-target_link_libraries(game PRIVATE aurora::core aurora::gx aurora::si aurora::vi aurora::pad)
+target_link_libraries(game PRIVATE aurora::core aurora::gx aurora::si aurora::vi aurora::pad aurora::mtx)
 
 add_executable(dusk src/dusk/main.cpp)
 target_compile_definitions(dusk PRIVATE TARGET_PC VERSION=0)

include/JSystem/JAudio2/JASGadget.h

@@ -33,6 +33,11 @@ public:
     static T* sInstance;
 };
 
+#ifndef __MWERKS__
+template<class T>
+T* JASGlobalInstance<T>::sInstance;
+#endif
+
 /**
  * @ingroup jsystem-jaudio
  * 

src/d/actor/d_a_npc_hoz.cpp

@@ -854,8 +854,8 @@ int daNpc_Hoz_c::test(void* i_this) {
         mMode = 2;
         // fall-through
     case 2:
-        mFaceMotionSeqMngr.setNo((int)mpHIO, -1.0f, 0, 0);
-        mMotionSeqMngr.setNo((int)mpHIO, -1.0f, 0, 0);
+        mFaceMotionSeqMngr.setNo(mpHIO->m.common.face_expression, -1.0f, 0, 0);
+        mMotionSeqMngr.setNo(mpHIO->m.common.motion, -1.0f, 0, 0);
         mJntAnm.lookNone(0);
         attention_info.flags = 0;
     case 3:

src/dusk/J3DTransforms_C.cpp

@@ -0,0 +1,25 @@
+#include <stdint.h>
+#include <dolphin/mtx.h>
+
+// translated to C, should be correct, but not tested.
+
+void J3DPSMtxArrayConcat(Mtx mA, Mtx mB, Mtx mAB, u32 count) {
+    for (uint32_t i = 0; i < count; i++) {
+        const float* b = (const float*)mB[i];
+        float* res = (float*)mAB[i];
+
+        for (int row = 0; row < 3; row++) {
+            float a0 = mA[row][0];
+            float a1 = mA[row][1];
+            float a2 = mA[row][2];
+            float a3 = mA[row][3];
+
+            // Standard Matrix Multiply for 3x4 * 3x4 (with implicit 4th row [0,0,0,1])
+            res[row * 4 + 0] = a0 * b[0] + a1 * b[4] + a2 * b[8];
+            res[row * 4 + 1] = a0 * b[1] + a1 * b[5] + a2 * b[9];
+            res[row * 4 + 2] = a0 * b[2] + a1 * b[6] + a2 * b[10];
+            // The 4th column includes the translation
+            res[row * 4 + 3] = a0 * b[3] + a1 * b[7] + a2 * b[11] + a3;
+        }
+    }
+}

src/dusk/extras.c

@@ -1,5 +1,8 @@
 #include "dusk/extras.h"
 #include <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include <stdint.h>
 
 int stricmp(const char* str1, const char* str2) {
 	char a_var;
@@ -43,3 +46,12 @@ int strnicmp(const char* str1, const char* str2, int n) {
 
     return 0;
 }
+
+
+void *_memcpy(void* dest, void const* src, int n) {
+    return memcpy(dest, src, n);
+}
+
+void DCZeroRange(void* addr, uint32_t nBytes) {
+    bzero(addr, nBytes);
+}

src/dusk/extras.cpp

@@ -0,0 +1,18 @@
+// C++ Mangled version of extras.c
+#include <cstring>
+#include <cstdint>
+
+void *__memcpy(void* dest, void const* src, int n) {
+    return memcpy(dest, src, n);
+}
+
+void __dcbz(void* addr, int offset) {
+    // Gekko cache lines are 32 bytes.
+    // dcbz usually requires addr to be 32-byte aligned.
+    memset((char*)addr + offset, 0, 32); 
+}
+
+int __cntlzw(unsigned int val) {
+    if (val == 0) return 32; // PowerPC returns 32 if the input is 0
+    return __builtin_clz(val);
+}

src/dusk/globals.cpp

@@ -0,0 +1,16 @@
+#include <dolphin/types.h>
+#include <d/d_kankyo.h>
+#include <d/d_debug_pad.h>
+u8 g_printOtherHeapDebug;
+
+dKankyo_HIO_c g_kankyoHIO;
+
+dDebugPad_c dDebugPad;
+
+u32 __OSFpscrEnableBits;
+
+GDLObj* __GDCurrentDL;
+
+// DSP
+DSPTaskInfo* __DSP_first_task;
+DSPTaskInfo* __DSP_curr_task;

src/dusk/m_Do_ext_dusk.cpp

@@ -0,0 +1,565 @@
+// XXX Ripped these from a DEBUG block, rather than changing defines.
+/**
+ * m_Do_ext.cpp
+ * Model, Animation, and Heap Functions
+ */
+
+#include "d/dolzel.h" // IWYU pragma: keep
+
+#include <dolphin/gf/GFPixel.h>
+#include <dolphin/gx.h>
+#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
+#include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "JSystem/J3DGraphLoader/J3DMaterialFactory.h"
+#include "JSystem/JKernel/JKRAssertHeap.h"
+#include "JSystem/JKernel/JKRExpHeap.h"
+#include "JSystem/JKernel/JKRSolidHeap.h"
+#include "JSystem/JUtility/JUTCacheFont.h"
+#include "JSystem/JUtility/JUTResFont.h"
+#include "Z2AudioLib/Z2Creature.h"
+#include "d/d_com_inf_game.h"
+#include "global.h"
+#include "m_Do/m_Do_ext.h"
+#include "m_Do/m_Do_main.h"
+#include "m_Do/m_Do_mtx.h"
+#include <cstdio>
+
+mDoExt_cube8pPacket::mDoExt_cube8pPacket(cXyz* i_points, const GXColor& i_color) {
+    cXyz* pnt_array = mPoints;
+
+    for (int i = 0; i < 8; i++) {
+        *(pnt_array)++ = *(i_points)++;
+    }
+
+    DCStoreRangeNoSync(mPoints, sizeof(cXyz) * 8);
+    mColor = i_color;
+}
+
+void drawCube(MtxP mtx, cXyz* pos, const GXColor& color) {
+    GXSetArray(GX_VA_POS, pos, sizeof(cXyz));
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_INDEX8);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP,
+                  GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, color);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_BACK);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXLoadPosMtxImm(mtx, 0);
+    GXSetCurrentMtx(0);
+
+    GXBegin(GX_TRIANGLESTRIP, GX_VTXFMT0, 14);
+    GXPosition1x8(4);
+    GXPosition1x8(6);
+    GXPosition1x8(5);
+    GXPosition1x8(7);
+    GXPosition1x8(3);
+    GXPosition1x8(6);
+    GXPosition1x8(2);
+    GXPosition1x8(4);
+    GXPosition1x8(0);
+    GXPosition1x8(5);
+    GXPosition1x8(1);
+    GXPosition1x8(3);
+    GXPosition1x8(0);
+    GXPosition1x8(2);
+    GXEnd();
+}
+
+void mDoExt_cube8pPacket::draw() {
+    drawCube(j3dSys.getViewMtx(), mPoints, mColor);
+}
+
+mDoExt_cubePacket::mDoExt_cubePacket(cXyz& i_position, cXyz& i_size, csXyz& i_angle, const GXColor& i_color) {
+    mPosition = i_position;
+    mSize = i_size;
+    mAngle = i_angle;
+    mColor = i_color;
+}
+
+void mDoExt_cubePacket::draw() {
+    static cXyz l_pos[8] = {
+        cXyz(-1.0f, 1.0f, -1.0f), cXyz(1.0f, 1.0f, -1.0f),   cXyz(-1.0f, 1.0f, 1.0f),
+        cXyz(1.0f, 1.0f, 1.0f),   cXyz(-1.0f, -1.0f, -1.0f), cXyz(1.0f, -1.0f, -1.0f),
+        cXyz(-1.0f, -1.0f, 1.0f), cXyz(1.0f, -1.0f, 1.0f),
+    };
+
+    mDoMtx_stack_c::transS(mPosition.x, mPosition.y, mPosition.z);
+    mDoMtx_stack_c::XYZrotM(mAngle.x, mAngle.y, mAngle.z);
+    mDoMtx_stack_c::scaleM(mSize.x, mSize.y, mSize.z);
+    mDoMtx_stack_c::revConcat(j3dSys.getViewMtx());
+    drawCube(mDoMtx_stack_c::get(), l_pos, mColor);
+}
+
+mDoExt_quadPacket::mDoExt_quadPacket(cXyz* i_points, const GXColor& i_color, u8 i_clipZ) {
+    cXyz* pnt_array = mPoints;
+
+    for (int i = 0; i < 4; i++) {
+        *(pnt_array)++ = *(i_points)++;
+    }
+
+    DCStoreRangeNoSync(mPoints, sizeof(cXyz) * 4);
+    mColor = i_color;
+    mClipZ = i_clipZ;
+}
+
+void mDoExt_quadPacket::draw() {
+    GXSetArray(GX_VA_POS, mPoints, sizeof(cXyz));
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_INDEX8);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP,
+                  GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_BACK);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXLoadPosMtxImm(j3dSys.getViewMtx(), 0);
+    GXSetCurrentMtx(0);
+
+    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
+    GXPosition1x8(0);
+    GXPosition1x8(1);
+    GXPosition1x8(2);
+    GXPosition1x8(3);
+    GXEnd();
+}
+
+mDoExt_trianglePacket::mDoExt_trianglePacket(cXyz* i_points, const GXColor& i_color, u8 i_clipZ) {
+    cXyz* pnt_array = mPoints;
+
+    for (int i = 0; i < 3; i++) {
+        *(pnt_array)++ = *(i_points)++;
+    }
+
+    DCStoreRangeNoSync(mPoints, sizeof(cXyz) * 3);
+    mColor = i_color;
+    mClipZ = i_clipZ;
+}
+
+void mDoExt_trianglePacket::draw() {
+    j3dSys.reinitGX();
+
+    GXSetArray(GX_VA_POS, mPoints, sizeof(cXyz));
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_INDEX8);
+    GXLoadPosMtxImm(j3dSys.getViewMtx(), 0);
+    GXSetCurrentMtx(0);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetZCompLoc(GX_ENABLE);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
+    GXSetFogRangeAdj(GX_DISABLE, 0, NULL);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetDither(GX_ENABLE);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXSetNumIndStages(0);
+
+    GXBegin(GX_TRIANGLES, GX_VTXFMT0, 3);
+    GXPosition1x8(0);
+    GXPosition1x8(1);
+    GXPosition1x8(2);
+    GXEnd();
+
+    J3DShape::resetVcdVatCache();
+}
+
+mDoExt_linePacket::mDoExt_linePacket(cXyz& i_start, cXyz& i_end, const GXColor& i_color, u8 i_clipZ, u8 i_width) {
+    mStart = i_start;
+    mEnd = i_end;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+    mWidth = i_width;
+}
+
+void mDoExt_linePacket::draw() {
+    j3dSys.reinitGX();
+
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXLoadPosMtxImm(j3dSys.getViewMtx(), 0);
+    GXSetCurrentMtx(0);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetZCompLoc(GX_ENABLE);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
+    GXSetFogRangeAdj(GX_DISABLE, 0, NULL);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetDither(GX_ENABLE);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXSetNumIndStages(0);
+    GXSetLineWidth(mWidth, GX_TO_ZERO);
+
+    GXBegin(GX_LINES, GX_VTXFMT0, 2);
+    GXPosition3f32(mStart.x, mStart.y, mStart.z);
+    GXPosition3f32(mEnd.x, mEnd.y, mEnd.z);
+    GXEnd();
+
+    J3DShape::resetVcdVatCache();
+}
+
+mDoExt_ArrowPacket::mDoExt_ArrowPacket(cXyz& i_position, cXyz& param_1, const GXColor& i_color, u8 i_clipZ, u8 i_lineWidth) {
+    mStart = i_position;
+    mEnd = param_1;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+    mLineWidth = i_lineWidth;
+}
+
+void mDoExt_ArrowPacket::draw() {
+    Mtx sp28;
+    cXyz sp18;
+
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXSetLineWidth(mLineWidth, GX_TO_ZERO);
+
+    sp18 = mEnd - mStart;
+    MtxTrans(mStart.x, mStart.y, mStart.z, 0);
+    cMtx_YrotM(*calc_mtx, sp18.atan2sX_Z());
+    cMtx_XrotM(*calc_mtx, cM_atan2s(JMAFastSqrt(SQUARE(sp18.x) + SQUARE(sp18.z)), sp18.y));
+    cMtx_concat(j3dSys.getViewMtx(), *calc_mtx, sp28);
+
+    GXLoadPosMtxImm(sp28, 0);
+    GXSetCurrentMtx(0);
+
+    GXBegin(GX_LINES, GX_VTXFMT0, 2);
+    GXPosition3f32(0.0f, 0.0f, 0.0f);
+    GXPosition3f32(0.0f, sp18.abs(), 0.0f);
+    GXEnd();
+
+    f32 var_f29 = sp18.abs();
+    f32 var_f31 = var_f29 * 0.1f;
+    f32 var_f30 = var_f29 * 0.8f;
+
+    GXBegin(GX_TRIANGLEFAN, GX_VTXFMT0, 6);
+    GXPosition3f32(0.0f, var_f29, 0.0f);
+    GXPosition3f32(0.0f, var_f30, var_f31);
+    GXPosition3f32(var_f31, var_f30, 0.0f);
+    GXPosition3f32(0.0f, var_f30, -var_f31);
+    GXPosition3f32(-var_f31, var_f30, 0.0f);
+    GXPosition3f32(0.0f, var_f30, var_f31);
+    GXEnd();
+}
+
+mDoExt_pointPacket::mDoExt_pointPacket(cXyz& i_position, const GXColor& i_color, u8 i_clipZ, u8 i_lineWidth) {
+    mPosition = i_position;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+    mLineWidth = i_lineWidth;
+}
+
+void mDoExt_pointPacket::draw() {
+    j3dSys.reinitGX();
+
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXSetPointSize(mLineWidth, GX_TO_ZERO);
+
+    GXLoadPosMtxImm(j3dSys.getViewMtx(), 0);
+    GXSetCurrentMtx(0);
+
+    GXBegin(GX_POINTS, GX_VTXFMT0, 1);
+    GXPosition3f32(mPosition.x, mPosition.y, mPosition.z);
+    GXEnd();
+
+    j3dSys.reinitGX();
+    J3DShape::resetVcdVatCache();
+}
+
+mDoExt_circlePacket::mDoExt_circlePacket(cXyz& i_position, f32 i_radius, const GXColor& i_color, u8 i_clipZ, u8 i_lineWidth) {
+    mPosition = i_position;
+    mRadius = i_radius;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+    mLineWidth = i_lineWidth;
+}
+
+void mDoExt_circlePacket::draw() {
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
+    GXClearVtxDesc();
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_DISABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_C0);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetClipMode(GX_CLIP_ENABLE);
+    GXSetLineWidth(mLineWidth, GX_TO_ZERO);
+    GXLoadPosMtxImm(j3dSys.getViewMtx(), 0);
+    GXSetCurrentMtx(0);
+
+    cXyz sp38;
+    cXyz sp44;
+    int numEdges = 36;
+    sp38.y = sp44.y = mPosition.y;
+    
+    GXBegin(GX_LINES, GX_VTXFMT0, numEdges * 2);
+    for (int i = 0; i < numEdges; i++) {
+        sp38.x = cM_fcos((i * 6.2831855f) / numEdges) * mRadius;
+        sp38.z = cM_fsin((i * 6.2831855f) / numEdges) * mRadius;
+
+        sp44.x = cM_fcos(((i + 1) * 6.2831855f) / numEdges) * mRadius;
+        sp44.z = cM_fsin(((i + 1) * 6.2831855f) / numEdges) * mRadius;
+
+        sp38.x += mPosition.x;
+        sp38.z += mPosition.z;
+        sp44.x += mPosition.x;
+        sp44.z += mPosition.z;
+        GXPosition3f32(sp38.x, sp38.y, sp38.z);
+        GXPosition3f32(sp44.x, sp44.y, sp44.z);
+    }
+    GXEnd();
+}
+
+mDoExt_spherePacket::mDoExt_spherePacket(cXyz& i_position, f32 i_size, const GXColor& i_color, u8 i_clipZ) {
+    mPosition = i_position;
+    mSize = i_size;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+}
+
+void mDoExt_spherePacket::draw() {
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_ENABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT0, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_RASC, GX_CC_C0, GX_CC_ZERO);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_BACK);
+    GXSetClipMode(GX_CLIP_ENABLE);
+
+    mDoMtx_stack_c::copy(j3dSys.getViewMtx());
+    mDoMtx_stack_c::transM(mPosition.x, mPosition.y, mPosition.z);
+    mDoMtx_stack_c::scaleM(mSize, mSize, mSize);
+
+    GXLoadPosMtxImm(mDoMtx_stack_c::get(), 0);
+    mDoMtx_stack_c::inverseTranspose();
+
+    GXLoadNrmMtxImm(mDoMtx_stack_c::get(), 0);
+    GXSetCurrentMtx(0);
+
+    GXDrawSphere(8, 8);
+}
+
+mDoExt_cylinderPacket::mDoExt_cylinderPacket(cXyz& i_position, f32 i_radius, f32 i_height, const GXColor& i_color, u8 i_clipZ) {
+    mPosition = i_position;
+    mRadius = i_radius;
+    mHeight = i_height;
+    mColor = i_color;
+    mClipZ = i_clipZ;
+}
+
+void mDoExt_cylinderPacket::draw() {
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_ENABLE, GX_SRC_REG, GX_SRC_REG, 1, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_RASC, GX_CC_C0, GX_CC_ZERO);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_BACK);
+    GXSetClipMode(GX_CLIP_ENABLE);
+
+    f32 var_f31 = mHeight * 0.5f;
+
+    mDoMtx_stack_c::copy(j3dSys.getViewMtx());
+    mDoMtx_stack_c::transM(mPosition.x, mPosition.y + var_f31, mPosition.z);
+    mDoMtx_stack_c::scaleM(mRadius, var_f31, mRadius);
+    mDoMtx_stack_c::XrotM(0x4000);
+
+    GXLoadPosMtxImm(mDoMtx_stack_c::get(), 0);
+    mDoMtx_stack_c::inverseTranspose();
+
+    GXLoadNrmMtxImm(mDoMtx_stack_c::get(), 0);
+    GXSetCurrentMtx(0);
+    GXDrawCylinder(8);
+}
+
+mDoExt_cylinderMPacket::mDoExt_cylinderMPacket(Mtx i_mtx, const GXColor& i_color, u8 i_clipZ) {
+    cMtx_copy(i_mtx, mMatrix);
+    mColor = i_color;
+    mClipZ = i_clipZ;
+}
+
+void mDoExt_cylinderMPacket::draw() {
+    GXSetNumChans(1);
+    GXSetChanCtrl(GX_COLOR0, GX_ENABLE, GX_SRC_REG, GX_SRC_REG, GX_LIGHT0, GX_DF_CLAMP, GX_AF_NONE);
+    GXSetNumTexGens(0);
+    GXSetNumTevStages(1);
+    GXSetTevColor(GX_TEVREG0, mColor);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_RASC, GX_CC_C0, GX_CC_ZERO);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_ENABLE, GX_TEVPREV);
+
+    if (mClipZ) {
+        GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_ENABLE);
+    } else {
+        GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
+    }
+
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
+    GXSetCullMode(GX_CULL_BACK);
+    GXSetClipMode(GX_CLIP_ENABLE);
+
+    cMtx_concat(j3dSys.getViewMtx(), mMatrix, mMatrix);
+
+    GXLoadPosMtxImm(mMatrix, 0);
+    cMtx_inverseTranspose(mMatrix, mMatrix);
+
+    GXLoadNrmMtxImm(mMatrix, 0);
+    GXSetCurrentMtx(0);
+
+    GXDrawCylinder(8);
+}

src/dusk/mtx.cpp

@@ -0,0 +1,730 @@
+// This should go into aurora, but for now we'll place it here:
+#include <dolphin/mtx.h>
+#include <math.h>
+#include <cstdio>
+
+#define ASSERTLINE(line, cond) (void)0
+#define ASSERTMSGLINE(line, cond, msg) (void)0
+#define ASSERTMSG1LINE(line, cond, msg, arg1) (void)0
+#define ASSERTMSG2LINE(line, cond, msg, arg1, arg2) (void)0
+#define ASSERTMSGLINEV(line, cond, ...) (void)0
+
+// SNIP : after here, place it into aurora
+
+void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT, f32 transS, f32 transT) {
+    f32 tmp;
+
+    ASSERTMSGLINE(2672, m, "MTXLightOrtho():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(2673, (t != b), "MTXLightOrtho():  't' and 'b' clipping planes are equal ");
+    ASSERTMSGLINE(2674, (l != r), "MTXLightOrtho():  'l' and 'r' clipping planes are equal ");
+    tmp = 1 / (r - l);
+    m[0][0] = (2 * tmp * scaleS);
+    m[0][1] = 0;
+    m[0][2] = 0;
+    m[0][3] = (transS + (scaleS * (tmp * -(r + l))));
+    tmp = 1/ (t - b);
+    m[1][0] = 0;
+    m[1][1] = (2 * tmp * scaleT);
+    m[1][2] = 0;
+    m[1][3] = (transT + (scaleT * (tmp * -(t + b))));
+    m[2][0] = 0;
+    m[2][1] = 0;
+    m[2][2] = 0;
+    m[2][3] = 1;
+}
+
+void C_MTXLightPerspective(Mtx m, f32 fovY, f32 aspect, f32 scaleS, f32 scaleT, f32 transS, f32 transT) {
+    f32 angle;
+    f32 cot;
+
+    ASSERTMSGLINE(2604, m, "MTXLightPerspective():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(2605, (fovY > 0.0) && (fovY < 180.0), "MTXLightPerspective():  'fovY' out of range ");
+    ASSERTMSGLINE(2606, 0 != aspect, "MTXLightPerspective():  'aspect' is 0 ");
+
+    angle = (0.5f * fovY);
+    angle = MTXDegToRad(angle);
+    cot = 1 / tanf(angle);
+    m[0][0] = (scaleS * (cot / aspect));
+    m[0][1] = 0;
+    m[0][2] = -transS;
+    m[0][3] = 0;
+    m[1][0] = 0;
+    m[1][1] = (cot * scaleT);
+    m[1][2] = -transT;
+    m[1][3] = 0;
+    m[2][0] = 0;
+    m[2][1] = 0;
+    m[2][2] = -1;
+    m[2][3] = 0;
+}
+
+void C_MTXLookAt(Mtx m, const Point3d* camPos, const Vec* camUp, const Point3d* target) {
+    Vec vLook;
+    Vec vRight;
+    Vec vUp;
+
+    ASSERTMSGLINE(2437, m, "MTXLookAt():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(2438, camPos, "MTXLookAt():  NULL VecPtr 'camPos' ");
+    ASSERTMSGLINE(2439, camUp, "MTXLookAt():  NULL VecPtr 'camUp' ");
+    ASSERTMSGLINE(2440, target, "MTXLookAt():  NULL Point3dPtr 'target' ");
+
+    vLook.x = camPos->x - target->x;
+    vLook.y = camPos->y - target->y;
+    vLook.z = camPos->z - target->z;
+    VECNormalize(&vLook, &vLook);
+    VECCrossProduct(camUp, &vLook, &vRight);
+    VECNormalize(&vRight, &vRight);
+    VECCrossProduct(&vLook, &vRight, &vUp);
+    m[0][0] = vRight.x;
+    m[0][1] = vRight.y;
+    m[0][2] = vRight.z;
+    m[0][3] = -((camPos->z * vRight.z) + ((camPos->x * vRight.x) + (camPos->y * vRight.y)));
+    m[1][0] = vUp.x;
+    m[1][1] = vUp.y;
+    m[1][2] = vUp.z;
+    m[1][3] = -((camPos->z * vUp.z) + ((camPos->x * vUp.x) + (camPos->y * vUp.y)));
+    m[2][0] = vLook.x;
+    m[2][1] = vLook.y;
+    m[2][2] = vLook.z;
+    m[2][3] = -((camPos->z * vLook.z) + ((camPos->x * vLook.x) + (camPos->y * vLook.y)));
+}
+
+void C_MTXPerspective(Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f) {
+    f32 angle;
+    f32 cot;
+    f32 tmp;
+
+    ASSERTMSGLINE(179, m, "MTXPerspective():  NULL Mtx44Ptr 'm' ");
+    ASSERTMSGLINE(180, (fovY > 0.0) && (fovY < 180.0), "MTXPerspective():  'fovY' out of range ");
+    ASSERTMSGLINE(181, 0.0f != aspect, "MTXPerspective():  'aspect' is 0 ");
+
+    angle = (0.5f * fovY);
+    angle = MTXDegToRad(angle);
+    cot = 1 / tanf(angle);
+    m[0][0] = (cot / aspect);
+    m[0][1] = 0;
+    m[0][2] = 0;
+    m[0][3] = 0;
+    m[1][0] = 0;
+    m[1][1] = (cot);
+    m[1][2] = 0;
+    m[1][3] = 0;
+    m[2][0] = 0;
+    m[2][1] = 0;
+    tmp = 1 / (f - n);
+    m[2][2] = (-n * tmp);
+    m[2][3] = (tmp * -(f * n));
+    m[3][0] = 0;
+    m[3][1] = 0;
+    m[3][2] = -1;
+    m[3][3] = 0;
+}
+
+void C_MTXRotRad(Mtx m, char axis, f32 rad) {
+    f32 sinA;
+    f32 cosA;
+
+    ASSERTMSGLINE(1447, m, "MTXRotRad():  NULL MtxPtr 'm' ");
+    sinA = sinf(rad);
+    cosA = cosf(rad);
+    C_MTXRotTrig(m, axis, sinA, cosA);
+}
+
+void C_MTXScale(Mtx m, f32 xS, f32 yS, f32 zS) {
+    ASSERTMSGLINE(2008, m, "MTXScale():  NULL MtxPtr 'm' ");
+    m[0][0] = xS;
+    m[0][1] = 0;
+    m[0][2] = 0;
+    m[0][3] = 0;
+    m[1][0] = 0;
+    m[1][1] = yS;
+    m[1][2] = 0;
+    m[1][3] = 0;
+    m[2][0] = 0;
+    m[2][1] = 0;
+    m[2][2] = zS;
+    m[2][3] = 0;
+}
+
+void C_MTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS) {
+    ASSERTMSGLINE(2070, src, "MTXScaleApply(): NULL MtxPtr 'src' ");
+    ASSERTMSGLINE(2071, dst, "MTXScaleApply(): NULL MtxPtr 'dst' ");
+    dst[0][0] = (src[0][0] * xS);
+    dst[0][1] = (src[0][1] * xS);
+    dst[0][2] = (src[0][2] * xS);
+    dst[0][3] = (src[0][3] * xS);
+    dst[1][0] = (src[1][0] * yS);
+    dst[1][1] = (src[1][1] * yS);
+    dst[1][2] = (src[1][2] * yS);
+    dst[1][3] = (src[1][3] * yS);
+    dst[2][0] = (src[2][0] * zS);
+    dst[2][1] = (src[2][1] * zS);
+    dst[2][2] = (src[2][2] * zS);
+    dst[2][3] = (src[2][3] * zS);
+}
+
+void C_MTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT) {
+    ASSERTMSGLINE(1933, src, "MTXTransApply(): NULL MtxPtr 'src' ");
+    ASSERTMSGLINE(1934, dst, "MTXTransApply(): NULL MtxPtr 'src' "); //! wrong assert string
+
+    if (src != dst) {
+        dst[0][0] = src[0][0];
+        dst[0][1] = src[0][1];
+        dst[0][2] = src[0][2];
+        dst[1][0] = src[1][0];
+        dst[1][1] = src[1][1];
+        dst[1][2] = src[1][2];
+        dst[2][0] = src[2][0];
+        dst[2][1] = src[2][1];
+        dst[2][2] = src[2][2];
+    }
+
+    dst[0][3] = (src[0][3] + xT);
+    dst[1][3] = (src[1][3] + yT);
+    dst[2][3] = (src[2][3] + zT);
+}
+
+void C_MTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA) {
+    ASSERTMSGLINE(1502, m, "MTXRotTrig():  NULL MtxPtr 'm' ");
+    switch(axis) {
+        case 'x':
+        case 'X':
+            m[0][0] = 1;
+            m[0][1] = 0;
+            m[0][2] = 0;
+            m[0][3] = 0;
+            m[1][0] = 0;
+            m[1][1] = cosA;
+            m[1][2] = -sinA;
+            m[1][3] = 0;
+            m[2][0] = 0;
+            m[2][1] = sinA;
+            m[2][2] = cosA;
+            m[2][3] = 0;
+            break;
+        case 'y':
+        case 'Y':
+            m[0][0] = cosA;
+            m[0][1] = 0;
+            m[0][2] = sinA;
+            m[0][3] = 0;
+            m[1][0] = 0;
+            m[1][1] = 1;
+            m[1][2] = 0;
+            m[1][3] = 0;
+            m[2][0] = -sinA;
+            m[2][1] = 0;
+            m[2][2] = cosA;
+            m[2][3] = 0;
+            break;
+        case 'z':
+        case 'Z':
+            m[0][0] = cosA;
+            m[0][1] = -sinA;
+            m[0][2] = 0;
+            m[0][3] = 0;
+            m[1][0] = sinA;
+            m[1][1] = cosA;
+            m[1][2] = 0;
+            m[1][3] = 0;
+            m[2][0] = 0;
+            m[2][1] = 0;
+            m[2][2] = 1;
+            m[2][3] = 0;
+            break;
+        default:
+            ASSERTMSGLINE(1529, FALSE, "MTXRotTrig():  invalid 'axis' value ");
+            break;
+    }
+}
+
+void C_VECAdd(const Vec* a, const Vec* b, Vec* ab) {
+    ASSERTMSGLINE(114, a, "VECAdd():  NULL VecPtr 'a' ");
+    ASSERTMSGLINE(115, b, "VECAdd():  NULL VecPtr 'b' ");
+    ASSERTMSGLINE(116, ab, "VECAdd():  NULL VecPtr 'ab' ");
+    ab->x = a->x + b->x;
+    ab->y = a->y + b->y;
+    ab->z = a->z + b->z;
+}
+
+// MTX QUAT
+
+void C_QUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq) {
+    Quaternion* r;
+    Quaternion pqTmp;
+
+    ASSERTMSGLINE(193, p, "QUATMultiply():  NULL QuaternionPtr 'p' ");
+    ASSERTMSGLINE(194, q, "QUATMultiply():  NULL QuaternionPtr 'q' ");
+    ASSERTMSGLINE(195, pq, "QUATMultiply():  NULL QuaternionPtr 'pq' ");
+
+    if (p == pq || q == pq){
+        r = &pqTmp;
+    } else {
+        r = pq;
+    }
+
+    r->w = (p->w * q->w) - (p->x * q->x) - (p->y * q->y) - (p->z * q->z);
+    r->x = (p->w * q->x) + (p->x * q->w) + (p->y * q->z) - (p->z * q->y);
+    r->y = (p->w * q->y) + (p->y * q->w) + (p->z * q->x) - (p->x * q->z);
+    r->z = (p->w * q->z) + (p->z * q->w) + (p->x * q->y) - (p->y * q->x);
+    
+    if (r == &pqTmp) {
+        *pq = pqTmp;
+    }
+}
+
+void C_QUATRotAxisRad(Quaternion* r, const Vec* axis, f32 rad) {
+    f32 half, sh, ch;
+    Vec nAxis;
+
+    ASSERTMSGLINE(758, r, "QUATRotAxisRad():  NULL QuaternionPtr 'r' ");
+    ASSERTMSGLINE(759, axis, "QUATRotAxisRad():  NULL VecPtr 'axis' ");
+
+    VECNormalize(axis, &nAxis);
+
+    half = rad * 0.5f;
+    sh = sinf(half);
+    ch = cosf(half);
+
+    r->x = sh * nAxis.x;
+    r->y = sh * nAxis.y;
+    r->z = sh * nAxis.z;
+    r->w = ch;
+}
+
+void C_QUATSlerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t) {
+    f32 theta, sin_th, cos_th;
+    f32 tp, tq;
+
+    ASSERTMSGLINE(869, p, "QUATSlerp():  NULL QuaternionPtr 'p' ");
+    ASSERTMSGLINE(870, q, "QUATSlerp():  NULL QuaternionPtr 'q' ");
+    ASSERTMSGLINE(871, r, "QUATSlerp():  NULL QuaternionPtr 'r' ");
+    
+    cos_th = p->x * q->x + p->y * q->y + p->z * q->z + p->w * q->w;
+    tq = 1.0f;
+
+    if (cos_th < 0.0f) {
+        cos_th = -cos_th;
+        tq = -tq;
+    }
+
+    if (cos_th <= 0.99999f) {
+        theta = acosf(cos_th);
+        sin_th = sinf(theta);
+
+        tp = sinf((1.0f - t) * theta) / sin_th;
+        tq *= sinf(t * theta) / sin_th;
+    } else {
+        tp = 1.0f - t;
+        tq *= t;
+    }
+
+    r->x = (tp * p->x) + (tq * q->x);
+    r->y = (tp * p->y) + (tq * q->y);
+    r->z = (tp * p->z) + (tq * q->z);
+    r->w = (tp * p->w) + (tq * q->w);
+}
+
+void C_VECHalfAngle(const Vec* a, const Vec* b, Vec* half) {
+    Vec aTmp;
+    Vec bTmp;
+    Vec hTmp;
+
+    ASSERTMSGLINE(713, a, "VECHalfAngle():  NULL VecPtr 'a' ");
+    ASSERTMSGLINE(714, b, "VECHalfAngle():  NULL VecPtr 'b' ");
+    ASSERTMSGLINE(715, half, "VECHalfAngle():  NULL VecPtr 'half' ");
+
+    aTmp.x = -a->x;
+    aTmp.y = -a->y;
+    aTmp.z = -a->z;
+    bTmp.x = -b->x;
+    bTmp.y = -b->y;
+    bTmp.z = -b->z;
+
+    VECNormalize(&aTmp, &aTmp);
+    VECNormalize(&bTmp, &bTmp);
+    VECAdd(&aTmp, &bTmp, &hTmp);
+
+    if (VECDotProduct(&hTmp, &hTmp) > 0.0f) {
+        VECNormalize(&hTmp, half);
+        return;
+    }
+    *half = hTmp;
+}
+
+void C_VECNormalize(const Vec* src, Vec* unit) {
+    f32 mag;
+
+    ASSERTMSGLINE(321, src, "VECNormalize():  NULL VecPtr 'src' ");
+    ASSERTMSGLINE(322, unit, "VECNormalize():  NULL VecPtr 'unit' ");
+
+    mag = (src->z * src->z) + ((src->x * src->x) + (src->y * src->y));
+    ASSERTMSGLINE(327, 0.0f != mag, "VECNormalize():  zero magnitude vector ");
+
+    mag = 1.0f/ sqrtf(mag);
+    unit->x = src->x * mag;
+    unit->y = src->y * mag;
+    unit->z = src->z * mag;
+}
+
+void C_VECReflect(const Vec* src, const Vec* normal, Vec* dst) {
+    f32 cosA;
+    Vec uI;
+    Vec uN;
+
+    ASSERTMSGLINE(769, src, "VECReflect():  NULL VecPtr 'src' ");
+    ASSERTMSGLINE(770, normal, "VECReflect():  NULL VecPtr 'normal' ");
+    ASSERTMSGLINE(771, dst, "VECReflect():  NULL VecPtr 'dst' ");
+
+    uI.x = -src->x;
+    uI.y = -src->y;
+    uI.z = -src->z;
+
+    VECNormalize(&uI, &uI);
+    VECNormalize(normal, &uN);
+
+    cosA = VECDotProduct(&uI, &uN);
+    dst->x = (2.0f * uN.x * cosA) - uI.x;
+    dst->y = (2.0f * uN.y * cosA) - uI.y;
+    dst->z = (2.0f * uN.z * cosA) - uI.z;
+    VECNormalize(dst, dst);
+}
+
+u32 C_MTXInverse(const Mtx src, Mtx inv) {
+    Mtx mTmp;
+    MtxPtr m;
+    f32 det;
+
+    ASSERTMSGLINE(950, src, "MTXInverse():  NULL MtxPtr 'src' ");
+    ASSERTMSGLINE(951, inv, "MTXInverse():  NULL MtxPtr 'inv' ");
+
+    if (src == inv) {
+        m = mTmp;
+    } else {
+        m = inv;
+    }
+    det = ((((src[2][1] * (src[0][2] * src[1][0])) 
+          + ((src[2][2] * (src[0][0] * src[1][1])) 
+           + (src[2][0] * (src[0][1] * src[1][2])))) 
+           - (src[0][2] * (src[2][0] * src[1][1]))) 
+           - (src[2][2] * (src[1][0] * src[0][1]))) 
+           - (src[1][2] * (src[0][0] * src[2][1]));
+    if (0 == det) {
+        return 0;
+    }
+    det = 1 / det;
+    m[0][0] = (det * +((src[1][1] * src[2][2]) - (src[2][1] * src[1][2])));
+    m[0][1] = (det * -((src[0][1] * src[2][2]) - (src[2][1] * src[0][2])));
+    m[0][2] = (det * +((src[0][1] * src[1][2]) - (src[1][1] * src[0][2])));
+
+    m[1][0] = (det * -((src[1][0] * src[2][2]) - (src[2][0] * src[1][2])));
+    m[1][1] = (det * +((src[0][0] * src[2][2]) - (src[2][0] * src[0][2])));
+    m[1][2] = (det * -((src[0][0] * src[1][2]) - (src[1][0] * src[0][2])));
+
+    m[2][0] = (det * +((src[1][0] * src[2][1]) - (src[2][0] * src[1][1])));
+    m[2][1] = (det * -((src[0][0] * src[2][1]) - (src[2][0] * src[0][1])));
+    m[2][2] = (det * +((src[0][0] * src[1][1]) - (src[1][0] * src[0][1])));
+
+    m[0][3] = ((-m[0][0] * src[0][3]) - (m[0][1] * src[1][3])) - (m[0][2] * src[2][3]);
+    m[1][3] = ((-m[1][0] * src[0][3]) - (m[1][1] * src[1][3])) - (m[1][2] * src[2][3]);
+    m[2][3] = ((-m[2][0] * src[0][3]) - (m[2][1] * src[1][3])) - (m[2][2] * src[2][3]);
+
+    if (m == mTmp) {
+        C_MTXCopy(mTmp, inv);
+    }
+    return 1;
+}
+
+void C_MTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count) {
+    u32 i;
+
+    ASSERTMSGLINE(580, a != 0, "MTXConcatArray(): NULL MtxPtr 'a' ");
+    ASSERTMSGLINE(581, srcBase != 0, "MTXConcatArray(): NULL MtxPtr 'srcBase' ");
+    ASSERTMSGLINE(582, dstBase != 0, "MTXConcatArray(): NULL MtxPtr 'dstBase' ");
+    ASSERTMSGLINE(583, count > 1, "MTXConcatArray(): count must be greater than 1.");
+
+    for (i = 0; i < count; i++) {
+        C_MTXConcat(a, *srcBase, *dstBase);
+        srcBase++;
+        dstBase++;
+    }
+}
+
+void C_MTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count) {
+    u32 i;
+    Vec vTmp;
+
+    ASSERTMSGLINE(168, m, "MTXMultVecArray():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(169, srcBase, "MTXMultVecArray():  NULL VecPtr 'srcBase' ");
+    ASSERTMSGLINE(170, dstBase, "MTXMultVecArray():  NULL VecPtr 'dstBase' ");
+    ASSERTMSGLINE(171, count > 1, "MTXMultVecArray():  count must be greater than 1.");
+
+    for(i = 0; i < count; i++) {
+        vTmp.x = m[0][3] + ((m[0][2] * srcBase->z) + ((m[0][0] * srcBase->x) + (m[0][1] * srcBase->y)));
+        vTmp.y = m[1][3] + ((m[1][2] * srcBase->z) + ((m[1][0] * srcBase->x) + (m[1][1] * srcBase->y)));
+        vTmp.z = m[2][3] + ((m[2][2] * srcBase->z) + ((m[2][0] * srcBase->x) + (m[2][1] * srcBase->y)));
+        dstBase->x = vTmp.x;
+        dstBase->y = vTmp.y;
+        dstBase->z = vTmp.z;
+        srcBase++;
+        dstBase++;
+    }
+}
+
+void C_MTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count) {
+    u32 i;
+    Vec vTmp;
+
+    ASSERTMSGLINE(410, m, "MTXMultVecArraySR():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(411, srcBase, "MTXMultVecArraySR():  NULL VecPtr 'srcBase' ");
+    ASSERTMSGLINE(412, dstBase, "MTXMultVecArraySR():  NULL VecPtr 'dstBase' ");
+    ASSERTMSGLINE(413, count > 1, "MTXMultVecArraySR():  count must be greater than 1.");
+
+    for(i = 0; i < count; i++) {
+        vTmp.x = (m[0][2] * srcBase->z) + ((m[0][0] * srcBase->x) + (m[0][1] * srcBase->y));
+        vTmp.y = (m[1][2] * srcBase->z) + ((m[1][0] * srcBase->x) + (m[1][1] * srcBase->y));
+        vTmp.z = (m[2][2] * srcBase->z) + ((m[2][0] * srcBase->x) + (m[2][1] * srcBase->y));
+        dstBase->x = vTmp.x;
+        dstBase->y = vTmp.y;
+        dstBase->z = vTmp.z;
+        srcBase++;
+        dstBase++;
+    }
+}
+
+void C_MTXQuat(Mtx m, const Quaternion* q) {
+    f32 s;
+    f32 xs;
+    f32 ys;
+    f32 zs;
+    f32 wx;
+    f32 wy;
+    f32 wz;
+    f32 xx;
+    f32 xy;
+    f32 xz;
+    f32 yy;
+    f32 yz;
+    f32 zz;
+
+    ASSERTMSGLINE(2145, m, "MTXQuat():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(2146, q, "MTXQuat():  NULL QuaternionPtr 'q' ");
+    ASSERTMSGLINE(2147, q->x || q->y || q->z || q->w, "MTXQuat():  zero-value quaternion ");
+    s = 2 / ((q->w * q->w) + ((q->z * q->z) + ((q->x * q->x) + (q->y * q->y))));
+    xs = q->x * s;
+    ys = q->y * s;
+    zs = q->z * s;
+    wx = q->w * xs;
+    wy = q->w * ys;
+    wz = q->w * zs;
+    xx = q->x * xs;
+    xy = q->x * ys;
+    xz = q->x * zs;
+    yy = q->y * ys;
+    yz = q->y * zs;
+    zz = q->z * zs;
+    m[0][0] = (1 - (yy + zz));
+    m[0][1] = (xy - wz);
+    m[0][2] = (xz + wy);
+    m[0][3] = 0;
+    m[1][0] = (xy + wz);
+    m[1][1] = (1 - (xx + zz));
+    m[1][2] = (yz - wx);
+    m[1][3] = 0;
+    m[2][0] = (xz - wy);
+    m[2][1] = (yz + wx);
+    m[2][2] = (1 - (xx + yy));
+    m[2][3] = 0;
+}
+void C_MTXRotAxisRad(Mtx m, const Vec* axis, f32 rad) {
+    Vec vN;
+    f32 s;
+    f32 c;
+    f32 t;
+    f32 x;
+    f32 y;
+    f32 z;
+    f32 xSq;
+    f32 ySq;
+    f32 zSq;
+
+    ASSERTMSGLINE(1677, m, "MTXRotAxisRad():  NULL MtxPtr 'm' ");
+    ASSERTMSGLINE(1678, axis, "MTXRotAxisRad():  NULL VecPtr 'axis' ");
+
+    s = sinf(rad);
+    c = cosf(rad);
+    t = 1 - c;
+    C_VECNormalize(axis, &vN);
+    x = vN.x;
+    y = vN.y;
+    z = vN.z;
+    xSq = (x * x);
+    ySq = (y * y);
+    zSq = (z * z);
+    m[0][0] = (c + (t * xSq));
+    m[0][1] = (y * (t * x)) - (s * z);
+    m[0][2] = (z * (t * x)) + (s * y);
+    m[0][3] = 0;
+    m[1][0] = ((y * (t * x)) + (s * z));
+    m[1][1] = (c + (t * ySq));
+    m[1][2] = ((z * (t * y)) - (s * x));
+    m[1][3] = 0;
+    m[2][0] = ((z * (t * x)) - (s * y));
+    m[2][1] = ((z * (t * y)) + (s * x));
+    m[2][2] = (c + (t * zSq));
+    m[2][3] = 0;
+}
+
+// VEC
+void C_VECCrossProduct(const Vec* a, const Vec* b, Vec* axb) {
+    Vec vTmp;
+
+    ASSERTMSGLINE(608, a, "VECCrossProduct():  NULL VecPtr 'a' ");
+    ASSERTMSGLINE(609, b, "VECCrossProduct():  NULL VecPtr 'b' ");
+    ASSERTMSGLINE(610, axb, "VECCrossProduct():  NULL VecPtr 'axb' ");
+
+    vTmp.x = (a->y * b->z) - (a->z * b->y);
+    vTmp.y = (a->z * b->x) - (a->x * b->z);
+    vTmp.z = (a->x * b->y) - (a->y * b->x);
+    axb->x = vTmp.x;
+    axb->y = vTmp.y;
+    axb->z = vTmp.z;
+}
+
+f32 C_VECDistance(const Vec* a, const Vec* b) {
+    return sqrtf(C_VECSquareDistance(a, b));
+}
+
+f32 C_VECDotProduct(const Vec* a, const Vec* b) {
+    f32 dot;
+
+    ASSERTMSGLINE(546, a, "VECDotProduct():  NULL VecPtr 'a' ");
+    ASSERTMSGLINE(547, b, "VECDotProduct():  NULL VecPtr 'b' ");
+    dot = (a->z * b->z) + ((a->x * b->x) + (a->y * b->y));
+    return dot;
+}
+
+f32 C_VECMag(const Vec* v) {
+    return sqrtf(C_VECSquareMag(v));
+}
+
+void C_VECScale(const Vec* src, Vec* dst, f32 scale) {
+    ASSERTMSGLINE(253, src, "VECScale():  NULL VecPtr 'src' ");
+    ASSERTMSGLINE(254, dst, "VECScale():  NULL VecPtr 'dst' ");
+    dst->x = (src->x * scale);
+    dst->y = (src->y * scale);
+    dst->z = (src->z * scale);
+}
+
+f32 C_VECSquareDistance(const Vec* a, const Vec* b) {
+    Vec diff;
+
+    diff.x = a->x - b->x;
+    diff.y = a->y - b->y;
+    diff.z = a->z - b->z;
+    return (diff.z * diff.z) + ((diff.x * diff.x) + (diff.y * diff.y));
+}
+
+f32 C_VECSquareMag(const Vec* v) {
+    f32 sqmag;
+
+    ASSERTMSGLINE(411, v, "VECMag():  NULL VecPtr 'v' ");
+
+    sqmag = v->z * v->z + ((v->x * v->x) + (v->y * v->y));
+    return sqmag;
+}
+
+void C_VECSubtract(const Vec* a, const Vec* b, Vec* a_b) {
+    ASSERTMSGLINE(183, a, "VECSubtract():  NULL VecPtr 'a' ");
+    ASSERTMSGLINE(184, b, "VECSubtract():  NULL VecPtr 'b' ");
+    ASSERTMSGLINE(185, a_b, "VECSubtract():  NULL VecPtr 'a_b' ");
+    a_b->x = a->x - b->x;
+    a_b->y = a->y - b->y;
+    a_b->z = a->z - b->z;
+}
+
+#pragma mark PSMTX
+// I think these are PPC ASM implemntations?
+// this can be done just with defining DEBUG, but that has some other
+// implecations, so we'll just define them here for now. These are all just wrappers around the C versions, so we can just call those directly.
+void PSMTXConcatArray(const __REGISTER Mtx a, const __REGISTER Mtx* srcBase, __REGISTER Mtx* dstBase, __REGISTER u32 count) {
+  C_MTXConcatArray(a, srcBase, dstBase, count);
+}
+void PSMTXCopy(const __REGISTER Mtx src, __REGISTER Mtx dst) {
+    C_MTXCopy(src, dst);
+}
+void PSMTXIdentity(__REGISTER Mtx m) {
+    C_MTXIdentity(m);
+}
+u32 PSMTXInverse(const __REGISTER Mtx src, __REGISTER Mtx inv) {
+    return C_MTXInverse(src, inv);
+}
+void PSMTXMultVec(const __REGISTER Mtx m, const __REGISTER Vec* src, __REGISTER Vec* dst) {
+    C_MTXMultVec(m, src, dst);
+}
+void PSMTXConcat(const __REGISTER Mtx a, const __REGISTER Mtx b, __REGISTER Mtx ab) {
+    C_MTXConcat(a, b, ab);
+}
+void PSMTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count) {
+    C_MTXMultVecArray(m, srcBase, dstBase, count);
+}
+void PSMTXMultVecArraySR(const __REGISTER Mtx m, const __REGISTER Vec* srcBase, __REGISTER Vec* dstBase, __REGISTER u32 count) {
+    C_MTXMultVecArraySR(m, srcBase, dstBase, count);
+}
+void PSMTXMultVecSR(const __REGISTER Mtx m, const __REGISTER Vec* src, __REGISTER Vec* dst) {
+    C_MTXMultVecSR(m, src, dst);
+}
+void PSMTXQuat(__REGISTER Mtx m, const __REGISTER Quaternion* q) {
+    C_MTXQuat(m, q);
+}
+void PSMTXRotAxisRad(Mtx m, const Vec* axis, f32 rad) {
+    C_MTXRotAxisRad(m, axis, rad);
+}
+void PSMTXRotRad(Mtx m, char axis, f32 rad) {
+    C_MTXRotRad(m, axis, rad);
+}
+void PSMTXScale(__REGISTER Mtx m, __REGISTER f32 xS, __REGISTER f32 yS, __REGISTER f32 zS) {
+    C_MTXScale(m, xS, yS, zS);
+}
+void PSMTXScaleApply(const __REGISTER Mtx src, __REGISTER Mtx dst, __REGISTER f32 xS, __REGISTER f32 yS, __REGISTER f32 zS) {
+    C_MTXScaleApply(src, dst, xS, yS, zS);
+}
+void PSMTXTrans(__REGISTER Mtx m, __REGISTER f32 xT, __REGISTER f32 yT, __REGISTER f32 zT) {
+    C_MTXTrans(m, xT, yT, zT);
+}
+void PSMTXTransApply(const __REGISTER Mtx src, __REGISTER Mtx dst, __REGISTER f32 xT, __REGISTER f32 yT, __REGISTER f32 zT) {
+    C_MTXTransApply(src, dst, xT, yT, zT);
+}
+void PSQUATMultiply(const __REGISTER Quaternion* p, const __REGISTER Quaternion* q, __REGISTER Quaternion* pq) {
+    C_QUATMultiply(p, q, pq);
+}
+void PSVECAdd(const __REGISTER Vec* a, const __REGISTER Vec* b, __REGISTER Vec* ab) {
+    C_VECAdd(a, b, ab);
+}
+void PSVECCrossProduct(const __REGISTER Vec* a, const __REGISTER Vec* b, __REGISTER Vec* axb) {
+    C_VECCrossProduct(a, b, axb);
+}
+f32 PSVECDistance(const __REGISTER Vec* a, const __REGISTER Vec* b) {
+    return C_VECDistance(a, b);
+}
+f32 PSVECDotProduct(const __REGISTER Vec* a, const __REGISTER Vec* b) {
+    return C_VECDotProduct(a, b);
+}
+f32 PSVECMag(const __REGISTER Vec* v) {
+    return C_VECMag(v);
+}
+void PSVECNormalize(const __REGISTER Vec* src, __REGISTER Vec* unit) {
+    C_VECNormalize(src, unit);
+}
+void PSVECScale(const __REGISTER Vec* src, __REGISTER Vec* dst, __REGISTER f32 scale) {
+    C_VECScale(src, dst, scale);
+}
+f32 PSVECSquareDistance(const __REGISTER Vec* a, const __REGISTER Vec* b) {
+    return C_VECSquareDistance(a, b);
+}
+f32 PSVECSquareMag(const __REGISTER Vec* v) {
+    return C_VECSquareMag(v);
+}
+void PSVECSubtract(const __REGISTER Vec* a, const __REGISTER Vec* b, __REGISTER Vec* a_b) {
+    C_VECSubtract(a, b, a_b);
+}

src/dusk/stubs.c

@@ -1,517 +0,0 @@
-#include <dolphin.h>
-#include <dolphin/gx/GXVert.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-// Credits: Super Monkey Ball
-
-static VIRetraceCallback sVIRetraceCallback = NULL;
-
-void OSReport(const char *msg, ...) {
-  va_list args;
-  va_start(args, msg);
-  vprintf(msg, args);
-  va_end(args);
-}
-
-u32 OSGetConsoleType() { return OS_CONSOLE_RETAIL1; }
-
-u32 OSGetSoundMode() { return 2; }
-
-s32 CARDCancel(CARDFileInfo *fileInfo) {
-  puts("CARDCancel is a stub");
-  return 0;
-}
-
-s32 CARDCheck(s32 chan) {
-  puts("CARDCheck is a stub");
-  return 0;
-}
-
-s32 CARDCheckAsync(s32 chan, CARDCallback callback) {
-  puts("CARDCheckAsync is a stub");
-  return 0;
-}
-
-s32 CARDClose(CARDFileInfo *fileInfo) {
-  puts("CARDClose is a stub");
-  return 0;
-}
-
-s32 CARDCreate(s32 chan, const char *fileName, u32 size,
-               CARDFileInfo *fileInfo) {
-  puts("CARDCreate is a stub");
-  return 0;
-}
-
-s32 CARDCreateAsync(s32 chan, const char *fileName, u32 size,
-                    CARDFileInfo *fileInfo, CARDCallback callback) {
-  puts("CARDCreateAsync is a stub");
-  return 0;
-}
-
-s32 CARDDelete(s32 chan, const char *fileName) {
-  puts("CARDDelete is a stub");
-  return 0;
-}
-
-s32 CARDDeleteAsync(s32 chan, const char *fileName, CARDCallback callback) {
-  puts("CARDDeleteAsync is a stub");
-  return 0;
-}
-
-s32 CARDFastDeleteAsync(s32 chan, s32 fileNo, CARDCallback callback) {
-  puts("CARDFastDeleteAsync is a stub");
-  return 0;
-}
-
-s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo *fileInfo) {
-  puts("CARDFastOpen is a stub");
-  return 0;
-}
-
-s32 CARDFormat(s32 chan) {
-  puts("CARDFormat is a stub");
-  return 0;
-}
-
-s32 CARDFreeBlocks(s32 chan, s32 *byteNotUsed, s32 *filesNotUsed) {
-  puts("CARDFreeBlocks is a stub");
-  return 0;
-}
-
-s32 CARDGetResultCode(s32 chan) {
-  puts("CARDGetResultCode is a stub");
-  return 0;
-}
-
-s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat *stat) {
-  puts("CARDGetStatus is a stub");
-  return 0;
-}
-
-s32 CARDGetSectorSize(s32 chan, u32 *size) {
-  puts("CARDGetSectorSize is a stub");
-  return 0;
-}
-
-void CARDInit() { puts("CARDInit is a stub"); }
-
-s32 CARDMount(s32 chan, void *workArea, CARDCallback detachCallback) {
-  puts("CARDMount is a stub");
-  return 0;
-}
-
-s32 CARDMountAsync(s32 chan, void *workArea, CARDCallback detachCallback,
-                   CARDCallback attachCallback) {
-  puts("CARDMountAsync is a stub");
-  return 0;
-}
-
-s32 CARDOpen(s32 chan, const char *fileName, CARDFileInfo *fileInfo) {
-  puts("CARDOpen is a stub");
-  return 0;
-}
-
-s32 CARDProbeEx(s32 chan, s32 *memSize, s32 *sectorSize) {
-  puts("CARDProbeEx is a stub");
-  return 0;
-}
-
-s32 CARDRead(CARDFileInfo *fileInfo, void *addr, s32 length, s32 offset) {
-  puts("CARDRead is a stub");
-  return 0;
-}
-
-s32 CARDReadAsync(CARDFileInfo *fileInfo, void *addr, s32 length, s32 offset,
-                  CARDCallback callback) {
-  puts("CARDReadAsync is a stub");
-  return 0;
-}
-
-s32 CARDRename(s32 chan, const char *oldName, const char *newName) {
-  puts("CARDRename is a stub");
-  return 0;
-}
-
-s32 CARDRenameAsync(s32 chan, const char *oldName, const char *newName,
-                    CARDCallback callback) {
-  puts("CARDRenameAsync is a stub");
-  return 0;
-}
-
-s32 CARDSetStatusAsync(s32 chan, s32 fileNo, CARDStat *stat,
-                       CARDCallback callback) {
-  puts("CARDSetStatusAsync is a stub");
-  return 0;
-}
-
-s32 CARDUnmount(s32 chan) {
-  puts("CARDUnmount is a stub");
-  return 0;
-}
-
-s32 CARDWrite(CARDFileInfo *fileInfo, const void *addr, s32 length,
-              s32 offset) {
-  puts("CARDWrite is a stub");
-  return 0;
-}
-
-s32 CARDWriteAsync(CARDFileInfo *fileInfo, const void *addr, s32 length,
-                   s32 offset, CARDCallback callback) {
-  puts("CARDWriteAsync is a stub");
-  return 0;
-}
-
-s32 CARDGetSerialNo(s32 chan, u64 *serialNo) { return 0; }
-
-s32 CARDSetStatus(s32 chan, s32 fileNo, CARDStat *stat) { return 0; }
-
-void DCFlushRange(void *addr, u32 nBytes) {
-  // puts("DCFlushRange is a stub");
-}
-
-void DCFlushRangeNoSync(void *addr, u32 nBytes) {
-  // puts("DCFlushRangeNoSync is a stub");
-}
-
-void DCInvalidateRange(void *addr, u32 nBytes) {
-  // puts("DCInvalidateRange is a stub");
-}
-
-void DCStoreRange(void *addr, u32 nBytes) {
-  // puts("DCStoreRange is a stub");
-}
-
-void DCStoreRangeNoSync(void *addr, u32 nBytes) {
-  // puts("DCStoreRangeNoSync is a stub");
-}
-
-s32 DVDCancel(DVDCommandBlock *block) {
-  puts("DVDCancel is a stub");
-  return 0;
-}
-
-void DVDReadAbsAsyncForBS(void *a, struct bb2struct *b, int c, int d,
-                          void (*e)()) {
-  puts("DVDReadAbsAsyncForBS is a stub");
-}
-
-void DVDReadDiskID(void *a, DVDDiskID *b, void (*c)()) {
-  puts("DVDReadDiskID is a stub");
-}
-
-void DVDReset() { puts("DVDReset is a stub"); }
-
-BOOL EXIDeselect(int chan) {
-  puts("EXIDeselect is a stub");
-  return FALSE;
-}
-
-BOOL EXIDma(int chan, void *buffer, s32 size, int d, int e) {
-  puts("EXIDma is a stub");
-  return FALSE;
-}
-
-BOOL EXIImm(int chan, u32 *b, int c, int d, int e) {
-  puts("EXIImm is a stub");
-  return FALSE;
-}
-
-BOOL EXILock(int chan, int b, int c) {
-  puts("EXILock is a stub");
-  return FALSE;
-}
-
-BOOL EXISelect(int chan, int b, int c) {
-  puts("EXISelect is a stub");
-  return FALSE;
-}
-
-BOOL EXISync(int chan) {
-  puts("EXISync is a stub");
-  return FALSE;
-}
-
-BOOL EXIUnlock(int chan) {
-  puts("EXIUnlock is a stub");
-  return FALSE;
-}
-
-void LCEnable() { puts("LCEnable is a stub"); }
-
-void OSClearContext(OSContext *context) { puts("OSClearContext is a stub"); }
-
-BOOL OSDisableInterrupts() {
-  puts("OSDisableInterrupts is a stub");
-  return FALSE;
-}
-
-void OSDumpContext(OSContext *context) { puts("OSDumpContext is a stub"); }
-
-OSThread *OSGetCurrentThread() {
-  puts("OSGetCurrentThread is a stub");
-  return 0;
-}
-
-u16 OSGetFontEncode() {
-  puts("OSGetFontEncode is a stub");
-  return 0;
-}
-
-char *OSGetFontTexture(char *string, void **image, s32 *x, s32 *y, s32 *width) {
-  puts("OSGetFontTexture is a stub");
-  return 0;
-}
-
-char *OSGetFontWidth(char *string, s32 *width) {
-  puts("OSGetFontWidth is a stub");
-  return 0;
-}
-
-BOOL OSGetResetButtonState() {
-  puts("OSGetResetButtonState is a stub");
-  return FALSE;
-}
-
-u32 OSGetStackPointer() {
-  puts("OSGetStackPointer is a stub");
-  return 0;
-}
-
-BOOL OSInitFont(OSFontHeader *fontData) {
-  puts("OSInitFont is a stub");
-  return FALSE;
-}
-
-BOOL OSLink(OSModuleInfo *newModule, void *bss) {
-  puts("OSLink is a stub");
-  return TRUE;
-}
-
-void OSLoadContext(OSContext *context) { puts("OSLoadContext is a stub"); }
-
-void OSResetSystem(int reset, u32 resetCode, BOOL forceMenu) {
-  puts("OSResetSystem is a stub");
-}
-
-BOOL OSRestoreInterrupts(BOOL level) {
-  puts("OSRestoreInterrupts is a stub");
-  return FALSE;
-}
-
-s32 OSResumeThread(OSThread *thread) {
-  puts("OSResumeThread is a stub");
-  return 0;
-}
-
-void OSSetCurrentContext(OSContext *context) {
-  puts("OSSetCurrentContext is a stub");
-}
-
-void OSSetStringTable(const void *stringTable) {
-  puts("OSSetStringTable is a stub");
-}
-
-s32 OSSuspendThread(OSThread *thread) {
-  puts("OSSuspendThread is a stub");
-  return 0;
-}
-
-void OSTicksToCalendarTime(OSTime ticks, OSCalendarTime *td) {
-  puts("OSTicksToCalendarTime is a stub");
-}
-
-BOOL OSUnlink(OSModuleInfo *oldModule) {
-  puts("OSUnlink is a stub");
-  return FALSE;
-}
-
-void OSWakeupThread(OSThreadQueue *queue) { puts("OSWakeupThread is a stub"); }
-
-void PPCHalt() { puts("PPCHalt is a stub"); }
-
-void SoundChoID(int a, int b) { puts("SoundChoID is a stub"); }
-
-void SoundPan(int a, int b, int c) { puts("SoundPan is a stub"); }
-
-void SoundPitch(u16 a, int b) { puts("SoundPitch is a stub"); }
-
-void SoundRevID(int a, int b) { puts("SoundRevID is a stub"); }
-
-void VIConfigure(const GXRenderModeObj *rm) { puts("VIConfigure is a stub"); }
-
-void VIConfigurePan(u16 xOrg, u16 yOrg, u16 width, u16 height) {
-  puts("VIConfigurePan is a stub");
-}
-
-u32 VIGetRetraceCount() {
-  // puts("VIGetRetraceCount is a stub");
-  return 0; // TODO this might be important
-}
-
-u32 VIGetNextField() {
-  puts("VIGetNextField is a stub");
-  return 0;
-}
-
-void VISetBlack(BOOL black) { puts("VISetBlack is a stub"); }
-
-void VISetNextFrameBuffer(void *fb) {
-  // puts("VISetNextFrameBuffer is a stub");
-}
-
-void VIWaitForRetrace() {
-  if (sVIRetraceCallback) {
-    sVIRetraceCallback(0);
-  }
-}
-
-s32 __CARDFormatRegionAsync(int a, int b) {
-  puts("__CARDFormatRegionAsync is a stub");
-  return 0;
-}
-
-void __GXSetSUTexSize() { puts("__GXSetSUTexSize is a stub"); }
-
-void __GXSetVAT() { puts("__GXSetVAT is a stub"); }
-
-void __GXSetVCD() { puts("__GXSetVCD is a stub"); }
-
-void __GXUpdateBPMask() { puts("__GXUpdateBPMask is a stub"); }
-
-u32 __OSGetDIConfig() {
-  puts("__OSGetDIConfig is a stub");
-  return 0;
-}
-
-__OSInterruptHandler __OSSetInterruptHandler(__OSInterrupt interrupt,
-                                             __OSInterruptHandler handler) {
-  puts("__OSSetInterruptHandler is a stub");
-  return 0;
-}
-
-OSInterruptMask __OSUnmaskInterrupts(OSInterruptMask mask) {
-  puts("__OSUnmaskInterrupts is a stub");
-  return 0;
-}
-
-void SISetSamplingRate(u32 msec) {
-  // Maybe we could include SI later
-  puts("SISetSamplingRate is a stub");
-}
-
-VIRetraceCallback VISetPostRetraceCallback(VIRetraceCallback callback) {
-  sVIRetraceCallback = callback;
-  return callback;
-}
-
-void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1) {
-  // puts("GXSetGPMetric is a stub");
-}
-
-void GXReadGPMetric(u32 *cnt0, u32 *cnt1) {
-  // puts("GXReadGPMetric is a stub");
-}
-
-void GXClearGPMetric(void) {
-  // puts("GXClearGPMetric is a stub");
-}
-
-void GXReadMemMetric(u32 *cp_req, u32 *tc_req, u32 *cpu_rd_req, u32 *cpu_wr_req,
-                     u32 *dsp_req, u32 *io_req, u32 *vi_req, u32 *pe_req,
-                     u32 *rf_req, u32 *fi_req) {
-  // puts("GXReadMemMetric is a stub");
-}
-
-void GXClearMemMetric(void) {
-  // puts("GXClearMemMetric is a stub");
-}
-
-void GXClearVCacheMetric(void) {
-  // puts("GXClearVCacheMetric is a stub");
-}
-
-void GXReadPixMetric(u32 *top_pixels_in, u32 *top_pixels_out,
-                     u32 *bot_pixels_in, u32 *bot_pixels_out,
-                     u32 *clr_pixels_in, u32 *copy_clks) {
-  // puts("GXReadPixMetric is a stub");
-}
-
-void GXClearPixMetric(void) {
-  // puts("GXClearPixMetric is a stub");
-}
-
-void GXSetVCacheMetric(GXVCachePerf attr) {
-  // puts("GXSetVCacheMetric is a stub");
-}
-
-void GXReadVCacheMetric(u32 *check, u32 *miss, u32 *stall) {
-  // puts("GXReadVCacheMetric is a stub");
-}
-
-void GXSetDrawSync(u16 token) {
-  // puts("GXSetDrawSync is a stub");
-}
-
-GXDrawSyncCallback GXSetDrawSyncCallback(GXDrawSyncCallback cb) {
-  puts("GXSetDrawSyncCallback is a stub");
-  // TODO
-  return cb;
-}
-
-void PPCSync(void) {
-  // puts("PPCSync is a stub");
-}
-
-void GXWaitDrawDone(void) {
-  // puts("GXWaitDrawDone is a stub");
-}
-
-void GXSetTevIndTile(GXTevStageID tev_stage, GXIndTexStageID ind_stage,
-                     u16 tilesize_s, u16 tilesize_t, u16 tilespacing_s,
-                     u16 tilespacing_t, GXIndTexFormat format,
-                     GXIndTexMtxID matrix_sel, GXIndTexBiasSel bias_sel,
-                     GXIndTexAlphaSel alpha_sel) {
-  // TODO
-  // puts("GXSetTevIndTile is a stub");
-}
-
-void GXResetWriteGatherPipe(void) {
-  // puts("GXResetWriteGatherPipe is a stub");
-}
-
-void ARQInit(void) { puts("ARQInit is a stub"); }
-
-void GXProject(f32 x, f32 y, f32 z, const f32 mtx[3][4], const f32 *pm,
-               const f32 *vp, f32 *sx, f32 *sy, f32 *sz) {
-  Vec peye;
-  f32 xc;
-  f32 yc;
-  f32 zc;
-  f32 wc;
-
-  peye.x = mtx[0][3] + ((mtx[0][2] * z) + ((mtx[0][0] * x) + (mtx[0][1] * y)));
-  peye.y = mtx[1][3] + ((mtx[1][2] * z) + ((mtx[1][0] * x) + (mtx[1][1] * y)));
-  peye.z = mtx[2][3] + ((mtx[2][2] * z) + ((mtx[2][0] * x) + (mtx[2][1] * y)));
-  if (pm[0] == 0.0f) {
-    xc = (peye.x * pm[1]) + (peye.z * pm[2]);
-    yc = (peye.y * pm[3]) + (peye.z * pm[4]);
-    zc = pm[6] + (peye.z * pm[5]);
-    wc = 1.0f / -peye.z;
-  } else {
-    xc = pm[2] + (peye.x * pm[1]);
-    yc = pm[4] + (peye.y * pm[3]);
-    zc = pm[6] + (peye.z * pm[5]);
-    wc = 1.0f;
-  }
-  *sx = (vp[2] / 2.0f) + (vp[0] + (wc * (xc * vp[2] / 2.0f)));
-  *sy = (vp[3] / 2.0f) + (vp[1] + (wc * (-yc * vp[3] / 2.0f)));
-  *sz = vp[5] + (wc * (zc * (vp[5] - vp[4])));
-}
-
-void GXGetViewportv(f32 *vp) {
-  // TODO
-}
-
-void OSSetSoundMode(u32 mode) {}