Editing collisions

Client/game_sa/CColModelSA.h

@@ -14,8 +14,10 @@
 #include <windows.h>
 #include <game/CColModel.h>
 
-#define FUNC_CColModel_Constructor      0x40FB60
-#define FUNC_CColModel_Destructor       0x40F700
+#define FUNC_CColModel_Constructor 0x40FB60
+#define FUNC_CColModel_Destructor  0x40F700
+
+enum class eCollisionShape;
 
 typedef struct
 {
@@ -27,22 +29,28 @@ typedef struct
 
 typedef struct
 {
-    CVector vecCenter;
-    float   fRadius;
+    CVector      vecCenter;
+    float        fRadius;
+    uchar        material;
+    uchar        flags;
+    CColLighting lighting;
+    uchar        light;
 } CColSphereSA;
 
 typedef struct
 {
-    CVector min;
-    CVector max;
+    CVector      min;
+    CVector      max;
+    uchar        material;
+    uchar        flags;
+    CColLighting lighting;
+    uchar        light;
 } CColBoxSA;
 
 typedef struct
 {
-    unsigned short v1;
-    unsigned short v2;
-    unsigned short v3;
-    EColSurface    material;
+    unsigned short vertex[3];
+    uchar          material;
     CColLighting   lighting;
 } CColTriangleSA;
 
@@ -58,19 +66,121 @@ typedef struct
     char  name[0x18];
 } ColModelFileHeader;
 
+typedef struct
+{
+    CVector m_vecStart;
+    float   m_fStartSize;
+    CVector m_vecEnd;
+    float   m_fEndSize;
+} CColLine;
+
+typedef struct
+{
+    CVector       m_vecStart;
+    float         m_fStartRadius;
+    unsigned char m_nMaterial;
+    unsigned char m_nPiece;
+    unsigned char m_nLighting;
+    char          _pad13;
+    CVector       m_vecEnd;
+    float         m_fEndRadius;
+} CColDisk;
+
+typedef struct
+{
+    signed __int16 x;
+    signed __int16 y;
+    signed __int16 z;
+    CVector        getVector() const { return CVector(x * 0.0078125f, y * 0.0078125f, z * 0.0078125f); }
+    void           setVector(CVector vec)
+    {
+        x = static_cast<signed __int16>(vec.fX * 128);
+        y = static_cast<signed __int16>(vec.fY * 128);
+        z = static_cast<signed __int16>(vec.fZ * 128);
+    }
+} CompressedVector;
+
 typedef struct
 {
     WORD                 numColSpheres;
     WORD                 numColBoxes;
     WORD                 numColTriangles;
     BYTE                 ucNumWheels;
-    BYTE                 pad3;
+    BYTE                 m_nFlags;
     CColSphereSA*        pColSpheres;
     CColBoxSA*           pColBoxes;
     void*                pSuspensionLines;
-    void*                pUnknown;
+    CompressedVector*    pVertices;
     CColTriangleSA*      pColTriangles;
     CColTrianglePlaneSA* pColTrianglePlanes;
+    unsigned int         m_nNumShadowTriangles;
+    unsigned int         m_nNumShadowVertices;
+    CompressedVector*    m_pShadowVertices;
+    CColTriangleSA*      m_pShadowTriangles;
+
+    std::map<ushort, CompressedVector> getAllVertices() const
+    {
+        std::map<ushort, CompressedVector> vertices;
+        for (uint i = 0; numColTriangles > i; i++)
+        {
+            vertices[pColTriangles[i].vertex[0]] = pVertices[pColTriangles[i].vertex[0]];
+            vertices[pColTriangles[i].vertex[1]] = pVertices[pColTriangles[i].vertex[1]];
+            vertices[pColTriangles[i].vertex[2]] = pVertices[pColTriangles[i].vertex[2]];
+        }
+        return vertices;
+    }
+
+    unsigned short getNumVertices() const
+    {
+        unsigned short numVertices = 0;
+        for (uint i = 0; numColTriangles > i; i++)
+        {
+            numVertices = std::max(std::max(numVertices, pColTriangles[i].vertex[0]), std::max(pColTriangles[i].vertex[1], pColTriangles[i].vertex[2]));
+        }
+        return numVertices;
+    }
+
+    bool isValidIndex(eCollisionShape eShape, ushort usIndex, ushort numVertices = 0) const
+    {
+        switch (eShape)
+        {
+            case eCollisionShape::BOX:
+                return (usIndex >= 0 && usIndex < numColBoxes);
+                break;
+            case eCollisionShape::SPHERE:
+                return (usIndex >= 0 && usIndex < numColSpheres);
+                break;
+            case eCollisionShape::TRIANGLE:
+                return (usIndex >= 0 && usIndex < numColTriangles);
+                break;
+            case eCollisionShape::VERTEX:
+                return (usIndex >= 0 && usIndex < numVertices);
+                break;
+        }
+        return false;
+    }
+
+    std::vector<ushort> getTrianglesByVertex(ushort usVertex) const
+    {
+        std::vector<ushort> vecTriangles;
+        CColTriangleSA      colTriangle;
+        for (ushort i = 0; i < numColTriangles; i++)
+        {
+            colTriangle = pColTriangles[i];
+            if (colTriangle.vertex[0] == usVertex || colTriangle.vertex[1] == usVertex || colTriangle.vertex[2] == usVertex)
+                vecTriangles.push_back(i);
+        }
+        return vecTriangles;
+    }
+
+    std::map<ushort, ushort> getVerticesUsage() const
+    {
+        std::map<ushort, ushort> verticesUsage;
+        for (ushort i = 0; i < numColTriangles; i++)
+            for (char cVertex = 0; cVertex < 3; cVertex++)
+                verticesUsage[pColTriangles[i].vertex[cVertex]]++;
+        return verticesUsage;
+    }
 } CColDataSA;
 
 class CColModelSAInterface

Client/mods/deathmatch/logic/CClientColModel.cpp

@@ -1,14 +1,15 @@
 /*****************************************************************************
  *
- *  PROJECT:     Multi Theft Auto v1.0
- *               (Shared logic for modifications)
+ *  PROJECT:     Multi Theft Auto
  *  LICENSE:     See LICENSE in the top level directory
- *  FILE:        mods/shared_logic/CClientColModel.cpp
+ *  FILE:        mods/deathmatch/logic/CClientColModel.cpp
  *  PURPOSE:     Model collision (.col file) entity class
  *
  *****************************************************************************/
 
 #include "StdInc.h"
+#include "../Client/game_sa/CModelInfoSA.h"
+#include "../Client/game_sa/CColModelSA.h"
 
 CClientColModel::CClientColModel(CClientManager* pManager, ElementID ID) : ClassInit(this), CClientEntity(ID)
 {
@@ -158,3 +159,19 @@ bool CClientColModel::IsCOLData(const SString& strData)
 {
     return strData.length() > 32 && memcmp(strData, "COL", 3) == 0 && strData[7] == 0;
 }
+
+CColModelSAInterface* CClientColModel::GetColModelInterface()
+{
+    if (m_pColModel)
+        return m_pColModel->GetInterface();
+    return nullptr;
+}
+
+void CClientColModel::UpdateVerticesCount()
+{
+    CColModelSAInterface* pInterface = GetColModelInterface();
+    CColDataSA*           pColData = pInterface->pColData;
+
+    if (pColData)
+        m_iVerticesCount = static_cast<unsigned short>(pColData->getNumVertices());
+}

Client/mods/deathmatch/logic/CClientColModel.h

@@ -13,7 +13,10 @@
 #include <list>
 #include "CClientEntity.h"
 
-class CClientColModel final : public CClientEntity
+constexpr int MaxCollisionSize = 128;            // collision bounding box in each axis
+constexpr int MaxCollisionSize2 = MaxCollisionSize * 2;
+
+class CClientColModel : public CClientEntity
 {
     DECLARE_CLASS(CClientColModel, CClientEntity)
 public:
@@ -22,17 +25,66 @@ class CClientColModel final : public CClientEntity
 
     eClientEntityType GetType() const { return CCLIENTCOL; }
 
-    bool LoadCol(const SString& strFile, bool bIsRawData);
-    bool Load(bool isRaw, SString input);
-
-    bool IsLoaded() { return m_pColModel != NULL; };
+    bool           LoadCol(const SString& strFile, bool bIsRawData);
+    bool           Load(bool isRaw, SString input);
+    int            GetVerticesCount() const { return m_iVerticesCount; };
+    void           SetCollisionHasChanged(bool bChanged) { b_hasChanged = bChanged; };
+    bool           HasChanged() const { return b_hasChanged; };
+    bool           IsLoaded() { return m_pColModel != NULL; };
 
     bool Replace(unsigned short usModel);
     void Restore(unsigned short usModel);
     void RestoreAll();
 
     bool        HasReplaced(unsigned short usModel);
     static bool IsCOLData(const SString& strData);
+    static bool CheckVector(CVector& vec, float fRadius = 0)
+    {
+        if (fRadius > 0)
+        {
+            return (MaxCollisionSize >= vec.fX + fRadius && vec.fX + fRadius >= -MaxCollisionSize && MaxCollisionSize >= vec.fY + fRadius &&
+                    vec.fY + fRadius >= -MaxCollisionSize && MaxCollisionSize >= vec.fZ + fRadius && vec.fZ + fRadius >= -MaxCollisionSize) &&
+                   (MaxCollisionSize >= vec.fX - fRadius && vec.fX - fRadius >= -MaxCollisionSize && MaxCollisionSize >= vec.fY - fRadius &&
+                    vec.fY - fRadius >= -MaxCollisionSize && MaxCollisionSize >= vec.fZ - fRadius && vec.fZ - fRadius >= -MaxCollisionSize);
+        }
+        return (MaxCollisionSize >= vec.fX && vec.fX >= -MaxCollisionSize && MaxCollisionSize >= vec.fY && vec.fY >= -MaxCollisionSize &&
+                    MaxCollisionSize >= vec.fZ && vec.fZ >= -MaxCollisionSize);
+    }
+    static bool CheckMoveVector(CVector& vec, float fRadius = 0)
+    {
+        if (fRadius > 0)
+        {
+            return ((MaxCollisionSize2 >= vec.fX + fRadius >= -MaxCollisionSize2 && MaxCollisionSize2 >= vec.fY + fRadius >= -MaxCollisionSize2 &&
+                     MaxCollisionSize2 >= vec.fZ + fRadius >= -MaxCollisionSize2) &&
+                    (MaxCollisionSize2 >= vec.fX - fRadius >= -MaxCollisionSize2 && MaxCollisionSize2 >= vec.fY - fRadius >= -MaxCollisionSize2 &&
+                     MaxCollisionSize2 >= vec.fZ - fRadius >= -MaxCollisionSize2));
+        }
+        return (MaxCollisionSize2 >= vec.fX && vec.fX >= -MaxCollisionSize2 && MaxCollisionSize2 >= vec.fY && vec.fY >= -MaxCollisionSize2 &&
+                    MaxCollisionSize2 >= vec.fZ && vec.fZ >= -MaxCollisionSize2);
+    }
+
+    // CompareVector returns true if all points in the second vector are greater than the corresponding points in the first vector
+    static bool CompareVector(CVector& vecMin, CVector& vecMax) { return vecMax.fX >= vecMin.fX && vecMax.fY >= vecMin.fY && vecMax.fZ >= vecMin.fZ; }
+
+    // AlignVector clamps a "source" vector between a min and max vector. Or something like that. I don't know.
+    static void AlignVector(CVector& destMin, CVector& destMax, const CVector& src)
+    {
+        if (src.fX < destMax.fX)
+            destMax.fX = src.fX;
+        if (src.fY < destMax.fY)
+            destMax.fY = src.fY;
+        if (src.fZ < destMax.fZ)
+            destMax.fZ = src.fZ;
+        if (src.fX > destMin.fX)
+            destMin.fX = src.fX;
+        if (src.fY > destMin.fY)
+            destMin.fY = src.fY;
+        if (src.fZ > destMin.fZ)
+            destMin.fZ = src.fZ;
+    }
+    void UpdateVerticesCount();
+
+    CColModelSAInterface* GetColModelInterface();
 
     // Sorta a hack that these are required by CClientEntity...
     void Unlink(){};
@@ -46,7 +98,12 @@ class CClientColModel final : public CClientEntity
     void InternalRestore(unsigned short usModel);
 
     class CClientColModelManager* m_pColModelManager;
+    int                           m_iVerticesCount;
+    CColModel*                    m_pColModel;
+    std::list<unsigned short>     m_Replaced;
 
-    CColModel*                m_pColModel;
-    std::list<unsigned short> m_Replaced;
+    // m_bHasChanged should be set to true when the bounding box has changed.
+    // This ensures that the bounding box is only recalculated when necessary.
+    // This is true by default as an object loaded collision could have the wrong bounding box.
+    bool b_hasChanged = true;
 };

Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.cpp

@@ -661,6 +661,23 @@ ADD_ENUM(SURFACE_ADHESION_GROUP_SAND, "sand")
 ADD_ENUM(SURFACE_ADHESION_GROUP_WET, "wet")
 IMPLEMENT_ENUM_END("surface-adhesion-group")
 
+IMPLEMENT_ENUM_CLASS_BEGIN(eCollisionShape)
+ADD_ENUM(eCollisionShape::BOX, "box")
+ADD_ENUM(eCollisionShape::SPHERE, "sphere")
+ADD_ENUM(eCollisionShape::TRIANGLE, "triangle")
+ADD_ENUM(eCollisionShape::VERTEX, "vertex")
+IMPLEMENT_ENUM_CLASS_END("collision-shape")
+
+IMPLEMENT_ENUM_CLASS_BEGIN(eCollisionKey)
+ADD_ENUM(eCollisionKey::SIZE, "size")
+ADD_ENUM(eCollisionKey::MATERIAL, "material")
+ADD_ENUM(eCollisionKey::POSITION, "position")
+ADD_ENUM(eCollisionKey::RADIUS, "radius")
+ADD_ENUM(eCollisionKey::LIGHTING, "lighting")
+ADD_ENUM(eCollisionKey::VERTICES, "vertices")
+ADD_ENUM(eCollisionKey::MOVE, "move")
+IMPLEMENT_ENUM_CLASS_END("collision-key")
+
 IMPLEMENT_ENUM_CLASS_BEGIN(eClientModelType)
 ADD_ENUM(eClientModelType::PED, "ped")
 ADD_ENUM(eClientModelType::OBJECT, "object")

Client/mods/deathmatch/logic/lua/CLuaFunctionParseHelpers.h

@@ -65,6 +65,7 @@ DECLARE_ENUM(eSurfaceBulletEffect);
 DECLARE_ENUM(eSurfaceWheelEffect);
 DECLARE_ENUM(eSurfaceSkidMarkType);
 DECLARE_ENUM(eSurfaceAdhesionGroup);
+DECLARE_ENUM_CLASS(eCollisionShape);
 DECLARE_ENUM_CLASS(eClientModelType);
 
 class CRemoteCall;
@@ -106,6 +107,18 @@ enum eJSONPrettyType
 };
 DECLARE_ENUM(eJSONPrettyType);
 
+enum class eCollisionKey
+{
+    SIZE,
+    MATERIAL,
+    POSITION,
+    RADIUS,
+    LIGHTING,
+    VERTICES,
+    MOVE,
+};
+DECLARE_ENUM_CLASS(eCollisionKey);
+
 // class -> class type
 inline eCGUIType GetClassType(CGUIButton*)
 {
@@ -455,6 +468,14 @@ inline SString GetClassByTypeName(eObjectGroup::BreakMode*)
 {
     return "objectgroup-breakmode";
 }
+inline SString GetClassTypeName(eCollisionShape*)
+{
+    return "collision-shape";
+}
+inline SString GetClassTypeName(eCollisionKey*)
+{
+    return "collision-key";
+}
 
 inline SString GetClassByTypeName(eClientModelType)
 {