Fix camera behavior and getCameraMatrix return values (#1282 & #1284) (#4393)

* align getCameraMatrix FOV/roll with actual rendering and improve transitions

* Refactor CClientCamera

* Refactor

Author: MohabCodeX

Client/game_sa/CCameraSA.cpp

@@ -565,7 +565,53 @@ void CCameraSA::ResetShakeCamera() noexcept
     GetInterface()->m_fCamShakeForce = 0.0f;
 }
 
-std::uint8_t CCameraSA::GetTransitionState()
+std::uint8_t CCameraSA::GetTransitionState() const
 {
     return GetInterface()->m_uiTransitionState;
 }
+
+bool CCameraSA::IsInTransition() const
+{
+    return GetTransitionState() != 0;
+}
+
+float CCameraSA::GetTransitionFOV() const
+{
+    CCameraSAInterface* cameraInterface = GetInterface();
+    return cameraInterface ? cameraInterface->FOVDuringInter : DEFAULT_FOV;
+}
+
+bool CCameraSA::GetTransitionMatrix(CMatrix& matrix) const
+{
+    CCameraSAInterface* cameraInterface = GetInterface();
+    if (!cameraInterface || !IsInTransition())
+        return false;
+    
+    CVector source = cameraInterface->SourceDuringInter;
+    CVector target = cameraInterface->TargetDuringInter;
+    CVector up = cameraInterface->UpDuringInter;
+    
+    CVector forward = target - source;
+    if (forward.Length() < FLOAT_EPSILON)
+        forward = CVector(0.0f, 1.0f, 0.0f);
+    else
+        forward.Normalize();
+    
+    CVector right = CVector(forward.fY, -forward.fX, 0.0f);
+    if (right.Length() < FLOAT_EPSILON)
+        right = CVector(1.0f, 0.0f, 0.0f);
+    else
+        right.Normalize();
+    
+    CVector correctedUp = right;
+    correctedUp.CrossProduct(&forward);
+    correctedUp.Normalize();
+    
+    matrix.vPos = source;
+    matrix.vFront = forward;
+    matrix.vRight = -right;
+    matrix.vUp = correctedUp;
+    matrix.OrthoNormalize(CMatrix::AXIS_FRONT, CMatrix::AXIS_UP);
+    
+    return true;
+}

Client/game_sa/CCameraSA.h

@@ -381,7 +381,7 @@ class CCameraSA : public CCamera
     CCameraSA(CCameraSAInterface* cameraInterface);
     ~CCameraSA();
 
-    CCameraSAInterface* GetInterface() { return internalInterface; };
+    CCameraSAInterface* GetInterface() const noexcept { return internalInterface; }
 
     // CCamera interface implementation
     void                TakeControl(CEntity* entity, eCamMode CamMode, int CamSwitchStyle) override;
@@ -413,7 +413,10 @@ class CCameraSA : public CCamera
     float               GetShakeForce() override;
     void                ShakeCamera(float radius, float x, float y, float z) noexcept override;
     void                ResetShakeCamera() noexcept override;
-    std::uint8_t        GetTransitionState() override;
+    std::uint8_t        GetTransitionState() const override;
+    bool                IsInTransition() const override;
+    float               GetTransitionFOV() const override;
+    bool                GetTransitionMatrix(CMatrix& matrix) const override;
 
     // Additional overload not in base interface
     virtual CCam* GetCam(CCamSAInterface* camInterface);

Client/mods/deathmatch/logic/CClientCamera.cpp

@@ -13,6 +13,9 @@
 
 #define PI_2 6.283185307179586476925286766559f
 
+// Camera FOV constants
+constexpr const std::uintptr_t VAR_CurrentCameraFOV = 0x8D5038; // CCamera::CurrentFOV
+
 CClientCamera::CClientCamera(CClientManager* pManager) : ClassInit(this), CClientEntity(INVALID_ELEMENT_ID)
 {
     CClientEntityRefManager::AddEntityRefs(ENTITY_REF_DEBUG(this, "CClientCamera"), &m_pFocusedPlayer, &m_pFocusedEntity, NULL);
@@ -27,7 +30,7 @@ CClientCamera::CClientCamera(CClientManager* pManager) : ClassInit(this), CClien
     m_bInvalidated = false;
     m_bFixed = false;
     m_fRoll = 0.0f;
-    m_fFOV = 70.0f;
+    m_fFOV = DEFAULT_FOV;
     SetTypeName("camera");
 
     m_pCamera = g_pGame->GetCamera();
@@ -359,7 +362,7 @@ void CClientCamera::SetFocus(CClientEntity* pEntity, eCamMode eMode, bool bSmoot
     }
 
     m_fRoll = 0.0f;
-    m_fFOV = 70.0f;
+    m_fFOV = DEFAULT_FOV;
 }
 
 void CClientCamera::SetFocus(CClientPlayer* pPlayer, eCamMode eMode, bool bSmoothTransition)
@@ -387,7 +390,7 @@ void CClientCamera::SetFocus(CClientPlayer* pPlayer, eCamMode eMode, bool bSmoot
     // Store the player we focused
     m_pFocusedPlayer = pPlayer;
     m_fRoll = 0.0f;
-    m_fFOV = 70.0f;
+    m_fFOV = DEFAULT_FOV;
     m_bFixed = false;
 }
 
@@ -427,7 +430,7 @@ void CClientCamera::Reset()
     m_pFocusedGameEntity = NULL;
     m_bFixed = false;
     m_fRoll = 0.0f;
-    m_fFOV = 70.0f;
+    m_fFOV = DEFAULT_FOV;
 }
 
 void CClientCamera::SetFocusToLocalPlayerImpl()
@@ -542,7 +545,7 @@ void CClientCamera::ToggleCameraFixedMode(bool bEnabled)
         SetFocusToLocalPlayer();
 
         m_fRoll = 0.0f;
-        m_fFOV = 70.0f;
+        m_fFOV = DEFAULT_FOV;
     }
 }
 
@@ -606,6 +609,9 @@ bool CClientCamera::ProcessFixedCamera(CCam* pCam)
 //
 CMatrix CClientCamera::GetGtaMatrix() const
 {
+    if (IsInCameraTransition())
+        return GetInterpolatedCameraMatrix();
+
     CCam* pCam = m_pCamera->GetCam(m_pCamera->GetActiveCam());
 
     CMatrix matResult;
@@ -644,3 +650,28 @@ void CClientCamera::ResetShakeCamera() noexcept
 {
     m_pCamera->ResetShakeCamera();
 }
+
+bool CClientCamera::IsInCameraTransition() const
+{
+    return m_pCamera ? m_pCamera->IsInTransition() : false;
+}
+
+CMatrix CClientCamera::GetInterpolatedCameraMatrix() const
+{
+    CMatrix matrix;
+    if (m_pCamera && m_pCamera->GetTransitionMatrix(matrix))
+        return matrix;
+    
+    return CMatrix();
+}
+
+float CClientCamera::GetAccurateFOV() const
+{
+    if (!m_pCamera)
+        return DEFAULT_FOV;
+    
+    if (IsInCameraTransition())
+        return m_pCamera->GetTransitionFOV();
+    
+    return *(float*)VAR_CurrentCameraFOV;
+}

Client/mods/deathmatch/logic/CClientCamera.h

@@ -82,6 +82,10 @@ class CClientCamera final : public CClientEntity
 
     void UnreferencePlayer(CClientPlayer* pPlayer);
 
+    bool    IsInCameraTransition() const;
+    CMatrix GetInterpolatedCameraMatrix() const;
+    float   GetAccurateFOV() const;
+
 private:
     CClientCamera(CClientManager* pManager);
     ~CClientCamera();

Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp

@@ -5007,7 +5007,16 @@ bool CStaticFunctionDefinitions::GetCameraMatrix(CVector& vecPosition, CVector&
 {
     m_pCamera->GetPosition(vecPosition);
     m_pCamera->GetFixedTarget(vecLookAt, &fRoll);
-    fFOV = m_pCamera->GetFOV();
+    
+    fFOV = m_pCamera->GetAccurateFOV();
+    
+    if (!m_pCamera->IsInFixedMode() && fRoll == 0.0f)
+    {
+        CVector rotation;
+        m_pCamera->GetRotationDegrees(rotation);
+        fRoll = rotation.fZ;
+    }
+    
     return true;
 }
 

Client/sdk/game/CCamera.h

@@ -17,6 +17,9 @@ class CMatrix;
 class CCam;
 struct RwMatrix;
 
+// Camera constants
+constexpr const float DEFAULT_FOV = 70.0f;
+
 enum eCamMode
 {
     MODE_NONE = 0,
@@ -147,5 +150,8 @@ class CCamera
     virtual void ShakeCamera(float radius, float x, float y, float z) noexcept = 0;
     virtual void ResetShakeCamera() noexcept = 0;
 
-    virtual std::uint8_t GetTransitionState() = 0;
+    virtual std::uint8_t GetTransitionState() const = 0;
+    virtual bool         IsInTransition() const = 0;
+    virtual float        GetTransitionFOV() const = 0;
+    virtual bool         GetTransitionMatrix(CMatrix& matrix) const = 0;
 };

Server/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp

@@ -4621,17 +4621,13 @@ bool CStaticFunctionDefinitions::GetCameraMatrix(CPlayer* pPlayer, CVector& vecP
     assert(pPlayer);
 
     CPlayerCamera* pCamera = pPlayer->GetCamera();
-
-    // Only allow this if we're in fixed mode?
-    if (pCamera->GetMode() == CAMERAMODE_FIXED)
-    {
-        pCamera->GetPosition(vecPosition);
-        pCamera->GetLookAt(vecLookAt);
-        fRoll = pCamera->GetRoll();
-        fFOV = pCamera->GetFOV();
-        return true;
-    }
-    return false;
+    
+    pCamera->GetPosition(vecPosition);
+    pCamera->GetLookAt(vecLookAt);
+    fRoll = pCamera->GetRoll();
+    fFOV = pCamera->GetFOV();
+    
+    return true;
 }
 
 CElement* CStaticFunctionDefinitions::GetCameraTarget(CPlayer* pPlayer)