mirror/ss
1
0
Fork 0
mirror of https://github.com/zeldaret/ss synced 2026-06-02 18:18:38 -04:00
Code Issues Packages Projects Releases Wiki Activity

MTX/VEC cleanup

Browse Source
This commit is contained in:
robojumper
2026-05-07 19:53:30 +02:00
parent ddb1161879
commit d8744e1f34
76 changed files with 243 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/d/col/c/c_m3d_g_lin.h
+1 -1
View File
@@ -26,7 +26,7 @@ public:
void CalcPos(mVec3_c *, f32) const;
void CalcVec(Vec *pOut) const {
PSVECSubtract(mEnd, mStart, pOut);
VECSubtract(mEnd, mStart, pOut);
}
void SetStart(const mVec3_c &);
include/m/m_vec.h
+1 -6
View File
@@ -222,7 +222,7 @@ public:
}
f32 distance(const mVec3_c &to) const {
return EGG::Math<f32>::sqrt(PSVECSquareDistance(*this, to));
return EGG::Math<f32>::sqrt(VECSquareDistance(*this, to));
}
f32 squareDistance(const mVec3_c &to) const {
return VEC3DistSq(*this, to);
@@ -277,11 +277,6 @@ public:
return EGG::Vector3f::angle(other);
}
void offsetWithAngle(s16 yRot, f32 scale) {
this->x += nw4r::math::SinIdx(yRot) * scale;
this->z += nw4r::math::CosIdx(yRot) * scale;
}
static mVec3_c Zero;
static mVec3_c Ex;
static mVec3_c Ey;
include/nw4r/g3d/g3d_calcworld.h
+4 -4
View File
@@ -64,21 +64,21 @@ public:
void SetScale(f32 x, f32 y, f32 z);
void GetMtx(nw4r::math::MTX34 *out) {
if (out != NULL) {
PSMTXCopy(*mpM, *out);
MTXCopy(*mpM, *out);
}
}
void SetMtx(const nw4r::math::MTX34 *arg) {
if (arg != NULL) {
PSMTXCopy(*arg, *mpM);
MTXCopy(*arg, *mpM);
} else {
PSMTXIdentity(*mpM);
MTXIdentity(*mpM);
}
}
// Not sure
void SetMtxUnchecked(const nw4r::math::MTX34 *arg) {
PSMTXCopy(*arg, *mpM);
MTXCopy(*arg, *mpM);
}
private:
include/nw4r/math/math_types.h
+15 -15
View File
@@ -448,30 +448,30 @@ inline VEC3 *VEC3Sub(register VEC3 *out, register const VEC3 *a, register const
}
inline VEC3 *VEC3Cross(VEC3 *out, const VEC3 *a, const VEC3 *b) {
PSVECCrossProduct(*a, *b, *out);
VECCrossProduct(*a, *b, *out);
return out;
}
inline f32 VEC3DistSq(const VEC3 *a, const VEC3 *b) {
return PSVECSquareDistance(*a, *b);
return VECSquareDistance(*a, *b);
}
inline f32 VEC3Len(const VEC3 *vec) {
return PSVECMag(*vec);
return VECMag(*vec);
}
inline VEC3 *VEC3Normalize(VEC3 *out, const VEC3 *in) {
PSVECNormalize(*in, *out);
VECNormalize(*in, *out);
return out;
}
inline VEC3 *VEC3Transform(VEC3 *out, const MTX34 *mtx, const VEC3 *vec) {
PSMTXMultVec(*mtx, *vec, *out);
MTXMultVec(*mtx, *vec, *out);
return out;
}
inline VEC3 *VEC3TransformCoord(VEC3 *out, const MTX34 *mtx, const VEC3 *vec) {
PSMTXMultVec(*mtx, *vec, *out);
MTXMultVec(*mtx, *vec, *out);
return out;
}
@@ -496,21 +496,21 @@ MTX34 *MTX34RotAxisFIdx(MTX34 *mtx, const VEC3 *axis, f32 fidx);
MTX34 *MTX34RotXYZFIdx(MTX34 *mtx, f32 fx, f32 fy, f32 fz);
inline MTX34 *MTX34Copy(MTX34 *out, const MTX34 *in) {
PSMTXCopy(*in, *out);
MTXCopy(*in, *out);
return out;
}
inline MTX34 *MTX34Identity(MTX34 *mtx) {
PSMTXIdentity(*mtx);
MTXIdentity(*mtx);
return mtx;
}
inline u32 MTX34Inv(MTX34 *out, const MTX34 *in) {
return PSMTXInverse(*in, *out);
return MTXInverse(*in, *out);
}
inline u32 MTX34InvTranspose(MTX34 *pOut, const MTX34 *pIn) {
return PSMTXInvXpose(*pIn, *pOut);
return MTXInvXpose(*pIn, *pOut);
}
inline MTX34 *MTX34LookAt(MTX34 *mtx, const VEC3 *pos, const VEC3 *up, const VEC3 *target) {
@@ -519,12 +519,12 @@ inline MTX34 *MTX34LookAt(MTX34 *mtx, const VEC3 *pos, const VEC3 *up, const VEC
}
inline MTX34 *MTX34Mult(MTX34 *out, const MTX34 *a, const MTX34 *b) {
PSMTXConcat(*a, *b, *out);
MTXConcat(*a, *b, *out);
return out;
}
inline MTX34 *MTX34MultArray(MTX34 *out, const MTX34 *p1, const MTX34 *src, u32 len) {
PSMTXConcatArray(*p1, *src, *out, len);
MTXConcatArray(*p1, *src, *out, len);
return out;
}
@@ -541,7 +541,7 @@ inline MTX34 *MTX34RotXYZRad(MTX34 *mtx, f32 rx, f32 ry, f32 rz) {
}
inline MTX34 *MTX34Scale(MTX34 *out, const VEC3 *scale, const MTX34 *in) {
PSMTXScaleApply(*in, *out, scale->x, scale->y, scale->z);
MTXScaleApply(*in, *out, scale->x, scale->y, scale->z);
return out;
}
@@ -551,7 +551,7 @@ inline QUAT *MTX34ToQUAT(QUAT *quat, const MTX34 *mtx) {
}
inline MTX34 *MTX34Trans(MTX34 *out, const VEC3 *trans, const MTX34 *in) {
PSMTXTransApply(*in, *out, trans->x, trans->y, trans->z);
MTXTransApply(*in, *out, trans->x, trans->y, trans->z);
return out;
}
@@ -569,7 +569,7 @@ MTX44 *MTX44Copy(MTX44 *dst, const MTX44 *src);
*
******************************************************************************/
inline MTX34 *QUATToMTX34(MTX34 *mtx, const QUAT *quat) {
PSMTXQuat(*mtx, *quat);
MTXQuat(*mtx, *quat);
return mtx;
}
include/rvl/MTX/mtx.h
+1
View File
@@ -31,6 +31,7 @@ typedef struct Quaternion {
#define MTXIdentity PSMTXIdentity
#define MTXCopy PSMTXCopy
#define MTXConcat PSMTXConcat
#define MTXConcatArray PSMTXConcatArray
#define MTXInverse PSMTXInverse
#define MTXTranspose PSMTXTranspose
#define MTXInverse PSMTXInverse
src/JSystem/JParticle/JPAFieldBlock.cpp
+1 -1
View File
@@ -127,7 +127,7 @@ void JPAFieldNewton::calc(JPAEmitterWorkData* work, JPAFieldBlock* block, JPABas
/* 8027C56C-8027C674 276EAC 0108+00 1/0 0/0 0/0 .text
* prepare__14JPAFieldVortexFP18JPAEmitterWorkDataP13JPAFieldBlock */
void JPAFieldVortex::prepare(JPAEmitterWorkData* work, JPAFieldBlock* block) {
PSMTXMultVecSR(work->mGlobalRot, block->getDir(), field_0x10);
MTXMultVecSR(work->mGlobalRot, block->getDir(), field_0x10);
field_0x10.normalise();
field_0x1c = block->getPos().z * block->getPos().z;
field_0x20 = 1.0f / field_0x1c;
src/REL/d/a/d_a_bombf.cpp
+2 -2
View File
@@ -54,7 +54,7 @@ int dAcBombf_c::actorPostCreate() {
mMtx_c mtx;
mtx.ZXYrotS(mRotation.x, mRotation.y, mRotation.z);
mVec3_c v;
PSMTXMultVecSR(mtx, mVec3_c::Ey, v);
MTXMultVecSR(mtx, mVec3_c::Ey, v);
mVec3_c v3 = mPosition + v * 10.0f;
mVec3_c v4 = mPosition - v * 10.0f;
@@ -184,7 +184,7 @@ void dAcBombf_c::executeState_Wait() {
f32 scaleFactor = mScale.x;
if (field_0x3D2 == 0 || field_0x3D2 == 2) {
mVec3_c up;
PSMTXMultVecSR(mWorldMtx, mVec3_c::Ey, up);
MTXMultVecSR(mWorldMtx, mVec3_c::Ey, up);
mVec3_c upScaled = up * 30.0f;
mVec3_c checkPos = mPosition + upScaled;
src/REL/d/a/d_a_t_wood_area.cpp
+1 -1
View File
@@ -14,7 +14,7 @@ STATE_DEFINE(dAcTWoodArea_c, Wait);
int dAcTWoodArea_c::actorCreate() {
mStateMgr.changeState(StateID_Init);
PSMTXTrans(mWorldMtx.m, mPosition.x, mPosition.y, mPosition.z);
MTXTrans(mWorldMtx.m, mPosition.x, mPosition.y, mPosition.z);
mBoundingBox.mMin = mVec3_c(-0.0f, -0.0f, -0.0f);
mBoundingBox.mMax = mVec3_c(0.0f, 0.0f, 0.0f);
return SUCCEEDED;
src/REL/d/a/e/d_a_e_hb_leaf.cpp
+2 -2
View File
@@ -75,8 +75,8 @@ int dAcEhb_leaf_c::actorExecute() {
updateMatrix();
if (mType != 0) {
Mtx m;
PSMTXScale(m, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00);
PSMTXConcat(mWorldMtx.m, m, mWorldMtx.m);
MTXScale(m, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00, mTimeAreaStruct.field_0x00);
MTXConcat(mWorldMtx.m, m, mWorldMtx.m);
}
mModel.getModel().setLocalMtx(mWorldMtx);
mModel.getModel().calc(false);
src/REL/d/a/e/d_a_e_remly.cpp
+1 -1
View File
@@ -1148,7 +1148,7 @@ void dAcEremly_c::executeState_Fly() {
mSomeCounter++;
mVec3_c v(0.f, 0.f, 0.f);
v.offsetWithAngle(a, -10.f + _weird_zero);
getXZCirclePoint(v, a, -10.f + _weird_zero);
field_0xAF8.set(v);
}
src/REL/d/a/obj/d_a_obj_F400_gate_seal.cpp
+1 -1
View File
@@ -55,7 +55,7 @@ int dAcOF400GateSeal_c::actorPostCreate() {
dAcOdoor_c *door;
while (notDone && parent != nullptr) {
if (10000.0f < PSVECSquareDistance(mPosition, parent->mPosition)) {
if (10000.0f < VECSquareDistance(mPosition, parent->mPosition)) {
parent = (dAcOdoor_c *)fManager_c::searchBaseByProfName(fProfile::OBJ_DOOR, parent);
door = parent;
} else {
src/REL/d/a/obj/d_a_obj_bird_sp.cpp
+1 -1
View File
@@ -42,7 +42,7 @@ int dAcObjBirdSp_c::actorExecute() {
mVec3_c posChange(0, -0.2, 1.0);
mMtx_c matrix;
matrix.ZXYrotS(mRotation);
PSMTXMultVec(matrix.m, posChange, posChange);
MTXMultVec(matrix.m, posChange, posChange);
f32 angle = (mPosition - dBird_c::getInstance()->mPosition).dot(posChange);
if (angle < 0.0f) {
src/REL/d/a/obj/d_a_obj_decoB.cpp
+1 -1
View File
@@ -35,7 +35,7 @@ int dAcODecoB_c::doDelete() {
int dAcODecoB_c::actorExecute() {
mStateMgr.executeState();
PSMTXTrans(mWorldMtx, mPosition.x, mPosition.y, mPosition.z);
MTXTrans(mWorldMtx, mPosition.x, mPosition.y, mPosition.z);
mWorldMtx.ZXYrotM(mRotation);
mMdl.setLocalMtx(mWorldMtx);
return SUCCEEDED;
src/REL/d/a/obj/d_a_obj_flying_clawshot_target.cpp
+1 -1
View File
@@ -85,7 +85,7 @@ int dAcOFlyingClawshotTarget_c::actorExecute() {
dAcPy_c *player = dAcPy_c::LINK;
mVec3_c markPoint;
PSMTXMultVec(mWorldMtx, mMarkPoint, markPoint);
MTXMultVec(mWorldMtx, mMarkPoint, markPoint);
f32 dist_to = markPoint.squareDistance(player->mPosition);
src/REL/d/a/obj/d_a_obj_ivy_rope.cpp
+2 -2
View File
@@ -852,7 +852,7 @@ void dAcOivyRope_c::fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool
getXZCirclePoint(somevec, swingAngle, something);
mVec3_c somevec2(0.f, -25.f, float0);
PSMTXMultVec(m, somevec, somevec2);
MTXMultVec(m, somevec, somevec2);
somevec2 += somevec;
if (somevec2.z < float0) {
somevec2.z = float0;
@@ -860,7 +860,7 @@ void dAcOivyRope_c::fn_256_D3D0(mVec3_c &pOut1, mVec3_c &pOut2, s16 param2, bool
// name 100% guess
mVec3_c swingTarget;
PSMTXMultVec(m, somevec, swingTarget);
MTXMultVec(m, somevec, swingTarget);
cLib::addCalcPos(&pOut2, swingTarget, 0.3f, 50.f, 1.f);
src/REL/d/a/obj/d_a_obj_pool_cock.cpp
+4 -4
View File
@@ -60,12 +60,12 @@ int dAcOPoolCock_c::actorExecute() {
mMtx_c tmp2;
mVec3_c translation = mOpenDirection * mOpenProgress;
PSMTXTrans(tmp1, translation.x, translation.y, translation.z);
PSMTXConcat(mdl1Transform, tmp1, mdl1Transform);
MTXTrans(tmp1, translation.x, translation.y, translation.z);
MTXConcat(mdl1Transform, tmp1, mdl1Transform);
mVec3_c translation2 = -translation;
PSMTXTrans(tmp2, translation2.x, translation2.y, translation2.z);
PSMTXConcat(mdl2Transform, tmp2, mdl2Transform);
MTXTrans(tmp2, translation2.x, translation2.y, translation2.z);
MTXConcat(mdl2Transform, tmp2, mdl2Transform);
mdl2Transform.YrotM(-0x8000);
mModels[0].setLocalMtx(mdl1Transform);
src/REL/d/a/obj/d_a_obj_soil.cpp
+3 -1
View File
@@ -11,6 +11,7 @@
#include "d/d_camera.h"
#include "d/d_sc_game.h"
#include "d/d_stage_mgr.h"
#include "d/d_vec.h"
#include "d/flag/sceneflag_manager.h"
#include "d/snd/d_snd_small_effect_mgr.h"
#include "d/t/d_t_insect.h"
@@ -476,7 +477,8 @@ void dAcOsoil_c::giveItemFinal() {
void dAcOsoil_c::calcItemAndInsectSpawnPos() {
mItemAndInsectSpawnPos = mPosition;
mItemAndInsectSpawnPos.offsetWithAngle(dAcPy_c::LINK->getRotation().y, 30.f);
// TODO not sure about this s16 cast
getXZCirclePoint(mItemAndInsectSpawnPos, (s16)dAcPy_c::LINK->getRotation().y, 30.f);
}
void dAcOsoil_c::fn_255_1A50() {
src/REL/d/a/obj/d_a_obj_spike.cpp
+3 -3
View File
@@ -35,15 +35,15 @@ int dAcOspike_c::create() {
updateMatrix();
mMdl.setLocalMtx(mWorldMtx);
mVec3_c tmp;
PSMTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp);
MTXMultVecSR(mWorldMtx.m, mVec3_c::Ex, tmp);
mCollision.SetAtVec(tmp);
mMtx_c mtx;
mtx.XrotS(mRotation.x);
mtx.ZrotM(mRotation.z);
mVec3_c tmp2, tmp3;
PSMTXMultVecSR(mtx.m, sVec1, tmp2);
PSMTXMultVecSR(mtx.m, sVec2, tmp3);
MTXMultVecSR(mtx.m, sVec1, tmp2);
MTXMultVecSR(mtx.m, sVec2, tmp3);
if (tmp2.x > tmp3.x) {
f32 copy = tmp2.x;
src/REL/d/a/obj/d_a_obj_tower_hand_D101.cpp
+14 -14
View File
@@ -176,7 +176,7 @@ int dAcOTowerHandD101_c::actorPostCreate() {
dAcObjBase_c *ac = dAcObjBase_c::getNextObject(&dAcItem_c::sItemList, nullptr);
f32 distLimit = 90000.0f;
while (handClosed && ac != nullptr) {
if (PSVECSquareDistance(pos, ac->mPosition) < distLimit) {
if (VECSquareDistance(pos, ac->mPosition) < distLimit) {
handClosed = false;
mHeldItem.link(static_cast<dAcItem_c *>(ac));
} else {
@@ -210,7 +210,7 @@ int dAcOTowerHandD101_c::actorExecute() {
UNKWORD w = link->IfCurrentActionToActor(this, 0x3D);
bool b = getItem(item);
if (!b && item->isStateWait()) {
f32 dist = PSVECSquareDistance(item->mPosition, link->mPosition);
f32 dist = VECSquareDistance(item->mPosition, link->mPosition);
if (w == 0 && dist < 15625.0f) {
item->getItemFromBWheelItem();
} else {
@@ -240,13 +240,13 @@ int dAcOTowerHandD101_c::actorExecute() {
mMtx_c tmpMtx4;
getLoc1Mtx(tmpMtx2);
PSMTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z);
PSMTXConcat(tmpMtx2, tmpMtx1, tmpMtx2);
MTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z);
MTXConcat(tmpMtx2, tmpMtx1, tmpMtx2);
mLoc1Mtx.copyFrom(tmpMtx2);
getLoc2Mtx(tmpMtx3);
PSMTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z);
PSMTXConcat(tmpMtx3, tmpMtx4, tmpMtx3);
MTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z);
MTXConcat(tmpMtx3, tmpMtx4, tmpMtx3);
mLoc2Mtx.copyFrom(tmpMtx3);
if (mEffects.hasEmitters()) {
@@ -292,13 +292,13 @@ int dAcOTowerHandD101_c::actorExecuteInEvent() {
mMtx_c tmpMtx4;
getLoc1Mtx(tmpMtx2);
PSMTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z);
PSMTXConcat(tmpMtx2, tmpMtx1, tmpMtx2);
MTXScale(tmpMtx1, newScale.x, newScale.y, newScale.z);
MTXConcat(tmpMtx2, tmpMtx1, tmpMtx2);
mLoc1Mtx.copyFrom(tmpMtx2);
getLoc2Mtx(tmpMtx3);
PSMTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z);
PSMTXConcat(tmpMtx3, tmpMtx4, tmpMtx3);
MTXScale(tmpMtx4, newScale.x, newScale.y, newScale.z);
MTXConcat(tmpMtx3, tmpMtx4, tmpMtx3);
mLoc2Mtx.copyFrom(tmpMtx3);
if (mEffects.hasEmitters()) {
@@ -572,7 +572,7 @@ void dAcOTowerHandD101_c::executeState_RemainOpen() {
dAcPy_c *link = dAcPy_c::LINK;
mVec3_c pos;
getItemPos(pos);
f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition);
f32 linkDistToItem = VECSquareDistance(pos, link->mPosition);
if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') {
return;
}
@@ -604,7 +604,7 @@ void dAcOTowerHandD101_c::executeState_Close() {
dAcPy_c *link = dAcPy_c::LINK;
mVec3_c pos;
getItemPos(pos);
f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition);
f32 linkDistToItem = VECSquareDistance(pos, link->mPosition);
if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') {
mStateMgr.changeState(StateID_Open);
return;
@@ -656,7 +656,7 @@ void dAcOTowerHandD101_c::executeState_Open() {
dAcPy_c *link = dAcPy_c::LINK;
mVec3_c pos;
getItemPos(pos);
f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition);
f32 linkDistToItem = VECSquareDistance(pos, link->mPosition);
if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') {
if (mMdl.getAnm().isStop()) {
mStateMgr.changeState(StateID_RemainOpen);
@@ -714,7 +714,7 @@ void dAcOTowerHandD101_c::executeState_RemainClosed() {
dAcPy_c *link = dAcPy_c::LINK;
mVec3_c pos;
getItemPos(pos);
f32 linkDistToItem = PSVECSquareDistance(pos, link->mPosition);
f32 linkDistToItem = VECSquareDistance(pos, link->mPosition);
if (EventManager::isInEvent() && getEventStuff().getCurrentEventCommand() == 'wait') {
mStateMgr.changeState(StateID_Open);
return;
src/REL/d/a/obj/d_a_obj_triforce.cpp
+2 -2
View File
@@ -67,8 +67,8 @@ int dAcOtriforce_c::actorExecute() {
dCcS::GetInstance()->Set(&mCollision);
updateMatrix();
Mtx m;
PSMTXScale(m, mScale.x, mScale.y, mScale.z);
PSMTXConcat(mWorldMtx.m, m, mWorldMtx.m);
MTXScale(m, mScale.x, mScale.y, mScale.z);
MTXConcat(mWorldMtx.m, m, mWorldMtx.m);
mMdl.setLocalMtx(mWorldMtx);
mAnm.play();
mEffects.holdEffect(PARTICLE_RESOURCE_ID_MAPPING_967_, mWorldMtx, nullptr, nullptr);
src/REL/d/a/obj/d_a_obj_tubo.cpp
+1 -1
View File
@@ -681,7 +681,7 @@ mVec3_c dAcOtubo_c::getCenter() const {
mMtx_c m;
m.ZXYrotS(mRotation.x, mRotation.y, mRotation.z);
mVec3_c dir;
PSMTXMultVecSR(m, mVec3_c::Ey, dir);
MTXMultVecSR(m, mVec3_c::Ey, dir);
return mPosition + dir * 28.f;
}
src/REL/d/a/obj/d_a_obj_tumble_weed.cpp
+1 -1
View File
@@ -385,7 +385,7 @@ mVec3_c dAcOTumbleWeed_c::getTumblePosition() const {
mMtx_c mtx;
mVec3_c vec;
mtx.ZXYrotS(mRotation.x, mRotation.y, mRotation.z);
PSMTXMultVecSR(mtx, mVec3_c::Ey, vec);
MTXMultVecSR(mtx, mVec3_c::Ey, vec);
return mPosition + vec * 40.f;
}
src/REL/d/t/d_t_col_bomb_shield.cpp
+1 -1
View File
@@ -25,7 +25,7 @@ int dTgColBombShield::create() {
mColMtx.transS(mPosition.x, mPosition.y + mScale.y * 0.5f - 0.05f, mPosition.z);
mColMtx.ZXYrotM(mRotation.x, mRotation.y, mRotation.z);
mMtx_c tmp;
PSMTXScale(tmp, mScale.x, mScale.y, mScale.z);
MTXScale(tmp, mScale.x, mScale.y, mScale.z);
mColMtx += tmp;
mStateMgr.changeState(StateID_Wait);
return SUCCEEDED;
src/REL/d/t/d_t_insect.cpp
+3 -3
View File
@@ -187,10 +187,10 @@ void dTgInsect_c::executeState_Wait() {
mInsectRespawnTimers[i]--;
} else if (mInsectRespawnTimers[i] == 0) {
nw4r::math::MTX34 mtx;
PSMTXTrans(mtx, mPosition.x, mPosition.y, mPosition.z);
MTXTrans(mtx, mPosition.x, mPosition.y, mPosition.z);
nw4r::math::MTX34 scale;
PSMTXScale(scale, mScale.x, mScale.y, mScale.x);
PSMTXConcat(mtx, scale, mtx);
MTXScale(scale, mScale.x, mScale.y, mScale.x);
MTXConcat(mtx, scale, mtx);
nw4r::math::AABB aabb(-100, 0, -100, 100, 100, 100);
aabb.Set(&aabb, &mtx);
if (fn_801BB750(&aabb, 10000)) {
src/REL/d/t/d_t_noeffect_area.cpp
+2 -2
View File
@@ -9,9 +9,9 @@ const f32 dTgNoEffectArea_c::sFloat2 = 100.0f;
int dTgNoEffectArea_c::create() {
mScale *= 0.01f;
PSMTXTrans(mMtx, mPosition.x, mPosition.y, mPosition.z);
MTXTrans(mMtx, mPosition.x, mPosition.y, mPosition.z);
mMtx.YrotM(mRotation.y);
PSMTXInverse(mMtx, mMtx);
MTXInverse(mMtx, mMtx);
addToList(sList);
return SUCCEEDED;
}
src/REL/d/t/d_t_sound_area.cpp
+6 -6
View File
@@ -23,9 +23,9 @@ int dTgSndAr_c::create() {
switch (getTypeFromParams()) {
case 0:
PSMTXTrans(mtx.m, mPosition.x, mPosition.y, mPosition.z);
MTXTrans(mtx.m, mPosition.x, mPosition.y, mPosition.z);
mtx.YrotM(mRotation.y);
PSMTXInverse(mtx.m, mtx.m);
MTXInverse(mtx.m, mtx.m);
break;
case 3: mRail.initWithPathIndex(mParams >> 8 & 0xFF, mRoomID, 0); break;
}
@@ -83,7 +83,7 @@ inline bool inRange(f32 val, f32 tolerance) {
// Box
bool dTgSndAr_c::checkAlg0(const mVec3_c &pos) {
mVec3_c c2 = pos;
PSMTXMultVec(mtx.m, c2, c2);
MTXMultVec(mtx.m, c2, c2);
f32 sxLower = -50.0f * mScale.x;
f32 sxUpper = 50.0f * mScale.x;
f32 syLower = 0.0f;
@@ -102,7 +102,7 @@ bool dTgSndAr_c::checkAlg0(const mVec3_c &pos) {
bool dTgSndAr_c::checkAlg1(const mVec3_c &pos) {
f32 tgtDist = mScale.x * 100.0f;
f32 tgtDist2 = tgtDist * tgtDist;
return PSVECSquareDistance(mPosition, pos) < tgtDist2;
return VECSquareDistance(mPosition, pos) < tgtDist2;
}
// Cylinder
@@ -152,11 +152,11 @@ bool dTgSndAr_c::checkAlg3(const mVec3_c &pos) {
return d < radius;
} else {
// Otherwise check if we are within the spheres around the endpoints
f32 distSq = PSVECSquareDistance(unk.GetStart(), pos);
f32 distSq = VECSquareDistance(unk.GetStart(), pos);
if (distSq < radius) {
return true;
} else {
distSq = PSVECSquareDistance(unk.GetEnd(), pos);
distSq = VECSquareDistance(unk.GetEnd(), pos);
return distSq < radius;
}
}
src/d/a/d_a_base.cpp
+4 -4
View File
@@ -391,7 +391,7 @@ bool dAcBase_c::getDistanceToActor(dAcBase_c *actor, f32 distThresh, f32 *outDis
bool isWithinThreshhold = false;
if (actor != nullptr) {
distSquared = PSVECSquareDistance(mPosition, actor->mPosition);
distSquared = VECSquareDistance(mPosition, actor->mPosition);
if (distSquared <= distThresh * distThresh) {
isWithinThreshhold = true;
@@ -414,7 +414,7 @@ bool dAcBase_c::getDistanceAndAngleToActor(
mAng angleToActorY(0), angleToActorX(0);
if (actor != nullptr) {
distSquared = PSVECSquareDistance(mPosition, actor->mPosition);
distSquared = VECSquareDistance(mPosition, actor->mPosition);
angleToActorY.set(cLib::targetAngleY(mPosition, actor->mPosition));
angleToActorX.set(cLib::targetAngleX(mPosition, actor->mPosition));
@@ -453,11 +453,11 @@ bool dAcBase_c::getDistanceAndAngleToPlayer(
}
f32 dAcBase_c::getDistToPlayer() {
return EGG::Math<f32>::sqrt(PSVECSquareDistance(mPosition, dAcPy_c::LINK->mPosition));
return EGG::Math<f32>::sqrt(VECSquareDistance(mPosition, dAcPy_c::LINK->mPosition));
}
f32 dAcBase_c::getSquareDistToPlayer() {
return PSVECSquareDistance(mPosition, dAcPy_c::LINK->mPosition);
return VECSquareDistance(mPosition, dAcPy_c::LINK->mPosition);
}
// Some weirdness with the float registers being used
src/d/a/obj/d_a_obj_switch.cpp
+4 -4
View File
@@ -26,8 +26,8 @@ void dAcOswMdlCallback_c::timingB(u32 nodeId, nw4r::g3d::WorldMtxManip *manip, n
mMtx_c mtx1;
mMtx_c mtx2;
manip->GetMtx(mtx1);
PSMTXTrans(mtx2, mElevation, 0.0f, 0.0f);
PSMTXConcat(mtx1, mtx2, mtx1);
MTXTrans(mtx2, mElevation, 0.0f, 0.0f);
MTXConcat(mtx1, mtx2, mtx1);
manip->SetMtx(mtx1);
}
}
@@ -189,8 +189,8 @@ int dAcOsw_c::actorExecute() {
updateMatrix();
field_0x5B8.copyFrom(mWorldMtx);
mMtx_c tmp;
PSMTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f);
PSMTXConcat(field_0x5B8, tmp, field_0x5B8);
MTXTrans(tmp, 0.0f, mButtonCtrl.mElevation, 0.0f);
MTXConcat(field_0x5B8, tmp, field_0x5B8);
mModel.setScale(mScale);
mModel.setLocalMtx(mWorldMtx);
mModel.calc(false);
src/d/a/obj/d_a_obj_tbox.cpp
+3 -3
View File
@@ -2418,7 +2418,7 @@ void dAcTbox_c::fn_8026DAC0(mAng &ang) {
}
void dAcTbox_c::fn_8026DAD0(const mVec3_c *a, mVec3_c *b) const {
PSMTXMultVec(mWorldMtx, *a, *b);
MTXMultVec(mWorldMtx, *a, *b);
}
void dAcTbox_c::getCylParams(mVec3_c *c, f32 *r, f32 *h) const {
@@ -2529,7 +2529,7 @@ void dAcTbox_c::getCylParams(mVec3_c *c, f32 *r, f32 *h) const {
break;
}
if (c != nullptr) {
PSMTXMultVec(mWorldMtx, *c, *c);
MTXMultVec(mWorldMtx, *c, *c);
}
}
@@ -2631,7 +2631,7 @@ bool dAcTbox_c::checkForLinkBonk() {
}
mVec3_c linkPos;
PSMTXMultVec(mCcD3.mInvMtx, link->mPosition, linkPos);
MTXMultVec(mCcD3.mInvMtx, link->mPosition, linkPos);
mVec3_c ccLo, ccHi;
getCCBounds(&ccLo, &ccHi);
// Math performed in local coordinate space
src/d/col/bg/d_bg_s.cpp
+2 -2
View File
@@ -886,10 +886,10 @@ void dBgS_MoveBGProc_Typical(
mMtx_c a;
if (i_bgw->GetOldInvMtx(&a) != NULL) {
mVec3_c moveOld;
PSMTXMultVec(a, *i_pos, moveOld);
MTXMultVec(a, *i_pos, moveOld);
mVec3_c movePos;
PSMTXMultVec(i_bgw->mInvMtx, moveOld, movePos);
MTXMultVec(i_bgw->mInvMtx, moveOld, movePos);
*i_pos = movePos;
}
}
src/d/col/bg/d_bg_w.cpp
+13 -13
View File
@@ -31,9 +31,9 @@ cBgW::cBgW()
mpGrp(nullptr),
mpNodeTree(nullptr),
mNeedsFullTransform(true) {
PSMTXIdentity(mInvMtx);
PSMTXIdentity(mMtx);
PSMTXIdentity(mMtxUnk);
MTXIdentity(mInvMtx);
MTXIdentity(mMtx);
MTXIdentity(mMtxUnk);
}
cBgW::~cBgW() {
@@ -65,24 +65,24 @@ void cBgW::FreeArea() {
}
u32 cBgW::GetOldInvMtx(mMtx_c *m) {
return PSMTXInverse(mMtx, *m);
return MTXInverse(mMtx, *m);
}
void cBgW::UpdateMtx() {
if (!mpMdlMtx) {
PSMTXIdentity(mInvMtx);
PSMTXIdentity(mMtx);
PSMTXIdentity(mMtxUnk);
MTXIdentity(mInvMtx);
MTXIdentity(mMtx);
MTXIdentity(mMtxUnk);
} else {
PSMTXCopy(*mpMdlMtx, mInvMtx);
MTXCopy(*mpMdlMtx, mInvMtx);
if (mpScale) {
mMtx_c scale;
PSMTXScale(scale, mpScale->x, mpScale->y, mpScale->z);
PSMTXConcat(mInvMtx, scale, mInvMtx);
MTXScale(scale, mpScale->x, mpScale->y, mpScale->z);
MTXConcat(mInvMtx, scale, mInvMtx);
}
PSMTXCopy(mInvMtx, mMtx);
PSMTXCopy(mInvMtx, mMtxUnk);
MTXCopy(mInvMtx, mMtx);
MTXCopy(mInvMtx, mMtxUnk);
}
}
@@ -99,7 +99,7 @@ void cBgW::GlobalVtx() {
} else {
int i = 0;
do {
PSMTXMultVec(mInvMtx, mpBgd->mVtxTbl[i], mpVtxTbl[i]);
MTXMultVec(mInvMtx, mpBgd->mVtxTbl[i], mpVtxTbl[i]);
i++;
} while (i < mpBgd->mVtxNum);
}
src/d/col/bg/d_bg_w_kcol.cpp
+1 -1
View File
@@ -146,7 +146,7 @@ void dBgWKCol::vt_0x3C() {
bool dBgWKCol::LineCheck(cBgS_LinChk *pLine) {
mVec3_c diff;
VEC3Sub(diff, pLine->mLin.GetStartP(), pLine->mLin.GetEndP());
f32 mag = PSVECMag(diff);
f32 mag = VECMag(diff);
if (mag < 500.0f) {
int tmp0 = (int)(mag * 0.002f) + 1;
f32 tmp1 = mag / (tmp0 + 1);
src/d/col/bg/d_bg_w_time.cpp
+3 -3
View File
@@ -49,9 +49,9 @@ bool dBgWTime::GetTriPnt(cBgS_PolyInfo const &info, mVec3_c *pA, mVec3_c *pB, mV
pB->set(1.f, 0.f, -1.f);
pC->set(-1.f, 0.f, -1.f);
PSMTXMultVec(mtx, *pA, *pA);
PSMTXMultVec(mtx, *pB, *pB);
PSMTXMultVec(mtx, *pC, *pC);
MTXMultVec(mtx, *pA, *pA);
MTXMultVec(mtx, *pB, *pB);
MTXMultVec(mtx, *pC, *pC);
*pA += info.GetField0x20();
*pB += info.GetField0x20();
src/d/col/c/c_cc_d.cpp
+30 -30
View File
@@ -19,7 +19,7 @@
#include "rvl/MTX.h" // IWYU pragma: export
static inline void MtxTransMinusXYZ(mMtx_c &mtx, f32 x, f32 y, f32 z) {
PSMTXTrans(mtx, -x, -y, -z);
MTXTrans(mtx, -x, -y, -z);
}
mVec3_c cCcD_ShapeAttr::sVirtualCenter = mVec3_c::Zero;
@@ -692,7 +692,7 @@ bool cCcD_TriAttr::GetNVec(const mVec3_c &pnt, mVec3_c *pOut) const {
*pOut = GetN();
} else {
*pOut = GetN();
PSVECScale(*pOut, *pOut, -1.0f);
VECScale(*pOut, *pOut, -1.0f);
}
return true;
}
@@ -728,8 +728,8 @@ cCcD_UnkAttr::~cCcD_UnkAttr() {}
bool cCcD_UnkAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut) {
mVec3_c tmp0, tmp1;
const mMtx_c &inv = mInvMtx;
PSMTXMultVec(inv, start, tmp0);
PSMTXMultVec(inv, end, tmp1);
MTXMultVec(inv, start, tmp0);
MTXMultVec(inv, end, tmp1);
for (int i = 0; i < 3; i++) {
bool tmp0Min = tmp0(i) < mMin(i);
bool tmp0Max = tmp0(i) > mMax(i);
@@ -761,7 +761,7 @@ bool cCcD_UnkAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut)
(*pOut)(i) = (tmp0(i) + tmp1(i)) * 0.5f;
}
}
PSMTXMultVec(mMtx, *pOut, *pOut);
MTXMultVec(mMtx, *pOut, *pOut);
return true;
}
@@ -827,23 +827,23 @@ void cCcD_UnkAttr::CalcAabBox() {
mVec3_c a;
a = start;
PSMTXMultVec(mtx, a, a);
MTXMultVec(mtx, a, a);
mAab.SetMinMax(a);
a = end;
PSMTXMultVec(mtx, a, a);
MTXMultVec(mtx, a, a);
mAab.SetMinMax(a);
a.x = start.x;
a.y = start.y;
a.z = end.z;
PSMTXMultVec(mtx, a, a);
MTXMultVec(mtx, a, a);
mAab.SetMinMax(a);
a.x = end.x;
a.y = end.y;
a.z = start.z;
PSMTXMultVec(mtx, a, a);
MTXMultVec(mtx, a, a);
mAab.SetMinMax(a);
}
@@ -988,18 +988,18 @@ bool cCcD_CpsAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut)
}
bInverse = false;
} else {
PSMTXTrans(mtx0, startRef.x, startRef.y, startRef.z);
MTXTrans(mtx0, startRef.x, startRef.y, startRef.z);
mtx0.XrotM(mAng::atan2s(-dist, tmp0.y));
mtx0.YrotM(mAng::atan2s(-tmp0.x, tmp0.z));
mMtx_c mtx1;
MtxTransMinusXYZ(mtx1, startRef.x, startRef.y, startRef.z);
PSMTXConcat(mtx0, mtx1, mtx0);
PSMTXMultVec(mtx0, start, tmp1);
PSMTXMultVec(mtx0, end, tmp2);
MTXConcat(mtx0, mtx1, mtx0);
MTXMultVec(mtx0, start, tmp1);
MTXMultVec(mtx0, end, tmp2);
tmp3 = GetStart();
PSMTXMultVec(mtx0, GetEnd(), tmp4);
MTXMultVec(mtx0, GetEnd(), tmp4);
bInverse = true;
}
tmp3.y -= GetR() * 0.5f;
@@ -1007,8 +1007,8 @@ bool cCcD_CpsAttr::Calc(const mVec3_c &start, const mVec3_c &end, mVec3_c *pOut)
cyl.SetC(tmp3, GetR(), tmp4.y - tmp3.y);
CalcCyl(cyl, tmp1, tmp2, pOut);
if (bInverse) {
PSMTXInverse(mtx0, mtx0);
PSMTXMultVec(mtx0, *pOut, *pOut);
MTXInverse(mtx0, mtx0);
MTXMultVec(mtx0, *pOut, *pOut);
}
return true;
}
@@ -1111,31 +1111,31 @@ void cCcD_CpsAttr::CalcAabBox() {
bool cCcD_CpsAttr::GetNVec(const mVec3_c &param0, mVec3_c *pOut) const {
mVec3_c tmp1;
PSVECSubtract(GetEnd(), GetStart(), tmp1);
f32 sqMag = PSVECDotProduct(tmp1, tmp1);
VECSubtract(GetEnd(), GetStart(), tmp1);
f32 sqMag = VECDotProduct(tmp1, tmp1);
if (cM3d_IsZero(sqMag)) {
return false;
}
mVec3_c tmp2;
PSVECSubtract(param0, GetStart(), tmp2);
f32 sqDist = PSVECDotProduct(tmp2, tmp1) / sqMag;
VECSubtract(param0, GetStart(), tmp2);
f32 sqDist = VECDotProduct(tmp2, tmp1) / sqMag;
mVec3_c tmp3;
if (sqDist < 0.f) {
tmp3 = GetStart();
} else if (sqDist > 1.f) {
tmp3 = GetEnd();
} else {
PSVECScale(tmp1, tmp1, sqDist);
PSVECAdd(tmp1, GetStart(), tmp3);
VECScale(tmp1, tmp1, sqDist);
VECAdd(tmp1, GetStart(), tmp3);
}
PSVECSubtract(param0, tmp3, *pOut);
if (cM3d_IsZero(PSVECMag(*pOut))) {
VECSubtract(param0, tmp3, *pOut);
if (cM3d_IsZero(VECMag(*pOut))) {
pOut->set(0.f, 0.f, 0.f);
return false;
} else {
PSVECNormalize(*pOut, *pOut);
VECNormalize(*pOut, *pOut);
return true;
}
}
@@ -1266,12 +1266,12 @@ bool cCcD_CylAttr::GetNVec(const mVec3_c &param0, mVec3_c *pOut) const {
vec = GetC();
vec.y = param0.y;
}
PSVECSubtract(param0, vec, *pOut);
if (cM3d_IsZero(PSVECMag(*pOut))) {
VECSubtract(param0, vec, *pOut);
if (cM3d_IsZero(VECMag(*pOut))) {
pOut->set(0.f, 0.f, 0.f);
return false;
} else {
PSVECNormalize(*pOut, *pOut);
VECNormalize(*pOut, *pOut);
return true;
}
}
@@ -1393,11 +1393,11 @@ bool cCcD_SphAttr::GetNVec(const mVec3_c &param0, mVec3_c *param1) const {
param1->x = param0.x - GetC().x;
param1->y = param0.y - GetC().y;
param1->z = param0.z - GetC().z;
if (cM3d_IsZero(PSVECMag(*param1))) {
if (cM3d_IsZero(VECMag(*param1))) {
param1->set(0.0f, 0.0f, 0.0f);
return false;
} else {
PSVECNormalize(*param1, *param1);
VECNormalize(*param1, *param1);
return true;
}
}
src/d/col/c/c_m3d.cpp
+3 -3
View File
@@ -169,8 +169,8 @@ bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, VEC3 *) {
void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph &pSph, const cM3dGTri &pTri, VEC3 *pPnt) {
VEC3 scale, add;
PSVECAdd(pTri.mA, pTri.mB, add);
PSVECScale(add, scale, 0.5f);
VECAdd(pTri.mA, pTri.mB, add);
VECScale(add, scale, 0.5f);
const f32 mag = VEC3DistSq(&scale, &pSph.GetC());
if (cM3d_IsZero(mag)) {
*pPnt = pSph.GetC();
@@ -245,7 +245,7 @@ f32 cM3d_lineVsPosSuisenCross(const VEC3 &, const VEC3 &, const VEC3 &, VEC3 *)
}
bool cM3d_Normalize(nw4r::math::VEC3 *pPnt) {
f32 mag = PSVECMag(*pPnt);
f32 mag = VECMag(*pPnt);
if (cM3d_IsZero(mag)) {
return true;
}
src/d/col/c/c_m3d_g_aab.cpp
+2 -2
View File
@@ -27,8 +27,8 @@ void cM3dGAab::SetMax(const mVec3_c &max) {
}
void cM3dGAab::CalcCenter(mVec3_c &center) const {
PSVECAdd(mMin, mMax, center);
PSVECScale(center, center, 0.5f);
VECAdd(mMin, mMax, center);
VECScale(center, center, 0.5f);
}
void cM3dGAab::PlusR(f32 r) {
src/d/col/c/c_m3d_g_cps.cpp
+2 -2
View File
@@ -34,10 +34,10 @@ bool cM3dGCps::Cross(cM3dGUnk &unk, mVec3_c *vec) {
bool cM3dGCps::fn_80337f40(const mVec3_c &v) const {
f32 r2 = mRadius * mRadius;
if (!(mFlags & 1) && PSVECSquareDistance(mStart, v) <= r2) {
if (!(mFlags & 1) && VECSquareDistance(mStart, v) <= r2) {
return true;
}
if (!(mFlags & 2) && PSVECSquareDistance(mEnd, v) <= r2) {
if (!(mFlags & 2) && VECSquareDistance(mEnd, v) <= r2) {
return true;
}
f32 tmp;
src/d/col/c/c_m3d_g_lin.cpp
+3 -3
View File
@@ -11,9 +11,9 @@ void cM3dGLin::SetStartEnd(const mVec3_c *start, const mVec3_c *end) {
void cM3dGLin::CalcPos(mVec3_c *out, f32 scale) const {
mVec3_c tmp;
PSVECSubtract(mEnd, mStart, tmp);
PSVECScale(tmp, tmp, scale);
PSVECAdd(tmp, mStart, *out);
VECSubtract(mEnd, mStart, tmp);
VECScale(tmp, tmp, scale);
VECAdd(tmp, mStart, *out);
}
void cM3dGLin::SetStart(const mVec3_c &start) {
src/d/col/c/c_m3d_g_unk.cpp
+10 -10
View File
@@ -16,8 +16,8 @@ cM3dGUnk::cM3dGUnk() {
field_0xB4 = 0;
mVirtCenter.set(0.0f, 0.0f, 0.0f);
field_0xC4 = 0.0f;
PSMTXIdentity(mMtx);
PSMTXIdentity(mInvMtx);
MTXIdentity(mMtx);
MTXIdentity(mInvMtx);
}
void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) {
@@ -34,13 +34,13 @@ void cM3dGUnk::Set(const mVec3_c &vA, const mVec3_c &vB) {
void cM3dGUnk::Update() {
mVec3_c a, b;
PSMTXMultVec(mMtx, mMin, a);
PSMTXMultVec(mMtx, mMax, b);
MTXMultVec(mMtx, mMin, a);
MTXMultVec(mMtx, mMax, b);
mLin.GetStart().x = (a.x + b.x) * 0.5f;
mLin.GetStart().y = (a.y + b.y) * 0.5f;
mLin.GetStart().z = (a.z + b.z) * 0.5f;
if (!PSMTXInverse(mMtx, mInvMtx)) {
PSMTXIdentity(mInvMtx);
if (!MTXInverse(mMtx, mInvMtx)) {
MTXIdentity(mInvMtx);
}
}
@@ -89,7 +89,7 @@ void cM3dGUnk::Set(const mMtx_c &mtx) {
void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) {
mMtx_c mtx;
PSMTXIdentity(mtx);
MTXIdentity(mtx);
mtx.YrotS(ang);
mtx.setTranslation(vec);
Set(mtx);
@@ -97,7 +97,7 @@ void cM3dGUnk::Set(const mVec3_c &vec, const mAng &ang) {
bool cM3dGUnk::Cross(const mVec3_c &vec) {
mVec3_c tmp;
PSMTXMultVec(mInvMtx, vec, tmp);
MTXMultVec(mInvMtx, vec, tmp);
if ((tmp.x < mMin.x)) {
return false;
}
@@ -121,11 +121,11 @@ bool cM3dGUnk::Cross(const mVec3_c &vec) {
void cM3dGUnk::Clamp(const mVec3_c &in, mVec3_c &out) {
mVec3_c tmp1, tmp2;
PSMTXMultVec(mInvMtx, in, tmp1);
MTXMultVec(mInvMtx, in, tmp1);
cM3dGAab aab;
aab.Set(mMin, mMax);
aab.Clamp(tmp1, tmp2);
PSMTXMultVec(mMtx, tmp2, out);
MTXMultVec(mMtx, tmp2, out);
}
void cM3dGUnk::fn_80338f30(f32 f0, f32 f1) {
src/d/col/cc/d_cc_d.cpp
+1 -1
View File
@@ -16,7 +16,7 @@ cCcD_ShapeAttr *dCcD_Cps::GetShapeAttr() {
}
void dCcD_Cps::unknownCalc() {
PSVECSubtract(mEnd, mStart, mAt.mVec);
VECSubtract(mEnd, mStart, mAt.mVec);
}
dCcD_Tri::dCcD_Tri() {}
src/d/col/cc/d_cc_mass_s.cpp
+5 -5
View File
@@ -176,13 +176,13 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p
if (field_0x3A8 & 0x10) {
mVec3_c vec;
PSVECSubtract((*p_actor)->getPosition(), *p_xyz, vec);
VECSubtract((*p_actor)->getPosition(), *p_xyz, vec);
vec.y = 0;
f32 vecMag = PSVECMag(vec);
f32 vecMag = VECMag(vec);
if (cM3d_IsZero(vecMag)) {
vec.x = 1;
} else {
PSVECScale(vec, vec, f / vecMag);
VECScale(vec, vec, f / vecMag);
}
obj->GetStts()->PlusCcMove(vec.x, vec.y, vec.z);
}
@@ -208,7 +208,7 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p
tmpVec.z = p_xyz->z;
if (mCamTopPos.y < (20.0f + plusH)) {
f32 newCamTopDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetStartP());
f32 newCamTopDist = VECSquareDistance(&tmpVec, *mCpsAttr.GetStartP());
if (mCamTopDist > newCamTopDist) {
mCamTopDist = newCamTopDist;
mCamTopPos = tmpVec;
@@ -216,7 +216,7 @@ u32 dCcMassS_Mng::Chk(mVec3_c *p_xyz, dAcObjBase_c **p_actor, dCcMassS_HitInf *p
}
if (mCamBottomPos.y < (20.0f + plusH)) {
f32 newCamBottomDist = PSVECSquareDistance(&tmpVec, *mCpsAttr.GetEndP());
f32 newCamBottomDist = VECSquareDistance(&tmpVec, *mCpsAttr.GetEndP());
if (mCamBottomDist > newCamBottomDist) {
mCamBottomDist = newCamBottomDist;
mCamBottomPos = tmpVec;
src/d/col/cc/d_cc_s.cpp
+1 -1
View File
@@ -159,7 +159,7 @@ void dCcS::SetArea(mMtx_c *pMtx) {
// non-match: Huh
mAreas[mAreaCount].mInv = mAreas[mAreaCount].mMtx = *pMtx;
PSMTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv);
MTXInverse(mAreas[mAreaCount].mInv, mAreas[mAreaCount].mInv);
mAreaCount++;
}
src/d/lyt/d_screen_fader.cpp
+4 -4
View File
@@ -45,14 +45,14 @@ void dScreenFader_c::draw() {
f32 scaleY = EGG::Screen::GetSizeYMax();
mMtx_c mtx;
PSMTXScale(mtx, scaleX, mProgress, 1.0f);
PSMTXTransApply(mtx, mtx, -scaleX * 0.5f, scaleY * 0.5f - mProgress, 0.0f);
MTXScale(mtx, scaleX, mProgress, 1.0f);
MTXTransApply(mtx, mtx, -scaleX * 0.5f, scaleY * 0.5f - mProgress, 0.0f);
GXColor a = EGG::DrawGX::BLACK;
EGG::DrawGX::DrawDL(EGG::DrawGX::DL_17, mtx, a);
PSMTXScale(mtx, scaleX, mProgress, 1.0f);
PSMTXTransApply(mtx, mtx, -scaleX * 0.5f, -scaleY * 0.5f, 0.0f);
MTXScale(mtx, scaleX, mProgress, 1.0f);
MTXTransApply(mtx, mtx, -scaleX * 0.5f, -scaleY * 0.5f, 0.0f);
EGG::DrawGX::DrawDL(EGG::DrawGX::DL_17, mtx, a);
}
src/egg/core/eggColorFader.cpp
+1 -1
View File
@@ -103,7 +103,7 @@ void EGG::ColorFader::draw() {
GXSetScissor(mStartX, mStartY, getWidth(), getHeight());
Mtx posMtx;
PSMTXIdentity(posMtx);
MTXIdentity(posMtx);
GXLoadPosMtxImm(posMtx, 0);
GXSetCurrentMtx(0);
src/egg/gfx/eggCpuTexture.cpp
+1 -1
View File
@@ -188,7 +188,7 @@ void CpuTexture::fillNormalMapSphere(f32 f1, f32 f2) {
// TODO: std::sqrtf?
vec(2) = fz < Math<f32>::zero() ? Math<f32>::zero() : (f32)sqrt(fz);
PSVECNormalize(vec, vec);
VECNormalize(vec, vec);
GXUtility::getNormalColor(c, vec);
c.r = c.a;
setColor(x, y, c);
src/egg/gfx/eggDrawGX.cpp
+17 -17
View File
@@ -72,8 +72,8 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe
int seg = numSegments + 1;
PSMTXMultVec(mtx, v1, v1);
PSMTXMultVec(mtx, v2, v2);
MTXMultVec(mtx, v1, v1);
MTXMultVec(mtx, v2, v2);
GXBegin(GX_TRIANGLEFAN, GX_VTXFMT0, seg + 1);
@@ -86,7 +86,7 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe
nw4r::math::VEC3 v3(
0.5f * nw4r::math::SinRad(signedStepSize * i), 0.0f, 0.5f * nw4r::math::CosRad(signedStepSize * i)
);
PSMTXMultVec(mtx, v3, v3);
MTXMultVec(mtx, v3, v3);
GXPosition3f32(v3.x, v3.y, v3.z);
nw4r::math::VEC3 v4(
@@ -98,15 +98,15 @@ static void DrawCircleYPolygonFan(const nw4r::math::MTX34 &mtx, f32 f, u16 numSe
0.5f * nw4r::math::CosRad(signedStepSize * (i + 1))
);
PSMTXMultVec(mtx, v4, v4);
PSMTXMultVec(mtx, v5, v5);
MTXMultVec(mtx, v4, v4);
MTXMultVec(mtx, v5, v5);
nw4r::math::VEC3Sub(&v4, &v4, &v2);
nw4r::math::VEC3Sub(&v5, &v5, &v2);
nw4r::math::VEC3 v6;
PSVECCrossProduct(v5, v4, v6);
PSVECNormalize(v6, v6);
VECCrossProduct(v5, v4, v6);
VECNormalize(v6, v6);
GXPosition3f32(v6.x, v6.y, v6.z);
}
@@ -145,7 +145,7 @@ void DrawGX::Initialize(Heap *pHeap_) {
GXInitTexObj(&CLEAR_Z_TEX_OBJ, s_clear_z_TX, 4, 4, GX_TF_Z24X8, GX_REPEAT, GX_REPEAT, false);
GXInitTexObjLOD(&CLEAR_Z_TEX_OBJ, GX_NEAR, GX_NEAR, 0.0, 0.0, 0.0, 0, 0, GX_ANISO_1);
PSMTXIdentity(s_cameraMtx.m);
MTXIdentity(s_cameraMtx.m);
CreateDisplayList(pHeap);
}
@@ -591,29 +591,29 @@ void DrawGX::CreateDisplayList(EGG::Heap *pHeap) {
GXPosition3f32(2.0f * x, 0.0f, 2.0f * z);
}
nw4r::math::MTX34 mtx;
PSMTXTrans(mtx, 0.0f, 0.5f, 0.0f);
MTXTrans(mtx, 0.0f, 0.5f, 0.0f);
DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_9]);
PSMTXIdentity(mtx);
PSMTXRotRad(mtx, M_PI, 0x7A);
PSMTXTransApply(mtx, mtx, 0.0f, -0.5f, 0.0f);
MTXIdentity(mtx);
MTXRotRad(mtx, M_PI, 0x7A);
MTXTransApply(mtx, mtx, 0.0f, -0.5f, 0.0f);
DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_9]);
break;
}
case DL_11:
case DL_12: {
nw4r::math::MTX34 mtx;
PSMTXIdentity(mtx);
MTXIdentity(mtx);
DrawCircleYPolygonFan(mtx, 1.0f, POS_NUM[i - DL_11]);
PSMTXRotRad(mtx, M_PI, 0x7A);
MTXRotRad(mtx, M_PI, 0x7A);
DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_11]);
break;
}
case DL_7:
case DL_8: {
nw4r::math::MTX34 mtx;
PSMTXIdentity(mtx);
PSMTXRotRad(mtx, M_PI / 2.0f, 0x78);
MTXIdentity(mtx);
MTXRotRad(mtx, M_PI / 2.0f, 0x78);
DrawCircleYPolygonFan(mtx, 0.0f, POS_NUM[i - DL_7]);
break;
}
@@ -725,7 +725,7 @@ void DrawGX::SetBlendMode(enum Blend mode) {
void DrawGX::DrawDLWorld(DL dl, const EGG::Matrix34f &mtx, GXColor color) {
nw4r::math::MTX34 resMtx;
PSMTXConcat(s_cameraMtx.m, mtx.m, resMtx.m);
MTXConcat(s_cameraMtx.m, mtx.m, resMtx.m);
DrawDL(dl, resMtx, color);
}
src/egg/gfx/eggDrawPathLightMap.cpp
+2 -2
View File
@@ -78,7 +78,7 @@ void DrawPathLightMap::internalDraw(u16 idx) {
PostEffectBase::setProjection(GetScreen());
PSMTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f);
MTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f);
mpTextureBuffer_0x30->load(GX_TEXMAP0);
DrawGX::BeginDrawScreen(true, true, false);
@@ -113,7 +113,7 @@ void DrawPathLightMap::internalDraw(u16 idx) {
nw4r::math::MTX34 forDL;
PostEffectBase::setProjection(GetScreen());
PSMTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f);
MTXScale(forDL, GetScreen().GetWidth(), GetScreen().GetHeight(), 1.0f);
GXColor tevColor = {0xFF, 0xFF, 0xFF, mAlpha};
src/egg/gfx/eggG3DUtility.cpp
+1 -1
View File
@@ -66,7 +66,7 @@ void G3DUtility::create(u32 size, Heap *pHeap) {
void G3DUtility::defaultTexMtxFunc(nw4r::math::MTX34 *pMtx, s8 camRef, s8 lightRef) {
const nw4r::math::MTX34 *mtxPtr = nw4r::g3d::G3DState::GetInvCameraMtxPtr();
PSMTXCopy(mtxPtr->m, pMtx->m);
MTXCopy(mtxPtr->m, pMtx->m);
}
bool G3DUtility::setUpLightSet(nw4r::g3d::LightSetting &lightSet, nw4r::g3d::ResAnmScn scn, int refNumber) {
src/egg/gfx/eggGlobalDrawState.cpp
+1 -1
View File
@@ -19,7 +19,7 @@ GlobalDrawState sState;
void GlobalDrawState::beginDrawView(u16 cameraId, const nw4r::math::MTX34 &mtx, const Screen &screen) {
spScreen = &screen;
sCameraId = cameraId;
PSMTXCopy(mtx, sMtx);
MTXCopy(mtx, sMtx);
StateEfb::Clean();
}
src/egg/gfx/eggIScnProc.cpp
+1 -1
View File
@@ -27,7 +27,7 @@ void IScnProc::createScnProc(u16 procNum, MEMAllocator *pAllocator) {
mNumScnProc = procNum;
mpDataSet = new ProcData[mNumScnProc];
nw4r::math::MTX34 mtx;
PSMTXIdentity(mtx);
MTXIdentity(mtx);
for (u16 i = 0; i < getNumScnProc(); i++) {
u32 sp8;
src/egg/gfx/eggLightManager.cpp
+1 -1
View File
@@ -117,7 +117,7 @@ void LightManager::CalcView(const nw4r::math::MTX34 &viewMtx, u8 lightObjOffset,
DCFlushRange(gxObj, CheckedNumLightObjs(mCounts.mNumEggLightObjects) * sizeof(GXLightObj));
if (root != nullptr) {
nw4r::math::MTX34 tmp;
PSMTXInverse(viewMtx, tmp);
MTXInverse(viewMtx, tmp);
CopyToG3D_View(root, tmp);
}
}
src/egg/gfx/eggLightObject.cpp
+6 -6
View File
@@ -114,18 +114,18 @@ void LightObject::CalcView(nw4r::math::MTX34 const &viewMtx) {
} else {
if (getField0x3C() == 1) {
nw4r::math::VEC3 tmp(-viewMtx._20, -viewMtx._21, -viewMtx._22);
if (PSVECMag(tmp) > 0.0f) {
if (VECMag(tmp) > 0.0f) {
nw4r::math::VEC3 angle;
C_VECHalfAngle(mDir, tmp, angle);
nw4r::math::VEC3Scale(&field_0x6C, &angle, -1.0f);
PSVECNormalize(field_0x6C, field_0x6C);
VECNormalize(field_0x6C, field_0x6C);
} else {
field_0x6C.x = field_0x6C.y = 0.0f;
field_0x6C.z = 1.0f;
}
}
PSMTXMultVec(viewMtx, mPos, mViewPos);
PSMTXMultVec(viewMtx, mAt, mViewAt);
MTXMultVec(viewMtx, mPos, mViewPos);
MTXMultVec(viewMtx, mAt, mViewAt);
nw4r::math::VEC3TransformNormal(&field_0x94, &viewMtx, &field_0x6C);
}
}
@@ -238,12 +238,12 @@ void LightObject::CopyToG3D_View(nw4r::g3d::LightObj &g3dObj, const nw4r::math::
break;
}
case 0: {
PSMTXMultVec(viewMtx, mViewPos, pos);
MTXMultVec(viewMtx, mViewPos, pos);
dir.x = dir.y = dir.z = 0.0f;
break;
}
case 2: {
PSMTXMultVec(viewMtx, mViewPos, pos);
MTXMultVec(viewMtx, mViewPos, pos);
nw4r::math::VEC3TransformNormal(&dir, &viewMtx, &field_0x94);
break;
}
src/egg/gfx/eggLightTexture.cpp
+1 -1
View File
@@ -519,7 +519,7 @@ void LightTexture::debugDraw(int i) {
fn_804AC0A0(i, &u1, &u2);
load(GX_TEXMAP0);
nw4r::math::MTX34 mtx;
PSMTXScale(mtx, sTexWidth, sTexHeight, 1.0f);
MTXScale(mtx, sTexWidth, sTexHeight, 1.0f);
mtx._03 = u1;
mtx._13 = sDrawHeight - (u2 + sTexHeight);
src/egg/gfx/eggLightTextureMgr.cpp
+1 -1
View File
@@ -247,7 +247,7 @@ void LightTextureManager::drawAndCaptureTexture(f32 ox, f32 oy, f32 sx, f32 sy)
StateGX::GXSetScissor_(x1, y1, x2, y2);
StateGX::GXSetScissorBoxOffset_(0, 0);
nw4r::math::MTX34 identity;
PSMTXIdentity(identity);
MTXIdentity(identity);
DrawGX::BeginDrawScreen(1, 1, 0);
DrawGX::SetBlendMode(DrawGX::BLEND_14);
src/egg/gfx/eggModelEx.cpp
+2 -2
View File
@@ -66,7 +66,7 @@ void ModelEx::getShapeMinMax(u16 shapeIndex, math::VEC3 *pMin, math::VEC3 *pMax,
math::MTX34 *pMtxArr =
reinterpret_cast<math::MTX34 *>(G3DUtility::BumpAlloc(info.GetNumPosNrmMtx() * sizeof(math::MTX34), 1));
if (doCalcWorld) {
PSMTXIdentity(tmpMtx);
MTXIdentity(tmpMtx);
calcWorld(pMtxArr, &tmpMtx);
}
@@ -86,7 +86,7 @@ void ModelEx::getShapeMinMax(u16 shapeIndex, math::VEC3 *pMin, math::VEC3 *pMax,
mtxIdx = defaultMatrixIdx;
}
nw4r::math::VEC3 tmpVec;
PSMTXMultVec(pMtxArr[mtxIdx], &analyze.getVtxResult().field_0x08, tmpVec);
MTXMultVec(pMtxArr[mtxIdx], &analyze.getVtxResult().field_0x08, tmpVec);
if (firstIteration) {
firstIteration = false;
*pMin = *pMax = tmpVec;
src/egg/gfx/eggPostEffectBase.cpp
+1 -1
View File
@@ -43,7 +43,7 @@ void PostEffectBase::setVtxState() {
void PostEffectBase::drawScreenInternal(f32 offsetX, f32 offsetY, f32 width, f32 height) {
nw4r::math::MTX34 mtx;
PSMTXScale(mtx, width, height, 1.0f);
MTXScale(mtx, width, height, 1.0f);
mtx._03 = offsetX;
mtx._13 = offsetY;
mtx._23 = 0.0f;
src/egg/gfx/eggPostEffectBlur.cpp
+1 -1
View File
@@ -76,7 +76,7 @@ void PostEffectBlur::setMaterialMulti(u8 kernelIdx, u8 p2, f32 f1, f32 f2) {
0.0f, 0.0f, 0.0f, 0.0f
// clang-format on
);
PSMTXConcat(m, mtx, m);
MTXConcat(m, mtx, m);
GXLoadTexMtxImm(m, texMtxId, GX_MTX2x4);
unk_00_scale++;
}
src/egg/gfx/eggPostEffectMaskDOF.cpp
+2 -2
View File
@@ -101,8 +101,8 @@ void PostEffectMaskDOF::draw(f32 width, f32 height) {
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX1, GX_TEX_ST, GX_F32, 0);
GXSetVtxDesc(GX_VA_TEX1, GX_DIRECT);
nw4r::math::MTX34 mtx;
PSMTXScale(mtx, width * mScaleX, height * mScaleY, 1.f);
PSMTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.f);
MTXScale(mtx, width * mScaleX, height * mScaleY, 1.f);
MTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.f);
GXLoadPosMtxImm(mtx, GX_PNMTX0);
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
GXPosition2u8(0, 0);
src/egg/gfx/eggPostEffectUnk2.cpp
+2 -2
View File
@@ -61,8 +61,8 @@ void PostEffectUnk2::draw(f32 width, f32 height) {
GXSetVtxDesc(GX_VA_TEX1, GX_DIRECT);
nw4r::math::MTX34 mtx;
PSMTXScale(mtx, width * mScaleX, height * mScaleY, 1.0f);
PSMTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.0f);
MTXScale(mtx, width * mScaleX, height * mScaleY, 1.0f);
MTXTransApply(mtx, mtx, mOffsetX, mOffsetY, 0.0f);
GXLoadPosMtxImm(mtx, 0);
static const f32 floats1[2][2] = {
src/egg/gfx/eggScreen.cpp
+1 -1
View File
@@ -264,7 +264,7 @@ bool Screen::IsChangeEfb() const {
}
void Screen::CalcMatrixForDrawQuad(math::MTX34 *mtx, f32 x, f32 y, f32 sx, f32 sy) const {
PSMTXScale(*mtx, sx, sy, 1.0f);
MTXScale(*mtx, sx, sy, 1.0f);
mtx->m[0][3] = x;
mtx->m[1][3] = mCanvasMode == CANVASMODE_0 ? y - sy : y;
src/egg/gfx/eggScreenEffectBlur.cpp
+2 -2
View File
@@ -96,7 +96,7 @@ void ScreenEffectBlur::fn_804B32B0() {
if (field_0x0C & 1) {
nw4r::math::MTX34 m;
PSMTXScale(m, sizeY, sizeY, 1.f);
MTXScale(m, sizeY, sizeY, 1.f);
pTex0->load(GX_TEXMAP0);
DrawGX::BeginDrawScreen(true, true, false);
DrawGX::SetBlendMode(DrawGX::BLEND_14);
@@ -114,7 +114,7 @@ void ScreenEffectBlur::fn_804B3710() {
// Have to perform a float -> u16 -> float round trip here...
u16 sizeY = sScreen.GetSize().y;
u16 sizeX = sScreen.GetSize().x;
PSMTXScale(mtx, sizeX, sizeY, 0.0f);
MTXScale(mtx, sizeX, sizeY, 0.0f);
mpCpuTexture->load(GX_TEXMAP0);
DrawGX::BeginDrawScreen(true, true, true);
GXSetTevKColor(GX_KCOLOR0, field_0x28);
src/egg/gfx/eggStateEfb.cpp
+1 -1
View File
@@ -184,7 +184,7 @@ void StateEfb::popWorkBuffer(bool b, u32 userData) {
StateGX::GXSetScissorBoxOffset_(0, 0);
nw4r::math::MTX34 mtx;
PSMTXScale(mtx, parentScreen.GetSize().x, parentScreen.GetSize().y, 1.0f);
MTXScale(mtx, parentScreen.GetSize().x, parentScreen.GetSize().y, 1.0f);
DrawGX::BeginDrawScreen(true, isEnableDirtyBufferMode(), false);
DrawGX::SetBlendMode(DrawGX::BLEND_14);
src/egg/math/eggMatrix.cpp
+3 -3
View File
@@ -6,11 +6,11 @@
namespace EGG {
void Matrix34f::inverseTo(Matrix34f &to) const {
PSMTXInverse(m, to.m);
MTXInverse(m, to.m);
}
void Matrix34f::inverseTransposeTo(Matrix34f &to) const {
PSMTXInvXpose(m, to.m);
MTXInvXpose(m, to.m);
}
void Matrix34f::makeIdentity() {
@@ -357,7 +357,7 @@ void Matrix34f::loadPosMtx(u32 posMtxId) {
}
void Matrix34f::multiplyTo(const Matrix34f &m2, Matrix34f &to) const {
PSMTXConcat(m, m2.m, to.m);
MTXConcat(m, m2.m, to.m);
}
void Matrix34f::dump() {}
src/m/m2d.cpp
+2 -2
View File
@@ -268,10 +268,10 @@ Simple_c::Simple_c() : Base_c(0x80), mLayout(), mDrawInfo(), mpResAcc(nullptr),
void Simple_c::calc() {
calcBefore();
nw4r::math::MTX34 mtx;
PSMTXIdentity(mtx.m);
MTXIdentity(mtx.m);
// Probably inlines
mVec3_c v = mVec;
PSMTXTransApply(mtx.m, mtx.m, v.x, v.y, v.z);
MTXTransApply(mtx.m, mtx.m, v.x, v.y, v.z);
mDrawInfo.SetViewMtx(mtx);
calcAfter();
}
src/m/m3d/m_bline.cpp
+2 -2
View File
@@ -59,8 +59,8 @@ void blineMat_c::update() {
mVec3_c vec;
getCurrentCamera().GetCameraMtx(&camMtx);
PSMTXInverse(camMtx, camMtx);
PSMTXMultVec(camMtx, mVec3_c::Zero, vec);
MTXInverse(camMtx, camMtx);
MTXMultVec(camMtx, mVec3_c::Zero, vec);
for (bline_c *line = (bline_c *)nw4r::ut::List_GetNext(&mLines, 0); line != nullptr;
line = (bline_c *)nw4r::ut::List_GetNext(&mLines, line)) {
src/m/m3d/m_bmdl.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ bool bmdl_c::getNodeWorldMtxMultVec(u32 p1, const nw4r::math::VEC3 &in, nw4r::ma
if (!getNodeWorldMtx(p1, &mtx)) {
return false;
} else {
PSMTXMultVec(mtx, in, out);
MTXMultVec(mtx, in, out);
return true;
}
}
src/m/m3d/m_mdl.cpp
+2 -2
View File
@@ -57,7 +57,7 @@ void mdl_c::mdlCallback_c::ExecCallbackA(
tmp.x = result->rt._03;
tmp.y = result->rt._13;
tmp.z = result->rt._23;
PSMTXQuat(result->rt, q1);
MTXQuat(result->rt, q1);
result->rt._03 = tmp.x;
result->rt._13 = tmp.y;
result->rt._23 = tmp.z;
@@ -121,7 +121,7 @@ bool mdl_c::mdlCallback_c::create(nw4r::g3d::ResMdl mdl, mAllocator_c *alloc, u3
node->s.x = 1.0f;
node->s.y = 1.0f;
node->s.z = 1.0f;
PSMTXIdentity(node->rt);
MTXIdentity(node->rt);
node++;
}
src/m/m3d/m_shadow.cpp
+7 -7
View File
@@ -504,7 +504,7 @@ bool mShadowChild_c::addMdl(scnLeaf_c &mdl, const mQuat_c &quat) {
bool mShadowChild_c::setGeom(const GXTexObj *texObj, const mMtx_c &mtx, const mQuat_c &quat) {
mQuat = quat;
PSMTXMultVec(mtx.m, mQuat.v, mQuat.v);
MTXMultVec(mtx.m, mQuat.v, mQuat.v);
if (texObj == nullptr) {
mTexObj = *mShadow_c::sTexObj;
} else {
@@ -591,7 +591,7 @@ void mShadowChild_c::draw() {
GXSetTevColor(GX_TEVREG0, mShadowColor);
Mtx mtx;
C_MTXLightOrtho(mtx, field_0x13C, -field_0x13C, -field_0x13C, field_0x13C, 0.5f, -0.5f, 0.5f, 0.5f);
PSMTXConcat(mtx, mFrustum.mView.m, mtx);
MTXConcat(mtx, mFrustum.mView.m, mtx);
GXLoadTexMtxImm(mtx, GX_TEXMTX0, GX_MTX3x4);
mShadow_c::GetInstance()->draw(mFrustum.mView, field_0x154);
GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
@@ -628,14 +628,14 @@ void mCustomShadow_c::calc(mMtx_c mtx, mMtx_c &mtx2) const {
mVec3_c trans;
mtx2.copyFrom(mMtx);
mVec3_c offset(0.0f, field_0x48, 0.0f);
PSMTXMultVec(mtx2, offset, trans);
PSMTXMultVec(mtx, trans, trans);
MTXMultVec(mtx2, offset, trans);
MTXMultVec(mtx, trans, trans);
PSMTXTrans(mtx2, trans.x, trans.y, trans.z);
MTXTrans(mtx2, trans.x, trans.y, trans.z);
mMtx_c scaleMtx;
PSMTXScale(scaleMtx, field_0x4C, field_0x4C, field_0x4C);
PSMTXConcat(mtx2, scaleMtx, mtx2);
MTXScale(scaleMtx, field_0x4C, field_0x4C, field_0x4C);
MTXConcat(mtx2, scaleMtx, mtx2);
}
} // namespace m3d
src/m/m_color_fader.cpp
+1 -1
View File
@@ -54,7 +54,7 @@ void mColorFader_c::draw() {
GXSetProjection(projMtx, GX_ORTHOGRAPHIC);
Mtx posMtx;
PSMTXIdentity(posMtx);
MTXIdentity(posMtx);
GXLoadPosMtxImm(posMtx, 0);
GXSetCurrentMtx(0);
src/nw4r/g3d/res/g3d_resnode.cpp
+1 -1
View File
@@ -99,7 +99,7 @@ void ResNode::CalcChrAnmResult(ChrAnmResult *pResult) const {
}
if (r.flags & ResNodeData::FLAG_ROT_ZERO) {
PSMTXIdentity(pResult->rt);
MTXIdentity(pResult->rt);
flags |= ChrAnmResult::FLAG_ROT_ZERO;
} else {
pResult->rawR = math::VEC3(r.rot);
src/nw4r/lyt/lyt_drawInfo.cpp
+1 -1
View File
@@ -9,7 +9,7 @@ namespace lyt {
// __ct__Q34nw4r3lyt8DrawInfoFv
DrawInfo::DrawInfo() : mViewRect(), mScale(1.0f, 1.0f), mGlobalAlpha(1.0f) {
memset(&mFlags, 0, 1);
PSMTXIdentity(mViewMtx);
MTXIdentity(mViewMtx);
}
// __dt__Q34nw4r3lyt8DrawInfoFv
src/nw4r/lyt/lyt_pane.cpp
+3 -3
View File
@@ -277,12 +277,12 @@ void Pane::CalculateMtx(const DrawInfo &drawInfo) {
this->mMtx._13 = this->mTranslate.y;
this->mMtx._23 = this->mTranslate.z;
if (this->mpParent) {
PSMTXConcat(this->mpParent->mGlbMtx, this->mMtx, this->mGlbMtx);
MTXConcat(this->mpParent->mGlbMtx, this->mMtx, this->mGlbMtx);
} else {
if (drawInfo.IsMultipleViewMtxOnDraw()) {
this->mGlbMtx = this->mMtx;
} else {
PSMTXConcat(drawInfo.GetViewMtx(), this->mMtx, this->mGlbMtx);
MTXConcat(drawInfo.GetViewMtx(), this->mMtx, this->mGlbMtx);
}
}
@@ -446,7 +446,7 @@ void Pane::LoadMtx(const DrawInfo &drawInfo) {
math::MTX34 mtx;
math::MTX34 *mtxPtr;
if (drawInfo.IsMultipleViewMtxOnDraw()) {
PSMTXConcat(drawInfo.GetViewMtx(), this->mGlbMtx, mtx);
MTXConcat(drawInfo.GetViewMtx(), this->mGlbMtx, mtx);
mtxPtr = &mtx;
} else {
mtxPtr = &this->mGlbMtx;
src/nw4r/lyt/lyt_textBox.cpp
+2 -2
View File
@@ -434,9 +434,9 @@ void TextBox::SetFont(const ut::Font *pFont) {
void TextBox::LoadMtx(const DrawInfo &drawInfo) {
math::MTX34 mtx;
if (drawInfo.IsMultipleViewMtxOnDraw()) {
PSMTXConcat(drawInfo.GetViewMtx(), mGlbMtx, mtx);
MTXConcat(drawInfo.GetViewMtx(), mGlbMtx, mtx);
} else {
PSMTXCopy(mGlbMtx, mtx);
MTXCopy(mGlbMtx, mtx);
}
ReverseYAxis(&mtx);
src/nw4r/lyt/lyt_util.cpp
+2 -2
View File
@@ -43,9 +43,9 @@ void SetAnimationEnable(Group *pGroup, nw4r::lyt::AnimTransform *pAnimTrans, boo
// IsContain__Q24nw4r3lytFPQ34nw4r3lyt4PaneRCQ34nw4r4math4VEC2
bool IsContain(Pane *pPane, const math::VEC2 &pos) {
math::MTX34 invGlbMtx;
PSMTXInverse(pPane->GetGlobalMtx(), invGlbMtx);
MTXInverse(pPane->GetGlobalMtx(), invGlbMtx);
math::VEC3 lclPos;
PSMTXMultVec(invGlbMtx, math::VEC3(pos.x, pos.y, 0.0f), lclPos);
MTXMultVec(invGlbMtx, math::VEC3(pos.x, pos.y, 0.0f), lclPos);
return Contains(pPane->GetPaneRect(), math::VEC2(lclPos.x, lclPos.y));
}
src/toBeSorted/attention.cpp
+1 -1
View File
@@ -250,7 +250,7 @@ bool AttentionManager::playTargetAnim(s32 idx) {
dAcObjBase_c *actor = pool->getActor(mModels.mCurrentTargetInfoIdx);
mMtx_c mtx;
mVec3_c v = pool->mInfos[mModels.mCurrentTargetInfoIdx].field_0x08;
PSMTXTrans(mtx, v.x, v.y, v.z);
MTXTrans(mtx, v.x, v.y, v.z);
mModels.mMdls->mMdl.setLocalMtx(mtx);
mModels.mMdls->mMdl.setScale(sHio.field_0x14, sHio.field_0x14, sHio.field_0x14);
src/toBeSorted/dowsing_target.cpp
+4 -4
View File
@@ -50,11 +50,11 @@ void DowsingTarget::reinitialize(DowsingSlot type) {
void DowsingTarget::getPosition(mVec3_c &position) {
mMtx_c mtx;
mMtx_c mtx2;
PSMTXTrans(mtx.m, mpActor->mPosition.x, mpActor->mPosition.y, mpActor->mPosition.z);
MTXTrans(mtx.m, mpActor->mPosition.x, mpActor->mPosition.y, mpActor->mPosition.z);
mtx.YrotM(mpActor->mRotation.y);
PSMTXScale(mtx2.m, mpActor->mScale.x, mpActor->mScale.y, mpActor->mScale.z);
PSMTXConcat(mtx.m, mtx2.m, mtx.m);
PSMTXMultVec(mtx.m, mOffset, position);
MTXScale(mtx2.m, mpActor->mScale.x, mpActor->mScale.y, mpActor->mScale.z);
MTXConcat(mtx.m, mtx2.m, mtx.m);
MTXMultVec(mtx.m, mOffset, position);
}
bool DowsingTarget::hasZeldaDowsing() {