Add vehicle dependent dummy positions (PR #1982)

Author: botder

Client/game_sa/CAutomobileSA.h

@@ -184,7 +184,7 @@ class CAutomobileSAInterface : public CVehicleSAInterface
     char                      field_963;
     float                     field_964;
     int                       m_wheelFrictionState[4];
-    void*                     pNitroParticle[2];
+    CFxSystemSAInterface*     pNitroParticle[2];
     char                      field_980;
     char                      field_981;
     short                     field_982;

Client/game_sa/CFxSystemSA.cpp

@@ -69,13 +69,18 @@ void CFxSystemSA::GetPosition(CVector& vecPos)
 
 void CFxSystemSA::SetPosition(const CVector& vecPos)
 {
-    m_pInterface->matPosition.pos.x = vecPos.fX;
-    m_pInterface->matPosition.pos.y = vecPos.fY;
-    m_pInterface->matPosition.pos.z = vecPos.fZ;
+    SetPosition(m_pInterface, vecPos);
+}
+
+void CFxSystemSA::SetPosition(CFxSystemSAInterface* fxSystem, const CVector& position)
+{
+    fxSystem->matPosition.pos.x = position.fX;
+    fxSystem->matPosition.pos.y = position.fY;
+    fxSystem->matPosition.pos.z = position.fZ;
 
     // Set the update flag(s)
     // this is what RwMatrixUpdate (@0x7F18E0) does
-    m_pInterface->matPosition.flags &= 0xFFFDFFFC;
+    fxSystem->matPosition.flags &= 0xFFFDFFFC;
 }
 
 float CFxSystemSA::GetEffectDensity()

Client/game_sa/CFxSystemSA.h

@@ -109,6 +109,8 @@ class CFxSystemSA : public CFxSystem
 
     static void StaticSetHooks();
 
+    static void SetPosition(CFxSystemSAInterface* fxSystem, const CVector& position);
+
 protected:
     CFxSystemSAInterface* m_pInterface;
     float                 m_fDrawDistance;

Client/game_sa/CModelInfoSA.cpp

@@ -25,6 +25,8 @@ std::map<CTimeInfoSAInterface*, CTimeInfoSAInterface*>                CModelInfo
 std::unordered_map<DWORD, unsigned short>                             CModelInfoSA::ms_OriginalObjectPropertiesGroups;
 std::unordered_map<DWORD, std::pair<float, float>>                    CModelInfoSA::ms_VehicleModelDefaultWheelSizes;
 
+static constexpr uintptr_t vftable_CVehicleModelInfo = 0x85C5C8u;
+
 CModelInfoSA::CModelInfoSA()
 {
     m_pInterface = NULL;
@@ -247,9 +249,15 @@ BYTE CModelInfoSA::GetVehicleType()
     return bReturn;
 }
 
-BOOL CModelInfoSA::IsVehicle()
+bool CModelInfoSA::IsVehicle() const
 {
-    return GetVehicleType() != 0xFF;
+    // NOTE(botder): This is from CModelInfo::IsVehicleModelType
+    if (m_dwModelID >= 20000)
+        return false;
+
+    // NOTE(botder): m_pInterface might be a nullptr here, we can't use it
+    CBaseModelInfoSAInterface* model = ppModelInfo[m_dwModelID];
+    return model != nullptr && reinterpret_cast<intptr_t>(model->VFTBL) == vftable_CVehicleModelInfo;
 }
 
 bool CModelInfoSA::IsPlayerModel()
@@ -1016,6 +1024,40 @@ void CModelInfoSA::SetVehicleExhaustFumesPosition(const CVector& vecPosition)
     return SetVehicleDummyPosition(eVehicleDummies::EXHAUST, vecPosition);
 }
 
+bool CModelInfoSA::GetVehicleDummyPositions(std::array<CVector, VEHICLE_DUMMY_COUNT>& positions) const
+{
+    if (!IsVehicle())
+        return false;
+
+    CVector* dummyPositions = reinterpret_cast<CVehicleModelInfoSAInterface*>(m_pInterface)->pVisualInfo->vecDummies;
+    std::copy(dummyPositions, dummyPositions + positions.size(), positions.begin());
+    return true;
+}
+
+CVector CModelInfoSA::GetVehicleDummyDefaultPosition(eVehicleDummies eDummy)
+{
+    if (!IsVehicle())
+        return CVector();
+
+    auto dummyIter = ms_ModelDefaultDummiesPosition.find(m_dwModelID);
+
+    if (dummyIter != ms_ModelDefaultDummiesPosition.end())
+    {
+        auto positionIter = dummyIter->second.find(eDummy);
+
+        if (positionIter != dummyIter->second.end())
+        {
+            return positionIter->second;
+        }
+    }
+
+    if (!IsLoaded())
+        Request(BLOCKING, "GetVehicleDummyDefaultPosition");
+
+    auto modelInfo = reinterpret_cast<CVehicleModelInfoSAInterface*>(m_pInterface);
+    return modelInfo->pVisualInfo->vecDummies[eDummy];
+}
+
 CVector CModelInfoSA::GetVehicleDummyPosition(eVehicleDummies eDummy)
 {
     if (!IsVehicle())

Client/game_sa/CModelInfoSA.h

@@ -335,7 +335,7 @@ class CModelInfoSA : public CModelInfo
     BOOL IsQuadBike();
     BOOL IsBmx();
     BOOL IsTrailer();
-    BOOL IsVehicle();
+    bool IsVehicle() const override;
     BOOL IsUpgrade();
 
     char* GetNameIfVehicle();
@@ -383,7 +383,9 @@ class CModelInfoSA : public CModelInfo
     void*        SetVehicleSuspensionData(void* pSuspensionLines);
     CVector      GetVehicleExhaustFumesPosition() override;
     void         SetVehicleExhaustFumesPosition(const CVector& vecPosition) override;
+    CVector      GetVehicleDummyDefaultPosition(eVehicleDummies eDummy) override;
     CVector      GetVehicleDummyPosition(eVehicleDummies eDummy) override;
+    bool         GetVehicleDummyPositions(std::array<CVector, VEHICLE_DUMMY_COUNT>& positions) const override;
     void         SetVehicleDummyPosition(eVehicleDummies eDummy, const CVector& vecPosition) override;
     void         ResetVehicleDummies(bool bRemoveFromDummiesMap);
     static void  ResetAllVehicleDummies();

Client/game_sa/CPoolsSA.cpp

@@ -97,15 +97,15 @@ CVehicle* CPoolsSA::AddVehicle(CClientVehicle* pClientVehicle, eVehicleTypes eVe
 
     if (m_vehiclePool.ulCount < MAX_VEHICLES)
     {
-        eVehicleModelTypes eVehicleModelType = (eVehicleModelTypes)pGame->GetModelInfo(eVehicleType)->GetVehicleType();
+        auto vehicleClass = static_cast<VehicleClass>(pGame->GetModelInfo(eVehicleType)->GetVehicleType());
 
-        switch (eVehicleModelType)
+        switch (vehicleClass)
 	    {
-            case eVehicleModelTypes::BOAT:
+            case VehicleClass::BOAT:
                 pVehicle = new CBoatSA(eVehicleType, ucVariation, ucVariation2);
                 break;
-            case eVehicleModelTypes::BMX:
-            case eVehicleModelTypes::BIKE:
+            case VehicleClass::BMX:
+            case VehicleClass::BIKE:
                 pVehicle = new CBikeSA(eVehicleType, ucVariation, ucVariation2);
                 break;
             default:
@@ -147,20 +147,19 @@ CVehicle* CPoolsSA::AddVehicle(CClientVehicle* pClientVehicle, DWORD* pGameInter
             }
             else
             {
-        
-                switch ((eVehicleModelTypes)pInterface->m_type)
-	             {
-                    case eVehicleModelTypes::BOAT:
-                         pVehicle = new CBoatSA(reinterpret_cast<CBoatSAInterface*>(pInterface));
+                switch ((VehicleClass)pInterface->m_vehicleClass)
+                {
+                    case VehicleClass::BOAT:
+                        pVehicle = new CBoatSA(reinterpret_cast<CBoatSAInterface*>(pInterface));
                         break;
-                    case eVehicleModelTypes::BMX:
-                    case eVehicleModelTypes::BIKE:
+                    case VehicleClass::BMX:
+                    case VehicleClass::BIKE:
                         pVehicle = new CBikeSA(reinterpret_cast<CBikeSAInterface*>(pInterface));
                         break;
                     default:
                         pVehicle = new CVehicleSA(pInterface);
                         break;
-	             }
+	            }
 
                 if (!AddVehicleToPool(pClientVehicle, pVehicle))
                 {

Client/game_sa/CVehicleSA.cpp

@@ -204,6 +204,16 @@ void CVehicleSA::Init()
     GetVehicleInterface()->m_pVehicle = this;
     g_bVehiclePointerInvalid = false;
 
+    CModelInfo* modelInfo = pGame->GetModelInfo(GetModelIndex());
+
+    if (modelInfo != nullptr)
+    {
+        for (size_t i = 0; i < m_dummyPositions.size(); ++i)
+        {
+            m_dummyPositions[i] = modelInfo->GetVehicleDummyPosition((eVehicleDummies)i);
+        }
+    }
+
     // Unlock doors as they spawn randomly with locked doors
     LockDoors(false);
 
@@ -1950,14 +1960,13 @@ void CVehicleSA::SetBikeWheelStatus(BYTE bWheel, BYTE bStatus)
 bool CVehicleSA::IsWheelCollided(BYTE eWheelPosition)
 {
     auto vehicle = static_cast<CAutomobileSAInterface*>(GetInterface());
-    switch (vehicle->m_type)
+    switch ((VehicleClass)vehicle->m_vehicleClass)
     {
-        case 0:
+        case VehicleClass::AUTOMOBILE:
             if (eWheelPosition < 4)
                 return vehicle->m_wheelCollisionState[eWheelPosition] == 4.f;
             break;
-
-        case 9:
+        case VehicleClass::BIKE:
             if (eWheelPosition < 2)
                 return *(float*)((DWORD)vehicle + 0x730 + eWheelPosition * 8) == 4.f || *(float*)((DWORD)vehicle + 0x734 + eWheelPosition * 8) == 4.f;
             break;
@@ -2668,6 +2677,63 @@ void CVehicleSA::UpdateLandingGearPosition()
         }
     }
 }
+
+bool CVehicleSA::GetDummyPosition(eVehicleDummies dummy, CVector& position) const
+{
+    if (dummy >= 0 && dummy < VEHICLE_DUMMY_COUNT)
+    {
+        position = m_dummyPositions[dummy];
+        return true;
+    }
+
+    return false;
+}
+
+bool CVehicleSA::SetDummyPosition(eVehicleDummies dummy, const CVector& position)
+{
+    if (dummy < 0 || dummy >= VEHICLE_DUMMY_COUNT)
+        return false;
+
+    auto vehicle = reinterpret_cast<CVehicleSAInterface*>(m_pInterface);
+
+    m_dummyPositions[dummy] = position;
+
+    if (dummy == ENGINE)
+    {
+        if (vehicle->m_overheatParticle != nullptr)
+            CFxSystemSA::SetPosition(vehicle->m_overheatParticle, position);
+
+        if (vehicle->m_fireParticle != nullptr)
+            CFxSystemSA::SetPosition(vehicle->m_fireParticle, position);
+    }
+
+    bool isAutomobileClass = static_cast<VehicleClass>(vehicle->m_vehicleClass) == VehicleClass::AUTOMOBILE;
+
+    if (isAutomobileClass)
+    {
+        SetAutomobileDummyPosition(reinterpret_cast<CAutomobileSAInterface*>(m_pInterface), dummy, position);
+    }
+
+    return true;
+}
+
+//
+// NOTE(botder): Move the code to CAutomobileSA::SetDummyPosition, when we start using CAutomobileSA
+//
+void CVehicleSA::SetAutomobileDummyPosition(CAutomobileSAInterface* automobile, eVehicleDummies dummy, const CVector& position)
+{
+    if (dummy == EXHAUST)
+    {
+        if (automobile->pNitroParticle[0] != nullptr)
+            CFxSystemSA::SetPosition(automobile->pNitroParticle[0], position);
+    }
+    else if (dummy == EXHAUST_SECONDARY)
+    {
+        if (automobile->pNitroParticle[1] != nullptr)
+            CFxSystemSA::SetPosition(automobile->pNitroParticle[1], position);
+    }
+}
+
 // Change plate text of existing vehicle
 bool CVehicleSA::SetPlateText(const SString& strText)
 {

Client/game_sa/CVehicleSA.h

@@ -326,9 +326,6 @@ class CAutoPilot
 
 #define MAX_UPGRADES_ATTACHED 15 // perhaps?
 
-/**
- * \todo GAME RELEASE: Update CVehicleSAInterface
- */
 class CVehicleSAInterface : public CPhysicalSAInterface
 {
 public:
@@ -424,22 +421,31 @@ class CVehicleSAInterface : public CPhysicalSAInterface
     unsigned int m_isUsingHornOrSecondarySiren;
 
     // 1304
-    BYTE Padding220[112];
+    uint8_t Padding220[96];
+
+    // 1400
+    CFxSystemSAInterface* m_overheatParticle;
+    CFxSystemSAInterface* m_fireParticle;
+    CFxSystemSAInterface* m_dustParticle;
+    uint32_t m_renderLights;
 
     // 1416
     RwTexture* m_pCustomPlateTexture;
 
-    // 1420
-    BYTE Padding225[4];
+    float m_steeringLeftRight;
 
     // 1424
-    BYTE m_type;            // 0 = car/plane, 5 = boat, 6 = train, 9 = bike
+    uint8_t  m_vehicleClass;
+    uint32_t m_vehicleSubClass;
 
-    // 1425
-    BYTE Padding226[15];
+    int16_t    m_peviousRemapTxd;
+    int16_t    m_remapTxd;
+    RwTexture* m_pRemapTexture;
 };
 static_assert(sizeof(CVehicleSAInterface) == 1440, "Invalid size for CVehicleSAInterface");
 
+class CAutomobileSAInterface;
+
 class CVehicleSA : public virtual CVehicle, public virtual CPhysicalSA
 {
     friend class CPoolsSA;
@@ -466,6 +472,8 @@ class CVehicleSA : public virtual CVehicle, public virtual CPhysicalSA
     unsigned char                    m_ucVariantCount;
     bool                             m_doorsUndamageable = false;
 
+    std::array<CVector, VEHICLE_DUMMY_COUNT> m_dummyPositions;
+
 public:
     CVehicleSA();
     CVehicleSA(CVehicleSAInterface* vehicleInterface);
@@ -745,7 +753,15 @@ class CVehicleSA : public virtual CVehicle, public virtual CPhysicalSA
 
     CAEVehicleAudioEntitySA* GetVehicleAudioEntity() { return m_pVehicleAudioEntity; };
 
+    bool GetDummyPosition(eVehicleDummies dummy, CVector& position) const override;
+    bool SetDummyPosition(eVehicleDummies dummy, const CVector& position) override;
+
+    CVector*       GetDummyPositions() { return m_dummyPositions.data(); }
+    const CVector* GetDummyPositions() const override { return m_dummyPositions.data(); }
+
 private:
+    static void SetAutomobileDummyPosition(CAutomobileSAInterface* automobile, eVehicleDummies dummy, const CVector& position);
+
     void           RecalculateSuspensionLines();
     void           CopyGlobalSuspensionLinesToPrivate();
     SVehicleFrame* GetVehicleComponent(const SString& vehicleComponent);