Updated CC collision (#80)

* c_cc_d soooo close

* d_cc_shape_colliders -> d_cc_d

* ported over changes from #43

* Oops, didnt save

* use better collision functions in bombf

* bombf fixes

* bombf actorPostCreate matching

* fix

* small fix for cCcD_UnkAttr Set function

* more cleanup(?) for c_cc_d

* d_cc_mass_s OK

* Initial d_cc_s setup

* some easy funcs

---------

Co-authored-by: robojumper <robojumper@gmail.com>

12 files changed, 1104 insertions, 122 deletions

diff --git a/include/d/col/c/c_bg_s_poly_info.h b/include/d/col/c/c_bg_s_poly_info.h
index 7ab2943f..25e41452 100644
--- a/include/d/col/c/c_bg_s_poly_info.h
+++ b/include/d/col/c/c_bg_s_poly_info.h
@@ -2,6 +2,7 @@
 #define C_BG_S_POLY_INFO_H
 
 #include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/c/c_bg_w.h"
 #include "d/col/c/c_m3d_g_pla.h"
 #include "m/m_vec.h"
diff --git a/include/d/col/c/c_cc_d.h b/include/d/col/c/c_cc_d.h
index be4685be..3a1796b1 100644
--- a/include/d/col/c/c_cc_d.h
+++ b/include/d/col/c/c_cc_d.h
@@ -1,4 +1,916 @@
 #ifndef C_CC_D_H
 #define C_CC_D_H
 
+#include "common.h"
+#include "d/a/d_a_base.h"
+#include "d/col/c/c_m3d.h"
+#include "d/col/c/c_m3d_g_aab.h"
+#include "d/col/c/c_m3d_g_cps.h"
+#include "d/col/c/c_m3d_g_cyl.h"
+#include "d/col/c/c_m3d_g_sph.h"
+#include "d/col/c/c_m3d_g_tri.h"
+#include "d/col/c/c_m3d_g_unk.h"
+#include "m/m_vec.h"
+#include "nw4r/types_nw4r.h"
+
+class dAcObjBase_c;
+
+class cCcD_CpsAttr;
+class cCcD_TriAttr;
+class cCcD_UnkAttr;
+class cCcD_CylAttr;
+class cCcD_SphAttr;
+
+class cCcD_DivideInfo {
+private:
+    /* 0x00 */ u32 mXDivInfo;
+    /* 0x04 */ u32 mYDivInfo;
+    /* 0x08 */ u32 mZDivInfo;
+    /* 0x0C vtable */
+public:
+    cCcD_DivideInfo();
+    virtual ~cCcD_DivideInfo();
+
+    // Following two funcs were probably inlined based on how other classes went
+    void Set(u32 xDivInfo, u32 yDivInfo, u32 zDivInfo) {
+        mXDivInfo = xDivInfo;
+        mYDivInfo = yDivInfo;
+        mZDivInfo = zDivInfo;
+    }
+
+    bool Chk(cCcD_DivideInfo const &other) const {
+        if ((mXDivInfo & other.mXDivInfo) && (mZDivInfo & other.mZDivInfo) && (mYDivInfo & other.mYDivInfo)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+};
+
+class cCcD_DivideArea : public cM3dGAab {
+private:
+    /* 0x18 */ bool mXDiffIsZero;
+    /* 0x1C */ f32 mScaledXDiff;
+    /* 0x20 */ f32 mInvScaledXDiff;
+    /* 0x24 */ bool mYDiffIsZero;
+    /* 0x28 */ f32 mScaledYDiff;
+    /* 0x2C */ f32 mInvScaledYDiff;
+    /* 0x30 */ bool mZDiffIsZero;
+    /* 0x34 */ f32 mScaledZDiff;
+    /* 0x38 */ f32 mInvScaledZDiff;
+    /* 0x3C vtable */
+
+public:
+    cCcD_DivideArea();
+    virtual ~cCcD_DivideArea();
+    void SetArea(cM3dGAab const &);
+    void CalcDivideInfo(cCcD_DivideInfo *, cM3dGAab const &);
+    void CalcDivideInfoOverArea(cCcD_DivideInfo *, cM3dGAab const &);
+};
+
+class cCcD_ShapeAttr {
+public:
+    cM3dGAab mAab;
+    cCcD_DivideInfo mInfo;
+    enum ShapeType {
+        SHAPE_SPHERE = 0,
+        SHAPE_CYLINDER = 1,
+        SHAPE_CAPSULE = 2,
+        SHAPE_TRIANGLE = 3,
+        SHAPE_DEFAULT = 4,
+    };
+    struct Shape {
+        ~Shape();
+
+        /* 0x00 */ int mField_0x00;
+        /* 0x04 */ mVec3_c mField_0x04;
+        /* 0x10 */ mVec3_c mField_0x10;
+        /* 0x1C */ mVec3_c mField_0x1C;
+    };
+    cCcD_ShapeAttr();
+    /* vt 0x08 */ virtual ~cCcD_ShapeAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *);
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *);
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) = 0;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) = 0;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) = 0;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) = 0;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) = 0;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *);
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) = 0;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) = 0;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) = 0;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) = 0;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) = 0;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP();
+    /* vt 0x44 */ virtual void CalcAabBox() = 0;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const = 0;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const = 0;
+    /* vt 0x54 */ virtual bool GetPosBool(mVec3_c *) const;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) = 0;
+
+    cM3dGAab &GetWorkAab() {
+        return mAab;
+    }
+    cM3dGAab const &GetWorkAab() const {
+        return mAab;
+    }
+
+    static mVec3_c sVirtualCenter;
+};
+
+struct cCcD_SrcCpsAttr {
+    f32 mRadius;
+};
+class cCcD_CpsAttr : public cCcD_ShapeAttr, public cM3dGCps {
+public:
+    mVec3_c mVirtCenter;
+
+    cCcD_CpsAttr();
+    void Set(const cCcD_SrcCpsAttr &src);
+    void SetVirtCenter(mVec3_c *);
+
+    f32 CrossCoCommon(cCcD_ShapeAttr &, f32);
+
+    /* vt 0x08 */ virtual ~cCcD_CpsAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+class cCcD_TriAttr : public cCcD_ShapeAttr, public cM3dGTri {
+public:
+    cCcD_TriAttr();
+    /* vt 0x08 */ virtual ~cCcD_TriAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcUnkAttr {
+    f32 mMinX, mMinY, mMinZ;
+    f32 mMaxX, mMaxY, mMaxZ;
+
+    mVec3_c &getMin() const {
+        return *(mVec3_c *)&mMinX;
+    }
+    mVec3_c &getMax() const {
+        return *(mVec3_c *)&mMaxX;
+    }
+};
+
+class cCcD_UnkAttr : public cCcD_ShapeAttr, public cM3dGUnk {
+public:
+    cCcD_UnkAttr();
+
+    void Set(const cCcD_SrcUnkAttr &src);
+    /* vt 0x08 */ virtual ~cCcD_UnkAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcCylAttr {
+    f32 mRadius;
+    f32 mHeight;
+};
+
+class cCcD_CylAttr : public cCcD_ShapeAttr, public cM3dGCyl {
+public:
+    cCcD_CylAttr();
+    void Set(const cCcD_SrcCylAttr &);
+    /* vt 0x08 */ virtual ~cCcD_CylAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+struct cCcD_SrcSphAttr {
+    f32 mRadius;
+};
+
+class cCcD_SphAttr : public cCcD_ShapeAttr, public cM3dGSph {
+public:
+    cCcD_SphAttr();
+    void Set(const cCcD_SrcSphAttr &);
+    /* vt 0x08 */ virtual ~cCcD_SphAttr();
+    /* vt 0x0C */ virtual bool Calc(const mVec3_c &, const mVec3_c &, mVec3_c *) override;
+    /* vt 0x10 */ virtual bool CrossAtTg(cCcD_ShapeAttr &, mVec3_c *) override;
+    /* vt 0x14 */ virtual bool CrossAtTg(cCcD_CpsAttr &, mVec3_c *) override;
+    /* vt 0x18 */ virtual bool CrossAtTg(cCcD_TriAttr &, mVec3_c *) override;
+    /* vt 0x1C */ virtual bool CrossAtTg(cCcD_UnkAttr &, mVec3_c *) override;
+    /* vt 0x20 */ virtual bool CrossAtTg(cCcD_CylAttr &, mVec3_c *) override;
+    /* vt 0x24 */ virtual bool CrossAtTg(cCcD_SphAttr &, mVec3_c *) override;
+    /* vt 0x28 */ virtual bool CrossCo(cCcD_ShapeAttr &, f32 *) override;
+    /* vt 0x2C */ virtual bool CrossCo(cCcD_CpsAttr &, f32 *) override;
+    /* vt 0x30 */ virtual bool CrossCo(cCcD_TriAttr &, f32 *) override;
+    /* vt 0x34 */ virtual bool CrossCo(cCcD_UnkAttr &, f32 *) override;
+    /* vt 0x38 */ virtual bool CrossCo(cCcD_CylAttr &, f32 *) override;
+    /* vt 0x3C */ virtual bool CrossCo(cCcD_SphAttr &, f32 *) override;
+    /* vt 0x40 */ virtual mVec3_c &GetCoP() override;
+    /* vt 0x44 */ virtual void CalcAabBox() override;
+    /* vt 0x48 */ virtual bool GetNVec(const mVec3_c &, mVec3_c *) const override;
+    /* vt 0x4C */ virtual void GetShapeAccess(cCcD_ShapeAttr::Shape *) const override;
+    /* vt 0x50 */ virtual void GetPos(nw4r::math::VEC3 *) const override;
+    /* vt 0x54 */ virtual bool GetPosBool(mVec3_c *) const override;
+    /* vt 0x58 */ virtual void TranslateXZ(f32, f32) override;
+};
+
+// This has changed bit
+class cCcD_Stts {
+public:
+    /* 0x00 */ int mAtApid;
+    /* 0x04 */ int mAtOldApid;
+    /* 0x08 */ int mTgApid;
+    /* 0x0C */ int mTgOldApid;
+    /* 0x10 */ mVec3_c mField_0x10;
+    /* 0x1C */ mVec3_c mField_0x1C;
+    /* 0x28 */ mVec3_c mCcMove;
+    /* 0x34 */ dAcObjBase_c *mpActor;
+    /* 0x38 */ int mRank;
+
+    cCcD_Stts(dAcObjBase_c *);
+    void Move();
+    int GetID() const;
+    void PlusCcMove(f32, f32, f32);
+    void ClrCcMove();
+    int GetWeight(int) const; // idk what to really call it but it removes the rank table
+
+    void SetDefaultRank() {
+        mRank = 0xD;
+    }
+    void SetRank(int rank) {
+        mRank = rank;
+    }
+    dAcObjBase_c *GetAc() {
+        return mpActor;
+    }
+};
+
+struct cCcD_SrcGObjTgInfo {
+    /* 0x00 */ u16 mField_0x0;
+    /* 0x02 */ u16 mField_0x2;
+};
+
+struct cCcD_SrcGObjTg {
+    /* 0x00 */ u32 mType;
+    /* 0x04 */ u32 mSPrm;
+    /* 0x08 */ cCcD_SrcGObjTgInfo mInfo;
+    /* 0x0C */ u16 mField_0x0C;
+    /* 0x0E */ u16 mField_0x0E;
+};
+
+enum cCcD_AtModifiers_e {
+    /* 0x 0000 0001 */ AT_MOD_FIRE = (1 << 0),
+    /* 0x 0000 0002 */ AT_MOD_0x2 = (1 << 1),
+    /* 0x 0000 0004 */ AT_MOD_ELECTRIC = (1 << 2),
+    /* 0x 0000 0008 */ AT_MOD_WIND = (1 << 3),
+    /* 0x 0000 0010 */ AT_MOD_0x10 = (1 << 4),
+    /* 0x 0000 0020 */ AT_MOD_0x20 = (1 << 5),
+    /* 0x 0000 0040 */ AT_MOD_WATER = (1 << 6),
+    /* 0x 0000 0080 */ AT_MOD_0x80 = (1 << 7),
+    /* 0x 0000 0100 */ AT_MOD_0x100 = (1 << 8),
+    /* 0x 0000 0200 */ AT_MOD_STINKY = (1 << 9),
+    /* 0x 0000 0400 */ AT_MOD_CURSED = (1 << 10),
+};
+struct cCcD_SrcGObjAtInfo {
+    /* 0x00 */ u8 mField_0x0;
+    /* 0x01 */ u8 mField_0x1;
+    /* 0x02 */ u16 mModifier;
+};
+
+enum cCcD_AtSPrm {
+    AT_SPRM_DAMAGE = 0x4,
+};
+
+struct cCcD_SrcGObjAt {
+    /* 0x00 */ u32 mType;
+    /* 0x04 */ u32 mSPrm;
+    /* 0x08 */ cCcD_SrcGObjAtInfo mInfo;
+    /* 0x0C */ u8 mDamage;
+    /* 0x0D */ u8 mField_0xD;
+    /* 0x0E */ u8 mField_0xE;
+    /* 0x0F */ u8 mField_0xF;
+    /* 0x10 */ u16 mField_0x10;
+    /* 0x12 */ s16 mField_0x12;
+};
+
+struct cCcD_SrcGObjCo {
+    /* 0x00 */ u32 mSPrm;
+};
+
+struct cCcD_SrcGObj {
+    /* 0x00 */ cCcD_SrcGObjAt mObjAt;
+    /* 0x14 */ cCcD_SrcGObjTg mObjTg;
+    /* 0x1C */ cCcD_SrcGObjCo mObjCo;
+};
+
+class dAcObjBase_c;
+class cCcD_Obj;
+
+typedef bool (*cCcD_HitCallback)(
+    dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB
+);
+typedef int (*cCcD_ShieldChkCallback)(
+    dAcObjBase_c *i_actorA, cCcD_Obj *i_objInfA, dAcObjBase_c *i_actorB, cCcD_Obj *i_objInfB
+);
+
+class cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_HitCallback mHit_cb;
+    s8 mEffCounter;
+    dAcRef_c<dAcObjBase_c> mAc;
+    u32 mRPrm;
+
+    cCcD_GAtTgCoCommonBase();
+
+    virtual ~cCcD_GAtTgCoCommonBase();
+    void dt() {
+        mEffCounter = 0;
+        ClrActorInfo();
+        mHit_cb = nullptr;
+    }
+    void ClrActorInfo();
+    void SetHitActor(dAcObjBase_c *);
+    dAcObjBase_c *GetActor();
+    void SubtractEffCounter();
+
+    bool ChkEffCounter() {
+        return mEffCounter > 0;
+    }
+    void ClrEffCounter() {
+        mEffCounter = 0;
+    }
+    void SetEffCounterTimer() {
+        mEffCounter = 5;
+    }
+
+    u32 MskRPrm(u32 m) const {
+        return mRPrm & m;
+    }
+    void SetRPrm(u32 f) {
+        mRPrm = f;
+    }
+    void OnRPrm(u32 m) {
+        mRPrm |= m;
+    }
+    void OffRPrm(u32 m) {
+        mRPrm = (mRPrm & ~m) | m;
+    }
+};
+
+class cCcD_ObjAt : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjAt();
+    virtual ~cCcD_ObjAt();
+    void Set(const cCcD_SrcGObjAt &);
+    void SetAtFlag(u32);
+    void AdjustHitPos(f32, f32);
+
+    void SetVec(const mVec3_c &vec) {
+        mVec = vec;
+    }
+    mVec3_c &GetVec() {
+        return mVec;
+    }
+
+    void SetHitPos(mVec3_c &pos) {
+        mHitPos = pos;
+    }
+    mVec3_c &GetHitPos() {
+        return mHitPos;
+    }
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+
+    void SetCallback(cCcD_HitCallback cb) {
+        mHit_cb = cb;
+    }
+
+    u32 MskType(u32 mask) const {
+        return mSrc.mType & mask;
+    }
+    void SetType(u32 flag) {
+        mSrc.mType = flag;
+    }
+    void OnType(u32 m) {
+        mSrc.mType |= m;
+    }
+    void OffType(u32 m) {
+        mSrc.mType &= ~m;
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+    u32 MskTgHitSPrm(u32 m) const {
+        return mTgHitSrc.mSPrm & m;
+    }
+    void SetTgHitSPrm(u32 f) {
+        mTgHitSrc.mSPrm = f;
+    }
+    void OnTgHitSPrm(u32 m) {
+        mTgHitSrc.mSPrm |= m;
+    }
+    void OffTgHitSPrm(u32 m) {
+        mTgHitSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjAt &GetSrc() const {
+        return mSrc;
+    }
+    void SetTgHitSrc(const cCcD_SrcGObjTg &src) {
+        mTgHitSrc = src;
+    }
+    const cCcD_SrcGObjTg &GetTgHitSrc() const {
+        return mTgHitSrc;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjAt mSrc;
+    /* 0x30 */ mVec3_c mHitPos;
+    /* 0x3C */ mVec3_c mVec;
+    /* 0x48 */ cCcD_SrcGObjTg mTgHitSrc;
+    /* 0x58 */ cCcD_HitCallback mField_0x58;
+};
+
+class cCcD_ObjTg : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjTg();
+    virtual ~cCcD_ObjTg();
+    void Set(const cCcD_SrcGObjTg &);
+    void AdjustHitPos(f32, f32);
+
+    void SetHitPos(mVec3_c &pos) {
+        mHitPos = pos;
+    }
+    mVec3_c &GetHitPos() {
+        return mHitPos;
+    }
+
+    u32 GetAtHitType() const {
+        return mAtHitSrc.mType;
+    }
+
+    void SetFlag_0xA(u16 flag) {
+        mSrc.mField_0x0E = flag;
+    }
+
+    u16 GetFlag_0xA(u16 mask) const {
+        return mSrc.mField_0x0E & mask;
+    }
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+
+    void Set_0x4C(u32 f) {
+        mField_0x4C = f;
+    }
+
+    u32 MskType(u32 mask) const {
+        return mSrc.mType & mask;
+    }
+    void SetType(u32 flag) {
+        mSrc.mType = flag;
+    }
+    void OnType(u32 m) {
+        mSrc.mType |= m;
+    }
+    void OffType(u32 m) {
+        mSrc.mType &= ~m;
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+    u32 MskAtHitSPrm(u32 m) const {
+        return mAtHitSrc.mSPrm & m;
+    }
+    void SetAtHitSPrm(u32 f) {
+        mAtHitSrc.mSPrm = f;
+    }
+    void OnAtHitSPrm(u32 m) {
+        mAtHitSrc.mSPrm |= m;
+    }
+    void OffAtHitSPrm(u32 m) {
+        mAtHitSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjTg &GetSrc() const {
+        return mSrc;
+    }
+    void SetAtHitSrc(const cCcD_SrcGObjAt &src) {
+        mAtHitSrc = src;
+    }
+    const cCcD_SrcGObjAt &GetAtHitSrc() const {
+        return mAtHitSrc;
+    }
+
+    void Set_0x4B(u8 val) {
+        mField_0x4B = val;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjTg mSrc;
+    /* 0x2C */ mVec3_c mField_0x2C;
+    /* 0x38 */ mVec3_c mHitPos;
+    /* 0x44 */ s16 *mShieldFrontRangeYAngle;
+    /* 0x48 */ s16 mShieldRange;
+    /* 0x4A */ u8 mField_0x4A;
+    /* 0x4B */ u8 mField_0x4B;
+    /* 0x4C */ u32 mField_0x4C;
+    /* 0x50 */ u32 mField_0x50;
+    /* 0x54 */ cCcD_ShieldChkCallback mField_0x54;
+    /* 0x58 */ cCcD_SrcGObjAt mAtHitSrc;
+    /* 0x6C */ mVec3_c mField_0x6C;
+    /* 0x78 */ cCcD_HitCallback mField_0x78;
+};
+
+class cCcD_ObjCo : public cCcD_GAtTgCoCommonBase {
+public:
+    cCcD_ObjCo();
+    virtual ~cCcD_ObjCo();
+    void Set(const cCcD_SrcGObjCo &);
+    void SetCoFlag(u32);
+    void AdjustHitPos(f32, f32);
+
+    void ClrSet() {
+        OffSPrm(1);
+    }
+    u32 ChkSet() {
+        return MskSPrm(1);
+    }
+    u32 MskSPrm(u32 m) const {
+        return mSrc.mSPrm & m;
+    }
+    void SetSPrm(u32 f) {
+        mSrc.mSPrm = f;
+    }
+    void OnSPrm(u32 m) {
+        mSrc.mSPrm |= m;
+    }
+    void OffSPrm(u32 m) {
+        mSrc.mSPrm &= ~m;
+    }
+
+    const cCcD_SrcGObjCo &GetSrc() const {
+        return mSrc;
+    }
+    void SetCoHitSrc(const cCcD_SrcGObjCo &src) {
+        mCoHitSrc = src;
+    }
+
+public:
+    /* 0x1C */ cCcD_SrcGObjCo mSrc;
+    /* 0x20 */ u32 mGrp;
+    /* 0x24 */ cCcD_SrcGObjCo mCoHitSrc;
+    /* 0x28 */ cCcD_HitCallback mField_0x28_callback;
+};
+
+// Maybe ?
+class cCcD_ObjInf {
+public:
+    /* 0x000 */ cCcD_ObjAt mObjAt;
+    /* 0x05C */ cCcD_ObjTg mObjTg;
+    /* 0x0D8 */ cCcD_ObjCo mObjCo;
+};
+
+class cCcD_Obj {
+public:
+    /* 0x000 */ cCcD_ObjAt mAt;
+    /* 0x05C */ cCcD_ObjTg mTg;
+    /* 0x0D8 */ cCcD_ObjCo mCo;
+    /* 0x104 */ cCcD_Stts *mStts;
+    /* 0x108 */ u32 mField_0x108;
+
+public:
+    cCcD_Obj();
+    virtual ~cCcD_Obj();
+    virtual cCcD_ShapeAttr *GetShapeAttr() = 0;
+    virtual cCcD_ObjInf *GetGObjInfo();
+    void ClrSet();
+    void Set(const cCcD_SrcGObj &);
+    void ClrAtHit();
+    void ClrTgHit();
+    void ClrCoHit();
+
+    const mVec3_c &GetAtHitPos() const;
+    mVec3_c &GetAtHitPos();
+    bool GetAtFlag0x2() const;
+    bool GetAtFlag0x4() const;
+    bool GetAtFlag0x8() const;
+
+    const mVec3_c &GetTgHitPos() const;
+    mVec3_c &GetTgHitPos();
+    bool GetTgFlag0x4() const;
+    bool GetTgFlag0x8() const;
+
+    bool ChkAtClawshot() const;
+    bool ChkAtClawshotDebug() const;
+    bool ChkAtElectrified() const;
+    bool ChkAtElectrifiedExtra() const;
+    bool ChkAtWhippable() const;
+    bool ChkAtBit24() const;
+    bool ChkAtArrowStick() const;
+    bool ChkAtWaterScaleBonk() const;
+    bool ChkAtSwordBonk() const;
+    dAcObjBase_c *GetAtActor();
+
+    bool ChkTgAtHitType(u32) const;
+    u32 GetTg_0x58() const;
+    bool ChkTgBit14() const;
+    u8 GetTgDamage() const;
+    u16 GetTgDamageFlags() const;
+    bool ChkTgSkywardStrike() const;
+    bool ChkTgBit17() const;
+    bool ChkTgBit18() const;
+    bool ChkTgBit19() const;
+    bool ChkTgBit20() const;
+    bool ChkTgBit23() const;
+    bool ChkTgBit24() const;
+    bool ChkTgBit25() const;
+    u16 GetTgSoundID() const;
+    s16 GetTg_0x6A() const;
+    bool ChkTgBit8() const;
+    u8 GetTg_0x4A() const;
+    dAcObjBase_c *GetTgActor();
+    const mVec3_c &GetTg_0x2C() const;
+
+    dAcObjBase_c *GetCoActor();
+    bool ChkCoBit4() const;
+
+    void SetAtFlagsUpper(u32);
+    bool ChkTgBit1() const;
+
+    void AdjustHitPos(f32, f32);
+
+    static bool fn_80328ad0(dAcObjBase_c *pObj, u32 attype);
+
+    // clang-format off
+    cCcD_Stts* GetStts() {
+        return mStts;
+    }
+    void SetStts(cCcD_Stts &stts) { mStts = &stts; }
+
+    void SetAtVec(const mVec3_c &vec) {  mAt.SetVec(vec); }
+
+
+    void OnTgCoFlag(u32 f) {
+        mTg.OnSPrm(f);
+        mCo.OnSPrm(f);
+    }
+
+    void SetTgFlag(u32 flag) {
+        mTg.SetType(flag);
+    }
+    void SetAtFlag(u32 flag) {
+        mAt.SetSPrm(flag);
+    }
+
+    void SetTgFlag_0xA(u16 flag) {
+        mTg.SetFlag_0xA(flag);
+    }
+
+    bool ChkTgHit() {
+        return mTg.MskSPrm(1) != 0 && mTg.GetActor() != nullptr;
+    }
+    bool ChkAtHit() {
+        return mAt.MskSPrm(1) != 0 && mAt.GetActor() != nullptr;
+    }
+    bool ChkCoHit() {
+        return mCo.MskSPrm(1) != 0 && mCo.GetActor() != nullptr;
+    }
+
+    dAcObjBase_c *GetAc() {
+        if (mStts == nullptr) {
+            return nullptr;
+        } else {
+            return mStts->mpActor;
+        }
+    }
+
+    void ClrCoSet() {
+        mCo.ClrSet();
+    }
+    void ClrAtSet() {
+        mAt.ClrSet();
+    }
+    void ClrTgSet() {
+        mTg.ClrSet();
+    }
+    u32 ChkCoSet() {
+        return mCo.ChkSet();
+    }
+    u32 ChkAtSet() {
+        return mAt.ChkSet();
+    }
+    u32 ChkTgSet() {
+        return mTg.ChkSet();
+    }
+
+    
+    bool ChkAtEffCounter() { return mAt.ChkEffCounter(); }
+    bool ChkTgEffCounter() { return mTg.ChkEffCounter(); }
+    void ClrAtEffCounter() { mAt.ClrEffCounter(); }
+    void ClrTgEffCounter() { mTg.ClrEffCounter(); }
+    void ClrCoEffCounter() { mCo.ClrEffCounter(); }
+    void SetAtEffCounterTimer() { mAt.SetEffCounterTimer(); }
+    void SetTgEffCounterTimer() { mTg.SetEffCounterTimer(); }
+    void SubtractAtEffCounter() { mAt.SubtractEffCounter(); }
+    void SubtractTgEffCounter() { mTg.SubtractEffCounter(); }
+    void SubtractCoEffCounter() { mCo.SubtractEffCounter(); }
+
+    void SetTg_0x4C(u32 f) {
+        mTg.Set_0x4C(f);
+    }
+
+    void SetAtCallback(cCcD_HitCallback cb) {
+        mAt.SetCallback(cb);
+    }
+
+    u32 ChkTgNoAtHitInfSet() const {
+        return mTg.MskSPrm(0x40);
+    }
+    u32 ChkAtNoTgHitInfSet() const {
+        return mAt.MskSPrm(0x40);
+    }
+    u32 ChkCoNoCoHitInfSet() const {
+        return mCo.MskSPrm(0x800); 
+    }
+
+    // At
+
+    u32 ChkAtNoMass() const {
+        return mAt.MskSPrm(0x400);
+    }
+    u32 GetAtGrp() const {
+        return mAt.MskSPrm(0x3E);
+    }
+    u32 ChkAtNoConHit() const {
+        return mAt.MskSPrm(0x80);
+    }
+    u32 ChkAtStopNoConHit() const {
+        return mAt.MskSPrm(0x200);
+    }
+    u32 ChkAtNoGaurd() const {
+        return mAt.MskSPrm(0x200000);
+    }
+
+    // Tg
+
+    u32 GetTgGrp() const {
+        return mTg.MskSPrm(0x3E);
+    }
+    u32 ChkTgNoConHit() const {
+        return mTg.MskSPrm(0x100);
+    }
+    u32 ChkTgStopNoConHit() const {
+        return mTg.MskSPrm(0x100000);
+    }
+    u32 ChkTgShieldFrontRange() const {
+        return mTg.MskSPrm(0x400);
+    }
+
+    void SetTg_0x4B(u8 val) {
+        mTg.Set_0x4B(val);
+    }
+
+    // Co
+
+    u32 ChkCoSet2() const {
+        return mCo.MskSPrm(0x800);
+    }
+    u32 ChkCoNoCamHit() const {
+        return mCo.MskSPrm(0x4000);
+    }
+    u32 ChkCoSameActorHit() const {
+        return mCo.MskSPrm(0x1000);
+    }
+
+    /**
+     * SET HIT
+     */
+
+    // Actor Objs
+    void SetAtHit(cCcD_Obj *other) {
+        mAt.SetHitActor(other->GetAc());
+    }
+    void SetTgHit(cCcD_Obj *other) {
+        mTg.SetHitActor(other->GetAc());
+    }
+    void SetCoHit(cCcD_Obj *other) {
+        mCo.SetHitActor(other->GetAc());
+    }
+
+    // Hit Positions
+    void SetAtHitPos(mVec3_c &pos) {
+        mAt.SetHitPos(pos);
+    }
+    void SetTgHitPos(mVec3_c &pos) {
+        mTg.SetHitPos(pos);
+    }
+
+    /**
+     * SET SOURCES
+     */
+
+    void SetAtTgHitSrc(cCcD_Obj *tg) {
+        mAt.SetTgHitSrc(tg->mTg.GetSrc());
+    }
+    void SetTgAtHitSrc(cCcD_Obj *at) {
+        mTg.SetAtHitSrc(at->mAt.GetSrc());
+    }
+    void SetCoCoHitSrc(cCcD_Obj *co) {
+        mCo.SetCoHitSrc(co->mCo.GetSrc());
+    }
+
+    // clang-format on
+};
+
 #endif
diff --git a/include/d/col/c/c_cc_s.h b/include/d/col/c/c_cc_s.h
index 9eccad82..dea515c7 100644
--- a/include/d/col/c/c_cc_s.h
+++ b/include/d/col/c/c_cc_s.h
@@ -1,7 +1,20 @@
 #ifndef C_CC_S_H
 #define C_CC_S_H
 
+#include "common.h"
+#include "d/a/obj/d_a_obj_base.h"
 #include "d/col/c/c_cc_d.h"
+#include "m/m_mtx.h"
+#include "m/m_vec.h"
+
+/**
+ * This still seems to be exist, but looks like was heavily revised.
+ * No more virtual functions
+ * a couple more entry arrays (a Matrix one and a model one)
+ *
+ * This file is largely here to support future changes?
+ *  - dCcS copies and pastes the content. Otherwise the ctor is weird
+ */
 
 enum WeightType {
     WeightType_0 = 0,
@@ -9,52 +22,53 @@ enum WeightType {
     WeightType_2 = 2,
 };
 
-// class cCcS {
-// public:
-//     /* 0x0000 */ cCcD_Obj *mpObjAt[0x100];
-//     /* 0x0400 */ cCcD_Obj *mpObjTg[0x300];
-//     /* 0x1000 */ cCcD_Obj *mpObjCo[0x100];
-//     /* 0x1400 */ cCcD_Obj *mpObj[0x500];
-//     /* 0x2800 */ u16 mObjAtCount;
-//     /* 0x2802 */ u16 mObjTgCount;
-//     /* 0x2804 */ u16 mObjCoCount;
-//     /* 0x2806 */ u16 mObjCount;
-//     /* 0x2808 */ cCcD_DivideArea mDivideArea;
-//     /* 0x2848 vtable */
-
-// /* 80264A6C */ cCcS();
-// /* 80264A94 */ void Ct();
-// /* 80264B60 */ void Dt();
-// /* 80264B80 */ WeightType GetWt(u8) const;
-// /* 80264BA8 */ void Set(cCcD_Obj *);
-// /* 80264C5C */ void ClrCoHitInf();
-// /* 80264CF0 */ void ClrTgHitInf();
-// /* 80264D90 */ void ClrAtHitInf();
-// /* 80264E2C */ bool ChkNoHitAtTg(cCcD_Obj *, cCcD_Obj *);
-// /* 80264F40 */ void ChkAtTg();
-// /* 8026515C */ bool ChkNoHitCo(cCcD_Obj *, cCcD_Obj *);
-// /* 80265230 */ void ChkCo();
-// /* 802653A0 vt[2] */ virtual void CalcTgPlusDmg(cCcD_Obj *, cCcD_Obj *, cCcD_Stts *, cCcD_Stts *);
-// /* 802653C8 */ void SetAtTgCommonHitInf(cCcD_Obj *, cCcD_Obj *, cXyz *);
-// /* 802655E4 */ void SetCoCommonHitInf(cCcD_Obj *, cXyz *, cCcD_Obj *, cXyz *, f32);
-// /* 80265750 vt[3]*/ virtual void SetPosCorrect(cCcD_Obj *, cXyz *, cCcD_Obj *, cXyz *, f32);
-// /* 80265BB4 */ void CalcArea();
-// /* 80265CCC */ void Move();
-// /* 80265D30 */ void DrawClear();
-// /* 80265DF8 vt[4] */ virtual void
-// SetCoGObjInf(bool, bool, cCcD_GObjInf *, cCcD_GObjInf *, cCcD_Stts *, cCcD_Stts *, cCcD_GStts *, cCcD_GStts *);
-// /* 80265DFC vt[5] */ virtual void
-// SetAtTgGObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *, cCcD_GObjInf *, cCcD_GObjInf *, cCcD_Stts *, cCcD_Stts *,
-// cCcD_GStts *, cCcD_GStts *, cXyz *);
-// /* 80265E00 vt[6] */ virtual bool
-// ChkNoHitGAtTg(cCcD_GObjInf const *, cCcD_GObjInf const *, cCcD_GStts *, cCcD_GStts *);
-// /* 80265E08 vt[7] */ virtual bool
-// ChkAtTgHitAfterCross(bool, bool, cCcD_GObjInf const *, cCcD_GObjInf const *, cCcD_Stts *, cCcD_Stts *, cCcD_GStts *,
-// cCcD_GStts *);
-// /* 80265E10 vt[8] */ virtual bool ChkNoHitGCo(cCcD_Obj *, cCcD_Obj *);
-// /* 80030BDC vt[9] */ virtual ~cCcS() {}
-// /* 80265E18 vt[10] */ virtual void MoveAfterCheck();
-// /* 80265DF4 vt[11] */ virtual void SetCoGCorrectProc(cCcD_Obj *, cCcD_Obj *);
-// }; // Size = 0x284C
+class cCcS {
+public:
+    /* 0x0000 */ cCcD_Obj *mpObjAt[0x200];
+    /* 0x0800 */ cCcD_Obj *mpObjTg[0x300];
+    /* 0x1400 */ cCcD_Obj *mpObjCo[0x200];
+    /* 0x1c00 */ cCcD_Obj *mpObj[0x340];
+    /* 0x2900 */ UNKTYPE *mpUnk[0x100];
+    /* 0x2D00 */ u16 mObjAtCount;
+    /* 0x2d02 */ u16 mObjTgCount;
+    /* 0x2D04 */ u16 mObjCoCount;
+    /* 0x2D06 */ u16 mObjCount;
+    /* 0x2D08 */ u32 mUnkCount;
+    /* 0x2D0C */ cCcD_DivideArea mDivideArea;
+    /* 0x2D4C */ bool mbAreaSet;
+    /* 0x2D50 */ mMtx_c mAreas[16][2]; // could be a structure?
+    /* 0x3350 */ int mAreaCount;
+
+    cCcS() {}
+
+    void Ct();
+    void Dt();
+
+    void Set(cCcD_Obj *);
+
+    void ChkCo(mVec3_c *, dAcObjBase_c *);
+    bool fn_80357c90(mVec3_c *, mVec3_c *, u32, UNKTYPE *);
+
+    // WeightType GetWt(u8) const;
+    // void ClrCoHitInf();
+    // void ClrTgHitInf();
+    // void ClrAtHitInf();
+    // bool ChkNoHitAtTg(cCcD_Obj *, cCcD_Obj *);
+    // void ChkAtTg();
+    // bool ChkNoHitCo(cCcD_Obj *, cCcD_Obj *);
+    // void CalcTgPlusDmg(cCcD_Obj *, cCcD_Obj *, cCcD_Stts *, cCcD_Stts *);
+    // void SetAtTgCommonHitInf(cCcD_Obj *, cCcD_Obj *, cXyz *);
+    // void SetCoCommonHitInf(cCcD_Obj *, cXyz *, cCcD_Obj *, cXyz *, f32);
+    // void SetPosCorrect(cCcD_Obj *, cXyz *, cCcD_Obj *, cXyz *, f32);
+    // void CalcArea();
+    // void Move();
+    // void DrawClear();
+    // void SetCoGObjInf(bool, bool, cCcD_ObjInf *, cCcD_ObjInf *, cCcD_Stts *, cCcD_Stts *, cCcD_GStts *, cCcD_GStts
+    // *); void SetAtTgGObjInf(bool, bool, cCcD_Obj *, cCcD_Obj *, cCcD_ObjInf *, cCcD_ObjInf *, cCcD_Stts *,
+    // cCcD_Stts *, cCcD_GStts *, cCcD_GStts *, cXyz *); bool ChkNoHitGAtTg(cCcD_ObjInf const *, cCcD_ObjInf const *,
+    // cCcD_GStts *, cCcD_GStts *); bool ChkAtTgHitAfterCross(bool, bool, cCcD_ObjInf const *, cCcD_ObjInf const *,
+    // cCcD_Stts *, cCcD_Stts *, cCcD_GStts *, cCcD_GStts *); bool ChkNoHitGCo(cCcD_Obj *, cCcD_Obj *); ~cCcS() {} void
+    // MoveAfterCheck(); void SetCoGCorrectProc(cCcD_Obj *, cCcD_Obj *);
+};
 
 #endif /* C_CC_S_H */
diff --git a/include/d/col/c/c_m3d.h b/include/d/col/c/c_m3d.h
index c148eef3..cf9c3450 100644
--- a/include/d/col/c/c_m3d.h
+++ b/include/d/col/c/c_m3d.h
@@ -3,7 +3,8 @@
 
 #include "common.h"
 #include "math.h"
-#include "nw4r/math.h"
+#include "nw4r/math.h" // IWYU pragma: export
+#include "nw4r/types_nw4r.h"
 
 class cM3dGAab;
 class cM3dGCps;
@@ -19,64 +20,69 @@ struct cM3d_Range;
 extern const f32 G_CM3D_F_ABS_MIN;
 
 bool cM3d_Len2dSqPntAndSegLine(f32, f32, f32, f32, f32, f32, f32 *, f32 *, f32 *);
-bool cM3d_Len3dSqPntAndSegLine(const cM3dGLin *, const nw4r::math::VEC3 *, nw4r::math::VEC3 *, f32 *, f32 *);
-f32 cM3d_SignedLenPlaAndPos(const cM3dGPla *, const nw4r::math::VEC3 *);
+bool cM3d_Len3dSqPntAndSegLine(const cM3dGLin &, const nw4r::math::VEC3 &, nw4r::math::VEC3 *, f32 *, f32 *);
+f32 cM3d_SignedLenPlaAndPos(const cM3dGPla &, const nw4r::math::VEC3 *);
 void cM3d_CalcPla(const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, nw4r::math::VEC3 *, f32 *);
-int cM3d_Check_LinLin(const cM3dGLin *, const cM3dGLin *, f32 *, f32 *);
-bool cM3d_Cross_LinPla(const cM3dGLin *, const cM3dGPla *, nw4r::math::VEC3 *, bool, bool);
+int cM3d_Check_LinLin(const cM3dGLin &, const cM3dGLin *, f32 *, f32 *);
+bool cM3d_Cross_LinPla(const cM3dGLin &, const cM3dGPla *, nw4r::math::VEC3 *, bool, bool);
 bool cM3d_Cross_MinMaxBoxLine(const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *);
 bool cM3d_InclusionCheckPosIn3PosBox3d(
     const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, f32
 );
-bool cM3d_CrossX_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, f32);
-bool cM3d_CrossX_Tri(const cM3dGTri *, const nw4r::math::VEC3 *);
-bool cM3d_CrossY_Tri(const cM3dGTri *, const nw4r::math::VEC3 *);
+bool cM3d_CrossX_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, f32);
+bool cM3d_CrossX_Tri(const cM3dGTri &, const nw4r::math::VEC3 *);
+bool cM3d_CrossY_Tri(const cM3dGTri &, const nw4r::math::VEC3 *);
 bool cM3d_CrossY_Tri_Front(const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 *);
-bool cM3d_CrossY_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, f32 *);
-bool cM3d_CrossY_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, f32);
-bool cM3d_CrossY_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, const cM3d_Range *, f32 *);
-bool cM3d_CrossZ_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, f32);
-bool cM3d_CrossZ_Tri(const cM3dGTri *, const nw4r::math::VEC3 *);
-bool cM3d_CrossZ_Tri(const cM3dGTri *, const nw4r::math::VEC3 *, f32 *);
-bool cM3d_Cross_LinTri(const cM3dGLin *, const cM3dGTri *, nw4r::math::VEC3 *, bool, bool);
+bool cM3d_CrossY_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, f32 *);
+bool cM3d_CrossY_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, f32);
+bool cM3d_CrossY_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, const cM3d_Range *, f32 *);
+bool cM3d_CrossZ_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, f32);
+bool cM3d_CrossZ_Tri(const cM3dGTri &, const nw4r::math::VEC3 *);
+bool cM3d_CrossZ_Tri(const cM3dGTri &, const nw4r::math::VEC3 *, f32 *);
+bool cM3d_Cross_LinTri(const cM3dGLin &, const cM3dGTri &, nw4r::math::VEC3 *, bool, bool);
 bool cM3d_Cross_LinTri(
-    const cM3dGLin *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, const cM3dGPla *,
+    const cM3dGLin &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, const cM3dGPla *,
     nw4r::math::VEC3 *, bool, bool
 );
 bool cM3d_Cross_LinTri_Easy(const cM3dGTri *, const nw4r::math::VEC3 *);
-bool cM3d_Cross_SphPnt(const cM3dGSph *, const nw4r::math::VEC3 *);
-bool cM3d_Cross_LinSph(const cM3dGLin *, const cM3dGSph *, nw4r::math::VEC3 *);
+bool cM3d_Cross_SphPnt(const cM3dGSph &, const nw4r::math::VEC3 *);
+bool cM3d_Cross_LinSph(const cM3dGLin &, const cM3dGSph &, nw4r::math::VEC3 *);
 bool cM3d_Cross_LinSph_CrossPos(const cM3dGSph &, const cM3dGLin &, nw4r::math::VEC3 *, nw4r::math::VEC3 *);
-bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, f32 *);
-bool cM3d_Cross_CylSph(const cM3dGCyl *, const cM3dGSph *, nw4r::math::VEC3 *, f32 *);
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *);
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, f32 *, f32 *);
-bool cM3d_Cross_SphSph(const cM3dGSph *, const cM3dGSph *, nw4r::math::VEC3 *);
-void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph *, const cM3dGTri *, nw4r::math::VEC3 *);
-bool cM3d_Cross_SphTri(const cM3dGSph *, const cM3dGTri *, nw4r::math::VEC3 *, f32 *, nw4r::math::VEC3 *);
-bool cM3d_Cross_CylCyl(const cM3dGCyl *, const cM3dGCyl *, f32 *);
-bool cM3d_Cross_CylCyl(const cM3dGCyl *, const cM3dGCyl *, nw4r::math::VEC3 *);
-bool cM3d_Cross_CylTri(const cM3dGCyl *, const cM3dGTri *, nw4r::math::VEC3 *);
-int cM3d_Cross_CylLin(const cM3dGCyl *, const cM3dGLin *, nw4r::math::VEC3 *, nw4r::math::VEC3 *);
-int cM3d_Cross_CylPntPnt(const cM3dGCyl *, const nw4r::math::VEC3 *, const nw4r::math::VEC3 *, nw4r::math::VEC3 *, nw4r::math::VEC3 *);
-bool cM3d_Cross_CylPnt(const cM3dGCyl *, const nw4r::math::VEC3 *);
+bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, f32 *);
+bool cM3d_Cross_CylSph(const cM3dGCyl &, const cM3dGSph &, nw4r::math::VEC3 *, f32 *);
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *);
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, f32 *, f32 *);
+bool cM3d_Cross_SphSph(const cM3dGSph &, const cM3dGSph &, nw4r::math::VEC3 *);
+void cM3d_CalcSphVsTriCrossPoint(const cM3dGSph &, const cM3dGTri &, nw4r::math::VEC3 *);
+bool cM3d_Cross_SphTri(const cM3dGSph &, const cM3dGTri &, nw4r::math::VEC3 *, f32 *, nw4r::math::VEC3 *);
+bool cM3d_Cross_CylCyl(const cM3dGCyl &, const cM3dGCyl &, f32 *);
+bool cM3d_Cross_CylCyl(const cM3dGCyl &, const cM3dGCyl &, nw4r::math::VEC3 *);
+bool cM3d_Cross_CylTri(const cM3dGCyl &, const cM3dGTri &, nw4r::math::VEC3 *);
+int cM3d_Cross_CylLin(const cM3dGCyl &, const cM3dGLin &, nw4r::math::VEC3 *, nw4r::math::VEC3 *);
+int cM3d_Cross_CylPntPnt(const cM3dGCyl &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, nw4r::math::VEC3 *, nw4r::math::VEC3 *);
+bool cM3d_Cross_CylPnt(const cM3dGCyl &, const nw4r::math::VEC3 &);
+bool cM3d_Cross_CpsCps(const cM3dGCps &, const cM3dGCps &, nw4r::math::VEC3 *, f32 *, f32 *);
+bool cM3d_Cross_CpsCyl(const cM3dGCps &, const cM3dGCyl &, nw4r::math::VEC3 *);
 bool cM3d_Cross_CpsSph_CrossPos(const cM3dGCps &, const cM3dGSph &, const nw4r::math::VEC3 &, nw4r::math::VEC3 *);
 bool cM3d_Cross_CpsSph(const cM3dGCps &, const cM3dGSph &, nw4r::math::VEC3 *);
 bool cM3d_Cross_TriTri(const cM3dGTri &, const cM3dGTri &, nw4r::math::VEC3 *);
-bool cM3d_Cross_CpsTri(const cM3dGCps &, cM3dGTri, nw4r::math::VEC3 *);
+bool cM3d_Cross_CpsTri(const cM3dGCps &, const cM3dGTri &, nw4r::math::VEC3 *);
 void cM3d_CalcVecZAngle(const nw4r::math::VEC3 &, mAng3_c *);
 void cM3d_PlaneCrossLineProcWork(f32, f32, f32, f32, f32, f32, f32, f32 *, f32 *);
 int cM3d_2PlaneCrossLine(const cM3dGPla &, const cM3dGPla &, cM3dGLin *);
 bool cM3d_3PlaneCrossPos(const cM3dGPla &, const cM3dGPla &, const cM3dGPla &, nw4r::math::VEC3 *);
-f32 cM3d_lineVsPosSuisenCross(const cM3dGLin *, const nw4r::math::VEC3 *, nw4r::math::VEC3 *);
+f32 cM3d_lineVsPosSuisenCross(const cM3dGLin &, const nw4r::math::VEC3 &, nw4r::math::VEC3 *);
 f32 cM3d_lineVsPosSuisenCross(const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, const nw4r::math::VEC3 &, nw4r::math::VEC3 *);
 
-bool fn_803354e0(cM3dGUnk *, cM3dGUnk *, nw4r::math::VEC3 *);
-bool fn_80336110(cM3dGCyl *, cM3dGUnk *, nw4r::math::VEC3 *);
-bool fn_803364e0(cM3dGCyl *, cM3dGUnk *, f32 *);
-bool fn_80336d90(cM3dGCps *, cM3dGUnk *, nw4r::math::VEC3 *);
-bool fn_80337690(cM3dGUnk *, cM3dGSph *, nw4r::math::VEC3 *);
-bool fn_80337780(cM3dGUnk *, cM3dGSph *, f32 *);
+bool cM3d_Cross_UnkTri(const cM3dGUnk &, cM3dGTri &, nw4r::math::VEC3 *);
+bool cM3d_Cross_CylUnk(const cM3dGCyl &, cM3dGUnk &, nw4r::math::VEC3 *);
+bool cM3d_Cross_CylUnk(const cM3dGCyl &, cM3dGUnk &, f32 *);
+bool cM3d_Cross_CpsUnk(const cM3dGCps &, cM3dGUnk &, nw4r::math::VEC3 *);
+bool cM3d_Cross_UnkSph(const cM3dGUnk &, cM3dGSph &, nw4r::math::VEC3 *);
+bool cM3d_Cross_UnkSph(const cM3dGUnk &, cM3dGSph &, f32 *);
+
+bool cM3d_Normalize(nw4r::math::VEC3 *);
+void cM3d_Normalize_Ex(nw4r::math::VEC3 *);
 
 inline bool cM3d_IsZero(f32 f) {
     return fabsf(f) < G_CM3D_F_ABS_MIN;
@@ -89,9 +95,9 @@ inline bool cM3d_IsZero_inverted(f32 param_0) {
 
 inline void
 cM3d_InDivPos1(const nw4r::math::VEC3 *pVecA, const nw4r::math::VEC3 *pVecB, f32 pF, nw4r::math::VEC3 *pOut) {
-    nw4r::math::VEC3 tmp;
-    VEC3Scale(&tmp, pVecB, pF);
-    VEC3Add(pOut, &tmp, pVecA);
+    nw4r::math::VEC3 tmp2;
+    VEC3Scale(&tmp2, pVecB, pF);
+    VEC3Add(pOut, &tmp2, pVecA);
 }
 inline void
 cM3d_InDivPos2(const nw4r::math::VEC3 *pVecA, const nw4r::math::VEC3 *pVecB, f32 pF, nw4r::math::VEC3 *pOut) {
diff --git a/include/d/col/c/c_m3d_g_aab.h b/include/d/col/c/c_m3d_g_aab.h
index 2afb932f..6f32e328 100644
--- a/include/d/col/c/c_m3d_g_aab.h
+++ b/include/d/col/c/c_m3d_g_aab.h
@@ -5,7 +5,7 @@
 #include "d/col/c/c_m3d.h"
 #include "d/col/c/c_m3d_g_lin.h"
 #include "d/col/c/c_m3d_g_sph.h"
-
+#include "m/m_vec.h"
 
 // Axis aligned bounding box
 class cM3dGAab {
@@ -23,7 +23,6 @@ public:
     bool CrossY(const mVec3_c &) const;
     bool UnderPlaneYUnder(f32) const;
     bool TopPlaneYUnder(f32) const;
-    void SetMinMax(const cM3dGAab &);
     void SetMin(const mVec3_c &min);
     void SetMax(const mVec3_c &max);
     void CalcCenter(mVec3_c &) const;
@@ -32,6 +31,11 @@ public:
     void Set(const cM3dGSph &);
     bool Cross(const mVec3_c &) const;
 
+    void SetMinMax(const cM3dGAab &aab) {
+        SetMin(aab.mMin);
+        SetMax(aab.mMax);
+    }
+
     void SetMinMax(const mVec3_c &minMax) {
         SetMin(minMax);
         SetMax(minMax);
@@ -46,6 +50,19 @@ public:
         mMax.x = -1000000000.0f;
     }
 
+    const mVec3_c &GetMax() const {
+        return mMax;
+    }
+    mVec3_c &GetMax() {
+        return mMax;
+    }
+    const mVec3_c &GetMin() const {
+        return mMin;
+    }
+    mVec3_c &GetMin() {
+        return mMin;
+    }
+
     const mVec3_c *GetMaxP(void) const {
         return &mMax;
     }
diff --git a/include/d/col/c/c_m3d_g_cps.h b/include/d/col/c/c_m3d_g_cps.h
index d700e3bb..ec0c88c2 100644
--- a/include/d/col/c/c_m3d_g_cps.h
+++ b/include/d/col/c/c_m3d_g_cps.h
@@ -18,7 +18,7 @@ public:
     void Set(const mVec3_c &, const mVec3_c &, f32);
     void SetR(f32 r);
     void Set_0x1C(f32);
-    bool fn_80337f30(cM3dGUnk *, mVec3_c *);
+    bool Cross(cM3dGUnk &, mVec3_c *);
     bool fn_80337f40(const mVec3_c &) const;
 
     f32 GetR() const {
diff --git a/include/d/col/c/c_m3d_g_cyl.h b/include/d/col/c/c_m3d_g_cyl.h
index c2941280..a5dfa486 100644
--- a/include/d/col/c/c_m3d_g_cyl.h
+++ b/include/d/col/c/c_m3d_g_cyl.h
@@ -17,14 +17,23 @@ public:
     void SetH(f32);
     void SetR(f32);
 
-    bool fn_803380e0(cM3dGUnk *, mVec3_c *);
-    bool fn_803380f0(cM3dGUnk *, f32 *);
+    bool Cross(cM3dGUnk &, mVec3_c *);
+    bool Cross(cM3dGUnk &, f32 *);
     bool Cross(const mVec3_c &) const;
     void Clamp(const mVec3_c &, mVec3_c &) const;
 
     const mVec3_c &GetC() const {
         return mCenter;
     }
+    mVec3_c &GetC() {
+        return mCenter;
+    }
+    f32 GetH() const {
+        return mHeight;
+    }
+    f32 GetR() const {
+        return mRadius;
+    }
 };
 
 #endif
diff --git a/include/d/col/c/c_m3d_g_lin.h b/include/d/col/c/c_m3d_g_lin.h
index 02cea601..8b1d9d46 100644
--- a/include/d/col/c/c_m3d_g_lin.h
+++ b/include/d/col/c/c_m3d_g_lin.h
@@ -3,14 +3,16 @@
 
 #include "common.h"
 #include "m/m_vec.h"
+#include "nw4r/types_nw4r.h"
 
 class cM3dGLin {
 public:
     typedef nw4r::math::VEC3 VEC3;
     typedef EGG::Vector3f Vector3f;
 
-    /* 0x00 */ mVec3_c mStart;
-    /* 0x0C */ mVec3_c mEnd;
+    // Needs to be mutable for cCcD_CpsAttr::GetPos and cCcD_CpsAttr::GetShapeAccess
+    /* 0x00 */ mutable mVec3_c mStart;
+    /* 0x0C */ mutable mVec3_c mEnd;
 
     cM3dGLin() {}
 
@@ -32,34 +34,34 @@ public:
         mEnd = *pEnd;
     }
 
-    nw4r::math::VEC3 &GetStart() {
+    mVec3_c &GetStart() {
         return mStart;
     }
 
-    const nw4r::math::VEC3 &GetStart() const {
+    const mVec3_c &GetStart() const {
         return mStart;
     }
 
-    nw4r::math::VEC3 *GetStartP(void) {
+    mVec3_c *GetStartP(void) {
         return &mStart;
     }
-    const nw4r::math::VEC3 *GetStartP(void) const {
+    const mVec3_c *GetStartP(void) const {
         return &mStart;
     }
 
-    nw4r::math::VEC3 &GetEnd() {
+    mVec3_c &GetEnd() {
         return mEnd;
     }
 
-    const nw4r::math::VEC3 &GetEnd() const {
+    const mVec3_c &GetEnd() const {
         return mEnd;
     }
 
-    nw4r::math::VEC3 *GetEndP(void) {
+    mVec3_c *GetEndP(void) {
         return &mEnd;
     }
 
-    const nw4r::math::VEC3 *GetEndP(void) const {
+    const mVec3_c *GetEndP(void) const {
         return &mEnd;
     }
 };
diff --git a/include/d/col/c/c_m3d_g_pla.h b/include/d/col/c/c_m3d_g_pla.h
index cac47fbe..9abe43d8 100644
--- a/include/d/col/c/c_m3d_g_pla.h
+++ b/include/d/col/c/c_m3d_g_pla.h
@@ -3,6 +3,7 @@
 
 #include "c/c_math.h"
 #include "d/col/c/c_m3d.h"
+#include "m/m_angle.h"
 #include "m/m_vec.h"
 
 // Plane with a normal
@@ -36,6 +37,12 @@ public:
     const mVec3_c *GetNP() const {
         return &mNormal;
     }
+    mVec3_c &GetN() {
+        return mNormal;
+    }
+    const mVec3_c &GetN() const {
+        return mNormal;
+    }
     f32 GetD() const {
         return mD;
     }
@@ -46,13 +53,13 @@ public:
         return ((-mNormal.x * param_1->x - mNormal.z * param_1->z) - mD) / mNormal.y;
     }
 
-    s32 GetAngleY() const {
-        return cM::atan2s(mNormal.x, mNormal.z);
-    }
-
     f32 GetXZDist() const {
         return EGG::Math<f32>::sqrt(mNormal.x * mNormal.x + mNormal.z * mNormal.z);
     }
+
+    mAng GetAngleY() const {
+        return cM::atan2s(mNormal.x, mNormal.z);
+    }
 };
 
 #endif
diff --git a/include/d/col/c/c_m3d_g_sph.h b/include/d/col/c/c_m3d_g_sph.h
index 43480a97..0dd60c2e 100644
--- a/include/d/col/c/c_m3d_g_sph.h
+++ b/include/d/col/c/c_m3d_g_sph.h
@@ -20,14 +20,17 @@ public:
     bool Cross(const cM3dGTri *, f32 *, mVec3_c *);
     void Clamp(const mVec3_c &, mVec3_c &) const;
 
-    bool fn_80338750(cM3dGUnk *, mVec3_c *);
-    bool fn_80338760(cM3dGUnk *, f32 *);
+    bool Cross(cM3dGUnk &, mVec3_c *);
+    bool Cross(cM3dGUnk &, f32 *);
 
     void SetRatio(f32);
 
     const mVec3_c &GetC() const {
         return mCenter;
     }
+    mVec3_c &GetC() {
+        return mCenter;
+    }
 
     const f32 &GetR() const {
         return mRadius;
diff --git a/include/d/col/c/c_m3d_g_tri.h b/include/d/col/c/c_m3d_g_tri.h
index a6402cdc..dc90bbb7 100644
--- a/include/d/col/c/c_m3d_g_tri.h
+++ b/include/d/col/c/c_m3d_g_tri.h
@@ -3,6 +3,7 @@
 
 #include "common.h"
 #include "d/col/c/c_m3d_g_pla.h"
+#include "m/m_vec.h"
 
 class cM3dGTri : public cM3dGPla {
     typedef nw4r::math::VEC3 VecType;
@@ -12,13 +13,23 @@ public:
     /* 0x1C */ VecType mB;
     /* 0x28 */ VecType mC;
 
+    const mVec3_c &GetPntA() const {
+        return *(mVec3_c *)&mA;
+    }
+    const mVec3_c &GetPntB() const {
+        return *(mVec3_c *)&mB;
+    }
+    const mVec3_c &GetPntC() const {
+        return *(mVec3_c *)&mC;
+    }
+
     cM3dGTri() {}
     void SetPos(const VecType *, const VecType *, const VecType *);
 
     void SetBg(const VecType *, const VecType *, const VecType *, const cM3dGPla *pla);
 
-    bool cross(const cM3dGLin *lin, VecType *xyz, bool param_2, bool param_3) const {
-        return cM3d_Cross_LinTri(lin, this, xyz, param_2, param_3);
+    bool cross(const cM3dGLin &lin, VecType *xyz, bool param_2, bool param_3) const {
+        return cM3d_Cross_LinTri(lin, *this, xyz, param_2, param_3);
     }
 };
 
diff --git a/include/d/col/c/c_m3d_g_unk.h b/include/d/col/c/c_m3d_g_unk.h
index ea0de359..26533f4b 100644
--- a/include/d/col/c/c_m3d_g_unk.h
+++ b/include/d/col/c/c_m3d_g_unk.h
@@ -2,10 +2,11 @@
 #define C_M3D_G_UNK_H
 
 #include "common.h"
+#include "d/col/c/c_m3d.h"
+#include "d/col/c/c_m3d_g_lin.h"
 #include "m/m_mtx.h"
 #include "m/m_vec.h"
 
-
 struct cM3dGCps;
 struct cM3dGCyl;
 struct cM3dGSph;
@@ -16,8 +17,7 @@ public:
     /* 0x30 */ mMtx_c mInvMtx;
     /* 0x60 */ mVec3_c mMin;
     /* 0x6C */ mVec3_c mMax;
-    /* 0x78 */ mVec3_c mField_0x78;
-    /* 0x84 */ mVec3_c mField_0x84;
+    /* 0x78 */ cM3dGLin mLin;
     /* 0x90 */ mVec3_c mField_0x90;
     /* 0x9C */ mVec3_c mField_0x9C;
     /* 0xA8 */ mVec3_c mField_0xA8;
@@ -34,13 +34,13 @@ public:
     void Update();
     void GetStartEnd(mVec3_c &, mVec3_c &);
 
-    void fn_80338c30(cM3dGCps *, mVec3_c *);
-    bool fn_80338c40(cM3dGUnk *, mVec3_c *);
-    bool fn_80338ca0(/* TODO */);
-    bool fn_80338cb0(cM3dGCyl *, mVec3_c *);
-    bool fn_80338cc0(cM3dGCyl *, f32 *);
-    bool fn_80338cd0(cM3dGSph *, mVec3_c *);
-    bool fn_80338ce0(cM3dGSph *, f32 *);
+    bool Cross(cM3dGCps &, mVec3_c *);
+    bool Cross(cM3dGTri &, mVec3_c *);
+    bool Cross(cM3dGUnk &, mVec3_c *);
+    bool Cross(cM3dGCyl &, mVec3_c *);
+    bool Cross(cM3dGCyl &, f32 *);
+    bool Cross(cM3dGSph &, mVec3_c *);
+    bool Cross(cM3dGSph &, f32 *);
 
     void Set(const mMtx_c &);
     void Set(const mVec3_c &, const mAng &);