OBJ Init

source/game/field/CollisionDirector.cc

@@ -10,7 +10,7 @@ void CollisionDirector::checkCourseColNarrScLocal(f32 radius, const EGG::Vector3
 
 /// @addr{0x8078F500}
 bool CollisionDirector::checkSphereFull(f32 radius, const EGG::Vector3f &v0,
-        const EGG::Vector3f &v1, KCLTypeMask flags, CourseColMgr::CollisionInfo *pInfo,
+        const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
         KCLTypeMask *pFlagsOut, u32 /*start*/) {
     if (pInfo) {
         pInfo->bbox.min = EGG::Vector3f::zero;
@@ -56,7 +56,7 @@ bool CollisionDirector::checkSphereFull(f32 radius, const EGG::Vector3f &v0,
 
 /// @addr{0x8078F784}
 bool CollisionDirector::checkSphereFullPush(f32 radius, const EGG::Vector3f &v0,
-        const EGG::Vector3f &v1, KCLTypeMask flags, CourseColMgr::CollisionInfo *pInfo,
+        const EGG::Vector3f &v1, KCLTypeMask flags, CollisionInfo *pInfo,
         KCLTypeMask *pFlagsOut, u32 /*param_8*/) {
     if (pInfo) {
         pInfo->bbox.setZero();
@@ -102,7 +102,7 @@ bool CollisionDirector::checkSphereFullPush(f32 radius, const EGG::Vector3f &v0,
 
 /// @addr{0x807903BC}
 bool CollisionDirector::checkSphereCachedPartialPush(const EGG::Vector3f &pos,
-        const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CourseColMgr::CollisionInfo *colInfo,
+        const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CollisionInfo *colInfo,
         KCLTypeMask *typeMaskOut, f32 radius, u32 /*start*/) {
     if (colInfo) {
         colInfo->bbox.setZero();
@@ -129,7 +129,7 @@ bool CollisionDirector::checkSphereCachedPartialPush(const EGG::Vector3f &pos,
 
 /// @addr{0x807907F8}
 bool CollisionDirector::checkSphereCachedFullPush(const EGG::Vector3f &pos,
-        const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CourseColMgr::CollisionInfo *colInfo,
+        const EGG::Vector3f &prevPos, KCLTypeMask typeMask, CollisionInfo *colInfo,
         KCLTypeMask *typeMaskOut, f32 radius, u32 /*start*/) {
     if (colInfo) {
         colInfo->bbox.min.setZero();

source/game/field/CollisionDirector.hh

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "game/field/CourseColMgr.hh"
+#include "game/field/CollisionInfo.hh"
 
 #include <egg/math/Vector.hh>
 
@@ -24,17 +25,17 @@ public:
             u32 /*unused*/);
 
     bool checkSphereFull(f32 radius, const EGG::Vector3f &v0, const EGG::Vector3f &v1,
-            KCLTypeMask flags, CourseColMgr::CollisionInfo *pInfo, KCLTypeMask *pFlagsOut,
+            KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut,
             u32 /*start*/);
     bool checkSphereFullPush(f32 radius, const EGG::Vector3f &v0, const EGG::Vector3f &v1,
-            KCLTypeMask flags, CourseColMgr::CollisionInfo *pInfo, KCLTypeMask *pFlagsOut,
+            KCLTypeMask flags, CollisionInfo *pInfo, KCLTypeMask *pFlagsOut,
             u32 /*start*/);
 
     bool checkSphereCachedPartialPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
-            KCLTypeMask typeMask, CourseColMgr::CollisionInfo *colInfo, KCLTypeMask *typeMaskOut,
+            KCLTypeMask typeMask, CollisionInfo *colInfo, KCLTypeMask *typeMaskOut,
             f32 radius, u32 start);
     bool checkSphereCachedFullPush(const EGG::Vector3f &pos, const EGG::Vector3f &prevPos,
-            KCLTypeMask typeMask, CourseColMgr::CollisionInfo *colInfo, KCLTypeMask *typeMaskOut,
+            KCLTypeMask typeMask, CollisionInfo *colInfo, KCLTypeMask *typeMaskOut,
             f32 radius, u32 start);
 
     void resetCollisionEntries(KCLTypeMask *ptr);

source/game/field/CollisionInfo.cc

@@ -0,0 +1,41 @@
+#include "CollisionInfo.hh"
+
+#include "game/field/KCollisionTypes.hh"
+
+namespace Field
+{
+
+void CollisionInfo::updateFloor(f32 dist, const EGG::Vector3f &fnrm) {
+    if (dist > floorDist) {
+        floorDist = dist;
+        floorNrm = fnrm;
+    }
+}
+
+void CollisionInfo::updateWall(f32 dist, const EGG::Vector3f &fnrm) {
+    if (dist > wallDist) {
+        wallDist = dist;
+        wallNrm = fnrm;
+    }
+}
+
+void CollisionInfo::update(f32 now_dist, const EGG::Vector3f &offset,
+        const EGG::Vector3f &fnrm, u32 kclAttributeTypeBit) {
+    bbox.min = bbox.min.minimize(offset);
+    bbox.max = bbox.max.maximize(offset);
+
+    if (kclAttributeTypeBit & KCL_TYPE_FLOOR) {
+        updateFloor(now_dist, fnrm);
+    } else if (kclAttributeTypeBit & KCL_TYPE_WALL) {
+        if (wallDist > -std::numeric_limits<f32>::min()) {
+            f32 dot = 1.0f - wallNrm.ps_dot(fnrm);
+            if (dot > perpendicularity) {
+                perpendicularity = std::min(dot, 1.0f);
+            }
+        }
+
+        updateWall(now_dist, fnrm);
+    }
+}
+
+} // namespace Field

source/game/field/CollisionInfo.hh

@@ -0,0 +1,28 @@
+#pragma once
+#include <Common.hh>
+
+#include "egg/math/BoundBox.hh"
+#include "egg/math/Vector.hh"
+
+namespace Field
+{
+
+/// @brief Structure regrouping information on a particular collision
+struct CollisionInfo {
+    EGG::BoundBox3f bbox;
+    EGG::Vector3f tangentOff;
+    EGG::Vector3f floorNrm;
+    EGG::Vector3f wallNrm;
+    EGG::Vector3f _3c;
+    f32 floorDist;
+    f32 wallDist;
+    f32 _50;
+    f32 perpendicularity;
+
+    void updateFloor(f32 dist, const EGG::Vector3f &fnrm);
+    void updateWall(f32 dist, const EGG::Vector3f &fnrm);
+    void update(f32 now_dist, const EGG::Vector3f &offset, const EGG::Vector3f &fnrm,
+            u32 kclAttributeTypeBit);
+};
+
+} // namespace Field

source/game/field/CourseColMgr.cc

@@ -298,39 +298,6 @@ bool CourseColMgr::doCheckMaskOnlyPush(KColData *data, CollisionCheckFunc collis
     return hasCol;
 }
 
-void CourseColMgr::CollisionInfo::updateFloor(f32 dist, const EGG::Vector3f &fnrm) {
-    if (dist > floorDist) {
-        floorDist = dist;
-        floorNrm = fnrm;
-    }
-}
-
-void CourseColMgr::CollisionInfo::updateWall(f32 dist, const EGG::Vector3f &fnrm) {
-    if (dist > wallDist) {
-        wallDist = dist;
-        wallNrm = fnrm;
-    }
-}
-
-void CourseColMgr::CollisionInfo::update(f32 now_dist, const EGG::Vector3f &offset,
-        const EGG::Vector3f &fnrm, u32 kclAttributeTypeBit) {
-    bbox.min = bbox.min.minimize(offset);
-    bbox.max = bbox.max.maximize(offset);
-
-    if (kclAttributeTypeBit & KCL_TYPE_FLOOR) {
-        updateFloor(now_dist, fnrm);
-    } else if (kclAttributeTypeBit & KCL_TYPE_WALL) {
-        if (wallDist > -std::numeric_limits<f32>::min()) {
-            f32 dot = 1.0f - wallNrm.ps_dot(fnrm);
-            if (dot > perpendicularity) {
-                perpendicularity = std::min(dot, 1.0f);
-            }
-        }
-
-        updateWall(now_dist, fnrm);
-    }
-}
-
 CourseColMgr *CourseColMgr::s_instance = nullptr; ///< @addr{0x809C3C10}
 
 } // namespace Field

source/game/field/CourseColMgr.hh

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "game/field/CollisionInfo.hh"
 #include "game/field/KColData.hh"
 
 #include <egg/math/BoundBox.hh>
@@ -17,23 +18,6 @@ typedef bool (
 /// @nosubgrouping
 class CourseColMgr {
 public:
-    struct CollisionInfo {
-        EGG::BoundBox3f bbox;
-        EGG::Vector3f tangentOff;
-        EGG::Vector3f floorNrm;
-        EGG::Vector3f wallNrm;
-        EGG::Vector3f _3c;
-        f32 floorDist;
-        f32 wallDist;
-        f32 _50;
-        f32 perpendicularity;
-
-        void updateFloor(f32 dist, const EGG::Vector3f &fnrm);
-        void updateWall(f32 dist, const EGG::Vector3f &fnrm);
-        void update(f32 now_dist, const EGG::Vector3f &offset, const EGG::Vector3f &fnrm,
-                u32 kclAttributeTypeBit);
-    };
-
     struct NoBounceWallColInfo {
         EGG::BoundBox3f bbox;
         EGG::Vector3f tangentOff;

source/game/field/KColData.cc

@@ -47,7 +47,7 @@ KColData::KColData(const void *file) {
     m_prisms = reinterpret_cast<const KCollisionPrism *>(
             addOffset(m_prismData, sizeof(KCollisionPrism)));
     m_prismCount =
-            (reinterpret_cast<uintptr_t>(m_blockData) - reinterpret_cast<uintptr_t>(m_prisms + 1)) /
+            (reinterpret_cast<uintptr_t>(m_blockData) - reinterpret_cast<uintptr_t>(m_prisms)) /
             sizeof(KCollisionPrism);
 
     computeBBox();
@@ -91,7 +91,7 @@ void KColData::computeBBox() {
     m_bbox.max.set(-999999.0f);
     m_bbox.min.set(999999.0f);
 
-    for (size_t i = 0; i < m_prismCount; i++) {
+    for (size_t i = 1; i < m_prismCount; i++) {
         const KCollisionPrism prism = getPrism(i);
 
         const EGG::Vector3f fnrm = getNrm(prism.fnrm_i);
@@ -297,6 +297,10 @@ u16 KColData::prismCache(u32 idx) const {
     return m_prismCache[idx];
 }
 
+EGG::BoundBox3f KColData::bbox() const {
+    return m_bbox;
+}
+
 /// @brief Computes a prism vertex based off of the triangle's normal vectors
 /// @addr{0x807BDF54}
 /// @par Triangle Vertices Formula

source/game/field/KColData.hh

@@ -57,6 +57,7 @@ public:
 
     /// @beginGetters
     u16 prismCache(u32 idx) const;
+    EGG::BoundBox3f bbox() const;
     /// @endGetters
 
     static EGG::Vector3f GetVertex(f32 height, const EGG::Vector3f &vertex1,

source/game/field/obj/GeoHitTable.cc

@@ -0,0 +1,44 @@
+#include "game/field/obj/GeoHitTable.hh"
+#include "egg/util/Stream.hh"
+#include "game/system/ResourceManager.hh"
+
+namespace Field {
+
+/// @addr{0x807F9278}
+GeoHitTable::GeoHitTable(const char* filename) {
+    constexpr int OFFSET_HITPARAMS = 8;
+    auto atOffset = [](void* buffer, u32 offset) -> void* {
+        return reinterpret_cast<void*>(reinterpret_cast<u8*>(buffer) + offset);
+    };
+
+    void* file = GeoHitTable::LoadFile(filename);
+    EGG::RamStream header = EGG::RamStream(reinterpret_cast<u8*>(file), sizeof(GeoHitTableHeader));
+
+    m_objectCount = header.read_u16();
+    m_hitParameterCount = header.read_u16();
+    m_hitParametersArray = reinterpret_cast<void**>(operator new[](m_objectCount * sizeof(void*)));
+
+    u32 hitParamsSize = m_hitParameterCount * sizeof(u16);
+    u32 entrySize = sizeof(u16) + hitParamsSize; // add id
+    u8* hitParamData = reinterpret_cast<u8*>(atOffset(file, OFFSET_HITPARAMS));
+    EGG::RamStream hitParams = EGG::RamStream(hitParamData, entrySize * m_objectCount);
+
+    for (u16 i = 0; i < m_objectCount; i++) {
+        hitParams.skip(sizeof(u16));
+        m_hitParametersArray[i] = hitParams.data();
+        hitParams.skip(hitParamsSize);
+    }
+
+    m_moreData = hitParams.data();
+}
+
+void* GeoHitTable::LoadFile(const char* filename) {
+    return System::ResourceManager::Instance()->getFile(filename, nullptr, System::ArchiveId::Core);
+}
+
+/// @addr{0x807F9348}
+GeoHitTable::~GeoHitTable() {
+    delete[] m_hitParametersArray;
+}
+
+} // namespace Field

source/game/field/obj/GeoHitTable.hh

@@ -0,0 +1,34 @@
+#pragma once
+#include <Common.hh>
+
+namespace Field {
+
+/// @brief 
+struct GeoHitTableHeader {
+    u16 m_objectCount;
+    u16 m_hitParameterCount;
+};
+
+/// @brief Parser and holder for player-object/item-object parameter tables stored in files in Common.szs
+/// @details There are 4 files in Common.szs that store interaction parameters for collisions between objects and players or items.
+/// GeoHitTableKart.bin : player-object collision effects on players (e.g. colliding with a cactus makes the player spin out)
+/// GeoHitTableKartObj.bin : player-object collision effects on objects (e.g. colliding with a crate in DS Delfino Square destroys the crate)
+/// GeoHitTableItem.bin : item-object collision effects on items (e.g. a green shell colliding with a pipe in SNES Mario Circuit 3 will bounce off of it as if it were a wall)
+/// GeoHitTableItemObj.bin : item-object collision effects on objects (e.g. a green shell colliding with a goomba with squish it and drop a mushroom)
+///
+/// Note: in the game, there are 4 derived classes for these tables. However, they are all the same size and have no virtual functions besides a default destructor.
+class GeoHitTable {
+public:
+    GeoHitTable(const char *filename);
+    virtual ~GeoHitTable();
+
+    static void *LoadFile(const char *filename);
+private:
+    // the game uses a cursor member, I used a ramstream instead
+    u16 m_objectCount;
+    u16 m_hitParameterCount;
+    void** m_hitParametersArray;
+    void* m_moreData;
+};
+
+} // namespace Field