mirror of
https://github.com/projectPiki/pikmin2.git
synced 2025-02-25 08:11:26 +00:00
Scaffold more gameMapParts, rework Sys structs
This commit is contained in:
HeartPiece
parent
f69f40e6e0
commit
7a01d2de46
@ -88,19 +88,19 @@
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/dynCreature.cpp">dynCreature.cpp</a> | 25215 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gameDynamics.cpp">gameDynamics.cpp</a> | 25558 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemPikihead.cpp">itemPikihead.cpp</a> | 26530 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/vsCardMgr.cpp">vsCardMgr.cpp</a> | 30652 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/singleGS_MainGame.cpp">singleGS_MainGame.cpp</a> | 31879 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemBridge.cpp">itemBridge.cpp</a> | 32134 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemGate.cpp">itemGate.cpp</a> | 32754 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gamePlayDataMemCard.cpp">gamePlayDataMemCard.cpp</a> | 36009 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemGate.cpp">itemGate.cpp</a> | 32798 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gamePlayDataMemCard.cpp">gamePlayDataMemCard.cpp</a> | 36009 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/piki.cpp">piki.cpp</a> | 36225 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/routeMgr.cpp">routeMgr.cpp</a> | 39098 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gameGeneratorCache.cpp">gameGeneratorCache.cpp</a> | 40204 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/collinfo.cpp">collinfo.cpp</a> | 43410 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/mapMgr.cpp">mapMgr.cpp</a> | 44302 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/pikiMgr.cpp">pikiMgr.cpp</a> | 47897 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/mapMgr.cpp">mapMgr.cpp</a> | 44316 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/pikiMgr.cpp">pikiMgr.cpp</a> | 47897 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/aiFormation.cpp">aiFormation.cpp</a> | 52263 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/cellPyramid.cpp">cellPyramid.cpp</a> | 52507 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/singleGS_CaveGame.cpp">singleGS_CaveGame.cpp</a> | 52763 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/navi_demoCheck.cpp">navi_demoCheck.cpp</a> | 57727 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemWeed.cpp">itemWeed.cpp</a> | 62058 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/pelletState.cpp">pelletState.cpp</a> | 62948 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemUjamushi.cpp">itemUjamushi.cpp</a> | 63548 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/fakePiki.cpp">fakePiki.cpp</a> | 65612 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemUjamushi.cpp">itemUjamushi.cpp</a> | 63548 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/fakePiki.cpp">fakePiki.cpp</a> | 65620 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gamePlayData.cpp">gamePlayData.cpp</a> | 66045 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/itemPlant.cpp">itemPlant.cpp</a> | 73150 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/baseGameSection.cpp">baseGameSection.cpp</a> | 91759 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/aiPrimitives.cpp">aiPrimitives.cpp</a> | 116997 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/pelletMgr.cpp">pelletMgr.cpp</a> | 142649 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/navi.cpp">navi.cpp</a> | 151194 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/pikiState.cpp">pikiState.cpp</a> | 153257 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/singleGS_Zukan.cpp">singleGS_Zukan.cpp</a> | 161342 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gameMapParts.cpp">gameMapParts.cpp</a> | 168069 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/naviState.cpp">naviState.cpp</a> | 181111 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/gameMapParts.cpp">gameMapParts.cpp</a> | 174234 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/plugProjectKandoU/naviState.cpp">naviState.cpp</a> | 181111 |
|
||||
|
||||
### <section id="plugProjectKonoU">plugProjectKonoU</section>
|
||||
| File | Size (bytes) | File | Size (bytes) |
|
||||
@ -179,10 +179,10 @@
|
||||
### <section id="sysCommonU">sysCommonU</section>
|
||||
| File | Size (bytes) | File | Size (bytes) |
|
||||
| ---- | ---- | ---- | ---- |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomCylinder.cpp">geomCylinder.cpp</a> | 8446 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomIntersection.cpp">geomIntersection.cpp</a> | 11431 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomTraceMove.cpp">geomTraceMove.cpp</a> | 18982 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/camera.cpp">camera.cpp</a> | 26810 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/sysMath.cpp">sysMath.cpp</a> | 30489 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomOBBTree.cpp">geomOBBTree.cpp</a> | 82287 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geometry.cpp">geometry.cpp</a> | 104686 | | |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomCylinder.cpp">geomCylinder.cpp</a> | 8376 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomIntersection.cpp">geomIntersection.cpp</a> | 11269 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomTraceMove.cpp">geomTraceMove.cpp</a> | 18982 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/camera.cpp">camera.cpp</a> | 26704 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/sysMath.cpp">sysMath.cpp</a> | 30400 | <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geomOBBTree.cpp">geomOBBTree.cpp</a> | 82125 |
|
||||
| <a href="https://github.com/projectPiki/pikmin2/tree/main/src/sysCommonU/geometry.cpp">geometry.cpp</a> | 104553 | | |
|
||||
|
||||
### <section id="sysGCU">sysGCU</section>
|
||||
| File | Size (bytes) | File | Size (bytes) |
|
||||
|
||||
@ -275,7 +275,7 @@ struct RoomMapMgr : public MapMgr {
|
||||
virtual void doSetView(int viewportNumber); // _58
|
||||
virtual void doViewCalc(); // _5C
|
||||
virtual Sys::TriIndexList* traceMove_new(MoveInfo&, f32); // _60
|
||||
virtual void traceMove_original(MoveInfo&, f32); // _64
|
||||
virtual Sys::TriIndexList* traceMove_original(MoveInfo&, f32); // _64
|
||||
|
||||
MapRoom* getMapRoom(s16 roomIdx);
|
||||
void createRandomMap(int floorNum, Cave::EditMapUnit* editInfo);
|
||||
|
||||
@ -5,32 +5,23 @@
|
||||
|
||||
struct Plane {
|
||||
Plane()
|
||||
: a(0.0f)
|
||||
, b(1.0f)
|
||||
, c(0.0f)
|
||||
, d(0.0f)
|
||||
: mNormal(0.0f, 1.0f, 0.0f)
|
||||
, mOffset(0.0f)
|
||||
{
|
||||
}
|
||||
|
||||
void read(Stream&);
|
||||
void write(Stream&);
|
||||
f32 calcDist(const Vector3f& vec) const { return (vec.x * a + vec.y * b + vec.z * c - d); }
|
||||
f32 calcDist(const Vector3f& vec) const { return (vec.x * mNormal.x + vec.y * mNormal.y + vec.z * mNormal.z - mOffset); }
|
||||
|
||||
inline void setVec(Plane& plane)
|
||||
{
|
||||
a = plane.a;
|
||||
b = plane.b;
|
||||
c = plane.c;
|
||||
}
|
||||
inline void setVec(Plane& plane) { mNormal = plane.mNormal; }
|
||||
|
||||
inline void setDist(Plane& plane) { d = plane.d; }
|
||||
inline void setDist(Plane& plane) { mOffset = plane.mOffset; }
|
||||
void calcProjection(Vector3f&);
|
||||
void intersectRay(Vector3f&, Vector3f&);
|
||||
|
||||
f32 a;
|
||||
f32 b;
|
||||
f32 c;
|
||||
f32 d;
|
||||
Vector3f mNormal; // _00
|
||||
f32 mOffset; // _0C
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@ -15,6 +15,8 @@ struct IndexList : public ArrayContainer<int> {
|
||||
{
|
||||
p1 = stream.readInt();
|
||||
}
|
||||
|
||||
inline int getIndex(int idx) { return mObjects[idx]; }
|
||||
};
|
||||
} // namespace Sys
|
||||
|
||||
|
||||
@ -71,22 +71,23 @@ struct OBB : public CNode {
|
||||
axisVec->y = mAxes[i].y;
|
||||
axisVec->z = mAxes[i].z;
|
||||
|
||||
Vector3f scaledVec = *axisVec * max;
|
||||
mSidePlanes[i].a = axisVec->x;
|
||||
mSidePlanes[i].b = axisVec->y;
|
||||
mSidePlanes[i].c = axisVec->z;
|
||||
mSidePlanes[i].d = mSidePlanes[i].a * (mPosition.x + scaledVec.x) + mSidePlanes[i].b * (mPosition.y + scaledVec.y)
|
||||
+ mSidePlanes[i].c * (mPosition.z + scaledVec.z);
|
||||
Vector3f scaledVec = *axisVec * max;
|
||||
mSidePlanes[i].mNormal.x = axisVec->x;
|
||||
mSidePlanes[i].mNormal.y = axisVec->y;
|
||||
mSidePlanes[i].mNormal.z = axisVec->z;
|
||||
mSidePlanes[i].mOffset = mSidePlanes[i].mNormal.x * (mPosition.x + scaledVec.x)
|
||||
+ mSidePlanes[i].mNormal.y * (mPosition.y + scaledVec.y)
|
||||
+ mSidePlanes[i].mNormal.z * (mPosition.z + scaledVec.z);
|
||||
}
|
||||
|
||||
inline void setMinPlane(int i)
|
||||
{
|
||||
mSidePlanes[i + 3].a = -mAxes[i].x;
|
||||
mSidePlanes[i + 3].b = -mAxes[i].y;
|
||||
mSidePlanes[i + 3].c = -mAxes[i].z;
|
||||
mSidePlanes[i + 3].d = mSidePlanes[i + 3].a * (mPosition.x + (-mAxes[i].x * mMinXYZ[i]))
|
||||
+ mSidePlanes[i + 3].b * (mPosition.y + (-mAxes[i].y * mMinXYZ[i]))
|
||||
+ mSidePlanes[i + 3].c * (mPosition.z + (-mAxes[i].z * mMinXYZ[i]));
|
||||
mSidePlanes[i + 3].mNormal.x = -mAxes[i].x;
|
||||
mSidePlanes[i + 3].mNormal.y = -mAxes[i].y;
|
||||
mSidePlanes[i + 3].mNormal.z = -mAxes[i].z;
|
||||
mSidePlanes[i + 3].mOffset = mSidePlanes[i + 3].mNormal.x * (mPosition.x + (-mAxes[i].x * mMinXYZ[i]))
|
||||
+ mSidePlanes[i + 3].mNormal.y * (mPosition.y + (-mAxes[i].y * mMinXYZ[i]))
|
||||
+ mSidePlanes[i + 3].mNormal.z * (mPosition.z + (-mAxes[i].z * mMinXYZ[i]));
|
||||
}
|
||||
|
||||
Plane mSidePlanes[6]; // _18
|
||||
|
||||
@ -59,7 +59,7 @@ struct Triangle {
|
||||
|
||||
static bool debug;
|
||||
|
||||
Vector3i mVertices; // _00, _04, _08 - addresses of each vertex in vertex table
|
||||
int mVertices[3]; // _00, _04, _08 - addresses of each vertex in vertex table
|
||||
Plane mTrianglePlane; // _0C - ax + by + cz + d form of plane triangle lies in
|
||||
Plane mEdgePlanes[3]; // _1C, _2C, _3C - plane through each side of triangle (?)
|
||||
Sphere mSphere; // _4C - bounding sphere of triangle
|
||||
|
||||
@ -18,9 +18,9 @@ struct TriangleTable : public ArrayContainer<Triangle> {
|
||||
virtual ~TriangleTable() { } // _08 (weak)
|
||||
virtual void writeObject(Stream& output, Triangle& triangle) // _2C (weak)
|
||||
{
|
||||
output.writeInt(triangle.mVertices.x);
|
||||
output.writeInt(triangle.mVertices.y);
|
||||
output.writeInt(triangle.mVertices.z);
|
||||
output.writeInt(triangle.mVertices[0]);
|
||||
output.writeInt(triangle.mVertices[1]);
|
||||
output.writeInt(triangle.mVertices[2]);
|
||||
|
||||
triangle.mTrianglePlane.write(output);
|
||||
triangle.mEdgePlanes[0].write(output);
|
||||
@ -29,9 +29,9 @@ struct TriangleTable : public ArrayContainer<Triangle> {
|
||||
}
|
||||
virtual void readObject(Stream& input, Triangle& triangle) // _30 (weak)
|
||||
{
|
||||
triangle.mVertices.x = input.readInt();
|
||||
triangle.mVertices.y = input.readInt();
|
||||
triangle.mVertices.z = input.readInt();
|
||||
triangle.mVertices[0] = input.readInt();
|
||||
triangle.mVertices[1] = input.readInt();
|
||||
triangle.mVertices[2] = input.readInt();
|
||||
triangle.mTrianglePlane.read(input);
|
||||
triangle.mEdgePlanes[0].read(input);
|
||||
triangle.mEdgePlanes[1].read(input);
|
||||
@ -46,8 +46,10 @@ struct TriangleTable : public ArrayContainer<Triangle> {
|
||||
Triangle* currTriangle = &mObjects[i];
|
||||
Triangle* refTriangle = &triTable->mObjects[i];
|
||||
|
||||
currTriangle->mVertices = refTriangle->mVertices;
|
||||
currTriangle->mCode = refTriangle->mCode;
|
||||
currTriangle->mVertices[0] = refTriangle->mVertices[0];
|
||||
currTriangle->mVertices[1] = refTriangle->mVertices[1];
|
||||
currTriangle->mVertices[2] = refTriangle->mVertices[2];
|
||||
currTriangle->mCode = refTriangle->mCode;
|
||||
currTriangle->makePlanes(*vtxTable);
|
||||
currTriangle->createSphere(*vtxTable);
|
||||
}
|
||||
@ -72,7 +74,13 @@ struct VertexTable : public ArrayContainer<Vector3f> {
|
||||
virtual void writeObject(Stream&, Vector3f&); // _2C
|
||||
virtual void readObject(Stream& input, Vector3f& vertex) { vertex.read(input); } // _30 (weak)
|
||||
virtual void write(Stream&); // _34
|
||||
virtual void addOne(Vector3f&); // _40 (weak)
|
||||
virtual void addOne(Vector3f& vert) // _40 (weak)
|
||||
{
|
||||
if (mCount < mLimit) {
|
||||
mObjects[mCount++] = vert;
|
||||
}
|
||||
mBoundBox.include(vert);
|
||||
}
|
||||
|
||||
void transform(Matrixf&);
|
||||
void cloneFrom(Matrixf&, VertexTable*);
|
||||
|
||||
@ -47,6 +47,9 @@ inline f32 normalise(Vector3f* a)
|
||||
}
|
||||
|
||||
// useful for planes, could be a plane method
|
||||
inline f32 planeDist(Vector3f& vec, Plane& plane) { return (vec.x * plane.a + vec.y * plane.b + vec.z * plane.c) - plane.d; }
|
||||
inline f32 planeDist(Vector3f& vec, Plane& plane)
|
||||
{
|
||||
return (vec.x * plane.mNormal.x + vec.y * plane.mNormal.y + vec.z * plane.mNormal.z) - plane.mOffset;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -1521,7 +1521,7 @@ void FakePiki::move(f32 rate)
|
||||
wallCallback(info.mReflectPosition);
|
||||
}
|
||||
|
||||
if (mBounceTriangle && mBounceTriangle->mTrianglePlane.b > 0.6f) {
|
||||
if (mBounceTriangle && mBounceTriangle->mTrianglePlane.mNormal.y > 0.6f) {
|
||||
mFakePikiBounceTriangle = mBounceTriangle;
|
||||
}
|
||||
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include "JSystem/JUtility/JUTTexture.h"
|
||||
#include "Dolphin/rand.h"
|
||||
#include "Sys/TriangleTable.h"
|
||||
#include "Sys/RayIntersectInfo.h"
|
||||
#include "VsOtakaraName.h"
|
||||
#include "nans.h"
|
||||
|
||||
@ -920,12 +921,10 @@ RoomMapMgr::RoomMapMgr(Cave::CaveInfo* info)
|
||||
mBoundbox.mMin = Vector3f(SHORT_FLOAT_MAX);
|
||||
mBoundbox.mMax = Vector3f(-SHORT_FLOAT_MAX);
|
||||
|
||||
mCaveInfo = info;
|
||||
mFloorInfo = nullptr;
|
||||
mSublevel = 0;
|
||||
mTriangle.mTrianglePlane.a = 0.0f;
|
||||
mTriangle.mTrianglePlane.b = 1.0f;
|
||||
mTriangle.mTrianglePlane.c = 0.0f;
|
||||
mCaveInfo = info;
|
||||
mFloorInfo = nullptr;
|
||||
mSublevel = 0;
|
||||
mTriangle.mTrianglePlane.mNormal = Vector3f(0.0f, 1.0f, 0.0f);
|
||||
|
||||
mWraith = nullptr;
|
||||
}
|
||||
@ -2648,8 +2647,56 @@ void RoomMapMgr::createGlobalCollision()
|
||||
triTable->addOne(tri);
|
||||
}
|
||||
|
||||
int count21 = 0;
|
||||
int count20 = 0;
|
||||
|
||||
Iterator<MapRoom> iterCreate(&mRoomMgr);
|
||||
CI_LOOP(iterCreate) { MapRoom* room = *iterCreate; }
|
||||
CI_LOOP(iterCreate)
|
||||
{
|
||||
MapRoom* room = *iterCreate;
|
||||
Matrixf& mtx = room->_0D8;
|
||||
Sys::VertexTable* verts = room->mUnit->mCollision.mDivider->mVertexTable; // r26
|
||||
Sys::TriangleTable* tris = room->mUnit->mCollision.mDivider->mTriangleTable; // r19
|
||||
for (int i = 0; i < verts->getNum(); i++) {
|
||||
Vector3f preVert = *verts->getVertex(i);
|
||||
Vector3f vert = mtx.mtxMult(preVert);
|
||||
vertTable->addOne(vert);
|
||||
count21++;
|
||||
}
|
||||
|
||||
for (int i = 0; i < tris->getNum(); i++) {
|
||||
Sys::Triangle* preTri = tris->getTriangle(i);
|
||||
Sys::Triangle* postTri = triTable->getTriangle(i);
|
||||
postTri->mVertices[0] = preTri->mVertices[0] + count20;
|
||||
postTri->mVertices[1] = preTri->mVertices[1] + count20;
|
||||
postTri->mVertices[2] = preTri->mVertices[2] + count20;
|
||||
postTri->mCode = preTri->mCode;
|
||||
postTri->makePlanes(*vertTable);
|
||||
postTri->createSphere(*vertTable);
|
||||
mRoomTriIndices[i] = room->mIndex;
|
||||
}
|
||||
count20 = count21;
|
||||
}
|
||||
|
||||
box = vertTable->mBoundBox;
|
||||
box.mMin = box.mMin - Vector3f(10.0f);
|
||||
box.mMax = box.mMax + Vector3f(10.0f);
|
||||
|
||||
mMapCollision = new MapCollision;
|
||||
mMapCollision->mDivider = new Sys::GridDivider;
|
||||
int countX = 48;
|
||||
int countZ = 48;
|
||||
|
||||
int altX = (f32)((int)absF(box.mMax.x - box.mMin.x)) / 64;
|
||||
int altZ = (f32)((int)absF(box.mMax.z - box.mMin.z)) / 64;
|
||||
if (altX < 48) {
|
||||
countX = altX;
|
||||
}
|
||||
|
||||
if (altZ < 48) {
|
||||
countZ = altZ;
|
||||
}
|
||||
static_cast<Sys::GridDivider*>(mMapCollision->mDivider)->create(box, countX, countZ, vertTable, triTable);
|
||||
|
||||
P2DEBUG("After: %d", JKRGetCurrentHeap()->getTotalFreeSize());
|
||||
/*
|
||||
@ -3378,8 +3425,58 @@ lbl_801BAB44:
|
||||
* @note Address: 0x801BAD60
|
||||
* @note Size: 0x328
|
||||
*/
|
||||
Sys::TriIndexList* RoomMapMgr::traceMove_new(MoveInfo&, f32)
|
||||
Sys::TriIndexList* RoomMapMgr::traceMove_new(MoveInfo& info, f32 step)
|
||||
{
|
||||
Vector3f* velocity = info.mVelocity; // r25
|
||||
Sys::Sphere* moveSphere = info.mMoveSphere; // r26
|
||||
Vector3f startPos = moveSphere->mPosition;
|
||||
moveSphere->mPosition = moveSphere->mPosition + *info.mVelocity * step;
|
||||
moveSphere->mPosition = moveSphere->mPosition;
|
||||
Sys::TriIndexList* triList = mMapCollision->mDivider->findTriLists(*moveSphere);
|
||||
|
||||
Sys::Sphere sphere44; // r29
|
||||
Sys::Sphere sphere34; // r28
|
||||
|
||||
Sys::VertexTable* vertTable = mMapCollision->mDivider->mVertexTable; // r23
|
||||
|
||||
for (triList; triList; triList = static_cast<Sys::TriIndexList*>(triList->mNext)) {
|
||||
for (int i = 0; i < triList->getNum(); i++) {
|
||||
int index = triList->getIndex(i);
|
||||
Sys::Triangle* tri = mMapCollision->mDivider->mTriangleTable->getTriangle(index);
|
||||
Sys::Triangle::SphereSweep sweep;
|
||||
sweep.mStartPos = startPos;
|
||||
sweep.mSphere = *moveSphere;
|
||||
if (info.mUseIntersectionAlgo) {
|
||||
sweep.mSweepType = Sys::Triangle::SphereSweep::ST_SphereIntersectPlane;
|
||||
}
|
||||
|
||||
if (tri->intersect(*vertTable, sweep)) {
|
||||
info.mRoomIndex = mRoomTriIndices[index];
|
||||
sphere34.mPosition = sphere34.mPosition;
|
||||
Vector3f old34 = sphere34.mPosition;
|
||||
if (info.mIntersectCallback) {
|
||||
info.mIntersectCallback->invoke(sphere44.mPosition, sphere34.mPosition);
|
||||
}
|
||||
|
||||
if (sphere34.mPosition.y >= info.mBounceThreshold) {
|
||||
info.mBounceTriangle = tri;
|
||||
info.mPosition = sphere34.mPosition;
|
||||
} else if (absF(sphere34.mPosition.y) <= info.mWallThreshold) {
|
||||
info.mWallTriangle = tri;
|
||||
info.mReflectPosition = sphere34.mPosition;
|
||||
}
|
||||
|
||||
f32 dotProd = sphere34.mPosition.dot(*velocity);
|
||||
dotProd = (1.0f + info.mTraceRadius) * dotProd;
|
||||
*velocity = *velocity - sphere34.mPosition * dotProd;
|
||||
moveSphere->mPosition = moveSphere->mPosition + old34 * sphere34.mRadius;
|
||||
}
|
||||
|
||||
Sys::Triangle::debug = false;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
/*
|
||||
stwu r1, -0xe0(r1)
|
||||
mflr r0
|
||||
@ -3609,8 +3706,65 @@ lbl_801BB038:
|
||||
* @note Address: 0x801BB088
|
||||
* @note Size: 0x740
|
||||
*/
|
||||
void RoomMapMgr::traceMove_original(MoveInfo&, f32)
|
||||
Sys::TriIndexList* RoomMapMgr::traceMove_original(MoveInfo& info, f32 step)
|
||||
{
|
||||
Iterator<MapRoom> iterRoom(&mRoomMgr);
|
||||
int count = 0;
|
||||
Vector3f* velocity = info.mVelocity;
|
||||
Sys::Sphere* moveSphere = info.mMoveSphere; // r19
|
||||
Vector3f startPos = moveSphere->mPosition;
|
||||
moveSphere->mPosition = moveSphere->mPosition + *info.mVelocity * step;
|
||||
CI_LOOP(iterRoom)
|
||||
{
|
||||
MapRoom* room = *iterRoom; // r31
|
||||
if (sqrDistanceXZ(room->mBoundingSphere.mPosition, moveSphere->mPosition)
|
||||
> SQUARE(room->mBoundingSphere.mRadius + moveSphere->mRadius)) {
|
||||
continue;
|
||||
}
|
||||
MapUnit* unit = room->mUnit;
|
||||
moveSphere->mPosition = room->_108.mtxMult(moveSphere->mPosition);
|
||||
|
||||
Sys::TriIndexList* triList = unit->mCollision.mDivider->findTriLists(*moveSphere); // r18
|
||||
|
||||
for (triList; triList && count < 8; triList = static_cast<Sys::TriIndexList*>(triList->mNext)) {
|
||||
Sys::VertexTable* vertTable = unit->mCollision.mDivider->mVertexTable;
|
||||
for (int i = 0; i < triList->getNum(); i++) {
|
||||
Sys::Triangle* tri = unit->mCollision.mDivider->mTriangleTable->getTriangle(triList->getIndex(i));
|
||||
|
||||
if ((info.mUseIntersectionAlgo) ? tri->intersectHard(*vertTable, *moveSphere, info.mBaseSpherePos)
|
||||
: tri->intersect(*vertTable, *moveSphere, info.mBaseSpherePos)) {
|
||||
info.mBaseSpherePos = room->_0D8.mtxMult(info.mBaseSpherePos);
|
||||
|
||||
Vector3f triNorm = tri->mTrianglePlane.mNormal;
|
||||
triNorm = room->_108.multTranspose(triNorm);
|
||||
if (info.mIntersectCallback) {
|
||||
info.mIntersectCallback->invoke(info.mBaseSpherePos, triNorm);
|
||||
}
|
||||
|
||||
if (count < 8) {
|
||||
JUT_ASSERTLINE(2856, count < 8, "siboudesu !\n");
|
||||
count++;
|
||||
}
|
||||
}
|
||||
Sys::Triangle::debug = false;
|
||||
}
|
||||
}
|
||||
|
||||
moveSphere->mPosition = room->_0D8.mtxMult(moveSphere->mPosition);
|
||||
}
|
||||
|
||||
if (count == 0) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int count2 = 0;
|
||||
for (int i = 0; i < count; i++) {
|
||||
count2++;
|
||||
}
|
||||
|
||||
if (count2 == 0) {
|
||||
return nullptr;
|
||||
}
|
||||
/*
|
||||
stwu r1, -0x150(r1)
|
||||
mflr r0
|
||||
@ -4143,8 +4297,18 @@ lbl_801BB7B4:
|
||||
* @note Address: 0x801BB7C8
|
||||
* @note Size: 0x4F0
|
||||
*/
|
||||
bool RoomMapMgr::findRayIntersection(Sys::RayIntersectInfo&)
|
||||
bool RoomMapMgr::findRayIntersection(Sys::RayIntersectInfo& info)
|
||||
{
|
||||
Iterator<MapRoom> iterRoom(&mRoomMgr);
|
||||
Vector3f intersectPos;
|
||||
bool result = false;
|
||||
CI_LOOP(iterRoom)
|
||||
{
|
||||
MapRoom* room = *iterRoom; // r29
|
||||
}
|
||||
|
||||
info.mIntersectPosition = intersectPos;
|
||||
return result;
|
||||
/*
|
||||
stwu r1, -0x160(r1)
|
||||
mflr r0
|
||||
@ -5051,8 +5215,23 @@ lbl_801BC490:
|
||||
* @note Address: 0x801BC4B4
|
||||
* @note Size: 0x460
|
||||
*/
|
||||
void RoomMapMgr::getCurrTri(CurrTriInfo&)
|
||||
void RoomMapMgr::getCurrTri(CurrTriInfo& info)
|
||||
{
|
||||
info.mMaxY = 328000.0f;
|
||||
Iterator<MapRoom> iterRoom(&mRoomMgr);
|
||||
CI_LOOP(iterRoom) { MapRoom* room = *iterRoom; }
|
||||
|
||||
if (mFloorInfo->hasHiddenCollision() && info.mMinY < 0.0f) {
|
||||
info.mMinY = 0.0f;
|
||||
info.mMaxY = 0.0f;
|
||||
info.mTriangle = &mTriangle;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!info.mTriangle) {
|
||||
info.mMaxY = 0.0f;
|
||||
info.mMinY = 0.0f;
|
||||
}
|
||||
/*
|
||||
stwu r1, -0x60(r1)
|
||||
mflr r0
|
||||
@ -5537,8 +5716,8 @@ void RoomMapMgr::makeOneRoom(f32 centreX, f32 centreY, f32 direction, char* unit
|
||||
|
||||
Door* door = mui->getDoor(wp->_76); // r22
|
||||
|
||||
Vector3f doorDirs[4] = { (Vector3f) { 1.0f, 0.0f, 0.0f }, (Vector3f) { 0.0f, 0.0f, 1.0f }, (Vector3f) { 0.0f, 0.0f, 0.0f },
|
||||
(Vector3f) { 0.0f, 1.0f, 0.0f } }; // 0x1B4
|
||||
Vector3f doorDirs[4] = { (Vector3f) { 0.0f, 0.0f, 1.0f }, (Vector3f) { 1.0f, 0.0f, 0.0f }, (Vector3f) { 0.0f, 0.0f, -1.0f },
|
||||
(Vector3f) { -1.0f, 0.0f, 0.0f } }; // 0x1B4
|
||||
|
||||
if (!aliveRoom) {
|
||||
P2ASSERTBOOLLINE(3480, wp->mIndex >= 0 && wp->mIndex < counter);
|
||||
|
||||
@ -447,31 +447,31 @@ void ItemGate::initPlanes()
|
||||
|
||||
Vector3f pos = getPosition();
|
||||
|
||||
Vector3f plane0vec = pos + (_270 * 20.0f);
|
||||
mPlanes[0].a = _270.x;
|
||||
mPlanes[0].b = _270.y;
|
||||
mPlanes[0].c = _270.z;
|
||||
mPlanes[0].d = _270.dot(plane0vec);
|
||||
Vector3f plane0vec = pos + (_270 * 20.0f);
|
||||
mPlanes[0].mNormal.x = _270.x;
|
||||
mPlanes[0].mNormal.y = _270.y;
|
||||
mPlanes[0].mNormal.z = _270.z;
|
||||
mPlanes[0].mOffset = _270.dot(plane0vec);
|
||||
|
||||
Vector3f vec2 = (-_270.x, -_270.y, _270.z);
|
||||
Vector3f plane1vec = pos + (vec2 * 20.0f);
|
||||
mPlanes[1].a = vec2.x;
|
||||
mPlanes[1].b = vec2.y;
|
||||
mPlanes[1].c = vec2.z;
|
||||
mPlanes[1].d = vec2.dot(plane1vec);
|
||||
Vector3f vec2 = (-_270.x, -_270.y, _270.z);
|
||||
Vector3f plane1vec = pos + (vec2 * 20.0f);
|
||||
mPlanes[1].mNormal.x = vec2.x;
|
||||
mPlanes[1].mNormal.y = vec2.y;
|
||||
mPlanes[1].mNormal.z = vec2.z;
|
||||
mPlanes[1].mOffset = vec2.dot(plane1vec);
|
||||
|
||||
Vector3f plane2vec = pos + (_264 * 76.5f);
|
||||
mPlanes[2].a = _264.x;
|
||||
mPlanes[2].b = _264.y;
|
||||
mPlanes[2].c = _264.z;
|
||||
mPlanes[2].d = _264.dot(plane2vec);
|
||||
Vector3f plane2vec = pos + (_264 * 76.5f);
|
||||
mPlanes[2].mNormal.x = _264.x;
|
||||
mPlanes[2].mNormal.y = _264.y;
|
||||
mPlanes[2].mNormal.z = _264.z;
|
||||
mPlanes[2].mOffset = _264.dot(plane2vec);
|
||||
|
||||
Vector3f vec3 = (-_264.x, -_264.y, _264.z);
|
||||
Vector3f plane3vec = pos + (vec3 * 76.5f);
|
||||
mPlanes[3].a = vec3.x;
|
||||
mPlanes[3].b = vec3.y;
|
||||
mPlanes[3].c = vec3.z;
|
||||
mPlanes[3].d = vec3.dot(plane3vec);
|
||||
Vector3f vec3 = (-_264.x, -_264.y, _264.z);
|
||||
Vector3f plane3vec = pos + (vec3 * 76.5f);
|
||||
mPlanes[3].mNormal.x = vec3.x;
|
||||
mPlanes[3].mNormal.y = vec3.y;
|
||||
mPlanes[3].mNormal.z = vec3.z;
|
||||
mPlanes[3].mOffset = vec3.dot(plane3vec);
|
||||
/*
|
||||
stwu r1, -0xb0(r1)
|
||||
mflr r0
|
||||
|
||||
@ -94,9 +94,9 @@ void TDispTriangleArray::draw(Graphics&)
|
||||
void TDispTriangle::store(Sys::Triangle& triangle, Sys::VertexTable& vertexTable, int index)
|
||||
{
|
||||
mSysTriangle = ▵
|
||||
mVertices[0] = vertexTable.mObjects[triangle.mVertices.x];
|
||||
mVertices[1] = vertexTable.mObjects[triangle.mVertices.y];
|
||||
mVertices[2] = vertexTable.mObjects[triangle.mVertices.z];
|
||||
mVertices[0] = vertexTable.mObjects[triangle.mVertices[0]];
|
||||
mVertices[1] = vertexTable.mObjects[triangle.mVertices[1]];
|
||||
mVertices[2] = vertexTable.mObjects[triangle.mVertices[2]];
|
||||
mFlags.clear();
|
||||
mFlags.typeView |= 1;
|
||||
mIndex = index;
|
||||
@ -110,9 +110,9 @@ void TDispTriangle::store(Sys::Triangle& triangle, Sys::VertexTable& vertexTable
|
||||
void TDispTriangle::store(Matrixf& mtx, Sys::Triangle& tri, Sys::VertexTable& vertTable, int index)
|
||||
{
|
||||
mSysTriangle = &tri;
|
||||
mVertices[0] = mtx.mtxMult(vertTable.mObjects[tri.mVertices.x]);
|
||||
mVertices[1] = mtx.mtxMult(vertTable.mObjects[tri.mVertices.y]);
|
||||
mVertices[2] = mtx.mtxMult(vertTable.mObjects[tri.mVertices.z]);
|
||||
mVertices[0] = mtx.mtxMult(vertTable.mObjects[tri.mVertices[0]]);
|
||||
mVertices[1] = mtx.mtxMult(vertTable.mObjects[tri.mVertices[1]]);
|
||||
mVertices[2] = mtx.mtxMult(vertTable.mObjects[tri.mVertices[2]]);
|
||||
mFlags.clear();
|
||||
mFlags.typeView |= 1;
|
||||
mIndex = index;
|
||||
@ -1678,7 +1678,7 @@ bool ShapeMapMgr::findRayIntersection(Sys::RayIntersectInfo& info)
|
||||
f32 sqrDist = interVec.sqrDistance(startPos);
|
||||
if (sqrDist < minDist) {
|
||||
outPos = interVec;
|
||||
info.mNormalY = tri->mTrianglePlane.b;
|
||||
info.mNormalY = tri->mTrianglePlane.mNormal.y;
|
||||
minDist = sqrDist;
|
||||
}
|
||||
}
|
||||
|
||||
@ -233,9 +233,9 @@ void Obj::getShadowParam(ShadowParam& param)
|
||||
|
||||
if (mBounceTriangle) {
|
||||
Plane* plane = &mBounceTriangle->mTrianglePlane;
|
||||
param.mBoundingSphere.mPosition.x = plane->a;
|
||||
param.mBoundingSphere.mPosition.y = plane->b;
|
||||
param.mBoundingSphere.mPosition.z = plane->c;
|
||||
param.mBoundingSphere.mPosition.x = plane->mNormal.x;
|
||||
param.mBoundingSphere.mPosition.y = plane->mNormal.y;
|
||||
param.mBoundingSphere.mPosition.z = plane->mNormal.z;
|
||||
} else {
|
||||
param.mBoundingSphere.mPosition = Vector3f(0.0f, 1.0f, 0.0f);
|
||||
}
|
||||
|
||||
@ -160,53 +160,45 @@ void CullFrustum::updatePlanes()
|
||||
|
||||
PSMTXRotAxisRad(outMat.mMatrix.mtxView, (Vec*)&row1, (PI - viewAngle));
|
||||
PSMTXMultVec(outMat.mMatrix.mtxView, (Vec*)&row2, &outVec);
|
||||
planeVec.x = outVec.x;
|
||||
planeVec.y = outVec.y;
|
||||
planeVec.z = outVec.z;
|
||||
mObjects[0].a = planeVec.x;
|
||||
mObjects[0].b = planeVec.y;
|
||||
mObjects[0].c = planeVec.z;
|
||||
dist = dot(planeVec, posVec);
|
||||
mObjects[0].d = dist;
|
||||
planeVec.x = outVec.x;
|
||||
planeVec.y = outVec.y;
|
||||
planeVec.z = outVec.z;
|
||||
mObjects[0].mNormal = planeVec;
|
||||
dist = dot(planeVec, posVec);
|
||||
mObjects[0].mOffset = dist;
|
||||
|
||||
Vec outVec1;
|
||||
Vector3f planeVec1;
|
||||
|
||||
PSMTXRotAxisRad(outMat.mMatrix.mtxView, (Vec*)&row1, viewAngle);
|
||||
PSMTXMultVec(outMat.mMatrix.mtxView, (Vec*)&row2, &outVec1);
|
||||
planeVec1.x = outVec1.x;
|
||||
planeVec1.y = outVec1.y;
|
||||
planeVec1.z = outVec1.z;
|
||||
mObjects[1].a = planeVec1.x;
|
||||
mObjects[1].b = planeVec1.y;
|
||||
mObjects[1].c = planeVec1.z;
|
||||
mObjects[1].d = dot(planeVec1, posVec);
|
||||
planeVec1.x = outVec1.x;
|
||||
planeVec1.y = outVec1.y;
|
||||
planeVec1.z = outVec1.z;
|
||||
mObjects[1].mNormal = planeVec1;
|
||||
mObjects[1].mOffset = dot(planeVec1, posVec);
|
||||
|
||||
Vec outVec2;
|
||||
Vector3f planeVec2;
|
||||
|
||||
PSMTXRotAxisRad(outMat.mMatrix.mtxView, (Vec*)&row1, -fovAngle);
|
||||
PSMTXMultVec(outMat.mMatrix.mtxView, (Vec*)&row2, &outVec2);
|
||||
planeVec2.x = outVec2.x;
|
||||
planeVec2.y = outVec2.y;
|
||||
planeVec2.z = outVec2.z;
|
||||
mObjects[2].a = planeVec2.x;
|
||||
mObjects[2].b = planeVec2.y;
|
||||
mObjects[2].c = planeVec2.z;
|
||||
mObjects[2].d = dot(planeVec2, posVec);
|
||||
planeVec2.x = outVec2.x;
|
||||
planeVec2.y = outVec2.y;
|
||||
planeVec2.z = outVec2.z;
|
||||
mObjects[2].mNormal = planeVec2;
|
||||
mObjects[2].mOffset = dot(planeVec2, posVec);
|
||||
|
||||
Vec outVec3;
|
||||
Vector3f planeVec3;
|
||||
|
||||
PSMTXRotAxisRad(outMat.mMatrix.mtxView, (Vec*)&row1, (PI + fovAngle));
|
||||
PSMTXMultVec(outMat.mMatrix.mtxView, (Vec*)&row2, &outVec3);
|
||||
planeVec3.x = outVec3.x;
|
||||
planeVec3.y = outVec3.y;
|
||||
planeVec3.z = outVec3.z;
|
||||
mObjects[3].a = planeVec3.x;
|
||||
mObjects[3].b = planeVec3.y;
|
||||
mObjects[3].c = planeVec3.z;
|
||||
mObjects[3].d = dot(planeVec3, posVec);
|
||||
planeVec3.x = outVec3.x;
|
||||
planeVec3.y = outVec3.y;
|
||||
planeVec3.z = outVec3.z;
|
||||
mObjects[3].mNormal = planeVec3;
|
||||
mObjects[3].mOffset = dot(planeVec3, posVec);
|
||||
/*
|
||||
stwu r1, -0xf0(r1)
|
||||
mflr r0
|
||||
@ -472,19 +464,15 @@ void Camera::updatePlanes()
|
||||
|
||||
Vector3f pos = getPosition();
|
||||
|
||||
mObjects[4].a = -zVec.x;
|
||||
mObjects[4].b = -zVec.y;
|
||||
mObjects[4].c = -zVec.z;
|
||||
Vector3f farPlaneVec(mObjects[4].a, mObjects[4].b, mObjects[4].c);
|
||||
Vector3f farVec = zVec * mProjectionFar + pos;
|
||||
mObjects[4].d = dot(farPlaneVec, farVec);
|
||||
mObjects[4].mNormal = Vector3f(-zVec.x, -zVec.y, -zVec.z);
|
||||
Vector3f farPlaneVec(mObjects[4].mNormal.x, mObjects[4].mNormal.y, mObjects[4].mNormal.z);
|
||||
Vector3f farVec = zVec * mProjectionFar + pos;
|
||||
mObjects[4].mOffset = dot(farPlaneVec, farVec);
|
||||
|
||||
mObjects[5].a = -zVec.x;
|
||||
mObjects[5].b = -zVec.y;
|
||||
mObjects[5].c = -zVec.z;
|
||||
Vector3f nearPlaneVec(mObjects[5].a, mObjects[5].b, mObjects[5].c);
|
||||
Vector3f nearVec = zVec * mProjectionNear + pos;
|
||||
mObjects[5].d = dot(nearPlaneVec, farVec);
|
||||
mObjects[5].mNormal = Vector3f(-zVec.x, -zVec.y, -zVec.z);
|
||||
Vector3f nearPlaneVec(mObjects[5].mNormal.x, mObjects[5].mNormal.y, mObjects[5].mNormal.z);
|
||||
Vector3f nearVec = zVec * mProjectionNear + pos;
|
||||
mObjects[5].mOffset = dot(nearPlaneVec, farVec);
|
||||
/*
|
||||
stwu r1, -0x70(r1)
|
||||
mflr r0
|
||||
|
||||
@ -67,7 +67,7 @@ bool Cylinder::culled(Plane const& inputPlane)
|
||||
Vector3f lowerVec = mCenter - scaledAxis;
|
||||
Vector3f upperVec = mCenter + scaledAxis;
|
||||
|
||||
Vector3f planeVec(inputPlane.a, inputPlane.b, inputPlane.c);
|
||||
Vector3f planeVec(inputPlane.mNormal);
|
||||
f32 dotPlane = dot(mAxis, planeVec);
|
||||
f32 scaledRadius = mRadius * pikmin2_sqrtf(-((dotPlane * dotPlane) - 1.0f));
|
||||
|
||||
@ -202,7 +202,7 @@ bool Cylinder::intersect(Triangle const& triangle, f32& p2)
|
||||
|
||||
Vector3f scaledAxis = mAxis * (0.5f * mLength);
|
||||
|
||||
Vector3f planeVec(triangle.mTrianglePlane.a, triangle.mTrianglePlane.b, triangle.mTrianglePlane.c);
|
||||
Vector3f planeVec(triangle.mTrianglePlane.mNormal);
|
||||
f32 dotPlane = dot(mAxis, planeVec);
|
||||
|
||||
Vector3f lowerVec = mCenter - scaledAxis;
|
||||
|
||||
@ -48,9 +48,7 @@ bool Triangle::intersect(Sys::VertexTable& vtxTable, Sys::Triangle::SphereSweep&
|
||||
|
||||
bool isIntersect = intersect(edge_intersect, sweep.mSphere.mRadius, *intersectPoint, sweep.mDistanceFromRadius);
|
||||
if (isIntersect) {
|
||||
sweep.mNormal.x = mTrianglePlane.a;
|
||||
sweep.mNormal.y = mTrianglePlane.b;
|
||||
sweep.mNormal.z = mTrianglePlane.c;
|
||||
sweep.mNormal = mTrianglePlane.mNormal;
|
||||
}
|
||||
return isIntersect;
|
||||
}
|
||||
@ -61,9 +59,7 @@ bool Triangle::intersect(Sys::VertexTable& vtxTable, Sys::Triangle::SphereSweep&
|
||||
}
|
||||
|
||||
if ((edgeDists[0] <= 0.0f) && (edgeDists[1] <= 0.0f) && (edgeDists[2] <= 0.0f)) {
|
||||
sweep.mNormal.x = mTrianglePlane.a;
|
||||
sweep.mNormal.y = mTrianglePlane.b;
|
||||
sweep.mNormal.z = mTrianglePlane.c;
|
||||
sweep.mNormal = mTrianglePlane.mNormal;
|
||||
sweep.mDistanceFromRadius = sweep.mSphere.mRadius - distSweep;
|
||||
|
||||
Vector3f new_norm = sweep.mNormal * sweep.mSphere.mRadius;
|
||||
@ -75,8 +71,8 @@ bool Triangle::intersect(Sys::VertexTable& vtxTable, Sys::Triangle::SphereSweep&
|
||||
Edge edge_in;
|
||||
f32 t; // sp8
|
||||
|
||||
int vertA = mVertices.x;
|
||||
int vertB = mVertices.y;
|
||||
int vertA = mVertices[0];
|
||||
int vertB = mVertices[1];
|
||||
edge_in.mStartPos = vtxTable.mObjects[vertA]; // sp28, 2C, 30
|
||||
edge_in.mEndPos = vtxTable.mObjects[vertB]; // sp34, 38, 3C
|
||||
// = vert_A;
|
||||
@ -88,8 +84,8 @@ bool Triangle::intersect(Sys::VertexTable& vtxTable, Sys::Triangle::SphereSweep&
|
||||
return true;
|
||||
}
|
||||
|
||||
vertA = mVertices.y;
|
||||
vertB = mVertices.z;
|
||||
vertA = mVertices[1];
|
||||
vertB = mVertices[2];
|
||||
edge_in.mStartPos = vtxTable.mObjects[vertA]; // sp28, 2C, 30
|
||||
edge_in.mEndPos = vtxTable.mObjects[vertB]; // sp34, 38, 3C
|
||||
|
||||
@ -99,8 +95,8 @@ bool Triangle::intersect(Sys::VertexTable& vtxTable, Sys::Triangle::SphereSweep&
|
||||
return true;
|
||||
}
|
||||
|
||||
vertA = mVertices.z;
|
||||
vertB = mVertices.x;
|
||||
vertA = mVertices[2];
|
||||
vertB = mVertices[0];
|
||||
edge_in.mStartPos = vtxTable.mObjects[vertA]; // sp28, 2C, 30
|
||||
edge_in.mEndPos = vtxTable.mObjects[vertB]; // sp34, 38, 3C
|
||||
|
||||
|
||||
@ -1003,11 +1003,11 @@ void OBB::determineDivPlane(Sys::VertexTable& vertTable, Sys::TriangleTable& tri
|
||||
int numAbove = 0;
|
||||
int numBelow = 0;
|
||||
|
||||
Vector3f* currAxis = &mAxes[i];
|
||||
currPlane.a = currAxis->x;
|
||||
currPlane.b = currAxis->y;
|
||||
currPlane.c = currAxis->z;
|
||||
currPlane.d = dot(*currAxis, mPosition);
|
||||
Vector3f* currAxis = &mAxes[i];
|
||||
currPlane.mNormal.x = currAxis->x;
|
||||
currPlane.mNormal.y = currAxis->y;
|
||||
currPlane.mNormal.z = currAxis->z;
|
||||
currPlane.mOffset = dot(*currAxis, mPosition);
|
||||
|
||||
// loop through all triangles
|
||||
for (int j = 0; j < mTriIndexList.mCount; j++) {
|
||||
@ -1038,10 +1038,8 @@ void OBB::determineDivPlane(Sys::VertexTable& vertTable, Sys::TriangleTable& tri
|
||||
|
||||
Vector3f correctAxis = mAxes[axisID];
|
||||
// divPlane has normal = axis with min cuts, and goes through center/position of box
|
||||
mDivPlane.a = correctAxis.x;
|
||||
mDivPlane.b = correctAxis.y;
|
||||
mDivPlane.c = correctAxis.z;
|
||||
mDivPlane.d = dot(correctAxis, mPosition);
|
||||
mDivPlane.mNormal = correctAxis;
|
||||
mDivPlane.mOffset = dot(correctAxis, mPosition);
|
||||
/*
|
||||
stwu r1, -0x80(r1)
|
||||
mflr r0
|
||||
@ -1591,12 +1589,13 @@ void OBB::getCurrTri(Game::CurrTriInfo& info)
|
||||
}
|
||||
|
||||
f32 dist;
|
||||
if (mDivPlane.b == 0.0f) {
|
||||
if (mDivPlane.mNormal.y == 0.0f) {
|
||||
dist = mDivPlane.calcDist(info.mPosition);
|
||||
} else {
|
||||
Vector3f vec = info.mPosition;
|
||||
vec.y = (mDivPlane.d - (mDivPlane.a * info.mPosition.x) - (mDivPlane.c * info.mPosition.z)) / mDivPlane.b;
|
||||
dist = mDivPlane.calcDist(vec);
|
||||
vec.y = (mDivPlane.mOffset - (mDivPlane.mNormal.x * info.mPosition.x) - (mDivPlane.mNormal.z * info.mPosition.z))
|
||||
/ mDivPlane.mNormal.y;
|
||||
dist = mDivPlane.calcDist(vec);
|
||||
}
|
||||
|
||||
if (dist > 0.01f) {
|
||||
@ -1631,9 +1630,7 @@ void OBB::getCurrTriTriList(Game::CurrTriInfo& info)
|
||||
info.mMaxY = position.y;
|
||||
|
||||
if (info.mUpdateOnNewMaxY) {
|
||||
info.mNormalVec.x = currTri->mTrianglePlane.a;
|
||||
info.mNormalVec.y = currTri->mTrianglePlane.b;
|
||||
info.mNormalVec.z = currTri->mTrianglePlane.c;
|
||||
info.mNormalVec = currTri->mTrianglePlane.mNormal;
|
||||
info.mTriangle = currTri;
|
||||
info.mGetFullInfo = true;
|
||||
}
|
||||
@ -1644,9 +1641,7 @@ void OBB::getCurrTriTriList(Game::CurrTriInfo& info)
|
||||
info.mMinY = position.y;
|
||||
|
||||
if (!info.mUpdateOnNewMaxY) {
|
||||
info.mNormalVec.x = currTri->mTrianglePlane.a;
|
||||
info.mNormalVec.y = currTri->mTrianglePlane.b;
|
||||
info.mNormalVec.z = currTri->mTrianglePlane.c;
|
||||
info.mNormalVec = currTri->mTrianglePlane.mNormal;
|
||||
info.mTriangle = currTri;
|
||||
info.mGetFullInfo = true;
|
||||
}
|
||||
@ -2546,7 +2541,7 @@ bool OBB::findRayIntersectionTriList(Sys::RayIntersectInfo& rayInfo, Matrixf& tr
|
||||
if (sqSep < rayInfo.mDistance) {
|
||||
rayInfo.mDistance = sqSep;
|
||||
rayInfo.mIntersectPosition = transformMtx.mtxMult(intersectVec);
|
||||
rayInfo.mNormalY = currTri->mTrianglePlane.b;
|
||||
rayInfo.mNormalY = currTri->mTrianglePlane.mNormal.y;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2762,13 +2757,13 @@ f32 OBB::getMinY(Vector3f& pos, Sys::TriangleTable& triTable, f32 inputMin)
|
||||
return getMinYTriList(pos, triTable);
|
||||
}
|
||||
|
||||
if (0.0f == mDivPlane.b) {
|
||||
if (0.0f == mDivPlane.mNormal.y) {
|
||||
divDist = mDivPlane.calcDist(pos);
|
||||
} else {
|
||||
Vector3f planeVec = pos;
|
||||
planeVec.y = -(mDivPlane.a * planeVec.x - mDivPlane.d);
|
||||
planeVec.y = -(mDivPlane.c * planeVec.z - planeVec.y);
|
||||
planeVec.y = planeVec.y / mDivPlane.b;
|
||||
planeVec.y = -(mDivPlane.mNormal.x * planeVec.x - mDivPlane.mOffset);
|
||||
planeVec.y = -(mDivPlane.mNormal.z * planeVec.z - planeVec.y);
|
||||
planeVec.y = planeVec.y / mDivPlane.mNormal.y;
|
||||
divDist = mDivPlane.calcDist(planeVec);
|
||||
}
|
||||
|
||||
|
||||
@ -653,16 +653,16 @@ void Triangle::createSphere(VertexTable& vertTable)
|
||||
f32 new_radius = 0.0f;
|
||||
|
||||
// get vertices of triangle
|
||||
Vector3f vert_3 = vertTable.mObjects[mVertices.z];
|
||||
Vector3f vert_2 = vertTable.mObjects[mVertices.y];
|
||||
Vector3f vert_1 = vertTable.mObjects[mVertices.x];
|
||||
Vector3f vert_3 = vertTable.mObjects[mVertices[2]];
|
||||
Vector3f vert_2 = vertTable.mObjects[mVertices[1]];
|
||||
Vector3f vert_1 = vertTable.mObjects[mVertices[0]];
|
||||
|
||||
// get center of triangle
|
||||
Vector3f center = (vert_1 + vert_2 + vert_3) * (f32)0x3EAAAAAB; // 0x3EAAAAAB = 1/3
|
||||
|
||||
// make sure radius includes all vertices
|
||||
for (int i = 0; i < 3; i++) {
|
||||
int* vertPtr = &mVertices.x;
|
||||
int* vertPtr = mVertices;
|
||||
Vector3f currVtx = (vertTable.mObjects[vertPtr[i]]);
|
||||
|
||||
f32 vtxDist = lenVec(currVtx - center);
|
||||
@ -740,9 +740,9 @@ f32 Sys::Triangle::calcDist(Plane& plane, Sys::VertexTable& vertTable)
|
||||
// but if triangle is completely 'below' plane, returns furthest point instead
|
||||
|
||||
// get triangle vertices from VertexTable vertTable
|
||||
Vector3f vert_1 = vertTable.mObjects[mVertices.x];
|
||||
Vector3f vert_2 = vertTable.mObjects[mVertices.y];
|
||||
Vector3f vert_3 = vertTable.mObjects[mVertices.z];
|
||||
Vector3f vert_1 = vertTable.mObjects[mVertices[0]];
|
||||
Vector3f vert_2 = vertTable.mObjects[mVertices[1]];
|
||||
Vector3f vert_3 = vertTable.mObjects[mVertices[2]];
|
||||
|
||||
// calculate distance from plane to each vertex (can be negative)
|
||||
f32 vertDist_1 = planeDist(vert_1, plane);
|
||||
@ -806,7 +806,7 @@ bool Triangle::intersect(Edge& edge, f32 cutoff, Vector3f& intersectionPoint)
|
||||
Vector3f edgeVec(edge.mEndPos.x - edge.mStartPos.x, edge.mEndPos.y - edge.mStartPos.y, edge.mEndPos.z - edge.mStartPos.z);
|
||||
f32 edgeLen = lenVec(edgeVec);
|
||||
|
||||
Vector3f triPlaneNormal(mTrianglePlane.a, mTrianglePlane.b, mTrianglePlane.c);
|
||||
Vector3f triPlaneNormal(mTrianglePlane.mNormal);
|
||||
|
||||
f32 scalarProj = dot(triPlaneNormal, edgeVec);
|
||||
|
||||
@ -825,13 +825,13 @@ bool Triangle::intersect(Edge& edge, f32 cutoff, Vector3f& intersectionPoint)
|
||||
// check each edge plane of triangle
|
||||
for (int i = 0; i < 3; i++) {
|
||||
// project normal onto edge
|
||||
Vector3f edgePlaneNormal(mEdgePlanes[i].a, mEdgePlanes[i].b, mEdgePlanes[i].c);
|
||||
Vector3f edgePlaneNormal(mEdgePlanes[i].mNormal);
|
||||
f32 edgePlaneProj = dot(edgePlaneNormal, edgeVec);
|
||||
|
||||
// check that projection isn't vanishingly small
|
||||
if (FABS(edgePlaneProj) > 0.01f) {
|
||||
// check we have an intersection point
|
||||
f32 edgePlaneRatio = (mEdgePlanes[i].d - dot(edgePlaneNormal, edge.mStartPos)) / edgePlaneProj;
|
||||
f32 edgePlaneRatio = (mEdgePlanes[i].mOffset - dot(edgePlaneNormal, edge.mStartPos)) / edgePlaneProj;
|
||||
if ((edgePlaneRatio > -ratio) && (edgePlaneRatio < (1 + ratio))) {
|
||||
// get intersection point
|
||||
Vector3f projVec = edgeVec * edgePlaneRatio;
|
||||
@ -853,7 +853,7 @@ bool Triangle::intersect(Edge& edge, f32 cutoff, Vector3f& intersectionPoint)
|
||||
|
||||
// edge not (close to) perpendicular, can just check triangle plane itself
|
||||
// check if we have an intersection point
|
||||
f32 triPlaneRatio = (mTrianglePlane.d - dot(triPlaneNormal, edge.mStartPos)) / scalarProj;
|
||||
f32 triPlaneRatio = (mTrianglePlane.mOffset - dot(triPlaneNormal, edge.mStartPos)) / scalarProj;
|
||||
if ((triPlaneRatio < -ratio) || (triPlaneRatio > (1 + ratio))) {
|
||||
// we don't
|
||||
return false;
|
||||
@ -887,7 +887,7 @@ bool Sys::Triangle::intersect(Sys::Edge& edge, f32 cutoff, Vector3f& intersectio
|
||||
Vector3f edgeVec(edge.mEndPos.x - edge.mStartPos.x, edge.mEndPos.y - edge.mStartPos.y, edge.mEndPos.z - edge.mStartPos.z);
|
||||
f32 edgeLen = lenVec(edgeVec);
|
||||
|
||||
Vector3f triPlaneNormal(mTrianglePlane.a, mTrianglePlane.b, mTrianglePlane.c);
|
||||
Vector3f triPlaneNormal(mTrianglePlane.mNormal);
|
||||
|
||||
f32 scalarProj = dot(triPlaneNormal, edgeVec);
|
||||
|
||||
@ -906,13 +906,13 @@ bool Sys::Triangle::intersect(Sys::Edge& edge, f32 cutoff, Vector3f& intersectio
|
||||
// check each edge plane of triangle
|
||||
for (int i = 0; i < 3; i++) {
|
||||
// project normal onto edge
|
||||
Vector3f edgePlaneNormal(mEdgePlanes[i].a, mEdgePlanes[i].b, mEdgePlanes[i].c);
|
||||
Vector3f edgePlaneNormal(mEdgePlanes[i].mNormal);
|
||||
f32 edgePlaneProj = dot(edgePlaneNormal, edgeVec);
|
||||
|
||||
// check that projection isn't vanishingly small
|
||||
if (FABS(edgePlaneProj) > 0.01f) {
|
||||
// check we have an intersection point
|
||||
f32 edgePlaneRatio = (mEdgePlanes[i].d - dot(edgePlaneNormal, edge.mStartPos)) / edgePlaneProj;
|
||||
f32 edgePlaneRatio = (mEdgePlanes[i].mOffset - dot(edgePlaneNormal, edge.mStartPos)) / edgePlaneProj;
|
||||
if ((edgePlaneRatio > -ratio) && (edgePlaneRatio < (1 + ratio))) {
|
||||
// get intersection point
|
||||
Vector3f projVec = edgeVec * edgePlaneRatio;
|
||||
@ -936,7 +936,7 @@ bool Sys::Triangle::intersect(Sys::Edge& edge, f32 cutoff, Vector3f& intersectio
|
||||
|
||||
// edge not (close to) perpendicular, can just check triangle plane itself
|
||||
// check if we have an intersection point
|
||||
f32 triPlaneRatio = (mTrianglePlane.d - dot(triPlaneNormal, edge.mStartPos)) / scalarProj;
|
||||
f32 triPlaneRatio = (mTrianglePlane.mOffset - dot(triPlaneNormal, edge.mStartPos)) / scalarProj;
|
||||
if ((triPlaneRatio < -ratio) || (triPlaneRatio > (1 + ratio))) {
|
||||
// we don't
|
||||
return false;
|
||||
@ -988,8 +988,8 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball)
|
||||
|
||||
// check for intersection with each edge in turn
|
||||
// REGSWAP START
|
||||
int vert_1 = mVertices.x;
|
||||
int vert_2 = mVertices.y;
|
||||
int vert_1 = mVertices[0];
|
||||
int vert_2 = mVertices[1];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -997,8 +997,8 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball)
|
||||
return true;
|
||||
}
|
||||
|
||||
vert_1 = mVertices.y;
|
||||
vert_2 = mVertices.z;
|
||||
vert_1 = mVertices[1];
|
||||
vert_2 = mVertices[2];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1006,8 +1006,8 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball)
|
||||
return true;
|
||||
}
|
||||
|
||||
vert_1 = mVertices.z;
|
||||
vert_2 = mVertices.x;
|
||||
vert_1 = mVertices[2];
|
||||
vert_2 = mVertices[0];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1242,20 +1242,23 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vector3
|
||||
|
||||
// this is wrong/suspicious
|
||||
// but should get all the distances?? from sphere to triangle? maybe?
|
||||
f32 triPlaneDist = (mTrianglePlane.a * ball.mPosition.x + mTrianglePlane.b * ball.mPosition.y + mTrianglePlane.c * ball.mPosition.z)
|
||||
- mTrianglePlane.d;
|
||||
Vector3f triPlaneNormal(mTrianglePlane.a, mTrianglePlane.b, mTrianglePlane.c);
|
||||
f32 triPlaneDist = (mTrianglePlane.mNormal.x * ball.mPosition.x + mTrianglePlane.mNormal.y * ball.mPosition.y
|
||||
+ mTrianglePlane.mNormal.z * ball.mPosition.z)
|
||||
- mTrianglePlane.mOffset;
|
||||
Vector3f triPlaneNormal(mTrianglePlane.mNormal);
|
||||
Vector3f sepVec = ball.mPosition - triPlaneNormal * triPlaneDist;
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
f32 edgePlaneDist = (sepVec.x * mEdgePlanes[i].a + sepVec.y * mEdgePlanes[i].b + sepVec.z * mEdgePlanes[i].c) - mEdgePlanes[i].d;
|
||||
ballDists[i] = edgePlaneDist;
|
||||
f32 edgePlaneDist
|
||||
= (sepVec.x * mEdgePlanes[i].mNormal.x + sepVec.y * mEdgePlanes[i].mNormal.y + sepVec.z * mEdgePlanes[i].mNormal.z)
|
||||
- mEdgePlanes[i].mOffset;
|
||||
ballDists[i] = edgePlaneDist;
|
||||
}
|
||||
// end wrong/suspicious
|
||||
|
||||
// check for intersection with each edge in turn
|
||||
int vert_1 = mVertices.x;
|
||||
int vert_2 = mVertices.y;
|
||||
int vert_1 = mVertices[0];
|
||||
int vert_2 = mVertices[1];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1263,8 +1266,8 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vector3
|
||||
return true;
|
||||
}
|
||||
|
||||
vert_1 = mVertices.y;
|
||||
vert_2 = mVertices.z;
|
||||
vert_1 = mVertices[1];
|
||||
vert_2 = mVertices[2];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1272,8 +1275,8 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vector3
|
||||
return true;
|
||||
}
|
||||
|
||||
vert_1 = mVertices.z;
|
||||
vert_2 = mVertices.x;
|
||||
vert_1 = mVertices[2];
|
||||
vert_2 = mVertices[0];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1289,7 +1292,7 @@ bool Triangle::intersect(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vector3
|
||||
}
|
||||
|
||||
// get normal to plane scaled by ball radius??
|
||||
triPlaneNormal = Vector3f(mTrianglePlane.a, mTrianglePlane.b, mTrianglePlane.c);
|
||||
triPlaneNormal = Vector3f(mTrianglePlane.mNormal);
|
||||
Vector3f radNorm = triPlaneNormal * ball.mRadius;
|
||||
|
||||
// calc outputs
|
||||
@ -1539,8 +1542,8 @@ bool Triangle::intersectHard(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vec
|
||||
// check for intersection with each edge in turn
|
||||
// REGSWAP START
|
||||
// A-B
|
||||
int vert_1 = mVertices.x;
|
||||
int vert_2 = mVertices.y;
|
||||
int vert_1 = mVertices[0];
|
||||
int vert_2 = mVertices[1];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1549,8 +1552,8 @@ bool Triangle::intersectHard(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vec
|
||||
}
|
||||
|
||||
// B-C
|
||||
vert_1 = mVertices.y;
|
||||
vert_2 = mVertices.z;
|
||||
vert_1 = mVertices[1];
|
||||
vert_2 = mVertices[2];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1559,8 +1562,8 @@ bool Triangle::intersectHard(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vec
|
||||
}
|
||||
|
||||
// C-A
|
||||
vert_1 = mVertices.z;
|
||||
vert_2 = mVertices.x;
|
||||
vert_1 = mVertices[2];
|
||||
vert_2 = mVertices[0];
|
||||
edge.mStartPos = *vertTable.getVertex(vert_1);
|
||||
edge.mEndPos = *vertTable.getVertex(vert_2);
|
||||
|
||||
@ -1577,7 +1580,7 @@ bool Triangle::intersectHard(Sys::VertexTable& vertTable, Sys::Sphere& ball, Vec
|
||||
}
|
||||
|
||||
// get normal to plane scaled by ball radius??
|
||||
Vector3f triPlaneNormal(mTrianglePlane.a, mTrianglePlane.b, mTrianglePlane.c);
|
||||
Vector3f triPlaneNormal(mTrianglePlane.mNormal);
|
||||
Vector3f radNorm = triPlaneNormal * ball.mRadius;
|
||||
|
||||
// calc outputs
|
||||
@ -1819,12 +1822,13 @@ bool Triangle::insideXZ(Vector3f& point)
|
||||
|
||||
// make sure plane of triangle is "pointing up"; if not, false
|
||||
// only want to deal with correctly oriented triangles?
|
||||
if (mTrianglePlane.b <= 0.0f) {
|
||||
if (mTrianglePlane.mNormal.y <= 0.0f) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// adjust y such that 'point' lies on the same plane as triangle
|
||||
point.y = (mTrianglePlane.d - ((mTrianglePlane.a * point.x) + (mTrianglePlane.c * point.z))) / mTrianglePlane.b;
|
||||
point.y = (mTrianglePlane.mOffset - ((mTrianglePlane.mNormal.x * point.x) + (mTrianglePlane.mNormal.z * point.z)))
|
||||
/ mTrianglePlane.mNormal.y;
|
||||
|
||||
// check if point is 'inside' triangle (negative side of each tangent plane), or on an edge
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
@ -1848,9 +1852,9 @@ void Triangle::makePlanes(Sys::VertexTable& vertTable)
|
||||
Vector3f edgeNormal;
|
||||
Vector3f* edgeNormalPtr = &edgeNormal;
|
||||
|
||||
Vector3f vert_A = *vertTable.getVertex(mVertices.x);
|
||||
Vector3f vert_B = *vertTable.getVertex(mVertices.y);
|
||||
Vector3f vert_C = *vertTable.getVertex(mVertices.z);
|
||||
Vector3f vert_A = *vertTable.getVertex(mVertices[0]);
|
||||
Vector3f vert_B = *vertTable.getVertex(mVertices[1]);
|
||||
Vector3f vert_C = *vertTable.getVertex(mVertices[2]);
|
||||
|
||||
Vector3f BA = vert_B - vert_A;
|
||||
Vector3f CA = vert_C - vert_A;
|
||||
@ -1867,11 +1871,10 @@ void Triangle::makePlanes(Sys::VertexTable& vertTable)
|
||||
}
|
||||
|
||||
// define trianglePlane using unit normal and point A
|
||||
Vector3f triPlaneVec = triNormal;
|
||||
mTrianglePlane.a = triPlaneVec.x;
|
||||
mTrianglePlane.b = triPlaneVec.y;
|
||||
mTrianglePlane.c = triPlaneVec.z;
|
||||
mTrianglePlane.d = mTrianglePlane.a * vert_A.x + mTrianglePlane.b * vert_A.y + mTrianglePlane.c * vert_A.z;
|
||||
Vector3f triPlaneVec = triNormal;
|
||||
mTrianglePlane.mNormal = triPlaneVec;
|
||||
mTrianglePlane.mOffset
|
||||
= mTrianglePlane.mNormal.x * vert_A.x + mTrianglePlane.mNormal.y * vert_A.y + mTrianglePlane.mNormal.z * vert_A.z;
|
||||
|
||||
// EDGE PLANES
|
||||
// AB
|
||||
@ -1886,10 +1889,9 @@ void Triangle::makePlanes(Sys::VertexTable& vertTable)
|
||||
edgeNormal.z *= norm_edgeNormal0;
|
||||
}
|
||||
// define AB edge plane using unit normal and point A
|
||||
mEdgePlanes[0].a = edgeNormal.x;
|
||||
mEdgePlanes[0].b = edgeNormal.y;
|
||||
mEdgePlanes[0].c = edgeNormal.z;
|
||||
mEdgePlanes[0].d = mEdgePlanes[0].a * vert_A.x + mEdgePlanes[0].b * vert_A.y + mEdgePlanes[0].c * vert_A.z;
|
||||
mEdgePlanes[0].mNormal = edgeNormal;
|
||||
mEdgePlanes[0].mOffset
|
||||
= mEdgePlanes[0].mNormal.x * vert_A.x + mEdgePlanes[0].mNormal.y * vert_A.y + mEdgePlanes[0].mNormal.z * vert_A.z;
|
||||
|
||||
// BC
|
||||
// get unit normal to BC edge plane
|
||||
@ -1904,10 +1906,9 @@ void Triangle::makePlanes(Sys::VertexTable& vertTable)
|
||||
}
|
||||
|
||||
// define BC edge plane using unit normal and point B
|
||||
mEdgePlanes[1].a = edgeNormal.x;
|
||||
mEdgePlanes[1].b = edgeNormal.y;
|
||||
mEdgePlanes[1].c = edgeNormal.z;
|
||||
mEdgePlanes[1].d = mEdgePlanes[1].a * vert_B.x + mEdgePlanes[1].b * vert_B.y + mEdgePlanes[1].c * vert_B.z;
|
||||
mEdgePlanes[1].mNormal = edgeNormal;
|
||||
mEdgePlanes[1].mOffset
|
||||
= mEdgePlanes[1].mNormal.x * vert_B.x + mEdgePlanes[1].mNormal.y * vert_B.y + mEdgePlanes[1].mNormal.z * vert_B.z;
|
||||
|
||||
// CA
|
||||
// get unit normal to CA edge plane
|
||||
@ -1921,10 +1922,9 @@ void Triangle::makePlanes(Sys::VertexTable& vertTable)
|
||||
}
|
||||
|
||||
// define CA edge plane using unit normal and point C
|
||||
mEdgePlanes[2].a = edgeNormal.x;
|
||||
mEdgePlanes[2].b = edgeNormal.y;
|
||||
mEdgePlanes[2].c = edgeNormal.z;
|
||||
mEdgePlanes[2].d = mEdgePlanes[2].a * vert_C.x + mEdgePlanes[2].b * vert_C.y + mEdgePlanes[2].c * vert_C.z;
|
||||
mEdgePlanes[2].mNormal = edgeNormal;
|
||||
mEdgePlanes[2].mOffset
|
||||
= mEdgePlanes[2].mNormal.x * vert_C.x + mEdgePlanes[2].mNormal.y * vert_C.y + mEdgePlanes[2].mNormal.z * vert_C.z;
|
||||
/*
|
||||
stwu r1, -0x140(r1)
|
||||
mflr r0
|
||||
@ -2250,7 +2250,7 @@ lbl_8041806C:
|
||||
bool RayIntersectInfo::condition(Sys::Triangle& triangle)
|
||||
{
|
||||
if (mCheckHorizontal) {
|
||||
if ((triangle.mTrianglePlane.b < 0.5f) && (triangle.mTrianglePlane.b > -0.1f)) {
|
||||
if ((triangle.mTrianglePlane.mNormal.y < 0.5f) && (triangle.mTrianglePlane.mNormal.y > -0.1f)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -2290,9 +2290,9 @@ void GridDivider::createTriangles(Sys::CreateTriangleArg& triArg)
|
||||
bool currTriTest = false;
|
||||
|
||||
testTri = mTriangleTable->getTriangle(triList->mObjects[triCtr]);
|
||||
Vector3f vert_A = *mVertexTable->getVertex(testTri->mVertices.x);
|
||||
Vector3f vert_B = *mVertexTable->getVertex(testTri->mVertices.y);
|
||||
Vector3f vert_C = *mVertexTable->getVertex(testTri->mVertices.z);
|
||||
Vector3f vert_A = *mVertexTable->getVertex(testTri->mVertices[0]);
|
||||
Vector3f vert_B = *mVertexTable->getVertex(testTri->mVertices[1]);
|
||||
Vector3f vert_C = *mVertexTable->getVertex(testTri->mVertices[2]);
|
||||
|
||||
int var_ctr = numTri;
|
||||
if (numTri > 0) {
|
||||
@ -2305,14 +2305,14 @@ void GridDivider::createTriangles(Sys::CreateTriangleArg& triArg)
|
||||
} while (var_ctr != 0);
|
||||
}
|
||||
if ((currTriTest == 0) && (numTri < 128)) {
|
||||
f32 triNorm_y = testTri->mTrianglePlane.b; // temp_f11
|
||||
f32 triNorm_y = testTri->mTrianglePlane.mNormal.y; // temp_f11
|
||||
if (triNorm_y > triArg._14) {
|
||||
f32 scaleFactor = triArg._10;
|
||||
numTri += 1;
|
||||
*triPtr1 = *testTri;
|
||||
triPtr1 += 4;
|
||||
Vector3f testVec(testTri->mTrianglePlane.a * scaleFactor, triNorm_y * scaleFactor,
|
||||
testTri->mTrianglePlane.c * scaleFactor);
|
||||
Vector3f testVec(testTri->mTrianglePlane.mNormal.x * scaleFactor, triNorm_y * scaleFactor,
|
||||
testTri->mTrianglePlane.mNormal.z * scaleFactor);
|
||||
vertexArray[3 * triCtr + 0] = vert_A + testVec;
|
||||
vertexArray[3 * triCtr + 1] = vert_B + testVec;
|
||||
vertexArray[3 * triCtr + 2] = vert_C + testVec;
|
||||
@ -2649,22 +2649,27 @@ f32 GridDivider::getMinY(Vector3f& inputPoint)
|
||||
|
||||
for (int triCtr = 0; triCtr < triList->getNum(); triCtr++) {
|
||||
testTri = mTriangleTable->getTriangle(triList->mObjects[triCtr]);
|
||||
f32 triNorm_y = testTri->mTrianglePlane.b;
|
||||
f32 triNorm_y = testTri->mTrianglePlane.mNormal.y;
|
||||
bool insideTriTest;
|
||||
|
||||
if (triNorm_y <= 0.0f) {
|
||||
insideTriTest = false;
|
||||
} else {
|
||||
insideTriTest = false;
|
||||
y_val = (testTri->mTrianglePlane.d - ((testTri->mTrianglePlane.a * x_in) + (testTri->mTrianglePlane.c * z_in))) / triNorm_y;
|
||||
if (!(((x_in * testTri->mEdgePlanes[0].a + y_val * testTri->mEdgePlanes[0].b + z_in * testTri->mEdgePlanes[0].c)
|
||||
- testTri->mEdgePlanes[0].d)
|
||||
y_val = (testTri->mTrianglePlane.mOffset
|
||||
- ((testTri->mTrianglePlane.mNormal.x * x_in) + (testTri->mTrianglePlane.mNormal.z * z_in)))
|
||||
/ triNorm_y;
|
||||
if (!(((x_in * testTri->mEdgePlanes[0].mNormal.x + y_val * testTri->mEdgePlanes[0].mNormal.y
|
||||
+ z_in * testTri->mEdgePlanes[0].mNormal.z)
|
||||
- testTri->mEdgePlanes[0].mOffset)
|
||||
> 0.0f)
|
||||
&& !(((x_in * testTri->mEdgePlanes[1].a + y_val * testTri->mEdgePlanes[1].b + z_in * testTri->mEdgePlanes[1].c)
|
||||
- testTri->mEdgePlanes[1].d)
|
||||
&& !(((x_in * testTri->mEdgePlanes[1].mNormal.x + y_val * testTri->mEdgePlanes[1].mNormal.y
|
||||
+ z_in * testTri->mEdgePlanes[1].mNormal.z)
|
||||
- testTri->mEdgePlanes[1].mOffset)
|
||||
> 0.0f)
|
||||
&& !(((x_in * testTri->mEdgePlanes[2].a + y_val * testTri->mEdgePlanes[2].b + z_in * testTri->mEdgePlanes[2].c)
|
||||
- testTri->mEdgePlanes[2].d)
|
||||
&& !(((x_in * testTri->mEdgePlanes[2].mNormal.x + y_val * testTri->mEdgePlanes[2].mNormal.y
|
||||
+ z_in * testTri->mEdgePlanes[2].mNormal.z)
|
||||
- testTri->mEdgePlanes[2].mOffset)
|
||||
> 0.0f)) {
|
||||
insideTriTest = true;
|
||||
}
|
||||
@ -2859,28 +2864,24 @@ void GridDivider::getCurrTri(Game::CurrTriInfo& inputInfo)
|
||||
|
||||
for (int triCtr = 0; triCtr < triList->getNum(); triCtr++) {
|
||||
testTri = mTriangleTable->getTriangle(triList->mObjects[triCtr]);
|
||||
f32 triNorm_y = testTri->mTrianglePlane.b;
|
||||
f32 triNorm_y = testTri->mTrianglePlane.mNormal.y;
|
||||
Vector3f tempPoint(x_in, y_val, z_in);
|
||||
if (testTri->insideXZ(tempPoint)) {
|
||||
if (min_y > y_val) {
|
||||
min_y = y_val;
|
||||
if (inputInfo.mUpdateOnNewMaxY != 0) {
|
||||
yTest = true;
|
||||
inputInfo.mNormalVec.x = testTri->mTrianglePlane.a;
|
||||
inputInfo.mNormalVec.y = testTri->mTrianglePlane.b;
|
||||
inputInfo.mNormalVec.z = testTri->mTrianglePlane.c;
|
||||
inputInfo.mTriangle = testTri;
|
||||
yTest = true;
|
||||
inputInfo.mNormalVec = testTri->mTrianglePlane.mNormal;
|
||||
inputInfo.mTriangle = testTri;
|
||||
}
|
||||
}
|
||||
|
||||
if (y_val > max_y) {
|
||||
max_y = y_val;
|
||||
if (inputInfo.mUpdateOnNewMaxY == 0) {
|
||||
yTest = true;
|
||||
inputInfo.mNormalVec.x = testTri->mTrianglePlane.a;
|
||||
inputInfo.mNormalVec.y = testTri->mTrianglePlane.b;
|
||||
inputInfo.mNormalVec.z = testTri->mTrianglePlane.c;
|
||||
inputInfo.mTriangle = testTri;
|
||||
yTest = true;
|
||||
inputInfo.mNormalVec = testTri->mTrianglePlane.mNormal;
|
||||
inputInfo.mTriangle = testTri;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -3790,9 +3791,9 @@ void TriIndexList::getMinMax(VertexTable& vertTable, TriangleTable& triTable, Ve
|
||||
for (int i = 0; i < mCount; i++) {
|
||||
Triangle* currTri = &triTable.mObjects[mObjects[i]];
|
||||
Vector3f vertices[3];
|
||||
vertices[0] = vertTable.mObjects[currTri->mVertices.x];
|
||||
vertices[1] = vertTable.mObjects[currTri->mVertices.y];
|
||||
vertices[2] = vertTable.mObjects[currTri->mVertices.z];
|
||||
vertices[0] = vertTable.mObjects[currTri->mVertices[0]];
|
||||
vertices[1] = vertTable.mObjects[currTri->mVertices[1]];
|
||||
vertices[2] = vertTable.mObjects[currTri->mVertices[2]];
|
||||
|
||||
for (int j = 0; j < 3; j++) {
|
||||
f32 testVal = dot(vec1, vertices[j] - vec2);
|
||||
@ -3832,9 +3833,9 @@ void TriIndexList::makeCovarianceMatrix(Sys::VertexTable& vertTable, Sys::Triang
|
||||
for (int i = count; i > 0; i--, vec_ctr++) {
|
||||
Triangle* currTri = triTable.getTriangle(mObjects[vec_ctr]);
|
||||
Vector3f* verts = vertTable.mObjects;
|
||||
Vector3f* vert_A = vertTable.getVertex(currTri->mVertices.x);
|
||||
Vector3f* vert_B = vertTable.getVertex(currTri->mVertices.y);
|
||||
Vector3f* vert_C = vertTable.getVertex(currTri->mVertices.z);
|
||||
Vector3f* vert_A = vertTable.getVertex(currTri->mVertices[0]);
|
||||
Vector3f* vert_B = vertTable.getVertex(currTri->mVertices[1]);
|
||||
Vector3f* vert_C = vertTable.getVertex(currTri->mVertices[2]);
|
||||
vec = vec + ((*vert_A + *vert_B) + *vert_C);
|
||||
}
|
||||
vec = vec * norm_const;
|
||||
@ -3866,9 +3867,9 @@ void TriIndexList::makeCovarianceMatrix(Sys::VertexTable& vertTable, Sys::Triang
|
||||
row = row_ptr[i];
|
||||
currTri = &triTable.mObjects[currTriAddr];
|
||||
Vector3f* verts = vertTable.mObjects;
|
||||
Vector3f* vert_B = &verts[currTri->mVertices.x];
|
||||
Vector3f* vert_A = &verts[currTri->mVertices.y];
|
||||
Vector3f* vert_C = &verts[currTri->mVertices.z];
|
||||
Vector3f* vert_B = &verts[currTri->mVertices[0]];
|
||||
Vector3f* vert_A = &verts[currTri->mVertices[1]];
|
||||
Vector3f* vert_C = &verts[currTri->mVertices[2]];
|
||||
|
||||
vec_14.x = vert_A->x;
|
||||
vec_14.y = vert_A->y;
|
||||
|
||||
@ -195,10 +195,8 @@ void Vector3f::write(Stream& stream)
|
||||
*/
|
||||
void Plane::write(Stream& stream)
|
||||
{
|
||||
stream.writeFloat(a);
|
||||
stream.writeFloat(b);
|
||||
stream.writeFloat(c);
|
||||
stream.writeFloat(d);
|
||||
mNormal.write(stream);
|
||||
stream.writeFloat(mOffset);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -207,10 +205,8 @@ void Plane::write(Stream& stream)
|
||||
*/
|
||||
void Plane::read(Stream& stream)
|
||||
{
|
||||
a = stream.readFloat();
|
||||
b = stream.readFloat();
|
||||
c = stream.readFloat();
|
||||
d = stream.readFloat();
|
||||
mNormal.read(stream);
|
||||
mOffset = stream.readFloat();
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user