1745 lines
56 KiB
C++
1745 lines
56 KiB
C++
//
|
|
// camera/CamInterface.cpp
|
|
//
|
|
// Copyright (C) 1999-2013 Rockstar Games. All Rights Reserved.
|
|
//
|
|
|
|
#include "camera/CamInterface.h"
|
|
|
|
#include "profile/group.h"
|
|
#include "profile/page.h"
|
|
#include "system/param.h"
|
|
|
|
#include "fwsys/timer.h"
|
|
|
|
#include "camera/animscene/AnimSceneDirector.h"
|
|
#include "camera/cinematic/CinematicDirector.h"
|
|
#include "camera/cinematic/camera/mounted/CinematicMountedCamera.h"
|
|
#include "camera/cinematic/context/CinematicOnFootSpectatingContext.h"
|
|
#include "camera/cutscene/CutsceneDirector.h"
|
|
#include "camera/debug/DebugDirector.h"
|
|
#include "camera/gameplay/GameplayDirector.h"
|
|
#include "camera/gameplay/follow/FollowCamera.h"
|
|
#include "camera/gameplay/aim/FirstPersonAimCamera.h"
|
|
#include "camera/gameplay/aim/FirstPersonShooterCamera.h"
|
|
#include "camera/gameplay/aim/ThirdPersonPedAssistedAimCamera.h"
|
|
#include "camera/helpers/FramePropagator.h"
|
|
#include "camera/helpers/switch/BaseSwitchHelper.h"
|
|
#include "camera/marketing/MarketingDirector.h"
|
|
#include "camera/replay/ReplayDirector.h"
|
|
#include "camera/scripted/ScriptDirector.h"
|
|
#include "camera/scripted/ScriptedCamera.h"
|
|
#include "camera/switch/SwitchDirector.h"
|
|
#include "camera/syncedscene/SyncedSceneDirector.h"
|
|
#include "camera/system/CameraManager.h"
|
|
#include "camera/system/CameraMetadata.h"
|
|
#include "camera/viewports/ViewportManager.h"
|
|
#include "Control/replay/replay.h"
|
|
#include "debug/DebugScene.h"
|
|
#include "frontend/LoadingScreens.h"
|
|
#include "game/ModelIndices.h"
|
|
#include "network/Network.h"
|
|
#include "network/NetworkInterface.h"
|
|
#include "peds/PedIntelligence.h"
|
|
#include "physics/gtaInst.h"
|
|
#include "physics/physics.h"
|
|
#include "scene/EntityIterator.h"
|
|
#include "scene/FocusEntity.h"
|
|
#include "scene/world/GameWorld.h"
|
|
#include "streaming/streamingvisualize.h"
|
|
#include "system/controlMgr.h"
|
|
#include "text/messages.h"
|
|
#include "tools/SectorTools.h"
|
|
#include "vehicles/Metadata/VehicleEntryPointInfo.h"
|
|
#include "peds/ped.h"
|
|
#include "vehicles/vehicle.h"
|
|
|
|
|
|
CAMERA_OPTIMISATIONS()
|
|
|
|
XPARAM(cameraWidgets);
|
|
|
|
RAGE_DEFINE_CHANNEL(camera)
|
|
|
|
PF_PAGE(camInterfacePage, "Camera Interface");
|
|
|
|
PF_GROUP(camInterfaceFrameDetails);
|
|
PF_LINK(camInterfacePage, camInterfaceFrameDetails);
|
|
|
|
PF_VALUE_FLOAT(camInterfaceFrameVelocityMag, camInterfaceFrameDetails);
|
|
PF_VALUE_FLOAT(camInterfaceFrameAccelerationMag, camInterfaceFrameDetails);
|
|
PF_VALUE_FLOAT(camInterfaceFrameRateOfChangeOfAccelerationMag, camInterfaceFrameDetails);
|
|
PF_VALUE_FLOAT(camInterfaceFrameAngularVelocityMag, camInterfaceFrameDetails);
|
|
PF_VALUE_FLOAT(camInterfaceFov, camInterfaceFrameDetails);
|
|
|
|
#define FIND_DIRECTOR_FATAL(_DirectorClass, _DirectorMember, _DirectorFriendlyName) \
|
|
{ _DirectorMember = camManager::FindDirector<_DirectorClass>(); \
|
|
cameraFatalAssertf(_DirectorMember.Get() != NULL, "The " _DirectorFriendlyName \
|
|
" camera director was not found in the camera metadata." \
|
|
" Please check you have up-to-date camera metadata PSOs or an up-to-date .meta file if you are running with -rawCameraMetadata"); }
|
|
|
|
#define GET_DIRECTOR_FATAL(_DirectorClass, _DirectorMember, _DirectorFriendlyName) \
|
|
{ cameraFatalAssertf(_DirectorMember.Get() != NULL, "The " _DirectorFriendlyName " camera director is invalid"); \
|
|
return *((_DirectorClass*)_DirectorMember.Get()); }
|
|
|
|
CViewportFader camInterface::ms_Fader;
|
|
|
|
camFrame camInterface::ms_CachedFrame;
|
|
|
|
#if GTA_REPLAY
|
|
RegdConstEnt camInterface::ms_CachedAttachedEntity;
|
|
#endif
|
|
|
|
Vector3 camInterface::ms_FramePositionDelta;
|
|
Vector3 camInterface::ms_FrameVelocity;
|
|
Vector3 camInterface::ms_FrameAcceleration;
|
|
Vector3 camInterface::ms_FrameRateOfChangeOfAcceleration;
|
|
|
|
RegdCamBaseDirector camInterface::ms_CinematicDirector;
|
|
RegdCamBaseDirector camInterface::ms_CutsceneDirector;
|
|
RegdCamBaseDirector camInterface::ms_DebugDirector;
|
|
RegdCamBaseDirector camInterface::ms_GameplayDirector;
|
|
RegdCamBaseDirector camInterface::ms_MarketingDirector;
|
|
RegdCamBaseDirector camInterface::ms_ScriptDirector;
|
|
RegdCamBaseDirector camInterface::ms_SwitchDirector;
|
|
RegdCamBaseDirector camInterface::ms_ReplayDirector;
|
|
RegdCamBaseDirector camInterface::ms_SyncedSceneDirector;
|
|
RegdCamBaseDirector camInterface::ms_AnimSceneDirector;
|
|
|
|
RegdConstPed camInterface::ms_ScriptControlledFollowPedThisUpdate;
|
|
s32 camInterface::ms_DeathFailEffectState;
|
|
float camInterface::ms_CachedHeading;
|
|
float camInterface::ms_CachedPitch;
|
|
float camInterface::ms_CachedRoll;
|
|
bool camInterface::ms_IsInitialized = false;
|
|
bool camInterface::ms_IsOverridingStreamingFocus = false;
|
|
bool camInterface::ms_IsRenderedCamInVehicle = false;
|
|
|
|
#if FPS_MODE_SUPPORTED
|
|
bool camInterface::ms_SetScriptedCameraIsFirstPersonThisFrame = false;
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
#if __BANK
|
|
u32 camInterface::ms_DebugRespotCounter = 10000;
|
|
bool camInterface::ms_DebugFlashLocallyWhileRespotting = false;
|
|
bool camInterface::ms_DebugFlashRemotelyWhileRespotting = true;
|
|
bool camInterface::ms_DebugShouldFollowDebugFocusPed = false;
|
|
bool camInterface::ms_DebugForceFollowPedControlOrientation = false;
|
|
bool camInterface::ms_DebugShouldDisplayActiveCameraInfo = false;
|
|
bool camInterface::ms_DebugShouldDisplayGameViewportInfo = false;
|
|
bool camInterface::ms_DebugShouldRestartSystemAtEndOfFrame = false;
|
|
#endif // __BANK
|
|
|
|
|
|
void camInterface::Init()
|
|
{
|
|
//Find and cache our game-specific directors to enable direct access.
|
|
FIND_DIRECTOR_FATAL(camCinematicDirector, ms_CinematicDirector, "cinematic");
|
|
FIND_DIRECTOR_FATAL(camCutsceneDirector, ms_CutsceneDirector, "cutscene");
|
|
FIND_DIRECTOR_FATAL(camDebugDirector, ms_DebugDirector, "debug");
|
|
FIND_DIRECTOR_FATAL(camGameplayDirector, ms_GameplayDirector, "gameplay");
|
|
FIND_DIRECTOR_FATAL(camMarketingDirector, ms_MarketingDirector, "marketing");
|
|
FIND_DIRECTOR_FATAL(camScriptDirector, ms_ScriptDirector, "script");
|
|
FIND_DIRECTOR_FATAL(camSwitchDirector, ms_SwitchDirector, "switch");
|
|
FIND_DIRECTOR_FATAL(camReplayDirector, ms_ReplayDirector, "replay");
|
|
FIND_DIRECTOR_FATAL(camSyncedSceneDirector, ms_SyncedSceneDirector, "synced-scene");
|
|
FIND_DIRECTOR_FATAL(camAnimSceneDirector, ms_AnimSceneDirector, "animscene");
|
|
|
|
camFrame defaultFrame;
|
|
ms_CachedFrame.CloneFrom(defaultFrame); //Clone a clean default frame.
|
|
|
|
ms_FramePositionDelta.Zero();
|
|
ms_FrameVelocity.Zero();
|
|
ms_FrameAcceleration.Zero();
|
|
ms_FrameRateOfChangeOfAcceleration.Zero();
|
|
|
|
ms_CachedHeading = 0.0f;
|
|
ms_CachedPitch = 0.0f;
|
|
ms_CachedRoll = 0.0f;
|
|
|
|
ms_DeathFailEffectState = DEATH_FAIL_EFFECT_INACTIVE;
|
|
|
|
ms_ScriptControlledFollowPedThisUpdate = NULL;
|
|
ms_IsInitialized = true;
|
|
|
|
#if __BANK
|
|
if(PARAM_cameraWidgets.Get())
|
|
{
|
|
//Enable rendering of camera-related on-screen debug text by default with -cameraWidgets.
|
|
ms_DebugShouldDisplayActiveCameraInfo = true;
|
|
}
|
|
#endif // __BANK
|
|
}
|
|
|
|
void camInterface::Shutdown()
|
|
{
|
|
ms_IsInitialized = false;
|
|
}
|
|
|
|
const Matrix34& camInterface::GetMat()
|
|
{
|
|
return ms_CachedFrame.GetWorldMatrix();
|
|
}
|
|
|
|
bool camInterface::GetObjectSpaceCameraMatrix(const CEntity* pTargetEntity, Matrix34& mat)
|
|
{
|
|
if(!pTargetEntity)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const camBaseCamera* pCamera = GetDominantRenderedCamera();
|
|
if(!pCamera)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(GetRenderedCameras().GetCount() == 1)
|
|
{
|
|
return pCamera->GetObjectSpaceCameraMatrix(pTargetEntity, mat);
|
|
}
|
|
else if(GetRenderedCameras().GetCount() > 1)
|
|
{
|
|
mat = ms_CachedFrame.GetWorldMatrix();
|
|
mat.DotTranspose(MAT34V_TO_MATRIX34(pTargetEntity->GetMatrix()));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const Vector3& camInterface::GetPos()
|
|
{
|
|
return ms_CachedFrame.GetPosition();
|
|
}
|
|
|
|
const Vector3& camInterface::GetFront()
|
|
{
|
|
return ms_CachedFrame.GetFront();
|
|
}
|
|
|
|
const Vector3& camInterface::GetRight()
|
|
{
|
|
return ms_CachedFrame.GetRight();
|
|
}
|
|
|
|
const Vector3& camInterface::GetUp()
|
|
{
|
|
return ms_CachedFrame.GetUp();
|
|
}
|
|
|
|
float camInterface::GetNear()
|
|
{
|
|
return ms_CachedFrame.GetNearClip();
|
|
}
|
|
|
|
float camInterface::GetFar()
|
|
{
|
|
return ms_CachedFrame.GetFarClip();
|
|
}
|
|
|
|
float camInterface::GetNearDof()
|
|
{
|
|
return ms_CachedFrame.GetNearInFocusDofPlane();
|
|
}
|
|
|
|
float camInterface::GetFarDof()
|
|
{
|
|
return ms_CachedFrame.GetFarInFocusDofPlane();
|
|
}
|
|
|
|
float camInterface::GetFov()
|
|
{
|
|
return ms_CachedFrame.GetFov();
|
|
}
|
|
|
|
float camInterface::GetMotionBlurStrength()
|
|
{
|
|
return ms_CachedFrame.GetMotionBlurStrength();
|
|
}
|
|
|
|
bool camInterface::IsDominantRenderedDirector(const camBaseDirector& director)
|
|
{
|
|
const camBaseDirector* renderedDirector = camManager::GetDominantRenderedDirector();
|
|
const bool isTheRenderedDirector = (&director == renderedDirector);
|
|
|
|
return isTheRenderedDirector;
|
|
}
|
|
|
|
const camBaseDirector* camInterface::GetDominantRenderedDirector()
|
|
{
|
|
const camBaseDirector* renderedDirector = camManager::GetDominantRenderedDirector();
|
|
|
|
return renderedDirector;
|
|
}
|
|
|
|
bool camInterface::IsRenderingDirector(const camBaseDirector& director)
|
|
{
|
|
bool isRenderingDirector = false;
|
|
|
|
const atArray<tRenderedCameraObjectSettings>& renderedDirectors = camManager::GetRenderedDirectors();
|
|
const s32 numRenderedDirectors = renderedDirectors.GetCount();
|
|
|
|
for(s32 directorIndex=0; directorIndex<numRenderedDirectors; directorIndex++)
|
|
{
|
|
if(renderedDirectors[directorIndex].m_Object == &director)
|
|
{
|
|
isRenderingDirector = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return isRenderingDirector;
|
|
}
|
|
|
|
const atArray<tRenderedCameraObjectSettings>& camInterface::GetRenderedDirectors()
|
|
{
|
|
const atArray<tRenderedCameraObjectSettings>& renderedDirectors = camManager::GetRenderedDirectors();
|
|
|
|
return renderedDirectors;
|
|
}
|
|
|
|
bool camInterface::IsDominantRenderedCamera(const camBaseCamera& camera)
|
|
{
|
|
const camBaseCamera* renderedCamera = camManager::GetDominantRenderedCamera();
|
|
const bool isTheRenderedCamera = (&camera == renderedCamera);
|
|
|
|
return isTheRenderedCamera;
|
|
}
|
|
|
|
const camBaseCamera* camInterface::GetDominantRenderedCamera()
|
|
{
|
|
const camBaseCamera* renderedCamera = camManager::GetDominantRenderedCamera();
|
|
|
|
return renderedCamera;
|
|
}
|
|
|
|
bool camInterface::IsRenderingCamera(const camBaseCamera& camera)
|
|
{
|
|
bool isRenderingCamera = false;
|
|
|
|
const atArray<tRenderedCameraObjectSettings>& renderedCameras = camManager::GetRenderedCameras();
|
|
const s32 numRenderedCameras = renderedCameras.GetCount();
|
|
|
|
for(s32 cameraIndex=0; cameraIndex<numRenderedCameras; cameraIndex++)
|
|
{
|
|
if(renderedCameras[cameraIndex].m_Object == &camera)
|
|
{
|
|
isRenderingCamera = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return isRenderingCamera;
|
|
}
|
|
|
|
const atArray<tRenderedCameraObjectSettings>& camInterface::GetRenderedCameras()
|
|
{
|
|
const atArray<tRenderedCameraObjectSettings>& renderedCameras = camManager::GetRenderedCameras();
|
|
|
|
return renderedCameras;
|
|
}
|
|
|
|
#if FPS_MODE_SUPPORTED
|
|
bool camInterface::IsRenderingFirstPersonCamera()
|
|
{
|
|
const bool isRenderingFirstPersonCamera = camManager::IsRenderingFirstPersonCamera();
|
|
|
|
return isRenderingFirstPersonCamera;
|
|
}
|
|
|
|
bool camInterface::IsRenderingFirstPersonShooterCamera()
|
|
{
|
|
const bool isRenderingFirstPersonShooterCamera = camManager::IsRenderingFirstPersonShooterCamera();
|
|
|
|
return isRenderingFirstPersonShooterCamera;
|
|
}
|
|
|
|
bool camInterface::IsRenderingFirstPersonShooterCustomFallBackCamera()
|
|
{
|
|
const bool isRenderingFirstPersonShooterCustomFallBackCamera = camManager::IsRenderingFirstPersonShooterCustomFallBackCamera();
|
|
|
|
return isRenderingFirstPersonShooterCustomFallBackCamera;
|
|
}
|
|
|
|
bool camInterface::IsDominantRenderedCameraAnyFirstPersonCamera()
|
|
{
|
|
#if GTA_REPLAY
|
|
//check we're in replay, we only care about the replay cameras if we are
|
|
const bool isReplayActive = IsRenderingDirector(GetReplayDirector());
|
|
if (isReplayActive)
|
|
{
|
|
if (CReplayMgr::GetCamInFirstPersonFlag())
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
#endif //GTA_REPLAY
|
|
|
|
const camBaseCamera* dominantCamera = camInterface::GetDominantRenderedCamera();
|
|
if(!dominantCamera)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (dominantCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (dominantCamera->GetIsClassId(camCinematicMountedCamera::GetStaticClassId()))
|
|
{
|
|
const camCinematicMountedCamera* povCamera = static_cast<const camCinematicMountedCamera*>(dominantCamera);
|
|
if(povCamera->IsFirstPersonCamera())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (ms_SetScriptedCameraIsFirstPersonThisFrame && dominantCamera->GetIsClassId(camScriptedCamera::GetStaticClassId()))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void camInterface::SetScriptedCameraIsFirstPersonThisFrame(bool isFirstPersonThisFrame)
|
|
{
|
|
ms_SetScriptedCameraIsFirstPersonThisFrame = isFirstPersonThisFrame;
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
camCinematicDirector& camInterface::GetCinematicDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camCinematicDirector, ms_CinematicDirector, "cinematic");
|
|
}
|
|
|
|
camCutsceneDirector& camInterface::GetCutsceneDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camCutsceneDirector, ms_CutsceneDirector, "cutscene");
|
|
}
|
|
|
|
camDebugDirector& camInterface::GetDebugDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camDebugDirector, ms_DebugDirector, "debug");
|
|
}
|
|
|
|
camDebugDirector* camInterface::GetDebugDirectorSafe()
|
|
{
|
|
return static_cast<camDebugDirector*>(ms_DebugDirector.Get());
|
|
}
|
|
|
|
camGameplayDirector& camInterface::GetGameplayDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camGameplayDirector, ms_GameplayDirector, "gameplay");
|
|
}
|
|
|
|
camGameplayDirector* camInterface::GetGameplayDirectorSafe()
|
|
{
|
|
return static_cast<camGameplayDirector*>(ms_GameplayDirector.Get());
|
|
}
|
|
|
|
camMarketingDirector& camInterface::GetMarketingDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camMarketingDirector, ms_MarketingDirector, "marketing");
|
|
}
|
|
|
|
camScriptDirector& camInterface::GetScriptDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camScriptDirector, ms_ScriptDirector, "script");
|
|
}
|
|
|
|
camSwitchDirector& camInterface::GetSwitchDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camSwitchDirector, ms_SwitchDirector, "switch");
|
|
}
|
|
|
|
camSyncedSceneDirector& camInterface::GetSyncedSceneDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camSyncedSceneDirector, ms_SyncedSceneDirector, "syncedscene");
|
|
}
|
|
|
|
camAnimSceneDirector& camInterface::GetAnimSceneDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camAnimSceneDirector, ms_AnimSceneDirector, "animscene");
|
|
}
|
|
|
|
camReplayDirector& camInterface::GetReplayDirector()
|
|
{
|
|
GET_DIRECTOR_FATAL(camReplayDirector, ms_ReplayDirector, "replay");
|
|
}
|
|
|
|
//As far as player control goes what should we consider the camera heading to be?
|
|
float camInterface::GetPlayerControlCamHeading(const CPed& player)
|
|
{
|
|
float heading;
|
|
|
|
const camThirdPersonCamera* thirdPersonCamera = GetGameplayDirector().GetThirdPersonCamera(&player);
|
|
#if FPS_MODE_SUPPORTED
|
|
const camFirstPersonShooterCamera* firstPersonShooterCamera = GetGameplayDirector().GetFirstPersonShooterCamera(&player);
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
if (player.GetPedResetFlag(CPED_RESET_FLAG_ForcePedToUseScripCamHeading) && GetScriptDirector().IsRendering())
|
|
{
|
|
heading = GetScriptDirector().GetFrame().ComputeHeading();
|
|
}
|
|
else if(thirdPersonCamera && (BANK_ONLY(ms_DebugForceFollowPedControlOrientation || )(!GetDebugDirector().IsFreeCamActive() &&
|
|
!GetMarketingDirector().IsCameraActive())))
|
|
{
|
|
const Vector3& front = thirdPersonCamera->GetBaseFront();
|
|
heading = camFrame::ComputeHeadingFromFront(front);
|
|
}
|
|
#if FPS_MODE_SUPPORTED
|
|
else if (firstPersonShooterCamera)
|
|
{
|
|
heading = firstPersonShooterCamera->GetHeading();
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
else
|
|
{
|
|
heading = GetHeading();
|
|
}
|
|
|
|
return heading;
|
|
}
|
|
|
|
//As far as player control goes what should we consider the camera pitch to be?
|
|
float camInterface::GetPlayerControlCamPitch(const CPed& player)
|
|
{
|
|
float pitch;
|
|
|
|
const camThirdPersonCamera* thirdPersonCamera = GetGameplayDirector().GetThirdPersonCamera(&player);
|
|
#if FPS_MODE_SUPPORTED
|
|
const camFirstPersonShooterCamera* firstPersonShooterCamera = GetGameplayDirector().GetFirstPersonShooterCamera(&player);
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
if(thirdPersonCamera && (BANK_ONLY(ms_DebugForceFollowPedControlOrientation ||) (!GetDebugDirector().IsFreeCamActive() &&
|
|
!GetMarketingDirector().IsCameraActive())))
|
|
{
|
|
const Vector3& front = thirdPersonCamera->GetBaseFront();
|
|
pitch = camFrame::ComputePitchFromFront(front);
|
|
}
|
|
#if FPS_MODE_SUPPORTED
|
|
else if (firstPersonShooterCamera)
|
|
{
|
|
pitch = firstPersonShooterCamera->GetPitch();
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
else
|
|
{
|
|
pitch = GetPitch();
|
|
}
|
|
|
|
return pitch;
|
|
}
|
|
|
|
//As far as player control goes what should we consider the camera aim frame to be?
|
|
const camFrame& camInterface::GetPlayerControlCamAimFrame()
|
|
{
|
|
const camBaseCamera* dominantRenderedCamera = GetDominantRenderedCamera();
|
|
if(dominantRenderedCamera && dominantRenderedCamera->GetIsClassId(camCinematicMountedCamera::GetStaticClassId()) &&
|
|
static_cast<const camCinematicMountedCamera*>(dominantRenderedCamera)->ShouldAffectAiming())
|
|
{
|
|
const camFrame& mountedCameraFrame = dominantRenderedCamera->GetFrameNoPostEffects();
|
|
return mountedCameraFrame;
|
|
}
|
|
else if(dominantRenderedCamera && dominantRenderedCamera->GetIsClassId(camThirdPersonPedAssistedAimCamera::GetStaticClassId()) &&
|
|
static_cast<const camThirdPersonPedAssistedAimCamera*>(dominantRenderedCamera)->ShouldAffectAiming())
|
|
{
|
|
const camFrame& assistedAimFrame = static_cast<const camThirdPersonPedAssistedAimCamera*>(dominantRenderedCamera)->GetFrameForAiming();
|
|
return assistedAimFrame;
|
|
}
|
|
|
|
//Use the frame of the rendered scripted camera if it is configured to affect aiming.
|
|
bool shouldUseScriptCameraFrame = false;
|
|
const bool isScriptDirectorRendering = GetScriptDirector().IsRendering();
|
|
if(isScriptDirectorRendering)
|
|
{
|
|
const camBaseCamera* renderedCamera = GetScriptDirector().GetRenderedCamera();
|
|
if(renderedCamera && renderedCamera->GetIsClassId(camScriptedCamera::GetStaticClassId()))
|
|
{
|
|
const camScriptedCamera* scriptedCamera = static_cast<const camScriptedCamera*>(renderedCamera);
|
|
shouldUseScriptCameraFrame = scriptedCamera->ShouldAffectAiming();
|
|
}
|
|
}
|
|
|
|
const camFrame& aimFrame = shouldUseScriptCameraFrame ? GetScriptDirector().GetFrame() : GetGameplayDirector().GetFrame();
|
|
|
|
return aimFrame;
|
|
}
|
|
|
|
float camInterface::ComputeMiniMapHeading()
|
|
{
|
|
//Use the heading of the debug free camera if it is active.
|
|
const bool isFreeCameraActive = GetDebugDirector().IsFreeCamActive();
|
|
if(isFreeCameraActive)
|
|
{
|
|
const float heading = GetDebugDirector().GetFreeCamFrame().ComputeHeading();
|
|
|
|
return heading;
|
|
}
|
|
|
|
//Use the heading of the rendered scripted camera if it is configured to control the mini map orientation.
|
|
const bool isScriptDirectorRendering = GetScriptDirector().IsRendering();
|
|
if(isScriptDirectorRendering)
|
|
{
|
|
const camBaseCamera* renderedCamera = GetScriptDirector().GetRenderedCamera();
|
|
if(renderedCamera)
|
|
{
|
|
bool shouldCameraControlMiniMapHeading = false;
|
|
if (renderedCamera->GetIsClassId(camScriptedCamera::GetStaticClassId()))
|
|
{
|
|
const camScriptedCamera* scriptedCamera = static_cast<const camScriptedCamera*>(renderedCamera);
|
|
shouldCameraControlMiniMapHeading = scriptedCamera->ShouldControlMiniMapHeading();
|
|
}
|
|
else if (renderedCamera->GetIsClassId(camAnimatedCamera::GetStaticClassId()))
|
|
{
|
|
const camAnimatedCamera* animatedCamera = static_cast<const camAnimatedCamera*>(renderedCamera);
|
|
shouldCameraControlMiniMapHeading = animatedCamera->ShouldControlMiniMapHeading();
|
|
}
|
|
|
|
if(shouldCameraControlMiniMapHeading)
|
|
{
|
|
//Use the script director's frame, as this can include the result of interpolation not visible in rendered camera itself.
|
|
const float heading = GetScriptDirector().GetFrameNoPostEffects().ComputeHeading();
|
|
|
|
return heading;
|
|
}
|
|
}
|
|
}
|
|
|
|
const bool isRenderingCinematicCamera = GetCinematicDirector().IsRendering();
|
|
if(isRenderingCinematicCamera)
|
|
{
|
|
const bool isRenderingMountedCamera = (GetCinematicDirector().IsRenderingCinematicMountedCamera());
|
|
if(isRenderingMountedCamera)
|
|
{
|
|
//Use the base front, the no post effects frame has already cloned the post effect frame by this point
|
|
const camBaseCamera* renderedCamera = camInterface::GetDominantRenderedCamera();
|
|
const Vector3& front = renderedCamera->GetBaseFront();
|
|
const float heading = camFrame::ComputeHeadingFromFront(front);
|
|
|
|
return heading;
|
|
}
|
|
|
|
const bool isRendingIdleCamera = (GetCinematicDirector().IsRenderingCinematicIdleCamera());
|
|
if(isRendingIdleCamera)
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
//Lock the mini-map to point north when spectating a remote player that is on-foot. Otherwise the mini-map can spin around in an
|
|
//unintuitive way.
|
|
const camBaseCinematicContext* currentContext = GetCinematicDirector().GetCurrentContext();
|
|
if(currentContext && currentContext->GetIsClassId(camCinematicOnFootSpectatingContext::GetStaticClassId()))
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
const camThirdPersonCamera* thirdPersonCamera = GetGameplayDirector().GetThirdPersonCamera();
|
|
if(thirdPersonCamera)
|
|
{
|
|
//Use the base front, as this ignores look-behind and thereby avoids confusing the user when a cinematic camera is rendering.
|
|
const Vector3& front = thirdPersonCamera->GetBaseFront();
|
|
const float heading = camFrame::ComputeHeadingFromFront(front);
|
|
|
|
return heading;
|
|
}
|
|
}
|
|
|
|
#if GTA_REPLAY
|
|
if(CReplayMgr::IsEditModeActive())
|
|
{
|
|
const bool isRenderingReplayCamera = camManager::FindDirector<camReplayDirector>()->IsRendering();
|
|
if(isRenderingReplayCamera)
|
|
{
|
|
const float heading = camManager::FindDirector<camReplayDirector>()->GetFrameNoPostEffects().ComputeHeading();
|
|
|
|
return heading;
|
|
}
|
|
}
|
|
#endif // GTA_REPLAY
|
|
|
|
const float heading = GetGameplayDirector().GetFrameNoPostEffects().ComputeHeading();
|
|
|
|
return heading;
|
|
}
|
|
|
|
void camInterface::CacheFrame(const camFrame& sourceFrame)
|
|
{
|
|
ms_FramePositionDelta = sourceFrame.GetPosition() - ms_CachedFrame.GetPosition();
|
|
float invTimeStep = fwTimer::GetInvTimeStep();
|
|
Vector3 velocity = ms_FramePositionDelta * invTimeStep;
|
|
Vector3 acceleration = (velocity - ms_FrameVelocity) * invTimeStep;
|
|
ms_FrameVelocity = velocity;
|
|
ms_FrameRateOfChangeOfAcceleration = (acceleration - ms_FrameAcceleration) * invTimeStep;
|
|
ms_FrameAcceleration = acceleration;
|
|
|
|
PF_SET(camInterfaceFrameVelocityMag, ms_FrameVelocity.Mag());
|
|
PF_SET(camInterfaceFrameAccelerationMag, ms_FrameAcceleration.Mag());
|
|
PF_SET(camInterfaceFrameRateOfChangeOfAccelerationMag, ms_FrameRateOfChangeOfAcceleration.Mag());
|
|
PF_SET(camInterfaceFrameAngularVelocityMag, sourceFrame.GetFront().FastAngle(ms_CachedFrame.GetFront()) * invTimeStep);
|
|
PF_SET(camInterfaceFov, sourceFrame.GetFov());
|
|
|
|
ms_CachedFrame.CloneFrom(sourceFrame);
|
|
|
|
ms_CachedFrame.ComputeHeadingPitchAndRoll(ms_CachedHeading, ms_CachedPitch, ms_CachedRoll);
|
|
|
|
UpdateRenderedCamInVehicle();
|
|
|
|
//Override the streaming focus, as necessary.
|
|
const bool shouldOverrideStreamingFocus = sourceFrame.GetFlags().IsFlagSet(camFrame::Flag_ShouldOverrideStreamingFocus);
|
|
if(shouldOverrideStreamingFocus)
|
|
{
|
|
CFocusEntityMgr::GetMgr().SetPosAndVel(sourceFrame.GetPosition(), velocity);
|
|
}
|
|
else if(ms_IsOverridingStreamingFocus)
|
|
{
|
|
//Reset the streaming focus, which is persistent.
|
|
CFocusEntityMgr::GetMgr().SetDefault(true);
|
|
}
|
|
|
|
ms_IsOverridingStreamingFocus = shouldOverrideStreamingFocus;
|
|
|
|
if(IsDeathFailEffectActive())
|
|
{
|
|
cameraDebugf3("Camera death/fail effect is active (state = %d)", ms_DeathFailEffectState);
|
|
}
|
|
|
|
if (CControlMgr::GetKeyboard().GetKeyJustDown(KEY_F3, KEYBOARD_MODE_DEBUG_ALT))
|
|
{
|
|
rage::ioHeadTracking::EnableFPSCamera(!rage::ioHeadTracking::UseFPSCamera());
|
|
}
|
|
|
|
CPad *pPad = CControlMgr::GetPlayerPad();
|
|
if (pPad)
|
|
{
|
|
#if !__FINAL
|
|
if(pPad->GetLeftShoulder1() && pPad->GetLeftShoulder2() && rage::ioHeadTracking::IsMotionTrackingEnabled())
|
|
{
|
|
rage::ioHeadTracking::EnableFPSCamera(!rage::ioHeadTracking::UseFPSCamera());
|
|
}
|
|
#endif // !__FINAL
|
|
if(pPad->GetDPadLeft() && pPad->ButtonCrossJustDown())
|
|
{
|
|
rage::ioHeadTracking::Reset();
|
|
}
|
|
}
|
|
|
|
fwTimer::SetTimeWarpCamera(sourceFrame.GetCameraTimeScaleThisUpdate());
|
|
}
|
|
|
|
void camInterface::SetCachedFrameOnly(const camFrame& sourceFrame)
|
|
{
|
|
ms_CachedFrame.CloneFrom(sourceFrame);
|
|
}
|
|
|
|
const CPed* camInterface::FindFollowPed()
|
|
{
|
|
const CPed* followPlayer = static_cast<CPed*>(CGameWorld::FindFollowPlayer());
|
|
|
|
if(ms_ScriptControlledFollowPedThisUpdate)
|
|
{
|
|
followPlayer = ms_ScriptControlledFollowPedThisUpdate;
|
|
}
|
|
else if(ms_GameplayDirector)
|
|
{
|
|
const camBaseSwitchHelper* switchHelper = static_cast<const camGameplayDirector*>(ms_GameplayDirector.Get())->GetSwitchHelper();
|
|
if(switchHelper)
|
|
{
|
|
const CPed* desiredFollowPedForSwitch = switchHelper->GetDesiredFollowPed();
|
|
if(desiredFollowPedForSwitch)
|
|
{
|
|
followPlayer = desiredFollowPedForSwitch;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if __BANK
|
|
if(ms_DebugShouldFollowDebugFocusPed)
|
|
{
|
|
CEntity* debugFocusEntity = CDebugScene::FocusEntities_Get(0);
|
|
if(debugFocusEntity)
|
|
{
|
|
if(debugFocusEntity->GetIsTypePed())
|
|
{
|
|
followPlayer = static_cast<CPed*>(debugFocusEntity);
|
|
}
|
|
else if(debugFocusEntity->GetIsTypeVehicle())
|
|
{
|
|
const CPed* driver = static_cast<CVehicle*>(debugFocusEntity)->GetDriver();
|
|
if(driver)
|
|
{
|
|
followPlayer = driver;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // __BANK
|
|
|
|
return followPlayer;
|
|
}
|
|
|
|
//Resurrect the main player - cameras associated with this player are cleaned up and reinstated.
|
|
void camInterface::ResurrectPlayer()
|
|
{
|
|
SetDeathFailEffectState(DEATH_FAIL_EFFECT_INACTIVE);
|
|
|
|
GetGameplayDirector().ResurrectPlayer();
|
|
GetCinematicDirector().InvalidateIdleCamera();
|
|
}
|
|
|
|
void camInterface::ShakeCameraExplosion(u32 shakeNameHash, float explosionStrength, float rollOffScaling, const Vector3& positionOfExplosion)
|
|
{
|
|
if(explosionStrength < SMALL_FLOAT)
|
|
{
|
|
return;
|
|
}
|
|
|
|
GetGameplayDirector().RegisterExplosion(shakeNameHash, explosionStrength, rollOffScaling, positionOfExplosion);
|
|
}
|
|
|
|
bool camInterface::IsCameraShaking(const bool includeExplosions)
|
|
{
|
|
const camBaseDirector* renderedDirector = GetDominantRenderedDirector();
|
|
if(renderedDirector && renderedDirector->IsShaking())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if(includeExplosions)
|
|
{
|
|
const atArray<camGameplayDirector::tExplosionSettings>& explosionSettingsList = GetGameplayDirector().GetExplosionSettings();
|
|
for(s32 explosionIndex = 0; explosionIndex < explosionSettingsList.GetCount(); ++explosionIndex)
|
|
{
|
|
if(explosionSettingsList[explosionIndex].m_FrameShaker)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void camInterface::RegisterWeaponFire(const CWeapon& weapon, const CEntity& firingEntity, const bool isNetworkClone)
|
|
{
|
|
const int numDirectors = camManager::ms_Directors.GetCount();
|
|
for(int i = 0; i < numDirectors; i++)
|
|
{
|
|
camBaseDirector* director = camManager::ms_Directors[i];
|
|
if(director)
|
|
{
|
|
director->RegisterWeaponFire(weapon, firingEntity, isNetworkClone);
|
|
}
|
|
}
|
|
}
|
|
|
|
float camInterface::GetViewportTanFovH()
|
|
{
|
|
return gVpMan.GetCurrentViewport()->GetGrcViewport().GetTanHFOV();
|
|
}
|
|
|
|
float camInterface::GetViewportTanFovV()
|
|
{
|
|
return gVpMan.GetCurrentViewport()->GetGrcViewport().GetTanVFOV();
|
|
}
|
|
|
|
const Vector3& camInterface::GetViewportUp()
|
|
{
|
|
return RCC_VECTOR3(gVpMan.GetCurrentViewport()->GetGrcViewport().GetCameraMtx().GetCol2ConstRef());
|
|
}
|
|
|
|
void camInterface::SetFixedFade(float fadeValue)
|
|
{
|
|
SetFixedFade(fadeValue, Color_black);
|
|
}
|
|
|
|
void camInterface::SetFixedFade(float fadeValue, const Color32 &fadeColor)
|
|
{
|
|
ms_Fader.SetFixedFade(fadeValue, &fadeColor);
|
|
}
|
|
|
|
void camInterface::FadeOut(s32 duration, bool shouldHoldAtEnd)
|
|
{
|
|
FadeOut(duration, shouldHoldAtEnd, Color_black);
|
|
}
|
|
|
|
void camInterface::FadeOut(s32 duration, bool shouldHoldAtEnd, const Color32& fadeColour)
|
|
{
|
|
STRVIS_ADD_MARKER(strStreamingVisualize::MARKER);
|
|
STRVIS_SET_MARKER_TEXT("FADE OUT");
|
|
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
if(viewport)
|
|
{
|
|
ms_Fader.Set(duration, false, &fadeColour, shouldHoldAtEnd);
|
|
|
|
if (!CLoadingScreens::AreActive())
|
|
{
|
|
CLoadingText::SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool camInterface::IsFadingOut()
|
|
{
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
bool isFadingOut = viewport && (ms_Fader.IsFadingOut());
|
|
return isFadingOut;
|
|
}
|
|
|
|
bool camInterface::IsFadedOut()
|
|
{
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
bool isFadedOut = viewport && (ms_Fader.IsFadedOut());
|
|
return isFadedOut;
|
|
}
|
|
|
|
void camInterface::FadeIn(s32 duration)
|
|
{
|
|
FadeIn(duration, Color_black);
|
|
}
|
|
|
|
void camInterface::FadeIn(s32 duration, const Color32& fadeColour)
|
|
{
|
|
STRVIS_ADD_MARKER(strStreamingVisualize::MARKER);
|
|
STRVIS_SET_MARKER_TEXT("FADE IN");
|
|
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
if(viewport)
|
|
{
|
|
ms_Fader.Set(duration, true, &fadeColour);
|
|
|
|
CLoadingText::SetActive(false);
|
|
}
|
|
}
|
|
|
|
void camInterface::RenderFade()
|
|
{
|
|
ms_Fader.Render();
|
|
}
|
|
|
|
bool camInterface::IsFadingIn()
|
|
{
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
bool isFadingIn = viewport && (ms_Fader.IsFadingIn());
|
|
return isFadingIn;
|
|
}
|
|
|
|
bool camInterface::IsFadedIn()
|
|
{
|
|
CViewport* viewport = gVpMan.GetPrimaryOrthoViewport();
|
|
bool isFadedIn = viewport && (ms_Fader.IsFadedIn());
|
|
return isFadedIn;
|
|
}
|
|
|
|
bool camInterface::IsFading()
|
|
{
|
|
bool isFading = IsFadingIn() || IsFadingOut();
|
|
return isFading;
|
|
}
|
|
|
|
bool camInterface::IsFadingOrJustFaded()
|
|
{
|
|
#define NUM_FRAMES_TO_WAIT (15)
|
|
bool isFadingOrJustFaded = IsFading();
|
|
|
|
static u32 releaseFramesRemaining = NUM_FRAMES_TO_WAIT;
|
|
if(isFadingOrJustFaded)
|
|
{
|
|
releaseFramesRemaining = NUM_FRAMES_TO_WAIT;
|
|
}
|
|
else if(releaseFramesRemaining > 0)
|
|
{
|
|
releaseFramesRemaining--;
|
|
}
|
|
|
|
if(releaseFramesRemaining > 0)
|
|
{
|
|
isFadingOrJustFaded = true;
|
|
}
|
|
|
|
return isFadingOrJustFaded;
|
|
}
|
|
|
|
void camInterface::UpdateFade()
|
|
{
|
|
ms_Fader.Process();
|
|
}
|
|
|
|
float camInterface::GetFadeLevel()
|
|
{
|
|
float fadeLevel = ms_Fader.GetAudioFade();
|
|
return fadeLevel;
|
|
}
|
|
|
|
#if GTA_REPLAY
|
|
void camInterface::SetFader(const CViewportFader& fader)
|
|
{
|
|
ms_Fader = fader;
|
|
}
|
|
#endif
|
|
|
|
//Returns true if the specified sphere is visible in the game viewport.
|
|
bool camInterface::IsSphereVisibleInGameViewport(const Vector3& centre, float radius)
|
|
{
|
|
bool isVisible = false;
|
|
|
|
CViewport* gameViewport = gVpMan.GetGameViewport();
|
|
if(cameraVerifyf(gameViewport, "camInterface::IsSphereVisibleInGameViewport was called when no game viewport was active"))
|
|
{
|
|
isVisible = (gameViewport->GetGrcViewport().IsSphereVisible(centre.x, centre.y, centre.z, radius) != cullOutside);
|
|
}
|
|
|
|
return isVisible;
|
|
}
|
|
|
|
bool camInterface::IsSphereVisibleInGameViewport(Vec4V_In centreAndRadius)
|
|
{
|
|
bool isVisible = false;
|
|
|
|
CViewport* gameViewport = gVpMan.GetGameViewport();
|
|
if(cameraVerifyf(gameViewport, "camInterface::IsSphereVisibleInGameViewport was called when no game viewport was active"))
|
|
{
|
|
isVisible = (gameViewport->GetGrcViewport().IsSphereVisible(centreAndRadius) != 0);
|
|
}
|
|
|
|
return isVisible;
|
|
}
|
|
|
|
|
|
bool camInterface::IsSphereVisibleInViewport(int viewportId, const Vector3& centre, float radius)
|
|
{
|
|
bool isVisible = false;
|
|
|
|
CViewport* viewport = gVpMan.FindById(viewportId);
|
|
if(cameraVerifyf(viewport, "camInterface::IsSphereVisibleInViewport was called with an inactive viewport ID"))
|
|
{
|
|
isVisible = (viewport->GetGrcViewport().IsSphereVisible(centre.x, centre.y, centre.z, radius) != cullOutside);
|
|
}
|
|
|
|
return isVisible;
|
|
}
|
|
|
|
bool camInterface::ComputeVehicleEntryExitPointPositionAndOrientation(const CPed& targetPed, const CVehicle& targetVehicle, Vector3& entryExitPointPosition,
|
|
Quaternion& entryExitOrientation, bool& hasClimbDown)
|
|
{
|
|
CQueriableInterface* queriableInterface = targetPed.GetPedIntelligence()->GetQueriableInterface();
|
|
if(!queriableInterface)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
s32 entryPointId = -1;
|
|
bool isGetInTaskActive = queriableInterface->IsTaskCurrentlyRunning(CTaskTypes::TASK_ENTER_VEHICLE);
|
|
if(isGetInTaskActive)
|
|
{
|
|
entryPointId = queriableInterface->GetTargetEntryPointForTaskType(CTaskTypes::TASK_ENTER_VEHICLE);
|
|
}
|
|
|
|
bool isGetOutTaskActive = queriableInterface->IsTaskCurrentlyRunning(CTaskTypes::TASK_EXIT_VEHICLE);
|
|
if(isGetOutTaskActive)
|
|
{
|
|
entryPointId = queriableInterface->GetTargetEntryPointForTaskType(CTaskTypes::TASK_EXIT_VEHICLE);
|
|
}
|
|
|
|
if(entryPointId < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CModelSeatInfo::CalculateEntrySituation(&targetVehicle, &targetPed, entryExitPointPosition, entryExitOrientation, entryPointId);
|
|
|
|
const CVehicleEntryPointAnimInfo* clipInfo = targetVehicle.GetEntryAnimInfo(entryPointId);
|
|
hasClimbDown = clipInfo && clipInfo->GetHasClimbDown();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool camInterface::ComputeShouldPauseCameras()
|
|
{
|
|
#if SECTOR_TOOLS_EXPORT
|
|
const bool isRunningSectorTools = CSectorTools::GetEnabled();
|
|
#else
|
|
const bool isRunningSectorTools = false;
|
|
#endif // SECTOR_TOOLS_EXPORT
|
|
|
|
//Only during a single-player game does the front-end pause the cameras.
|
|
//MF: Also only when the player settings menu is not running, don't forget that.
|
|
//NOTE: Cameras are never paused when the debug sector tools are running, as all cameras must update during the tests.
|
|
const bool shouldPause = !isRunningSectorTools && BANK_ONLY(!fwTimer::GetSingleStepThisFrame() &&)
|
|
((fwTimer::IsUserPaused() && !NetworkInterface::IsGameInProgress()) || fwTimer::IsGamePaused());
|
|
|
|
return shouldPause REPLAY_ONLY(&& !CReplayMgr::IsEditModeActive());
|
|
}
|
|
|
|
struct tCameraFocusPedCandidate
|
|
{
|
|
CPed* m_Ped;
|
|
float m_ScaledDistance;
|
|
};
|
|
|
|
s32 CameraFocusPedCandidateCompareFunc(const tCameraFocusPedCandidate* candidateA, const tCameraFocusPedCandidate* candidateB)
|
|
{
|
|
return (candidateA->m_ScaledDistance < candidateB->m_ScaledDistance) ? -1 : 1;
|
|
}
|
|
|
|
CPed* camInterface::ComputeFocusPedOnScreen(float maxValidDistance, s32 screenPositionTestBoneTag,
|
|
float maxScreenWidthRatioAroundCentreForTestBone, float maxScreenHeightRatioAroundCentreForTestBone, float minRelativeHeadingScore,
|
|
float maxScreenCentreScoreBoost, float maxScreenRatioAroundCentreForScoreBoost, s32 losTestBoneTag1, s32 losTestBoneTag2)
|
|
{
|
|
const CPed* followPed = FindFollowPed();
|
|
const Vector3& cameraPosition = ms_CachedFrame.GetPosition();
|
|
const Vector3& cameraFront = ms_CachedFrame.GetFront();
|
|
const float verticalFov = ms_CachedFrame.GetFov();
|
|
const CViewport* viewport = gVpMan.GetGameViewport();
|
|
const float aspectRatio = viewport ? viewport->GetGrcViewport().GetAspectRatio() : (16.0f / 9.0f);
|
|
const float horizontalFov = verticalFov * aspectRatio;
|
|
|
|
const float maxCameraToScreenTestBoneHeadingDelta = 0.5f * maxScreenWidthRatioAroundCentreForTestBone * horizontalFov * DtoR;
|
|
const float maxCameraToScreenTestBonePitchDelta = 0.5f * maxScreenHeightRatioAroundCentreForTestBone * verticalFov * DtoR;
|
|
|
|
atArray<tCameraFocusPedCandidate> candidatePeds;
|
|
|
|
Vec3V vIteratorPos = VECTOR3_TO_VEC3V(cameraPosition);
|
|
CEntityIterator entityIterator(IteratePeds, followPed, &vIteratorPos, maxValidDistance);
|
|
while(true)
|
|
{
|
|
CEntity* nearbyEntity = entityIterator.GetNext();
|
|
if(!nearbyEntity)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(nearbyEntity->GetIsTypePed())
|
|
{
|
|
CPed* ped = static_cast<CPed*>(nearbyEntity);
|
|
|
|
if(screenPositionTestBoneTag != BONETAG_INVALID)
|
|
{
|
|
//Ensure that the specified test bone is within the view frustum, including a sensible border width.
|
|
Vector3 screenTestBonePosition;
|
|
const bool hasValidBone = ped->GetBonePosition(screenTestBonePosition, static_cast<eAnimBoneTag>(screenPositionTestBoneTag));
|
|
if(!hasValidBone)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Vector3 cameraToScreenTestBoneFront(screenTestBonePosition - cameraPosition);
|
|
cameraToScreenTestBoneFront.NormalizeSafe(cameraFront);
|
|
|
|
const float headingDelta = Abs(camFrame::ComputeHeadingDeltaBetweenFronts(cameraFront, cameraToScreenTestBoneFront));
|
|
if(headingDelta > maxCameraToScreenTestBoneHeadingDelta)
|
|
{
|
|
//This ped's test bone is outside of the screen-space safe zone.
|
|
continue;
|
|
}
|
|
|
|
const float pitchDelta = Abs(camFrame::ComputePitchDeltaBetweenFronts(cameraFront, cameraToScreenTestBoneFront));
|
|
if(pitchDelta > maxCameraToScreenTestBonePitchDelta)
|
|
{
|
|
//This ped's test bone is outside of the screen-space safe zone.
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//Score the camera-relative heading to the ped, as more centrally framed peds are more relevant.
|
|
const Vector3 pedPosition = VEC3V_TO_VECTOR3(ped->GetTransform().GetPosition());
|
|
const Vector3 cameraToPedDelta = pedPosition - cameraPosition;
|
|
Vector3 cameraToPedFront(cameraToPedDelta);
|
|
cameraToPedFront.NormalizeSafe(cameraFront);
|
|
|
|
const float headingDelta = Abs(camFrame::ComputeHeadingDeltaBetweenFronts(cameraFront, cameraToPedFront));
|
|
|
|
float headingScoreScaling = RampValueSafe(headingDelta, 0.0f, 0.5f * horizontalFov * DtoR, 1.0f, 0.0f);
|
|
headingScoreScaling = SlowInOut(headingScoreScaling);
|
|
headingScoreScaling = RampValue(headingScoreScaling, 0.0f, 1.0f, minRelativeHeadingScore, 1.0f);
|
|
|
|
//Compute the any score boost around the screen centre.
|
|
float screenCentreScoreBoost = RampValueSafe(headingDelta, 0.0f, 0.5f * maxScreenRatioAroundCentreForScoreBoost * horizontalFov * DtoR,
|
|
1.0f, 0.0f);
|
|
screenCentreScoreBoost = SlowInOut(screenCentreScoreBoost);
|
|
screenCentreScoreBoost = RampValue(screenCentreScoreBoost, 0.0f, 1.0f, 1.0f, maxScreenCentreScoreBoost);
|
|
headingScoreScaling *= screenCentreScoreBoost;
|
|
|
|
if(headingScoreScaling >= SMALL_FLOAT)
|
|
{
|
|
//Now factor in the distance to the ped.
|
|
tCameraFocusPedCandidate& candidate = candidatePeds.Grow();
|
|
candidate.m_Ped = ped;
|
|
candidate.m_ScaledDistance = cameraToPedDelta.Mag() / headingScoreScaling;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Order the candidates by scaled distance, nearest first.
|
|
candidatePeds.QSort(0, -1, CameraFocusPedCandidateCompareFunc);
|
|
|
|
CPed* focusPed = NULL;
|
|
|
|
//Find the best candidate ped that meets the LOS requirements.
|
|
const int numCandidatePeds = candidatePeds.GetCount();
|
|
for(int i=0; i<numCandidatePeds; i++)
|
|
{
|
|
CPed* candidatePed = candidatePeds[i].m_Ped;
|
|
|
|
if(losTestBoneTag1 != BONETAG_INVALID)
|
|
{
|
|
const bool hasClearLosToPed = ComputeHasClearLineOfSightToPedBone(*candidatePed, losTestBoneTag1);
|
|
if(!hasClearLosToPed)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(losTestBoneTag2 != BONETAG_INVALID)
|
|
{
|
|
const bool hasClearLosToPed = ComputeHasClearLineOfSightToPedBone(*candidatePed, losTestBoneTag2);
|
|
if(!hasClearLosToPed)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
focusPed = candidatePed;
|
|
break;
|
|
}
|
|
|
|
return focusPed;
|
|
}
|
|
|
|
s32 CompareLosProbeIntersections(const WorldProbe::CShapeTestHitPoint* a, const WorldProbe::CShapeTestHitPoint* b)
|
|
{
|
|
return (a->GetHitTValue() < b->GetHitTValue()) ? -1 : 1;
|
|
}
|
|
|
|
bool camInterface::ComputeHasClearLineOfSightToPedBone(const CPed& ped, s32 boneTag, bool shouldIgnoreOcclusionDueToFollowPed, bool shouldIgnoreOcclusionDueToFollowVehicle)
|
|
{
|
|
Vector3 bonePosition;
|
|
const bool hasValidBone = ped.GetBonePosition(bonePosition, static_cast<eAnimBoneTag>(boneTag));
|
|
if(!hasValidBone)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
WorldProbe::CShapeTestProbeDesc probeTest;
|
|
WorldProbe::CShapeTestFixedResults<> probeTestResults;
|
|
probeTest.SetResultsStructure(&probeTestResults);
|
|
probeTest.SetContext(WorldProbe::LOS_Camera);
|
|
|
|
const u32 typesToCollideWith = ArchetypeFlags::GTA_ALL_TYPES_WEAPON | ArchetypeFlags::GTA_RAGDOLL_TYPE;
|
|
probeTest.SetIncludeFlags(typesToCollideWith);
|
|
|
|
atArray<const phInst*> excludeInstances;
|
|
|
|
//Exclude all of the ped's immediate child attachments.
|
|
const fwEntity* childAttachment = ped.GetChildAttachment();
|
|
while(childAttachment)
|
|
{
|
|
const phInst* attachmentInstance = childAttachment->GetCurrentPhysicsInst();
|
|
if(attachmentInstance)
|
|
{
|
|
excludeInstances.Grow() = attachmentInstance;
|
|
}
|
|
|
|
childAttachment = childAttachment->GetSiblingAttachment();
|
|
}
|
|
|
|
if(shouldIgnoreOcclusionDueToFollowPed)
|
|
{
|
|
//Exclude the follow ped capsule and ragdoll bounds.
|
|
const CPed* followPed = FindFollowPed();
|
|
if(followPed)
|
|
{
|
|
const phInst* animatedInstance = followPed->GetAnimatedInst();
|
|
if(animatedInstance)
|
|
{
|
|
excludeInstances.Grow() = animatedInstance;
|
|
}
|
|
|
|
const phInst* ragdollInstance = followPed->GetRagdollInst();
|
|
if(ragdollInstance)
|
|
{
|
|
excludeInstances.Grow() = ragdollInstance;
|
|
}
|
|
|
|
//Exclude all of the follow ped's immediate child attachments.
|
|
const fwEntity* childAttachment = followPed->GetChildAttachment();
|
|
while(childAttachment)
|
|
{
|
|
const phInst* attachmentInstance = childAttachment->GetCurrentPhysicsInst();
|
|
if(attachmentInstance)
|
|
{
|
|
excludeInstances.Grow() = attachmentInstance;
|
|
}
|
|
|
|
childAttachment = childAttachment->GetSiblingAttachment();
|
|
}
|
|
}
|
|
}
|
|
|
|
if(shouldIgnoreOcclusionDueToFollowVehicle)
|
|
{
|
|
const CVehicle* followVehicle = camInterface::GetGameplayDirector().GetFollowVehicle();
|
|
if(followVehicle)
|
|
{
|
|
const phInst* followVehicleInstance = followVehicle->GetCurrentPhysicsInst();
|
|
if(followVehicleInstance)
|
|
{
|
|
excludeInstances.Grow() = followVehicleInstance;
|
|
}
|
|
}
|
|
}
|
|
|
|
const int numExcludeInstances = excludeInstances.GetCount();
|
|
if(numExcludeInstances > 0)
|
|
{
|
|
probeTest.SetExcludeInstances(excludeInstances.GetElements(), numExcludeInstances);
|
|
}
|
|
|
|
const Vector3& cameraPosition = ms_CachedFrame.GetPosition();
|
|
probeTest.SetStartAndEnd(cameraPosition, bonePosition);
|
|
|
|
WorldProbe::GetShapeTestManager()->SubmitTest(probeTest, WorldProbe::PERFORM_SYNCHRONOUS_TEST);
|
|
|
|
const u32 numHits = probeTestResults.GetNumHits();
|
|
if(numHits == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(numHits > 1)
|
|
{
|
|
probeTestResults.SortHits(CompareLosProbeIntersections);
|
|
}
|
|
|
|
phInst* hitInstance = probeTestResults[0].GetHitInst();
|
|
CEntity* hitEntity = hitInstance ? CPhysics::GetEntityFromInst(hitInstance) : NULL;
|
|
|
|
const bool hasClearLosToPed = (hitEntity == &ped);
|
|
|
|
return hasClearLosToPed;
|
|
}
|
|
|
|
//This is for Alex (and decals for rendering bullet holes and stuff on glass.)
|
|
bool camInterface::IsRenderedCameraInsideVehicle()
|
|
{
|
|
#if GTA_REPLAY
|
|
if(CReplayMgr::IsEditModeActive())
|
|
{
|
|
return CReplayMgr::IsRenderedCamInVehicle();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return ms_IsRenderedCamInVehicle;
|
|
}
|
|
}
|
|
|
|
bool camInterface::IsRenderedCameraForcingMotionBlur()
|
|
{
|
|
const camCinematicDirector& cinematicDirector = GetCinematicDirector();
|
|
const camBaseCamera* renderedCinematicCamera = cinematicDirector.GetRenderedCamera();
|
|
const bool isActuallyRenderingCinematicCamera = renderedCinematicCamera && IsDominantRenderedCamera(*renderedCinematicCamera);
|
|
|
|
return isActuallyRenderingCinematicCamera && cinematicDirector.IsRenderedCameraForcingMotionBlur();
|
|
}
|
|
|
|
void camInterface::UpdateRenderedCamInVehicle()
|
|
{
|
|
const camCinematicDirector& cinematicDirector = GetCinematicDirector();
|
|
const camBaseCamera* renderedCinematicCamera = cinematicDirector.GetRenderedCamera();
|
|
const bool isActuallyRenderingCinematicCamera = renderedCinematicCamera && IsDominantRenderedCamera(*renderedCinematicCamera);
|
|
ms_IsRenderedCamInVehicle = isActuallyRenderingCinematicCamera && cinematicDirector.IsRenderedCameraInsideVehicle();
|
|
|
|
if(!ms_IsRenderedCamInVehicle)
|
|
{
|
|
//Check if we're rendering a scripted camera that has been specially flagged by script as being inside a vehicle.
|
|
const camBaseCamera* dominantRenderedCamera = GetDominantRenderedCamera();
|
|
ms_IsRenderedCamInVehicle = (dominantRenderedCamera && dominantRenderedCamera->GetIsClassId(camScriptedCamera::GetStaticClassId()) &&
|
|
static_cast<const camScriptedCamera*>(dominantRenderedCamera)->IsInsideVehicle());
|
|
}
|
|
}
|
|
|
|
bool camInterface::ComputeShouldMakePedHeadInvisible(const CPed& ped)
|
|
{
|
|
const CPed* pedToMakeHeadInvisible = NULL;
|
|
|
|
//Hide the follow ped's head if we're fully rendering gameplay and first-person mode is active.
|
|
// TODO: remove if we drop using third person camera for first person mode, head visibility state read from FirstPersonAimCamera metadata
|
|
#if FPS_MODE_SUPPORTED
|
|
camGameplayDirector* gameplayDirector = static_cast<camGameplayDirector*>(ms_GameplayDirector.Get());
|
|
if(gameplayDirector)
|
|
{
|
|
const bool isFirstPersonModeActive = (gameplayDirector->IsFirstPersonModeEnabled() && gameplayDirector->IsFirstPersonModeAllowed());
|
|
if(isFirstPersonModeActive && gameplayDirector->ShouldUseThirdPersonCameraForFirstPersonMode())
|
|
{
|
|
const atArray<tRenderedCameraObjectSettings>& renderedDirectors = GetRenderedDirectors();
|
|
const int numRenderedDirectors = renderedDirectors.GetCount();
|
|
if((numRenderedDirectors == 1) && (static_cast<const camBaseDirector*>(renderedDirectors[0].m_Object.Get()) == gameplayDirector))
|
|
{
|
|
const CPed* followPed = gameplayDirector->GetFollowPed();
|
|
if(followPed == &ped)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
//Otherwise, we only make the ped's head invisible if we are fully rendering a cinematic mounted or first-person camera that has flagged this ped.
|
|
|
|
const atArray<tRenderedCameraObjectSettings>& renderedCameras = GetRenderedCameras();
|
|
const int numRenderedCameras = renderedCameras.GetCount();
|
|
if(numRenderedCameras < 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const camBaseCamera* renderedCamera = static_cast<const camBaseCamera*>(renderedCameras[0].m_Object.Get());
|
|
if(!renderedCamera)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool isInterpolatingBetweenTableGamesCameras = false;
|
|
if (numRenderedCameras == 2)
|
|
{
|
|
const camBaseCamera* firstCamera = renderedCamera;
|
|
const camBaseCamera* secondCamera = static_cast<const camBaseCamera*>(renderedCameras[1].m_Object.Get());
|
|
|
|
const bool isFirstCameraTableGames =
|
|
firstCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()) &&
|
|
static_cast<const camFirstPersonShooterCamera*>(firstCamera)->IsTableGamesCamera();
|
|
|
|
const bool isSecondCameraTableGames = secondCamera &&
|
|
secondCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()) &&
|
|
static_cast<const camFirstPersonShooterCamera*>(secondCamera)->IsTableGamesCamera();
|
|
|
|
isInterpolatingBetweenTableGamesCameras = isFirstCameraTableGames || isSecondCameraTableGames;
|
|
}
|
|
|
|
if (!isInterpolatingBetweenTableGamesCameras)
|
|
{
|
|
// If cinematic camera is rendering and it wants ped head to be invisible, allow head to be hidden while interpolating. (i.e. 2 cameras rendering)
|
|
bool bCinematicCameraWantsPedHeadInvisible = renderedCamera->GetIsClassId(camCinematicMountedCamera::GetStaticClassId()) &&
|
|
static_cast<const camCinematicMountedCamera*>(renderedCamera)->GetPedToMakeHeadInvisible();
|
|
|
|
if (numRenderedCameras != 1 && (!bCinematicCameraWantsPedHeadInvisible || numRenderedCameras != 2))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( renderedCamera->GetIsClassId(camCinematicMountedCamera::GetStaticClassId()) )
|
|
{
|
|
pedToMakeHeadInvisible = static_cast<const camCinematicMountedCamera*>(renderedCamera)->GetPedToMakeHeadInvisible();
|
|
}
|
|
else if( renderedCamera->GetIsClassId(camFirstPersonAimCamera::GetStaticClassId()) )
|
|
{
|
|
const camFirstPersonAimCamera* pFirstPersonAimCamera = static_cast<const camFirstPersonAimCamera*>(renderedCamera);
|
|
if( !pFirstPersonAimCamera->ShouldMakeAttachedEntityInvisible() && pFirstPersonAimCamera->ShouldMakeAttachedPedHeadInvisible() )
|
|
{
|
|
const CEntity* entityToMakeInvisible = pFirstPersonAimCamera->GetAttachParent();
|
|
if(entityToMakeInvisible && entityToMakeInvisible->GetIsTypePed())
|
|
{
|
|
pedToMakeHeadInvisible = static_cast<const CPed*>(entityToMakeInvisible);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if FPS_MODE_SUPPORTED && 0
|
|
// If free camera is active and only other camera is first person camera, don't render the head.
|
|
camGameplayDirector* gameplayDirector = static_cast<camGameplayDirector*>(ms_GameplayDirector.Get());
|
|
if(ms_DebugDirector.Get() && GetDebugDirector().IsFreeCamActive() && ms_GameplayDirector.Get())
|
|
{
|
|
const bool isFirstPersonModeActive = (GetGameplayDirector().IsFirstPersonModeEnabled() && GetGameplayDirector().IsFirstPersonModeAllowed());
|
|
if(isFirstPersonModeActive)
|
|
{
|
|
const int numRenderedDirectors = renderedDirectors.GetCount();
|
|
if((numRenderedDirectors == 2) && (static_cast<const camBaseDirector*>(renderedDirectors[0].m_Object.Get()) == gameplayDirector))
|
|
{
|
|
const CPed* followPed = gameplayDirector->GetFollowPed();
|
|
if(followPed == &ped)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
const bool shouldMakeInvisible = (pedToMakeHeadInvisible == &ped);
|
|
return shouldMakeInvisible;
|
|
}
|
|
|
|
void camInterface::DisableNearClipScanThisUpdate()
|
|
{
|
|
camManager::ms_FramePropagator.DisableNearClipScanThisUpdate();
|
|
}
|
|
|
|
u32 camInterface::ComputePovTurretCameraHash(const CVehicle* pVehicle)
|
|
{
|
|
const CPed* pFollowPed = FindFollowPed();
|
|
if(!pVehicle || !pVehicle->GetVehicleModelInfo() || !pFollowPed)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
const s32 seatIndex = camGameplayDirector::ComputeSeatIndexPedIsIn(*pVehicle, *pFollowPed);
|
|
const bool isPedOnATurret = camGameplayDirector::IsTurretSeat(pVehicle, seatIndex);
|
|
if(isPedOnATurret)
|
|
{
|
|
const CVehicleModelInfo* pVehicleModelInfo = pVehicle->GetVehicleModelInfo();
|
|
const CWeaponInfo* pTurretWeaponInfo = camGameplayDirector::GetTurretWeaponInfoForSeat(*pVehicle, seatIndex);
|
|
|
|
if(pTurretWeaponInfo && pTurretWeaponInfo->GetPovTurretCameraHash() != 0)
|
|
{
|
|
return pTurretWeaponInfo->GetPovTurretCameraHash();
|
|
}
|
|
else if(pVehicleModelInfo && pVehicleModelInfo->GetPovTurretCameraNameHash() != 0)
|
|
{
|
|
return pVehicleModelInfo->GetPovTurretCameraNameHash();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if RSG_PC
|
|
float camInterface::GetStereoConvergence()
|
|
{
|
|
return camManager::ms_fStereoConvergence;
|
|
}
|
|
#endif
|
|
|
|
void camInterface::SetDeathFailEffectState(s32 state)
|
|
{
|
|
if(ms_DeathFailEffectState == state)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const bool hasSucceeded = GetGameplayDirector().SetDeathFailEffectState(state);
|
|
if(hasSucceeded)
|
|
{
|
|
ms_DeathFailEffectState = state;
|
|
}
|
|
}
|
|
|
|
#if FPS_MODE_SUPPORTED
|
|
void camInterface::ApplyPedBoneOverridesForFirstPerson(const CPed& ped, crSkeleton& skeleton)
|
|
{
|
|
//Rotate the attach ped's spine backwards a little if we're rendering an FPS camera that's been pushed back out of collision (towards a safe fall back position.)
|
|
|
|
const camBaseCamera* renderedCamera = camManager::GetDominantRenderedCamera();
|
|
if(!renderedCamera || !renderedCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
const camFirstPersonShooterCamera* fpsCamera = static_cast<const camFirstPersonShooterCamera*>(renderedCamera);
|
|
const float rotationToApply = fpsCamera->ComputeRotationToApplyToPedSpineBone(ped);
|
|
if(IsNearZero(rotationToApply))
|
|
{
|
|
return;
|
|
}
|
|
|
|
const s32 tempBoneIndex = ped.GetBoneIndexFromBoneTag(BONETAG_SPINE0);
|
|
if(tempBoneIndex == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const u32 boneIndex = static_cast<u32>(tempBoneIndex);
|
|
Mat34V& localBoneMatrix = skeleton.GetLocalMtx(boneIndex);
|
|
Matrix34 tmpLocalBoneMatrix = RC_MATRIX34(localBoneMatrix);
|
|
|
|
tmpLocalBoneMatrix.RotateLocalZ(rotationToApply);
|
|
localBoneMatrix = MATRIX34_TO_MAT34V(tmpLocalBoneMatrix);
|
|
skeleton.PartialUpdate(boneIndex);
|
|
}
|
|
#endif // FPS_MODE_SUPPORTED
|
|
|
|
#if __BANK
|
|
void camInterface::AddWidgets(bkBank &bank)
|
|
{
|
|
bank.AddToggle("Display active camera info on-screen", &ms_DebugShouldDisplayActiveCameraInfo);
|
|
bank.AddToggle("Display game viewport info on-screen", &ms_DebugShouldDisplayGameViewportInfo);
|
|
|
|
bank.AddButton("Dump spectator ped info (network ped id & spectator cam)", datCallback(CFA(DebugDumpSpectatorPedInfo)));
|
|
|
|
bank.AddToggle("Follow debug focus ped", &ms_DebugShouldFollowDebugFocusPed);
|
|
bank.AddToggle("Always take control orientation from follow-ped camera", &ms_DebugForceFollowPedControlOrientation);
|
|
|
|
bank.AddToggle("Flash Locally While Respotting", &ms_DebugFlashLocallyWhileRespotting);
|
|
bank.AddToggle("Flash Remotely While Respotting", &ms_DebugFlashRemotelyWhileRespotting);
|
|
bank.AddSlider("Respot counter to apply", &ms_DebugRespotCounter, 0, 600000, 1);
|
|
bank.AddButton("Set respot counter on debug focus vehicle", datCallback(CFA(DebugSetRespotCounterOnDebugFocusVehicle)));
|
|
}
|
|
|
|
void camInterface::DebugDisplayCameraInfoText()
|
|
{
|
|
const int debugStringLength = 256;
|
|
char debugString[debugStringLength];
|
|
|
|
if(ms_DebugShouldDisplayActiveCameraInfo)
|
|
{
|
|
const camBaseCamera* renderedCamera = camManager::GetDominantRenderedCamera();
|
|
const char* renderedCameraName = SAFE_CSTRING(renderedCamera ? renderedCamera->GetName() : NULL);
|
|
if (renderedCamera && renderedCamera->GetIsClassId(camScriptedCamera::GetStaticClassId()))
|
|
{
|
|
const camScriptedCamera* pScriptedCamera = static_cast<const camScriptedCamera*>(renderedCamera);
|
|
if ( pScriptedCamera->GetDebugName() != NULL && pScriptedCamera->GetDebugName()[0] != 0 )
|
|
{
|
|
renderedCameraName = pScriptedCamera->GetDebugName();
|
|
}
|
|
}
|
|
const Vector3& position = GetPos();
|
|
|
|
#if FPS_MODE_SUPPORTED
|
|
if( renderedCamera &&
|
|
(renderedCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()) ||
|
|
renderedCamera->GetIsClassId(camCinematicMountedCamera::GetStaticClassId())) )
|
|
{
|
|
formatf(debugString, debugStringLength, "%s: %8.2f %8.2f %8.2f[Clip:%5.2f>%8.1f][DOF:%5.2f>%8.1f][FOV:%5.2f][HDG:%.2f][PCH:%.2f]",
|
|
renderedCameraName, position.x, position.y, position.z, GetNear(), GetFar(), GetNearDof(), GetFarDof(), GetFov(), GetHeading(), GetPitch());
|
|
|
|
if(renderedCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()) && Abs(GetRoll()) >= 0.001f)
|
|
safecatf(debugString, debugStringLength, "[RLL:%2.3f]", GetRoll());
|
|
|
|
if( GetMotionBlurStrength() > SMALL_FLOAT )
|
|
{
|
|
safecatf(debugString, debugStringLength, "[MB:%2.3f]", GetMotionBlurStrength());
|
|
}
|
|
|
|
if(renderedCamera->GetIsClassId(camFirstPersonShooterCamera::GetStaticClassId()))
|
|
{
|
|
const camFirstPersonShooterCamera* fpsCamera = (const camFirstPersonShooterCamera*)renderedCamera;
|
|
if(Abs(fpsCamera->GetRelativeHeading()) > SMALL_FLOAT)
|
|
{
|
|
safecatf(debugString, debugStringLength, "[rH:%.3f]", fpsCamera->GetRelativeHeading());
|
|
}
|
|
if(Abs(fpsCamera->GetRelativePitch()) > SMALL_FLOAT)
|
|
{
|
|
safecatf(debugString, debugStringLength, "[rP:%.3f]", fpsCamera->GetRelativePitch());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
formatf(debugString, debugStringLength, "%s: %8.2f %8.2f %8.2f[Clip:%5.2f>%8.2f][DOF:%5.2f>%8.2f][FOV:%5.2f][HDG:%.2f][MB:%2.3f]",
|
|
renderedCameraName, position.x, position.y, position.z, GetNear(), GetFar(), GetNearDof(), GetFarDof(), GetFov(), GetHeading(),
|
|
GetMotionBlurStrength());
|
|
}
|
|
|
|
GetScriptDirector().DebugBuildCameraStringForTextDisplay(debugString, debugStringLength);
|
|
|
|
grcDebugDraw::AddDebugOutput(debugString);
|
|
}
|
|
|
|
if(ms_DebugShouldDisplayGameViewportInfo)
|
|
{
|
|
CViewport *viewport = gVpMan.GetGameViewport();
|
|
if(viewport)
|
|
{
|
|
const grcViewport& grcVp = viewport->GetGrcViewport();
|
|
const Vector2 shear = grcVp.GetPerspectiveShear();
|
|
formatf(debugString, debugStringLength, "Game VPort:[AR %5.3f][WIN %dx%d][FOVY %5.3f][TANHFOV %5.3f][TANVFOV %5.3f][SHEARX %.1f][SHEARY %.1f]",
|
|
grcVp.GetAspectRatio(), grcVp.GetWidth(), grcVp.GetHeight(), grcVp.GetFOVY(), grcVp.GetTanHFOV(), grcVp.GetTanVFOV(), shear.x, shear.y);
|
|
}
|
|
else
|
|
{
|
|
debugString[0] = '\0';
|
|
}
|
|
|
|
grcDebugDraw::AddDebugOutput(debugString);
|
|
}
|
|
|
|
const bool shouldDisplay = camManager::GetFramePropagator().ComputeDebugOutputText(debugString, debugStringLength);
|
|
if(shouldDisplay)
|
|
{
|
|
grcDebugDraw::AddDebugOutput(debugString);
|
|
}
|
|
}
|
|
|
|
void camInterface::DebugDumpSpectatorPedInfo()
|
|
{
|
|
if(NetworkInterface::IsGameInProgress() && NetworkInterface::IsInSpectatorMode())
|
|
{
|
|
ObjectId objid = NetworkInterface::GetSpectatorObjectId();
|
|
|
|
Printf("In Spectator Mode - Dump Network Object Id Info\n");
|
|
Printf("================================================\n");
|
|
Printf("Network Object Id=\"%d\"\n", objid);
|
|
Printf("================================================\n");
|
|
|
|
netObject* netobj = NetworkInterface::GetNetworkObject(objid);
|
|
if(netobj)
|
|
{
|
|
NetworkObjectType objtype = netobj->GetObjectType();
|
|
if (AssertVerify(objtype == NET_OBJ_TYPE_PLAYER || objtype == NET_OBJ_TYPE_PED))
|
|
{
|
|
CPed* ped = static_cast<CPed*>(static_cast<CNetObjPed*>(netobj)->GetPed());
|
|
if(AssertVerify(ped))
|
|
{
|
|
cameraDisplayf("%s: Network ObjId#%d address %p pedID %d\n", objtype == NET_OBJ_TYPE_PLAYER ? "Player" : "Ped", objid, ped, CPed::GetPool()->GetIndex(ped));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void camInterface::DebugSetRespotCounterOnDebugFocusVehicle()
|
|
{
|
|
CEntity* debugFocusEntity = CDebugScene::FocusEntities_Get(0);
|
|
if(debugFocusEntity && debugFocusEntity->GetIsTypeVehicle())
|
|
{
|
|
static_cast<CVehicle*>(debugFocusEntity)->SetFlashLocallyDuringRespotting(ms_DebugFlashLocallyWhileRespotting);
|
|
static_cast<CVehicle*>(debugFocusEntity)->SetFlashRemotelyDuringRespotting(ms_DebugFlashRemotelyWhileRespotting);
|
|
static_cast<CVehicle*>(debugFocusEntity)->SetRespotCounter(ms_DebugRespotCounter);
|
|
}
|
|
}
|
|
|
|
void camInterface::UpdateAtEndOfFrame()
|
|
{
|
|
if (ms_DebugShouldRestartSystemAtEndOfFrame)
|
|
{
|
|
camManager::Shutdown(SHUTDOWN_SESSION);
|
|
camManager::Init(INIT_SESSION);
|
|
|
|
ms_DebugShouldRestartSystemAtEndOfFrame = false;
|
|
}
|
|
}
|
|
#endif // __BANK
|
|
|
|
#if RSG_PC
|
|
bool camInterface::IsTripleHeadDisplay()
|
|
{
|
|
const float sceneWidth = static_cast<float>(VideoResManager::GetSceneWidth());
|
|
const float sceneHeight = static_cast<float>(VideoResManager::GetSceneHeight());
|
|
const float viewportAspect = sceneWidth / sceneHeight;
|
|
|
|
const float baseLineAspectRatio = 4.0f/3.0f;
|
|
const float wideScreenAspectRatio = baseLineAspectRatio * baseLineAspectRatio; //16:9
|
|
const float ultraWideScreenAspectRatio = wideScreenAspectRatio * baseLineAspectRatio; //21:9
|
|
|
|
//we arbitrarily pick up a point in between the wide and ultra-wide aspect ratio. This because we often see windowed resolutions
|
|
//which have an aspect ratio bigger than 16:9 screen but smaller than 21:9
|
|
const float minValueToConsiderTripleHead = (wideScreenAspectRatio + ultraWideScreenAspectRatio) * 0.5f; //mid point
|
|
|
|
const bool isTripleHeadDisplay = viewportAspect >= minValueToConsiderTripleHead;
|
|
|
|
TUNE_BOOL(FORCE_TRIPLEHEAD_CAMERA_CODE_EVERYWHERE, false);
|
|
return isTripleHeadDisplay || FORCE_TRIPLEHEAD_CAMERA_CODE_EVERYWHERE;
|
|
}
|
|
#endif
|