c_cc_d work

include/SSystem/SComponent/c_m3d_g_cps.h

@@ -3,6 +3,7 @@
 
 #include "SSystem/SComponent/c_m3d.h"
 #include "SSystem/SComponent/c_m3d_g_lin.h"
+#include "SSystem/SComponent/c_m3d_g_tri.h"
 #include "global.h"
 
 struct cM3dGCpsS {
@@ -23,11 +24,10 @@ public:
         SetR(src.mRadius);
     }
     void SetCps(const cM3dGCps&);
-    bool Cross(cM3dGCps const* other, cXyz* xyz) const {
-        return cM3d_Cross_CpsCps(*this, *other, xyz);
-    }
+    bool Cross(cM3dGCps const* cps, cXyz* xyz) const { return cM3d_Cross_CpsCps(*this, *cps, xyz); }
     bool Cross(cM3dGCyl const* cyl, cXyz* xyz) const { return cM3d_Cross_CpsCyl(*this, *cyl, xyz); }
     bool Cross(cM3dGSph const* sph, cXyz* xyz) const { return cM3d_Cross_CpsSph(*this, *sph, xyz); }
+    bool Cross(cM3dGTri const& tri, cXyz* xyz) const { return cM3d_Cross_CpsTri(*this, tri, xyz); }
     void SetR(f32 r) { mRadius = r; }
 
 };  // Size = 0x20

include/SSystem/SComponent/c_m3d_g_cyl.h

@@ -42,13 +42,13 @@ public:
     bool cross(const cM3dGCyl*, cXyz*) const;
     bool cross(const cM3dGSph*, f32*) const;
     bool cross(const cM3dGCyl*, f32*) const;
+    bool Cross(const cM3dGCps* cps, cXyz* dst) const { return cM3d_Cross_CpsCyl(*cps, *this, dst); }
+    bool Cross(const cM3dGTri& tri, cXyz* dst) const { return cM3d_Cross_CylTri(this, &tri, dst); }
     const cXyz* GetCP() const { return &mCenter; }
     f32 GetR() const { return mRadius; }
     f32 GetH() const { return mHeight; }
     cXyz& GetC() { return mCenter; }
 
-    void Cross(const cM3dGCps*, cXyz*) const {}
-    void Cross(const cM3dGTri&, cXyz*) const {}
     void GetC() const {}
     void GetCP() {}
     void GetRP() {}

include/SSystem/SComponent/c_m3d_g_pla.h

@@ -41,7 +41,6 @@ public:
     void GetD() const {}
     void Set(const cM3dGPla*) {}
     void SetupFrom3Vtx(const Vec*, const Vec*, const Vec*) {}
-    cM3dGPla(const cM3dGPla&) {}
     cM3dGPla(const cXyz*, float) {}
     void cross(const cM3dGLin&, Vec&) const {}
     void getCrossYLessD(const Vec&, float*) const {}

include/SSystem/SComponent/c_m3d_g_sph.h

@@ -27,8 +27,14 @@ public:
         SetC(src.mCenter);
         SetR(src.mRadius);
     }
-    bool cross(const cM3dGSph*, cXyz*) const;
+    bool Cross(const cM3dGCps* cps, cXyz* dst) const {
+        return cM3d_Cross_CpsSph(*cps, *this, dst);
+    }
+    bool Cross(const cM3dGTri& tri, cXyz* dst) const {
+        return cM3d_Cross_SphTri(this, &tri, dst);
+    }
     bool cross(const cM3dGCyl*, cXyz*) const;
+    bool cross(const cM3dGSph*, cXyz*) const;
     bool cross(const cM3dGSph*, f32*) const;
     const cXyz& GetC() const { return mCenter; }
     const cXyz* GetCP() const { return &mCenter; }

include/SSystem/SComponent/c_m3d_g_tri.h

@@ -22,11 +22,14 @@ public:
 public:
     cM3dGTri() {}
     cM3dGTri(const Vec *pA, const Vec *pB, const Vec *pC);
-    bool cross(const cM3dGCyl*, Vec*) const;
 
-    bool cross(const cM3dGLin* line, Vec* vec, bool param_3, bool param_4) const {
-        return cM3d_Cross_LinTri(line, this, vec, param_3, param_4);
-    }
+    bool cross(const cM3dGCyl* cyl, Vec* out) const;
+
+    bool Cross(const cM3dGCps& cps, Vec* out) const { return cM3d_Cross_CpsTri(cps, *this, out); }
+    bool Cross(const cM3dGCyl& cyl, Vec* out) const { return cross(&cyl, out); }
+    bool Cross(const cM3dGSph& sph, Vec* out) const { return cM3d_Cross_SphTri(&sph, this, out); }
+    bool Cross(const cM3dGTri& tri, Vec* out) const { return cM3d_Cross_TriTri(tri, *this, out); }
+
     void Up(f32 dist) {
         Vec delta;
         PSVECScale(&mNormal, &delta, dist);
@@ -37,11 +40,6 @@ public:
     }
 
     // TODO
-    void Cross(const cM3dGCps&, Vec*) const {}
-    void Cross(const cM3dGCyl&, Vec*) const {}
-    void Cross(const cM3dGSph&, Vec*) const {}
-    void Cross(const cM3dGTri&, Vec*) const {}
-    cM3dGTri(const cM3dGTri&) {}
     void crossX(const Vec*, f32*) const {}
     void crossY(const Vec*) const {}
     void crossZ(const Vec*, f32*) const {}

src/SSystem/SComponent/c_cc_d.cpp

@@ -104,166 +104,321 @@ void cCcD_Obj::Set(const cCcD_SrcObj& src) {
 }
 
 /* 80241C98-80241D68       .text CrossAtTg__12cCcD_TriAttrCFRC12cCcD_CpsAttrP4cXyz */
-bool cCcD_TriAttr::CrossAtTg(const cCcD_CpsAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_TriAttr::CrossAtTg(const cCcD_CpsAttr& cps, cXyz* dst) const {
+    if (Cross(cps, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241D68-80241DA0       .text CrossAtTg__12cCcD_TriAttrCFRC12cCcD_CylAttrP4cXyz */
-bool cCcD_TriAttr::CrossAtTg(const cCcD_CylAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_TriAttr::CrossAtTg(const cCcD_CylAttr& cyl, cXyz* dst) const {
+    if (Cross(cyl, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241DA0-80241DDC       .text CrossAtTg__12cCcD_TriAttrCFRC12cCcD_SphAttrP4cXyz */
-bool cCcD_TriAttr::CrossAtTg(const cCcD_SphAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_TriAttr::CrossAtTg(const cCcD_SphAttr& sph, cXyz* dst) const {
+    if (Cross(sph, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241DDC-80241E14       .text CrossAtTg__12cCcD_TriAttrCFRC12cCcD_TriAttrP4cXyz */
-bool cCcD_TriAttr::CrossAtTg(const cCcD_TriAttr&, cXyz*) const {
+bool cCcD_TriAttr::CrossAtTg(const cCcD_TriAttr& tri, cXyz* dst) const {
     /* Nonmatching */
+    if (Cross(tri, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241E14-80241EC4       .text CalcAabBox__12cCcD_TriAttrFv */
 void cCcD_TriAttr::CalcAabBox() {
-    /* Nonmatching */
+    mAab.ClearForMinMax();
+    mAab.SetMinMax(mA);
+    mAab.SetMinMax(mB);
+    mAab.SetMinMax(mC);
 }
 
 /* 80241EC4-80241F60       .text GetNVec__12cCcD_TriAttrCFRC4cXyzP4cXyz */
-bool cCcD_TriAttr::GetNVec(const cXyz&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_TriAttr::GetNVec(const cXyz& vec, cXyz* dst) const {
+    f32 dot = mNormal.getDotProduct(vec);
+    if (mD + dot >= 0.0f) {
+        dst->set(mNormal);
+    } else {
+        dst->set(mNormal);
+        *dst *= -1.0f;
+    }
+    return true;
 }
 
 /* 80241F60-80241FA4       .text CrossAtTg__12cCcD_CpsAttrCFRC12cCcD_CpsAttrP4cXyz */
-bool cCcD_CpsAttr::CrossAtTg(const cCcD_CpsAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossAtTg(const cCcD_CpsAttr& cps, cXyz* dst) const {
+    if (Cross(&cps, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241FA4-80241FE8       .text CrossAtTg__12cCcD_CpsAttrCFRC12cCcD_CylAttrP4cXyz */
-bool cCcD_CpsAttr::CrossAtTg(const cCcD_CylAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossAtTg(const cCcD_CylAttr& cyl, cXyz* dst) const {
+    if (Cross(&cyl, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80241FE8-8024202C       .text CrossAtTg__12cCcD_CpsAttrCFRC12cCcD_SphAttrP4cXyz */
-bool cCcD_CpsAttr::CrossAtTg(const cCcD_SphAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossAtTg(const cCcD_SphAttr& sph, cXyz* dst) const {
+    if (Cross(&sph, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 8024202C-802420FC       .text CrossAtTg__12cCcD_CpsAttrCFRC12cCcD_TriAttrP4cXyz */
-bool cCcD_CpsAttr::CrossAtTg(const cCcD_TriAttr&, cXyz*) const {
+bool cCcD_CpsAttr::CrossAtTg(const cCcD_TriAttr& tri, cXyz* dst) const {
     /* Nonmatching */
+    if (Cross(tri, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 802420FC-8024214C       .text CrossCo__12cCcD_CpsAttrCFRC12cCcD_CpsAttrPf */
-bool cCcD_CpsAttr::CrossCo(const cCcD_CpsAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossCo(const cCcD_CpsAttr& cps, f32* dst) const {
+    *dst = 0.0f;
+    cXyz xyz;
+    if (Cross(&cps, &xyz)) 
+        return true;
+    else
+        return false;
 }
 
 /* 8024214C-8024219C       .text CrossCo__12cCcD_CpsAttrCFRC12cCcD_CylAttrPf */
-bool cCcD_CpsAttr::CrossCo(const cCcD_CylAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossCo(const cCcD_CylAttr& cyl, f32* dst) const {
+    *dst = 0.0f;
+    cXyz xyz;
+    if (Cross(&cyl, &xyz)) 
+        return true;
+    else
+        return false;
 }
 
 /* 8024219C-802421EC       .text CrossCo__12cCcD_CpsAttrCFRC12cCcD_SphAttrPf */
-bool cCcD_CpsAttr::CrossCo(const cCcD_SphAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CpsAttr::CrossCo(const cCcD_SphAttr& sph, f32* dst) const {
+    *dst = 0.0f;
+    cXyz xyz;
+    if (Cross(&sph, &xyz)) 
+        return true;
+    else
+        return false;
 }
 
 /* 802421EC-80242294       .text CalcAabBox__12cCcD_CpsAttrFv */
 void cCcD_CpsAttr::CalcAabBox() {
-    /* Nonmatching */
+    mAab.ClearForMinMax();
+    mAab.SetMinMax(GetStart());
+    mAab.SetMinMax(GetEnd());
+    f32 r = mRadius;
+    mAab.mMin.x -= r;
+    mAab.mMin.y -= r;
+    mAab.mMin.z -= r;
+    mAab.mMax.x += r;
+    mAab.mMax.y += r;
+    mAab.mMax.z += r;
 }
 
 /* 80242294-802423FC       .text GetNVec__12cCcD_CpsAttrCFRC4cXyzP4cXyz */
-bool cCcD_CpsAttr::GetNVec(const cXyz&, cXyz*) const {
+bool cCcD_CpsAttr::GetNVec(const cXyz& vec, cXyz* dst) const {
     /* Nonmatching */
+    cXyz lin;
+    VECSubtract(&mEnd, &mStart, &lin);
+    f32 len = lin.getDotProduct(lin);
+    if (cM3d_IsZero(len))
+        return false;
+
+    cXyz p0_v;
+    VECSubtract(&vec, &mEnd, &p0_v);
+    f32 dot = p0_v.getDotProduct(lin) / len;
+
+    cXyz pt;
+    if (dot < 0.0f) {
+        pt.set(mStart);
+    } else if (dot > 1.0f) {
+        pt.set(mEnd);
+    } else {
+        VECScale(&lin, &lin, dot);
+        VECAdd(&lin, &mStart, &pt);
+    }
+
+    VECSubtract(&vec, &pt, dst);
+    if (cM3d_IsZero(VECMag(dst))) {
+        dst->set(0.0f, 0.0f, 0.0f);
+        return false;
+    }
+
+    VECNormalize(dst, dst);
+    return true;
 }
 
 /* 802423FC-80242448       .text CrossAtTg__12cCcD_CylAttrCFRC12cCcD_CpsAttrP4cXyz */
-bool cCcD_CylAttr::CrossAtTg(const cCcD_CpsAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossAtTg(const cCcD_CpsAttr& cps, cXyz* dst) const {
+    if (Cross(&cps, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242448-8024248C       .text CrossAtTg__12cCcD_CylAttrCFRC12cCcD_CylAttrP4cXyz */
-bool cCcD_CylAttr::CrossAtTg(const cCcD_CylAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossAtTg(const cCcD_CylAttr& cyl, cXyz* dst) const {
+    if (cross(&cyl, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 8024248C-802424D0       .text CrossAtTg__12cCcD_CylAttrCFRC12cCcD_SphAttrP4cXyz */
-bool cCcD_CylAttr::CrossAtTg(const cCcD_SphAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossAtTg(const cCcD_SphAttr& sph, cXyz* dst) const {
+    if (cross(&sph, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 802424D0-80242508       .text CrossAtTg__12cCcD_CylAttrCFRC12cCcD_TriAttrP4cXyz */
-bool cCcD_CylAttr::CrossAtTg(const cCcD_TriAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossAtTg(const cCcD_TriAttr& tri, cXyz* dst) const {
+    if (Cross(tri, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242508-8024254C       .text CrossCo__12cCcD_CylAttrCFRC12cCcD_CylAttrPf */
-bool cCcD_CylAttr::CrossCo(const cCcD_CylAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossCo(const cCcD_CylAttr& cyl, f32* dst) const {
+    if (cross(&cyl, dst)) 
+        return true;
+    else
+        return false;
 }
 
 /* 8024254C-80242590       .text CrossCo__12cCcD_CylAttrCFRC12cCcD_SphAttrPf */
-bool cCcD_CylAttr::CrossCo(const cCcD_SphAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossCo(const cCcD_SphAttr& sph, f32* dst) const {
+    if (cross(&sph, dst)) 
+        return true;
+    else
+        return false;
 }
 
 /* 80242590-802425E8       .text CrossCo__12cCcD_CylAttrCFRC12cCcD_CpsAttrPf */
-bool cCcD_CylAttr::CrossCo(const cCcD_CpsAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_CylAttr::CrossCo(const cCcD_CpsAttr& cps, f32* dst) const {
+    *dst = 0.0f;
+    cXyz xyz;
+    if (Cross(&cps, &xyz)) 
+        return true;
+    else
+        return false;
 }
 
 /* 802425E8-8024264C       .text CalcAabBox__12cCcD_CylAttrFv */
 void cCcD_CylAttr::CalcAabBox() {
-    /* Nonmatching */
+    cXyz min, max;
+    min.x = mCenter.x - mRadius;
+    min.y = mCenter.y;
+    min.z = mCenter.z - mRadius;
+    max.x = mCenter.x + mRadius;
+    max.y = mCenter.y + mHeight;
+    max.z = mCenter.z + mRadius;
+    mAab.mMin.set(min);
+    mAab.mMax.set(max);
 }
 
 /* 8024264C-80242734       .text GetNVec__12cCcD_CylAttrCFRC4cXyzP4cXyz */
-bool cCcD_CylAttr::GetNVec(const cXyz&, cXyz*) const {
+bool cCcD_CylAttr::GetNVec(const cXyz&, cXyz* dst) const {
     /* Nonmatching */
 }
 
 /* 80242734-80242780       .text CrossAtTg__12cCcD_SphAttrCFRC12cCcD_CpsAttrP4cXyz */
-bool cCcD_SphAttr::CrossAtTg(const cCcD_CpsAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_SphAttr::CrossAtTg(const cCcD_CpsAttr& cps, cXyz* dst) const {
+    if (Cross(&cps, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242780-802427C4       .text CrossAtTg__12cCcD_SphAttrCFRC12cCcD_CylAttrP4cXyz */
-bool cCcD_SphAttr::CrossAtTg(const cCcD_CylAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_SphAttr::CrossAtTg(const cCcD_CylAttr& cyl, cXyz* dst) const {
+    if (cross(&cyl, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 802427C4-80242808       .text CrossAtTg__12cCcD_SphAttrCFRC12cCcD_SphAttrP4cXyz */
-bool cCcD_SphAttr::CrossAtTg(const cCcD_SphAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_SphAttr::CrossAtTg(const cCcD_SphAttr& sph, cXyz* dst) const {
+    if (cross(&sph, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242808-80242840       .text CrossAtTg__12cCcD_SphAttrCFRC12cCcD_TriAttrP4cXyz */
-bool cCcD_SphAttr::CrossAtTg(const cCcD_TriAttr&, cXyz*) const {
-    /* Nonmatching */
+bool cCcD_SphAttr::CrossAtTg(const cCcD_TriAttr& tri, cXyz* dst) const {
+    if (Cross(tri, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242840-80242894       .text CrossCo__12cCcD_SphAttrCFRC12cCcD_CylAttrPf */
-bool cCcD_SphAttr::CrossCo(const cCcD_CylAttr&, f32*) const {
+bool cCcD_SphAttr::CrossCo(const cCcD_CylAttr& cyl, f32* dst) const {
     /* Nonmatching */
+    cXyz xyz;
+    if (cM3d_Cross_CylSph(&cyl, this, &xyz, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 80242894-802428D8       .text CrossCo__12cCcD_SphAttrCFRC12cCcD_SphAttrPf */
-bool cCcD_SphAttr::CrossCo(const cCcD_SphAttr&, f32*) const {
-    /* Nonmatching */
+bool cCcD_SphAttr::CrossCo(const cCcD_SphAttr& sph, f32* dst) const {
+    if (cross(&sph, dst))
+        return true;
+    else
+        return false;
 }
 
 /* 802428D8-80242930       .text CrossCo__12cCcD_SphAttrCFRC12cCcD_CpsAttrPf */
-bool cCcD_SphAttr::CrossCo(const cCcD_CpsAttr&, f32*) const {
+bool cCcD_SphAttr::CrossCo(const cCcD_CpsAttr& cps, f32* dst) const {
     /* Nonmatching */
+    cXyz xyz;
+    *dst = 0.0f;
+    if (cM3d_Cross_CpsSph(cps, *this, &xyz))
+        return true;
+    else
+        return false;
 }
 
 /* 80242930-802429B8       .text CalcAabBox__12cCcD_SphAttrFv */
 void cCcD_SphAttr::CalcAabBox() {
     /* Nonmatching */
+    cXyz min = mCenter;
+    cXyz max = mCenter;
+    min.x -= mRadius;
+    min.y -= mRadius;
+    min.z -= mRadius;
+    max.x += mRadius;
+    max.y += mRadius;
+    max.z += mRadius;
+    mAab.mMin.set(min);
+    mAab.mMax.set(max);
 }
 
 /* 802429B8-80242A54       .text GetNVec__12cCcD_SphAttrCFRC4cXyzP4cXyz */
-bool cCcD_SphAttr::GetNVec(const cXyz&, cXyz*) const {
+bool cCcD_SphAttr::GetNVec(const cXyz&, cXyz* dst) const {
     /* Nonmatching */
 }