Addendum to 9ff02d5

Dutchman101 · Dutchman101 · commit 1a105c3c6d7e · 2025-08-22T10:42:02.000+08:00
diff --git a/Client/game_sa/CCamSA.cpp b/Client/game_sa/CCamSA.cpp
@@ -12,14 +12,19 @@
 #include "StdInc.h"
 #include "CCamSA.h"
 #include "CGameSA.h"
+#include <cmath>
 
 extern CGameSA* pGame;
 
 CEntity* CCamSA::GetTargetEntity() const
 {
+
+    if (!m_pInterface)
+        return nullptr;
+        
     CEntitySAInterface* pInterface = m_pInterface->CamTargetEntity;
     if (pInterface)
-    {
+    {           
         CPools* pPools = pGame->GetPools();
         return pPools->GetEntity((DWORD*)pInterface);
     }
@@ -28,9 +33,16 @@ CEntity* CCamSA::GetTargetEntity() const
 
 void CCamSA::SetTargetEntity(CEntity* pEntity)
 {
+    if (!m_pInterface)
+        return;
+        
     if (pEntity)
     {
-        m_pInterface->CamTargetEntity = pEntity->GetInterface();
+        auto pEntityInterface = pEntity->GetInterface();
+        if (!pEntityInterface)
+            return;
+            
+        m_pInterface->CamTargetEntity = pEntityInterface;
     }
     else
     {
@@ -40,13 +52,45 @@ void CCamSA::SetTargetEntity(CEntity* pEntity)
 
 void CCamSA::GetDirection(float& fHorizontal, float& fVertical)
 {
-    fHorizontal = m_pInterface->m_fHorizontalAngle;
-    fVertical = m_pInterface->m_fVerticalAngle;
+    if (!m_pInterface)
+    {
+        fHorizontal = 0.0f;
+        fVertical = 0.0f;
+        return;
+    }
+
+    float fHoriz = m_pInterface->m_fHorizontalAngle;
+    float fVert = m_pInterface->m_fVerticalAngle;
+    
+    if (!std::isfinite(fHoriz) || !std::isfinite(fVert))
+    {
+        fHorizontal = 0.0f;
+        fVertical = 0.0f;
+        return;
+    }
+    
+    fHorizontal = fHoriz;
+    fVertical = fVert;
 }
 
 void CCamSA::SetDirection(float fHorizontal, float fVertical)
 {
+    if (!m_pInterface)
+        return;
+        
+    // Validate input float values
+    if (!std::isfinite(fHorizontal) || !std::isfinite(fVertical))
+        return;
+        
+    // Clamp angle values to prevent overflow
+    constexpr float MIN_ANGLE = -360.0f;
+    constexpr float MAX_ANGLE = 360.0f;
+    
+    if (fHorizontal < MIN_ANGLE || fHorizontal > MAX_ANGLE ||
+        fVertical < MIN_ANGLE || fVertical > MAX_ANGLE)
+        return;
+
     // Calculation @ sub 0x50F970
     m_pInterface->m_fHorizontalAngle = fHorizontal;
     m_pInterface->m_fVerticalAngle = fVertical;
-}
+}
diff --git a/Client/game_sa/CCamSA.h b/Client/game_sa/CCamSA.h
@@ -162,22 +162,75 @@ class CCamSA : public CCam
     CCamSAInterface* m_pInterface;
 
 public:
-    CCamSA(CCamSAInterface* pInterface) { m_pInterface = pInterface; }
+    CCamSA(CCamSAInterface* pInterface) : m_pInterface(pInterface) 
+    {
+        if (!pInterface)
+        {
+            m_pInterface = nullptr;
+        }
+    }
+    
     CCamSAInterface* GetInterface() { return m_pInterface; }
 
-    CVector*     GetFront() const override { return &m_pInterface->Front; }
-    CVector*     GetUp() const override { return &m_pInterface->Up; }
-    CVector*     GetSource() const override { return &m_pInterface->Source; }
-    unsigned int GetMode() const override { return m_pInterface->Mode; }
-    float        GetFOV() const override { return m_pInterface->FOV; }
-    void         SetFOV(float fFOV) override { m_pInterface->FOV = fFOV; }
-    void         GetDirection(float& fHorizontal, float& fVertical) override;
-    void         SetDirection(float fHorizontal, float fVertical) override;
-
-    CVector* GetFixedModeSource() const override { return &m_pInterface->m_cvecCamFixedModeSource; }
-    CVector* GetFixedModeVector() const override { return &m_pInterface->m_cvecCamFixedModeVector; }
-    CVector* GetTargetHistoryPos() const override { return m_pInterface->m_aTargetHistoryPos; }
+    CVector* GetFront() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Front : nullptr; 
+    }
+    
+    CVector* GetUp() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Up : nullptr; 
+    }
+    
+    CVector* GetSource() const override 
+    { 
+        return m_pInterface ? &m_pInterface->Source : nullptr; 
+    }
+    
+    unsigned int GetMode() const override 
+    { 
+        return m_pInterface ? static_cast<unsigned int>(m_pInterface->Mode) : 0; 
+    }
+    
+    float GetFOV() const override 
+    { 
+        if (!m_pInterface)
+            return 70.0f; // Default FOV
+            
+        float fov = m_pInterface->FOV;
+        return std::isfinite(fov) ? fov : 70.0f;
+    }
+    
+    void SetFOV(float fFOV) override 
+    { 
+        if (!m_pInterface)
+            return;
+            
+        // Validate FOV range
+        if (!std::isfinite(fFOV) || fFOV <= 0.0f || fFOV >= 180.0f)
+            return;
+            
+        m_pInterface->FOV = fFOV; 
+    }
+
+    void GetDirection(float& fHorizontal, float& fVertical) override;
+    void SetDirection(float fHorizontal, float fVertical) override;
+
+    CVector* GetFixedModeSource() const override 
+    { 
+        return m_pInterface ? &m_pInterface->m_cvecCamFixedModeSource : nullptr; 
+    }
+    
+    CVector* GetFixedModeVector() const override 
+    { 
+        return m_pInterface ? &m_pInterface->m_cvecCamFixedModeVector : nullptr; 
+    }
+    
+    CVector* GetTargetHistoryPos() const override 
+    { 
+        return m_pInterface ? m_pInterface->m_aTargetHistoryPos : nullptr; 
+    }
 
     CEntity* GetTargetEntity() const override;
     void     SetTargetEntity(CEntity* pEntity) override;
-};
+};
diff --git a/Client/game_sa/CCameraSA.cpp b/Client/game_sa/CCameraSA.cpp
@@ -12,9 +12,12 @@
 #include "StdInc.h"
 #include "CCameraSA.h"
 #include "CGameSA.h"
+#include <mutex>
+#include <cmath>
 
 extern CGameSA* pGame;
 
+static std::mutex s_cameraClipMutex;
 static bool   bCameraClipObjects;
 static bool   bCameraClipVehicles;
 
@@ -28,19 +31,54 @@ void  HOOK_Camera_CollisionDetection();
 
 CCameraSA::CCameraSA(CCameraSAInterface* cameraInterface)
 {
+    if (!cameraInterface)
+    {
+        internalInterface = nullptr;
+        // Initialize all camera pointers to null
+        for (int i = 0; i < MAX_CAMS; i++)
+            Cams[i] = nullptr;
+        return;
+    }
+    
     internalInterface = cameraInterface;
+    
     for (int i = 0; i < MAX_CAMS; i++)
-        Cams[i] = new CCamSA(&internalInterface->Cams[i]);
-    bCameraClipObjects = true;
-    bCameraClipVehicles = true;
+    {
+        try {
+            Cams[i] = new CCamSA(&internalInterface->Cams[i]);
+        }
+        catch (...)
+        {
+            // Clean up on failure
+            for (int j = 0; j < i; j++)
+            {
+                delete Cams[j];
+                Cams[j] = nullptr;
+            }
+            internalInterface = nullptr;
+            throw;
+        }
+    }
+    
+    // Thread-safe initialization
+    {
+        std::lock_guard<std::mutex> lock(s_cameraClipMutex);
+        bCameraClipObjects = true;
+        bCameraClipVehicles = true;
+    }
+    
     HookInstall(HOOKPOS_Camera_CollisionDetection, (DWORD)HOOK_Camera_CollisionDetection, 5);
 }
 
 CCameraSA::~CCameraSA()
 {
     for (int i = 0; i < MAX_CAMS; i++)
     {
-        delete Cams[i];
+        if (Cams[i])
+        {
+            delete Cams[i];
+            Cams[i] = nullptr;
+        }
     }
 }
 
@@ -89,7 +127,11 @@ void CCameraSA::TakeControl(CEntity* entity, eCamMode CamMode, int CamSwitchStyl
         return;
         
     CCameraSAInterface* cameraInterface = GetInterface();
-    // __thiscall
+    if (!cameraInterface)
+        return;
+
+    if (CamSwitchStyle < 0 || CamSwitchStyle > 10)
+        return;
 
     DWORD CCamera__TakeControl = FUNC_TakeControl;
     _asm
@@ -196,7 +238,17 @@ void CCameraSA::RestoreLastGoodState()
 
 CMatrix* CCameraSA::GetMatrix(CMatrix* matrix)
 {
-    CMatrix_Padded* pCamMatrix = &GetInterface()->m_cameraMatrix;            // ->matrix;
+    if (!matrix)
+        return nullptr;
+        
+    CCameraSAInterface* cameraInterface = GetInterface();
+    if (!cameraInterface)
+    {
+        *matrix = CMatrix();
+        return matrix;
+    }
+    
+    CMatrix_Padded* pCamMatrix = &cameraInterface->m_cameraMatrix;
     if (pCamMatrix)
     {
         matrix->vFront = pCamMatrix->vFront;
@@ -234,11 +286,26 @@ void CCameraSA::SetMatrix(CMatrix* matrix)
 
 void CCameraSA::Find3rdPersonCamTargetVector(float fDistance, CVector* vecGunMuzzle, CVector* vecSource, CVector* vecTarget)
 {
+    if (!vecGunMuzzle || !vecSource || !vecTarget)
+        return;
+    
+    // Validate float parameter to prevent NaN/infinity issues
+    if (!std::isfinite(fDistance) || fDistance < 0.0f)
+        return;
+        
     float               fOriginX = vecGunMuzzle->fX;
     float               fOriginY = vecGunMuzzle->fY;
     float               fOriginZ = vecGunMuzzle->fZ;
+
+    if (!std::isfinite(fOriginX) || !std::isfinite(fOriginY) || !std::isfinite(fOriginZ))
+        return;
+        
     DWORD               dwFunc = FUNC_Find3rdPersonCamTargetVector;
     CCameraSAInterface* cameraInterface = GetInterface();
+
+    if (!cameraInterface)
+        return;
+        
     _asm
     {
         mov     ecx, cameraInterface
@@ -334,8 +401,18 @@ int CCameraSA::GetFadingDirection()
 
 void CCameraSA::Fade(float fFadeOutTime, int iOutOrIn)
 {
+    if (!std::isfinite(fFadeOutTime) || fFadeOutTime < 0.0f || fFadeOutTime > 60.0f)
+        return;
+        
+    if (iOutOrIn < 0 || iOutOrIn > 1)
+        return;
+        
     DWORD               dwFunc = FUNC_Fade;
     CCameraSAInterface* cameraInterface = GetInterface();
+    
+    if (!cameraInterface)
+        return;
+        
     _asm
     {
         mov     ecx, cameraInterface
@@ -369,8 +446,18 @@ float CCameraSA::GetCameraRotation()
 
 RwMatrix* CCameraSA::GetLTM()
 {
+    CCameraSAInterface* cameraInterface = GetInterface();
+    if (!cameraInterface)
+        return nullptr;
+        
+    if (!cameraInterface->m_pRwCamera)
+        return nullptr;
+        
+    if (!cameraInterface->m_pRwCamera->object.object.parent)
+        return nullptr;
+
     // RwFrameGetLTM
-    return ((RwMatrix*(_cdecl*)(void*))0x7F0990)(GetInterface()->m_pRwCamera->object.object.parent);
+    return ((RwMatrix*(_cdecl*)(void*))0x7F0990)(cameraInterface->m_pRwCamera->object.object.parent);
 }
 
 CEntity* CCameraSA::GetTargetEntity()
@@ -386,12 +473,16 @@ CEntity* CCameraSA::GetTargetEntity()
 
 void CCameraSA::SetCameraClip(bool bObjects, bool bVehicles)
 {
+    // Thread-safe access to static variables
+    std::lock_guard<std::mutex> lock(s_cameraClipMutex);
     bCameraClipObjects = bObjects;
     bCameraClipVehicles = bVehicles;
 }
 
 void CCameraSA::GetCameraClip(bool& bObjects, bool& bVehicles)
 {
+    // Thread-safe access to static variables
+    std::lock_guard<std::mutex> lock(s_cameraClipMutex);
     bObjects = bCameraClipObjects;
     bVehicles = bCameraClipVehicles;
 }
diff --git a/Client/mods/deathmatch/logic/rpc/CCameraRPCs.cpp b/Client/mods/deathmatch/logic/rpc/CCameraRPCs.cpp
@@ -42,6 +42,14 @@ void CCameraRPCs::SetCameraMatrix(NetBitStreamInterface& bitStream)
     bitStream.Read(fRoll);
     bitStream.Read(fFOV);
 
+    // Validate float values to prevent potential issues
+    if (!std::isfinite(fRoll) || !std::isfinite(fFOV) || 
+        !std::isfinite(vecPosition.fX) || !std::isfinite(vecPosition.fY) || !std::isfinite(vecPosition.fZ) ||
+        !std::isfinite(vecLookAt.fX) || !std::isfinite(vecLookAt.fY) || !std::isfinite(vecLookAt.fZ))
+    {
+        return; // Invalid float values (NaN, infinity, etc.)
+    }
+
     // Validate camera pointer before use
     if (!m_pCamera)
         return;
@@ -76,6 +84,10 @@ void CCameraRPCs::SetCameraTarget(NetBitStreamInterface& bitStream)
     if (!pEntity)
         return;
 
+    // Check if entity is being deleted - critical memory safety check
+    if (pEntity->IsBeingDeleted())
+        return;
+
     switch (pEntity->GetType())
     {
         case CCLIENTPLAYER:
