mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-05-27 07:37:24 -04:00
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
This commit is contained in:
Jeffrey Crowell
+6
-1
@@ -1347,6 +1347,11 @@ set(DUSK_FILES
|
||||
src/dusk/imgui.cpp
|
||||
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})
|
||||
@@ -1357,7 +1362,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)
|
||||
|
||||
@@ -33,6 +33,11 @@ public:
|
||||
static T* sInstance;
|
||||
};
|
||||
|
||||
#ifndef __MWERKS__
|
||||
template<class T>
|
||||
T* JASGlobalInstance<T>::sInstance;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @ingroup jsystem-jaudio
|
||||
*
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
#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
|
||||
#include <dolphin/dsp.h>
|
||||
DSPTaskInfo* __DSP_first_task;
|
||||
DSPTaskInfo* __DSP_curr_task;
|
||||
|
||||
// mDo_dvd
|
||||
#include <m_Do/m_Do_dvd_thread.h>
|
||||
u8 mDoDvdThd::DVDLogoMode;
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
+1231
-849
File diff suppressed because it is too large
Load Diff
@@ -774,9 +774,16 @@ void main01(void) {
|
||||
} while (true);
|
||||
}
|
||||
|
||||
#if !__MWERKS__
|
||||
template<typename T>
|
||||
JHIComPortManager<T>* JHIComPortManager<T>::instance = nullptr;
|
||||
|
||||
template<>
|
||||
JHIComPortManager<JHICmnMem>* JHIComPortManager<JHICmnMem>::instance = nullptr;
|
||||
#endif
|
||||
|
||||
#if DEBUG
|
||||
JHIComPortManager<JHICmnMem>* JHIComPortManager<JHICmnMem>:: instance;
|
||||
|
||||
// DEBUG NONMATCHING
|
||||
void parse_args(int argc, const char* argv[]) {
|
||||
int i;
|
||||
|
||||
Reference in New Issue
Block a user