summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/control/Garages.cpp5
-rw-r--r--src/control/Garages.h2
-rw-r--r--src/control/Remote.cpp2
-rw-r--r--src/control/SceneEdit.cpp1
-rw-r--r--src/control/SceneEdit.h1
-rw-r--r--src/control/Script.cpp8
-rw-r--r--src/core/AnimViewer.cpp2
-rw-r--r--src/core/Cam.cpp125
-rw-r--r--src/core/Camera.cpp3404
-rw-r--r--src/core/Camera.h224
-rw-r--r--src/core/CutsceneMgr.h1
-rw-r--r--src/core/Frontend.cpp8
-rw-r--r--src/core/Frontend.h2
-rw-r--r--src/core/Pad.h2
-rw-r--r--src/core/config.h2
-rw-r--r--src/core/re3.cpp6
-rw-r--r--src/peds/Ped.cpp8
-rw-r--r--src/peds/PlayerPed.cpp16
-rw-r--r--src/vehicles/Automobile.cpp6
19 files changed, 3462 insertions, 363 deletions
diff --git a/src/control/Garages.cpp b/src/control/Garages.cpp
index 2cb89444..6a91da76 100644
--- a/src/control/Garages.cpp
+++ b/src/control/Garages.cpp
@@ -1464,8 +1464,9 @@ void CGarage::UpdateDoorsHeight()
void CGarage::BuildRotatedDoorMatrix(CEntity * pDoor, float fPosition)
{
float fAngle = -fPosition * HALFPI;
- CVector r(-Sin(fAngle) * pDoor->GetForward().x, Sin(fAngle) * pDoor->GetForward().y, Cos(fAngle) * pDoor->GetForward().z);
- pDoor->GetRight() = CrossProduct(r, pDoor->GetForward());
+ CVector up(-Sin(fAngle) * pDoor->GetForward().y, Sin(fAngle) * pDoor->GetForward().z, Cos(fAngle));
+ pDoor->GetRight() = CrossProduct(up, pDoor->GetForward());
+ pDoor->GetUp() = up;
}
void CGarage::UpdateCrusherAngle()
diff --git a/src/control/Garages.h b/src/control/Garages.h
index 3f471555..e3864a48 100644
--- a/src/control/Garages.h
+++ b/src/control/Garages.h
@@ -5,6 +5,7 @@
#include "config.h"
class CVehicle;
+class CCamera;
enum eGarageState : int8
{
@@ -168,6 +169,7 @@ class CGarage
friend class CGarages;
friend class cAudioManager;
+ friend class CCamera;
};
static_assert(sizeof(CGarage) == 140, "CGarage");
diff --git a/src/control/Remote.cpp b/src/control/Remote.cpp
index e3891502..f7d12702 100644
--- a/src/control/Remote.cpp
+++ b/src/control/Remote.cpp
@@ -35,7 +35,7 @@ CRemote::GivePlayerRemoteControlledCar(float x, float y, float z, float rot, uin
CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle = car;
CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle->RegisterReference((CEntity**)&CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle);
- TheCamera.TakeControl(car, CCam::MODE_BEHINDCAR, INTERPOLATION, CAM_CONTROLLER_1);
+ TheCamera.TakeControl(car, CCam::MODE_BEHINDCAR, INTERPOLATION, CAMCONTROL_SCRIPT);
}
void
diff --git a/src/control/SceneEdit.cpp b/src/control/SceneEdit.cpp
index 4c05e11b..3e55d431 100644
--- a/src/control/SceneEdit.cpp
+++ b/src/control/SceneEdit.cpp
@@ -2,6 +2,7 @@
#include "patcher.h"
#include "SceneEdit.h"
+bool &CSceneEdit::m_bEditOn = *(bool*)0x95CD77;
int32 &CSceneEdit::m_bCameraFollowActor = *(int*)0x940590;
bool &CSceneEdit::m_bRecording = *(bool*)0x95CD1F;
CVector &CSceneEdit::m_vecCurrentPosition = *(CVector*)0x943064;
diff --git a/src/control/SceneEdit.h b/src/control/SceneEdit.h
index ec321b27..0de72c19 100644
--- a/src/control/SceneEdit.h
+++ b/src/control/SceneEdit.h
@@ -3,6 +3,7 @@
class CSceneEdit
{
public:
+ static bool &m_bEditOn;
static int32 &m_bCameraFollowActor;
static bool &m_bRecording;
static CVector &m_vecCurrentPosition;
diff --git a/src/control/Script.cpp b/src/control/Script.cpp
index 8a79ba1d..f96ec060 100644
--- a/src/control/Script.cpp
+++ b/src/control/Script.cpp
@@ -3073,7 +3073,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
{
CollectParameters(&m_nIp, 3);
// ScriptParams[0] is unused.
- TheCamera.TakeControl(nil, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+ TheCamera.TakeControl(nil, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
return 0;
}
case COMMAND_POINT_CAMERA_AT_CAR:
@@ -3081,7 +3081,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
CollectParameters(&m_nIp, 3);
CVehicle* pVehicle = CPools::GetVehiclePool()->GetAt(ScriptParams[0]);
assert(pVehicle);
- TheCamera.TakeControl(pVehicle, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+ TheCamera.TakeControl(pVehicle, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
return 0;
}
case COMMAND_POINT_CAMERA_AT_CHAR:
@@ -3089,7 +3089,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
CollectParameters(&m_nIp, 3);
CPed* pPed = CPools::GetPedPool()->GetAt(ScriptParams[0]);
assert(pPed);
- TheCamera.TakeControl(pPed, ScriptParams[1], ScriptParams[2], CAM_CONTROLLER_1);
+ TheCamera.TakeControl(pPed, ScriptParams[1], ScriptParams[2], CAMCONTROL_SCRIPT);
return 0;
}
case COMMAND_RESTORE_CAMERA:
@@ -3140,7 +3140,7 @@ int8 CRunningScript::ProcessCommands300To399(int32 command)
CVector pos = *(CVector*)&ScriptParams[0];
if (pos.z <= MAP_Z_LOW_LIMIT)
pos.z = CWorld::FindGroundZForCoord(pos.x, pos.y);
- TheCamera.TakeControlNoEntity(pos, ScriptParams[3], CAM_CONTROLLER_1);
+ TheCamera.TakeControlNoEntity(pos, ScriptParams[3], CAMCONTROL_SCRIPT);
return 0;
}
case COMMAND_ADD_BLIP_FOR_CAR_OLD:
diff --git a/src/core/AnimViewer.cpp b/src/core/AnimViewer.cpp
index 20a0098d..1086db20 100644
--- a/src/core/AnimViewer.cpp
+++ b/src/core/AnimViewer.cpp
@@ -294,7 +294,7 @@ CAnimViewer::Update(void)
}
newEntity->GetPosition() = CVector(0.0f, 0.0f, 0.0f);
CWorld::Add(newEntity);
- TheCamera.TakeControl(pTarget, CCam::MODE_MODELVIEW, JUMP_CUT, CAM_CONTROLLER_1);
+ TheCamera.TakeControl(pTarget, CCam::MODE_MODELVIEW, JUMP_CUT, CAMCONTROL_SCRIPT);
}
if (pTarget->m_type == ENTITY_TYPE_VEHICLE || pTarget->m_type == ENTITY_TYPE_PED || pTarget->m_type == ENTITY_TYPE_OBJECT) {
((CPhysical*)pTarget)->m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
diff --git a/src/core/Cam.cpp b/src/core/Cam.cpp
index dd1b5ce2..5b7a53e9 100644
--- a/src/core/Cam.cpp
+++ b/src/core/Cam.cpp
@@ -31,8 +31,7 @@ bool PrintDebugCode = false;
int16 &DebugCamMode = *(int16*)0x95CCF2;
#ifdef FREE_CAM
-bool bFreePadCam = false;
-bool bFreeMouseCam = false;
+bool CCamera::bFreeCam = false;
int nPreviousMode = -1;
#endif
@@ -146,7 +145,7 @@ CCam::Process(void)
Process_FollowPedWithMouse(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
else
#ifdef FREE_CAM
- if(bFreePadCam)
+ if(CCamera::bFreeCam)
Process_FollowPed_Rotation(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
else
#endif
@@ -187,7 +186,7 @@ CCam::Process(void)
break;
case MODE_CAM_ON_A_STRING:
#ifdef FREE_CAM
- if(bFreeMouseCam || bFreePadCam)
+ if(CCamera::bFreeCam)
Process_FollowCar_SA(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
else
#endif
@@ -204,7 +203,7 @@ CCam::Process(void)
break;
case MODE_BEHINDBOAT:
#ifdef FREE_CAM
- if (bFreeMouseCam || bFreePadCam)
+ if (CCamera::bFreeCam)
Process_FollowCar_SA(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
else
#endif
@@ -267,7 +266,7 @@ CCam::Process(void)
float DistOnGround = TargetToCam.Magnitude2D();
m_fTrueBeta = CGeneral::GetATanOfXY(TargetToCam.x, TargetToCam.y);
m_fTrueAlpha = CGeneral::GetATanOfXY(TargetToCam.z, DistOnGround);
- if(TheCamera.m_uiTransitionState == 0) // TODO? what values are possible? enum?
+ if(TheCamera.m_uiTransitionState == 0)
KeepTrackOfTheSpeed(Source, m_cvecTargetCoorsForFudgeInter, Up, m_fTrueAlpha, m_fTrueBeta, FOV);
// Look Behind, Left, Right
@@ -421,11 +420,11 @@ CCam::ProcessSpecialHeightRoutines(void)
float DistScale = (2.1f - dist)/2.1f;
if(Mode == MODE_FOLLOWPED){
- if(TheCamera.PedZoomIndicator == 1.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_1)
Offset = 0.45*DistScale + PedZDist;
- if(TheCamera.PedZoomIndicator == 2.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_2)
Offset = 0.35*DistScale + PedZDist;
- if(TheCamera.PedZoomIndicator == 3.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_3)
Offset = 0.25*DistScale + PedZDist;
if(Abs(CGeneral::GetRadianAngleBetweenPoints(CamToPed.x, CamToPed.y, CamToTarget.x, CamToTarget.y)) > HALFPI)
Offset += 0.3f;
@@ -575,11 +574,11 @@ CCam::ProcessSpecialHeightRoutines(void)
m_fRoadOffSet = 1.4f;
}else{
if(Mode == MODE_FOLLOWPED){
- if(TheCamera.PedZoomIndicator == 1.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_1)
m_fRoadOffSet += 0.2f;
- if(TheCamera.PedZoomIndicator == 2.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_2)
m_fRoadOffSet += 0.5f;
- if(TheCamera.PedZoomIndicator == 3.0f)
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_3)
m_fRoadOffSet += 0.95f;
}
}
@@ -628,7 +627,7 @@ CCam::LookBehind(void)
DeltaBeta = TargetOrientation - Beta;
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
- if(DirectionWasLooking == LOOKING_BEHIND)
+ if(DirectionWasLooking != LOOKING_BEHIND)
LookBehindCamWasInFront = DeltaBeta <= -HALFPI || DeltaBeta >= HALFPI;
if(LookBehindCamWasInFront)
TargetOrientation += PI;
@@ -636,7 +635,7 @@ CCam::LookBehind(void)
Source.y = Dist*Sin(TargetOrientation) + TargetCoors.y;
Source.z -= 1.0f;
if(CWorld::ProcessLineOfSight(TargetCoors, Source, colPoint, entity, true, false, false, true, false, true, true)){
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
Source = colPoint.point;
}
Source.z += 1.0f;
@@ -800,7 +799,7 @@ CCam::ClipIfPedInFrontOfPlayer(void)
if(Abs(DeltaAngle) < HALFPI){
fDist = Sqrt(SQR(vDist.x) + SQR(vDist.y));
if(fDist < 1.25f){
- Near = 0.9f - (1.25f - fDist);
+ Near = DEFAULT_NEAR - (1.25f - fDist);
if(Near < 0.05f)
Near = 0.05f;
RwCameraSetNearClipPlane(Scene.camera, Near);
@@ -1044,7 +1043,7 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
}else{
LateralDist = 0.8f;
CenterDist = 1.35f;
- if(TheCamera.PedZoomIndicator == 1.0f || TheCamera.PedZoomIndicator == 4.0f){
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_1 || TheCamera.PedZoomIndicator == CAM_ZOOM_TOPDOWN){
LateralDist = 1.25f;
CenterDist = 1.6f;
}
@@ -1082,7 +1081,6 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
else
IdealSource = TargetCoors + CVector(1.0f, 1.0f, 0.0f);
- // TODO: what's transition beta?
if(TheCamera.m_bUseTransitionBeta && ResetStatics){
CVector VecDistance;
IdealSource.x = TargetCoors.x + GroundDist*Cos(m_fTransitionBeta);
@@ -1111,17 +1109,17 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
// BUG? is this ever used?
// The values seem to be roughly m_fPedZoomValueSmooth + 1.85
if(ResetStatics){
- if(TheCamera.PedZoomIndicator == 1.0) m_fRealGroundDist = 2.090556f;
- if(TheCamera.PedZoomIndicator == 2.0) m_fRealGroundDist = 3.34973f;
- if(TheCamera.PedZoomIndicator == 3.0) m_fRealGroundDist = 4.704914f;
- if(TheCamera.PedZoomIndicator == 4.0) m_fRealGroundDist = 2.090556f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_1) m_fRealGroundDist = 2.090556f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_2) m_fRealGroundDist = 3.34973f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_3) m_fRealGroundDist = 4.704914f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_TOPDOWN) m_fRealGroundDist = 2.090556f;
}
// And what is this? It's only used for collision and rotation it seems
float RealGroundDist;
- if(TheCamera.PedZoomIndicator == 1.0) RealGroundDist = 2.090556f;
- if(TheCamera.PedZoomIndicator == 2.0) RealGroundDist = 3.34973f;
- if(TheCamera.PedZoomIndicator == 3.0) RealGroundDist = 4.704914f;
- if(TheCamera.PedZoomIndicator == 4.0) RealGroundDist = 2.090556f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_1) RealGroundDist = 2.090556f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_2) RealGroundDist = 3.34973f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_3) RealGroundDist = 4.704914f;
+ if(TheCamera.PedZoomIndicator == CAM_ZOOM_TOPDOWN) RealGroundDist = 2.090556f;
if(m_fCloseInPedHeightOffset > 0.00001f)
RealGroundDist = 1.7016f;
@@ -1292,8 +1290,8 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
// Now do the Beta rotation
- float Distance = (IdealSource - TargetCoors).Magnitude2D();
- m_fDistanceBeforeChanges = Distance;
+ float RotDistance = (IdealSource - TargetCoors).Magnitude2D();
+ m_fDistanceBeforeChanges = RotDistance;
if(Rotating){
m_bFixingBeta = true;
@@ -1334,8 +1332,8 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
BetaSpeed = 0.0f;
}
- Source.x = TargetCoors.x + Distance * Cos(Beta);
- Source.y = TargetCoors.y + Distance * Sin(Beta);
+ Source.x = TargetCoors.x + RotDistance * Cos(Beta);
+ Source.y = TargetCoors.y + RotDistance * Sin(Beta);
// Check if we can stop rotating
DeltaBeta = FixedTargetOrientation - Beta;
@@ -1354,18 +1352,18 @@ CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, fl
HackPlayerOnStoppingTrain || Rotating){
if(TheCamera.m_bCamDirectlyBehind){
Beta = TargetOrientation + PI;
- Source.x = TargetCoors.x + Distance * Cos(Beta);
- Source.y = TargetCoors.y + Distance * Sin(Beta);
+ Source.x = TargetCoors.x + RotDistance * Cos(Beta);
+ Source.y = TargetCoors.y + RotDistance * Sin(Beta);
}
if(TheCamera.m_bCamDirectlyInFront){
Beta = TargetOrientation;
- Source.x = TargetCoors.x + Distance * Cos(Beta);
- Source.y = TargetCoors.y + Distance * Sin(Beta);
+ Source.x = TargetCoors.x + RotDistance * Cos(Beta);
+ Source.y = TargetCoors.y + RotDistance * Sin(Beta);
}
if(HackPlayerOnStoppingTrain){
Beta = TargetOrientation + PI;
- Source.x = TargetCoors.x + Distance * Cos(Beta);
- Source.y = TargetCoors.y + Distance * Sin(Beta);
+ Source.x = TargetCoors.x + RotDistance * Cos(Beta);
+ Source.y = TargetCoors.y + RotDistance * Sin(Beta);
m_fDimensionOfHighestNearCar = 0.0f;
m_fCamBufferedHeight = 0.0f;
m_fCamBufferedHeightSpeed = 0.0f;
@@ -1551,7 +1549,7 @@ CCam::Process_FollowPedWithMouse(const CVector &CameraTarget, float TargetOrient
// SA code
#ifdef FREE_CAM
- if((bFreeMouseCam && Alpha > 0.0f) || (!bFreeMouseCam && Alpha > fBaseDist))
+ if((CCamera::bFreeCam && Alpha > 0.0f) || (!CCamera::bFreeCam && Alpha > fBaseDist))
#else
if(Alpha > fBaseDist) // comparing an angle against a distance?
#endif
@@ -1586,14 +1584,14 @@ CCam::Process_FollowPedWithMouse(const CVector &CameraTarget, float TargetOrient
if(CWorld::ProcessLineOfSight(colPoint.point, Source, colPoint, entity, true, true, true, true, false, false, true)){
PedColDist = (TargetCoors - colPoint.point).Magnitude();
Source = colPoint.point;
- if(PedColDist < 0.9f + 0.3f)
+ if(PedColDist < DEFAULT_NEAR + 0.3f)
RwCameraSetNearClipPlane(Scene.camera, max(PedColDist-0.3f, 0.05f));
}else{
- RwCameraSetNearClipPlane(Scene.camera, min(ColCamDist-0.35f, 0.9f));
+ RwCameraSetNearClipPlane(Scene.camera, min(ColCamDist-0.35f, DEFAULT_NEAR));
}
}else{
Source = colPoint.point;
- if(PedColDist < 0.9f + 0.3f)
+ if(PedColDist < DEFAULT_NEAR + 0.3f)
RwCameraSetNearClipPlane(Scene.camera, max(PedColDist-0.3f, 0.05f));
}
}
@@ -1640,7 +1638,7 @@ CCam::Process_FollowPedWithMouse(const CVector &CameraTarget, float TargetOrient
CPed *player = FindPlayerPed();
float PlayerDist = (Source - player->GetPosition()).Magnitude();
if(PlayerDist < 2.75f)
- Near = PlayerDist/2.75f * 0.9f - 0.3f;
+ Near = PlayerDist/2.75f * DEFAULT_NEAR - 0.3f;
RwCameraSetNearClipPlane(Scene.camera, max(Near, 0.1f));
}
}
@@ -1800,11 +1798,11 @@ CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, floa
float zoomvalue = TheCamera.CarZoomValueSmooth;
if(zoomvalue < 0.1f)
zoomvalue = 0.1f;
- if(TheCamera.CarZoomIndicator == 1.0f)
+ if(TheCamera.CarZoomIndicator == CAM_ZOOM_1)
ModeAlpha = CGeneral::GetATanOfXY(23.0f, zoomvalue); // near
- else if(TheCamera.CarZoomIndicator == 2.0f)
+ else if(TheCamera.CarZoomIndicator == CAM_ZOOM_2)
ModeAlpha = CGeneral::GetATanOfXY(10.8f, zoomvalue); // mid
- else if(TheCamera.CarZoomIndicator == 3.0f)
+ else if(TheCamera.CarZoomIndicator == CAM_ZOOM_3)
ModeAlpha = CGeneral::GetATanOfXY(7.0f, zoomvalue); // far
@@ -1900,7 +1898,7 @@ CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, floa
PreviousNearCheckNearClipSmall = false;
if(!CamClear){
PreviousNearCheckNearClipSmall = true;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
DeltaAlpha = TargetAlpha - (Alpha + ModeAlpha);
while(DeltaAlpha >= PI) DeltaAlpha -= 2*PI;
@@ -1918,7 +1916,7 @@ CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, floa
if(CamClear)
if(CamZ - CamGround2 < 1.5f){
PreviousNearCheckNearClipSmall = true;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
float a;
if(Length == 0.0f || CamGround2 + 1.5f - TargetCoors.z == 0.0f)
@@ -1934,7 +1932,7 @@ CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, floa
float CamRoof2 = CWorld::FindRoofZFor3DCoord(Source.x, Source.y, CamZ, &FoundRoof);
if(FoundRoof && CamZ - CamRoof2 < 1.5f){
PreviousNearCheckNearClipSmall = true;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
if(CamRoof2 > TargetCoors.z + 3.5f)
CamRoof2 = TargetCoors.z + 3.5f;
@@ -1956,7 +1954,7 @@ CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, floa
LastAlphaSpeedStep = AlphaSpeedStep;
}else{
if(PreviousNearCheckNearClipSmall)
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
}
WellBufferMe(LastTargetAlphaWithCollisionOn, &Alpha, &AlphaSpeed, LastTopAlphaSpeed, LastAlphaSpeedStep, true);
@@ -3204,7 +3202,8 @@ CCam::Process_BehindBoat(const CVector &CameraTarget, float TargetOrientation, f
static float WaterZAddition = 2.75f;
float WaterLevel = 0.0f;
float s, c;
- float Beta = CGeneral::GetATanOfXY(TargetCoors.x - Source.x, TargetCoors.y - Source.y);
+
+ Beta = CGeneral::GetATanOfXY(TargetCoors.x - Source.x, TargetCoors.y - Source.y);
FOV = DefaultFOV;
if(ResetStatics){
@@ -3717,7 +3716,7 @@ CCam::Process_Debug(const CVector&, float, float, float)
static float PanSpeedY = 0.0f;
CVector TargetCoors;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
FOV = DefaultFOV;
Alpha += DEGTORAD(CPad::GetPad(1)->GetLeftStickY()) / 50.0f;
Beta += DEGTORAD(CPad::GetPad(1)->GetLeftStickX())*1.5f / 19.0f;
@@ -3814,7 +3813,7 @@ CCam::Process_Debug(const CVector&, float, float, float)
static float Speed = 0.0f;
CVector TargetCoors;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
FOV = DefaultFOV;
Alpha += DEGTORAD(CPad::GetPad(1)->GetLeftStickY()) / 50.0f;
Beta += DEGTORAD(CPad::GetPad(1)->GetLeftStickX())*1.5f / 19.0f;
@@ -3887,7 +3886,7 @@ CCam::Process_Editor(const CVector&, float, float, float)
}
ResetStatics = false;
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
FOV = DefaultFOV;
Alpha += DEGTORAD(CPad::GetPad(1)->GetLeftStickY()) / 50.0f;
Beta += DEGTORAD(CPad::GetPad(1)->GetLeftStickX())*1.5f / 19.0f;
@@ -4465,11 +4464,14 @@ CCam::Process_FollowPed_Rotation(const CVector &CameraTarget, float TargetOrient
float MouseX = CPad::GetPad(0)->GetMouseX();
float MouseY = CPad::GetPad(0)->GetMouseY();
float LookLeftRight, LookUpDown;
- if(bFreeMouseCam && (MouseX != 0.0f || MouseY != 0.0f) && !CPad::GetPad(0)->ArePlayerControlsDisabled()){
+/*
+ if((MouseX != 0.0f || MouseY != 0.0f) && !CPad::GetPad(0)->ArePlayerControlsDisabled()){
UseMouse = true;
LookLeftRight = -2.5f*MouseX;
LookUpDown = 4.0f*MouseY;
- }else{
+ }else
+*/
+ {
LookLeftRight = -CPad::GetPad(0)->LookAroundLeftRight();
LookUpDown = CPad::GetPad(0)->LookAroundUpDown();
}
@@ -4553,14 +4555,14 @@ CCam::Process_FollowPed_Rotation(const CVector &CameraTarget, float TargetOrient
if(CWorld::ProcessLineOfSight(colPoint.point, Source, colPoint, entity, true, true, true, true, false, false, true)){
PedColDist = (TargetCoors - colPoint.point).Magnitude();
Source = colPoint.point;
- if(PedColDist < 0.9f + 0.3f)
+ if(PedColDist < DEFAULT_NEAR + 0.3f)
RwCameraSetNearClipPlane(Scene.camera, max(PedColDist-0.3f, 0.05f));
}else{
- RwCameraSetNearClipPlane(Scene.camera, min(ColCamDist-0.35f, 0.9f));
+ RwCameraSetNearClipPlane(Scene.camera, min(ColCamDist-0.35f, DEFAULT_NEAR));
}
}else{
Source = colPoint.point;
- if(PedColDist < 0.9f + 0.3f)
+ if(PedColDist < DEFAULT_NEAR + 0.3f)
RwCameraSetNearClipPlane(Scene.camera, max(PedColDist-0.3f, 0.05f));
}
}
@@ -4922,7 +4924,7 @@ CCam::Process_FollowCar_SA(const CVector& CameraTarget, float TargetOrientation,
bool mouseChangesBeta = false;
// FIX: Disable mouse movement in drive-by, it's buggy. Original SA bug.
- if (bFreeMouseCam && CCamera::m_bUseMouse3rdPerson && !pad->ArePlayerControlsDisabled() && nextDirectionIsForward) {
+ if (/*bFreeMouseCam &&*/ CCamera::m_bUseMouse3rdPerson && !pad->ArePlayerControlsDisabled() && nextDirectionIsForward) {
float mouseY = pad->GetMouseY() * 2.0f;
float mouseX = pad->GetMouseX() * -2.0f;
@@ -5093,10 +5095,10 @@ CCam::Process_FollowCar_SA(const CVector& CameraTarget, float TargetOrientation,
} else {
if (!CWorld::ProcessLineOfSight(foundCol.point, Source, foundCol, foundEnt, true, dontCollideWithCars < 0.1f, false, true, false, true, false)) {
float lessClip = obstacleCamDist - 0.35f;
- if (lessClip <= 0.9f)
+ if (lessClip <= DEFAULT_NEAR)
RwCameraSetNearClipPlane(Scene.camera, lessClip);
else
- RwCameraSetNearClipPlane(Scene.camera, 0.9f);
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
} else {
obstacleTargetDist = (TargetCoors - foundCol.point).Magnitude();
Source = foundCol.point;
@@ -5238,9 +5240,6 @@ CCam::Process_FollowCar_SA(const CVector& CameraTarget, float TargetOrientation,
#endif
STARTPATCHES
-#ifdef FREE_CAM
- Nop(0x468E7B, 0x468E90-0x468E7B); // disable first person
-#endif
InjectHook(0x456F40, WellBufferMe, PATCH_JUMP);
InjectHook(0x458410, &CCam::Init, PATCH_JUMP);
InjectHook(0x4582F0, &CCam::GetVectorsReadyForRW, PATCH_JUMP);
@@ -5290,6 +5289,4 @@ STARTPATCHES
InjectHook(0x456CE0, &FindSplinePathPositionFloat, PATCH_JUMP);
InjectHook(0x4569A0, &FindSplinePathPositionVector, PATCH_JUMP);
-
- InjectHook(0x473250, &CCamera::dtor, PATCH_JUMP);
ENDPATCHES
diff --git a/src/core/Camera.cpp b/src/core/Camera.cpp
index 3f7ed286..e5bc09c8 100644
--- a/src/core/Camera.cpp
+++ b/src/core/Camera.cpp
@@ -4,277 +4,2903 @@
#include "Draw.h"
#include "World.h"
#include "Vehicle.h"
+#include "Train.h"
+#include "Automobile.h"
#include "Ped.h"
#include "PlayerPed.h"
+#include "Wanted.h"
#include "Pad.h"
+#include "ControllerConfig.h"
#include "General.h"
#include "ZoneCull.h"
#include "SurfaceTable.h"
+#include "WaterLevel.h"
+#include "World.h"
+#include "Garages.h"
+#include "Replay.h"
+#include "CutsceneMgr.h"
+#include "Renderer.h"
#include "MBlur.h"
+#include "Text.h"
+#include "Hud.h"
+#include "DMAudio.h"
+#include "FileMgr.h"
+#include "Frontend.h"
+#include "SceneEdit.h"
+#include "Pools.h"
+#include "Debug.h"
#include "Camera.h"
+enum
+{
+ // car
+ OBBE_WHEEL,
+ OBBE_1,
+ OBBE_2,
+ OBBE_3,
+ OBBE_1STPERSON, // unused
+ OBBE_5,
+ OBBE_ONSTRING,
+ OBBE_COPCAR,
+ OBBE_COPCAR_WHEEL,
+ // ped
+ OBBE_9,
+ OBBE_10,
+ OBBE_11,
+ OBBE_12,
+ OBBE_13,
+
+ OBBE_INVALID
+};
+
+// abbreviate a few things
+#define PLAYER (CWorld::Players[CWorld::PlayerInFocus].m_pPed)
+// NB: removed explicit TheCamera from all functions
+
CCamera &TheCamera = *(CCamera*)0x6FACF8;
bool &CCamera::m_bUseMouse3rdPerson = *(bool *)0x5F03D8;
+bool &bDidWeProcessAnyCinemaCam = *(bool*)0x95CD46;
-WRAPPER void CCamera::CamShake(float strength, float x, float y, float z) { EAXJMP(0x46B200); }
-WRAPPER void CCamera::DrawBordersForWideScreen(void) { EAXJMP(0x46B430); }
-WRAPPER void CCamera::CalculateDerivedValues(void) { EAXJMP(0x46EEA0); }
-WRAPPER void CCamera::Restore(void) { EAXJMP(0x46F990); }
-WRAPPER void CamShakeNoPos(CCamera*, float) { EAXJMP(0x46B100); }
-WRAPPER void CCamera::TakeControl(CEntity*, int16, int16, int32) { EAXJMP(0x471500); }
-WRAPPER void CCamera::TakeControlNoEntity(const CVector&, int16, int32) { EAXJMP(0x4715B0); }
-WRAPPER void CCamera::Init(void) { EAXJMP(0x46BAD0); }
-WRAPPER void CCamera::Process(void) { EAXJMP(0x46D3F0); }
-WRAPPER void CCamera::LoadPathSplines(int file) { EAXJMP(0x46D1D0); }
-WRAPPER void CCamera::RestoreWithJumpCut(void) { EAXJMP(0x46FAE0); };
-WRAPPER void CCamera::SetPercentAlongCutScene(float) { EAXJMP(0x46FE20); };
-WRAPPER void CCamera::SetParametersForScriptInterpolation(float, float, int32) { EAXJMP(0x46FDE0); }
+#ifdef IMPROVED_CAMERA
+#define KEYJUSTDOWN(k) ControlsManager.GetIsKeyboardKeyJustDown((RsKeyCodes)k)
+#define KEYDOWN(k) ControlsManager.GetIsKeyboardKeyDown((RsKeyCodes)k)
+#define CTRLJUSTDOWN(key) \
+ ((KEYDOWN(rsLCTRL) || KEYDOWN(rsRCTRL)) && KEYJUSTDOWN((RsKeyCodes)key) || \
+ (KEYJUSTDOWN(rsLCTRL) || KEYJUSTDOWN(rsRCTRL)) && KEYDOWN((RsKeyCodes)key))
+#define CTRLDOWN(key) ((KEYDOWN(rsLCTRL) || KEYDOWN(rsRCTRL)) && KEYDOWN((RsKeyCodes)key))
+#endif
-bool
-CCamera::GetFading()
+void
+CCamera::Init(void)
{
- return m_bFading;
+ memset(this, 0, sizeof(CCamera)); // getting rid of vtable, eh?
+
+ m_pRwCamera = nil;
+ m_1rstPersonRunCloseToAWall = false;
+ m_fPositionAlongSpline = 0.0f;
+ m_bCameraJustRestored = false;
+ Cams[0].Init();
+ Cams[1].Init();
+ Cams[2].Init();
+ Cams[0].Mode = CCam::MODE_FOLLOWPED;
+ Cams[1].Mode = CCam::MODE_FOLLOWPED;
+ unknown = 0;
+ m_bJustJumpedOutOf1stPersonBecauseOfTarget = 0;
+ ClearPlayerWeaponMode();
+ m_bInATunnelAndABigVehicle = false;
+ m_iModeObbeCamIsInForCar = OBBE_INVALID;
+ Cams[0].CamTargetEntity = nil;
+ Cams[1].CamTargetEntity = nil;
+ Cams[2].CamTargetEntity = nil;
+ Cams[0].m_fCamBufferedHeight = 0.0f;
+ Cams[0].m_fCamBufferedHeightSpeed = 0.0f;
+ Cams[1].m_fCamBufferedHeight = 0.0f;
+ Cams[1].m_fCamBufferedHeightSpeed = 0.0f;
+ Cams[0].m_bCamLookingAtVector = false;
+ Cams[1].m_bCamLookingAtVector = false;
+ Cams[2].m_bCamLookingAtVector = false;
+ Cams[0].m_fPlayerVelocity = 0.0f;
+ Cams[1].m_fPlayerVelocity = 0.0f;
+ Cams[2].m_fPlayerVelocity = 0.0f;
+ m_bHeadBob = false;
+ m_fFractionInterToStopMovingTarget = 0.25f;
+ m_fFractionInterToStopCatchUpTarget = 0.75f;
+ m_fGaitSwayBuffer = 0.85f;
+ m_bScriptParametersSetForInterPol = false;
+ m_uiCamShakeStart = 0;
+ m_fCamShakeForce = 0.0f;
+ m_iModeObbeCamIsInForCar = OBBE_INVALID;
+ m_bIgnoreFadingStuffForMusic = false;
+ m_bWaitForInterpolToFinish = false;
+ pToGarageWeAreIn = nil;
+ pToGarageWeAreInForHackAvoidFirstPerson = nil;
+ m_bPlayerIsInGarage = false;
+ m_bJustCameOutOfGarage = false;
+ m_fNearClipScript = DEFAULT_NEAR;
+ m_bUseNearClipScript = false;
+ m_vecDoingSpecialInterPolation = false;
+ m_bAboveGroundTrainNodesLoaded = false;
+ m_bBelowGroundTrainNodesLoaded = false;
+ m_WideScreenOn = false;
+ m_fFOV_Wide_Screen = 0.0f;
+ m_bRestoreByJumpCut = false;
+ CarZoomIndicator = 2.0f;
+ PedZoomIndicator = 2.0f;
+ CarZoomValueSmooth = 0.0f;
+ m_fPedZoomValueSmooth = 0.0f;
+ pTargetEntity = nil;
+ if(FindPlayerVehicle())
+ pTargetEntity = FindPlayerVehicle();
+ else
+ pTargetEntity = CWorld::Players[CWorld::PlayerInFocus].m_pPed;
+ m_bInitialNodeFound = false;
+ m_ScreenReductionPercentage = 0.0f;
+ m_ScreenReductionSpeed = 0.0f;
+ m_WideScreenOn = false;
+ m_bWantsToSwitchWidescreenOff = false;
+ WorldViewerBeingUsed = false;
+ PlayerExhaustion = 1.0f;
+ DebugCamMode = CCam::MODE_NONE;
+ m_PedOrientForBehindOrInFront = 0.0f;
+ if(!FrontEndMenuManager.m_bStartGameLoading){
+ m_bFading = false;
+ CDraw::FadeValue = 0;
+ m_fFLOATingFade = 0.0f;
+ m_bMusicFading = false;
+ m_fTimeToFadeMusic = 0.0f;
+ m_fFLOATingFadeMusic = 0.0f;
+ }
+ m_bMoveCamToAvoidGeom = false;
+ if(FrontEndMenuManager.m_bStartGameLoading)
+ m_bMoveCamToAvoidGeom = true;
+ m_bStartingSpline = false;
+ m_iTypeOfSwitch = INTERPOLATION;
+ m_bUseScriptZoomValuePed = false;
+ m_bUseScriptZoomValueCar = false;
+ m_fPedZoomValueScript = 0.0f;
+ m_fCarZoomValueScript = 0.0f;
+ m_bUseSpecialFovTrain = false;
+ m_fFovForTrain = 70.0f; // or DefaultFOV from Cam.cpp
+ m_iModeToGoTo = CCam::MODE_FOLLOWPED;
+ m_bJust_Switched = false;
+ m_bUseTransitionBeta = false;
+ m_matrix.SetScale(1.0f);
+ m_bTargetJustBeenOnTrain = false;
+ m_bInitialNoNodeStaticsSet = false;
+ m_uiLongestTimeInMill = 5000;
+ m_uiTimeLastChange = 0;
+ m_uiTimeWeEnteredIdle = 0;
+ m_bIdleOn = false;
+ LODDistMultiplier = 1.0f;
+ m_bCamDirectlyBehind = false;
+ m_bCamDirectlyInFront = false;
+ m_motionBlur = 0;
+ m_bGarageFixedCamPositionSet = false;
+ SetMotionBlur(255, 255, 255, 0, 0);
+ m_bCullZoneChecksOn = false;
+ m_bFailedCullZoneTestPreviously = false;
+ m_iCheckCullZoneThisNumFrames = 6;
+ m_iZoneCullFrameNumWereAt = 0;
+ m_CameraAverageSpeed = 0.0f;
+ m_CameraSpeedSoFar = 0.0f;
+ m_PreviousCameraPosition = CVector(0.0f, 0.0f, 0.0f);
+ m_iWorkOutSpeedThisNumFrames = 4;
+ m_iNumFramesSoFar = 0;
+ m_bJustInitalised = true;
+ m_uiTransitionState = 0;
+ m_uiTimeTransitionStart = 0;
+ m_bLookingAtPlayer = true;
+ m_fMouseAccelHorzntl = 0.0025f;
+ m_fMouseAccelVertical = 0.003f;
+ m_f3rdPersonCHairMultX = 0.53f;
+ m_f3rdPersonCHairMultY = 0.4f;
}
-int
-CCamera::GetFadingDirection()
+void
+CCamera::Process(void)
{
+ // static bool InterpolatorNotInitialised = true; // unused
+ static float PlayerMinDist = 1.6f; // not on PS2
+ static bool WasPreviouslyInterSyhonFollowPed = false; // only written
+ float FOV = 0.0f;
+ float oldBeta, newBeta;
+ float deltaBeta = 0.0f;
+ bool lookLRBVehicle = false;
+ CVector CamFront, CamUp, CamSource, Target;
+
+ m_bJust_Switched = false;
+ m_RealPreviousCameraPosition = GetPosition();
+
+ // Update target entity
+ if(m_bLookingAtPlayer || m_bTargetJustBeenOnTrain || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE)
+ UpdateTargetEntity();
+ if(pTargetEntity == nil)
+ pTargetEntity = FindPlayerPed();
+ if(Cams[ActiveCam].CamTargetEntity == nil)
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ if(Cams[(ActiveCam+1)%2].CamTargetEntity == nil)
+ Cams[(ActiveCam+1)%2].CamTargetEntity = pTargetEntity;
+
+ CamControl();
if(m_bFading)
- return m_iFadingDirection == FADE_IN ? FADE_IN : FADE_OUT;
+ ProcessFade();
+ if(m_bMusicFading)
+ ProcessMusicFade();
+ if(m_WideScreenOn)
+ ProcessWideScreenOn();
+
+#ifdef IMPROVED_CAMERA
+ if(CPad::GetPad(1)->GetCircleJustDown() || CTRLJUSTDOWN('B')){
+#else
+ if(CPad::GetPad(1)->GetCircleJustDown()){
+#endif
+ WorldViewerBeingUsed = !WorldViewerBeingUsed;
+ if(WorldViewerBeingUsed)
+ InitialiseCameraForDebugMode();
+ else
+ CPad::m_bMapPadOneToPadTwo = false;
+ }
+
+ RwCameraSetNearClipPlane(Scene.camera, DEFAULT_NEAR);
+
+ if(Cams[ActiveCam].Front.x == 0.0f && Cams[ActiveCam].Front.y == 0.0f)
+ oldBeta = 0.0f;
else
- return FADE_NONE;
-}
+ oldBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
-bool
-CCamera::IsSphereVisible(const CVector &center, float radius, const CMatrix *mat)
-{
- RwV3d c;
- c = *(RwV3d*)&center;
- RwV3dTransformPoints(&c, &c, 1, &mat->m_matrix);
- if(c.y + radius < CDraw::GetNearClipZ()) return false;
- if(c.y - radius > CDraw::GetFarClipZ()) return false;
- if(c.x*m_vecFrustumNormals[0].x + c.y*m_vecFrustumNormals[0].y > radius) return false;
- if(c.x*m_vecFrustumNormals[1].x + c.y*m_vecFrustumNormals[1].y > radius) return false;
- if(c.y*m_vecFrustumNormals[2].y + c.z*m_vecFrustumNormals[2].z > radius) return false;
- if(c.y*m_vecFrustumNormals[3].y + c.z*m_vecFrustumNormals[3].z > radius) return false;
- return true;
+ Cams[ActiveCam].Process();
+ Cams[ActiveCam].ProcessSpecialHeightRoutines();
+
+ if(Cams[ActiveCam].Front.x == 0.0f && Cams[ActiveCam].Front.y == 0.0f)
+ newBeta = 0.0f;
+ else
+ newBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+
+
+ // Stop transition when it's done
+ if(m_uiTransitionState != 0){
+/*
+ // PS2:
+ if(!m_bWaitForInterpolToFinish){
+ Cams[(ActiveCam+1)%2].Process();
+ Cams[(ActiveCam+1)%2].ProcessSpecialHeightRoutines();
+ }
+*/
+ // not PS2 (done in CamControl there it seems)
+ if(CTimer::GetTimeInMilliseconds() > m_uiTransitionDuration+m_uiTimeTransitionStart){
+ m_uiTransitionState = 0;
+ m_vecDoingSpecialInterPolation = false;
+ m_bWaitForInterpolToFinish = false;
+ }
+ }
+
+ if(m_bUseNearClipScript)
+ RwCameraSetNearClipPlane(Scene.camera, m_fNearClipScript);
+
+ deltaBeta = newBeta - oldBeta;
+ while(deltaBeta >= PI) deltaBeta -= 2*PI;
+ while(deltaBeta < -PI) deltaBeta += 2*PI;
+ if(Abs(deltaBeta) > 0.3f)
+ m_bJust_Switched = true;
+
+ // Debug stuff
+ if(!gbModelViewer)
+ Cams[ActiveCam].PrintMode();
+ if(WorldViewerBeingUsed)
+ Cams[2].Process();
+
+ if(Cams[ActiveCam].DirectionWasLooking != LOOKING_FORWARD && pTargetEntity->IsVehicle())
+ lookLRBVehicle = true;
+
+ if(m_uiTransitionState != 0 && !lookLRBVehicle){
+ // Process transition
+ // different on PS2
+
+ uint32 currentTime = CTimer::GetTimeInMilliseconds() - m_uiTimeTransitionStart;
+ if(currentTime >= m_uiTransitionDuration)
+ currentTime = m_uiTransitionDuration;
+ float fractionInter = (float) currentTime / m_uiTransitionDuration;
+
+ if(fractionInter <= m_fFractionInterToStopMovingTarget){
+ float inter;
+ if(m_fFractionInterToStopMovingTarget == 0.0f)
+ inter = 0.0f;
+ else
+ inter = (m_fFractionInterToStopMovingTarget - fractionInter)/m_fFractionInterToStopMovingTarget;
+ inter = 0.5f - 0.5*Cos(inter*PI); // smooth it
+
+ m_vecSourceWhenInterPol = m_cvecStartingSourceForInterPol + inter*m_cvecSourceSpeedAtStartInter;
+ m_vecTargetWhenInterPol = m_cvecStartingTargetForInterPol + inter*m_cvecTargetSpeedAtStartInter;
+ m_vecUpWhenInterPol = m_cvecStartingUpForInterPol + inter*m_cvecUpSpeedAtStartInter;
+ m_fFOVWhenInterPol = m_fStartingFOVForInterPol + inter*m_fFOVSpeedAtStartInter;
+
+ CamSource = m_vecSourceWhenInterPol;
+
+ if(m_bItsOkToLookJustAtThePlayer){
+ m_vecTargetWhenInterPol.x = FindPlayerPed()->GetPosition().x;
+ m_vecTargetWhenInterPol.y = FindPlayerPed()->GetPosition().y;
+ m_fBetaWhenInterPol = m_fStartingBetaForInterPol + inter*m_fBetaSpeedAtStartInter;
+
+ float dist = (CamSource - m_vecTargetWhenInterPol).Magnitude2D();
+ if(dist < PlayerMinDist){
+ if(dist > 0.0f){
+ CamSource.x = m_vecTargetWhenInterPol.x + PlayerMinDist*Cos(m_fBetaWhenInterPol);
+ CamSource.y = m_vecTargetWhenInterPol.y + PlayerMinDist*Sin(m_fBetaWhenInterPol);
+ }else{
+ // can only be 0.0 now...
+ float beta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+ CamSource.x = m_vecTargetWhenInterPol.x + PlayerMinDist*Cos(beta);
+ CamSource.y = m_vecTargetWhenInterPol.y + PlayerMinDist*Sin(beta);
+ }
+ }else{
+ CamSource.x = m_vecTargetWhenInterPol.x + dist*Cos(m_fBetaWhenInterPol);
+ CamSource.y = m_vecTargetWhenInterPol.y + dist*Sin(m_fBetaWhenInterPol);
+ }
+ }
+
+ CamFront = m_vecTargetWhenInterPol - CamSource;
+ StoreValuesDuringInterPol(CamSource, m_vecTargetWhenInterPol, m_vecUpWhenInterPol, m_fFOVWhenInterPol);
+ Target = m_vecTargetWhenInterPol;
+ CamFront.Normalise();
+ if(m_bLookingAtPlayer)
+ CamUp = CVector(0.0f, 0.0f, 1.0f);
+ else
+ CamUp = m_vecUpWhenInterPol;
+ CamUp.Normalise();
+
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN || Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+ CamFront.Normalise();
+ CamUp = CrossProduct(CamFront, CVector(-1.0f, 0.0f, 0.0f));
+ }else{
+ CamFront.Normalise();
+ CamUp.Normalise();
+ CVector right = CrossProduct(CamFront, CamUp);
+ right.Normalise();
+ CamUp = CrossProduct(right, CamFront);
+ }
+ CamUp.Normalise();
+ FOV = m_fFOVWhenInterPol;
+ }else if(fractionInter > m_fFractionInterToStopMovingTarget && fractionInter <= 1.0f){
+ float inter;
+ if(m_fFractionInterToStopCatchUpTarget == 0.0f)
+ inter = 0.0f;
+ else
+ inter = (fractionInter - m_fFractionInterToStopMovingTarget)/m_fFractionInterToStopCatchUpTarget;
+ inter = 0.5f - 0.5*Cos(inter*PI); // smooth it
+
+ CamSource = m_vecSourceWhenInterPol + inter*(Cams[ActiveCam].Source - m_vecSourceWhenInterPol);
+ FOV = m_fFOVWhenInterPol + inter*(Cams[ActiveCam].FOV - m_fFOVWhenInterPol);
+ Target = m_vecTargetWhenInterPol + inter*(Cams[ActiveCam].m_cvecTargetCoorsForFudgeInter - m_vecTargetWhenInterPol);
+ CamUp = m_vecUpWhenInterPol + inter*(Cams[ActiveCam].Up - m_vecUpWhenInterPol);
+ deltaBeta = Cams[ActiveCam].m_fTrueBeta - m_fBetaWhenInterPol;
+ MakeAngleLessThan180(deltaBeta);
+ float interpBeta = m_fBetaWhenInterPol + inter*deltaBeta;
+
+ if(m_bItsOkToLookJustAtThePlayer){
+ Target.x = FindPlayerPed()->GetPosition().x;
+ Target.y = FindPlayerPed()->GetPosition().y;
+
+ float dist = (CamSource - Target).Magnitude2D();
+ if(dist < PlayerMinDist){
+ if(dist > 0.0f){
+ CamSource.x = Target.x + PlayerMinDist*Cos(interpBeta);
+ CamSource.y = Target.y + PlayerMinDist*Sin(interpBeta);
+ }else{
+ // can only be 0.0 now...
+ float beta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+ CamSource.x = Target.x + PlayerMinDist*Cos(beta);
+ CamSource.y = Target.y + PlayerMinDist*Sin(beta);
+ }
+ }else{
+ CamSource.x = Target.x + dist*Cos(interpBeta);
+ CamSource.y = Target.y + dist*Sin(interpBeta);
+ }
+ }
+
+ CamFront = Target - CamSource;
+ StoreValuesDuringInterPol(CamSource, Target, CamUp, FOV);
+ CamFront.Normalise();
+ if(m_bLookingAtPlayer)
+ CamUp = CVector(0.0f, 0.0f, 1.0f);
+
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN || Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+ CamFront.Normalise();
+ CamUp = CrossProduct(CamFront, CVector(-1.0f, 0.0f, 0.0f));
+ }else{
+ CamFront.Normalise();
+ CamUp.Normalise();
+ CVector right = CrossProduct(CamFront, CamUp);
+ right.Normalise();
+ CamUp = CrossProduct(right, CamFront);
+ }
+ CamUp.Normalise();
+#ifndef FIX_BUGS
+ // BUG: FOV was already interpolated but m_fFOVWhenInterPol was not
+ FOV = m_fFOVWhenInterPol;
+#endif
+ }
+
+ CVector Dist = CamSource - Target;
+ float DistOnGround = Dist.Magnitude2D();
+ float Alpha = CGeneral::GetATanOfXY(DistOnGround, Dist.z);
+ float Beta = CGeneral::GetATanOfXY(Dist.x, Dist.y);
+ Cams[ActiveCam].KeepTrackOfTheSpeed(CamSource, Target, CamUp, Alpha, Beta, FOV);
+ }else{
+ // No transition, take Cam values directly
+ if(WorldViewerBeingUsed){
+ CamSource = Cams[2].Source;
+ CamFront = Cams[2].Front;
+ CamUp = Cams[2].Up;
+ FOV = Cams[2].FOV;
+ }else{
+ CamSource = Cams[ActiveCam].Source;
+ CamFront = Cams[ActiveCam].Front;
+ CamUp = Cams[ActiveCam].Up;
+ FOV = Cams[ActiveCam].FOV;
+ }
+ WasPreviouslyInterSyhonFollowPed = false; // unused
+ }
+
+ if(m_uiTransitionState != 0)
+ if(!m_bLookingAtVector && m_bLookingAtPlayer && !CCullZones::CamStairsForPlayer() && !m_bPlayerIsInGarage){
+ CEntity *entity = nil;
+ CColPoint colPoint;
+ if(CWorld::ProcessLineOfSight(pTargetEntity->GetPosition(), CamSource, colPoint, entity, true, false, false, true, false, true, true)){
+ CamSource = colPoint.point;
+ RwCameraSetNearClipPlane(Scene.camera, 0.05f);
+ }
+ }
+
+ GetRight() = CrossProduct(CamUp, CamFront); // actually Left
+ GetForward() = CamFront;
+ GetUp() = CamUp;
+ GetPosition() = CamSource;
+
+ // Process Shake
+ float shakeStrength = m_fCamShakeForce - 0.28f*(CTimer::GetTimeInMilliseconds()-m_uiCamShakeStart)/1000.0f;
+ shakeStrength = clamp(shakeStrength, 0.0f, 2.0f);
+ int shakeRand = CGeneral::GetRandomNumber();
+ float shakeOffset = shakeStrength*0.1f;
+ GetPosition().x += shakeOffset*((shakeRand&0xF)-7);
+ GetPosition().y += shakeOffset*(((shakeRand&0xF0)>>4)-7);
+ GetPosition().z += shakeOffset*(((shakeRand&0xF00)>>8)-7);
+
+ if(shakeOffset > 0.0f && m_BlurType != MBLUR_SNIPER)
+ SetMotionBlurAlpha(min((int)(shakeStrength*255.0f) + 25, 150));
+ if(Cams[ActiveCam].Mode == CCam::MODE_1STPERSON && FindPlayerVehicle() && FindPlayerVehicle()->GetUp().z < 0.2f)
+ SetMotionBlur(230, 230, 230, 215, MBLUR_NORMAL);
+
+ CalculateDerivedValues();
+ CDraw::SetFOV(FOV);
+
+ // Set RW camera
+ if(WorldViewerBeingUsed){
+ RwFrame *frame = RwCameraGetFrame(m_pRwCamera);
+ CVector Source = Cams[2].Source;
+ CVector Front = Cams[2].Front;
+ CVector Up = Cams[2].Up;
+
+ GetRight() = CrossProduct(Up, Front);
+ GetForward() = Front;
+ GetUp() = Up;
+ GetPosition() = Source;
+
+ CDraw::SetFOV(Cams[2].FOV);
+ m_vecGameCamPos = Cams[ActiveCam].Source;
+
+ *RwMatrixGetPos(RwFrameGetMatrix(frame)) = (RwV3d)GetPosition();
+ *RwMatrixGetAt(RwFrameGetMatrix(frame)) = (RwV3d)GetForward();
+ *RwMatrixGetUp(RwFrameGetMatrix(frame)) = (RwV3d)GetUp();
+ *RwMatrixGetRight(RwFrameGetMatrix(frame)) = (RwV3d)GetRight();
+ RwMatrixUpdate(RwFrameGetMatrix(frame));
+ RwFrameUpdateObjects(frame);
+ }else{
+ RwFrame *frame = RwCameraGetFrame(m_pRwCamera);
+ m_vecGameCamPos = GetPosition();
+ *RwMatrixGetPos(RwFrameGetMatrix(frame)) = (RwV3d)GetPosition();
+ *RwMatrixGetAt(RwFrameGetMatrix(frame)) = (RwV3d)GetForward();
+ *RwMatrixGetUp(RwFrameGetMatrix(frame)) = (RwV3d)GetUp();
+ *RwMatrixGetRight(RwFrameGetMatrix(frame)) = (RwV3d)GetRight();
+ RwMatrixUpdate(RwFrameGetMatrix(frame));
+ RwFrameUpdateObjects(frame);
+ }
+
+ CDraw::SetNearClipZ(RwCameraGetNearClipPlane(m_pRwCamera));
+ CDraw::SetFarClipZ(RwCameraGetFarClipPlane(m_pRwCamera));
+
+ UpdateSoundDistances();
+
+ if((CTimer::GetFrameCounter()&0xF) == 3)
+ DistanceToWater = CWaterLevel::CalcDistanceToWater(GetPosition().x, GetPosition().y);
+
+ // LOD dist
+ if(!CCutsceneMgr::IsRunning() || CCutsceneMgr::UseLodMultiplier())
+ LODDistMultiplier = 70.0f/CDraw::GetFOV() * CDraw::GetAspectRatio()/(4.0f/3.0f);
+ else
+ LODDistMultiplier = 1.0f;
+ GenerationDistMultiplier = LODDistMultiplier;
+ LODDistMultiplier *= CRenderer::ms_lodDistScale;
+
+ // Keep track of speed
+ if(m_bJustInitalised || m_bJust_Switched){
+ m_PreviousCameraPosition = GetPosition();
+ m_bJustInitalised = false;
+ }
+ m_CameraSpeedSoFar += (GetPosition() - m_PreviousCameraPosition).Magnitude();
+ m_iNumFramesSoFar++;
+ if(m_iNumFramesSoFar == m_iWorkOutSpeedThisNumFrames){
+ m_CameraAverageSpeed = m_CameraSpeedSoFar / m_iWorkOutSpeedThisNumFrames;
+ m_CameraSpeedSoFar = 0.0f;
+ m_iNumFramesSoFar = 0;
+ }
+ m_PreviousCameraPosition = GetPosition();
+
+ // PS2: something doing on with forward vector here
+
+ if(Cams[ActiveCam].DirectionWasLooking != LOOKING_FORWARD && Cams[ActiveCam].Mode != CCam::MODE_TOP_DOWN_PED){
+ Cams[ActiveCam].Source = Cams[ActiveCam].SourceBeforeLookBehind;
+ Orientation += PI;
+ }
+
+ if(m_uiTransitionState != 0){
+ int OtherCam = (ActiveCam+1)%2;
+ if(Cams[OtherCam].CamTargetEntity &&
+ pTargetEntity && pTargetEntity->IsPed() &&
+ !Cams[OtherCam].CamTargetEntity->IsVehicle() &&
+ Cams[ActiveCam].Mode != CCam::MODE_TOP_DOWN_PED && Cams[ActiveCam].DirectionWasLooking != LOOKING_FORWARD){
+ Cams[OtherCam].Source = Cams[ActiveCam%2].SourceBeforeLookBehind;
+ Orientation += PI;
+ }
+ }
+
+ m_bCameraJustRestored = false;
}
-bool
-CCamera::IsSphereVisible(const CVector &center, float radius)
+void
+CCamera::CamControl(void)
{
- CMatrix mat = m_cameraMatrix;
- return IsSphereVisible(center, radius, &mat);
+ static bool PlaceForFixedWhenSniperFound = false;
+ static int16 ReqMode;
+ bool disableGarageCam = false;
+ bool switchByJumpCut = false;
+ bool stairs = false;
+ bool boatTarget = false;
+ CVector targetPos;
+ CVector garageCenter, garageDoorPos1, garageDoorPos2;
+ CVector garageCenterToDoor, garageCamPos;
+ int whichDoor;
+
+ m_bObbeCinematicPedCamOn = false;
+ m_bObbeCinematicCarCamOn = false;
+ m_bUseTransitionBeta = false;
+ m_bUseSpecialFovTrain = false;
+ m_bJustCameOutOfGarage = false;
+ m_bTargetJustCameOffTrain = false;
+ m_bInATunnelAndABigVehicle = false;
+
+ if(Cams[ActiveCam].CamTargetEntity == nil && pTargetEntity == nil)
+ pTargetEntity = PLAYER;
+
+ m_iZoneCullFrameNumWereAt++;
+ if(m_iZoneCullFrameNumWereAt > m_iCheckCullZoneThisNumFrames)
+ m_iZoneCullFrameNumWereAt = 1;
+ m_bCullZoneChecksOn = m_iZoneCullFrameNumWereAt == m_iCheckCullZoneThisNumFrames;
+ if(m_bCullZoneChecksOn)
+ m_bFailedCullZoneTestPreviously = CCullZones::CamCloseInForPlayer();
+
+ if(m_bLookingAtPlayer){
+ CPad::GetPad(0)->DisablePlayerControls &= ~PLAYERCONTROL_DISABLED_1;
+ FindPlayerPed()->bIsVisible = true;
+ }
+
+ if(!CTimer::GetIsPaused()){
+ float CloseInCarHeightTarget = 0.0f;
+ float CloseInPedHeightTarget = 0.0f;
+
+ if(m_bTargetJustBeenOnTrain){
+ // Getting off train
+ if(!pTargetEntity->IsVehicle() || !((CVehicle*)pTargetEntity)->IsTrain()){
+ Restore();
+ m_bTargetJustCameOffTrain = true;
+ m_bTargetJustBeenOnTrain = false;
+ SetWideScreenOff();
+ }
+ }
+
+ // Vehicle target
+ if(pTargetEntity->IsVehicle()){
+ if(((CVehicle*)pTargetEntity)->IsTrain()){
+ if(!m_bTargetJustBeenOnTrain){
+ m_bInitialNodeFound = false;
+ m_bInitialNoNodeStaticsSet = false;
+ }
+ Process_Train_Camera_Control();
+ }else{
+ if(((CVehicle*)pTargetEntity)->IsBoat())
+ boatTarget = true;
+
+ // Change user selected mode
+ if(CPad::GetPad(0)->CycleCameraModeUpJustDown() && !CReplay::IsPlayingBack() &&
+ (m_bLookingAtPlayer || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE) &&
+ !m_WideScreenOn)
+ CarZoomIndicator -= 1.0f;
+ if(CPad::GetPad(0)->CycleCameraModeDownJustDown() && !CReplay::IsPlayingBack() &&
+ (m_bLookingAtPlayer || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE) &&
+ !m_WideScreenOn)
+ CarZoomIndicator += 1.0f;
+ if(!m_bFailedCullZoneTestPreviously){
+ if(CarZoomIndicator < CAM_ZOOM_1STPRS) CarZoomIndicator = CAM_ZOOM_CINEMATIC;
+ else if(CarZoomIndicator > CAM_ZOOM_CINEMATIC) CarZoomIndicator = CAM_ZOOM_1STPRS;
+ }
+
+ if(m_bFailedCullZoneTestPreviously)
+ if(CarZoomIndicator != CAM_ZOOM_1STPRS && CarZoomIndicator != CAM_ZOOM_TOPDOWN)
+ ReqMode = CCam::MODE_CAM_ON_A_STRING;
+
+ switch(((CVehicle*)pTargetEntity)->m_vehType){
+ case VEHICLE_TYPE_CAR:
+ case VEHICLE_TYPE_BIKE:
+ if(CGarages::IsPointInAGarageCameraZone(pTargetEntity->GetPosition())){
+ if(!m_bGarageFixedCamPositionSet && m_bLookingAtPlayer ||
+ WhoIsInControlOfTheCamera == CAMCONTROL_OBBE){
+ if(pToGarageWeAreIn){
+ float ground;
+ bool foundGround;
+
+ // This is all very strange....
+ // targetPos = pTargetEntity->GetPosition(); // unused
+ if(pToGarageWeAreIn->m_pDoor1){
+ whichDoor = 1;
+ garageDoorPos1.x = pToGarageWeAreIn->m_fDoor1X;
+ garageDoorPos1.y = pToGarageWeAreIn->m_fDoor1Y;
+ garageDoorPos1.z = 0.0f;
+ // targetPos.z = 0.0f; // unused
+ // (targetPos - doorPos1).Magnitude(); // unused
+ }else if(pToGarageWeAreIn->m_pDoor2){
+ whichDoor = 2;
+#ifdef FIX_BUGS
+ garageDoorPos2.x = pToGarageWeAreIn->m_fDoor2X;
+ garageDoorPos2.y = pToGarageWeAreIn->m_fDoor2Y;
+ garageDoorPos2.z = 0.0f;
+#endif
+ }else{
+ whichDoor = 1;
+ garageDoorPos1.x = pTargetEntity->GetPosition().x;
+ garageDoorPos1.y = pTargetEntity->GetPosition().y;
+#ifdef FIX_BUGS
+ garageDoorPos1.z = 0.0f;
+#else
+ garageDoorPos2.z = 0.0f;
+#endif
+ }
+ garageCenter.x = (pToGarageWeAreIn->m_fX1 + pToGarageWeAreIn->m_fX2)/2.0f;
+ garageCenter.y = (pToGarageWeAreIn->m_fY1 + pToGarageWeAreIn->m_fY2)/2.0f;
+ garageCenter.z = 0.0f;
+ if(whichDoor == 1)
+ garageCenterToDoor = garageDoorPos1 - garageCenter;
+ else
+ garageCenterToDoor = garageDoorPos2 - garageCenter;
+ targetPos = pTargetEntity->GetPosition();
+ ground = CWorld::FindGroundZFor3DCoord(targetPos.x, targetPos.y, targetPos.z, &foundGround);
+ if(!foundGround)
+ ground = targetPos.z - 0.2f;
+ garageCenterToDoor.z = 0.0f;
+ garageCenterToDoor.Normalise();
+ if(whichDoor == 1)
+ garageCamPos = garageDoorPos1 + 13.0f*garageCenterToDoor;
+ else
+ garageCamPos = garageDoorPos2 + 13.0f*garageCenterToDoor;
+ garageCamPos.z = ground + 3.1f;
+ SetCamPositionForFixedMode(garageCamPos, CVector(0.0f, 0.0f, 0.0f));
+ m_bGarageFixedCamPositionSet = true;
+ }
+ }
+
+ if(CGarages::CameraShouldBeOutside() && m_bGarageFixedCamPositionSet &&
+ (m_bLookingAtPlayer || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE)){
+ if(pToGarageWeAreIn){
+ ReqMode = CCam::MODE_FIXED;
+ m_bPlayerIsInGarage = true;
+ }
+ }else{
+ if(m_bPlayerIsInGarage){
+ m_bJustCameOutOfGarage = true;
+ m_bPlayerIsInGarage = false;
+ }
+ ReqMode = CCam::MODE_CAM_ON_A_STRING;
+ }
+ }else{
+ if(m_bPlayerIsInGarage){
+ m_bJustCameOutOfGarage = true;
+ m_bPlayerIsInGarage = false;
+ }
+ m_bGarageFixedCamPositionSet = false;
+ ReqMode = CCam::MODE_CAM_ON_A_STRING;
+ }
+ break;
+ case VEHICLE_TYPE_BOAT:
+ ReqMode = CCam::MODE_BEHINDBOAT;
+ break;
+ }
+
+ // Car zoom value
+ if(CarZoomIndicator == CAM_ZOOM_1STPRS && !m_bPlayerIsInGarage){
+ CarZoomValue = 0.0f;
+ ReqMode = CCam::MODE_1STPERSON;
+ }else if(CarZoomIndicator == CAM_ZOOM_1)
+ CarZoomValue = 0.05f;
+ else if(CarZoomIndicator == CAM_ZOOM_2)
+ CarZoomValue = 1.9f;
+ else if(CarZoomIndicator == CAM_ZOOM_3)
+ CarZoomValue = 3.9f;
+ if(CarZoomIndicator == CAM_ZOOM_TOPDOWN && !m_bPlayerIsInGarage){
+ CarZoomValue = 1.0f;
+ ReqMode = CCam::MODE_TOPDOWN;
+ }
+
+ // Check if we have to go into first person
+ if(((CVehicle*)pTargetEntity)->IsCar() && !m_bPlayerIsInGarage){
+ if(CCullZones::Cam1stPersonForPlayer() &&
+ pTargetEntity->GetColModel()->boundingBox.GetSize().z >= 3.026f &&
+ pToGarageWeAreInForHackAvoidFirstPerson == nil){
+ ReqMode = CCam::MODE_1STPERSON;
+ m_bInATunnelAndABigVehicle = true;
+ }
+ }
+ if(ReqMode == CCam::MODE_TOPDOWN &&
+ (CCullZones::Cam1stPersonForPlayer() || CCullZones::CamNoRain() || CCullZones::PlayerNoRain()))
+ ReqMode = CCam::MODE_1STPERSON;
+
+ // Smooth zoom value - ugly code
+ if(m_bUseScriptZoomValueCar){
+ if(CarZoomValueSmooth < m_fCarZoomValueScript){
+ CarZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = min(CarZoomValueSmooth, m_fCarZoomValueScript);
+ }else{
+ CarZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = max(CarZoomValueSmooth, m_fCarZoomValueScript);
+ }
+ }else if(m_bFailedCullZoneTestPreviously){
+ CloseInCarHeightTarget = 0.65f;
+ if(CarZoomValueSmooth < -0.65f){
+ CarZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = min(CarZoomValueSmooth, -0.65f);
+ }else{
+ CarZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = max(CarZoomValueSmooth, -0.65f);
+ }
+ }else{
+ if(CarZoomValueSmooth < CarZoomValue){
+ CarZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = min(CarZoomValueSmooth, CarZoomValue);
+ }else{
+ CarZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ CarZoomValueSmooth = max(CarZoomValueSmooth, CarZoomValue);
+ }
+ }
+
+ WellBufferMe(CloseInCarHeightTarget, &Cams[ActiveCam].m_fCloseInCarHeightOffset, &Cams[ActiveCam].m_fCloseInCarHeightOffsetSpeed, 0.1f, 0.25f, false);
+
+ // Fallen into water
+ if(Cams[ActiveCam].IsTargetInWater(Cams[ActiveCam].Source) && !boatTarget &&
+ !Cams[ActiveCam].CamTargetEntity->IsPed())
+ ReqMode = CCam::MODE_PLAYER_FALLEN_WATER;
+ }
+ }
+
+ // Ped target
+ else if(pTargetEntity->IsPed()){
+ // Change user selected mode
+ if(CPad::GetPad(0)->CycleCameraModeUpJustDown() && !CReplay::IsPlayingBack() &&
+ (m_bLookingAtPlayer || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE) &&
+ !m_WideScreenOn && !m_bFailedCullZoneTestPreviously){
+ if(FrontEndMenuManager.m_ControlMethod == CONTROL_STANDARD){
+ if(PedZoomIndicator == CAM_ZOOM_TOPDOWN)
+ PedZoomIndicator = CAM_ZOOM_1;
+ else
+ PedZoomIndicator = CAM_ZOOM_TOPDOWN;
+ }else
+ PedZoomIndicator -= 1.0f;
+ }
+ if(CPad::GetPad(0)->CycleCameraModeDownJustDown() && !CReplay::IsPlayingBack() &&
+ (m_bLookingAtPlayer || WhoIsInControlOfTheCamera == CAMCONTROL_OBBE) &&
+ !m_WideScreenOn && !m_bFailedCullZoneTestPreviously){
+ if(FrontEndMenuManager.m_ControlMethod == CONTROL_STANDARD){
+ if(PedZoomIndicator == CAM_ZOOM_TOPDOWN)
+ PedZoomIndicator = CAM_ZOOM_1;
+ else
+ PedZoomIndicator = CAM_ZOOM_TOPDOWN;
+ }else
+ PedZoomIndicator += 1.0f;
+ }
+ // disabled obbe's cam here
+ if(PedZoomIndicator < CAM_ZOOM_1) PedZoomIndicator = CAM_ZOOM_TOPDOWN;
+ else if(PedZoomIndicator > CAM_ZOOM_TOPDOWN) PedZoomIndicator = CAM_ZOOM_1;
+
+ ReqMode = CCam::MODE_FOLLOWPED;
+
+ // Check 1st person mode
+ if(m_bLookingAtPlayer && pTargetEntity->IsPed() && !m_WideScreenOn && !Cams[0].Using3rdPersonMouseCam()
+#ifdef FREE_CAM
+ && !CCamera::bFreeCam
+#endif
+ ){
+ // See if we want to enter first person mode
+ if(CPad::GetPad(0)->LookAroundLeftRight() || CPad::GetPad(0)->LookAroundUpDown()){
+ m_uiFirstPersonCamLastInputTime = CTimer::GetTimeInMilliseconds();
+ m_bFirstPersonBeingUsed = true;
+ }else if(m_bFirstPersonBeingUsed){
+ // Or if we want to go back to 3rd person
+ if(CPad::GetPad(0)->GetPedWalkLeftRight() || CPad::GetPad(0)->GetPedWalkUpDown() ||
+ CPad::GetPad(0)->GetSquare() || CPad::GetPad(0)->GetTriangle() ||
+ CPad::GetPad(0)->GetCross() || CPad::GetPad(0)->GetCircle() ||
+ CTimer::GetTimeInMilliseconds() - m_uiFirstPersonCamLastInputTime > 2850.0f)
+ m_bFirstPersonBeingUsed = false;
+ }
+ }else
+ m_bFirstPersonBeingUsed = false;
+
+ if(!FindPlayerPed()->IsPedInControl() || FindPlayerPed()->m_fMoveSpeed > 0.0f)
+ m_bFirstPersonBeingUsed = false;
+ if(m_bFirstPersonBeingUsed){
+ ReqMode = CCam::MODE_1STPERSON;
+ CPad::GetPad(0)->DisablePlayerControls |= PLAYERCONTROL_DISABLED_1;
+ }
+
+ // Zoom value
+ if(PedZoomIndicator == CAM_ZOOM_1)
+ m_fPedZoomValue = 0.25f;
+ else if(PedZoomIndicator == CAM_ZOOM_2)
+ m_fPedZoomValue = 1.5f;
+ else if(PedZoomIndicator == CAM_ZOOM_3)
+ m_fPedZoomValue = 2.9f;
+
+ // Smooth zoom value - ugly code
+ if(m_bUseScriptZoomValuePed){
+ if(m_fPedZoomValueSmooth < m_fPedZoomValueScript){
+ m_fPedZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = min(m_fPedZoomValueSmooth, m_fPedZoomValueScript);
+ }else{
+ m_fPedZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = max(m_fPedZoomValueSmooth, m_fPedZoomValueScript);
+ }
+ }else if(m_bFailedCullZoneTestPreviously){
+ static float PedZoomedInVal = 0.5f;
+ CloseInPedHeightTarget = 0.7f;
+ if(m_fPedZoomValueSmooth < PedZoomedInVal){
+ m_fPedZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = min(m_fPedZoomValueSmooth, PedZoomedInVal);
+ }else{
+ m_fPedZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = max(m_fPedZoomValueSmooth, PedZoomedInVal);
+ }
+ }else{
+ if(m_fPedZoomValueSmooth < m_fPedZoomValue){
+ m_fPedZoomValueSmooth += 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = min(m_fPedZoomValueSmooth, m_fPedZoomValue);
+ }else{
+ m_fPedZoomValueSmooth -= 0.12f * CTimer::GetTimeStep();
+ m_fPedZoomValueSmooth = max(m_fPedZoomValueSmooth, m_fPedZoomValue);
+ }
+ }
+
+ WellBufferMe(CloseInPedHeightTarget, &Cams[ActiveCam].m_fCloseInPedHeightOffset, &Cams[ActiveCam].m_fCloseInPedHeightOffsetSpeed, 0.1f, 0.025f, false);
+
+ // Check if entering fight cam
+ if(!m_bFirstPersonBeingUsed){
+ if(FindPlayerPed()->GetPedState() == PED_FIGHT && !m_bUseMouse3rdPerson)
+ ReqMode = CCam::MODE_FIGHT_CAM;
+ if(((CPed*)pTargetEntity)->GetWeapon()->m_eWeaponType == WEAPONTYPE_BASEBALLBAT &&
+ FindPlayerPed()->GetPedState() == PED_ATTACK && !m_bUseMouse3rdPerson)
+ ReqMode = CCam::MODE_FIGHT_CAM;
+ }
+
+ // Garage cam
+ if(CCullZones::CamStairsForPlayer() && CCullZones::FindZoneWithStairsAttributeForPlayer())
+ stairs = true;
+ // Some hack for Mr Whoopee in a bomb shop
+ if(Cams[ActiveCam].Using3rdPersonMouseCam() && CCollision::ms_collisionInMemory == LEVEL_COMMERCIAL){
+ if(pTargetEntity->GetPosition().x < 83.0f && pTargetEntity->GetPosition().x > 18.0f &&
+ pTargetEntity->GetPosition().y < -305.0f && pTargetEntity->GetPosition().y > -390.0f)
+ disableGarageCam = true;
+ }
+ if(!disableGarageCam && (CGarages::IsPointInAGarageCameraZone(pTargetEntity->GetPosition()) || stairs)){
+ if(!m_bGarageFixedCamPositionSet && m_bLookingAtPlayer){
+ if(pToGarageWeAreIn || stairs){
+ float ground;
+ bool foundGround;
+
+ if(pToGarageWeAreIn){
+ // targetPos = pTargetEntity->GetPosition(); // unused
+ if(pToGarageWeAreIn->m_pDoor1){
+ whichDoor = 1;
+ garageDoorPos1.x = pToGarageWeAreIn->m_fDoor1X;
+ garageDoorPos1.y = pToGarageWeAreIn->m_fDoor1Y;
+ garageDoorPos1.z = 0.0f;
+ // targetPos.z = 0.0f; // unused
+ // (targetPos - doorPos1).Magnitude(); // unused
+ }else if(pToGarageWeAreIn->m_pDoor2){
+ whichDoor = 2;
+#ifdef FIX_BUGS
+ garageDoorPos2.x = pToGarageWeAreIn->m_fDoor2X;
+ garageDoorPos2.y = pToGarageWeAreIn->m_fDoor2Y;
+ garageDoorPos2.z = 0.0f;
+#endif
+ }else{
+ whichDoor = 1;
+ garageDoorPos1.x = pTargetEntity->GetPosition().x;
+ garageDoorPos1.y = pTargetEntity->GetPosition().y;
+#ifdef FIX_BUGS
+ garageDoorPos1.z = 0.0f;
+#else
+ garageDoorPos2.z = 0.0f;
+#endif
+ }
+ }else{
+ whichDoor = 1;
+ garageDoorPos1 = Cams[ActiveCam].Source;
+ }
+
+ if(pToGarageWeAreIn){
+ garageCenter.x = (pToGarageWeAreIn->m_fX1 + pToGarageWeAreIn->m_fX2)/2.0f;
+ garageCenter.y = (pToGarageWeAreIn->m_fY1 + pToGarageWeAreIn->m_fY2)/2.0f;
+ garageCenter.z = 0.0f;
+ }else{
+ garageDoorPos1.z = 0.0f;
+ if(stairs){
+ CAttributeZone *az = CCullZones::FindZoneWithStairsAttributeForPlayer();
+ garageCenter.x = (az->minx + az->maxx)/2.0f;
+ garageCenter.y = (az->miny + az->maxy)/2.0f;
+ garageCenter.z = 0.0f;
+ }else
+ garageCenter = pTargetEntity->GetPosition();
+ }
+ if(whichDoor == 1)
+ garageCenterToDoor = garageDoorPos1 - garageCenter;
+ else
+ garageCenterToDoor = garageDoorPos2 - garageCenter;
+ targetPos = pTargetEntity->GetPosition();
+ ground = CWorld::FindGroundZFor3DCoord(targetPos.x, targetPos.y, targetPos.z, &foundGround);
+ if(!foundGround)
+ ground = targetPos.z - 0.2f;
+ garageCenterToDoor.z = 0.0f;
+ garageCenterToDoor.Normalise();
+ if(whichDoor == 1){
+ if(pToGarageWeAreIn == nil && stairs)
+ garageCamPos = garageDoorPos1 + 3.75f*garageCenterToDoor;
+ else
+ garageCamPos = garageDoorPos1 + 13.0f*garageCenterToDoor;
+ }else{
+ garageCamPos = garageDoorPos2 + 13.0f*garageCenterToDoor;
+ }
+ if(PedZoomIndicator == CAM_ZOOM_TOPDOWN && !stairs){
+ garageCamPos = garageCenter;
+ garageCamPos.z += FindPlayerPed()->GetPosition().z + 2.1f;
+ if(pToGarageWeAreIn && garageCamPos.z > pToGarageWeAreIn->m_fX2) // What?
+ garageCamPos.z = pToGarageWeAreIn->m_fX2;
+ }else
+ garageCamPos.z = ground + 3.1f;
+ SetCamPositionForFixedMode(garageCamPos, CVector(0.0f, 0.0f, 0.0f));
+ m_bGarageFixedCamPositionSet = true;
+ }
+ }
+
+ if((CGarages::CameraShouldBeOutside() || stairs) && m_bLookingAtPlayer && m_bGarageFixedCamPositionSet){
+ if(pToGarageWeAreIn || stairs){
+ ReqMode = CCam::MODE_FIXED;
+ m_bPlayerIsInGarage = true;
+ }
+ }else{
+ if(m_bPlayerIsInGarage){
+ m_bJustCameOutOfGarage = true;
+ m_bPlayerIsInGarage = false;
+ }
+ ReqMode = CCam::MODE_FOLLOWPED;
+ }
+ }else{
+ if(m_bPlayerIsInGarage){
+ m_bJustCameOutOfGarage = true;
+ m_bPlayerIsInGarage = false;
+ }
+ m_bGarageFixedCamPositionSet = false;
+ }
+
+ // Fallen into water
+ if(Cams[ActiveCam].IsTargetInWater(Cams[ActiveCam].Source) &&
+ Cams[ActiveCam].CamTargetEntity->IsPed())
+ ReqMode = CCam::MODE_PLAYER_FALLEN_WATER;
+
+ // Set top down
+ if(PedZoomIndicator == CAM_ZOOM_TOPDOWN &&
+ !CCullZones::Cam1stPersonForPlayer() &&
+ !CCullZones::CamNoRain() &&
+ !CCullZones::PlayerNoRain() &&
+ !m_bFirstPersonBeingUsed &&
+ !m_bPlayerIsInGarage)
+ ReqMode = CCam::MODE_TOP_DOWN_PED;
+
+ // Weapon mode
+ if(!CPad::GetPad(0)->GetTarget() && PlayerWeaponMode.Mode != CCam::MODE_HELICANNON_1STPERSON)
+ ClearPlayerWeaponMode();
+ if(m_PlayerMode.Mode != CCam::MODE_NONE)
+ ReqMode = m_PlayerMode.Mode;
+ if(PlayerWeaponMode.Mode != CCam::MODE_NONE && !stairs){
+ if(PlayerWeaponMode.Mode == CCam::MODE_SNIPER ||
+ PlayerWeaponMode.Mode == CCam::MODE_ROCKETLAUNCHER ||
+ PlayerWeaponMode.Mode == CCam::MODE_M16_1STPERSON ||
+ PlayerWeaponMode.Mode == CCam::MODE_HELICANNON_1STPERSON ||
+ Cams[ActiveCam].GetWeaponFirstPersonOn()){
+ // First person weapon mode
+ if(PLAYER->GetPedState() == PED_SEEK_CAR){
+ if(ReqMode == CCam::MODE_TOP_DOWN_PED || Cams[ActiveCam].GetWeaponFirstPersonOn())
+ ReqMode = PlayerWeaponMode.Mode;
+ else
+ ReqMode = CCam::MODE_FOLLOWPED;
+ }else
+ ReqMode = PlayerWeaponMode.Mode;
+ }else if(ReqMode != CCam::MODE_TOP_DOWN_PED){
+ // Syphon mode
+ float playerTargetDist;
+ float deadPedDist = 4.0f;
+ static float alivePedDist = 2.0f; // original name lost
+ float pedDist; // actually only used on dead target
+ bool targetDead = false;
+ float camAngle, targetAngle;
+ CVector playerToTarget = m_cvecAimingTargetCoors - pTargetEntity->GetPosition();
+ CVector playerToCam = Cams[ActiveCam].Source - pTargetEntity->GetPosition();
+
+ if(PedZoomIndicator == CAM_ZOOM_1)
+ deadPedDist = 2.25f;
+ if(FindPlayerPed()->m_pPointGunAt){
+ // BUG: this need not be a ped!
+ if(((CPed*)FindPlayerPed()->m_pPointGunAt)->DyingOrDead()){
+ targetDead = true;
+ pedDist = deadPedDist;
+ }else
+ pedDist = alivePedDist;
+ playerTargetDist = playerToTarget.Magnitude2D();
+ camAngle = CGeneral::GetATanOfXY(playerToCam.x, playerToCam.y);
+ targetAngle = CGeneral::GetATanOfXY(playerToTarget.x, playerToTarget.y);
+ ReqMode = PlayerWeaponMode.Mode;
+
+ // Check whether to start aiming in crim-in-front mode
+ if(Cams[ActiveCam].Mode != CCam::MODE_SYPHON){
+ float angleDiff = camAngle - targetAngle;
+ while(angleDiff >= PI) angleDiff -= 2*PI;
+ while(angleDiff < -PI) angleDiff += 2*PI;
+ if(Abs(angleDiff) < HALFPI && playerTargetDist < 3.5f && playerToTarget.z > -1.0f)
+ ReqMode = CCam::MODE_SYPHON_CRIM_IN_FRONT;
+ }
+
+ // Check whether to go to special fixed mode
+ float fixedModeDist = 0.0f;
+ if((ReqMode == CCam::MODE_SYPHON_CRIM_IN_FRONT || ReqMode == CCam::MODE_SYPHON) &&
+ (m_uiTransitionState == 0 || Cams[ActiveCam].Mode == CCam::MODE_SPECIAL_FIXED_FOR_SYPHON) &&
+ playerTargetDist < pedDist && targetDead){
+ if(ReqMode == CCam::MODE_SYPHON_CRIM_IN_FRONT)
+ fixedModeDist = 5.0f;
+ else
+ fixedModeDist = 3.0f;
+ ReqMode = CCam::MODE_SPECIAL_FIXED_FOR_SYPHON;
+ }
+ if(ReqMode == CCam::MODE_SPECIAL_FIXED_FOR_SYPHON){
+ if(!PlaceForFixedWhenSniperFound){
+ // Find position
+ CEntity *entity;
+ CColPoint colPoint;
+ CVector fixedPos = pTargetEntity->GetPosition();
+ fixedPos.x += fixedModeDist*Cos(camAngle);
+ fixedPos.y += fixedModeDist*Sin(camAngle);
+ fixedPos.z += 1.15f;
+ if(CWorld::ProcessLineOfSight(pTargetEntity->GetPosition(), fixedPos, colPoint, entity, true, false, false, true, false, true, true))
+ SetCamPositionForFixedMode(colPoint.point, CVector(0.0f, 0.0f, 0.0f));
+ else
+ SetCamPositionForFixedMode(fixedPos, CVector(0.0f, 0.0f, 0.0f));
+ PlaceForFixedWhenSniperFound = true;
+ }
+ }else
+ PlaceForFixedWhenSniperFound = false;
+ }
+ }
+ }
+ }
+ }
+
+ m_bIdleOn = false;
+
+ if(DebugCamMode)
+ ReqMode = DebugCamMode;
+
+
+ // Process arrested player
+ static int ThePickedArrestMode;
+ static int LastPedState;
+ bool startArrestCam = false;
+
+ if(LastPedState != PED_ARRESTED && PLAYER->GetPedState() == PED_ARRESTED){
+ if(CarZoomIndicator != CAM_ZOOM_1STPRS && pTargetEntity->IsVehicle())
+ startArrestCam = true;
+ }else
+ startArrestCam = false;
+ LastPedState = PLAYER->GetPedState();
+ if(startArrestCam){
+ if(m_uiTransitionState)
+ ReqMode = Cams[ActiveCam].Mode;
+ else{
+ bool valid;
+ if(pTargetEntity->IsPed()){
+ // How can this happen if arrest cam is only done in cars?
+ Cams[(ActiveCam+1)%2].ResetStatics = true;
+ valid = Cams[(ActiveCam+1)%2].ProcessArrestCamOne();
+ ReqMode = CCam::MODE_ARRESTCAM_ONE;
+ }else{
+ Cams[(ActiveCam+1)%2].ResetStatics = true;
+ valid = Cams[(ActiveCam+1)%2].ProcessArrestCamTwo();
+ ReqMode = CCam::MODE_ARRESTCAM_TWO;
+ }
+ if(!valid)
+ ReqMode = Cams[ActiveCam].Mode;
+ }
+ }
+ ThePickedArrestMode = ReqMode;
+ if(PLAYER->GetPedState() == PED_ARRESTED)
+ ReqMode = ThePickedArrestMode; // this is rather useless...
+
+ // Process dead player
+ if(PLAYER->GetPedState() == PED_DEAD){
+ if(Cams[ActiveCam].Mode == CCam::MODE_PED_DEAD_BABY)
+ ReqMode = CCam::MODE_PED_DEAD_BABY;
+ else{
+ bool foundRoof;
+ CVector pos = FindPlayerPed()->GetPosition();
+ CWorld::FindRoofZFor3DCoord(pos.x, pos.y, pos.z, &foundRoof);
+ if(!foundRoof)
+ ReqMode = CCam::MODE_PED_DEAD_BABY;
+ }
+ }
+
+ // Restore with a jump cut
+ if(m_bRestoreByJumpCut){
+ if(ReqMode != CCam::MODE_FOLLOWPED &&
+ ReqMode != CCam::MODE_M16_1STPERSON &&
+ ReqMode != CCam::MODE_SNIPER &&
+ ReqMode != CCam::MODE_ROCKETLAUNCHER ||
+ !m_bUseMouse3rdPerson)
+ SetCameraDirectlyBehindForFollowPed_CamOnAString();
+
+ ReqMode = m_iModeToGoTo;
+ Cams[ActiveCam].Mode = ReqMode;
+ m_bJust_Switched = true;
+ Cams[ActiveCam].ResetStatics = true;
+ Cams[ActiveCam].m_cvecCamFixedModeVector = m_vecFixedModeVector;
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ Cams[ActiveCam].m_cvecCamFixedModeSource = m_vecFixedModeSource;
+ Cams[ActiveCam].m_cvecCamFixedModeUpOffSet = m_vecFixedModeUpOffSet;
+ Cams[ActiveCam].m_bCamLookingAtVector = false;
+ Cams[ActiveCam].m_vecLastAboveWaterCamPosition = Cams[(ActiveCam+1)%2].m_vecLastAboveWaterCamPosition;
+ m_bRestoreByJumpCut = false;
+ Cams[ActiveCam].ResetStatics = true;
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ CarZoomValueSmooth = CarZoomValue;
+ m_fPedZoomValueSmooth = m_fPedZoomValue;
+ m_uiTransitionState = 0;
+ m_vecDoingSpecialInterPolation = false;
+ }
+
+ if(gbModelViewer)
+ ReqMode = CCam::MODE_MODELVIEW;
+
+ // Turn on Obbe's cam
+ bool canUseObbeCam = true;
+ if(pTargetEntity){
+ if(pTargetEntity->IsVehicle()){
+ if(CarZoomIndicator == CAM_ZOOM_CINEMATIC)
+ m_bObbeCinematicCarCamOn = true;
+ }else{
+ if(PedZoomIndicator == CAM_ZOOM_CINEMATIC)
+ m_bObbeCinematicPedCamOn = true;
+ }
+ }
+ if(m_bTargetJustBeenOnTrain ||
+ ReqMode == CCam::MODE_SYPHON || ReqMode == CCam::MODE_SYPHON_CRIM_IN_FRONT || ReqMode == CCam::MODE_SPECIAL_FIXED_FOR_SYPHON ||
+ ReqMode == CCam::MODE_PED_DEAD_BABY || ReqMode == CCam::MODE_ARRESTCAM_ONE || ReqMode == CCam::MODE_ARRESTCAM_TWO ||
+ ReqMode == CCam::MODE_FIGHT_CAM || ReqMode == CCam::MODE_PLAYER_FALLEN_WATER ||
+ ReqMode == CCam::MODE_SNIPER || ReqMode == CCam::MODE_ROCKETLAUNCHER || ReqMode == CCam::MODE_M16_1STPERSON ||
+ ReqMode == CCam::MODE_SNIPER_RUNABOUT || ReqMode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ ReqMode == CCam::MODE_1STPERSON_RUNABOUT || ReqMode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ ReqMode == CCam::MODE_FIGHT_CAM_RUNABOUT || ReqMode == CCam::MODE_HELICANNON_1STPERSON ||
+ WhoIsInControlOfTheCamera == CAMCONTROL_SCRIPT ||
+ m_bJustCameOutOfGarage || m_bPlayerIsInGarage)
+ canUseObbeCam = false;
+
+ if(m_bObbeCinematicPedCamOn && canUseObbeCam)
+ ProcessObbeCinemaCameraPed();
+ else if(m_bObbeCinematicCarCamOn && canUseObbeCam)
+ ProcessObbeCinemaCameraCar();
+ else{
+ if(m_bPlayerIsInGarage && m_bObbeCinematicCarCamOn)
+ switchByJumpCut = true;
+ canUseObbeCam = false;
+ DontProcessObbeCinemaCamera();
+ }
+
+ // Start the transition or do a jump cut
+ if(m_bLookingAtPlayer){
+ // Going into top down modes normally needs a jump cut (but see below)
+ if(ReqMode == CCam::MODE_TOPDOWN || ReqMode == CCam::MODE_1STPERSON || ReqMode == CCam::MODE_TOP_DOWN_PED){
+ switchByJumpCut = true;
+ }
+ // Going from top down to vehicle
+ else if(ReqMode == CCam::MODE_CAM_ON_A_STRING || ReqMode == CCam::MODE_BEHINDBOAT){
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED)
+ switchByJumpCut = true;
+ }else if(ReqMode == CCam::MODE_FIXED){
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN)
+ switchByJumpCut = true;
+ }
+
+ // Top down modes can interpolate between each other
+ if(ReqMode == CCam::MODE_TOPDOWN){
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED || Cams[ActiveCam].Mode == CCam::MODE_PED_DEAD_BABY)
+ switchByJumpCut = false;
+ }else if(ReqMode == CCam::MODE_TOP_DOWN_PED){
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN || Cams[ActiveCam].Mode == CCam::MODE_PED_DEAD_BABY)
+ switchByJumpCut = false;
+ }
+
+ if(ReqMode == CCam::MODE_1STPERSON || ReqMode == CCam::MODE_M16_1STPERSON ||
+ ReqMode == CCam::MODE_SNIPER || ReqMode == CCam::MODE_ROCKETLAUNCHER ||
+ ReqMode == CCam::MODE_SNIPER_RUNABOUT || ReqMode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ ReqMode == CCam::MODE_1STPERSON_RUNABOUT || ReqMode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ ReqMode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ ReqMode == CCam::MODE_HELICANNON_1STPERSON ||
+ ReqMode == CCam::MODE_ARRESTCAM_ONE || ReqMode == CCam::MODE_ARRESTCAM_TWO){
+ // Going into any 1st person mode is a jump cut
+ if(pTargetEntity->IsPed())
+ switchByJumpCut = true;
+ }else if(ReqMode == CCam::MODE_FIXED && m_bPlayerIsInGarage){
+ // Going from 1st peron mode into garage
+ if(Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_HELICANNON_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED ||
+ stairs ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON_RUNABOUT){
+ if(pTargetEntity && pTargetEntity->IsVehicle())
+ switchByJumpCut = true;
+ }
+ }else if(ReqMode == CCam::MODE_FOLLOWPED){
+ if(Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER ||
+ Cams[ActiveCam].Mode == CCam::MODE_ARRESTCAM_ONE ||
+ Cams[ActiveCam].Mode == CCam::MODE_ARRESTCAM_TWO ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_PED_DEAD_BABY ||
+ Cams[ActiveCam].Mode == CCam::MODE_PILLOWS_PAPS ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_HELICANNON_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_TOPDOWN ||
+ Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+ if(!m_bJustCameOutOfGarage){
+ if(Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_HELICANNON_1STPERSON){
+ float angle = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) - HALFPI;
+ ((CPed*)pTargetEntity)->m_fRotationCur = angle;
+ ((CPed*)pTargetEntity)->m_fRotationDest = angle;
+ }
+ m_bUseTransitionBeta = true;
+ switchByJumpCut = true;
+ if(Cams[ActiveCam].Mode == CCam::MODE_TOP_DOWN_PED){
+ CVector front = Cams[ActiveCam].Source - FindPlayerPed()->GetPosition();
+ front.z = 0.0f;
+ front.Normalise();
+#ifdef FIX_BUGS
+ // this is almost as bad as the bugged code
+ if(front.x == 0.001f && front.y == 0.001f)
+ front.y = 1.0f;
+#else
+ // someone used = instead of == in the above check by accident
+ front.x = 0.001f;
+ front.y = 1.0f;
+#endif
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(front.x, front.y);
+ }else
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) + PI;
+ }
+ }
+ }else if(ReqMode == CCam::MODE_FIGHT_CAM){
+ if(Cams[ActiveCam].Mode == CCam::MODE_1STPERSON)
+ switchByJumpCut = true;
+ }
+
+ if(ReqMode != Cams[ActiveCam].Mode && Cams[ActiveCam].CamTargetEntity == nil)
+ switchByJumpCut = true;
+ if(m_bPlayerIsInGarage && pToGarageWeAreIn){
+ if(pToGarageWeAreIn->m_eGarageType == GARAGE_BOMBSHOP1 ||
+ pToGarageWeAreIn->m_eGarageType == GARAGE_BOMBSHOP2 ||
+ pToGarageWeAreIn->m_eGarageType == GARAGE_BOMBSHOP3){
+ if(pTargetEntity->IsVehicle() && pTargetEntity->GetModelIndex() == MI_MRWHOOP &&
+ ReqMode != Cams[ActiveCam].Mode)
+ switchByJumpCut = true;
+ }
+ }
+ if(CSceneEdit::m_bEditOn)
+ ReqMode = CCam::MODE_EDITOR;
+
+ if((m_uiTransitionState == 0 || switchByJumpCut) && ReqMode != Cams[ActiveCam].Mode){
+ if(switchByJumpCut){
+ if(!m_bPlayerIsInGarage || m_bJustCameOutOfGarage){
+ if(ReqMode != CCam::MODE_FOLLOWPED &&
+ ReqMode != CCam::MODE_M16_1STPERSON &&
+ ReqMode != CCam::MODE_SNIPER &&
+ ReqMode != CCam::MODE_ROCKETLAUNCHER ||
+ !m_bUseMouse3rdPerson)
+ SetCameraDirectlyBehindForFollowPed_CamOnAString();
+ }
+ Cams[ActiveCam].Mode = ReqMode;
+ m_bJust_Switched = true;
+ Cams[ActiveCam].m_cvecCamFixedModeVector = m_vecFixedModeVector;
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ Cams[ActiveCam].m_cvecCamFixedModeSource = m_vecFixedModeSource;
+ Cams[ActiveCam].m_cvecCamFixedModeUpOffSet = m_vecFixedModeUpOffSet;
+ Cams[ActiveCam].m_bCamLookingAtVector = m_bLookingAtVector;
+ Cams[ActiveCam].m_vecLastAboveWaterCamPosition = Cams[(ActiveCam+1)%2].m_vecLastAboveWaterCamPosition;
+ CarZoomValueSmooth = CarZoomValue;
+ m_fPedZoomValueSmooth = m_fPedZoomValue;
+ m_uiTransitionState = 0;
+ m_vecDoingSpecialInterPolation = false;
+ m_bStartInterScript = false;
+ Cams[ActiveCam].ResetStatics = true;
+
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }else if(!m_bWaitForInterpolToFinish){
+ StartTransition(ReqMode);
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }
+ }else if(m_uiTransitionState != 0 && ReqMode != Cams[ActiveCam].Mode){
+ bool startTransition = true;
+
+ if(ReqMode == CCam::MODE_FIGHT_CAM || Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM)
+ startTransition = false;
+ if(ReqMode == CCam::MODE_FOLLOWPED && Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM)
+ startTransition = false;
+
+ if(!m_bWaitForInterpolToFinish && m_bLookingAtPlayer && m_uiTransitionState != 0){
+ CVector playerDist;
+ playerDist.x = FindPlayerPed()->GetPosition().x - GetPosition().x;
+ playerDist.y = FindPlayerPed()->GetPosition().y - GetPosition().y;
+ playerDist.z = FindPlayerPed()->GetPosition().z - GetPosition().z;
+ // if player is too far away, keep interpolating and don't transition
+ if(pTargetEntity && pTargetEntity->IsPed()){
+ if(playerDist.Magnitude() > 17.5f &&
+ (ReqMode == CCam::MODE_SYPHON || ReqMode == CCam::MODE_SYPHON_CRIM_IN_FRONT))
+ m_bWaitForInterpolToFinish = true;
+ }
+ }
+ if(m_bWaitForInterpolToFinish)
+ startTransition = false;
+
+ if(startTransition){
+ StartTransitionWhenNotFinishedInter(ReqMode);
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }
+ }else if(ReqMode == CCam::MODE_FIXED && pTargetEntity != Cams[ActiveCam].CamTargetEntity && m_bPlayerIsInGarage){
+ if(m_uiTransitionState != 0)
+ StartTransitionWhenNotFinishedInter(ReqMode);
+ else
+ StartTransition(ReqMode);
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }
+ }else{
+ // not following player
+ if(m_uiTransitionState == 0 && m_bStartInterScript && m_iTypeOfSwitch == INTERPOLATION){
+ ReqMode = m_iModeToGoTo;
+ StartTransition(ReqMode);
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }else if(m_uiTransitionState != 0 && m_bStartInterScript && m_iTypeOfSwitch == INTERPOLATION){
+ ReqMode = m_iModeToGoTo;
+ StartTransitionWhenNotFinishedInter(ReqMode);
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ }else if(m_bStartInterScript && m_iTypeOfSwitch == JUMP_CUT){
+ m_uiTransitionState = 0;
+ m_vecDoingSpecialInterPolation = false;
+ Cams[ActiveCam].Mode = m_iModeToGoTo;
+ m_bJust_Switched = true;
+ Cams[ActiveCam].ResetStatics = true;
+ Cams[ActiveCam].m_cvecCamFixedModeVector = m_vecFixedModeVector;
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ Cams[ActiveCam].m_cvecCamFixedModeSource = m_vecFixedModeSource;
+ Cams[ActiveCam].m_cvecCamFixedModeUpOffSet = m_vecFixedModeUpOffSet;
+ Cams[ActiveCam].m_bCamLookingAtVector = m_bLookingAtVector;
+ Cams[ActiveCam].m_vecLastAboveWaterCamPosition = Cams[(ActiveCam+1)%2].m_vecLastAboveWaterCamPosition;
+ m_bJust_Switched = true;
+ pTargetEntity->RegisterReference(&pTargetEntity);
+ Cams[ActiveCam].CamTargetEntity->RegisterReference(&Cams[ActiveCam].CamTargetEntity);
+ CarZoomValueSmooth = CarZoomValue;
+ m_fPedZoomValueSmooth = m_fPedZoomValue;
+ }
+ }
+
+ m_bStartInterScript = false;
+
+ if(Cams[ActiveCam].CamTargetEntity == nil)
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+
+ // Ped visibility
+ if((Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER) && pTargetEntity->IsPed() ||
+ Cams[ActiveCam].Mode == CCam::MODE_FLYBY)
+ FindPlayerPed()->bIsVisible = false;
+ else
+ FindPlayerPed()->bIsVisible = true;
+
+ if(!canUseObbeCam && WhoIsInControlOfTheCamera == CAMCONTROL_OBBE)
+ Restore();
}
-bool
-CCamera::IsPointVisible(const CVector &center, const CMatrix *mat)
+// What a mess!
+void
+CCamera::UpdateTargetEntity(void)
{
- RwV3d c;
- c = *(RwV3d*)&center;
- RwV3dTransformPoints(&c, &c, 1, &mat->m_matrix);
- if(c.y < CDraw::GetNearClipZ()) return false;
- if(c.y > CDraw::GetFarClipZ()) return false;
- if(c.x*m_vecFrustumNormals[0].x + c.y*m_vecFrustumNormals[0].y > 0.0f) return false;
- if(c.x*m_vecFrustumNormals[1].x + c.y*m_vecFrustumNormals[1].y > 0.0f) return false;
- if(c.y*m_vecFrustumNormals[2].y + c.z*m_vecFrustumNormals[2].z > 0.0f) return false;
- if(c.y*m_vecFrustumNormals[3].y + c.z*m_vecFrustumNormals[3].z > 0.0f) return false;
- return true;
+ bool enteringCar = false; // not on PS2 but only used as && !enteringCar so we can keep it
+ bool obbeCam = false;
+
+ if(WhoIsInControlOfTheCamera == CAMCONTROL_OBBE){
+ obbeCam = true;
+ if(m_iModeObbeCamIsInForCar == OBBE_COPCAR_WHEEL || m_iModeObbeCamIsInForCar == OBBE_COPCAR){
+ if(FindPlayerPed()->GetPedState() != PED_ARRESTED)
+ obbeCam = false;
+ if(FindPlayerVehicle() == nil)
+ pTargetEntity = FindPlayerPed();
+ }
+ }
+
+ if((m_bLookingAtPlayer || obbeCam) && m_uiTransitionState == 0 ||
+ pTargetEntity == nil ||
+ m_bTargetJustBeenOnTrain){
+ if(FindPlayerVehicle())
+ pTargetEntity = FindPlayerVehicle();
+ else{
+ pTargetEntity = FindPlayerPed();
+#ifndef GTA_PS2_STUFF
+ // this keeps the camera on the player while entering cars
+ if(PLAYER->GetPedState() == PED_ENTER_CAR ||
+ PLAYER->GetPedState() == PED_CARJACK ||
+ PLAYER->GetPedState() == PED_OPEN_DOOR)
+ enteringCar = true;
+
+ if(!enteringCar)
+ if(Cams[ActiveCam].CamTargetEntity != pTargetEntity)
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+#endif
+ }
+
+ bool cantOpen = true;
+ if(PLAYER &&
+ PLAYER->m_pMyVehicle &&
+ PLAYER->m_pMyVehicle->CanPedOpenLocks(PLAYER))
+ cantOpen = false;
+
+ if(PLAYER->GetPedState() == PED_ENTER_CAR && !cantOpen){
+ if(!enteringCar && CarZoomIndicator != 0.0f){
+ pTargetEntity = PLAYER->m_pMyVehicle;
+ if(PLAYER->m_pMyVehicle == nil)
+ pTargetEntity = PLAYER;
+ }
+ }
+
+ if((PLAYER->GetPedState() == PED_CARJACK || PLAYER->GetPedState() == PED_OPEN_DOOR) && !cantOpen){
+ if(!enteringCar && CarZoomIndicator != 0.0f)
+#ifdef GTA_PS2_STUFF
+// dunno if this has any amazing effects
+ {
+#endif
+ pTargetEntity = PLAYER->m_pMyVehicle;
+ if(PLAYER->m_pMyVehicle == nil)
+ pTargetEntity = PLAYER;
+#ifdef GTA_PS2_STUFF
+ }
+#endif
+ }
+
+ if(PLAYER->GetPedState() == PED_EXIT_CAR)
+ pTargetEntity = FindPlayerPed();
+ if(PLAYER->GetPedState() == PED_DRAG_FROM_CAR)
+ pTargetEntity = FindPlayerPed();
+ if(pTargetEntity->IsVehicle() && CarZoomIndicator != 0.0f && FindPlayerPed()->GetPedState() == PED_ARRESTED)
+ pTargetEntity = FindPlayerPed();
+ }
}
-bool
-CCamera::IsBoxVisible(RwV3d *box, const CMatrix *mat)
+const float SOUND_DIST = 20.0f;
+
+void
+CCamera::UpdateSoundDistances(void)
{
- int i;
- int frustumTests[6] = { 0 };
- RwV3dTransformPoints(box, box, 8, &mat->m_matrix);
+ CVector center, end;
+ CEntity *entity;
+ CColPoint colPoint;
+ float f;
+ int n;
- for(i = 0; i < 8; i++){
- if(box[i].y < CDraw::GetNearClipZ()) frustumTests[0]++;
- if(box[i].y > CDraw::GetFarClipZ()) frustumTests[1]++;
- if(box[i].x*m_vecFrustumNormals[0].x + box[i].y*m_vecFrustumNormals[0].y > 0.0f) frustumTests[2]++;
- if(box[i].x*m_vecFrustumNormals[1].x + box[i].y*m_vecFrustumNormals[1].y > 0.0f) frustumTests[3]++;
-// Why not test z?
-// if(box[i].y*m_vecFrustumNormals[2].y + box[i].z*m_vecFrustumNormals[2].z > 0.0f) frustumTests[4]++;
-// if(box[i].y*m_vecFrustumNormals[3].y + box[i].z*m_vecFrustumNormals[3].z > 0.0f) frustumTests[5]++;
+ if((Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_HELICANNON_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER) &&
+ pTargetEntity->IsPed())
+ center = GetPosition() + 0.5f*GetForward();
+ else
+ center = GetPosition() + 5.0f*GetForward();
+
+ // check up
+ n = CTimer::GetFrameCounter() % 12;
+ if(n == 0){
+ SoundDistUpAsReadOld = SoundDistUpAsRead;
+ if(CWorld::ProcessVerticalLine(center, center.z+SOUND_DIST, colPoint, entity, true, false, false, false, true, false, nil))
+ SoundDistUpAsRead = colPoint.point.z - center.z;
+ else
+ SoundDistUpAsRead = SOUND_DIST;
}
- for(i = 0; i < 6; i++)
- if(frustumTests[i] == 8)
- return false; // Box is completely outside of one plane
- return true;
+ f = (n + 1) / 6.0f;
+ SoundDistUp = (1.0f-f)*SoundDistUpAsReadOld + f*SoundDistUpAsRead;
+
+ // check left
+ n = (CTimer::GetFrameCounter()+2) % 12;
+ if(n == 0){
+ SoundDistLeftAsReadOld = SoundDistLeftAsRead;
+ end = center + SOUND_DIST*GetRight();
+ if(CWorld::ProcessLineOfSight(center, end, colPoint, entity, true, false, false, false, true, true, true))
+ SoundDistLeftAsRead = (colPoint.point - center).Magnitude();
+ else
+ SoundDistLeftAsRead = SOUND_DIST;
+ }
+ f = (n + 1) / 6.0f;
+ SoundDistLeft = (1.0f-f)*SoundDistLeftAsReadOld + f*SoundDistLeftAsRead;
+
+ // check right
+ // end = center - SOUND_DIST*GetRight(); // useless
+ n = (CTimer::GetFrameCounter()+4) % 12;
+ if(n == 0){
+ SoundDistRightAsReadOld = SoundDistRightAsRead;
+ end = center - SOUND_DIST*GetRight();
+ if(CWorld::ProcessLineOfSight(center, end, colPoint, entity, true, false, false, false, true, true, true))
+ SoundDistRightAsRead = (colPoint.point - center).Magnitude();
+ else
+ SoundDistRightAsRead = SOUND_DIST;
+ }
+ f = (n + 1) / 6.0f;
+ SoundDistRight = (1.0f-f)*SoundDistRightAsReadOld + f*SoundDistRightAsRead;
}
-int
-CCamera::GetLookDirection(void)
+void
+CCamera::InitialiseCameraForDebugMode(void)
{
- if(Cams[ActiveCam].Mode == CCam::MODE_CAM_ON_A_STRING ||
- Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
- Cams[ActiveCam].Mode == CCam::MODE_BEHINDBOAT ||
- Cams[ActiveCam].Mode == CCam::MODE_FOLLOWPED)
- return Cams[ActiveCam].DirectionWasLooking;
- return LOOKING_FORWARD;;
+ if(FindPlayerVehicle())
+ Cams[2].Source = FindPlayerVehicle()->GetPosition();
+ else if(FindPlayerPed())
+ Cams[2].Source = FindPlayerPed()->GetPosition();
+ Cams[2].Alpha = 0.0f;
+ Cams[2].Beta = 0.0f;
+ Cams[2].Mode = CCam::MODE_DEBUG;
}
-bool
-CCamera::GetLookingForwardFirstPerson()
+void
+CCamera::CamShake(float strength, float x, float y, float z)
{
- return Cams[ActiveCam].Mode == CCam::MODE_1STPERSON &&
- Cams[ActiveCam].DirectionWasLooking == LOOKING_FORWARD;
+ CVector Dist = Cams[ActiveCam].Source - CVector(x, y, z);
+ // a bit complicated...
+ float dist2d = Sqrt(SQR(Dist.x) + SQR(Dist.y));
+ float dist3d = Sqrt(SQR(dist2d) + SQR(Dist.z));
+ if(dist3d > 100.0f) dist3d = 100.0f;
+ if(dist3d < 0.0f) dist3d = 0.0f;
+ float mult = 1.0f - dist3d/100.0f;
+
+ float curForce = mult*(m_fCamShakeForce - (CTimer::GetTimeInMilliseconds() - m_uiCamShakeStart)/1000.0f);
+ strength = mult*strength;
+ if(clamp(curForce, 0.0f, 2.0f) < strength){
+ m_fCamShakeForce = strength;
+ m_uiCamShakeStart = CTimer::GetTimeInMilliseconds();
+ }
}
+// This seems to be CCamera::CamShake(float) on PS2
+void
+CamShakeNoPos(CCamera *cam, float strength)
+{
+ float curForce = cam->m_fCamShakeForce - (CTimer::GetTimeInMilliseconds() - cam->m_uiCamShakeStart)/1000.0f;
+ if(clamp(curForce, 0.0f, 2.0f) < strength){
+ cam->m_fCamShakeForce = strength;
+ cam->m_uiCamShakeStart = CTimer::GetTimeInMilliseconds();
+ }
+}
-WRAPPER void CCamera::Fade(float timeout, int16 direction) { EAXJMP(0x46B3A0); }
-WRAPPER void CCamera::ProcessFade(void) { EAXJMP(0x46F080); }
-WRAPPER void CCamera::ProcessMusicFade(void) { EAXJMP(0x46F1E0); }
-int
-CCamera::GetScreenFadeStatus(void)
+
+void
+CCamera::TakeControl(CEntity *target, int16 mode, int16 typeOfSwitch, int32 controller)
{
- if(m_fFLOATingFade == 0.0f)
- return FADE_0;
- if(m_fFLOATingFade == 255.0f)
- return FADE_2;
- return FADE_1;
+ bool doSwitch = true;
+ if(controller == CAMCONTROL_OBBE && WhoIsInControlOfTheCamera == CAMCONTROL_SCRIPT)
+ doSwitch = false;
+ if(doSwitch){
+ WhoIsInControlOfTheCamera = controller;
+ if(target){
+ if(mode == CCam::MODE_NONE){
+ // Why are we checking the old entity?
+ if(pTargetEntity->IsPed())
+ mode = CCam::MODE_FOLLOWPED;
+ else if(pTargetEntity->IsVehicle())
+ mode = CCam::MODE_CAM_ON_A_STRING;
+ }
+ }else if(FindPlayerVehicle())
+ target = FindPlayerVehicle();
+ else
+ target = PLAYER;
+
+ m_bLookingAtVector = false;
+ pTargetEntity = target;
+ m_iModeToGoTo = mode;
+ m_iTypeOfSwitch = typeOfSwitch;
+ m_bLookingAtPlayer = false;
+ m_bStartInterScript = true;
+ // FindPlayerPed(); // unused
+ }
}
void
-CCamera::SetFadeColour(uint8 r, uint8 g, uint8 b)
+CCamera::TakeControlNoEntity(const CVector &position, int16 typeOfSwitch, int32 controller)
{
- m_FadeTargetIsSplashScreen = r == 0 && g == 0 && b == 0;
- CDraw::FadeRed = r;
- CDraw::FadeGreen = g;
- CDraw::FadeBlue = b;
+ bool doSwitch = true;
+ if(controller == CAMCONTROL_OBBE && WhoIsInControlOfTheCamera == CAMCONTROL_SCRIPT)
+ doSwitch = false;
+ if(doSwitch){
+ WhoIsInControlOfTheCamera = controller;
+ m_bLookingAtVector = true;
+ m_bLookingAtPlayer = false;
+ m_iModeToGoTo = CCam::MODE_FIXED;
+ m_vecFixedModeVector = position;
+ m_iTypeOfSwitch = typeOfSwitch;
+ m_bStartInterScript = true;
+ }
}
void
-CCamera::SetMotionBlur(int r, int g, int b, int a, int type)
+CCamera::TakeControlWithSpline(int16 typeOfSwitch)
{
- m_BlurRed = r;
- m_BlurGreen = g;
- m_BlurBlue = b;
- m_motionBlur = a;
- m_BlurType = type;
+ m_iModeToGoTo = CCam::MODE_FLYBY;
+ m_bLookingAtPlayer = false;
+ m_bLookingAtVector = false;
+ m_bcutsceneFinished = false;
+ m_iTypeOfSwitch = typeOfSwitch;
+ m_bStartInterScript = true;
+
+ //FindPlayerPed(); // unused
+};
+
+void
+CCamera::Restore(void)
+{
+ m_bLookingAtPlayer = true;
+ m_bLookingAtVector = false;
+ m_iTypeOfSwitch = INTERPOLATION;
+ m_bUseNearClipScript = false;
+ m_iModeObbeCamIsInForCar = OBBE_INVALID;
+ m_fPositionAlongSpline = 0.0;
+ m_bStartingSpline = false;
+ m_bScriptParametersSetForInterPol = false;
+ WhoIsInControlOfTheCamera = CAMCONTROL_GAME;
+
+ if(FindPlayerVehicle()){
+ m_iModeToGoTo = CCam::MODE_CAM_ON_A_STRING;
+ pTargetEntity = FindPlayerVehicle();
+ }else{
+ m_iModeToGoTo = CCam::MODE_FOLLOWPED;
+ pTargetEntity = PLAYER;
+ }
+
+ if(PLAYER->GetPedState() == PED_ENTER_CAR ||
+ PLAYER->GetPedState() == PED_CARJACK ||
+ PLAYER->GetPedState() == PED_OPEN_DOOR){
+ m_iModeToGoTo = CCam::MODE_CAM_ON_A_STRING;
+ pTargetEntity = PLAYER->m_pSeekTarget;
+ }
+ if(PLAYER->GetPedState() == PED_EXIT_CAR){
+ m_iModeToGoTo = CCam::MODE_FOLLOWPED;
+ pTargetEntity = PLAYER;
+ }
+
+ m_bUseScriptZoomValuePed = false;
+ m_bUseScriptZoomValueCar = false;
+ m_bStartInterScript = true;
+ m_bCameraJustRestored = true;
}
void
-CCamera::SetMotionBlurAlpha(int a)
+CCamera::RestoreWithJumpCut(void)
{
- m_imotionBlurAddAlpha = a;
+ m_bRestoreByJumpCut = true;
+ m_bLookingAtPlayer = true;
+ m_bLookingAtVector = false;
+ m_iTypeOfSwitch = JUMP_CUT;
+ m_bUseNearClipScript = false;
+ m_iModeObbeCamIsInForCar = OBBE_INVALID;
+ m_fPositionAlongSpline = 0.0;
+ m_bStartingSpline = false;
+ m_bScriptParametersSetForInterPol = false;
+ WhoIsInControlOfTheCamera = CAMCONTROL_GAME;
+ m_bCameraJustRestored = true;
+
+ if(FindPlayerVehicle()){
+ m_iModeToGoTo = CCam::MODE_CAM_ON_A_STRING;
+ pTargetEntity = FindPlayerVehicle();
+ }else{
+ m_iModeToGoTo = CCam::MODE_FOLLOWPED;
+ pTargetEntity = PLAYER;
+ }
+
+ if(PLAYER->GetPedState() == PED_ENTER_CAR ||
+ PLAYER->GetPedState() == PED_CARJACK ||
+ PLAYER->GetPedState() == PED_OPEN_DOOR){
+ m_iModeToGoTo = CCam::MODE_CAM_ON_A_STRING;
+ pTargetEntity = PLAYER->m_pSeekTarget;
+ }
+ if(PLAYER->GetPedState() == PED_EXIT_CAR){
+ m_iModeToGoTo = CCam::MODE_FOLLOWPED;
+ pTargetEntity = PLAYER;
+ }
+
+ m_bUseScriptZoomValuePed = false;
+ m_bUseScriptZoomValueCar = false;
}
void
-CCamera::SetNearClipScript(float clip)
+CCamera::SetCamPositionForFixedMode(const CVector &Source, const CVector &UpOffSet)
{
- m_fNearClipScript = clip;
- m_bUseNearClipScript = true;
+ m_vecFixedModeSource = Source;
+ m_vecFixedModeUpOffSet = UpOffSet;
}
+
+
+/*
+ * On PS2 the transition happens between Cams[1] and Cams[2].
+ * On PC the whole system has been changed.
+ */
void
-CCamera::RenderMotionBlur(void)
+CCamera::StartTransition(int16 newMode)
{
- if(m_BlurType == 0)
- return;
+ bool foo = false;
+ bool switchSyphonMode = false;
+ bool switchPedToCar = false;
+ bool switchPedMode = false;
+ bool switchFromFixed = false;
+ bool switch1stPersonToVehicle = false;
+ float betaOffset, targetBeta, camBeta, deltaBeta;
+ int door;
+ bool vehicleVertical;
- CMBlur::MotionBlurRender(m_pRwCamera,
- m_BlurRed, m_BlurGreen, m_BlurBlue,
- m_motionBlur, m_BlurType, m_imotionBlurAddAlpha);
+// missing on PS2
+ m_bItsOkToLookJustAtThePlayer = false;
+ m_fFractionInterToStopMovingTarget = 0.25f;
+ m_fFractionInterToStopCatchUpTarget = 0.75f;
+
+ if(Cams[ActiveCam].Mode == CCam::MODE_SYPHON_CRIM_IN_FRONT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FOLLOWPED ||
+ Cams[ActiveCam].Mode == CCam::MODE_SYPHON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SPECIAL_FIXED_FOR_SYPHON){
+ if(newMode == CCam::MODE_SYPHON_CRIM_IN_FRONT ||
+ newMode == CCam::MODE_FOLLOWPED ||
+ newMode == CCam::MODE_SYPHON ||
+ newMode == CCam::MODE_SPECIAL_FIXED_FOR_SYPHON)
+ m_bItsOkToLookJustAtThePlayer = true;
+ if(newMode == CCam::MODE_CAM_ON_A_STRING)
+ switchPedToCar = true;
+ }
+//
+
+ if(Cams[ActiveCam].Mode == CCam::MODE_SYPHON_CRIM_IN_FRONT && newMode == CCam::MODE_SYPHON)
+ switchSyphonMode = true;
+ if(Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM && newMode == CCam::MODE_FOLLOWPED)
+ switchPedMode = true;
+ if(Cams[ActiveCam].Mode == CCam::MODE_FIXED)
+ switchFromFixed = true;
+
+ m_bUseTransitionBeta = false;
+
+ if((Cams[ActiveCam].Mode == CCam::MODE_SNIPER ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_SNIPER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ Cams[ActiveCam].Mode == CCam::MODE_HELICANNON_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON_RUNABOUT) &&
+ pTargetEntity->IsPed()){
+ float angle = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) - HALFPI;
+ ((CPed*)pTargetEntity)->m_fRotationCur = angle;
+ ((CPed*)pTargetEntity)->m_fRotationDest = angle;
+ }
+
+/* // PS2
+ ActiveCam = (ActiveCam+1)%2;
+ Cams[ActiveCam].Init();
+ Cams[ActiveCam].Mode = newMode;
+ */
+
+ Cams[ActiveCam].m_cvecCamFixedModeVector = m_vecFixedModeVector;
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ Cams[ActiveCam].m_cvecCamFixedModeSource = m_vecFixedModeSource;
+ Cams[ActiveCam].m_cvecCamFixedModeUpOffSet = m_vecFixedModeUpOffSet;
+ Cams[ActiveCam].m_bCamLookingAtVector = m_bLookingAtVector;
+
+ if(newMode == CCam::MODE_SNIPER ||
+ newMode == CCam::MODE_ROCKETLAUNCHER ||
+ newMode == CCam::MODE_M16_1STPERSON ||
+ newMode == CCam::MODE_SNIPER_RUNABOUT ||
+ newMode == CCam::MODE_ROCKETLAUNCHER_RUNABOUT ||
+ newMode == CCam::MODE_1STPERSON_RUNABOUT ||
+ newMode == CCam::MODE_M16_1STPERSON_RUNABOUT ||
+ newMode == CCam::MODE_FIGHT_CAM_RUNABOUT ||
+ newMode == CCam::MODE_HELICANNON_1STPERSON)
+ Cams[ActiveCam].Alpha = 0.0f;
+
+ // PS2 also copies values to ActiveCam here
+ switch(Cams[ActiveCam].Mode)
+ case CCam::MODE_SNIPER_RUNABOUT:
+ case CCam::MODE_ROCKETLAUNCHER_RUNABOUT:
+ case CCam::MODE_1STPERSON_RUNABOUT:
+ case CCam::MODE_M16_1STPERSON_RUNABOUT:
+ case CCam::MODE_FIGHT_CAM_RUNABOUT:
+ if(newMode == CCam::MODE_CAM_ON_A_STRING || newMode == CCam::MODE_BEHINDBOAT)
+ switch1stPersonToVehicle = true;
+
+ switch(newMode){
+ case CCam::MODE_BEHINDCAR:
+ Cams[ActiveCam].BetaSpeed = 0.0f;
+ break;
+
+ case CCam::MODE_FOLLOWPED:
+ // Getting out of vehicle normally
+ betaOffset = DEGTORAD(55.0f);
+ if(m_bJustCameOutOfGarage){
+ m_bUseTransitionBeta = true;
+/*
+ // weird logic...
+ if(CMenuManager::m_ControlMethod == CONTROL_CLASSIC)
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) + PI;
+ else if(Cams[ActiveCam].Front.x != 0.0f && Cams[ActiveCam].Front.y != 0.0f) // && is wrong here
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) + PI;
+ else
+ Cams[ActiveCam].m_fTransitionBeta = 0.0f;
+*/
+ // this is better:
+ if(Cams[ActiveCam].Front.x != 0.0f || Cams[ActiveCam].Front.y != 0.0f)
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y) + PI;
+ else
+ Cams[ActiveCam].m_fTransitionBeta = 0.0f;
+ }
+ if(m_bTargetJustCameOffTrain)
+ m_bCamDirectlyInFront = true;
+ if(Cams[ActiveCam].Mode != CCam::MODE_CAM_ON_A_STRING)
+ break;
+ m_bUseTransitionBeta = true;
+ vehicleVertical = false;
+ if(((CPed*)pTargetEntity)->m_carInObjective &&
+ ((CPed*)pTargetEntity)->m_carInObjective->GetForward().x == 0.0f &&
+ ((CPed*)pTargetEntity)->m_carInObjective->GetForward().y == 0.0f)
+ vehicleVertical = true;
+ if(vehicleVertical){
+ Cams[ActiveCam].m_fTransitionBeta = 0.0f;
+ break;
+ }
+ camBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+ if(((CPed*)pTargetEntity)->m_carInObjective)
+ targetBeta = CGeneral::GetATanOfXY(((CPed*)pTargetEntity)->m_carInObjective->GetForward().x, ((CPed*)pTargetEntity)->m_carInObjective->GetForward().y);
+ else
+ targetBeta = camBeta;
+ deltaBeta = targetBeta - camBeta;
+ while(deltaBeta >= PI) deltaBeta -= 2*PI;
+ while(deltaBeta < -PI) deltaBeta += 2*PI;
+ deltaBeta = Abs(deltaBeta);
+
+ door = FindPlayerPed()->m_vehEnterType;
+ if(deltaBeta > HALFPI){
+ if(((CPed*)pTargetEntity)->m_carInObjective){
+ if(((CPed*)pTargetEntity)->m_carInObjective->IsUpsideDown()){
+ if(door == CAR_DOOR_LF || door == CAR_DOOR_LR)
+ betaOffset = -DEGTORAD(95.0f);
+ }else{
+ if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = -DEGTORAD(95.0f);
+ }
+ }
+ Cams[ActiveCam].m_fTransitionBeta = targetBeta + betaOffset;
+ }else{
+ if(((CPed*)pTargetEntity)->m_carInObjective){
+ if(((CPed*)pTargetEntity)->m_carInObjective->IsUpsideDown()){
+ if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = -DEGTORAD(55.0f);
+ else if(door == CAR_DOOR_LF || door == CAR_DOOR_LR)
+ betaOffset = DEGTORAD(95.0f);
+ }else{
+ if(door == CAR_DOOR_LF || door == CAR_DOOR_LR)
+ betaOffset = -DEGTORAD(55.0f);
+ else if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = DEGTORAD(95.0f);
+ }
+ }
+ Cams[ActiveCam].m_fTransitionBeta = targetBeta + betaOffset + PI;
+ }
+ break;
+
+ case CCam::MODE_SNIPER:
+ case CCam::MODE_ROCKETLAUNCHER:
+ case CCam::MODE_M16_1STPERSON:
+ case CCam::MODE_SNIPER_RUNABOUT:
+ case CCam::MODE_ROCKETLAUNCHER_RUNABOUT:
+ case CCam::MODE_1STPERSON_RUNABOUT:
+ case CCam::MODE_M16_1STPERSON_RUNABOUT:
+ case CCam::MODE_FIGHT_CAM_RUNABOUT:
+ case CCam::MODE_HELICANNON_1STPERSON:
+ if(FindPlayerVehicle())
+ Cams[ActiveCam].Beta = Atan2(FindPlayerVehicle()->GetForward().x, FindPlayerVehicle()->GetForward().y);
+ else
+ Cams[ActiveCam].Beta = Atan2(PLAYER->GetForward().x, PLAYER->GetForward().y);
+ break;
+
+ case CCam::MODE_SYPHON:
+ Cams[ActiveCam].Alpha = 0.0f;
+ Cams[ActiveCam].AlphaSpeed = 0.0f;
+ break;
+
+ case CCam::MODE_CAM_ON_A_STRING:
+ // Get into vehicle
+ betaOffset = DEGTORAD(57.0f);
+ if(!m_bLookingAtPlayer || m_bJustCameOutOfGarage)
+ break;
+ m_bUseTransitionBeta = true;
+ targetBeta = CGeneral::GetATanOfXY(pTargetEntity->GetForward().x, pTargetEntity->GetForward().y);
+ camBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+ deltaBeta = targetBeta - camBeta;
+ while(deltaBeta >= PI) deltaBeta -= 2*PI;
+ while(deltaBeta < -PI) deltaBeta += 2*PI;
+ deltaBeta = Abs(deltaBeta);
+ // switchFromFixed logic again here, skipped
+ if(switchFromFixed){
+ Cams[ActiveCam].m_fTransitionBeta = CGeneral::GetATanOfXY(Cams[ActiveCam].Front.x, Cams[ActiveCam].Front.y);
+ break;
+ }
+
+ door = FindPlayerPed()->m_vehEnterType;
+ if(deltaBeta > HALFPI){
+ if(((CVehicle*)pTargetEntity)->IsUpsideDown()){
+ if(door == CAR_DOOR_LF || door == CAR_DOOR_LR) // BUG: game checks LF twice
+ betaOffset = -DEGTORAD(57.0f);
+ }else{
+ if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = -DEGTORAD(57.0f);
+ }
+ Cams[ActiveCam].m_fTransitionBeta = targetBeta + betaOffset + PI;
+ }else{
+ if(((CVehicle*)pTargetEntity)->IsUpsideDown()){
+ if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = -DEGTORAD(57.0f);
+ else if(door == CAR_DOOR_LF || door == CAR_DOOR_LR)
+ betaOffset = DEGTORAD(57.0f);
+ }else{
+ if(door == CAR_DOOR_LF || door == CAR_DOOR_LR)
+ betaOffset = -DEGTORAD(57.0f);
+ else if(door == CAR_DOOR_RF || door == CAR_DOOR_RR)
+ betaOffset = DEGTORAD(57.0f);
+ }
+ Cams[ActiveCam].m_fTransitionBeta = targetBeta + betaOffset;
+ }
+ break;
+
+ case CCam::MODE_BEHINDBOAT:
+ Cams[ActiveCam].BetaSpeed = 0.0f;
+ break;
+
+ case CCam::MODE_PED_DEAD_BABY:
+ Cams[ActiveCam].Alpha = DEGTORAD(15.0f);
+ break;
+
+ case CCam::MODE_FIGHT_CAM:
+ Cams[ActiveCam].Beta = 0.0f;
+ Cams[ActiveCam].BetaSpeed = 0.0f;
+ Cams[ActiveCam].Alpha = 0.0f;
+ Cams[ActiveCam].AlphaSpeed = 0.0f;
+ break;
+ }
+
+ Cams[ActiveCam].Init();
+ Cams[ActiveCam].Mode = newMode;
+
+ m_uiTransitionDuration = 1350;
+ if(switchSyphonMode)
+ m_uiTransitionDuration = 1800;
+ else if(switchPedMode)
+ m_uiTransitionDuration = 750;
+// not on PS2
+ else if(switchPedToCar){
+ m_fFractionInterToStopMovingTarget = 0.2f;
+ m_fFractionInterToStopCatchUpTarget = 0.8f;
+ m_uiTransitionDuration = 950;
+ }else if(switchFromFixed){
+ m_fFractionInterToStopMovingTarget = 0.05f;
+ m_fFractionInterToStopCatchUpTarget = 0.95f;
+ }else if(switch1stPersonToVehicle){
+ m_fFractionInterToStopMovingTarget = 0.0f;
+ m_fFractionInterToStopCatchUpTarget = 1.0f;
+ m_uiTransitionDuration = 1;
+ }else
+ m_uiTransitionDuration = 1350; // already set above
+//
+ m_uiTransitionState = 1;
+ m_uiTimeTransitionStart = CTimer::GetTimeInMilliseconds();
+ m_uiTransitionJUSTStarted = 1;
+// PS2 returns here
+ if(m_vecDoingSpecialInterPolation){
+ m_cvecStartingSourceForInterPol = SourceDuringInter;
+ m_cvecStartingTargetForInterPol = TargetDuringInter;
+ m_cvecStartingUpForInterPol = UpDuringInter;
+ m_fStartingAlphaForInterPol = m_fAlphaDuringInterPol;
+ m_fStartingBetaForInterPol = m_fBetaDuringInterPol;
+ }else{
+ m_cvecStartingSourceForInterPol = Cams[ActiveCam].Source;
+ m_cvecStartingTargetForInterPol = Cams[ActiveCam].m_cvecTargetCoorsForFudgeInter;
+ m_cvecStartingUpForInterPol = Cams[ActiveCam].Up;
+ m_fStartingAlphaForInterPol = Cams[ActiveCam].m_fTrueAlpha;
+ m_fStartingBetaForInterPol = Cams[ActiveCam].m_fTrueBeta;
+ }
+ Cams[ActiveCam].m_bCamLookingAtVector = m_bLookingAtVector;
+ Cams[ActiveCam].m_cvecCamFixedModeVector = m_vecFixedModeVector;
+ Cams[ActiveCam].m_cvecCamFixedModeSource = m_vecFixedModeSource;
+ Cams[ActiveCam].m_cvecCamFixedModeUpOffSet = m_vecFixedModeUpOffSet;
+ Cams[ActiveCam].Mode = newMode; // already done above
+ Cams[ActiveCam].CamTargetEntity = pTargetEntity;
+ m_uiTransitionState = 1; // these three already done above
+ m_uiTimeTransitionStart = CTimer::GetTimeInMilliseconds();
+ m_uiTransitionJUSTStarted = 1;
+ m_fStartingFOVForInterPol = Cams[ActiveCam].FOV;
+ m_cvecSourceSpeedAtStartInter = Cams[ActiveCam].m_cvecSourceSpeedOverOneFrame;
+ m_cvecTargetSpeedAtStartInter = Cams[ActiveCam].m_cvecTargetSpeedOverOneFrame;
+ m_cvecUpSpeedAtStartInter = Cams[ActiveCam].m_cvecUpOverOneFrame;
+ m_fAlphaSpeedAtStartInter = Cams[ActiveCam].m_fAlphaSpeedOverOneFrame;
+ m_fBetaSpeedAtStartInter = Cams[ActiveCam].m_fBetaSpeedOverOneFrame;
+ m_fFOVSpeedAtStartInter = Cams[ActiveCam].m_fFovSpeedOverOneFrame;
+ Cams[ActiveCam].ResetStatics = true;
+ if(!m_bLookingAtPlayer && m_bScriptParametersSetForInterPol){
+ m_fFractionInterToStopMovingTarget = m_fScriptPercentageInterToStopMoving;
+ m_fFractionInterToStopCatchUpTarget = m_fScriptPercentageInterToCatchUp;
+ m_uiTransitionDuration = m_fScriptTimeForInterPolation;
+ }
}
void
-CCamera::ClearPlayerWeaponMode()
+CCamera::StartTransitionWhenNotFinishedInter(int16 mode)
{
- PlayerWeaponMode.Mode = 0;
- PlayerWeaponMode.MaxZoom = 1;
- PlayerWeaponMode.MinZoom = -1;
- PlayerWeaponMode.Duration = 0.0f;
+ m_vecDoingSpecialInterPolation = true;
+ StartTransition(mode);
}
-float
-CCamera::Find3rdPersonQuickAimPitch(void)
+void
+CCamera::StoreValuesDuringInterPol(CVector &source, CVector &target, CVector &up, float &FOV)
{
- float clampedFrontZ = clamp(Cams[ActiveCam].Front.z, -1.0f, 1.0f);
+ SourceDuringInter = source;
+ TargetDuringInter = target;
+ UpDuringInter = up;
+ FOVDuringInter = FOV;
+ CVector Dist = source - TargetDuringInter;
+ float DistOnGround = Dist.Magnitude2D();
+ m_fBetaDuringInterPol = CGeneral::GetATanOfXY(Dist.x, Dist.y);
+ m_fAlphaDuringInterPol = CGeneral::GetATanOfXY(DistOnGround, Dist.z);
+}
- // float rot = atan2(clampedFrontZ, sqrt(1.0f - sq(clampedFrontZ)));
- float rot = Asin(clampedFrontZ);
- return -(DEGTORAD(((0.5f - m_f3rdPersonCHairMultY) * 1.8f * 0.5f * Cams[ActiveCam].FOV)) + rot);
+
+void
+CCamera::SetWideScreenOn(void)
+{
+ m_WideScreenOn = true;
}
void
-CCamera::SetCamCutSceneOffSet(const CVector &pos)
+CCamera::SetWideScreenOff(void)
{
- m_vecCutSceneOffset = pos;
-};
+ m_bWantsToSwitchWidescreenOff = m_WideScreenOn;
+}
void
-CCamera::TakeControlWithSpline(short nSwitch)
+CCamera::ProcessWideScreenOn(void)
{
- m_iModeToGoTo = CCam::MODE_FLYBY;
- m_bLookingAtPlayer = false;
- m_bLookingAtVector = false;
- m_bcutsceneFinished = false;
- m_iTypeOfSwitch = nSwitch;
- m_bStartInterScript = true;
+ if(m_bWantsToSwitchWidescreenOff){
+ m_bWantsToSwitchWidescreenOff = false;
+ m_WideScreenOn = false;
+ m_ScreenReductionPercentage = 0.0f;
+ m_fFOV_Wide_Screen = 0.0f;
+ m_fWideScreenReductionAmount = 0.0f;
+ }else{
+ m_fFOV_Wide_Screen = 0.3f*Cams[ActiveCam].FOV;
+ m_fWideScreenReductionAmount = 1.0f;
+ m_ScreenReductionPercentage = 30.0f;
+ }
+}
- //FindPlayerPed(); // unused
-};
+void
+CCamera::DrawBordersForWideScreen(void)
+{
+ if(m_BlurType == MBLUR_NONE || m_BlurType == MBLUR_NORMAL)
+ SetMotionBlurAlpha(80);
+
+ CSprite2d::DrawRect(
+ CRect(0.0f, (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - 8.0f,
+ SCREEN_WIDTH, 0.0f),
+ CRGBA(0, 0, 0, 255));
-void CCamera::SetCameraDirectlyInFrontForFollowPed_CamOnAString()
+ CSprite2d::DrawRect(
+ CRect(0.0f, SCREEN_HEIGHT,
+ SCREEN_WIDTH, SCREEN_HEIGHT - (SCREEN_HEIGHT/2) * m_ScreenReductionPercentage/100.0f - 8.0f),
+ CRGBA(0, 0, 0, 255));
+}
+
+
+
+bool
+CCamera::IsItTimeForNewcam(int32 obbeMode, int32 time)
{
- m_bCamDirectlyInFront = true;
- CPlayerPed *player = FindPlayerPed();
- if (player)
- m_PedOrientForBehindOrInFront = CGeneral::GetATanOfXY(player->GetForward().x, player->GetForward().y);
+ CVehicle *veh;
+ uint32 t = time; // no annoying compiler warnings
+ CVector fwd;
+
+ if(obbeMode < 0)
+ return true;
+ switch(obbeMode){
+ case OBBE_WHEEL:
+ veh = FindPlayerVehicle();
+ if(veh == nil){
+ if(CTimer::GetTimeInMilliseconds() > t+5000)
+ return true;
+ SetNearClipScript(0.6f);
+ return false;
+ }
+ if(veh->IsBoat() || veh->GetModelIndex() == MI_RHINO)
+ return true;
+ if(CWorld::GetIsLineOfSightClear(pTargetEntity->GetPosition(), Cams[ActiveCam].Source, true, false, false, false, false, false, false)){
+ if(CTimer::GetTimeInMilliseconds() > t+5000)
+ return true;
+ SetNearClipScript(0.6f);
+ return false;
+ }
+ return true;
+ case OBBE_1:
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return true;
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 20.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ // too close
+ if(fwd.Magnitude() < 1.6f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_2:
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return true;
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ if(fwd.Magnitude() < 2.0f)
+ // very close, fix near clip
+ SetNearClipScript(max(fwd.Magnitude()*0.5f, 0.05f));
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 19.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ // too close
+ if(fwd.Magnitude() < 1.6f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_3:
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 28.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_1STPERSON:
+ return CTimer::GetTimeInMilliseconds() > t+3000;
+ case OBBE_5:
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return true;
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 28.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_ONSTRING:
+ return CTimer::GetTimeInMilliseconds() > t+3000;
+ case OBBE_COPCAR:
+ return CTimer::GetTimeInMilliseconds() > t+2000 && !FindPlayerVehicle()->GetIsOnScreen();
+ case OBBE_COPCAR_WHEEL:
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return true;
+ if(CWorld::GetIsLineOfSightClear(pTargetEntity->GetPosition(), Cams[ActiveCam].Source, true, false, false, false, false, false, false)){
+ if(CTimer::GetTimeInMilliseconds() > t+1000)
+ return true;
+ SetNearClipScript(0.6f);
+ return false;
+ }
+ return true;
+
+ // Ped modes
+ case OBBE_9:
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 20.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_10:
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 8.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_11:
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 25.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_12:
+ if(CWorld::GetIsLineOfSightClear(FindPlayerCoors(), m_vecFixedModeSource, true, false, false, false, false, false, false)){
+ fwd = FindPlayerCoors() - m_vecFixedModeSource;
+ fwd.z = 0.0f;
+
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 8.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return true;
+ return false;
+ }
+ return true;
+ case OBBE_13:
+ return CTimer::GetTimeInMilliseconds() > t+5000;
+ default:
+ return false;
+ }
}
-void CCamera::SetCameraDirectlyBehindForFollowPed_CamOnAString()
+bool
+CCamera::TryToStartNewCamMode(int obbeMode)
{
- m_bCamDirectlyBehind = true;
- CPlayerPed *player = FindPlayerPed();
- if (player)
- m_PedOrientForBehindOrInFront = CGeneral::GetATanOfXY(player->GetForward().x, player->GetForward().y);
+ CVehicle *veh;
+ CVector target, camPos, playerSpeed, fwd;
+ float ground;
+ bool foundGround;
+ int i;
+
+ if(obbeMode < 0)
+ return true;
+ switch(obbeMode){
+ case OBBE_WHEEL:
+ veh = FindPlayerVehicle();
+ if(veh == nil || veh->IsBoat() || veh->GetModelIndex() == MI_RHINO)
+ return false;
+ target = Multiply3x3(FindPlayerVehicle()->GetMatrix(), CVector(-1.4f, -2.3f, 0.3f));
+ target += FindPlayerVehicle()->GetPosition();
+ if(!CWorld::GetIsLineOfSightClear(veh->GetPosition(), target, true, false, false, false, false, false, false))
+ return false;
+ TakeControl(veh, CCam::MODE_WHEELCAM, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_1:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 20.0f*playerSpeed;
+ camPos += 3.0f*CVector(playerSpeed.y, -playerSpeed.x, 0.0f);
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return false;
+
+ ground = CWorld::FindGroundZFor3DCoord(camPos.x, camPos.y, camPos.z+5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 1.5f;
+ else{
+ ground = CWorld::FindRoofZFor3DCoord(camPos.x, camPos.y, camPos.z-5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 1.5f;
+ }
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ fwd = FindPlayerCoors() - camPos;
+ fwd.z = 0.0f;
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 20.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return false;
+ // too close
+ if(fwd.Magnitude() < 1.6f)
+ return true;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_2:
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return false;
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 16.0f*playerSpeed;
+ camPos += 2.5f*CVector(playerSpeed.y, -playerSpeed.x, 0.0f);
+
+ ground = CWorld::FindGroundZFor3DCoord(camPos.x, camPos.y, camPos.z+5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 0.5f;
+ else{
+ ground = CWorld::FindRoofZFor3DCoord(camPos.x, camPos.y, camPos.z-5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 0.5f;
+ }
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ fwd = FindPlayerCoors() - camPos;
+ fwd.z = 0.0f;
+ // too far and driving away from cam
+ if(fwd.Magnitude() > 19.0f && DotProduct(FindPlayerSpeed(), fwd) > 0.0f)
+ return false;
+ // too close
+ if(fwd.Magnitude() < 1.6f)
+ return true;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_3:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 30.0f*playerSpeed;
+ camPos += 8.0f*CVector(playerSpeed.y, -playerSpeed.x, 0.0f);
+
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_1STPERSON:
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_5:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 30.0f*playerSpeed;
+ camPos += 6.0f*CVector(playerSpeed.y, -playerSpeed.x, 0.0f);
+
+ ground = CWorld::FindGroundZFor3DCoord(camPos.x, camPos.y, camPos.z+5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 3.5f;
+ else{
+ ground = CWorld::FindRoofZFor3DCoord(camPos.x, camPos.y, camPos.z-5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 3.5f;
+ }
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_ONSTRING:
+ TakeControl(FindPlayerEntity(), CCam::MODE_CAM_ON_A_STRING, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_COPCAR:
+ if(FindPlayerPed()->m_pWanted->m_nWantedLevel < 1)
+ return false;
+ if(FindPlayerVehicle() == nil)
+ return false;
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return false;
+ i = CPools::GetVehiclePool()->GetSize();
+ while(--i >= 0){
+ veh = CPools::GetVehiclePool()->GetSlot(i);
+ if(veh && veh->IsCar() && veh != FindPlayerVehicle() && veh->bIsLawEnforcer){
+ float dx = veh->GetPosition().x - FindPlayerCoors().x;
+ float dy = veh->GetPosition().y - FindPlayerCoors().y;
+ float dist = (veh->GetPosition() - FindPlayerCoors()).Magnitude();
+ if(dist < 30.0f){
+ if(dx*FindPlayerVehicle()->GetForward().x + dy*FindPlayerVehicle()->GetForward().y < 0.0f &&
+ veh->GetForward().x*FindPlayerVehicle()->GetForward().x + veh->GetForward().y*FindPlayerVehicle()->GetForward().y > 0.8f){
+ TakeControl(veh, CCam::MODE_CAM_ON_A_STRING, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ case OBBE_COPCAR_WHEEL:
+ if(FindPlayerPed()->m_pWanted->m_nWantedLevel < 1)
+ return false;
+ if(FindPlayerVehicle() == nil)
+ return false;
+ if(FindPlayerVehicle() && FindPlayerVehicle()->IsBoat())
+ return false;
+ i = CPools::GetVehiclePool()->GetSize();
+ while(--i >= 0){
+ veh = CPools::GetVehiclePool()->GetSlot(i);
+ if(veh && veh->IsCar() && veh != FindPlayerVehicle() && veh->bIsLawEnforcer){
+ float dx = veh->GetPosition().x - FindPlayerCoors().x;
+ float dy = veh->GetPosition().y - FindPlayerCoors().y;
+ float dist = (veh->GetPosition() - FindPlayerCoors()).Magnitude();
+ if(dist < 30.0f){
+ if(dx*FindPlayerVehicle()->GetForward().x + dy*FindPlayerVehicle()->GetForward().y < 0.0f &&
+ veh->GetForward().x*FindPlayerVehicle()->GetForward().x + veh->GetForward().y*FindPlayerVehicle()->GetForward().y > 0.8f){
+ target = Multiply3x3(veh->GetMatrix(), CVector(-1.4f, -2.3f, 0.3f));
+ target += veh->GetPosition();
+ if(!CWorld::GetIsLineOfSightClear(veh->GetPosition(), target, true, false, false, false, false, false, false))
+ return false;
+ TakeControl(veh, CCam::MODE_WHEELCAM, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+
+ case OBBE_9:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 15.0f*playerSpeed;
+ camPos += CVector(2.0f, 1.0f, 0.0f);
+
+ ground = CWorld::FindGroundZFor3DCoord(camPos.x, camPos.y, camPos.z+5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 0.5f;
+ else{
+ ground = CWorld::FindRoofZFor3DCoord(camPos.x, camPos.y, camPos.z-5.0f, &foundGround);
+ if(foundGround)
+ camPos.z = ground + 0.5f;
+ }
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_10:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 5.0f*playerSpeed;
+ camPos += CVector(2.0f, 1.0f, 0.5f);
+
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_11:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 20.0f*playerSpeed;
+ camPos += CVector(2.0f, 1.0f, 20.0f);
+
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_12:
+ camPos = FindPlayerCoors();
+ playerSpeed = FindPlayerSpeed();
+ playerSpeed.z = 0.0f;
+ playerSpeed.Normalise();
+ camPos += 5.0f*playerSpeed;
+ camPos += CVector(2.0f, 1.0f, 10.5f);
+
+ if(!CWorld::GetIsLineOfSightClear(FindPlayerCoors(), camPos, true, false, false, false, false, false, false))
+ return false;
+
+ SetCamPositionForFixedMode(camPos, CVector(0.0f, 0.0f, 0.0f));
+ TakeControl(FindPlayerEntity(), CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_OBBE);
+ return true;
+ case OBBE_13:
+#ifdef FIX_BUGS
+ TakeControl(FindPlayerEntity(), CCam::MODE_TOP_DOWN_PED, JUMP_CUT, CAMCONTROL_OBBE);
+#else
+ TakeControl(FindPlayerEntity(), CCam::MODE_TOPDOWN, JUMP_CUT, CAMCONTROL_OBBE);
+#endif
+ return true;
+ default:
+ return false;
+ }
}
+static int32 SequenceOfCams[16] = {
+ OBBE_WHEEL, OBBE_COPCAR, OBBE_3, OBBE_1, OBBE_3, OBBE_COPCAR_WHEEL,
+ OBBE_2, OBBE_3, OBBE_COPCAR_WHEEL, OBBE_COPCAR, OBBE_2, OBBE_3,
+ OBBE_5, OBBE_3,
+ OBBE_ONSTRING // actually unused...
+};
+
void
-CCamera::SetWideScreenOn(void)
+CCamera::ProcessObbeCinemaCameraCar(void)
{
- m_WideScreenOn = true;
+ static int OldMode = -1;
+ static int32 TimeForNext = 0;
+ int i = 0;
+
+ if(!bDidWeProcessAnyCinemaCam){
+ OldMode = -1;
+ CHud::SetHelpMessage(TheText.Get("CINCAM"), true);
+ }
+
+ if(!bDidWeProcessAnyCinemaCam || IsItTimeForNewcam(SequenceOfCams[OldMode], TimeForNext)){
+ // This is very strange code...
+ for(OldMode = (OldMode+1) % 14;
+ !TryToStartNewCamMode(SequenceOfCams[OldMode]) && i <= 14;
+ OldMode = (OldMode+1) % 14)
+ i++;
+ TimeForNext = CTimer::GetTimeInMilliseconds();
+ if(i >= 14){
+ OldMode = 14;
+ TryToStartNewCamMode(SequenceOfCams[14]);
+ }
+ }
+
+ m_iModeObbeCamIsInForCar = OldMode;
+ bDidWeProcessAnyCinemaCam = true;
}
+static int32 SequenceOfPedCams[5] = { OBBE_9, OBBE_10, OBBE_11, OBBE_12, OBBE_13 };
+
void
-CCamera::SetWideScreenOff(void)
+CCamera::ProcessObbeCinemaCameraPed(void)
{
- m_bWantsToSwitchWidescreenOff = m_WideScreenOn;
+ // static bool bObbePedProcessed = false; // unused
+ static int PedOldMode = -1;
+ static int32 PedTimeForNext = 0;
+
+ if(!bDidWeProcessAnyCinemaCam)
+ PedOldMode = -1;
+
+ if(!bDidWeProcessAnyCinemaCam || IsItTimeForNewcam(SequenceOfPedCams[PedOldMode], PedTimeForNext)){
+ for(PedOldMode = (PedOldMode+1) % 5;
+ !TryToStartNewCamMode(SequenceOfPedCams[PedOldMode]);
+ PedOldMode = (PedOldMode+1) % 5);
+ PedTimeForNext = CTimer::GetTimeInMilliseconds();
+ }
+ bDidWeProcessAnyCinemaCam = true;
}
void
-CCamera::SetNewPlayerWeaponMode(int16 mode, int16 minZoom, int16 maxZoom)
+CCamera::DontProcessObbeCinemaCamera(void)
{
- PlayerWeaponMode.Mode = mode;
- PlayerWeaponMode.MaxZoom = maxZoom;
- PlayerWeaponMode.MinZoom = minZoom;
- PlayerWeaponMode.Duration = 0.0f;
+ bDidWeProcessAnyCinemaCam = false;
}
+
void
-CCamera::UpdateAimingCoors(CVector const &coors)
+CCamera::LoadTrainCamNodes(char const *name)
{
- m_cvecAimingTargetCoors = coors;
+ CFileMgr::SetDir("data");
+
+ char token[16] = { 0 };
+ char filename[16] = { 0 };
+ uint8 *buf;
+ int bufpos = 0;
+ int field = 0;
+ int tokpos = 0;
+ char c;
+ int i;
+ int len;
+
+ strcpy(filename, name);
+ len = strlen(filename);
+ filename[len] = '.';
+ filename[len+1] = 'd';
+ filename[len+2] = 'a';
+ filename[len+3] = 't';
+
+ m_uiNumberOfTrainCamNodes = 0;
+
+ buf = new uint8[20000];
+ len = CFileMgr::LoadFile(filename, buf, 20000, "r");
+
+ for(i = 0; i < MAX_NUM_OF_NODES; i++){
+ m_arrTrainCamNode[i].m_cvecPointToLookAt = CVector(0.0f, 0.0f, 0.0f);
+ m_arrTrainCamNode[i].m_cvecMinPointInRange = CVector(0.0f, 0.0f, 0.0f);
+ m_arrTrainCamNode[i].m_cvecMaxPointInRange = CVector(0.0f, 0.0f, 0.0f);
+ m_arrTrainCamNode[i].m_fDesiredFOV = 0.0f;
+ m_arrTrainCamNode[i].m_fNearClip = 0.0f;
+ }
+
+ while(bufpos <= len){
+ c = buf[bufpos];
+ switch(c){
+ case '-':
+ case '.':
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+// case '10': case '11': case '12': case '13': // ahem...
+ token[tokpos++] = c;
+ bufpos++;
+ break;
+
+ case ',':
+ case ';': // game has the code for this duplicated but we handle both under the same case
+ switch((field+14)%14){
+ case 0:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecCamPosition.x = atof(token);
+ break;
+ case 1:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecCamPosition.y = atof(token);
+ break;
+ case 2:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecCamPosition.z = atof(token);
+ break;
+ case 3:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecPointToLookAt.x = atof(token);
+ break;
+ case 4:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecPointToLookAt.y = atof(token);
+ break;
+ case 5:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecPointToLookAt.z = atof(token);
+ break;
+ case 6:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMinPointInRange.x = atof(token);
+ break;
+ case 7:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMinPointInRange.y = atof(token);
+ break;
+ case 8:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMinPointInRange.z = atof(token);
+ break;
+ case 9:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMaxPointInRange.x = atof(token);
+ break;
+ case 10:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMaxPointInRange.y = atof(token);
+ break;
+ case 11:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_cvecMaxPointInRange.z = atof(token);
+ break;
+ case 12:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_fDesiredFOV = atof(token);
+ break;
+ case 13:
+ m_arrTrainCamNode[m_uiNumberOfTrainCamNodes].m_fNearClip = atof(token);
+ m_uiNumberOfTrainCamNodes++;
+ break;
+ }
+ field++;
+ bufpos++;
+ memset(token, 0, sizeof(token));
+ tokpos = 0;
+ break;
+
+ default:
+ bufpos++;
+ break;
+ }
+ }
+
+ delete[] buf;
+ CFileMgr::SetDir("");
}
void
-CCamera::SetCamPositionForFixedMode(const CVector &Source, const CVector &UpOffSet)
+CCamera::Process_Train_Camera_Control(void)
{
- m_vecFixedModeSource = Source;
- m_vecFixedModeUpOffSet = UpOffSet;
+ bool found = false;
+ CTrain *target = (CTrain*)pTargetEntity;
+ m_bUseSpecialFovTrain = true;
+ static bool OKtoGoBackToNodeCam = true; // only ever set to true
+ uint32 i;
+
+ if(target->m_nTrackId == TRACK_ELTRAIN && !m_bAboveGroundTrainNodesLoaded){
+ m_bAboveGroundTrainNodesLoaded = true;
+ m_bBelowGroundTrainNodesLoaded = false;
+ LoadTrainCamNodes("Train");
+ m_uiTimeLastChange = CTimer::GetTimeInMilliseconds();
+ OKtoGoBackToNodeCam = true;
+ m_iCurrentTrainCamNode = 0;
+ }
+ if(target->m_nTrackId == TRACK_SUBWAY && !m_bBelowGroundTrainNodesLoaded){
+ m_bBelowGroundTrainNodesLoaded = true;
+ m_bAboveGroundTrainNodesLoaded = false;
+ LoadTrainCamNodes("Train2");
+ m_uiTimeLastChange = CTimer::GetTimeInMilliseconds();
+ OKtoGoBackToNodeCam = true;
+ m_iCurrentTrainCamNode = 0;
+ }
+
+ m_bTargetJustBeenOnTrain = true;
+ uint32 node = m_iCurrentTrainCamNode;
+ for(i = 0; i < m_uiNumberOfTrainCamNodes && !found; i++){
+ if(target->IsWithinArea(m_arrTrainCamNode[node].m_cvecMinPointInRange.x,
+ m_arrTrainCamNode[node].m_cvecMinPointInRange.y,
+ m_arrTrainCamNode[node].m_cvecMinPointInRange.z,
+ m_arrTrainCamNode[node].m_cvecMaxPointInRange.x,
+ m_arrTrainCamNode[node].m_cvecMaxPointInRange.y,
+ m_arrTrainCamNode[node].m_cvecMaxPointInRange.z)){
+ m_iCurrentTrainCamNode = node;
+ found = true;
+ }
+ node++;
+ if(node >= m_uiNumberOfTrainCamNodes)
+ node = 0;
+ }
+
+ if(found){
+ SetWideScreenOn();
+ if(DotProduct(((CTrain*)pTargetEntity)->GetMoveSpeed(), pTargetEntity->GetForward()) < 0.001f){
+ TakeControl(FindPlayerPed(), CCam::MODE_FOLLOWPED, JUMP_CUT, CAMCONTROL_SCRIPT);
+ if(target->Doors[0].IsFullyOpen())
+ SetWideScreenOff();
+ }else{
+ SetCamPositionForFixedMode(m_arrTrainCamNode[m_iCurrentTrainCamNode].m_cvecCamPosition, CVector(0.0f, 0.0f, 0.0f));
+ if(m_arrTrainCamNode[m_iCurrentTrainCamNode].m_cvecPointToLookAt.x == 999.0f &&
+ m_arrTrainCamNode[m_iCurrentTrainCamNode].m_cvecPointToLookAt.y == 999.0f &&
+ m_arrTrainCamNode[m_iCurrentTrainCamNode].m_cvecPointToLookAt.z == 999.0f)
+ TakeControl(target, CCam::MODE_FIXED, JUMP_CUT, CAMCONTROL_SCRIPT);
+ else
+ TakeControlNoEntity(m_arrTrainCamNode[m_iCurrentTrainCamNode].m_cvecPointToLookAt, JUMP_CUT, CAMCONTROL_SCRIPT);
+ RwCameraSetNearClipPlane(Scene.camera, m_arrTrainCamNode[m_iCurrentTrainCamNode].m_fNearClip);
+ }
+ }else{
+ if(DotProduct(((CTrain*)pTargetEntity)->GetMoveSpeed(), pTargetEntity->GetForward()) < 0.001f){
+ TakeControl(FindPlayerPed(), CCam::MODE_FOLLOWPED, JUMP_CUT, CAMCONTROL_SCRIPT);
+ if(target->Doors[0].IsFullyOpen())
+ SetWideScreenOff();
+ }
+ }
}
+
+
void
-CCamera::SetRwCamera(RwCamera *cam)
+CCamera::LoadPathSplines(int file)
{
- m_pRwCamera = cam;
- m_viewMatrix.Attach(&m_pRwCamera->viewMatrix, false);
- CMBlur::MotionBlurOpen(m_pRwCamera);
+ bool reading = true;
+ char c, token[32] = { 0 };
+ int i, j, n;
+
+ n = 0;
+
+ for(i = 0; i < MAX_NUM_OF_SPLINETYPES; i++)
+ for(j = 0; j < CCamPathSplines::MAXPATHLENGTH; j++)
+ m_arrPathArray[i].m_arr_PathData[j] = 0.0f;
+
+ m_bStartingSpline = false;
+
+ i = 0;
+ j = 0;
+ while(reading){
+ CFileMgr::Read(file, &c, 1);
+ switch(c){
+ case '\0':
+ reading = false;
+ break;
+
+ case '+': case '-': case '.':
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ case 'e': case 'E':
+ token[n++] = c;
+ break;
+
+ case ',':
+#ifdef FIX_BUGS
+ if(i < MAX_NUM_OF_SPLINETYPES && j < CCamPathSplines::MAXPATHLENGTH)
+#endif
+ m_arrPathArray[i].m_arr_PathData[j] = atof(token);
+ j++;
+ memset(token, 0, 32);
+ n = 0;
+ break;
+
+ case ';':
+#ifdef FIX_BUGS
+ if(i < MAX_NUM_OF_SPLINETYPES && j < CCamPathSplines::MAXPATHLENGTH)
+#endif
+ m_arrPathArray[i].m_arr_PathData[j] = atof(token);
+ i++;
+ j = 0;
+ memset(token, 0, 32);
+ n = 0;
+ }
+ }
+}
+
+void
+CCamera::FinishCutscene(void)
+{
+ SetPercentAlongCutScene(100.0f);
+ m_fPositionAlongSpline = 1.0f;
+ m_bcutsceneFinished = true;
}
uint32
@@ -291,17 +2917,33 @@ CCamera::GetCutSceneFinishTime(void)
}
void
-CCamera::FinishCutscene(void)
+CCamera::SetCamCutSceneOffSet(const CVector &pos)
{
- SetPercentAlongCutScene(100.0f);
- m_fPositionAlongSpline = 1.0f;
- m_bcutsceneFinished = true;
+ m_vecCutSceneOffset = pos;
+};
+
+void
+CCamera::SetPercentAlongCutScene(float percent)
+{
+ if(Cams[ActiveCam].Mode == CCam::MODE_FLYBY)
+ Cams[ActiveCam].m_fTimeElapsedFloat = percent/100.0f * Cams[ActiveCam].m_uiFinishTime;
+ else if(Cams[(ActiveCam+1)%2].Mode == CCam::MODE_FLYBY)
+ Cams[(ActiveCam+1)%2].m_fTimeElapsedFloat = percent/100.0f * Cams[(ActiveCam+1)%2].m_uiFinishTime;
}
void
-CCamera::SetZoomValueFollowPedScript(int16 mode)
+CCamera::SetParametersForScriptInterpolation(float stopMoving, float catchUp, int32 time)
{
- switch (mode) {
+ m_fScriptPercentageInterToStopMoving = stopMoving * 0.01f;
+ m_fScriptPercentageInterToCatchUp = catchUp * 0.01f;
+ m_fScriptTimeForInterPolation = time;
+ m_bScriptParametersSetForInterPol = true;
+}
+
+void
+CCamera::SetZoomValueFollowPedScript(int16 dist)
+{
+ switch (dist) {
case 0: m_fPedZoomValueScript = 0.25f; break;
case 1: m_fPedZoomValueScript = 1.5f; break;
case 2: m_fPedZoomValueScript = 2.9f; break;
@@ -312,9 +2954,9 @@ CCamera::SetZoomValueFollowPedScript(int16 mode)
}
void
-CCamera::SetZoomValueCamStringScript(int16 mode)
+CCamera::SetZoomValueCamStringScript(int16 dist)
{
- switch (mode) {
+ switch (dist) {
case 0: m_fCarZoomValueScript = 0.05f; break;
case 1: m_fCarZoomValueScript = 1.9f; break;
case 2: m_fCarZoomValueScript = 3.9f; break;
@@ -324,6 +2966,395 @@ CCamera::SetZoomValueCamStringScript(int16 mode)
m_bUseScriptZoomValueCar = true;
}
+void
+CCamera::SetNearClipScript(float clip)
+{
+ m_fNearClipScript = clip;
+ m_bUseNearClipScript = true;
+}
+
+
+
+void
+CCamera::ProcessFade(void)
+{
+ float fade = (CTimer::GetTimeInMilliseconds() - m_uiFadeTimeStarted)/1000.0f;
+ // Why even set CDraw::FadeValue if m_fFLOATingFade sets it anyway?
+ if(m_bFading){
+ if(m_iFadingDirection == FADE_IN){
+ if(m_fTimeToFadeOut != 0.0f){
+ m_fFLOATingFade = 255.0f - 255.0f*fade/m_fTimeToFadeOut;
+ if(m_fFLOATingFade <= 0.0f){
+ m_bFading = false;
+ CDraw::FadeValue = 0;
+ m_fFLOATingFade = 0.0f;
+ }
+ }else{
+ m_bFading = false;
+ CDraw::FadeValue = 0;
+ m_fFLOATingFade = 0.0f;
+ }
+ }else if(m_iFadingDirection == FADE_OUT){
+ if(m_fTimeToFadeOut != 0.0f){
+ m_fFLOATingFade = 255.0f*fade/m_fTimeToFadeOut;
+ if(m_fFLOATingFade >= 255.0f){
+ m_bFading = false;
+ CDraw::FadeValue = 255;
+ m_fFLOATingFade = 255.0f;
+ }
+ }else{
+ m_bFading = false;
+ CDraw::FadeValue = 255;
+ m_fFLOATingFade = 255.0f;
+ }
+ }
+ CDraw::FadeValue = m_fFLOATingFade;
+ }
+}
+
+void
+CCamera::ProcessMusicFade(void)
+{
+ float fade = (CTimer::GetTimeInMilliseconds() - m_uiFadeTimeStartedMusic)/1000.0f;
+ if(m_bMusicFading){
+ if(m_iMusicFadingDirection == FADE_IN){
+ if(m_fTimeToFadeMusic == 0.0f)
+ m_fTimeToFadeMusic = 1.0f;
+
+ m_fFLOATingFadeMusic = 255.0f*fade/m_fTimeToFadeMusic;
+ if(m_fFLOATingFadeMusic > 255.0f){
+ m_bMusicFading = false;
+ m_fFLOATingFadeMusic = 0.0f;
+ DMAudio.SetEffectsFadeVol(127);
+ DMAudio.SetMusicFadeVol(127);
+ }else{
+ DMAudio.SetEffectsFadeVol(m_fFLOATingFadeMusic/255.0f * 127);
+ DMAudio.SetMusicFadeVol(m_fFLOATingFadeMusic/255.0f * 127);
+ }
+ }else if(m_iMusicFadingDirection == FADE_OUT){
+ if(m_fTimeToFadeMusic == 0.0f)
+ m_fTimeToFadeMusic = 1.0f;
+
+ if(m_bMoveCamToAvoidGeom || StillToFadeOut){
+ m_fFLOATingFadeMusic = 256.0f;
+ m_bMoveCamToAvoidGeom = false;
+ }else
+ m_fFLOATingFadeMusic = 255.0f*fade/m_fTimeToFadeMusic;
+
+ if(m_fFLOATingFadeMusic > 255.0f){
+ m_bMusicFading = false;
+ m_fFLOATingFadeMusic = 255.0f;
+ DMAudio.SetEffectsFadeVol(0);
+ DMAudio.SetMusicFadeVol(0);
+ }else{
+ DMAudio.SetEffectsFadeVol(127 - m_fFLOATingFadeMusic/255.0f * 127);
+ DMAudio.SetMusicFadeVol(127 - m_fFLOATingFadeMusic/255.0f * 127);
+ }
+ }
+ }
+}
+
+void
+CCamera::Fade(float timeout, int16 direction)
+{
+ m_bFading = true;
+ m_iFadingDirection = direction;
+ m_fTimeToFadeOut = timeout;
+ m_uiFadeTimeStarted = CTimer::GetTimeInMilliseconds();
+ if(!m_bIgnoreFadingStuffForMusic){
+ m_bMusicFading = true;
+ m_iMusicFadingDirection = direction;
+ m_fTimeToFadeMusic = timeout;
+ m_uiFadeTimeStartedMusic = CTimer::GetTimeInMilliseconds();
+// Not on PS2
+ if(!m_bJustJumpedOutOf1stPersonBecauseOfTarget && m_iMusicFadingDirection == FADE_OUT){
+ unknown++;
+ if(unknown >= 2){
+ m_bJustJumpedOutOf1stPersonBecauseOfTarget = true;
+ unknown = 0;
+ }else
+ m_bMoveCamToAvoidGeom = true;
+ }
+ }
+}
+
+void
+CCamera::SetFadeColour(uint8 r, uint8 g, uint8 b)
+{
+ m_FadeTargetIsSplashScreen = r == 0 && g == 0 && b == 0;
+ CDraw::FadeRed = r;
+ CDraw::FadeGreen = g;
+ CDraw::FadeBlue = b;
+}
+
+bool
+CCamera::GetFading(void)
+{
+ return m_bFading;
+}
+
+int
+CCamera::GetFadingDirection(void)
+{
+ if(m_bFading)
+ return m_iFadingDirection == FADE_IN ? FADE_IN : FADE_OUT;
+ else
+ return FADE_NONE;
+}
+
+int
+CCamera::GetScreenFadeStatus(void)
+{
+ if(m_fFLOATingFade == 0.0f)
+ return FADE_0;
+ if(m_fFLOATingFade == 255.0f)
+ return FADE_2;
+ return FADE_1;
+}
+
+
+
+void
+CCamera::RenderMotionBlur(void)
+{
+ if(m_BlurType == 0)
+ return;
+
+ CMBlur::MotionBlurRender(m_pRwCamera,
+ m_BlurRed, m_BlurGreen, m_BlurBlue,
+ m_motionBlur, m_BlurType, m_imotionBlurAddAlpha);
+}
+
+void
+CCamera::SetMotionBlur(int r, int g, int b, int a, int type)
+{
+ m_BlurRed = r;
+ m_BlurGreen = g;
+ m_BlurBlue = b;
+ m_motionBlur = a;
+ m_BlurType = type;
+}
+
+void
+CCamera::SetMotionBlurAlpha(int a)
+{
+ m_imotionBlurAddAlpha = a;
+}
+
+
+
+int
+CCamera::GetLookDirection(void)
+{
+ if(Cams[ActiveCam].Mode == CCam::MODE_CAM_ON_A_STRING ||
+ Cams[ActiveCam].Mode == CCam::MODE_1STPERSON ||
+ Cams[ActiveCam].Mode == CCam::MODE_BEHINDBOAT ||
+ Cams[ActiveCam].Mode == CCam::MODE_FOLLOWPED)
+ return Cams[ActiveCam].DirectionWasLooking;
+ return LOOKING_FORWARD;;
+}
+
+bool
+CCamera::GetLookingForwardFirstPerson(void)
+{
+ return Cams[ActiveCam].Mode == CCam::MODE_1STPERSON &&
+ Cams[ActiveCam].DirectionWasLooking == LOOKING_FORWARD;
+}
+
+bool
+CCamera::GetLookingLRBFirstPerson(void)
+{
+ return Cams[ActiveCam].Mode == CCam::MODE_1STPERSON && Cams[ActiveCam].DirectionWasLooking != LOOKING_FORWARD;
+}
+
+void
+CCamera::SetCameraDirectlyBehindForFollowPed_CamOnAString(void)
+{
+ m_bCamDirectlyBehind = true;
+ CPlayerPed *player = FindPlayerPed();
+ if (player)
+ m_PedOrientForBehindOrInFront = CGeneral::GetATanOfXY(player->GetForward().x, player->GetForward().y);
+}
+
+void
+CCamera::SetCameraDirectlyInFrontForFollowPed_CamOnAString(void)
+{
+ m_bCamDirectlyInFront = true;
+ CPlayerPed *player = FindPlayerPed();
+ if (player)
+ m_PedOrientForBehindOrInFront = CGeneral::GetATanOfXY(player->GetForward().x, player->GetForward().y);
+}
+
+void
+CCamera::SetNewPlayerWeaponMode(int16 mode, int16 minZoom, int16 maxZoom)
+{
+ PlayerWeaponMode.Mode = mode;
+ PlayerWeaponMode.MaxZoom = maxZoom;
+ PlayerWeaponMode.MinZoom = minZoom;
+ PlayerWeaponMode.Duration = 0.0f;
+}
+
+void
+CCamera::ClearPlayerWeaponMode(void)
+{
+ PlayerWeaponMode.Mode = 0;
+ PlayerWeaponMode.MaxZoom = 1;
+ PlayerWeaponMode.MinZoom = -1;
+ PlayerWeaponMode.Duration = 0.0f;
+}
+
+void
+CCamera::UpdateAimingCoors(CVector const &coors)
+{
+ m_cvecAimingTargetCoors = coors;
+}
+
+void
+CCamera::Find3rdPersonCamTargetVector(float dist, CVector pos, CVector &source, CVector &target)
+{
+ if(CPad::GetPad(0)->GetLookBehindForPed()){
+ source = pos;
+ target = dist*Cams[ActiveCam].CamTargetEntity->GetForward() + source;
+ }else{
+ float angleX = DEGTORAD((m_f3rdPersonCHairMultX-0.5f) * 1.8f * 0.5f * Cams[ActiveCam].FOV * CDraw::GetAspectRatio());
+ float angleY = DEGTORAD((0.5f-m_f3rdPersonCHairMultY) * 1.8f * 0.5f * Cams[ActiveCam].FOV);
+ source = Cams[ActiveCam].Source;
+ target = Cams[ActiveCam].Front;
+ target += Cams[ActiveCam].Up * Tan(angleY);
+ target += CrossProduct(Cams[ActiveCam].Front, Cams[ActiveCam].Up) * Tan(angleX);
+ target.Normalise();
+ float dot = DotProduct(pos - source, target);
+ source += dot*target;
+ target = dist*target + source;
+ }
+}
+
+float
+CCamera::Find3rdPersonQuickAimPitch(void)
+{
+ float clampedFrontZ = clamp(Cams[ActiveCam].Front.z, -1.0f, 1.0f);
+
+ float rot = Asin(clampedFrontZ);
+
+ return -(DEGTORAD(((0.5f - m_f3rdPersonCHairMultY) * 1.8f * 0.5f * Cams[ActiveCam].FOV)) + rot);
+}
+
+
+
+void
+CCamera::SetRwCamera(RwCamera *cam)
+{
+ m_pRwCamera = cam;
+ m_viewMatrix.Attach(&m_pRwCamera->viewMatrix, false);
+ CMBlur::MotionBlurOpen(m_pRwCamera);
+}
+
+void
+CCamera::CalculateDerivedValues(void)
+{
+ m_cameraMatrix = Invert(m_matrix);
+
+ float hfov = DEGTORAD(CDraw::GetFOV()/2.0f);
+ float c = cos(hfov);
+ float s = sin(hfov);
+
+ // right plane
+ m_vecFrustumNormals[0] = CVector(c, -s, 0.0f);
+ // left plane
+ m_vecFrustumNormals[1] = CVector(-c, -s, 0.0f);
+
+ c /= CDraw::FindAspectRatio();
+ s /= CDraw::FindAspectRatio();
+ // bottom plane
+ m_vecFrustumNormals[2] = CVector(0.0f, -s, -c);
+ // top plane
+ m_vecFrustumNormals[3] = CVector(0.0f, -s, c);
+
+ if(GetForward().x == 0.0f && GetForward().y == 0.0f)
+ GetForward().x = 0.0001f;
+ else
+ Orientation = Atan2(GetForward().x, GetForward().y);
+
+ CamFrontXNorm = GetForward().x;
+ CamFrontYNorm = GetForward().y;
+ float l = Sqrt(SQR(CamFrontXNorm) + SQR(CamFrontYNorm));
+ if(l == 0.0f)
+ CamFrontXNorm = 1.0f;
+ else{
+ CamFrontXNorm /= l;
+ CamFrontYNorm /= l;
+ }
+}
+
+bool
+CCamera::IsPointVisible(const CVector &center, const CMatrix *mat)
+{
+ RwV3d c;
+ c = *(RwV3d*)&center;
+ RwV3dTransformPoints(&c, &c, 1, &mat->m_matrix);
+ if(c.y < CDraw::GetNearClipZ()) return false;
+ if(c.y > CDraw::GetFarClipZ()) return false;
+ if(c.x*m_vecFrustumNormals[0].x + c.y*m_vecFrustumNormals[0].y > 0.0f) return false;
+ if(c.x*m_vecFrustumNormals[1].x + c.y*m_vecFrustumNormals[1].y > 0.0f) return false;
+ if(c.y*m_vecFrustumNormals[2].y + c.z*m_vecFrustumNormals[2].z > 0.0f) return false;
+ if(c.y*m_vecFrustumNormals[3].y + c.z*m_vecFrustumNormals[3].z > 0.0f) return false;
+ return true;
+}
+
+bool
+CCamera::IsSphereVisible(const CVector &center, float radius, const CMatrix *mat)
+{
+ RwV3d c;
+ c = *(RwV3d*)&center;
+ RwV3dTransformPoints(&c, &c, 1, &mat->m_matrix);
+ if(c.y + radius < CDraw::GetNearClipZ()) return false;
+ if(c.y - radius > CDraw::GetFarClipZ()) return false;
+ if(c.x*m_vecFrustumNormals[0].x + c.y*m_vecFrustumNormals[0].y > radius) return false;
+ if(c.x*m_vecFrustumNormals[1].x + c.y*m_vecFrustumNormals[1].y > radius) return false;
+ if(c.y*m_vecFrustumNormals[2].y + c.z*m_vecFrustumNormals[2].z > radius) return false;
+ if(c.y*m_vecFrustumNormals[3].y + c.z*m_vecFrustumNormals[3].z > radius) return false;
+ return true;
+}
+
+bool
+CCamera::IsSphereVisible(const CVector &center, float radius)
+{
+ CMatrix mat = m_cameraMatrix;
+ return IsSphereVisible(center, radius, &mat);
+}
+
+bool
+CCamera::IsBoxVisible(RwV3d *box, const CMatrix *mat)
+{
+ int i;
+ int frustumTests[6] = { 0 };
+ RwV3dTransformPoints(box, box, 8, &mat->m_matrix);
+
+ for(i = 0; i < 8; i++){
+ if(box[i].y < CDraw::GetNearClipZ()) frustumTests[0]++;
+ if(box[i].y > CDraw::GetFarClipZ()) frustumTests[1]++;
+ if(box[i].x*m_vecFrustumNormals[0].x + box[i].y*m_vecFrustumNormals[0].y > 0.0f) frustumTests[2]++;
+ if(box[i].x*m_vecFrustumNormals[1].x + box[i].y*m_vecFrustumNormals[1].y > 0.0f) frustumTests[3]++;
+// Why not test z?
+// if(box[i].y*m_vecFrustumNormals[2].y + box[i].z*m_vecFrustumNormals[2].z > 0.0f) frustumTests[4]++;
+// if(box[i].y*m_vecFrustumNormals[3].y + box[i].z*m_vecFrustumNormals[3].z > 0.0f) frustumTests[5]++;
+ }
+ for(i = 0; i < 6; i++)
+ if(frustumTests[i] == 8)
+ return false; // Box is completely outside of one plane
+ return true;
+}
+
+
+
+CCamPathSplines::CCamPathSplines(void)
+{
+ int i;
+ for(i = 0; i < MAXPATHLENGTH; i++)
+ m_arr_PathData[i] = 0.0f;
+}
+
+
STARTPATCHES
InjectHook(0x42C760, (bool (CCamera::*)(const CVector &center, float radius, const CMatrix *mat))&CCamera::IsSphereVisible, PATCH_JUMP);
InjectHook(0x46FD00, &CCamera::SetFadeColour, PATCH_JUMP);
@@ -343,4 +3374,37 @@ STARTPATCHES
InjectHook(0x46B560, &CCamera::FinishCutscene, PATCH_JUMP);
InjectHook(0x46FF30, &CCamera::SetZoomValueFollowPedScript, PATCH_JUMP);
InjectHook(0x46FF90, &CCamera::SetZoomValueCamStringScript, PATCH_JUMP);
+
+
+ InjectHook(0x46F8E0, &CCamera::ProcessWideScreenOn, PATCH_JUMP);
+ InjectHook(0x46FDE0, &CCamera::SetParametersForScriptInterpolation, PATCH_JUMP);
+ InjectHook(0x46BA20, &CCamera::GetLookingLRBFirstPerson, PATCH_JUMP);
+ InjectHook(0x470D80, &CCamera::StartTransitionWhenNotFinishedInter, PATCH_JUMP);
+ InjectHook(0x46FFF0, &CCamera::StartTransition, PATCH_JUMP);
+ InjectHook(0x46BEB0, &CCamera::InitialiseCameraForDebugMode, PATCH_JUMP);
+ InjectHook(0x471500, &CCamera::TakeControl, PATCH_JUMP);
+ InjectHook(0x4715B0, &CCamera::TakeControlNoEntity, PATCH_JUMP);
+ InjectHook(0x46B3A0, &CCamera::Fade, PATCH_JUMP);
+ InjectHook(0x46FE20, &CCamera::SetPercentAlongCutScene, PATCH_JUMP);
+ InjectHook(0x46B100, &CamShakeNoPos, PATCH_JUMP);
+ InjectHook(0x46B200, &CCamera::CamShake, PATCH_JUMP);
+ InjectHook(0x46F520, &CCamera::ProcessObbeCinemaCameraPed, PATCH_JUMP);
+ InjectHook(0x46F3E0, &CCamera::ProcessObbeCinemaCameraCar, PATCH_JUMP);
+ InjectHook(0x470DA0, &CCamera::StoreValuesDuringInterPol, PATCH_JUMP);
+ InjectHook(0x46B430, &CCamera::DrawBordersForWideScreen, PATCH_JUMP);
+ InjectHook(0x46F990, &CCamera::Restore, PATCH_JUMP);
+ InjectHook(0x46FAE0, &CCamera::RestoreWithJumpCut, PATCH_JUMP);
+ InjectHook(0x46F080, &CCamera::ProcessFade, PATCH_JUMP);
+ InjectHook(0x46EEA0, &CCamera::CalculateDerivedValues, PATCH_JUMP);
+ InjectHook(0x46F1E0, &CCamera::ProcessMusicFade, PATCH_JUMP);
+ InjectHook(0x46D1D0, &CCamera::LoadPathSplines, PATCH_JUMP);
+ InjectHook(0x4712A0, &CCamera::UpdateTargetEntity, PATCH_JUMP);
+ InjectHook(0x46B580, &CCamera::Find3rdPersonCamTargetVector, PATCH_JUMP);
+ InjectHook(0x46BAD0, &CCamera::Init, PATCH_JUMP);
+ InjectHook(0x46C9E0, &CCamera::LoadTrainCamNodes, PATCH_JUMP);
+ InjectHook(0x46F600, &CCamera::Process_Train_Camera_Control, PATCH_JUMP);
+ InjectHook(0x470EA0, &CCamera::UpdateSoundDistances, PATCH_JUMP);
+ InjectHook(0x46BF10, &CCamera::IsItTimeForNewcam, PATCH_JUMP);
+ InjectHook(0x471650, &CCamera::TryToStartNewCamMode, PATCH_JUMP);
+// InjectHook(0x46D3F0, &CCamera::Process, PATCH_JUMP);
ENDPATCHES
diff --git a/src/core/Camera.h b/src/core/Camera.h
index f3e3e661..f21fe913 100644
--- a/src/core/Camera.h
+++ b/src/core/Camera.h
@@ -4,13 +4,28 @@
class CEntity;
class CPed;
class CAutomobile;
+class CGarage;
extern int16 &DebugCamMode;
-#define NUMBER_OF_VECTORS_FOR_AVERAGE 2
+enum
+{
+ NUMBER_OF_VECTORS_FOR_AVERAGE = 2,
+ MAX_NUM_OF_SPLINETYPES = 4,
+ MAX_NUM_OF_NODES = 800 // for trains
+};
+
+#define DEFAULT_NEAR (0.9f)
+#define CAM_ZOOM_1STPRS (0.0f)
+#define CAM_ZOOM_1 (1.0f)
+#define CAM_ZOOM_2 (2.0f)
+#define CAM_ZOOM_3 (3.0f)
+#define CAM_ZOOM_TOPDOWN (4.0f)
+#define CAM_ZOOM_CINEMATIC (5.0f)
-struct CCam
+class CCam
{
+public:
enum
{
MODE_NONE = 0,
@@ -230,9 +245,12 @@ static_assert(sizeof(CCam) == 0x1A4, "CCam: wrong size");
static_assert(offsetof(CCam, Alpha) == 0xA8, "CCam: error");
static_assert(offsetof(CCam, Front) == 0x140, "CCam: error");
-struct CCamPathSplines
+class CCamPathSplines
{
- float m_arr_PathData[800];
+public:
+ enum {MAXPATHLENGTH=800};
+ float m_arr_PathData[MAXPATHLENGTH];
+ CCamPathSplines(void);
};
struct CTrainCamNode
@@ -296,13 +314,14 @@ enum
enum
{
- CAM_CONTROLLER_0,
- CAM_CONTROLLER_1,
- CAM_CONTROLLER_2
+ CAMCONTROL_GAME,
+ CAMCONTROL_SCRIPT,
+ CAMCONTROL_OBBE
};
-struct CCamera : public CPlaceable
+class CCamera : public CPlaceable
{
+public:
bool m_bAboveGroundTrainNodesLoaded;
bool m_bBelowGroundTrainNodesLoaded;
bool m_bCamDirectlyBehind;
@@ -344,16 +363,12 @@ struct CCamera : public CPlaceable
bool m_bHeadBob;
bool m_bFailedCullZoneTestPreviously;
-bool m_FadeTargetIsSplashScreen;
+ bool m_FadeTargetIsSplashScreen;
bool WorldViewerBeingUsed;
uint8 ActiveCam;
uint32 m_uiCamShakeStart;
uint32 m_uiFirstPersonCamLastInputTime;
-// where are those?
-//bool m_bVehicleSuspenHigh;
-//bool m_bEnable1rstPersonCamCntrlsScript;
-//bool m_bAllow1rstPersonWeaponsCamera;
uint32 m_uiLongestTimeInMill;
uint32 m_uiNumberOfTrainCamNodes;
@@ -369,7 +384,7 @@ bool m_FadeTargetIsSplashScreen;
int m_BlurRed;
int m_BlurType;
-uint32 unknown;
+uint32 unknown; // some counter having to do with music
int m_iWorkOutSpeedThisNumFrames;
int m_iNumFramesSoFar;
@@ -412,20 +427,20 @@ uint32 unknown;
float m_fOldBetaDiff;
float m_fPedZoomValue;
- float m_fPedZoomValueScript;
- float m_fPedZoomValueSmooth;
- float m_fPositionAlongSpline;
- float m_ScreenReductionPercentage;
- float m_ScreenReductionSpeed;
- float m_AlphaForPlayerAnim1rstPerson;
- float Orientation;
- float PedZoomIndicator;
- float PlayerExhaustion;
- float SoundDistUp, SoundDistLeft, SoundDistRight;
- float SoundDistUpAsRead, SoundDistLeftAsRead, SoundDistRightAsRead;
- float SoundDistUpAsReadOld, SoundDistLeftAsReadOld, SoundDistRightAsReadOld;
- float m_fWideScreenReductionAmount;
- float m_fStartingFOVForInterPol;
+ float m_fPedZoomValueScript;
+ float m_fPedZoomValueSmooth;
+ float m_fPositionAlongSpline;
+ float m_ScreenReductionPercentage;
+ float m_ScreenReductionSpeed;
+ float m_AlphaForPlayerAnim1rstPerson;
+ float Orientation;
+ float PedZoomIndicator;
+ float PlayerExhaustion;
+ float SoundDistUp, SoundDistLeft, SoundDistRight;
+ float SoundDistUpAsRead, SoundDistLeftAsRead, SoundDistRightAsRead;
+ float SoundDistUpAsReadOld, SoundDistLeftAsReadOld, SoundDistRightAsReadOld;
+ float m_fWideScreenReductionAmount;
+ float m_fStartingFOVForInterPol;
// not static yet
float m_fMouseAccelHorzntl;// acceleration multiplier for 1st person controls
@@ -435,8 +450,8 @@ uint32 unknown;
CCam Cams[3];
- void *pToGarageWeAreIn;
- void *pToGarageWeAreInForHackAvoidFirstPerson;
+ CGarage *pToGarageWeAreIn;
+ CGarage *pToGarageWeAreInForHackAvoidFirstPerson;
CQueuedMode m_PlayerMode;
CQueuedMode PlayerWeaponMode;
CVector m_PreviousCameraPosition;
@@ -447,17 +462,15 @@ uint32 unknown;
CVector m_vecFixedModeUpOffSet;
CVector m_vecCutSceneOffset;
- // one of those has to go
- CVector m_cvecStartingSourceForInterPol;
- CVector m_cvecStartingTargetForInterPol;
- CVector m_cvecStartingUpForInterPol;
- CVector m_cvecSourceSpeedAtStartInter;
- CVector m_cvecTargetSpeedAtStartInter;
- CVector m_cvecUpSpeedAtStartInter;
- CVector m_vecSourceWhenInterPol;
- CVector m_vecTargetWhenInterPol;
- CVector m_vecUpWhenInterPol;
- //CVector m_vecClearGeometryVec;
+ CVector m_cvecStartingSourceForInterPol;
+ CVector m_cvecStartingTargetForInterPol;
+ CVector m_cvecStartingUpForInterPol;
+ CVector m_cvecSourceSpeedAtStartInter;
+ CVector m_cvecTargetSpeedAtStartInter;
+ CVector m_cvecUpSpeedAtStartInter;
+ CVector m_vecSourceWhenInterPol;
+ CVector m_vecTargetWhenInterPol;
+ CVector m_vecUpWhenInterPol;
CVector m_vecGameCamPos;
CVector SourceDuringInter;
@@ -465,8 +478,8 @@ uint32 unknown;
CVector UpDuringInter;
RwCamera *m_pRwCamera;
CEntity *pTargetEntity;
- CCamPathSplines m_arrPathArray[4];
- CTrainCamNode m_arrTrainCamNode[800];
+ CCamPathSplines m_arrPathArray[MAX_NUM_OF_SPLINETYPES];
+ CTrainCamNode m_arrTrainCamNode[MAX_NUM_OF_NODES];
CMatrix m_cameraMatrix;
bool m_bGarageFixedCamPositionSet;
bool m_vecDoingSpecialInterPolation;
@@ -490,7 +503,7 @@ uint32 unknown;
float m_fScriptPercentageInterToStopMoving;
float m_fScriptPercentageInterToCatchUp;
-uint32 m_fScriptTimeForInterPolation;
+ uint32 m_fScriptTimeForInterPolation;
int16 m_iFadingDirection;
@@ -503,68 +516,97 @@ uint32 m_fScriptTimeForInterPolation;
uint32 m_uiFadeTimeStartedMusic;
static bool &m_bUseMouse3rdPerson;
+#ifdef FREE_CAM
+ static bool bFreeCam;
+#endif
+ // High level and misc
+ void Init(void);
+ void Process(void);
+ void CamControl(void);
+ void UpdateTargetEntity(void);
+ void UpdateSoundDistances(void);
+ void InitialiseCameraForDebugMode(void);
+ void CamShake(float strength, float x, float y, float z);
bool Get_Just_Switched_Status() { return m_bJust_Switched; }
- inline const CMatrix& GetCameraMatrix(void) { return m_cameraMatrix; }
- CVector &GetGameCamPosition(void) { return m_vecGameCamPos; }
- float GetPositionAlongSpline(void) { return m_fPositionAlongSpline; }
- bool IsPointVisible(const CVector &center, const CMatrix *mat);
- bool IsSphereVisible(const CVector &center, float radius, const CMatrix *mat);
- bool IsSphereVisible(const CVector &center, float radius);
- bool IsBoxVisible(RwV3d *box, const CMatrix *mat);
- int GetLookDirection(void);
- bool GetLookingForwardFirstPerson(void);
- void Fade(float timeout, int16 direction);
- int GetScreenFadeStatus(void);
- void ProcessFade(void);
- void ProcessMusicFade(void);
- void SetFadeColour(uint8 r, uint8 g, uint8 b);
-
- void CamShake(float strength, float x, float y, float z);
+ // Who's in control
+ void TakeControl(CEntity *target, int16 mode, int16 typeOfSwitch, int32 controller);
+ void TakeControlNoEntity(const CVector &position, int16 typeOfSwitch, int32 controller);
+ void TakeControlWithSpline(int16 typeOfSwitch);
+ void Restore(void);
+ void RestoreWithJumpCut(void);
+ void SetCamPositionForFixedMode(const CVector &Source, const CVector &UppOffSet);
- void SetMotionBlur(int r, int g, int b, int a, int type);
- void SetMotionBlurAlpha(int a);
- void RenderMotionBlur(void);
- void ClearPlayerWeaponMode();
- void CalculateDerivedValues(void);
+ // Transition
+ void StartTransition(int16 mode);
+ void StartTransitionWhenNotFinishedInter(int16 mode);
+ void StoreValuesDuringInterPol(CVector &source, CVector &target, CVector &up, float &FOV);
- void DrawBordersForWideScreen(void);
- void Restore(void);
+ // Widescreen borders
void SetWideScreenOn(void);
void SetWideScreenOff(void);
- void SetNearClipScript(float);
-
- float Find3rdPersonQuickAimPitch(void);
+ void ProcessWideScreenOn(void);
+ void DrawBordersForWideScreen(void);
- void TakeControl(CEntity*, int16, int16, int32);
- void TakeControlNoEntity(const CVector&, int16, int32);
- void SetCamPositionForFixedMode(const CVector&, const CVector&);
- bool GetFading();
- int GetFadingDirection();
+ // Obbe's cam
+ bool IsItTimeForNewcam(int32 obbeMode, int32 time);
+ bool TryToStartNewCamMode(int32 obbeMode);
+ void DontProcessObbeCinemaCamera(void);
+ void ProcessObbeCinemaCameraCar(void);
+ void ProcessObbeCinemaCameraPed(void);
- void Init();
- void SetRwCamera(RwCamera*);
- void Process();
+ // Train
+ void LoadTrainCamNodes(char const *name);
+ void Process_Train_Camera_Control(void);
+ // Script
void LoadPathSplines(int file);
- uint32 GetCutSceneFinishTime(void);
void FinishCutscene(void);
+ float GetPositionAlongSpline(void) { return m_fPositionAlongSpline; }
+ uint32 GetCutSceneFinishTime(void);
+ void SetCamCutSceneOffSet(const CVector &pos);
+ void SetPercentAlongCutScene(float percent);
+ void SetParametersForScriptInterpolation(float stopMoving, float catchUp, int32 time);
+ void SetZoomValueFollowPedScript(int16 dist);
+ void SetZoomValueCamStringScript(int16 dist);
+ void SetNearClipScript(float);
- void SetCamCutSceneOffSet(const CVector&);
- void TakeControlWithSpline(short);
- void RestoreWithJumpCut(void);
+ // Fading
+ void ProcessFade(void);
+ void ProcessMusicFade(void);
+ void Fade(float timeout, int16 direction);
+ void SetFadeColour(uint8 r, uint8 g, uint8 b);
+ bool GetFading(void);
+ int GetFadingDirection(void);
+ int GetScreenFadeStatus(void);
+
+ // Motion blur
+ void RenderMotionBlur(void);
+ void SetMotionBlur(int r, int g, int b, int a, int type);
+ void SetMotionBlurAlpha(int a);
+
+ // Player looking and aiming
+ int GetLookDirection(void);
+ bool GetLookingForwardFirstPerson(void);
+ bool GetLookingLRBFirstPerson(void);
void SetCameraDirectlyInFrontForFollowPed_CamOnAString(void);
void SetCameraDirectlyBehindForFollowPed_CamOnAString(void);
- void SetZoomValueFollowPedScript(int16);
- void SetZoomValueCamStringScript(int16);
- void SetNewPlayerWeaponMode(int16, int16, int16);
- void UpdateAimingCoors(CVector const &);
-
- void SetPercentAlongCutScene(float);
- void SetParametersForScriptInterpolation(float, float, int32);
+ void SetNewPlayerWeaponMode(int16 mode, int16 minZoom, int16 maxZoom);
+ void ClearPlayerWeaponMode(void);
+ void UpdateAimingCoors(CVector const &coors);
+ void Find3rdPersonCamTargetVector(float dist, CVector pos, CVector &source, CVector &target);
+ float Find3rdPersonQuickAimPitch(void);
- void dtor(void) { this->CCamera::~CCamera(); }
+ // Physical camera
+ void SetRwCamera(RwCamera *cam);
+ const CMatrix& GetCameraMatrix(void) { return m_cameraMatrix; }
+ CVector &GetGameCamPosition(void) { return m_vecGameCamPos; }
+ void CalculateDerivedValues(void);
+ bool IsPointVisible(const CVector &center, const CMatrix *mat);
+ bool IsSphereVisible(const CVector &center, float radius, const CMatrix *mat);
+ bool IsSphereVisible(const CVector &center, float radius);
+ bool IsBoxVisible(RwV3d *box, const CMatrix *mat);
};
static_assert(offsetof(CCamera, DistanceToWater) == 0xe4, "CCamera: error");
static_assert(offsetof(CCamera, m_WideScreenOn) == 0x70, "CCamera: error");
@@ -583,3 +625,5 @@ static_assert(sizeof(CCamera) == 0xE9D8, "CCamera: wrong size");
extern CCamera &TheCamera;
void CamShakeNoPos(CCamera*, float);
+void MakeAngleLessThan180(float &Angle);
+void WellBufferMe(float Target, float *CurrentValue, float *CurrentSpeed, float MaxSpeed, float Acceleration, bool IsAngle);
diff --git a/src/core/CutsceneMgr.h b/src/core/CutsceneMgr.h
index 381c71c9..7b809964 100644
--- a/src/core/CutsceneMgr.h
+++ b/src/core/CutsceneMgr.h
@@ -29,6 +29,7 @@ public:
static void SetRunning(bool running) { ms_running = running; }
static bool IsRunning(void) { return ms_running; }
static bool IsCutsceneProcessing(void) { return ms_cutsceneProcessing; }
+ static bool UseLodMultiplier(void) { return ms_useLodMultiplier; }
static CCutsceneObject* GetCutsceneObject(int id) { return ms_pCutsceneObjects[id]; }
static int GetCutsceneTimeInMilleseconds(void) { return 1000.0f * ms_cutsceneTimer; }
static char *GetCutsceneName(void) { return ms_cutsceneName; }
diff --git a/src/core/Frontend.cpp b/src/core/Frontend.cpp
index d4264a05..74729fec 100644
--- a/src/core/Frontend.cpp
+++ b/src/core/Frontend.cpp
@@ -529,7 +529,7 @@ WRAPPER void CMenuManager::DoSettingsBeforeStartingAGame() { EAXJMP(0x48AB40); }
#else
void CMenuManager::DoSettingsBeforeStartingAGame()
{
- CCamera::m_bUseMouse3rdPerson = m_ControlMethod == CONTROL_STANDART;
+ CCamera::m_bUseMouse3rdPerson = m_ControlMethod == CONTROL_STANDARD;
if (m_PrefsVsyncDisp != m_PrefsVsync)
m_PrefsVsync = m_PrefsVsyncDisp;
@@ -2072,7 +2072,7 @@ void CMenuManager::Process(void)
}
if (m_nCurrScreen == MENUPAGE_LOADING_IN_PROGRESS) {
if (CheckSlotDataValid(m_nCurrSaveSlot)) {
- TheCamera.m_bUseMouse3rdPerson = m_ControlMethod == CONTROL_STANDART;
+ TheCamera.m_bUseMouse3rdPerson = m_ControlMethod == CONTROL_STANDARD;
if (m_PrefsVsyncDisp != m_PrefsVsync)
m_PrefsVsync = m_PrefsVsyncDisp;
DMAudio.Service();
@@ -3175,7 +3175,7 @@ CMenuManager::ProcessButtonPresses(void)
PSGLOBAL(joy1)->GetCapabilities(&devCaps);
ControlsManager.InitDefaultControlConfigJoyPad(devCaps.dwButtons);
}
- CMenuManager::m_ControlMethod = CONTROL_STANDART;
+ CMenuManager::m_ControlMethod = CONTROL_STANDARD;
MousePointerStateHelper.bInvertVertically = false;
TheCamera.m_fMouseAccelHorzntl = 0.0025f;
CVehicle::m_bDisableMouseSteering = true;
@@ -3188,7 +3188,7 @@ CMenuManager::ProcessButtonPresses(void)
#ifndef TIDY_UP_PBP
if (CMenuManager::m_ControlMethod == CONTROL_CLASSIC) {
CCamera::m_bUseMouse3rdPerson = true;
- CMenuManager::m_ControlMethod = CONTROL_STANDART;
+ CMenuManager::m_ControlMethod = CONTROL_STANDARD;
} else {
CCamera::m_bUseMouse3rdPerson = false;
CMenuManager::m_ControlMethod = CONTROL_CLASSIC;
diff --git a/src/core/Frontend.h b/src/core/Frontend.h
index 04c24aff..74b3990e 100644
--- a/src/core/Frontend.h
+++ b/src/core/Frontend.h
@@ -365,7 +365,7 @@ enum
enum eControlMethod
{
- CONTROL_STANDART = 0,
+ CONTROL_STANDARD = 0,
CONTROL_CLASSIC,
};
diff --git a/src/core/Pad.h b/src/core/Pad.h
index 84919f32..ca44a9f7 100644
--- a/src/core/Pad.h
+++ b/src/core/Pad.h
@@ -2,7 +2,7 @@
enum {
PLAYERCONTROL_ENABLED = 0,
- PLAYERCONTROL_DISABLED_1 = 1,
+ PLAYERCONTROL_DISABLED_1 = 1, // used by first person camera
PLAYERCONTROL_DISABLED_2 = 2,
PLAYERCONTROL_GARAGE = 4,
PLAYERCONTROL_DISABLED_8 = 8,
diff --git a/src/core/config.h b/src/core/config.h
index 4d66eef5..373fca2f 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -215,4 +215,4 @@ enum Config {
// Camera
#define IMPROVED_CAMERA // Better Debug cam, and maybe more in the future
-//#define FREE_CAM // Rotating cam
+#define FREE_CAM // Rotating cam
diff --git a/src/core/re3.cpp b/src/core/re3.cpp
index 05d28167..6d4ff252 100644
--- a/src/core/re3.cpp
+++ b/src/core/re3.cpp
@@ -372,11 +372,9 @@ DebugMenuPopulate(void)
extern bool PrintDebugCode;
extern int16 &DebugCamMode;
+ DebugMenuAddVarBool8("Cam", "Use mouse Cam", (int8*)&CCamera::m_bUseMouse3rdPerson, nil);
#ifdef FREE_CAM
- extern bool bFreePadCam;
- extern bool bFreeMouseCam;
- DebugMenuAddVarBool8("Cam", "Free Gamepad Cam", (int8*)&bFreePadCam, nil);
- DebugMenuAddVarBool8("Cam", "Free Mouse Cam", (int8*)&bFreeMouseCam, nil);
+ DebugMenuAddVarBool8("Cam", "Free Cam", (int8*)&CCamera::bFreeCam, nil);
#endif
DebugMenuAddVarBool8("Cam", "Print Debug Code", (int8*)&PrintDebugCode, nil);
DebugMenuAddVar("Cam", "Cam Mode", &DebugCamMode, nil, 1, 0, CCam::MODE_EDITOR, nil);
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index 264fa669..54816b1c 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -59,10 +59,6 @@
#define CAN_SEE_ENTITY_ANGLE_THRESHOLD DEGTORAD(60.0f)
-#ifdef FREE_CAM
-extern bool bFreeMouseCam;
-#endif
-
CPed *gapTempPedList[50];
uint16 gnNumTempPedList;
@@ -812,7 +808,7 @@ bool
CPed::CanStrafeOrMouseControl(void)
{
#ifdef FREE_CAM
- if (bFreeMouseCam)
+ if (CCamera::bFreeCam)
return false;
#endif
return m_nPedState == PED_NONE || m_nPedState == PED_IDLE || m_nPedState == PED_FLEE_POS || m_nPedState == PED_FLEE_ENTITY ||
@@ -6993,7 +6989,7 @@ CPed::FinishLaunchCB(CAnimBlendAssociation *animAssoc, void *arg)
) {
#ifdef FREE_CAM
- if (TheCamera.Cams[0].Using3rdPersonMouseCam() && !bFreeMouseCam) {
+ if (TheCamera.Cams[0].Using3rdPersonMouseCam() && !CCamera::bFreeCam) {
#else
if (TheCamera.Cams[0].Using3rdPersonMouseCam()) {
#endif
diff --git a/src/peds/PlayerPed.cpp b/src/peds/PlayerPed.cpp
index cd2cac23..6dbf7687 100644
--- a/src/peds/PlayerPed.cpp
+++ b/src/peds/PlayerPed.cpp
@@ -18,10 +18,6 @@
#define PAD_MOVE_TO_GAME_WORLD_MOVE 60.0f
-#ifdef FREE_CAM
-extern bool bFreeMouseCam;
-#endif
-
CPlayerPed::~CPlayerPed()
{
delete m_pWanted;
@@ -693,7 +689,7 @@ CPlayerPed::PlayerControl1stPersonRunAround(CPad *padUsed)
float padMoveInGameUnit = padMove / PAD_MOVE_TO_GAME_WORLD_MOVE;
if (padMoveInGameUnit > 0.0f) {
#ifdef FREE_CAM
- if (!bFreeMouseCam)
+ if (!CCamera::bFreeCam)
m_fRotationDest = CGeneral::LimitRadianAngle(TheCamera.Orientation);
else
m_fRotationDest = CGeneral::GetRadianAngleBetweenPoints(0.0f, 0.0f, -leftRight, upDown) - TheCamera.Orientation;
@@ -993,7 +989,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
SetStoredState();
m_nPedState = PED_SNIPER_MODE;
#ifdef FREE_CAM
- if (bFreeMouseCam && TheCamera.Cams[0].Using3rdPersonMouseCam()) {
+ if (CCamera::bFreeCam && TheCamera.Cams[0].Using3rdPersonMouseCam()) {
m_fRotationCur = CGeneral::LimitRadianAngle(-TheCamera.Orientation);
SetHeading(m_fRotationCur);
}
@@ -1018,7 +1014,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
if (m_nSelectedWepSlot == m_currentWeapon) {
if (m_pPointGunAt) {
#ifdef FREE_CAM
- if (bFreeMouseCam && weaponInfo->m_eWeaponFire == WEAPON_FIRE_MELEE && m_fMoveSpeed < 1.0f)
+ if (CCamera::bFreeCam && weaponInfo->m_eWeaponFire == WEAPON_FIRE_MELEE && m_fMoveSpeed < 1.0f)
StartFightAttack(padUsed->GetWeapon());
else
#endif
@@ -1052,7 +1048,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
#ifdef FREE_CAM
// Rotate player/arm when shooting. We don't have auto-rotation anymore
- if (CCamera::m_bUseMouse3rdPerson && bFreeMouseCam &&
+ if (CCamera::m_bUseMouse3rdPerson && CCamera::bFreeCam &&
m_nSelectedWepSlot == m_currentWeapon && m_nMoveState != PEDMOVE_SPRINT) {
// Weapons except throwable and melee ones
@@ -1103,7 +1099,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
// what??
if (!m_pPointGunAt
#ifdef FREE_CAM
- || (!bFreeMouseCam && CCamera::m_bUseMouse3rdPerson)
+ || (!CCamera::bFreeCam && CCamera::m_bUseMouse3rdPerson)
#else
|| CCamera::m_bUseMouse3rdPerson
#endif
@@ -1125,7 +1121,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
TheCamera.UpdateAimingCoors(m_pPointGunAt->GetPosition());
}
#ifdef FREE_CAM
- else if ((bFreeMouseCam && weaponInfo->m_eWeaponFire == WEAPON_FIRE_MELEE) || (weaponInfo->m_bCanAim && !CCamera::m_bUseMouse3rdPerson)) {
+ else if ((CCamera::bFreeCam && weaponInfo->m_eWeaponFire == WEAPON_FIRE_MELEE) || (weaponInfo->m_bCanAim && !CCamera::m_bUseMouse3rdPerson)) {
#else
else if (weaponInfo->m_bCanAim && !CCamera::m_bUseMouse3rdPerson) {
#endif
diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index aca96aa3..e6b936f6 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -2340,8 +2340,7 @@ CAutomobile::FireTruckControl(void)
if(!CPad::GetPad(0)->GetWeapon())
return;
#ifdef FREE_CAM
- extern bool bFreeMouseCam;
- if (!bFreeMouseCam)
+ if (!CCamera::bFreeCam)
#endif
{
m_fCarGunLR += CPad::GetPad(0)->GetCarGunLeftRight() * 0.00025f * CTimer::GetTimeStep();
@@ -2416,8 +2415,7 @@ CAutomobile::TankControl(void)
// Rotate turret
float prevAngle = m_fCarGunLR;
#ifdef FREE_CAM
- extern bool bFreeMouseCam;
- if(!bFreeMouseCam)
+ if(!CCamera::bFreeCam)
#endif
m_fCarGunLR -= CPad::GetPad(0)->GetCarGunLeftRight() * 0.00015f * CTimer::GetTimeStep();
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 16:32:09 +0100