mirror of
https://github.com/zeldaret/oot.git
synced 2025-07-04 15:04:31 +00:00
matched Math3D_CylVsLineSeg and fixed a Math_ error (#564)
* matched cylvsline * slight name adjustment * format * and asm * comment cleanup * fixed misspelling and added mathfixer tool * formatting Co-authored-by: petrie911 <pmontag@DESKTOP-LG8A167.localdomain>
This commit is contained in:
petrie911
GitHub
parent
b95643b397
commit
3727cc38b8
36 changed files with 382 additions and 1048 deletions
|
|
@ -62,6 +62,11 @@ s32 Math3D_LineSegMakePerpLineSeg(Vec3f* lineAPointA, Vec3f* lineAPointB, Vec3f*
|
|||
Vec3f lineABPointADiff;
|
||||
f32 t;
|
||||
f32 t2;
|
||||
f32 tempf1;
|
||||
f32 tempf2;
|
||||
f32 tempf3;
|
||||
f32 tempf4;
|
||||
f32 tempf5;
|
||||
|
||||
lineADiff.x = lineAPointB->x - lineAPointA->x;
|
||||
lineADiff.y = lineAPointB->y - lineAPointA->y;
|
||||
|
|
@ -70,21 +75,18 @@ s32 Math3D_LineSegMakePerpLineSeg(Vec3f* lineAPointA, Vec3f* lineAPointB, Vec3f*
|
|||
lineBDiff.y = lineBPointB->y - lineBPointA->y;
|
||||
lineBDiff.z = lineBPointB->z - lineBPointA->z;
|
||||
|
||||
if (IS_ZERO(SQ(lineBDiff.x) + SQ(lineBDiff.y) + SQ(lineBDiff.z))) {
|
||||
if (IS_ZERO(SQXYZ(lineBDiff))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
sp5C = ((lineADiff.x * lineBDiff.x) + (lineADiff.y * lineBDiff.y) + (lineADiff.z * lineBDiff.z)) *
|
||||
(1.0f / (SQ(lineBDiff.x) + SQ(lineBDiff.y) + SQ(lineBDiff.z)));
|
||||
tempf1 = 1.0f / SQXYZ(lineBDiff);
|
||||
sp5C = DOTXYZ(lineADiff, lineBDiff) * tempf1;
|
||||
|
||||
lineABPointADiff.x = lineAPointA->x - lineBPointA->x;
|
||||
lineABPointADiff.y = lineAPointA->y - lineBPointA->y;
|
||||
lineABPointADiff.z = lineAPointA->z - lineBPointA->z;
|
||||
|
||||
// most reordering is here.
|
||||
temp_f18 =
|
||||
((lineABPointADiff.x * lineBDiff.x) + (lineABPointADiff.y * lineBDiff.y) + (lineABPointADiff.z * lineBDiff.z)) *
|
||||
(1.0f / (SQ(lineBDiff.x) + SQ(lineBDiff.y) + SQ(lineBDiff.z)));
|
||||
temp_f18 = DOTXYZ(lineABPointADiff, lineBDiff) * tempf1;
|
||||
|
||||
sp4C = lineADiff.x - (lineBDiff.x * sp5C);
|
||||
sp50 = lineADiff.y - (lineBDiff.y * sp5C);
|
||||
|
|
@ -92,7 +94,6 @@ s32 Math3D_LineSegMakePerpLineSeg(Vec3f* lineAPointA, Vec3f* lineAPointB, Vec3f*
|
|||
if (IS_ZERO(SQ(sp4C) + SQ(sp50) + SQ(sp30))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
t = SQ(sp4C) + SQ(sp50) + SQ(sp30);
|
||||
temp_f0_4 = -((sp4C * (lineABPointADiff.x - (lineBDiff.x * temp_f18))) +
|
||||
(sp50 * (lineABPointADiff.y - (lineBDiff.y * temp_f18))) +
|
||||
|
|
@ -1624,72 +1625,28 @@ s32 Math3D_PointInCyl(Cylinder16* cyl, Vec3f* point) {
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef NON_MATCHING
|
||||
s32 Math3D_CylVsLineSeg(Cylinder16* cyl, Vec3f* linePointA, Vec3f* linePointB, Vec3f* intersectA, Vec3f* intersectB) {
|
||||
Vec3f pointACylBottomDiff;
|
||||
Vec3f pointBCylBottomDiff;
|
||||
Vec3f spD4;
|
||||
f32 spD0;
|
||||
f32 spCC;
|
||||
f32 spB8;
|
||||
s32 sp9C;
|
||||
Vec3f sp6C[4];
|
||||
s32 sp68;
|
||||
f32 sp4C;
|
||||
f32 sp2C;
|
||||
f32 sp28;
|
||||
f32* temp_a0;
|
||||
f32* temp_a1;
|
||||
f32* temp_s0;
|
||||
f32 temp_f0;
|
||||
f32 temp_f0_2;
|
||||
f32 temp_f0_3;
|
||||
f32 temp_f0_4;
|
||||
f32 temp_f0_5;
|
||||
f32 temp_f0_6;
|
||||
f32 temp_f10;
|
||||
f32 temp_f12;
|
||||
f32 temp_f12_2;
|
||||
Vec3f cylToPtA;
|
||||
Vec3f cylToPtB;
|
||||
Vec3f ptAToPtB;
|
||||
f32 fracA;
|
||||
f32 fracB;
|
||||
f32 fracBase;
|
||||
f32 zero = 0.0f;
|
||||
f32 pad;
|
||||
f32 cylRadiusSq;
|
||||
f32 temp_f14_2;
|
||||
f32 temp_f14_3;
|
||||
f32 temp_f16;
|
||||
f32 temp_f16_2;
|
||||
f32 temp_f18;
|
||||
f32 temp_f2;
|
||||
f32 temp_f2_2;
|
||||
f32 temp_f2_3;
|
||||
f32 temp_f2_4;
|
||||
f32 temp_f2_5;
|
||||
f32 temp_f2_6;
|
||||
f32 temp_f2_7;
|
||||
s32 temp_a0_2;
|
||||
s32 temp_t0;
|
||||
s32 temp_v0;
|
||||
s32 temp_v1;
|
||||
void* temp_t2;
|
||||
s32 phi_a1;
|
||||
s32 phi_a1_2;
|
||||
f32 phi_f2;
|
||||
s32 phi_v0;
|
||||
s32 phi_v0_2;
|
||||
s32 phi_v1;
|
||||
s32 phi_v1_2;
|
||||
s32 phi_a2;
|
||||
s32 phi_a1_3;
|
||||
s32 phi_a2_2;
|
||||
s32 phi_a1_4;
|
||||
s32 phi_v0_3;
|
||||
s32 phi_t0;
|
||||
s32 phi_v1_3;
|
||||
s32 phi_v1_4;
|
||||
s32 phi_a2_3;
|
||||
s32 phi_a2_4;
|
||||
s32 phi_t0_2;
|
||||
s32 phi_v1_5;
|
||||
s32 phi_t0_3;
|
||||
f32 radSqDiff;
|
||||
f32 distCent2;
|
||||
f32 dot2AB;
|
||||
s32 sideIntA;
|
||||
s32 sideIntB;
|
||||
s32 intBeyondA;
|
||||
s32 intBeyondB;
|
||||
s32 intFlags = 0;
|
||||
Vec3f intPts[4];
|
||||
s32 count;
|
||||
s32 i;
|
||||
|
||||
sp9C = 0;
|
||||
if (Math3D_PointInCyl(cyl, linePointA) && Math3D_PointInCyl(cyl, linePointB)) {
|
||||
// both points are in the cylinder
|
||||
*intersectA = *linePointA;
|
||||
|
|
@ -1697,151 +1654,158 @@ s32 Math3D_CylVsLineSeg(Cylinder16* cyl, Vec3f* linePointA, Vec3f* linePointB, V
|
|||
return 2;
|
||||
}
|
||||
|
||||
pointACylBottomDiff.x = linePointA->x - cyl->pos.x;
|
||||
pointACylBottomDiff.y = linePointA->y - cyl->pos.y - cyl->yShift;
|
||||
pointACylBottomDiff.z = linePointA->z - cyl->pos.z;
|
||||
pointBCylBottomDiff.x = linePointB->x - cyl->pos.x;
|
||||
pointBCylBottomDiff.y = linePointB->y - cyl->pos.y - cyl->yShift;
|
||||
pointBCylBottomDiff.z = linePointB->z - cyl->pos.z;
|
||||
Math_Vec3f_Diff(&pointBCylBottomDiff, &pointACylBottomDiff, &spD4);
|
||||
cylToPtA.x = linePointA->x - cyl->pos.x;
|
||||
cylToPtA.y = linePointA->y - cyl->pos.y - cyl->yShift;
|
||||
cylToPtA.z = linePointA->z - cyl->pos.z;
|
||||
cylToPtB.x = linePointB->x - cyl->pos.x;
|
||||
cylToPtB.y = linePointB->y - cyl->pos.y - cyl->yShift;
|
||||
cylToPtB.z = linePointB->z - cyl->pos.z;
|
||||
Math_Vec3f_Diff(&cylToPtB, &cylToPtA, &ptAToPtB);
|
||||
cylRadiusSq = SQ(cyl->radius);
|
||||
if (!IS_ZERO(spD4.y)) {
|
||||
if (1) {}
|
||||
if ((-pointACylBottomDiff.y / spD4.y) >= 0.0f) {
|
||||
if ((-pointACylBottomDiff.y / spD4.y) <= 1.0f) {
|
||||
if ((SQ((spD4.x * (-pointACylBottomDiff.y / spD4.y)) + pointACylBottomDiff.x) +
|
||||
SQ((spD4.z * (-pointACylBottomDiff.y / spD4.y)) + pointACylBottomDiff.z)) < cylRadiusSq) {
|
||||
sp6C[0].x =
|
||||
(f32)cyl->pos.x + ((spD4.x * (-pointACylBottomDiff.y / spD4.y)) + pointACylBottomDiff.x);
|
||||
sp6C[0].y = (f32)cyl->pos.y + (f32)cyl->yShift;
|
||||
sp6C[0].z =
|
||||
(f32)cyl->pos.z + ((spD4.z * (-pointACylBottomDiff.y / spD4.y)) + pointACylBottomDiff.z);
|
||||
sp9C |= 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* This section checks for intersections with the cylinder's base and top
|
||||
*/
|
||||
if (!IS_ZERO(ptAToPtB.y)) {
|
||||
// fraction of length along AB to reach y = 0
|
||||
fracBase = -cylToPtA.y / ptAToPtB.y;
|
||||
if ((0.0f <= fracBase) && (fracBase <= 1.0f)) {
|
||||
f32 baseIntX = (ptAToPtB.x * fracBase) + cylToPtA.x;
|
||||
f32 baseIntZ = (ptAToPtB.z * fracBase) + cylToPtA.z;
|
||||
|
||||
if (SQ(baseIntX) + SQ(baseIntZ) < cylRadiusSq) {
|
||||
// adds base intersection point to intPts and sets its flag
|
||||
intPts[0].x = cyl->pos.x + baseIntX;
|
||||
intPts[0].y = (f32)cyl->pos.y + cyl->yShift;
|
||||
intPts[0].z = cyl->pos.z + baseIntZ;
|
||||
intFlags |= 1;
|
||||
}
|
||||
}
|
||||
// fraction of length along AB to reach y = cyl->height
|
||||
fracA = (cyl->height - cylToPtA.y) / ptAToPtB.y;
|
||||
if ((0.0f <= fracA) && (fracA <= 1.0f)) {
|
||||
f32 topIntX = ptAToPtB.x * fracA + cylToPtA.x;
|
||||
f32 topIntZ = ptAToPtB.z * fracA + cylToPtA.z;
|
||||
|
||||
phi_f2 = ((cyl->height - pointACylBottomDiff.y) / spD4.y);
|
||||
if (phi_f2 >= 0.0f) {
|
||||
if (phi_f2 <= 1.0f) {
|
||||
if ((SQ(pointACylBottomDiff.x + (spD4.x * phi_f2)) + SQ(pointACylBottomDiff.z + (spD4.z * phi_f2))) <
|
||||
cylRadiusSq) {
|
||||
sp6C[1].x = (f32)cyl->pos.x + pointACylBottomDiff.x + (spD4.x * phi_f2);
|
||||
sp6C[1].y = (f32)cyl->pos.y + cyl->height + cyl->yShift;
|
||||
sp6C[1].z = (f32)cyl->pos.z + pointACylBottomDiff.z + (spD4.x * phi_f2);
|
||||
sp9C |= 2;
|
||||
}
|
||||
if (SQ(topIntX) + SQ(topIntZ) < cylRadiusSq) {
|
||||
// adds top intersection point to intPts and sets its flag
|
||||
intPts[1].x = cyl->pos.x + topIntX;
|
||||
intPts[1].y = (f32)cyl->pos.y + cyl->yShift + cyl->height;
|
||||
intPts[1].z = cyl->pos.z + topIntZ;
|
||||
intFlags |= 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
spB8 = SQ(pointACylBottomDiff.x) + SQ(pointACylBottomDiff.z) - cylRadiusSq; // 498c
|
||||
temp_f12_2 = SQ(spD4.z) + SQ(spD4.x);
|
||||
temp_f18 = temp_f12_2 * 2.0f;
|
||||
if (!IS_ZERO(temp_f18)) {
|
||||
temp_f2_3 = (spD4.x * pointACylBottomDiff.x) + (spD4.z * pointACylBottomDiff.z);
|
||||
temp_f14_2 = temp_f2_3 + temp_f2_3;
|
||||
temp_f0_3 = temp_f14_2 * temp_f14_2;
|
||||
temp_f16_2 = (4.0f * temp_f12_2) * spB8;
|
||||
if (temp_f0_3 < temp_f16_2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
phi_a1 = (temp_f0_3 - temp_f16_2) > 0.0f;
|
||||
phi_f2 = (sqrtf((temp_f0_3 - temp_f16_2)) - temp_f14_2) / temp_f18;
|
||||
|
||||
if (phi_a1) {
|
||||
spCC = (-temp_f14_2 - sqrtf((temp_f0_3 - temp_f16_2))) / temp_f18;
|
||||
}
|
||||
} else if (!IS_ZERO(((spD4.x * pointACylBottomDiff.x) + (spD4.z * pointACylBottomDiff.z)) +
|
||||
((spD4.x * pointACylBottomDiff.x) + (spD4.z * pointACylBottomDiff.z)))) {
|
||||
phi_f2 = -spB8 / ((spD4.x * pointACylBottomDiff.x) + (spD4.z * pointACylBottomDiff.z)) +
|
||||
((spD4.x * pointACylBottomDiff.x) + (spD4.z * pointACylBottomDiff.z));
|
||||
phi_a2 = 1;
|
||||
phi_a1 = 0;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!phi_a1) {
|
||||
if (phi_f2 < 0.0f || phi_f2 > 1.0f) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
phi_a2 = phi_f2 < 0.0f || phi_f2 > 1.0f;
|
||||
|
||||
phi_a1 = spCC < 0.0f || spCC > 1.0f;
|
||||
|
||||
if (phi_a1 && phi_a2) {
|
||||
/**
|
||||
* This section finds the points of intersection of the infinite line containing AB with the side of the infinite
|
||||
* cylinder containing cyl. Intersection points beyond the bounds of the segment and cylinder are filtered out
|
||||
* afterward.
|
||||
*/
|
||||
radSqDiff = SQXZ(cylToPtA) - cylRadiusSq;
|
||||
if (!IS_ZERO(2.0f * SQXZ(ptAToPtB))) {
|
||||
dot2AB = 2.0f * DOTXZ(ptAToPtB, cylToPtA);
|
||||
if (SQ(dot2AB) < 4.0f * SQXZ(ptAToPtB) * radSqDiff) {
|
||||
// Line's closest xz-approach is outside cylinder. No intersections.
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (phi_a2) {
|
||||
phi_a2 = 0;
|
||||
if (SQ(dot2AB) - (4.0f * SQXZ(ptAToPtB) * radSqDiff) > zero) {
|
||||
sideIntA = sideIntB = 1;
|
||||
} else {
|
||||
// Line is tangent in xz-plane. At most 1 side intersection.
|
||||
sideIntA = 1;
|
||||
sideIntB = 0;
|
||||
}
|
||||
|
||||
if (phi_a1) {
|
||||
phi_a1 = 0;
|
||||
distCent2 = sqrtf(SQ(dot2AB) - (4.0f * SQXZ(ptAToPtB) * radSqDiff));
|
||||
if (sideIntA == 1) {
|
||||
// fraction of length along AB for side intersection closer to A
|
||||
fracA = (distCent2 - dot2AB) / (2.0f * SQXZ(ptAToPtB));
|
||||
}
|
||||
}
|
||||
|
||||
if ((phi_a2 == 1) && (((phi_f2 * spD4.y) + pointACylBottomDiff.y) < 0.0f ||
|
||||
cyl->height < ((phi_f2 * spD4.y) + pointACylBottomDiff.y))) {
|
||||
phi_a2 = 0;
|
||||
}
|
||||
|
||||
if ((phi_a1 == 1) &&
|
||||
(((spCC * spD4.y) + pointACylBottomDiff.y) < 0.0f || cyl->height < ((spCC * spD4.y) + pointACylBottomDiff.y))) {
|
||||
phi_a1 = 0;
|
||||
}
|
||||
if (phi_a2 == 0 && phi_a1 == 0) {
|
||||
if (sideIntB == 1) {
|
||||
// fraction of length along AB for side intersection closer to B
|
||||
fracB = (-dot2AB - distCent2) / (2.0f * SQXZ(ptAToPtB));
|
||||
}
|
||||
} else if (!IS_ZERO(2.0f * DOTXZ(ptAToPtB, cylToPtA))) {
|
||||
// Used if the line segment is nearly vertical. Unclear what it's calculating.
|
||||
fracA = -radSqDiff / (2.0f * DOTXZ(ptAToPtB, cylToPtA));
|
||||
sideIntA = 1;
|
||||
sideIntB = 0;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (phi_a2 == 1 && phi_a1 == 1) {
|
||||
sp6C[2].x = ((phi_f2 * spD4.x) + pointACylBottomDiff.x) + (f32)cyl->pos.x;
|
||||
sp6C[2].y = (((phi_f2 * spD4.y) + pointACylBottomDiff.y) + (f32)cyl->pos.y) + (f32)cyl->yShift;
|
||||
sp6C[2].z = ((phi_f2 * spD4.z) + pointACylBottomDiff.z) + (f32)cyl->pos.z;
|
||||
sp6C[2].x = ((spCC * spD4.x) + pointACylBottomDiff.x) + (f32)cyl->pos.x;
|
||||
sp6C[2].y = (((spCC * spD4.y) + pointACylBottomDiff.y) + (f32)cyl->pos.y) + (f32)cyl->yShift;
|
||||
sp6C[2].z = ((spCC * spD4.z) + pointACylBottomDiff.z) + (f32)cyl->pos.z;
|
||||
sp9C = (sp9C | 4) | 8;
|
||||
} else if (phi_a2 == 1) {
|
||||
sp6C[2].x = ((phi_f2 * spD4.x) + pointACylBottomDiff.x) + (f32)cyl->pos.x;
|
||||
sp6C[2].y = (((phi_f2 * spD4.y) + pointACylBottomDiff.y) + (f32)cyl->pos.y) + (f32)cyl->yShift;
|
||||
sp6C[2].z = ((phi_f2 * spD4.z) + pointACylBottomDiff.z) + (f32)cyl->pos.z;
|
||||
sp9C |= 4;
|
||||
} else if (phi_a1 == 1) {
|
||||
sp6C[2].x = ((spCC * spD4.x) + pointACylBottomDiff.x) + (f32)cyl->pos.x;
|
||||
sp6C[2].y = (((spCC * spD4.y) + pointACylBottomDiff.y) + (f32)cyl->pos.y) + (f32)cyl->yShift;
|
||||
sp6C[2].z = ((spCC * spD4.z) + pointACylBottomDiff.z) + (f32)cyl->pos.z;
|
||||
sp9C |= 4;
|
||||
// checks for intersection points outside the bounds of the segment
|
||||
if (!sideIntB) {
|
||||
if (fracA < 0.0f || 1.0f < fracA) {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
intBeyondA = fracA < 0.0f || 1.0f < fracA;
|
||||
intBeyondB = fracB < 0.0f || 1.0f < fracB;
|
||||
if (intBeyondA && intBeyondB) {
|
||||
return 0;
|
||||
}
|
||||
if (intBeyondA) {
|
||||
sideIntA = 0;
|
||||
}
|
||||
if (intBeyondB) {
|
||||
sideIntB = 0;
|
||||
}
|
||||
}
|
||||
// checks for intersection points outside the bounds of the cylinder
|
||||
if ((sideIntA == 1) &&
|
||||
((fracA * ptAToPtB.y + cylToPtA.y) < 0.0f || cyl->height < (fracA * ptAToPtB.y + cylToPtA.y))) {
|
||||
sideIntA = 0;
|
||||
}
|
||||
if ((sideIntB == 1) &&
|
||||
((fracB * ptAToPtB.y + cylToPtA.y) < 0.0f || cyl->height < (fracB * ptAToPtB.y + cylToPtA.y))) {
|
||||
sideIntB = 0;
|
||||
}
|
||||
if (sideIntA == 0 && sideIntB == 0) {
|
||||
return 0;
|
||||
}
|
||||
// Adds intersection points to intPts and sets side A and side B flags
|
||||
if (sideIntA == 1 && sideIntB == 1) {
|
||||
intPts[2].x = (fracA * ptAToPtB.x + cylToPtA.x) + cyl->pos.x;
|
||||
intPts[2].y = (fracA * ptAToPtB.y + cylToPtA.y) + cyl->pos.y + cyl->yShift;
|
||||
intPts[2].z = (fracA * ptAToPtB.z + cylToPtA.z) + cyl->pos.z;
|
||||
intFlags |= 4;
|
||||
intPts[3].x = (fracB * ptAToPtB.x + cylToPtA.x) + cyl->pos.x;
|
||||
intPts[3].y = (fracB * ptAToPtB.y + cylToPtA.y) + cyl->pos.y + cyl->yShift;
|
||||
intPts[3].z = (fracB * ptAToPtB.z + cylToPtA.z) + cyl->pos.z;
|
||||
intFlags |= 8;
|
||||
} else if (sideIntA == 1) {
|
||||
intPts[2].x = (fracA * ptAToPtB.x + cylToPtA.x) + cyl->pos.x;
|
||||
intPts[2].y = (fracA * ptAToPtB.y + cylToPtA.y) + cyl->pos.y + cyl->yShift;
|
||||
intPts[2].z = (fracA * ptAToPtB.z + cylToPtA.z) + cyl->pos.z;
|
||||
intFlags |= 4;
|
||||
} else if (sideIntB == 1) {
|
||||
intPts[2].x = (fracB * ptAToPtB.x + cylToPtA.x) + cyl->pos.x;
|
||||
intPts[2].y = (fracB * ptAToPtB.y + cylToPtA.y) + cyl->pos.y + cyl->yShift;
|
||||
intPts[2].z = (fracB * ptAToPtB.z + cylToPtA.z) + cyl->pos.z;
|
||||
intFlags |= 4;
|
||||
}
|
||||
|
||||
for (phi_v0_3 = 0, phi_v1_3 = 0; phi_v0_3 < 4; phi_v0_3++) {
|
||||
if (sp9C & (1 << phi_v0_3)) {
|
||||
if (phi_v1_3 == 0) {
|
||||
*intersectA = sp6C[phi_v0_3];
|
||||
} else if (phi_v1_3 == 1) {
|
||||
if (Math3D_Vec3fDistSq(intersectA, linePointA) < Math3D_Vec3fDistSq(intersectA, &sp6C[phi_v0_3])) {
|
||||
*intersectB = sp6C[phi_v0_3];
|
||||
/**
|
||||
* Places the found intersection points into intersectA and intersectB. IntersectA is always closer to point A
|
||||
*/
|
||||
for (count = 0, i = 0; i < 4; i++) {
|
||||
if (intFlags & (1 << i)) {
|
||||
if (count == 0) {
|
||||
*intersectA = intPts[i];
|
||||
} else if (count == 1) {
|
||||
if (Math3D_Vec3fDistSq(intersectA, linePointA) < Math3D_Vec3fDistSq(intersectA, &intPts[i])) {
|
||||
*intersectB = intPts[i];
|
||||
} else {
|
||||
*intersectB = *intersectA;
|
||||
*intersectA = sp6C[phi_v0_3];
|
||||
*intersectA = intPts[i];
|
||||
}
|
||||
break;
|
||||
}
|
||||
count++;
|
||||
}
|
||||
phi_v1_3++;
|
||||
}
|
||||
|
||||
return phi_v1_3;
|
||||
return count;
|
||||
}
|
||||
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/sys_math3d/Math3D_CylVsLineSeg.s")
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Determines if `cyl` and `tri` are touching. The point of intersection
|
||||
* is placed in `intersect` Returns 1 if they are touching, 0 otherwise.
|
||||
|
|
|
|||
|
|
@ -3160,9 +3160,6 @@ void func_80062E14(GlobalContext* globalCtx, Vec3f* v, Vec3f* arg2) {
|
|||
Audio_PlaySoundGeneral(NA_SE_IT_REFLECTION_WOOD, arg2, 4, &D_801333E0, &D_801333E0, &D_801333E8);
|
||||
}
|
||||
|
||||
#define SQXZ(vec) (SQ(vec.x) + SQ(vec.z))
|
||||
#define DOTXZ(vec1, vec2) ((vec1.x) * (vec2.x) + (vec1.z) * (vec2.z))
|
||||
|
||||
/*
|
||||
* Determines if the line segment connecting itemPos and itemProjPos intersects the side of a cylinder with the given
|
||||
* radius, height, and offset at actorPos. Returns 3 if either endpoint is inside the cylinder, otherwise returns the
|
||||
|
|
@ -3174,18 +3171,18 @@ s32 func_80062ECC(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* it
|
|||
Vec3f actorToItem;
|
||||
Vec3f actorToItemProj;
|
||||
Vec3f itemStep;
|
||||
f32 sp50;
|
||||
f32 sp4C;
|
||||
u32 phi_v0;
|
||||
u32 phi_v1;
|
||||
u32 phi_a1;
|
||||
u32 phi_a2;
|
||||
f32 sp38;
|
||||
f32 temp_f14;
|
||||
f32 temp_f2;
|
||||
f32 frac1;
|
||||
f32 frac2;
|
||||
u32 intersect2;
|
||||
u32 intersect1;
|
||||
u32 test1;
|
||||
u32 test2;
|
||||
f32 radSqDiff;
|
||||
f32 actorDotItemXZ;
|
||||
f32 zero = 0.0f;
|
||||
f32 temp_f0;
|
||||
f32 pad;
|
||||
f32 closeDist;
|
||||
s32 pad1;
|
||||
s32 pad2;
|
||||
|
||||
actorToItem.x = itemPos->x - actorPos->x;
|
||||
actorToItem.y = itemPos->y - actorPos->y - offset;
|
||||
|
|
@ -3199,54 +3196,51 @@ s32 func_80062ECC(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* it
|
|||
itemStep.y = actorToItemProj.y - actorToItem.y;
|
||||
itemStep.z = actorToItemProj.z - actorToItem.z;
|
||||
|
||||
if ((actorToItem.y > 0.0f) && (actorToItem.y < height) && (sqrtf(SQ(actorToItem.x) + SQ(actorToItem.z)) < radius)) {
|
||||
if ((actorToItem.y > 0.0f) && (actorToItem.y < height) && (sqrtf(SQXZ(actorToItem)) < radius)) {
|
||||
return 3;
|
||||
}
|
||||
|
||||
if ((actorToItemProj.y > 0.0f) && (actorToItemProj.y < height) &&
|
||||
(sqrtf(SQ(actorToItemProj.x) + SQ(actorToItemProj.z)) < radius)) {
|
||||
if ((actorToItemProj.y > 0.0f) && (actorToItemProj.y < height) && (sqrtf(SQXZ(actorToItemProj)) < radius)) {
|
||||
return 3;
|
||||
}
|
||||
sp38 = SQXZ(actorToItem) - SQ(radius);
|
||||
temp_f2 = SQXZ(itemStep);
|
||||
if (!IS_ZERO(temp_f2)) {
|
||||
temp_f14 = DOTXZ(2.0f * itemStep, actorToItem);
|
||||
if (SQ(temp_f14) < (4.0f * temp_f2) * sp38) {
|
||||
radSqDiff = SQXZ(actorToItem) - SQ(radius);
|
||||
if (!IS_ZERO(SQXZ(itemStep))) {
|
||||
actorDotItemXZ = DOTXZ(2.0f * itemStep, actorToItem);
|
||||
if (SQ(actorDotItemXZ) < (4.0f * SQXZ(itemStep) * radSqDiff)) {
|
||||
return 0;
|
||||
}
|
||||
if (SQ(temp_f14) - ((4.0f * temp_f2) * sp38) > zero) {
|
||||
phi_v1 = phi_v0 = 1;
|
||||
if (SQ(actorDotItemXZ) - (4.0f * SQXZ(itemStep) * radSqDiff) > zero) {
|
||||
intersect1 = intersect2 = 1;
|
||||
} else {
|
||||
phi_v1 = 1;
|
||||
phi_v0 = 0;
|
||||
intersect1 = 1;
|
||||
intersect2 = 0;
|
||||
}
|
||||
temp_f0 = sqrtf(SQ(temp_f14) - (4.0f * temp_f2) * sp38);
|
||||
if (phi_v1 == 1) {
|
||||
sp50 = (temp_f0 - temp_f14) / (2.0f * temp_f2);
|
||||
closeDist = sqrtf(SQ(actorDotItemXZ) - (4.0f * SQXZ(itemStep) * radSqDiff));
|
||||
if (intersect1 == 1) {
|
||||
frac1 = (closeDist - actorDotItemXZ) / (2.0f * SQXZ(itemStep));
|
||||
}
|
||||
if (phi_v0 == 1) {
|
||||
sp4C = (-temp_f14 - temp_f0) / (2.0f * temp_f2);
|
||||
if (intersect2 == 1) {
|
||||
frac2 = (-actorDotItemXZ - closeDist) / (2.0f * SQXZ(itemStep));
|
||||
}
|
||||
|
||||
} else if (!IS_ZERO(DOTXZ(2.0f * itemStep, actorToItem))) {
|
||||
phi_v1 = 1;
|
||||
phi_v0 = 0;
|
||||
sp50 = -sp38 / DOTXZ(2.0f * itemStep, actorToItem);
|
||||
intersect1 = 1;
|
||||
intersect2 = 0;
|
||||
frac1 = -radSqDiff / DOTXZ(2.0f * itemStep, actorToItem);
|
||||
} else {
|
||||
if (sp38 <= 0.0f) {
|
||||
phi_a1 = (0.0f < actorToItem.y) && (actorToItem.y < height);
|
||||
phi_a2 = (0.0f < actorToItemProj.y) && (actorToItemProj.y < height);
|
||||
if (radSqDiff <= 0.0f) {
|
||||
test1 = (0.0f < actorToItem.y) && (actorToItem.y < height);
|
||||
test2 = (0.0f < actorToItemProj.y) && (actorToItemProj.y < height);
|
||||
|
||||
if (phi_a1 && phi_a2) {
|
||||
if (test1 && test2) {
|
||||
*out1 = actorToItem;
|
||||
*out2 = actorToItemProj;
|
||||
return 2;
|
||||
}
|
||||
if (phi_a1) {
|
||||
if (test1) {
|
||||
*out1 = actorToItem;
|
||||
return 1;
|
||||
}
|
||||
if (phi_a2) {
|
||||
if (test2) {
|
||||
*out1 = actorToItemProj;
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -3254,58 +3248,57 @@ s32 func_80062ECC(f32 radius, f32 height, f32 offset, Vec3f* actorPos, Vec3f* it
|
|||
return 0;
|
||||
}
|
||||
|
||||
if (phi_v0 == 0) {
|
||||
if (sp50 < 0.0f || 1.0f < sp50) {
|
||||
if (intersect2 == 0) {
|
||||
if (frac1 < 0.0f || 1.0f < frac1) {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
phi_a1 = (sp50 < 0.0f || 1.0f < sp50);
|
||||
phi_a2 = (sp4C < 0.0f || 1.0f < sp4C);
|
||||
test1 = (frac1 < 0.0f || 1.0f < frac1);
|
||||
test2 = (frac2 < 0.0f || 1.0f < frac2);
|
||||
|
||||
if (phi_a1 && phi_a2) {
|
||||
if (test1 && test2) {
|
||||
return 0;
|
||||
}
|
||||
if (phi_a1) {
|
||||
phi_v1 = 0;
|
||||
if (test1) {
|
||||
intersect1 = 0;
|
||||
}
|
||||
if (phi_a2) {
|
||||
phi_v0 = 0;
|
||||
if (test2) {
|
||||
intersect2 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if ((phi_v1 == 1) && ((sp50 * itemStep.y + actorToItem.y < 0.0f) || (height < sp50 * itemStep.y + actorToItem.y))) {
|
||||
phi_v1 = 0;
|
||||
if ((intersect1 == 1) &&
|
||||
((frac1 * itemStep.y + actorToItem.y < 0.0f) || (height < frac1 * itemStep.y + actorToItem.y))) {
|
||||
intersect1 = 0;
|
||||
}
|
||||
if ((phi_v0 == 1) && ((sp4C * itemStep.y + actorToItem.y < 0.0f) || (height < sp4C * itemStep.y + actorToItem.y))) {
|
||||
phi_v0 = 0;
|
||||
if ((intersect2 == 1) &&
|
||||
((frac2 * itemStep.y + actorToItem.y < 0.0f) || (height < frac2 * itemStep.y + actorToItem.y))) {
|
||||
intersect2 = 0;
|
||||
}
|
||||
if (phi_v1 == 0 && phi_v0 == 0) {
|
||||
if (intersect1 == 0 && intersect2 == 0) {
|
||||
return 0;
|
||||
} else if ((phi_v1 == 1) && (phi_v0 == 1)) {
|
||||
out1->x = sp50 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = sp50 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = sp50 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
out2->x = sp4C * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out2->y = sp4C * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out2->z = sp4C * itemStep.z + actorToItem.z + actorPos->z;
|
||||
} else if ((intersect1 == 1) && (intersect2 == 1)) {
|
||||
out1->x = frac1 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = frac1 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = frac1 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
out2->x = frac2 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out2->y = frac2 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out2->z = frac2 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
return 2;
|
||||
} else if (phi_v1 == 1) {
|
||||
out1->x = sp50 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = sp50 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = sp50 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
} else if (intersect1 == 1) {
|
||||
out1->x = frac1 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = frac1 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = frac1 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
return 1;
|
||||
} else if (phi_v0 == 1) {
|
||||
out1->x = sp4C * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = sp4C * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = sp4C * itemStep.z + actorToItem.z + actorPos->z;
|
||||
} else if (intersect2 == 1) {
|
||||
out1->x = frac2 * itemStep.x + actorToItem.x + actorPos->x;
|
||||
out1->y = frac2 * itemStep.y + actorToItem.y + actorPos->y;
|
||||
out1->z = frac2 * itemStep.z + actorToItem.z + actorPos->z;
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
#undef SQXZ
|
||||
#undef DOTXZ
|
||||
|
||||
s32 func_800635D0(s32 arg0) {
|
||||
s32 result;
|
||||
|
||||
|
|
|
|||
|
|
@ -286,13 +286,11 @@ void func_8001DFC8(EnItem00* this, GlobalContext* globalCtx) {
|
|||
} else {
|
||||
if ((this->actor.params >= ITEM00_SHIELD_DEKU) && (this->actor.params != ITEM00_BOMBS_SPECIAL)) {
|
||||
if (this->unk_15A == -1) {
|
||||
if (!Math_SmoothStepToS(&this->actor.shape.rot.x, this->actor.posRot.rot.x - 0x4000, 2, 3000,
|
||||
1500)) {
|
||||
if (!Math_SmoothStepToS(&this->actor.shape.rot.x, this->actor.posRot.rot.x - 0x4000, 2, 3000, 1500)) {
|
||||
this->unk_15A = -2;
|
||||
}
|
||||
} else {
|
||||
if (!Math_SmoothStepToS(&this->actor.shape.rot.x, -this->actor.posRot.rot.x - 0x4000, 2, 3000,
|
||||
1500)) {
|
||||
if (!Math_SmoothStepToS(&this->actor.shape.rot.x, -this->actor.posRot.rot.x - 0x4000, 2, 3000, 1500)) {
|
||||
this->unk_15A = -1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -175,7 +175,7 @@ s32 Math_StepUntilF(f32* pValue, f32 limit, f32 step) {
|
|||
* Changes pValue toward target by incrStep if pValue is smaller and by decrStep if it is greater, setting it equal when
|
||||
* target is reached. Returns true when target is reached, false otherwise.
|
||||
*/
|
||||
s32 Math_AymStepToF(f32* pValue, f32 target, f32 incrStep, f32 decrStep) {
|
||||
s32 Math_AsymStepToF(f32* pValue, f32 target, f32 incrStep, f32 decrStep) {
|
||||
f32 step = (target >= *pValue) ? incrStep : decrStep;
|
||||
|
||||
if (step != 0.0f) {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue