Resolve remaining collisionless objects (Fixes #927)

Client/game_sa/CColModelSA.h

@@ -11,77 +11,165 @@
 
 #pragma once
 
-#include <windows.h>
 #include <game/CColModel.h>
+#include "CCompressedVectorSA.h"
 
 #define FUNC_CColModel_Constructor      0x40FB60
 #define FUNC_CColModel_Destructor       0x40F700
 
-typedef struct
+struct CBoxSA
 {
-    CVector vecMin;
-    CVector vecMax;
-    CVector vecOffset;
-    FLOAT   fRadius;
-} CBoundingBoxSA;
+    CVector m_vecMin;
+    CVector m_vecMax;
+};
+static_assert(sizeof(CBoxSA) == 0x18, "Invalid size for CBoxSA");
 
-typedef struct
+struct CBoundingBoxSA : CBoxSA
 {
-    CVector vecCenter;
-    float   fRadius;
-} CColSphereSA;
+};
+static_assert(sizeof(CBoundingBoxSA) == 0x18, "Invalid size for CBoundingBoxSA");
 
-typedef struct
+struct CColBoxSA : CBoxSA
 {
-    CVector min;
-    CVector max;
-} CColBoxSA;
+    EColSurface  m_material;
+    std::uint8_t m_flags;
+    CColLighting m_lighting;
+    std::uint8_t m_brightness;
+};
+static_assert(sizeof(CColBoxSA) == 0x1C, "Invalid size for CColBoxSA");
 
-typedef struct
+struct CColLineSA
 {
-    unsigned short v1;
-    unsigned short v2;
-    unsigned short v3;
-    EColSurface    material;
-    CColLighting   lighting;
-} CColTriangleSA;
-
-typedef struct
+    CVector m_vecStart;
+    float   m_startSize;
+    CVector m_vecStop;
+    float   m_stopSize;
+};
+static_assert(sizeof(CColLineSA) == 0x20, "Invalid size for CColLineSA");
+
+struct CColDiskSA
+{
+    CVector      m_startPosition;
+    float        m_startRadius;
+    std::uint8_t m_material;
+    std::uint8_t m_piece;
+    std::uint8_t m_lighting;
+    CVector      m_stopPosition;
+    float        m_stopRadius;
+};
+static_assert(sizeof(CColDiskSA) == 0x24, "Invalid size for CColDiskSA");
+
+struct CSphereSA
 {
-    BYTE pad0[12];
-} CColTrianglePlaneSA;
+    CVector m_center;
+    float   m_radius;
+};
+static_assert(sizeof(CSphereSA) == 0x10, "Invalid size for CSphereSA");
 
-typedef struct
+struct CColSphereSA : CSphereSA
+{
+    union
+    {
+        EColSurface  m_material;
+        std::uint8_t m_collisionSlot;
+    };
+
+    union
+    {
+        std::uint8_t m_flags;
+
+        struct
+        {
+            std::uint8_t m_hasSpheresBoxesTriangles : 1;
+            std::uint8_t m_isSingleAllocationCollisionData : 1;
+            std::uint8_t m_isActive: 1;
+            std::uint8_t m_flag0x08 : 1;
+            std::uint8_t m_flag0x10 : 1;
+            std::uint8_t m_flag0x20 : 1;
+            std::uint8_t m_flag0x40 : 1;
+            std::uint8_t m_flag0x80 : 1;
+        };
+    };
+
+    std::uint8_t m_lighting;
+    std::uint8_t m_light;
+
+    CColSphereSA()
+    {
+        m_collisionSlot = 0;
+        m_flags = 0;
+        m_lighting = 0;
+        m_light = 0;
+    }
+};
+static_assert(sizeof(CColSphereSA) == 0x14, "Invalid size for CColSphereSA");
+
+struct CColTriangleSA
+{
+    std::uint16_t m_indices[3];
+    EColSurface   m_material;
+    CColLighting  m_lighting;
+};
+static_assert(sizeof(CColTriangleSA) == 0x8, "Invalid size for CColTriangleSA");
+
+struct CColTrianglePlaneSA
+{
+    CCompressedVectorSA m_normal;
+    std::uint16_t       m_distance;
+    std::uint8_t        m_orientation;
+};
+static_assert(sizeof(CColTrianglePlaneSA) == 0xA, "Invalid size for CColTrianglePlaneSA");
+
+struct ColModelFileHeader
 {
     char  version[4];
     DWORD size;
     char  name[0x18];
-} ColModelFileHeader;
+};
 
-typedef struct
+struct CColDataSA
 {
-    WORD                 numColSpheres;
-    WORD                 numColBoxes;
-    WORD                 numColTriangles;
-    BYTE                 ucNumWheels;
-    BYTE                 pad3;
-    CColSphereSA*        pColSpheres;
-    CColBoxSA*           pColBoxes;
-    void*                pSuspensionLines;
-    void*                pUnknown;
-    CColTriangleSA*      pColTriangles;
-    CColTrianglePlaneSA* pColTrianglePlanes;
-} CColDataSA;
-
-class CColModelSAInterface
+    std::uint16_t m_numSpheres;
+    std::uint16_t m_numBoxes;
+    std::uint16_t m_numTriangles;
+    std::uint8_t  m_numSuspensionLines;
+    union
+    {
+        std::uint8_t m_flags;
+
+        struct
+        {
+            std::uint8_t m_usesDisks : 1;
+            std::uint8_t m_notEmpty : 1;
+            std::uint8_t m_hasShadowInfo : 1;
+            std::uint8_t m_hasFaceGroups : 1;
+            std::uint8_t m_hasShadow : 1;
+        };
+    };
+    CColSphereSA* m_spheres;
+    CColBoxSA*    m_boxes;
+    union
+    {
+        CColLineSA* m_suspensionLines;
+        CColDiskSA* m_disks;
+    };
+    CCompressedVectorSA* m_vertices;
+    CColTriangleSA*      m_triangles;
+    CColTrianglePlaneSA* m_trianglePlanes;
+    std::uint32_t        m_numShadowTriangles;
+    std::uint32_t        m_numShadowVertices;
+    CCompressedVectorSA* m_shadowVertices;
+    CColTriangleSA*      m_shadowTriangles;
+};
+static_assert(sizeof(CColDataSA) == 0x30, "Invalid size for CColDataSA");
+
+struct CColModelSAInterface
 {
-public:
-    CBoundingBoxSA boundingBox;
-    BYTE           level;
-    BYTE           unknownFlags;
-    BYTE           pad[2];
-    CColDataSA*    pColData;
+    CBoundingBoxSA m_bounds;
+    CColSphereSA   m_sphere;
+    CColDataSA*    m_data;
 };
+static_assert(sizeof(CColModelSAInterface) == 0x30, "Invalid size for CColModelSAInterface");
 
 class CColModelSA : public CColModel
 {
@@ -90,8 +178,8 @@ class CColModelSA : public CColModel
     CColModelSA(CColModelSAInterface* pInterface);
     ~CColModelSA();
 
-    CColModelSAInterface* GetInterface() { return m_pInterface; }
-    void                  Destroy() { delete this; }
+    CColModelSAInterface* GetInterface() override { return m_pInterface; }
+    void                  Destroy() override { delete this; }
 
 private:
     CColModelSAInterface* m_pInterface;

Client/game_sa/CColStoreSA.cpp

@@ -0,0 +1,152 @@
+/*****************************************************************************
+ *
+ *  PROJECT:     Multi Theft Auto
+ *  LICENSE:     See LICENSE in the top level directory
+ *  FILE:        game_sa/CColStoreSA.cpp
+ *
+ *  Multi Theft Auto is available from https://multitheftauto.com/
+ *
+ *****************************************************************************/
+
+#include "StdInc.h"
+#include "CColStoreSA.h"
+
+void CColStoreSA::Initialise()
+{
+    using Signature = void(__cdecl*)();
+    const auto function = reinterpret_cast<Signature>(0x4113F0);
+    function();
+}
+
+void CColStoreSA::Shutdown()
+{
+    using Signature = void(__cdecl*)();
+    const auto function = reinterpret_cast<Signature>(0x4114D0);
+    function();
+}
+
+void CColStoreSA::BoundingBoxesPostProcess()
+{
+    using Signature = void(__cdecl*)();
+    const auto function = reinterpret_cast<Signature>(0x410EC0);
+    function();
+}
+
+int CColStoreSA::AddColSlot(const char* name)
+{
+    using Signature = int(__cdecl*)(const char*);
+    const auto function = reinterpret_cast<Signature>(0x411140);
+    return function(name);
+}
+
+bool CColStoreSA::IsValidSlot(CollisionSlot slot)
+{
+    using Signature = bool(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x410660);
+    return function(slot);
+}
+
+void CColStoreSA::AddCollisionNeededAtPosition(const CVector& position)
+{
+    using Signature = void(__cdecl*)(const CVector&);
+    const auto function = reinterpret_cast<Signature>(0x4103A0);
+    function(position);
+}
+
+void CColStoreSA::EnsureCollisionIsInMemory(const CVector& position)
+{
+    using Signature = void(__cdecl*)(const CVector&);
+    const auto function = reinterpret_cast<Signature>(0x410AD0);
+    function(position);
+}
+
+bool CColStoreSA::HasCollisionLoaded(const CVector& position, int areaCode)
+{
+    using Signature = bool(__cdecl*)(const CVector&, int);
+    const auto function = reinterpret_cast<Signature>(0x410CE0);
+    return function(position, areaCode);
+}
+
+void CColStoreSA::RequestCollision(const CVector& position, int areaCode)
+{
+    using Signature = void(__cdecl*)(const CVector&, int);
+    const auto function = reinterpret_cast<Signature>(0x410C00);
+    function(position, areaCode);
+}
+
+void CColStoreSA::SetCollisionRequired(const CVector& position, int areaCode)
+{
+    using Signature = void(__cdecl*)(const CVector&, int);
+    const auto function = reinterpret_cast<Signature>(0x4104E0);
+    function(position, areaCode);
+}
+
+void CColStoreSA::RemoveAllCollision()
+{
+    using Signature = void(__cdecl*)();
+    const auto function = reinterpret_cast<Signature>(0x410E00);
+    function();
+}
+
+void CColStoreSA::AddRef(CollisionSlot slot)
+{
+    using Signature = void(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x4107A0);
+    function(slot);
+}
+
+void CColStoreSA::RemoveRef(CollisionSlot slot)
+{
+    using Signature = void(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x4107D0);
+    function(slot);
+}
+
+void CColStoreSA::RemoveCol(CollisionSlot slot)
+{
+    using Signature = void(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x410730);
+    function(slot);
+}
+
+void CColStoreSA::RemoveColSlot(CollisionSlot slot)
+{
+    using Signature = void(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x411330);
+    function(slot);
+}
+
+void CColStoreSA::LoadAllBoundingBoxes()
+{
+    using Signature = void(__cdecl*)();
+    const auto function = reinterpret_cast<Signature>(0x4113D0);
+    function();
+}
+
+CColStore::BoundingBox CColStoreSA::GetBoundingBox(CollisionSlot slot)
+{
+    using Signature = BoundingBox&(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x410800);
+    return function(slot);
+}
+
+void CColStoreSA::IncludeModelIndex(CollisionSlot slot, std::uint16_t model)
+{
+    using Signature = void(__cdecl*)(CollisionSlot, int);
+    const auto function = reinterpret_cast<Signature>(0x410820);
+    function(slot, model);
+}
+
+int CColStoreSA::GetFirstModel(CollisionSlot slot)
+{
+    using Signature = int(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x537A80);
+    return function(slot);
+}
+
+int CColStoreSA::GetLastModel(CollisionSlot slot)
+{
+    using Signature = int(__cdecl*)(CollisionSlot);
+    const auto function = reinterpret_cast<Signature>(0x537AB0);
+    return function(slot);
+}