mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-08-19 05:02:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

setup dolphin VEC/MTX function defines (#1903)

Browse Source 
* setup VEC function defines

* setup MTX function defines
This commit is contained in:
TakaRikka
2023-09-02 06:38:08 -07:00
committed by GitHub
parent f90d73eeeb
commit 2a67e0a8ba
102 changed files with 479 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/SSystem/SComponent/c_cc_d.cpp
+15 -15
View File
@@ -343,7 +343,7 @@ bool cCcD_TriAttr::GetNVec(cXyz const& param_0, cXyz* pOut) const {
*pOut = mNormal;
} else {
*pOut = mNormal;
PSVECScale(pOut, pOut, -1.0f);
VECScale(pOut, pOut, -1.0f);
}
return true;
}
@@ -436,32 +436,32 @@ void cCcD_CpsAttr::CalcAabBox() {
bool cCcD_CpsAttr::GetNVec(cXyz const& param_0, cXyz* param_1) const {
Vec diff;
const cXyz& endP = GetEndP();
PSVECSubtract(&endP, &mStart, &diff);
VECSubtract(&endP, &mStart, &diff);
f32 diffLen = PSVECDotProduct(&diff, &diff);
f32 diffLen = VECDotProduct(&diff, &diff);
if (cM3d_IsZero(diffLen)) {
return false;
} else {
Vec vec1, vec2;
PSVECSubtract(&param_0, &mStart, &vec1);
f32 vec1Len = PSVECDotProduct(&vec1, &diff) / diffLen;
VECSubtract(&param_0, &mStart, &vec1);
f32 vec1Len = VECDotProduct(&vec1, &diff) / diffLen;
if (vec1Len < 0.0f) {
vec2 = mStart;
} else {
if (vec1Len > 1.0f) {
vec2 = endP;
} else {
PSVECScale(&diff, &diff, vec1Len);
PSVECAdd(&diff, &mStart, &vec2);
VECScale(&diff, &diff, vec1Len);
VECAdd(&diff, &mStart, &vec2);
}
}
PSVECSubtract(&param_0, &vec2, param_1);
if (cM3d_IsZero(PSVECMag(param_1))) {
VECSubtract(&param_0, &vec2, param_1);
if (cM3d_IsZero(VECMag(param_1))) {
param_1->set(0.0f, 0.0f, 0.0f);
return false;
} else {
PSVECNormalize(param_1, param_1);
VECNormalize(param_1, param_1);
return true;
}
}
@@ -569,12 +569,12 @@ bool cCcD_CylAttr::GetNVec(cXyz const& param_0, cXyz* param_1) const {
}
}
PSVECSubtract(&param_0, &vec, param_1);
if (cM3d_IsZero(PSVECMag(param_1))) {
VECSubtract(&param_0, &vec, param_1);
if (cM3d_IsZero(VECMag(param_1))) {
param_1->set(0.0f, 0.0f, 0.0f);
return false;
} else {
PSVECNormalize(param_1, param_1);
VECNormalize(param_1, param_1);
return true;
}
return false;
@@ -692,13 +692,13 @@ bool cCcD_SphAttr::GetNVec(cXyz const& param_0, cXyz* param_1) const {
param_1->y = param_0.y - mCenter.y;
param_1->z = param_0.z - mCenter.z;
if (cM3d_IsZero(PSVECMag(param_1))) {
if (cM3d_IsZero(VECMag(param_1))) {
param_1->x = 0.0f;
param_1->y = 0.0f;
param_1->z = 0.0f;
return false;
} else {
PSVECNormalize(param_1, param_1);
VECNormalize(param_1, param_1);
return true;
}
}
libs/SSystem/SComponent/c_cc_s.cpp
+7 -7
View File
@@ -310,8 +310,8 @@ void cCcS::SetPosCorrect(cCcD_Obj* obj1, cXyz* xyz1, cCcD_Obj* obj2, cXyz* xyz2,
Vec obj2Move;
Vec objsDist;
if (bothCoSph3DCrr) {
PSVECSubtract(xyz2, xyz1, &objsDist);
objDistLen = PSVECMag(&objsDist);
VECSubtract(xyz2, xyz1, &objsDist);
objDistLen = VECMag(&objsDist);
} else {
objsDist.x = xyz2->x - xyz1->x;
objsDist.y = 0;
@@ -320,10 +320,10 @@ void cCcS::SetPosCorrect(cCcD_Obj* obj1, cXyz* xyz1, cCcD_Obj* obj2, cXyz* xyz2,
}
if (!cM3d_IsZero(objDistLen)) {
if (bothCoSph3DCrr) {
PSVECScale(&objsDist, &objsDist, crossLen / objDistLen);
VECScale(&objsDist, &objsDist, crossLen / objDistLen);
obj2Weight *= -1;
PSVECScale(&objsDist, &obj1Move, obj2Weight);
PSVECScale(&objsDist, &obj2Move, obj1Weight);
VECScale(&objsDist, &obj1Move, obj2Weight);
VECScale(&objsDist, &obj2Move, obj1Weight);
} else {
f32 pushFactor = crossLen / objDistLen;
objsDist.x *= pushFactor;
@@ -350,8 +350,8 @@ void cCcS::SetPosCorrect(cCcD_Obj* obj1, cXyz* xyz1, cCcD_Obj* obj2, cXyz* xyz2,
}
obj1->GetStts()->PlusCcMove(obj1Move.x, obj1Move.y, obj1Move.z);
obj2->GetStts()->PlusCcMove(obj2Move.x, obj2Move.y, obj2Move.z);
PSVECAdd(xyz1, &obj1Move, xyz1);
PSVECAdd(xyz2, &obj2Move, xyz2);
VECAdd(xyz1, &obj1Move, xyz1);
VECAdd(xyz2, &obj2Move, xyz2);
}
}
libs/SSystem/SComponent/c_lib.cpp
+9 -9
View File
@@ -363,36 +363,36 @@ void MtxInit() {
/* 80270E5C-80270EA4 26B79C 0048+00 0/0 0/0 43/43 .text MtxTrans__FfffUc */
void MtxTrans(f32 x_trans, f32 y_trans, f32 z_trans, u8 param_3) {
if (param_3 == 0) {
PSMTXTrans(*calc_mtx, x_trans, y_trans, z_trans);
MTXTrans(*calc_mtx, x_trans, y_trans, z_trans);
} else {
Mtx mtx;
PSMTXTrans(mtx, x_trans, y_trans, z_trans);
PSMTXConcat(*calc_mtx, mtx, *calc_mtx);
MTXTrans(mtx, x_trans, y_trans, z_trans);
MTXConcat(*calc_mtx, mtx, *calc_mtx);
}
}
/* 80270EA4-80270EEC 26B7E4 0048+00 0/0 0/0 46/46 .text MtxScale__FfffUc */
void MtxScale(f32 x_trans, f32 y_trans, f32 z_trans, u8 param_3) {
if (param_3 == 0) {
PSMTXScale(*calc_mtx, x_trans, y_trans, z_trans);
MTXScale(*calc_mtx, x_trans, y_trans, z_trans);
} else {
Mtx mtx;
PSMTXScale(mtx, x_trans, y_trans, z_trans);
PSMTXConcat(*calc_mtx, mtx, *calc_mtx);
MTXScale(mtx, x_trans, y_trans, z_trans);
MTXConcat(*calc_mtx, mtx, *calc_mtx);
}
}
/* 80270EEC-80270F1C 26B82C 0030+00 0/0 2/2 615/615 .text MtxPosition__FP4cXyzP4cXyz */
void MtxPosition(cXyz* src, cXyz* dest) {
PSMTXMultVec(*calc_mtx, src, dest);
MTXMultVec(*calc_mtx, src, dest);
}
/* 80270F1C-80270F58 26B85C 003C+00 0/0 0/0 20/20 .text MtxPush__Fv */
void MtxPush() {
Mtx mtx;
PSMTXCopy(*calc_mtx, mtx);
MTXCopy(*calc_mtx, mtx);
calc_mtx++;
PSMTXCopy(mtx, *calc_mtx);
MTXCopy(mtx, *calc_mtx);
}
/* 80270F58-80270F68 26B898 0010+00 0/0 0/0 20/20 .text MtxPull__Fv */
libs/SSystem/SComponent/c_m3d.cpp
+56 -56
View File
@@ -117,15 +117,15 @@ f32 G_CM3D_F_ABS_MIN = 32 * FLT_EPSILON;
*/
void cM3d_InDivPos1(const Vec* pVecA, const Vec* pVecB, f32 pF, Vec* pOut) {
Vec tmp;
PSVECScale(pVecB, &tmp, pF);
PSVECAdd(&tmp, pVecA, pOut);
VECScale(pVecB, &tmp, pF);
VECAdd(&tmp, pVecA, pOut);
}
/* 802685B0-80268614 262EF0 0064+00 2/2 1/1 2/2 .text cM3d_InDivPos2__FPC3VecPC3VecfP3Vec
*/
void cM3d_InDivPos2(const Vec* pVecA, const Vec* pVecB, f32 pF, Vec* pOut) {
Vec tmp;
PSVECSubtract(pVecB, pVecA, &tmp);
VECSubtract(pVecB, pVecA, &tmp);
cM3d_InDivPos1(pVecA, &tmp, pF, pOut);
}
@@ -189,24 +189,24 @@ bool cM3d_Len2dSqPntAndSegLine(f32 param_1, f32 param_2, f32 param_3, f32 param_
bool cM3d_Len3dSqPntAndSegLine(const cM3dGLin* pLine, const Vec* pVec, Vec* pOutVec, f32* pOutF) {
bool retVal = false;
Vec tmp;
PSVECSubtract(&pLine->GetEndP(), &pLine->GetStartP(), &tmp);
f32 seqLen = PSVECDotProduct(&tmp, &tmp);
VECSubtract(&pLine->GetEndP(), &pLine->GetStartP(), &tmp);
f32 seqLen = VECDotProduct(&tmp, &tmp);
if (cM3d_IsZero(seqLen)) {
*pOutF = /* 0.0 */ FLOAT_LABEL(lit_2256);
return retVal;
} else {
Vec tmp2;
PSVECSubtract(pVec, &pLine->GetStartP(), &tmp2);
f32 tmpF = PSVECDotProduct(&tmp2, &tmp);
VECSubtract(pVec, &pLine->GetStartP(), &tmp2);
f32 tmpF = VECDotProduct(&tmp2, &tmp);
tmpF /= seqLen;
if (tmpF < /* 0.0 */ FLOAT_LABEL(lit_2256) || tmpF > /* 1.0 */ FLOAT_LABEL(lit_2273)) {
retVal = false;
} else {
retVal = true;
}
PSVECScale(&tmp, &tmp, tmpF);
PSVECAdd(&tmp, &pLine->GetStartP(), pOutVec);
*pOutF = PSVECSquareDistance(pOutVec, pVec);
VECScale(&tmp, &tmp, tmpF);
VECAdd(&tmp, &pLine->GetStartP(), pOutVec);
*pOutF = VECSquareDistance(pOutVec, pVec);
return retVal;
}
}
@@ -214,11 +214,11 @@ bool cM3d_Len3dSqPntAndSegLine(const cM3dGLin* pLine, const Vec* pVec, Vec* pOut
/* 80268814-80268894 263154 0080+00 1/1 3/3 0/0 .text cM3d_SignedLenPlaAndPos__FPC8cM3dGPlaPC3Vec
*/
f32 cM3d_SignedLenPlaAndPos(const cM3dGPla* pPlane, const Vec* pPosition) {
f32 mag = PSVECMag(&pPlane->GetNP());
f32 mag = VECMag(&pPlane->GetNP());
if (cM3d_IsZero(mag)) {
return /* 0.0 */ FLOAT_LABEL(lit_2256);
} else {
return (pPlane->mD + PSVECDotProduct(&pPlane->GetNP(), pPosition)) / mag;
return (pPlane->mD + VECDotProduct(&pPlane->GetNP(), pPosition)) / mag;
}
}
@@ -232,9 +232,9 @@ f32 cM3d_VectorProduct2d(f32 pX1, f32 pY1, f32 pX2, f32 pY2, f32 pX3, f32 pY3) {
void cM3d_VectorProduct(const cXyz* pVecA, const cXyz* pVecB, const cXyz* pVecC, cXyz* pVecOut) {
Vec tmp1;
Vec tmp2;
PSVECSubtract(pVecB, pVecA, &tmp1);
PSVECSubtract(pVecC, pVecA, &tmp2);
PSVECCrossProduct(&tmp1, &tmp2, pVecOut);
VECSubtract(pVecB, pVecA, &tmp1);
VECSubtract(pVecC, pVecA, &tmp2);
VECCrossProduct(&tmp1, &tmp2, pVecOut);
}
/* ############################################################################################## */
@@ -245,13 +245,13 @@ SECTION_SDATA2 static f32 lit_2346 = 1.0f / 50.0f;
void cM3d_CalcPla(const Vec* pVecA, const Vec* pVecB, const Vec* pVecC, Vec* pVecOut, f32* pD) {
Vec tmp2;
Vec tmp1;
PSVECSubtract(pVecB, pVecA, &tmp1);
PSVECSubtract(pVecC, pVecA, &tmp2);
PSVECCrossProduct(&tmp1, &tmp2, pVecOut);
f32 mag = PSVECMag(pVecOut);
VECSubtract(pVecB, pVecA, &tmp1);
VECSubtract(pVecC, pVecA, &tmp2);
VECCrossProduct(&tmp1, &tmp2, pVecOut);
f32 mag = VECMag(pVecOut);
if (fabsf(mag) >= /* 0.02 */ FLOAT_LABEL(lit_2346)) {
PSVECScale(pVecOut, pVecOut, /* 1.0 */ FLOAT_LABEL(lit_2273) / mag);
*pD = -PSVECDotProduct(pVecOut, pVecA);
VECScale(pVecOut, pVecOut, /* 1.0 */ FLOAT_LABEL(lit_2273) / mag);
*pD = -VECDotProduct(pVecOut, pVecA);
} else {
f32 zero = /* 0.0 */ FLOAT_LABEL(lit_2256);
pVecOut->y = zero;
@@ -346,23 +346,23 @@ int cM3d_Check_LinLin(const cM3dGLin* pLinA, const cM3dGLin* pLinB, f32* pFloatA
Vec linBVec;
pLinA->CalcVec(&linAVec);
pLinB->CalcVec(&linBVec);
f32 linALen = PSVECMag(&linAVec);
f32 linBLen = PSVECMag(&linBVec);
f32 linALen = VECMag(&linAVec);
f32 linBLen = VECMag(&linBVec);
if (cM3d_IsZero(linALen) || cM3d_IsZero(linBLen)) {
return 1;
} else {
f32 invLinALen = /* 1.0 */ FLOAT_LABEL(lit_2273) / linALen;
f32 invLinBLen = /* 1.0 */ FLOAT_LABEL(lit_2273) / linBLen;
PSVECScale(&linAVec, &linAVec, invLinALen);
PSVECScale(&linBVec, &linBVec, invLinBLen);
VECScale(&linAVec, &linAVec, invLinALen);
VECScale(&linBVec, &linBVec, invLinBLen);
Vec tmp;
PSVECSubtract(&pLinA->GetStartP(), &pLinB->GetStartP(), &tmp);
f32 tmpF = -PSVECDotProduct(&linAVec, &linBVec);
f32 tmpF2 = PSVECDotProduct(&tmp, &linAVec);
PSVECSquareMag(&tmp); // result not used
VECSubtract(&pLinA->GetStartP(), &pLinB->GetStartP(), &tmp);
f32 tmpF = -VECDotProduct(&linAVec, &linBVec);
f32 tmpF2 = VECDotProduct(&tmp, &linAVec);
VECSquareMag(&tmp); // result not used
f32 tmpF3 = fabsf(/* 1.0 */ FLOAT_LABEL(lit_2273) - (tmpF * tmpF));
if (!cM3d_IsZero(tmpF3)) {
f32 tmpF4 = -PSVECDotProduct(&tmp, &linBVec);
f32 tmpF4 = -VECDotProduct(&tmp, &linBVec);
f32 tmpF7 = /* 1.0 */ FLOAT_LABEL(lit_2273) / tmpF3;
f32 outFloatAtmp = ((tmpF * tmpF4) - tmpF2) * tmpF7;
*pFloatA = outFloatAtmp * invLinALen;
@@ -377,7 +377,7 @@ int cM3d_Check_LinLin(const cM3dGLin* pLinA, const cM3dGLin* pLinB, f32* pFloatA
tmpF6 = linBLen;
tmpF5 = (tmpF6 * tmpF) - tmpF2;
}
f32 tmpF7 = PSVECDotProduct(&tmp, &linBVec);
f32 tmpF7 = VECDotProduct(&tmp, &linBVec);
if (tmpF5 < /* 0.0 */ FLOAT_LABEL(lit_2256) || tmpF5 > linALen) {
tmpF5 = /* 0.0 */ FLOAT_LABEL(lit_2256);
tmpF6 = tmpF7;
@@ -897,9 +897,9 @@ bool cM3d_Cross_SphSph(const cM3dGSph* pSphereA, const cM3dGSph* pSphereB, Vec*
// could be an inlined function
f32 tmpF = pSphereB->GetR() / centerDist;
Vec tmp;
PSVECSubtract(&pSphereA->GetC(), &pSphereB->GetC(), &tmp);
PSVECScale(&tmp, &tmp, tmpF);
PSVECAdd(&tmp, &pSphereB->GetC(), pVecOut);
VECSubtract(&pSphereA->GetC(), &pSphereB->GetC(), &tmp);
VECScale(&tmp, &tmp, tmpF);
VECAdd(&tmp, &pSphereB->GetC(), pVecOut);
} else {
*pVecOut = pSphereA->GetC();
}
@@ -918,9 +918,9 @@ SECTION_SDATA2 static f32 lit_3892 = 0.5f;
void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph* pSphere, const cM3dGTri* pTriangle, Vec* pVecOut) {
Vec tmp2;
Vec tmp;
PSVECAdd(&pTriangle->mA, &pTriangle->mB, &tmp);
PSVECScale(&tmp, &tmp2, /* 0.5 */ FLOAT_LABEL(lit_3892));
f32 sqDist = PSVECSquareDistance(&tmp2, &pSphere->GetC());
VECAdd(&pTriangle->mA, &pTriangle->mB, &tmp);
VECScale(&tmp, &tmp2, /* 0.5 */ FLOAT_LABEL(lit_3892));
f32 sqDist = VECSquareDistance(&tmp2, &pSphere->GetC());
if (cM3d_IsZero(sqDist)) {
*pVecOut = pSphere->GetC();
} else {
@@ -1071,8 +1071,8 @@ inline void cM3d_2LinCenter(cM3dGLin const pLinA, f32 pLinAF, cM3dGLin const& pL
Vec tmp, tmp2;
pLinA.CalcPos(&tmp, pLinAF);
pLinB.CalcPos(&tmp2, pLinBF);
PSVECAdd(&tmp, &tmp2, pVecOut);
PSVECScale(pVecOut, pVecOut, /* 0.5 */ FLOAT_LABEL(lit_3892));
VECAdd(&tmp, &tmp2, pVecOut);
VECScale(pVecOut, pVecOut, /* 0.5 */ FLOAT_LABEL(lit_3892));
}
/* 8026E12C-8026E4FC 268A6C 03D0+00 0/0 2/2 0/0 .text
@@ -1115,7 +1115,7 @@ void cM3d_PlaneCrossLineProcWork(f32 f1, f32 f2, f32 f3, f32 f4, f32 f5, f32 f6,
static int cM3d_2PlaneCrossLine(const cM3dGPla& pPlaneA, const cM3dGPla& pPlaneB,
cM3dGLin* pLinOut) {
Vec tmp;
PSVECCrossProduct(&pPlaneA.GetNP(), &pPlaneB.GetNP(), &tmp);
VECCrossProduct(&pPlaneA.GetNP(), &pPlaneB.GetNP(), &tmp);
if (cM3d_IsZero(tmp.x) && cM3d_IsZero(tmp.y) && cM3d_IsZero(tmp.z)) {
return 0;
} else {
@@ -1138,12 +1138,12 @@ static int cM3d_2PlaneCrossLine(const cM3dGPla& pPlaneA, const cM3dGPla& pPlaneB
&pLinOut->GetStartP().x, &pLinOut->GetStartP().y);
pLinOut->GetStartP().z = /* 0.0 */ FLOAT_LABEL(lit_2256);
}
f32 scale = PSVECMag(&pLinOut->GetStartP());
f32 scale = VECMag(&pLinOut->GetStartP());
if (cM3d_IsZero(scale)) {
scale = /* 1.0 */ FLOAT_LABEL(lit_2273);
}
PSVECScale(&tmp, &tmp, scale);
PSVECAdd(&pLinOut->GetStartP(), &tmp, &pLinOut->GetEndP());
VECScale(&tmp, &tmp, scale);
VECAdd(&pLinOut->GetStartP(), &tmp, &pLinOut->GetEndP());
return 1;
}
}
@@ -1174,15 +1174,15 @@ f32 cM3d_lineVsPosSuisenCross(const cM3dGLin* pLine, const Vec* pPoint, Vec* pVe
Vec tmp2;
Vec tmp3;
pLine->CalcVec(&tmp1);
f32 diffLen = PSVECSquareMag(&tmp1);
f32 diffLen = VECSquareMag(&tmp1);
if (cM3d_IsZero(diffLen)) {
*pVecOut = *pPoint;
return /* 0.0 */ FLOAT_LABEL(lit_2256);
} else {
PSVECSubtract(pPoint, &pLine->GetStartP(), &tmp2);
f32 retVal = PSVECDotProduct(&tmp2, &tmp1) / diffLen;
PSVECScale(&tmp1, &tmp3, retVal);
PSVECAdd(&tmp3, &pLine->GetStartP(), pVecOut);
VECSubtract(pPoint, &pLine->GetStartP(), &tmp2);
f32 retVal = VECDotProduct(&tmp2, &tmp1) / diffLen;
VECScale(&tmp1, &tmp3, retVal);
VECAdd(&tmp3, &pLine->GetStartP(), pVecOut);
return retVal;
}
}
@@ -1194,17 +1194,17 @@ f32 cM3d_lineVsPosSuisenCross(const Vec& pLinePointA, const Vec& pLinePointB, co
Vec tmp1;
Vec tmp2;
Vec tmp3;
PSVECSubtract(&pLinePointB, &pLinePointA, &tmp1);
f32 diffLen = PSVECSquareMag(&tmp1);
VECSubtract(&pLinePointB, &pLinePointA, &tmp1);
f32 diffLen = VECSquareMag(&tmp1);
if (cM3d_IsZero(diffLen)) {
*pVecOut = pPoint;
return /* 0.0 */ FLOAT_LABEL(lit_2256);
} else {
PSVECSubtract(&pPoint, &pLinePointA, &tmp2);
f32 dotProd = PSVECDotProduct(&tmp2, &tmp1);
VECSubtract(&pPoint, &pLinePointA, &tmp2);
f32 dotProd = VECDotProduct(&tmp2, &tmp1);
f32 retVal = dotProd / diffLen;
PSVECScale(&tmp1, &tmp3, retVal);
PSVECAdd(&tmp3, &pLinePointA, pVecOut);
VECScale(&tmp1, &tmp3, retVal);
VECAdd(&tmp3, &pLinePointA, pVecOut);
return retVal;
}
}
@@ -1225,6 +1225,6 @@ int cM3d_2PlaneLinePosNearPos(const cM3dGPla& pPlaneA, const cM3dGPla& pPlaneB,
/* 8026EBBC-8026EC3C 2694FC 0080+00 0/0 1/1 0/0 .text cM3d_CrawVec__FRC3VecRC3VecP3Vec */
void cM3d_CrawVec(const Vec& pVecA, const Vec& pVecB, Vec* pVecOut) {
Vec tmp;
PSVECScale(&pVecA, &tmp, fabsf(pVecB.x * pVecA.x + pVecB.y * pVecA.y + pVecB.z * pVecA.z));
PSVECAdd(&tmp, &pVecB, pVecOut);
VECScale(&pVecA, &tmp, fabsf(pVecB.x * pVecA.x + pVecB.y * pVecA.y + pVecB.z * pVecA.z));
VECAdd(&tmp, &pVecB, pVecOut);
}
libs/SSystem/SComponent/c_m3d_g_aab.cpp
+2 -2
View File
@@ -68,8 +68,8 @@ void cM3dGAab::SetMax(const cXyz& pMax) {
}
/* 8026EE24-8026EE68 0044+00 s=0 e=1 z=0 None .text CalcCenter__8cM3dGAabCFP4cXyz */
void cM3dGAab::CalcCenter(cXyz* pOut) const {
PSVECAdd(&mMin, &mMax, pOut);
PSVECScale(pOut, pOut, 0.5f);
VECAdd(&mMin, &mMax, pOut);
VECScale(pOut, pOut, 0.5f);
}
/* 8026EE68-8026EEB4 004C+00 s=0 e=1 z=0 None .text PlusR__8cM3dGAabFf */
libs/SSystem/SComponent/c_m3d_g_lin.cpp
+3 -3
View File
@@ -28,9 +28,9 @@ void cM3dGLin::SetStartEnd(const Vec& pStart, const Vec& pEnd) {
/* 8026F350-8026F3C0 0070+00 s=0 e=3 z=0 None .text CalcPos__8cM3dGLinCFP3Vecf */
void cM3dGLin::CalcPos(Vec* pOut, f32 pScale) const {
Vec tmp;
PSVECSubtract(&mEnd, &mStart, &tmp);
PSVECScale(&tmp, &tmp, pScale);
PSVECAdd(&tmp, &mStart, pOut);
VECSubtract(&mEnd, &mStart, &tmp);
VECScale(&tmp, &tmp, pScale);
VECAdd(&tmp, &mStart, pOut);
}
/* 8026F3C0-8026F3DC 001C+00 s=0 e=1 z=0 None .text SetEnd__8cM3dGLinFRC4cXyz */
libs/SSystem/SComponent/c_m3d_g_pla.cpp
+5 -5
View File
@@ -17,8 +17,8 @@ cM3dGPla::cM3dGPla(const cXyz* pNormal, f32 pD) : mNormal(*pNormal), mD(pD) {}
/* 8026F408-8026F4C4 269D48 00BC+00 0/0 3/3 0/0 .text crossInfLin__8cM3dGPlaCFRC4cXyzRC4cXyzR4cXyz
*/
bool cM3dGPla::crossInfLin(const cXyz& pStart, const cXyz& pEnd, cXyz& out) const {
f32 tmp1 = (mD + PSVECDotProduct(&mNormal, &pStart));
f32 tmp2 = tmp1 - (mD + PSVECDotProduct(&mNormal, &pEnd));
f32 tmp1 = (mD + VECDotProduct(&mNormal, &pStart));
f32 tmp2 = tmp1 - (mD + VECDotProduct(&mNormal, &pEnd));
if (fabsf(tmp2) < G_CM3D_F_ABS_MIN) {
out = pEnd;
return false;
@@ -31,14 +31,14 @@ bool cM3dGPla::crossInfLin(const cXyz& pStart, const cXyz& pEnd, cXyz& out) cons
/* 8026F4C4-8026F52C 269E04 0068+00 0/0 1/1 0/0 .text SetupNP0__8cM3dGPlaFRC3VecRC3Vec */
void cM3dGPla::SetupNP0(const Vec& pNormal, const Vec& pPoint) {
mNormal = pNormal;
PSVECNormalize(&mNormal, &mNormal);
mD = -PSVECDotProduct(&mNormal, &pPoint);
VECNormalize(&mNormal, &mNormal);
mD = -VECDotProduct(&mNormal, &pPoint);
}
/* 8026F52C-8026F57C 269E6C 0050+00 0/0 2/2 0/0 .text SetupNP__8cM3dGPlaFRC3VecRC3Vec */
void cM3dGPla::SetupNP(const Vec& pNormal, const Vec& pPoint) {
mNormal = pNormal;
mD = -PSVECDotProduct(&mNormal, &pPoint);
mD = -VECDotProduct(&mNormal, &pPoint);
}
/* 8026F57C-8026F5D4 269EBC 0058+00 0/0 2/2 0/0 .text getCrossY__8cM3dGPlaCFRC4cXyzPf */
libs/SSystem/SComponent/c_xyz.cpp
+11 -11
View File
@@ -14,21 +14,21 @@
/* 80266AE4-80266B34 0050+00 s=0 e=103 z=300 None .text __pl__4cXyzCFRC3Vec */
cXyz cXyz::operator+(const Vec& vec) const {
Vec ret;
PSVECAdd(this, &vec, &ret);
VECAdd(this, &vec, &ret);
return cXyz(ret);
}
/* 80266B34-80266B84 0050+00 s=0 e=196 z=1082 None .text __mi__4cXyzCFRC3Vec */
cXyz cXyz::operator-(const Vec& vec) const {
Vec ret;
PSVECSubtract(this, &vec, &ret);
VECSubtract(this, &vec, &ret);
return cXyz(ret);
}
/* 80266B84-80266BD0 004C+00 s=1 e=99 z=158 None .text __ml__4cXyzCFf */
cXyz cXyz::operator*(f32 scale) const {
Vec ret;
PSVECScale(this, &ret, scale);
VECScale(this, &ret, scale);
return cXyz(ret);
}
@@ -48,14 +48,14 @@ cXyz cXyz::operator*(const Vec& vec) const {
/* 80266C18-80266C6C 0054+00 s=0 e=3 z=12 None .text __dv__4cXyzCFf */
cXyz cXyz::operator/(f32 scale) const {
Vec ret;
PSVECScale(this, &ret, 1.0f / scale);
VECScale(this, &ret, 1.0f / scale);
return cXyz(ret);
}
/* 80266C6C-80266CBC 0050+00 s=1 e=0 z=0 None .text getCrossProduct__4cXyzCFRC3Vec */
cXyz cXyz::getCrossProduct(const Vec& vec) const {
Vec ret;
PSVECCrossProduct(this, &vec, &ret);
VECCrossProduct(this, &vec, &ret);
return cXyz(ret);
}
@@ -67,7 +67,7 @@ cXyz cXyz::outprod(const Vec& vec) const {
/* 80266CE4-80266D30 004C+00 s=0 e=10 z=1 None .text norm__4cXyzCFv */
cXyz cXyz::norm(void) const {
Vec ret;
PSVECNormalize(this, &ret);
VECNormalize(this, &ret);
return cXyz(ret);
}
@@ -75,7 +75,7 @@ cXyz cXyz::norm(void) const {
cXyz cXyz::normZP(void) const {
Vec vec;
if (this->isNearZeroSquare() == false) {
PSVECNormalize(this, &vec);
VECNormalize(this, &vec);
} else {
vec = cXyz::Zero;
}
@@ -96,7 +96,7 @@ inline void normToUpZIfNearZero(Vec& vec) {
cXyz cXyz::normZC(void) const {
Vec outVec;
if (this->isNearZeroSquare() == false) {
PSVECNormalize(this, &outVec);
VECNormalize(this, &outVec);
} else {
outVec = (*this * 1.25f * 1000000.0f).normZP();
normToUpZIfNearZero(outVec);
@@ -106,14 +106,14 @@ cXyz cXyz::normZC(void) const {
/* 80266EF4-80266F48 0054+00 s=0 e=13 z=17 None .text normalize__4cXyzFv */
cXyz cXyz::normalize(void) {
PSVECNormalize(this, this);
VECNormalize(this, this);
return *this;
}
/* 80266F48-80266FDC 0094+00 s=0 e=19 z=59 None .text normalizeZP__4cXyzFv */
cXyz cXyz::normalizeZP(void) {
if (this->isNearZeroSquare() == false) {
PSVECNormalize(this, this);
VECNormalize(this, this);
} else {
*this = cXyz::Zero;
}
@@ -125,7 +125,7 @@ bool cXyz::normalizeRS(void) {
if (this->isNearZeroSquare()) {
return false;
} else {
PSVECNormalize(this, this);
VECNormalize(this, this);
return true;
}
}