mirror of
https://github.com/GTAmodding/re3.git
synced 2024-12-02 17:45:42 +00:00
5424 lines
183 KiB
C++
5424 lines
183 KiB
C++
#include "common.h"
|
|
|
|
#include "main.h"
|
|
#include "Draw.h"
|
|
#include "World.h"
|
|
#include "Vehicle.h"
|
|
#include "Automobile.h"
|
|
#include "Boat.h"
|
|
#include "Bones.h"
|
|
#include "Ped.h"
|
|
#include "PlayerPed.h"
|
|
#include "CopPed.h"
|
|
#include "RpAnimBlend.h"
|
|
#include "ControllerConfig.h"
|
|
#include "Pad.h"
|
|
#include "Frontend.h"
|
|
#include "General.h"
|
|
#include "Timecycle.h"
|
|
#include "Renderer.h"
|
|
#include "Shadows.h"
|
|
#include "Hud.h"
|
|
#include "ZoneCull.h"
|
|
#include "SurfaceTable.h"
|
|
#include "WaterLevel.h"
|
|
#include "MBlur.h"
|
|
#include "SceneEdit.h"
|
|
#include "Debug.h"
|
|
#include "Camera.h"
|
|
#include "DMAudio.h"
|
|
#include "Bike.h"
|
|
#include "Pickups.h"
|
|
|
|
//--MIAMI: file done
|
|
|
|
bool PrintDebugCode = false;
|
|
int16 DebugCamMode;
|
|
|
|
extern float fRangePlayerRadius;
|
|
extern float fCloseNearClipLimit;
|
|
|
|
#ifdef FREE_CAM
|
|
bool CCamera::bFreeCam = false;
|
|
int nPreviousMode = -1;
|
|
#endif
|
|
|
|
void
|
|
CCam::Init(void)
|
|
{
|
|
Mode = MODE_FOLLOWPED;
|
|
Front = CVector(0.0f, 0.0f, -1.0f);
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
Rotating = false;
|
|
m_iDoCollisionChecksOnFrameNum = 1;
|
|
m_iDoCollisionCheckEveryNumOfFrames = 9;
|
|
m_iFrameNumWereAt = 0;
|
|
m_bCollisionChecksOn = false;
|
|
m_fRealGroundDist = 0.0f;
|
|
BetaSpeed = 0.0f;
|
|
AlphaSpeed = 0.0f;
|
|
DistanceSpeed = 0.0f;
|
|
f_max_role_angle = DEGTORAD(5.0f);
|
|
Distance = 30.0f;
|
|
DistanceSpeed = 0.0f;
|
|
m_pLastCarEntered = nil;
|
|
m_pLastPedLookedAt = nil;
|
|
ResetStatics = true;
|
|
Beta = 0.0f;
|
|
m_fTilt = 0.0f;
|
|
m_fTiltSpeed = 0.0f;
|
|
m_bFixingBeta = false;
|
|
CA_MIN_DISTANCE = 0.0f;
|
|
CA_MAX_DISTANCE = 0.0f;
|
|
LookingBehind = false;
|
|
LookingLeft = false;
|
|
LookingRight = false;
|
|
m_fPlayerInFrontSyphonAngleOffSet = DEGTORAD(20.0f);
|
|
m_fSyphonModeTargetZOffSet = 0.5f;
|
|
m_fRadiusForDead = 1.5f;
|
|
DirectionWasLooking = LOOKING_FORWARD;
|
|
LookBehindCamWasInFront = false;
|
|
f_Roll = 0.0f;
|
|
f_rollSpeed = 0.0f;
|
|
m_fCloseInPedHeightOffset = 0.0f;
|
|
m_fCloseInPedHeightOffsetSpeed = 0.0f;
|
|
m_fCloseInCarHeightOffset = 0.0f;
|
|
m_fCloseInCarHeightOffsetSpeed = 0.0f;
|
|
m_fPedBetweenCameraHeightOffset = 0.0f;
|
|
m_fTargetBeta = 0.0f;
|
|
m_fBufferedTargetBeta = 0.0f;
|
|
m_fBufferedTargetOrientation = 0.0f;
|
|
m_fBufferedTargetOrientationSpeed = 0.0f;
|
|
m_fDimensionOfHighestNearCar = 0.0f;
|
|
}
|
|
|
|
float PLAYERPED_LEVEL_SMOOTHING_CONST_INV = 0.6f;
|
|
float PLAYERPED_TREND_SMOOTHING_CONST_INV = 0.8f;
|
|
|
|
void
|
|
CCam::Process(void)
|
|
{
|
|
CVector CameraTarget;
|
|
float TargetSpeedVar = 0.0f;
|
|
float TargetOrientation = 0.0f;
|
|
|
|
static CVector SmoothedPos(0.0f, 0.0f, 10000.0f);
|
|
static CVector SmoothedSpeed(0.0f, 0.0f, 0.0f);
|
|
|
|
if(CamTargetEntity == nil)
|
|
CamTargetEntity = TheCamera.pTargetEntity;
|
|
|
|
m_iFrameNumWereAt++;
|
|
if(m_iFrameNumWereAt > m_iDoCollisionCheckEveryNumOfFrames)
|
|
m_iFrameNumWereAt = 1;
|
|
m_bCollisionChecksOn = m_iFrameNumWereAt == m_iDoCollisionChecksOnFrameNum;
|
|
|
|
if(m_bCamLookingAtVector){
|
|
CameraTarget = m_cvecCamFixedModeVector;
|
|
}else if(CamTargetEntity->IsVehicle()){
|
|
CameraTarget = CamTargetEntity->GetPosition();
|
|
|
|
if(CamTargetEntity->GetForward().x == 0.0f && CamTargetEntity->GetForward().y == 0.0f)
|
|
TargetOrientation = 0.0f;
|
|
else
|
|
TargetOrientation = CGeneral::GetATanOfXY(CamTargetEntity->GetForward().x, CamTargetEntity->GetForward().y);
|
|
|
|
CVector Fwd(0.0f, 0.0f, 0.0f);
|
|
Fwd.x = CamTargetEntity->GetForward().x;
|
|
Fwd.y = CamTargetEntity->GetForward().y;
|
|
Fwd.Normalise();
|
|
float FwdLength = Fwd.Magnitude2D();
|
|
if(FwdLength != 0.0f){
|
|
Fwd.x /= FwdLength;
|
|
Fwd.y /= FwdLength;
|
|
}
|
|
|
|
float FwdSpeedX = ((CVehicle*)CamTargetEntity)->GetMoveSpeed().x * Fwd.x;
|
|
float FwdSpeedY = ((CVehicle*)CamTargetEntity)->GetMoveSpeed().y * Fwd.y;
|
|
if(FwdSpeedX + FwdSpeedY > 0.0f)
|
|
TargetSpeedVar = Min(Sqrt(SQR(FwdSpeedX) + SQR(FwdSpeedY))/0.9f, 1.0f);
|
|
else
|
|
TargetSpeedVar = -Min(Sqrt(SQR(FwdSpeedX) + SQR(FwdSpeedY))/1.8f, 0.5f);
|
|
SpeedVar = 0.895f*SpeedVar + 0.105*TargetSpeedVar;
|
|
}else{
|
|
if(CamTargetEntity == FindPlayerPed()){
|
|
// Some fancy smoothing of player position and speed
|
|
float LevelSmoothing = 1.0f - Pow(PLAYERPED_LEVEL_SMOOTHING_CONST_INV, CTimer::GetTimeStep());
|
|
float TrendSmoothing = 1.0f - Pow(PLAYERPED_TREND_SMOOTHING_CONST_INV, CTimer::GetTimeStep());
|
|
|
|
CVector NewSmoothedPos, NewSmoothedSpeed;
|
|
if((SmoothedPos - CamTargetEntity->GetPosition()).MagnitudeSqr() > SQR(3.0f) ||
|
|
CTimer::GetTimeStep() < 0.2f || Using3rdPersonMouseCam()){
|
|
// Reset values
|
|
NewSmoothedPos = CamTargetEntity->GetPosition();
|
|
NewSmoothedSpeed = CVector(0.0f, 0.0f, 0.0f);
|
|
}else{
|
|
NewSmoothedPos = LevelSmoothing*CamTargetEntity->GetPosition() + (1.0f-LevelSmoothing)*(SmoothedPos + SmoothedSpeed*CTimer::GetTimeStep());
|
|
NewSmoothedSpeed = TrendSmoothing*(NewSmoothedPos-SmoothedPos)/CTimer::GetTimeStep() + (1.0f-TrendSmoothing)*SmoothedSpeed;
|
|
}
|
|
|
|
CameraTarget = NewSmoothedPos;
|
|
SmoothedPos = NewSmoothedPos;
|
|
SmoothedSpeed = NewSmoothedSpeed;
|
|
}else
|
|
CameraTarget = CamTargetEntity->GetPosition();
|
|
|
|
if(CamTargetEntity->GetForward().x == 0.0f && CamTargetEntity->GetForward().y == 0.0f)
|
|
TargetOrientation = 0.0f;
|
|
else
|
|
TargetOrientation = CGeneral::GetATanOfXY(CamTargetEntity->GetForward().x, CamTargetEntity->GetForward().y);
|
|
TargetSpeedVar = 0.0f;
|
|
SpeedVar = 0.0f;
|
|
}
|
|
|
|
switch(Mode){
|
|
case MODE_TOPDOWN:
|
|
case MODE_GTACLASSIC:
|
|
// Process_TopDown(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_BEHINDCAR:
|
|
Process_BehindCar(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_FOLLOWPED:
|
|
#ifdef PC_PLAYER_CONTROLS
|
|
if(CCamera::m_bUseMouse3rdPerson)
|
|
Process_FollowPedWithMouse(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
else
|
|
#endif
|
|
#ifdef FREE_CAM
|
|
if(CCamera::bFreeCam)
|
|
Process_FollowPed_Rotation(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
else
|
|
#endif
|
|
Process_FollowPed(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
// case MODE_AIMING:
|
|
case MODE_DEBUG:
|
|
Process_Debug(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_SNIPER:
|
|
case MODE_CAMERA:
|
|
Process_Sniper(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_ROCKETLAUNCHER:
|
|
Process_Rocket(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_MODELVIEW:
|
|
Process_ModelView(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
// case MODE_BILL:
|
|
case MODE_SYPHON:
|
|
Process_Syphon(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_CIRCLE:
|
|
// Process_Circle(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
// case MODE_CHEESYZOOM:
|
|
case MODE_WHEELCAM:
|
|
Process_WheelCam(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_FIXED:
|
|
Process_Fixed(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_1STPERSON:
|
|
Process_1stPerson(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_FLYBY:
|
|
Process_FlyBy(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_CAM_ON_A_STRING:
|
|
#ifdef FREE_CAM
|
|
if(CCamera::bFreeCam)
|
|
Process_FollowCar_SA(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
else
|
|
#endif
|
|
Process_Cam_On_A_String(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
// case MODE_REACTION:
|
|
// case MODE_FOLLOW_PED_WITH_BIND:
|
|
// case MODE_CHRIS:
|
|
case MODE_BEHINDBOAT:
|
|
#ifdef FREE_CAM
|
|
if (CCamera::bFreeCam)
|
|
Process_FollowCar_SA(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
else
|
|
#endif
|
|
Process_BehindBoat(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_PLAYER_FALLEN_WATER:
|
|
Process_Player_Fallen_Water(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
// case MODE_CAM_ON_TRAIN_ROOF:
|
|
// case MODE_CAM_RUNNING_SIDE_TRAIN:
|
|
// case MODE_BLOOD_ON_THE_TRACKS:
|
|
// case MODE_IM_THE_PASSENGER_WOOWOO:
|
|
case MODE_SYPHON_CRIM_IN_FRONT:
|
|
Process_Syphon_Crim_In_Front(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_PED_DEAD_BABY:
|
|
ProcessPedsDeadBaby();
|
|
break;
|
|
// case MODE_PILLOWS_PAPS:
|
|
// case MODE_LOOK_AT_CARS:
|
|
case MODE_ARRESTCAM_ONE:
|
|
ProcessArrestCamOne();
|
|
break;
|
|
case MODE_ARRESTCAM_TWO:
|
|
ProcessArrestCamTwo();
|
|
break;
|
|
case MODE_M16_1STPERSON:
|
|
case MODE_HELICANNON_1STPERSON:
|
|
Process_M16_1stPerson(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_SPECIAL_FIXED_FOR_SYPHON:
|
|
Process_SpecialFixedForSyphon(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_FIGHT_CAM:
|
|
Process_Fight_Cam(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_LIGHTHOUSE:
|
|
Process_LightHouse(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_TOP_DOWN_PED:
|
|
// Process_TopDownPed(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
case MODE_SNIPER_RUNABOUT:
|
|
case MODE_ROCKETLAUNCHER_RUNABOUT:
|
|
case MODE_1STPERSON_RUNABOUT:
|
|
case MODE_M16_1STPERSON_RUNABOUT:
|
|
case MODE_FIGHT_CAM_RUNABOUT:
|
|
Process_1rstPersonPedOnPC(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
#ifdef GTA_SCENE_EDIT
|
|
case MODE_EDITOR:
|
|
Process_Editor(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar);
|
|
break;
|
|
#endif
|
|
default:
|
|
Source = CVector(0.0f, 0.0f, 0.0f);
|
|
Front = CVector(0.0f, 1.0f, 0.0f);
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
}
|
|
|
|
#ifdef FREE_CAM
|
|
nPreviousMode = Mode;
|
|
#endif
|
|
CVector TargetToCam = Source - m_cvecTargetCoorsForFudgeInter;
|
|
float DistOnGround = TargetToCam.Magnitude2D();
|
|
m_fTrueBeta = CGeneral::GetATanOfXY(TargetToCam.x, TargetToCam.y);
|
|
m_fTrueAlpha = CGeneral::GetATanOfXY(DistOnGround, TargetToCam.z);
|
|
if(TheCamera.m_uiTransitionState == 0)
|
|
KeepTrackOfTheSpeed(Source, m_cvecTargetCoorsForFudgeInter, Up, m_fTrueAlpha, m_fTrueBeta, FOV);
|
|
|
|
// Look Behind, Left, Right
|
|
LookingBehind = false;
|
|
LookingLeft = false;
|
|
LookingRight = false;
|
|
SourceBeforeLookBehind = Source;
|
|
if(&TheCamera.Cams[TheCamera.ActiveCam] == this){
|
|
if((Mode == MODE_CAM_ON_A_STRING || Mode == MODE_1STPERSON || Mode == MODE_BEHINDBOAT || Mode == MODE_BEHINDCAR) &&
|
|
CamTargetEntity->IsVehicle()){
|
|
bool bDisableLR = CamTargetEntity &&
|
|
(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI || CamTargetEntity->GetModelIndex() == MI_RCBARON);
|
|
if(CPad::GetPad(0)->GetLookBehindForCar()){
|
|
LookBehind();
|
|
if(DirectionWasLooking != LOOKING_BEHIND)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_BEHIND;
|
|
}else if(bDisableLR){
|
|
if(DirectionWasLooking != LOOKING_FORWARD)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_FORWARD;
|
|
}else if(CPad::GetPad(0)->GetLookLeft()){
|
|
LookLeft();
|
|
if(DirectionWasLooking != LOOKING_LEFT)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_LEFT;
|
|
}else if(CPad::GetPad(0)->GetLookRight()){
|
|
LookRight();
|
|
if(DirectionWasLooking != LOOKING_RIGHT)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_RIGHT;
|
|
}else{
|
|
if(DirectionWasLooking != LOOKING_FORWARD)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_FORWARD;
|
|
}
|
|
}
|
|
if(Mode == MODE_FOLLOWPED && CamTargetEntity->IsPed()){
|
|
if(CPad::GetPad(0)->GetLookBehindForPed()){
|
|
LookBehind();
|
|
if(DirectionWasLooking != LOOKING_BEHIND)
|
|
TheCamera.m_bJust_Switched = true;
|
|
DirectionWasLooking = LOOKING_BEHIND;
|
|
}else
|
|
DirectionWasLooking = LOOKING_FORWARD;
|
|
}
|
|
}
|
|
|
|
if(Mode == MODE_SNIPER || Mode == MODE_ROCKETLAUNCHER || Mode == MODE_M16_1STPERSON ||
|
|
Mode == MODE_1STPERSON || Mode == MODE_HELICANNON_1STPERSON || Mode == MODE_CAMERA || GetWeaponFirstPersonOn())
|
|
ClipIfPedInFrontOfPlayer();
|
|
}
|
|
|
|
// MaxSpeed is a limit of how fast the value is allowed to change. 1.0 = to Target in up to 1ms
|
|
// Acceleration is how fast the speed will change to MaxSpeed. 1.0 = to MaxSpeed in 1ms
|
|
void
|
|
WellBufferMe(float Target, float *CurrentValue, float *CurrentSpeed, float MaxSpeed, float Acceleration, bool IsAngle)
|
|
{
|
|
float Delta = Target - *CurrentValue;
|
|
|
|
if(IsAngle){
|
|
while(Delta >= PI) Delta -= 2*PI;
|
|
while(Delta < -PI) Delta += 2*PI;
|
|
}
|
|
|
|
float TargetSpeed = Delta * MaxSpeed;
|
|
// Add or subtract absolute depending on sign, genius!
|
|
// if(TargetSpeed - *CurrentSpeed > 0.0f)
|
|
// *CurrentSpeed += Acceleration * Abs(TargetSpeed - *CurrentSpeed) * CTimer::GetTimeStep();
|
|
// else
|
|
// *CurrentSpeed -= Acceleration * Abs(TargetSpeed - *CurrentSpeed) * CTimer::GetTimeStep();
|
|
// this is simpler:
|
|
*CurrentSpeed += Acceleration * (TargetSpeed - *CurrentSpeed) * CTimer::GetTimeStep();
|
|
|
|
// Clamp speed if we overshot
|
|
if(TargetSpeed < 0.0f && *CurrentSpeed < TargetSpeed)
|
|
*CurrentSpeed = TargetSpeed;
|
|
else if(TargetSpeed > 0.0f && *CurrentSpeed > TargetSpeed)
|
|
*CurrentSpeed = TargetSpeed;
|
|
|
|
*CurrentValue += *CurrentSpeed * Min(10.0f, CTimer::GetTimeStep());
|
|
}
|
|
|
|
void
|
|
MakeAngleLessThan180(float &Angle)
|
|
{
|
|
while(Angle >= PI) Angle -= 2*PI;
|
|
while(Angle < -PI) Angle += 2*PI;
|
|
}
|
|
|
|
void
|
|
CCam::ProcessSpecialHeightRoutines(void)
|
|
{
|
|
int i;
|
|
bool StandingOnBoat = false;
|
|
static bool PreviouslyFailedRoadHeightCheck = false;
|
|
CVector CamToTarget, CamToPed;
|
|
float DistOnGround, BetaAngle;
|
|
CPed *Player;
|
|
float PedZDist;
|
|
CColPoint colPoint;
|
|
|
|
CamToTarget = TheCamera.pTargetEntity->GetPosition() - TheCamera.GetGameCamPosition();
|
|
DistOnGround = CamToTarget.Magnitude2D();
|
|
BetaAngle = CGeneral::GetATanOfXY(CamToTarget.x, CamToTarget.y);
|
|
m_bTheHeightFixerVehicleIsATrain = false;
|
|
// CGeneral::GetATanOfXY(TheCamera.GetForward().x, TheCamera.GetForward().y);
|
|
Player = CWorld::Players[CWorld::PlayerInFocus].m_pPed;
|
|
|
|
if(DistOnGround > 10.0f)
|
|
DistOnGround = 10.0f;
|
|
|
|
if(CamTargetEntity && CamTargetEntity->IsPed()){
|
|
if(FindPlayerPed()->m_pCurSurface && FindPlayerPed()->m_pCurSurface->IsVehicle() &&
|
|
((CVehicle*)FindPlayerPed()->m_pCurSurface)->IsBoat())
|
|
StandingOnBoat = true;
|
|
|
|
float FoundPedZ = -100.0f;
|
|
|
|
// Move up the camera if there is a ped close to it
|
|
if(Mode == MODE_FOLLOWPED || Mode == MODE_FIGHT_CAM || Mode == MODE_PILLOWS_PAPS){
|
|
// Find highest ped close to camera
|
|
for(i = 0; i < Player->m_numNearPeds; i++){
|
|
CPed *nearPed = Player->m_nearPeds[i];
|
|
if(nearPed && nearPed->GetPedState() != PED_DEAD){
|
|
CamToPed = nearPed->GetPosition() - TheCamera.GetGameCamPosition();
|
|
if(Abs(CamToPed.z) < 1.0f){
|
|
float DistSq = CamToPed.MagnitudeSqr();
|
|
if(DistSq < SQR(2.1f)){
|
|
if(nearPed->GetPosition().z > FoundPedZ)
|
|
FoundPedZ = nearPed->GetPosition().z;
|
|
}else{
|
|
float Dist = Sqrt(DistSq);
|
|
CamToPed /= Dist;
|
|
// strange calculation
|
|
CVector PlayerCamSpeed = DotProduct(Front, Player->m_vecMoveSpeed)*Front;
|
|
float SpeedDiff = DotProduct(PlayerCamSpeed - nearPed->m_vecMoveSpeed, CamToPed);
|
|
if(SpeedDiff > 0.01f &&
|
|
(m_fPedBetweenCameraHeightOffset > 0.0f && (Dist-2.1f)/SpeedDiff < 75.0f ||
|
|
m_fPedBetweenCameraHeightOffset <= 0.0f && (Dist-2.1f)/SpeedDiff < 75.0f * 0.1f))
|
|
if(nearPed->GetPosition().z > FoundPedZ)
|
|
FoundPedZ = nearPed->GetPosition().z;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FoundPedZ > -99.0f){
|
|
float Offset = 0.0f;
|
|
PedZDist = 0.0f;
|
|
if(FoundPedZ > Player->GetPosition().z)
|
|
PedZDist = FoundPedZ - Player->GetPosition().z;
|
|
|
|
if(Mode == MODE_FOLLOWPED){
|
|
if(TheCamera.PedZoomIndicator == CAM_ZOOM_1 &&
|
|
((CPed*)CamTargetEntity)->GetPedState() != PED_ENTER_CAR &&
|
|
((CPed*)CamTargetEntity)->GetPedState() != PED_CARJACK)
|
|
Offset = 0.45f + PedZDist;
|
|
// BUG: overrides this ^ case
|
|
if(TheCamera.PedZoomIndicator == CAM_ZOOM_2 || TheCamera.PedZoomIndicator == CAM_ZOOM_1)
|
|
Offset = 0.35f + PedZDist;
|
|
if(TheCamera.PedZoomIndicator == CAM_ZOOM_3)
|
|
Offset = 0.25f + PedZDist;
|
|
m_fPedBetweenCameraHeightOffset = Offset + 1.3f;
|
|
}else if(Mode == MODE_FIGHT_CAM)
|
|
m_fPedBetweenCameraHeightOffset = PedZDist + 1.3f + 0.5f;
|
|
else if(Mode == MODE_PILLOWS_PAPS)
|
|
m_fPedBetweenCameraHeightOffset = PedZDist + 1.3f + 0.45f;
|
|
}else{
|
|
m_fPedBetweenCameraHeightOffset = 0.0f;
|
|
}
|
|
}
|
|
|
|
|
|
// Move camera up for vehicles in the way
|
|
if(m_bCollisionChecksOn && (Mode == MODE_FOLLOWPED || Mode == MODE_FIGHT_CAM)){
|
|
bool FoundCar = false;
|
|
CEntity *vehicle = nil;
|
|
float TestDist = DistOnGround + 1.25f;
|
|
float HighestCar = 0.0f;
|
|
if(m_fDimensionOfHighestNearCar > 0.0f)
|
|
TestDist += 0.3f;
|
|
CVector TestBase = CamTargetEntity->GetPosition();
|
|
CVector TestPoint;
|
|
TestBase.z -= 0.15f;
|
|
|
|
TestPoint = TestBase - TestDist * CVector(Cos(BetaAngle), Sin(BetaAngle), 0.0f);
|
|
if(CWorld::ProcessLineOfSight(CamTargetEntity->GetPosition(), TestPoint, colPoint, vehicle, false, true, false, false, false, false) &&
|
|
vehicle->IsVehicle()){
|
|
float height = vehicle->GetColModel()->boundingBox.GetSize().z;
|
|
FoundCar = true;
|
|
HighestCar = height;
|
|
if(((CVehicle*)vehicle)->IsTrain())
|
|
m_bTheHeightFixerVehicleIsATrain = true;
|
|
}
|
|
|
|
TestPoint = TestBase - TestDist * CVector(Cos(BetaAngle+DEGTORAD(28.0f)), Sin(BetaAngle+DEGTORAD(28.0f)), 0.0f);
|
|
if(CWorld::ProcessLineOfSight(CamTargetEntity->GetPosition(), TestPoint, colPoint, vehicle, false, true, false, false, false, false) &&
|
|
vehicle->IsVehicle()){
|
|
float height = vehicle->GetColModel()->boundingBox.GetSize().z;
|
|
if(FoundCar){
|
|
HighestCar = Max(HighestCar, height);
|
|
}else{
|
|
FoundCar = true;
|
|
HighestCar = height;
|
|
}
|
|
if(((CVehicle*)vehicle)->IsTrain())
|
|
m_bTheHeightFixerVehicleIsATrain = true;
|
|
}
|
|
|
|
TestPoint = TestBase - TestDist * CVector(Cos(BetaAngle-DEGTORAD(28.0f)), Sin(BetaAngle-DEGTORAD(28.0f)), 0.0f);
|
|
if(CWorld::ProcessLineOfSight(CamTargetEntity->GetPosition(), TestPoint, colPoint, vehicle, false, true, false, false, false, false) &&
|
|
vehicle->IsVehicle()){
|
|
float height = vehicle->GetColModel()->boundingBox.GetSize().z;
|
|
if(FoundCar){
|
|
HighestCar = Max(HighestCar, height);
|
|
}else{
|
|
FoundCar = true;
|
|
HighestCar = height;
|
|
}
|
|
if(((CVehicle*)vehicle)->IsTrain())
|
|
m_bTheHeightFixerVehicleIsATrain = true;
|
|
}
|
|
|
|
if(FoundCar){
|
|
m_fDimensionOfHighestNearCar = HighestCar + 0.1f;
|
|
if(Mode == MODE_FIGHT_CAM)
|
|
m_fDimensionOfHighestNearCar += 0.75f;
|
|
}else
|
|
m_fDimensionOfHighestNearCar = 0.0f;
|
|
}
|
|
}
|
|
|
|
if(StandingOnBoat){
|
|
m_fDimensionOfHighestNearCar = 1.0f;
|
|
m_fPedBetweenCameraHeightOffset = 0.0f;
|
|
}
|
|
}
|
|
|
|
void
|
|
CCam::GetVectorsReadyForRW(void)
|
|
{
|
|
CVector right;
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
Front.Normalise();
|
|
if(Front.x == 0.0f && Front.y == 0.0f){
|
|
Front.x = 0.0001f;
|
|
Front.y = 0.0001f;
|
|
}
|
|
right = CrossProduct(Front, Up);
|
|
right.Normalise();
|
|
Up = CrossProduct(right, Front);
|
|
}
|
|
|
|
bool
|
|
CCam::GetBoatLook_L_R_HeightOffset(float &Offset)
|
|
{
|
|
if(CamTargetEntity == nil)
|
|
return false;
|
|
CVehicleModelInfo *mi = (CVehicleModelInfo*)CModelInfo::GetModelInfo(CamTargetEntity->GetModelIndex());
|
|
tBoatHandlingData *handling = mod_HandlingManager.GetBoatPointer(mi->m_handlingId);
|
|
if(handling){
|
|
Offset = handling->fLook_L_R_BehindCamHeight;
|
|
return true;
|
|
}
|
|
return false; // can't happen, we always get a boat pointer back
|
|
}
|
|
|
|
void
|
|
CCam::LookBehind(void)
|
|
{
|
|
float Dist, DeltaBeta, TargetOrientation, Angle;
|
|
CVector TargetCoors, TargetFwd, TestCoors;
|
|
|
|
TargetCoors = CamTargetEntity->GetPosition();
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
|
|
if((Mode == MODE_CAM_ON_A_STRING || Mode == MODE_BEHINDBOAT || Mode == MODE_BEHINDCAR) && CamTargetEntity->IsVehicle()){
|
|
LookingBehind = true;
|
|
Dist = Mode == MODE_CAM_ON_A_STRING ? CA_MAX_DISTANCE : 15.5f;
|
|
TargetFwd = CamTargetEntity->GetForward();
|
|
TargetFwd.Normalise();
|
|
TargetOrientation = CGeneral::GetATanOfXY(TargetFwd.x, TargetFwd.y);
|
|
DeltaBeta = TargetOrientation - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
if(DirectionWasLooking != LOOKING_BEHIND)
|
|
LookBehindCamWasInFront = DeltaBeta <= -HALFPI || DeltaBeta >= HALFPI;
|
|
if(LookBehindCamWasInFront)
|
|
TargetOrientation += PI;
|
|
Source.x = Dist*Cos(TargetOrientation) + TargetCoors.x;
|
|
Source.y = Dist*Sin(TargetOrientation) + TargetCoors.y;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
if(Mode == MODE_1STPERSON && CamTargetEntity->IsVehicle()){
|
|
LookingBehind = true;
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.25f);
|
|
Front = CamTargetEntity->GetForward();
|
|
Front.Normalise();
|
|
if(((CVehicle*)CamTargetEntity)->IsBoat())
|
|
Source.z -= 0.5f;
|
|
if(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_BIKE){
|
|
float FrontDist = 1.1f;
|
|
if(((CVehicle*)CamTargetEntity)->pDriver){
|
|
CVector ExtraFwd(0.0f, 0.0f, 0.0f);
|
|
((CVehicle*)CamTargetEntity)->pDriver->m_pedIK.GetComponentPosition(ExtraFwd, PED_HEAD);
|
|
ExtraFwd += ((CVehicle*)CamTargetEntity)->m_vecMoveSpeed*CTimer::GetTimeStep() - CamTargetEntity->GetPosition();
|
|
FrontDist += 0.2f + Max(DotProduct(ExtraFwd, CamTargetEntity->GetForward()), 0.0f);
|
|
}
|
|
Source += FrontDist*Front;
|
|
Front = -Front;
|
|
}else if(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI){
|
|
Front = -1.0f*CamTargetEntity->GetUp();
|
|
Up = CamTargetEntity->GetForward();
|
|
Source += 0.25f*Front;
|
|
}else{
|
|
Source += 0.25f*Front;
|
|
Front = -Front;
|
|
}
|
|
}
|
|
if(CamTargetEntity->IsPed()){
|
|
Angle = CGeneral::GetATanOfXY(Source.x - TargetCoors.x, Source.y - TargetCoors.y) + PI;
|
|
Source.x = 4.5f*Cos(Angle) + TargetCoors.x;
|
|
Source.y = 4.5f*Sin(Angle) + TargetCoors.y;
|
|
Source.z = 1.15f + TargetCoors.z;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
Front = TargetCoors - Source;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
}
|
|
|
|
float BOAT_1STPERSON_L_OFFSETX = 0.7f;
|
|
float BOAT_1STPERSON_R_OFFSETX = 0.3f;
|
|
float BOAT_1STPERSON_LR_OFFSETZ = 0.2f;
|
|
|
|
void
|
|
CCam::LookLeft(void)
|
|
{
|
|
float Dist, TargetOrientation;
|
|
CVector TargetCoors, TargetFwd;
|
|
|
|
if((Mode == MODE_CAM_ON_A_STRING || Mode == MODE_BEHINDBOAT || Mode == MODE_BEHINDCAR) && CamTargetEntity->IsVehicle()){
|
|
LookingLeft = true;
|
|
TargetCoors = CamTargetEntity->GetPosition();
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
if(Mode == MODE_CAM_ON_A_STRING)
|
|
Dist = CA_MAX_DISTANCE;
|
|
else if(Mode == MODE_BEHINDBOAT){
|
|
Dist = 9.0f;
|
|
float Offset = 0.0f;
|
|
if(GetBoatLook_L_R_HeightOffset(Offset) && !CCullZones::Cam1stPersonForPlayer())
|
|
Source.z = TargetCoors.z + Offset;
|
|
}else
|
|
Dist = 9.0f;
|
|
TargetFwd = CamTargetEntity->GetForward();
|
|
TargetFwd.Normalise();
|
|
TargetOrientation = CGeneral::GetATanOfXY(TargetFwd.x, TargetFwd.y);
|
|
Source.x = Dist*Cos(TargetOrientation - HALFPI) + TargetCoors.x;
|
|
Source.y = Dist*Sin(TargetOrientation - HALFPI) + TargetCoors.y;
|
|
|
|
CColModel *colModel = CamTargetEntity->GetColModel();
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
|
|
CVector TopRight = CamTargetEntity->GetPosition() +
|
|
CamTargetEntity->GetRight()*colModel->boundingBox.max.x +
|
|
CamTargetEntity->GetUp()*colModel->boundingBox.max.z;
|
|
float Height = Min(Max(m_cvecTargetCoorsForFudgeInter.z, TopRight.z)+0.1f, OrigSource.z);
|
|
Source.z = Max(Height, Source.z);
|
|
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
Front.z += 1.1f;
|
|
if(Mode == MODE_BEHINDBOAT)
|
|
Front.z += 1.2f;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
if(Mode == MODE_1STPERSON && CamTargetEntity->IsVehicle()){
|
|
LookingLeft = true;
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.25f);
|
|
if(((CVehicle*)CamTargetEntity)->IsBoat()){
|
|
if(((CVehicle*)CamTargetEntity)->pDriver){
|
|
CVector neck(0.0f, 0.0f, 0.0f);
|
|
CPed *driver = ((CVehicle*)CamTargetEntity)->pDriver;
|
|
driver->SetPedPositionInCar();
|
|
driver->GetMatrix().UpdateRW();
|
|
driver->UpdateRwFrame();
|
|
driver->UpdateRpHAnim();
|
|
driver->m_pedIK.GetComponentPosition(neck, PED_NECK);
|
|
Source = neck +
|
|
BOAT_1STPERSON_L_OFFSETX*CamTargetEntity->GetRight() +
|
|
BOAT_1STPERSON_LR_OFFSETZ*CamTargetEntity->GetUp();
|
|
}else
|
|
Source.z -= 0.5f;
|
|
}
|
|
|
|
Up = CamTargetEntity->GetUp();
|
|
Up.Normalise();
|
|
Front = CamTargetEntity->GetForward();
|
|
Front.Normalise();
|
|
Front = -CrossProduct(Front, Up);
|
|
Front.Normalise();
|
|
if(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_BIKE)
|
|
Source -= 1.45f*Front;
|
|
}
|
|
}
|
|
|
|
void
|
|
CCam::LookRight(void)
|
|
{
|
|
float Dist, TargetOrientation;
|
|
CVector TargetCoors, TargetFwd;
|
|
CColPoint colPoint;
|
|
|
|
if((Mode == MODE_CAM_ON_A_STRING || Mode == MODE_BEHINDBOAT) && CamTargetEntity->IsVehicle()){
|
|
LookingRight = true;
|
|
TargetCoors = CamTargetEntity->GetPosition();
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
if(Mode == MODE_CAM_ON_A_STRING)
|
|
Dist = CA_MAX_DISTANCE;
|
|
else if(Mode == MODE_BEHINDBOAT){
|
|
Dist = 9.0f;
|
|
float Offset = 0.0f;
|
|
if(GetBoatLook_L_R_HeightOffset(Offset) && !CCullZones::Cam1stPersonForPlayer())
|
|
Source.z = TargetCoors.z + Offset;
|
|
}else
|
|
Dist = 9.0f;
|
|
TargetFwd = CamTargetEntity->GetForward();
|
|
TargetFwd.Normalise();
|
|
TargetOrientation = CGeneral::GetATanOfXY(TargetFwd.x, TargetFwd.y);
|
|
Source.x = Dist*Cos(TargetOrientation + HALFPI) + TargetCoors.x;
|
|
Source.y = Dist*Sin(TargetOrientation + HALFPI) + TargetCoors.y;
|
|
|
|
CColModel *colModel = CamTargetEntity->GetColModel();
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
|
|
CVector TopLeft = CamTargetEntity->GetPosition() +
|
|
CamTargetEntity->GetRight()*colModel->boundingBox.min.x +
|
|
CamTargetEntity->GetUp()*colModel->boundingBox.max.z;
|
|
float Height = Min(Max(m_cvecTargetCoorsForFudgeInter.z, TopLeft.z)+0.1f, OrigSource.z);
|
|
Source.z = Max(Height, Source.z);
|
|
|
|
Front = CamTargetEntity->GetPosition() - Source;
|
|
Front.z += 1.1f;
|
|
if(Mode == MODE_BEHINDBOAT)
|
|
Front.z += 1.2f;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
if(Mode == MODE_1STPERSON && CamTargetEntity->IsVehicle()){
|
|
LookingRight = true;
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.25f);
|
|
if(((CVehicle*)CamTargetEntity)->IsBoat()){
|
|
if(((CVehicle*)CamTargetEntity)->pDriver){
|
|
CVector neck(0.0f, 0.0f, 0.0f);
|
|
CPed *driver = ((CVehicle*)CamTargetEntity)->pDriver;
|
|
driver->SetPedPositionInCar();
|
|
driver->GetMatrix().UpdateRW();
|
|
driver->UpdateRwFrame();
|
|
driver->UpdateRpHAnim();
|
|
driver->m_pedIK.GetComponentPosition(neck, PED_NECK);
|
|
Source = neck +
|
|
BOAT_1STPERSON_R_OFFSETX*CamTargetEntity->GetRight() +
|
|
BOAT_1STPERSON_LR_OFFSETZ*CamTargetEntity->GetUp();
|
|
}else
|
|
Source.z -= 0.5f;
|
|
}
|
|
|
|
Up = CamTargetEntity->GetUp();
|
|
Up.Normalise();
|
|
Front = CamTargetEntity->GetForward();
|
|
Front.Normalise();
|
|
Front = CrossProduct(Front, Up);
|
|
Front.Normalise();
|
|
if(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_BIKE)
|
|
Source -= 1.45f*Front;
|
|
}
|
|
}
|
|
|
|
void
|
|
CCam::ClipIfPedInFrontOfPlayer(void)
|
|
{
|
|
float FwdAngle, PedAngle, DeltaAngle, fDist, Near;
|
|
CVector vDist;
|
|
CPed *Player;
|
|
bool found = false;
|
|
int ped = 0;
|
|
|
|
// unused: TheCamera.pTargetEntity->GetPosition() - TheCamera.GetGameCamPosition();
|
|
|
|
FwdAngle = CGeneral::GetATanOfXY(TheCamera.GetForward().x, TheCamera.GetForward().y);
|
|
Player = CWorld::Players[CWorld::PlayerInFocus].m_pPed;
|
|
while(ped < Player->m_numNearPeds && !found)
|
|
if(Player->m_nearPeds[ped] && Player->m_nearPeds[ped]->GetPedState() != PED_DEAD)
|
|
found = true;
|
|
else
|
|
ped++;
|
|
if(found){
|
|
vDist = Player->m_nearPeds[ped]->GetPosition() - TheCamera.GetGameCamPosition();
|
|
PedAngle = CGeneral::GetATanOfXY(vDist.x, vDist.y);
|
|
DeltaAngle = FwdAngle - PedAngle;
|
|
while(DeltaAngle >= PI) DeltaAngle -= 2*PI;
|
|
while(DeltaAngle < -PI) DeltaAngle += 2*PI;
|
|
if(Abs(DeltaAngle) < HALFPI){
|
|
fDist = vDist.Magnitude2D();
|
|
if(fDist < 1.25f){
|
|
Near = DEFAULT_NEAR - (1.25f - fDist);
|
|
if(Near < 0.05f)
|
|
Near = 0.05f;
|
|
RwCameraSetNearClipPlane(Scene.camera, Near);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CCam::KeepTrackOfTheSpeed(const CVector &source, const CVector &target, const CVector &up, const float &alpha, const float &beta, const float &fov)
|
|
{
|
|
static CVector PreviousSource = source;
|
|
static CVector PreviousTarget = target;
|
|
static CVector PreviousUp = up;
|
|
static float PreviousBeta = beta;
|
|
static float PreviousAlpha = alpha;
|
|
static float PreviousFov = fov;
|
|
|
|
if(TheCamera.m_bJust_Switched){
|
|
PreviousSource = source;
|
|
PreviousTarget = target;
|
|
PreviousUp = up;
|
|
}
|
|
|
|
m_cvecSourceSpeedOverOneFrame = source - PreviousSource;
|
|
m_cvecTargetSpeedOverOneFrame = target - PreviousTarget;
|
|
m_cvecUpOverOneFrame = up - PreviousUp;
|
|
m_fFovSpeedOverOneFrame = fov - PreviousFov;
|
|
m_fBetaSpeedOverOneFrame = beta - PreviousBeta;
|
|
MakeAngleLessThan180(m_fBetaSpeedOverOneFrame);
|
|
m_fAlphaSpeedOverOneFrame = alpha - PreviousAlpha;
|
|
MakeAngleLessThan180(m_fAlphaSpeedOverOneFrame);
|
|
|
|
PreviousSource = source;
|
|
PreviousTarget = target;
|
|
PreviousUp = up;
|
|
PreviousBeta = beta;
|
|
PreviousAlpha = alpha;
|
|
PreviousFov = fov;
|
|
}
|
|
|
|
bool
|
|
CCam::Using3rdPersonMouseCam(void)
|
|
{
|
|
return CCamera::m_bUseMouse3rdPerson && Mode == MODE_FOLLOWPED;
|
|
}
|
|
|
|
bool
|
|
CCam::GetWeaponFirstPersonOn(void)
|
|
{
|
|
return CamTargetEntity && CamTargetEntity->IsPed() && ((CPed*)CamTargetEntity)->GetWeapon()->m_bAddRotOffset;
|
|
}
|
|
|
|
bool
|
|
CCam::IsTargetInWater(const CVector &CamCoors)
|
|
{
|
|
if(CamTargetEntity){
|
|
float WaterZ = -6000.0f;
|
|
CWaterLevel::GetWaterLevel(CamTargetEntity->GetPosition(), &WaterZ, false);
|
|
if(CamTargetEntity->IsPed()){
|
|
if(((CPed*)CamTargetEntity)->bIsDrowning ||
|
|
((CPed*)CamTargetEntity)->bIsInWater && CamTargetEntity->GetPosition().z < WaterZ)
|
|
return true;
|
|
}else{
|
|
assert(CamTargetEntity->IsVehicle());
|
|
if(((CVehicle*)CamTargetEntity)->bIsDrowning ||
|
|
((CVehicle*)CamTargetEntity)->bIsInWater && CamTargetEntity->GetPosition().z < WaterZ)
|
|
return true;
|
|
}
|
|
}
|
|
m_vecLastAboveWaterCamPosition = Source;
|
|
return false;
|
|
}
|
|
|
|
void
|
|
CCam::PrintMode(void)
|
|
{
|
|
// Doesn't do anything
|
|
char buf[256];
|
|
|
|
if(PrintDebugCode){
|
|
sprintf(buf, " ");
|
|
sprintf(buf, " ");
|
|
sprintf(buf, " ");
|
|
|
|
static Const char *modes[] = { "None",
|
|
"Top Down", "GTA Classic", "Behind Car", "Follow Ped",
|
|
"Aiming", "Debug", "Sniper", "Rocket", "Model Viewer", "Bill",
|
|
"Syphon", "Circle", "Cheesy Zoom", "Wheel", "Fixed",
|
|
"1st Person", "Fly by", "on a String", "Reaction",
|
|
"Follow Ped with Bind", "Chris", "Behind Boat",
|
|
"Player fallen in Water", "Train Roof", "Train Side",
|
|
"Blood on the tracks", "Passenger", "Syphon Crim in Front",
|
|
"Dead Baby", "Pillow Paps", "Look at Cars", "Arrest One",
|
|
"Arrest Two", "M16", "Special fixed for Syphon", "Fight",
|
|
"Top Down Ped", "Lighthouse",
|
|
"Sniper run about", "Rocket run about",
|
|
"1st Person run about", "M16 run about", "Fight run about",
|
|
"Editor", "Helicannon", "Camera"
|
|
};
|
|
sprintf(buf, "Cam: %s", modes[TheCamera.Cams[TheCamera.ActiveCam].Mode]);
|
|
CDebug::PrintAt(buf, 2, 5);
|
|
}
|
|
|
|
if(DebugCamMode != MODE_NONE){
|
|
switch(Mode){
|
|
case MODE_FOLLOWPED:
|
|
sprintf(buf, "Debug:- Cam Choice1. No Locking, used as game default");
|
|
break;
|
|
case MODE_REACTION:
|
|
sprintf(buf, "Debug:- Cam Choice2. Reaction Cam On A String ");
|
|
sprintf(buf, " Uses Locking Button LeftShoulder 1. "); // lie
|
|
break;
|
|
case MODE_FOLLOW_PED_WITH_BIND:
|
|
sprintf(buf, "Debug:- Cam Choice3. Game ReactionCam with Locking ");
|
|
sprintf(buf, " Uses Locking Button LeftShoulder 1. ");
|
|
break;
|
|
case MODE_CHRIS:
|
|
sprintf(buf, "Debug:- Cam Choice4. Chris's idea. ");
|
|
sprintf(buf, " Uses Locking Button LeftShoulder 1. ");
|
|
sprintf(buf, " Also control the camera using the right analogue stick.");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// This code is really bad. wtf R*?
|
|
CVector
|
|
CCam::DoAverageOnVector(const CVector &vec)
|
|
{
|
|
int i;
|
|
CVector Average = { 0.0f, 0.0f, 0.0f };
|
|
|
|
if(ResetStatics){
|
|
m_iRunningVectorArrayPos = 0;
|
|
m_iRunningVectorCounter = 1;
|
|
}
|
|
|
|
// TODO: make this work with NUMBER_OF_VECTORS_FOR_AVERAGE != 2
|
|
if(m_iRunningVectorCounter == 3){
|
|
m_arrPreviousVectors[0] = m_arrPreviousVectors[1];
|
|
m_arrPreviousVectors[1] = vec;
|
|
}else
|
|
m_arrPreviousVectors[m_iRunningVectorArrayPos] = vec;
|
|
|
|
for(i = 0; i <= m_iRunningVectorArrayPos; i++)
|
|
Average += m_arrPreviousVectors[i];
|
|
Average /= i;
|
|
|
|
m_iRunningVectorArrayPos++;
|
|
m_iRunningVectorCounter++;
|
|
if(m_iRunningVectorArrayPos >= NUMBER_OF_VECTORS_FOR_AVERAGE)
|
|
m_iRunningVectorArrayPos = NUMBER_OF_VECTORS_FOR_AVERAGE-1;
|
|
if(m_iRunningVectorCounter > NUMBER_OF_VECTORS_FOR_AVERAGE+1)
|
|
m_iRunningVectorCounter = NUMBER_OF_VECTORS_FOR_AVERAGE+1;
|
|
|
|
return Average;
|
|
}
|
|
|
|
float DefaultAcceleration = 0.045f;
|
|
float DefaultMaxStep = 0.15f;
|
|
float fDefaultSpeedStep = 0.025f;
|
|
float fDefaultSpeedMultiplier = 0.09f;
|
|
float fDefaultSpeedLimit = 0.15f;
|
|
float fDefaultSpeedStep4Avoid = 0.02f;
|
|
float fDefaultSpeedMultiplier4Avoid = 0.05f;
|
|
float fDefaultSpeedLimit4Avoid = 0.25f;
|
|
float fAvoidGeomThreshhold = 1.5f;
|
|
float fMiniGunBetaOffset = 0.3f;
|
|
|
|
void
|
|
CCam::Process_FollowPed(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
CVector TargetCoors, Dist, IdealSource;
|
|
float Length = 0.0f;
|
|
static bool PickedASide;
|
|
static float FixedTargetOrientation = 0.0f;
|
|
float AngleToGoTo = 0.0f;
|
|
bool StandingInTrain = false;
|
|
float ZoomGroundTarget = 0.0f;
|
|
float ZoomZTarget = 0.0f;
|
|
static int TimeIndicatedWantedToGoDown = 0;
|
|
static bool StartedCountingForGoDown = false;
|
|
static float ZoomGround = 0.0f;
|
|
static float ZoomGroundSpeed = 0.0f;
|
|
static float ZoomZ = 0.0f;
|
|
static float ZoomZSpeed = 0.0f;
|
|
float DeltaBeta;
|
|
|
|
m_bFixingBeta = false;
|
|
bBelowMinDist = false;
|
|
bBehindPlayerDesired = false;
|
|
|
|
FOV = DefaultFOV;
|
|
|
|
if(ResetStatics){
|
|
Rotating = false;
|
|
m_bCollisionChecksOn = true;
|
|
FixedTargetOrientation = 0.0f;
|
|
PickedASide = false;
|
|
StartedCountingForGoDown = false;
|
|
AngleToGoTo = 0.0f;
|
|
ZoomGround = 0.0f;
|
|
ZoomGroundSpeed = 0.0f;
|
|
ZoomZ = 0.0f;
|
|
ZoomZSpeed = 0.0f;
|
|
Distance = 500.0f;
|
|
}
|
|
|
|
|
|
TargetCoors = CameraTarget;
|
|
|
|
// Take speed of thing we're standing on into account
|
|
CVector GroundMovement(0.0f, 0.0f, 0.0f);
|
|
CPhysical *ground = (CPhysical*)((CPed*)CamTargetEntity)->m_pCurSurface;
|
|
if(ground && (ground->IsVehicle() || ground->IsObject()))
|
|
GroundMovement += ground->GetSpeed(CamTargetEntity->GetPosition() - ground->GetPosition()) * CTimer::GetTimeStep();
|
|
|
|
Source += GroundMovement;
|
|
IdealSource = Source;
|
|
TargetCoors.z += m_fSyphonModeTargetZOffSet;
|
|
|
|
TargetCoors.z = DoAverageOnVector(TargetCoors).z;
|
|
|
|
Dist.x = IdealSource.x - TargetCoors.x;
|
|
Dist.y = IdealSource.y - TargetCoors.y;
|
|
Length = Dist.Magnitude2D();
|
|
|
|
// Cam on a string. With a fixed distance. Zoom in/out is done later.
|
|
if(Length != 0.0f){
|
|
IdealSource = TargetCoors + CVector(Dist.x, Dist.y, 0.0f)/Length * m_fMinRealGroundDist;
|
|
IdealSource.z += GroundMovement.z;
|
|
}else
|
|
IdealSource = TargetCoors + CVector(1.0f, 1.0f, 0.0f);
|
|
|
|
if(TheCamera.m_bUseTransitionBeta && ResetStatics){
|
|
CVector VecDistance;
|
|
IdealSource.x = TargetCoors.x + m_fMinRealGroundDist*Cos(m_fTransitionBeta);
|
|
IdealSource.y = TargetCoors.y + m_fMinRealGroundDist*Sin(m_fTransitionBeta);
|
|
Beta = CGeneral::GetATanOfXY(IdealSource.x - TargetCoors.x, IdealSource.y - TargetCoors.y);
|
|
}else
|
|
Beta = CGeneral::GetATanOfXY(Source.x - TargetCoors.x, Source.y - TargetCoors.y);
|
|
|
|
if(TheCamera.m_bCamDirectlyBehind){
|
|
m_bCollisionChecksOn = true;
|
|
Beta = TargetOrientation + PI;
|
|
}
|
|
|
|
if(FindPlayerVehicle())
|
|
if(FindPlayerVehicle()->m_vehType == VEHICLE_TYPE_TRAIN)
|
|
StandingInTrain = true;
|
|
|
|
if(TheCamera.m_bCamDirectlyInFront){
|
|
m_bCollisionChecksOn = true;
|
|
Beta = TargetOrientation;
|
|
}
|
|
|
|
while(Beta >= PI) Beta -= 2.0f * PI;
|
|
while(Beta < -PI) Beta += 2.0f * PI;
|
|
|
|
if(TheCamera.PedZoomIndicator == CAM_ZOOM_1 &&
|
|
((CPed*)CamTargetEntity)->GetPedState() != PED_ENTER_CAR &&
|
|
((CPed*)CamTargetEntity)->GetPedState() != PED_CARJACK){
|
|
ZoomGroundTarget = m_fTargetZoomGroundOne;
|
|
ZoomZTarget = m_fTargetZoomOneZExtra;
|
|
}else if(TheCamera.PedZoomIndicator == CAM_ZOOM_2 || TheCamera.PedZoomIndicator == CAM_ZOOM_1){
|
|
ZoomGroundTarget = m_fTargetZoomGroundTwo;
|
|
ZoomZTarget = m_fTargetZoomTwoZExtra;
|
|
}else if(TheCamera.PedZoomIndicator == CAM_ZOOM_3){
|
|
ZoomGroundTarget = m_fTargetZoomGroundThree;
|
|
ZoomZTarget = m_fTargetZoomThreeZExtra;
|
|
}
|
|
if(m_fCloseInPedHeightOffset > 0.00001f){
|
|
ZoomGroundTarget = m_fTargetCloseInDist;
|
|
ZoomZTarget = m_fTargetZoomZCloseIn;
|
|
}
|
|
if(ResetStatics){
|
|
ZoomGround = ZoomGroundTarget;
|
|
ZoomZ = ZoomZTarget;
|
|
}
|
|
|
|
float SpeedStep = fDefaultSpeedStep;
|
|
float SpeedMultiplier = fDefaultSpeedMultiplier;
|
|
float SpeedLimit = fDefaultSpeedLimit;
|
|
bool Shooting = false;
|
|
CPed *ped = (CPed*)CamTargetEntity;
|
|
if(ped->GetWeapon()->m_eWeaponType != WEAPONTYPE_UNARMED)
|
|
if(CPad::GetPad(0)->GetWeapon())
|
|
Shooting = true;
|
|
if(ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_DETONATOR ||
|
|
ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_BASEBALLBAT)
|
|
Shooting = false;
|
|
|
|
|
|
// Figure out if and where we want to rotate
|
|
|
|
if(CPad::GetPad(0)->ForceCameraBehindPlayer() && !CPickups::PlayerOnWeaponPickup || Shooting){
|
|
|
|
// Center cam behind player
|
|
|
|
if(PickedASide){
|
|
if(AngleToGoTo == 0.0f){
|
|
FixedTargetOrientation = TargetOrientation + PI;
|
|
if(Shooting && ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_MINIGUN)
|
|
FixedTargetOrientation -= fMiniGunBetaOffset;
|
|
}
|
|
Rotating = true;
|
|
}else{
|
|
FixedTargetOrientation = TargetOrientation + PI;
|
|
Rotating = true;
|
|
PickedASide = true;
|
|
if(Shooting && ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_MINIGUN)
|
|
FixedTargetOrientation -= fMiniGunBetaOffset;
|
|
}
|
|
}else if(Abs(TheCamera.m_fAvoidTheGeometryProbsTimer) > fAvoidGeomThreshhold && !Rotating ){
|
|
|
|
if(TheCamera.m_fAvoidTheGeometryProbsTimer < 0.0f)
|
|
FixedTargetOrientation = TargetOrientation;
|
|
else
|
|
FixedTargetOrientation = TargetOrientation + PI;
|
|
float dist = (Source - TargetCoors).Magnitude();
|
|
float mult = dist > 0.1f ? 1.0f/dist : 10.0f;
|
|
SpeedStep = mult * fDefaultSpeedStep4Avoid;
|
|
SpeedMultiplier = mult * fDefaultSpeedMultiplier4Avoid;
|
|
SpeedLimit = mult * fDefaultSpeedLimit4Avoid;
|
|
}
|
|
|
|
int MoveState = ((CPed*)CamTargetEntity)->m_nMoveState;
|
|
if(MoveState != PEDMOVE_NONE && MoveState != PEDMOVE_STILL &&
|
|
!(CPad::GetPad(0)->ForceCameraBehindPlayer() && !CPickups::PlayerOnWeaponPickup) && !Shooting){
|
|
Rotating = false;
|
|
if(TheCamera.m_fAvoidTheGeometryProbsTimer <= fAvoidGeomThreshhold)
|
|
BetaSpeed = 0.0f;
|
|
}
|
|
|
|
// Now do the Beta rotation
|
|
|
|
float RotDistance = m_fMinRealGroundDist;
|
|
|
|
if(Rotating || TheCamera.m_fAvoidTheGeometryProbsTimer > fAvoidGeomThreshhold){
|
|
m_bFixingBeta = true;
|
|
|
|
while(FixedTargetOrientation >= PI) FixedTargetOrientation -= 2*PI;
|
|
while(FixedTargetOrientation < -PI) FixedTargetOrientation += 2*PI;
|
|
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
|
|
|
|
// This is inlined WellBufferMe - unfortunately modified so we can't just call it
|
|
{
|
|
DeltaBeta = FixedTargetOrientation - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
|
|
// this is the added bit
|
|
if(!Rotating){
|
|
if(TheCamera.m_nAvoidTheGeometryProbsDirn == -1 && DeltaBeta > 0.0f ||
|
|
TheCamera.m_nAvoidTheGeometryProbsDirn == 1 && DeltaBeta < 0.0f)
|
|
DeltaBeta *= -1.0f;
|
|
}
|
|
|
|
float ReqSpeed = DeltaBeta * SpeedMultiplier;
|
|
// this is also added
|
|
ReqSpeed = clamp(ReqSpeed, -SpeedLimit, SpeedLimit);
|
|
|
|
// Add or subtract absolute depending on sign, genius!
|
|
if(ReqSpeed - BetaSpeed > 0.0f)
|
|
BetaSpeed += SpeedStep * Abs(ReqSpeed - BetaSpeed) * CTimer::GetTimeStep();
|
|
else
|
|
BetaSpeed -= SpeedStep * Abs(ReqSpeed - BetaSpeed) * CTimer::GetTimeStep();
|
|
// this would be simpler:
|
|
// BetaSpeed += SpeedStep * (ReqSpeed - BetaSpeed) * CTimer::ms_fTimeStep;
|
|
|
|
if(ReqSpeed < 0.0f && BetaSpeed < ReqSpeed)
|
|
BetaSpeed = ReqSpeed;
|
|
else if(ReqSpeed > 0.0f && BetaSpeed > ReqSpeed)
|
|
BetaSpeed = ReqSpeed;
|
|
|
|
Beta += BetaSpeed * Min(10.0f, CTimer::GetTimeStep());
|
|
}
|
|
|
|
if(ResetStatics){
|
|
Beta = FixedTargetOrientation;
|
|
BetaSpeed = 0.0f;
|
|
}
|
|
|
|
Source.x = TargetCoors.x + RotDistance * Cos(Beta);
|
|
Source.y = TargetCoors.y + RotDistance * Sin(Beta);
|
|
|
|
// Check if we can stop rotating
|
|
DeltaBeta = FixedTargetOrientation - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
if(Abs(DeltaBeta) < DEGTORAD(1.0f) && !bBehindPlayerDesired){
|
|
// Stop rotation
|
|
PickedASide = false;
|
|
Rotating = false;
|
|
BetaSpeed = 0.0f;
|
|
}
|
|
}
|
|
|
|
|
|
if(TheCamera.m_bCamDirectlyBehind || TheCamera.m_bCamDirectlyInFront ||
|
|
StandingInTrain || Rotating ||
|
|
TheCamera.m_bUseTransitionBeta && ResetStatics ||
|
|
Abs(TheCamera.m_fAvoidTheGeometryProbsTimer) > fAvoidGeomThreshhold){
|
|
if(TheCamera.m_bUseTransitionBeta){
|
|
Beta = m_fTransitionBeta;
|
|
Source.x = TargetCoors.x + RotDistance * Cos(m_fTransitionBeta);
|
|
Source.y = TargetCoors.y + RotDistance * Sin(m_fTransitionBeta);
|
|
}
|
|
if(TheCamera.m_bCamDirectlyBehind){
|
|
Beta = TargetOrientation + PI;
|
|
Source.x = TargetCoors.x + RotDistance * Cos(Beta);
|
|
Source.y = TargetCoors.y + RotDistance * Sin(Beta);
|
|
}
|
|
if(TheCamera.m_bCamDirectlyInFront){
|
|
Beta = TargetOrientation;
|
|
Source.x = TargetCoors.x + RotDistance * Cos(Beta);
|
|
Source.y = TargetCoors.y + RotDistance * Sin(Beta);
|
|
}
|
|
if(StandingInTrain){
|
|
Beta = TargetOrientation + PI;
|
|
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;
|
|
}
|
|
if(StandingInTrain){
|
|
Beta = TargetOrientation + PI;
|
|
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;
|
|
}
|
|
|
|
// Beta and Source already set in the rotation code
|
|
}else{
|
|
Source = IdealSource;
|
|
BetaSpeed = 0.0f;
|
|
}
|
|
Source.z = IdealSource.z;
|
|
|
|
// Zoom out camera
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
WellBufferMe(ZoomGroundTarget, &ZoomGround, &ZoomGroundSpeed, 0.2f, 0.07f, false);
|
|
WellBufferMe(ZoomZTarget, &ZoomZ, &ZoomZSpeed, 0.2f, 0.07f, false);
|
|
Source.x -= Front.x*ZoomGround;
|
|
Source.y -= Front.y*ZoomGround;
|
|
Source.z += ZoomZ;
|
|
|
|
|
|
// Process height offset to avoid peds and cars
|
|
|
|
float TargetZOffSet = Max(m_fDimensionOfHighestNearCar, m_fPedBetweenCameraHeightOffset);
|
|
float TargetHeight = CameraTarget.z + TargetZOffSet - Source.z;
|
|
|
|
if(TargetHeight > m_fCamBufferedHeight){
|
|
// Have to go up
|
|
if(TargetZOffSet == m_fPedBetweenCameraHeightOffset && TargetZOffSet > m_fCamBufferedHeight)
|
|
WellBufferMe(TargetHeight, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.2f, 0.04f, false);
|
|
else
|
|
WellBufferMe(TargetHeight, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.2f, 0.025f, false);
|
|
StartedCountingForGoDown = false;
|
|
}else{
|
|
// Have to go down
|
|
if(StartedCountingForGoDown){
|
|
if(CTimer::GetTimeInMilliseconds() != TimeIndicatedWantedToGoDown){
|
|
if(TargetHeight > 0.0f)
|
|
WellBufferMe(TargetHeight, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.2f, 0.01f, false);
|
|
else
|
|
WellBufferMe(0.0f, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.2f, 0.01f, false);
|
|
}
|
|
}else{
|
|
StartedCountingForGoDown = true;
|
|
TimeIndicatedWantedToGoDown = CTimer::GetTimeInMilliseconds();
|
|
}
|
|
}
|
|
|
|
Source.z += m_fCamBufferedHeight;
|
|
TargetCoors.z += Min(1.0f, m_fCamBufferedHeight/2.0f);
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
float TargetDist = (TargetCoors - Source).Magnitude();
|
|
if(TargetDist < Distance)
|
|
Distance = TargetDist;
|
|
else{
|
|
float f = Pow(0.97f, CTimer::GetTimeStep());
|
|
Distance = (1.0f - f)*TargetDist + f*Distance;
|
|
if(TargetDist > 0.05f)
|
|
Source = TargetCoors + (Source-TargetCoors)*Distance/TargetDist;
|
|
float clip = Distance-fRangePlayerRadius;
|
|
if(clip < RwCameraGetNearClipPlane(Scene.camera))
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(clip, fCloseNearClipLimit));
|
|
}
|
|
|
|
Front = TargetCoors - Source;
|
|
m_fRealGroundDist = Front.Magnitude2D();
|
|
m_fMinDistAwayFromCamWhenInterPolating = m_fRealGroundDist;
|
|
Front.Normalise();
|
|
GetVectorsReadyForRW();
|
|
TheCamera.m_bCamDirectlyBehind = false;
|
|
TheCamera.m_bCamDirectlyInFront = false;
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
float fBaseDist = 1.7f;
|
|
float fAngleDist = 2.0f;
|
|
float fFalloff = 3.0f;
|
|
float fStickSens = 0.01f;
|
|
float fTweakFOV = 1.1f;
|
|
float fTranslateCamUp = 0.8f;
|
|
int16 nFadeControlThreshhold = 45;
|
|
float fDefaultAlphaOrient = -0.22f;
|
|
float fMouseAvoidGeomReturnRate = 0.92f;
|
|
|
|
void
|
|
CCam::Process_FollowPedWithMouse(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
CVector TargetCoors;
|
|
float CamDist;
|
|
CColPoint colPoint;
|
|
CEntity *entity;
|
|
|
|
if(ResetStatics){
|
|
Rotating = false;
|
|
m_bCollisionChecksOn = true;
|
|
CPad::GetPad(0)->ClearMouseHistory();
|
|
ResetStatics = false;
|
|
}
|
|
|
|
bool OnTrain = FindPlayerVehicle() && FindPlayerVehicle()->IsTrain();
|
|
|
|
TargetCoors = CameraTarget;
|
|
TargetCoors.z += fTranslateCamUp;
|
|
|
|
float AlphaOffset, BetaOffset;
|
|
if(CPad::GetPad(0)->IsPlayerControlsDisabledBy(PLAYERCONTROL_PLAYERINFO)){
|
|
CVector ToCam = Source - TargetCoors;
|
|
ToCam.Normalise();
|
|
if(ToCam.z < -0.9f)
|
|
BetaOffset = TargetOrientation + PI;
|
|
else
|
|
BetaOffset = Atan2(ToCam.y, ToCam.x);
|
|
BetaOffset -= Beta;
|
|
AlphaOffset = 0.0f;
|
|
}else{
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
if((MouseX != 0.0f || MouseY != 0.0f) && !CPad::GetPad(0)->ArePlayerControlsDisabled()){
|
|
UseMouse = true;
|
|
LookLeftRight = -2.5f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else{
|
|
LookLeftRight = -CPad::GetPad(0)->LookAroundLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->LookAroundUpDown();
|
|
}
|
|
if(UseMouse){
|
|
BetaOffset = LookLeftRight * TheCamera.m_fMouseAccelHorzntl * FOV/80.0f;
|
|
AlphaOffset = LookUpDown * TheCamera.m_fMouseAccelVertical * FOV/80.0f;
|
|
}else{
|
|
BetaOffset = LookLeftRight * fStickSens * (1.0f/14.0f) * FOV/80.0f * CTimer::GetTimeStep();
|
|
AlphaOffset = LookUpDown * fStickSens * (0.6f/14.0f) * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
}
|
|
|
|
if(TheCamera.GetFading() && TheCamera.GetFadingDirection() == FADE_IN && nFadeControlThreshhold < CDraw::FadeValue ||
|
|
CDraw::FadeValue > 200 ||
|
|
CPad::GetPad(0)->IsPlayerControlsDisabledBy(PLAYERCONTROL_PLAYERINFO)){
|
|
if(Alpha < fDefaultAlphaOrient-0.05f)
|
|
AlphaOffset = 0.05f;
|
|
else if(Alpha < fDefaultAlphaOrient)
|
|
AlphaOffset = fDefaultAlphaOrient - Alpha;
|
|
else if(Alpha > fDefaultAlphaOrient+0.05f)
|
|
AlphaOffset = -0.05f;
|
|
else if(Alpha > fDefaultAlphaOrient)
|
|
AlphaOffset = fDefaultAlphaOrient - Alpha;
|
|
else
|
|
AlphaOffset = 0.0f;
|
|
}
|
|
|
|
Alpha += AlphaOffset;
|
|
Beta += BetaOffset;
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
if(Alpha > DEGTORAD(45.0f)) Alpha = DEGTORAD(45.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
// SA code
|
|
#ifdef FREE_CAM
|
|
if((CCamera::bFreeCam && Alpha > 0.0f) || (!CCamera::bFreeCam && Alpha > fBaseDist))
|
|
#else
|
|
if(Alpha > fBaseDist) // comparing an angle against a distance?
|
|
#endif
|
|
CamDist = fBaseDist + Cos(Min(Alpha*fFalloff, HALFPI))*fAngleDist;
|
|
else
|
|
CamDist = fBaseDist + Cos(Alpha)*fAngleDist;
|
|
|
|
if(TheCamera.m_bUseTransitionBeta)
|
|
Beta = m_fTransitionBeta;
|
|
|
|
if(TheCamera.m_bCamDirectlyBehind)
|
|
Beta = TheCamera.m_PedOrientForBehindOrInFront + PI;
|
|
if(TheCamera.m_bCamDirectlyInFront)
|
|
Beta = TheCamera.m_PedOrientForBehindOrInFront;
|
|
if(OnTrain)
|
|
Beta = TargetOrientation;
|
|
|
|
Front.x = Cos(Alpha) * -Cos(Beta);
|
|
Front.y = Cos(Alpha) * -Sin(Beta);
|
|
Front.z = Sin(Alpha);
|
|
Source = TargetCoors - Front*CamDist;
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
|
|
// Clip Source and fix near clip
|
|
CWorld::pIgnoreEntity = CamTargetEntity;
|
|
entity = nil;
|
|
if(CWorld::ProcessLineOfSight(TargetCoors, Source, colPoint, entity, true, true, true, true, false, false, true)){
|
|
float PedColDist = (TargetCoors - colPoint.point).Magnitude();
|
|
float ColCamDist = CamDist - PedColDist;
|
|
if(entity->IsPed() && ColCamDist > DEFAULT_NEAR + 0.1f){
|
|
// Ped in the way but not clipping through
|
|
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 < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}else{
|
|
RwCameraSetNearClipPlane(Scene.camera, Min(ColCamDist-0.35f, DEFAULT_NEAR));
|
|
}
|
|
}else{
|
|
Source = colPoint.point;
|
|
if(PedColDist < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}
|
|
}
|
|
CWorld::pIgnoreEntity = nil;
|
|
|
|
float ViewPlaneHeight = Tan(DEGTORAD(FOV) / 2.0f);
|
|
float ViewPlaneWidth = ViewPlaneHeight * CDraw::CalculateAspectRatio() * fTweakFOV;
|
|
float Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
float radius = ViewPlaneWidth*Near;
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, false);
|
|
int i = 0;
|
|
while(entity){
|
|
CVector CamToCol = gaTempSphereColPoints[0].point - Source;
|
|
float frontDist = DotProduct(CamToCol, Front);
|
|
float dist = (CamToCol - Front*frontDist).Magnitude() / ViewPlaneWidth;
|
|
|
|
// Try to decrease near clip
|
|
dist = Max(Min(Near, dist), 0.1f);
|
|
if(dist < Near)
|
|
RwCameraSetNearClipPlane(Scene.camera, dist);
|
|
|
|
// Move forward a bit
|
|
if(dist == 0.1f)
|
|
Source += (TargetCoors - Source)*0.3f;
|
|
|
|
Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
#ifndef FIX_BUGS
|
|
// this is wrong...DEGTORAD missing
|
|
radius = Tan(FOV / 2.0f) * CDraw::CalculateAspectRatio() * fTweakFOV * Near;
|
|
#else
|
|
radius = ViewPlaneWidth*Near;
|
|
#endif
|
|
// Keep testing
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, false);
|
|
|
|
i++;
|
|
if(i > 5)
|
|
entity = nil;
|
|
}
|
|
|
|
float TargetDist = (TargetCoors - Source).Magnitude();
|
|
if(TargetDist < Distance)
|
|
Distance = TargetDist;
|
|
else{
|
|
float f = Pow(fMouseAvoidGeomReturnRate, CTimer::GetTimeStep());
|
|
Distance = (1.0f - f)*TargetDist + f*Distance;
|
|
if(TargetDist > 0.05f)
|
|
Source = TargetCoors + (Source-TargetCoors)*Distance/TargetDist;
|
|
float clip = Distance-fRangePlayerRadius;
|
|
if(clip < RwCameraGetNearClipPlane(Scene.camera))
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(clip, fCloseNearClipLimit));
|
|
}
|
|
|
|
TheCamera.m_bCamDirectlyInFront = false;
|
|
TheCamera.m_bCamDirectlyBehind = false;
|
|
|
|
GetVectorsReadyForRW();
|
|
|
|
if(((CPed*)CamTargetEntity)->CanStrafeOrMouseControl() && CDraw::FadeValue < 250 &&
|
|
(TheCamera.GetFadingDirection() != FADE_OUT || CDraw::FadeValue <= 100) &&
|
|
!CPad::GetPad(0)->IsPlayerControlsDisabledBy(PLAYERCONTROL_PLAYERINFO)){
|
|
float Heading = Front.Heading();
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Heading;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Heading;
|
|
TheCamera.pTargetEntity->SetHeading(Heading);
|
|
TheCamera.pTargetEntity->GetMatrix().UpdateRW();
|
|
}
|
|
}
|
|
|
|
float fBillsBetaOffset; // made up name, actually in CCam
|
|
|
|
void
|
|
CCam::Process_BehindCar(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
if(!CamTargetEntity->IsVehicle())
|
|
return;
|
|
|
|
CVector TargetCoors = CameraTarget;
|
|
TargetCoors.z -= 0.2f;
|
|
CA_MAX_DISTANCE = 9.95f;
|
|
CA_MIN_DISTANCE = 8.5f;
|
|
|
|
CVector Dist = Source - TargetCoors;
|
|
float Length = Dist.Magnitude2D();
|
|
m_fDistanceBeforeChanges = Length;
|
|
if(Length < 0.002f)
|
|
Length = 0.002f;
|
|
Beta = CGeneral::GetATanOfXY(TargetCoors.x - Source.x, TargetCoors.y - Source.y);
|
|
#ifdef TOGGLEABLE_BETA_FEATURES
|
|
// This is completely made up but Bill's cam manipulates an angle before calling this
|
|
// and otherwise calculating Beta doesn't make much sense.
|
|
Beta += fBillsBetaOffset;
|
|
fBillsBetaOffset = 0.0f;
|
|
Dist.x = -Length*Cos(Beta);
|
|
Dist.y = -Length*Sin(Beta);
|
|
Source = TargetCoors + Dist;
|
|
#endif
|
|
if(Length > CA_MAX_DISTANCE){
|
|
Source.x = TargetCoors.x + Dist.x/Length * CA_MAX_DISTANCE;
|
|
Source.y = TargetCoors.y + Dist.y/Length * CA_MAX_DISTANCE;
|
|
}else if(Length < CA_MIN_DISTANCE){
|
|
Source.x = TargetCoors.x + Dist.x/Length * CA_MIN_DISTANCE;
|
|
Source.y = TargetCoors.y + Dist.y/Length * CA_MIN_DISTANCE;
|
|
}
|
|
TargetCoors.z += 0.8f;
|
|
|
|
Alpha = DEGTORAD(25.0f);
|
|
Source.z = TargetCoors.z + CA_MAX_DISTANCE*Sin(Alpha);
|
|
|
|
RotCamIfInFrontCar(TargetCoors, TargetOrientation);
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, m_cvecTargetCoorsForFudgeInter, Source, FOV);
|
|
|
|
Front = TargetCoors - Source;
|
|
ResetStatics = false;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
|
|
float ZmOneAlphaOffset[] = { -0.01f, 0.1f, 0.125f, -0.1f, -0.06f };
|
|
float ZmTwoAlphaOffset[] = { 0.045f, 0.12f, 0.045f, 0.045f, -0.035f };
|
|
float ZmThreeAlphaOffset[] = { 0.005f, 0.005f, 0.15f, 0.005f, 0.12f };
|
|
float INIT_RC_HELI_HORI_EXTRA = 6.0f;
|
|
float INIT_RC_PLANE_HORI_EXTRA = 9.5f;
|
|
float INIT_RC_HELI_ALPHA_EXTRA = 0.2f;
|
|
float INIT_RC_PLANE_ALPHA_EXTRA = 0.295f;
|
|
|
|
void
|
|
CCam::WorkOutCamHeight(const CVector &TargetCoors, float TargetOrientation, float TargetHeight)
|
|
{
|
|
if(!CamTargetEntity->IsVehicle())
|
|
return;
|
|
|
|
static float AlphaOffset = 0.0;
|
|
static float AlphaOffsetSpeed = 0.0;
|
|
static float AlphaDec = 0.0f;
|
|
|
|
bool isHeli = false;
|
|
bool isBike = false;
|
|
int appearance = ((CVehicle*)CamTargetEntity)->GetVehicleAppearance();
|
|
if(appearance == VEHICLE_APPEARANCE_BIKE)
|
|
isBike = true;
|
|
if(appearance == VEHICLE_APPEARANCE_HELI)
|
|
isHeli = true;
|
|
int index = 0;
|
|
TheCamera.GetArrPosForVehicleType(appearance, index);
|
|
|
|
float ExtraOffset = 0.0f;
|
|
int id = CamTargetEntity->GetModelIndex();
|
|
if(id == MI_RCRAIDER || id == MI_RCGOBLIN)
|
|
ExtraOffset = INIT_RC_HELI_ALPHA_EXTRA;
|
|
else if(id == MI_RCBARON)
|
|
ExtraOffset = INIT_RC_PLANE_ALPHA_EXTRA;
|
|
|
|
if(ResetStatics){
|
|
AlphaOffset = 0.0f;
|
|
AlphaOffsetSpeed = 0.0f;
|
|
AlphaDec = 0.0f;
|
|
|
|
if(TheCamera.CarZoomIndicator == CAM_ZOOM_1)
|
|
AlphaOffset = ZmOneAlphaOffset[index] + ExtraOffset;
|
|
else if(TheCamera.CarZoomIndicator == CAM_ZOOM_2)
|
|
AlphaOffset = ZmTwoAlphaOffset[index] + ExtraOffset;
|
|
else if(TheCamera.CarZoomIndicator == CAM_ZOOM_3)
|
|
AlphaOffset = ZmThreeAlphaOffset[index] + ExtraOffset;
|
|
}
|
|
|
|
if(TheCamera.CarZoomIndicator == CAM_ZOOM_1)
|
|
WellBufferMe(ZmOneAlphaOffset[index] + ExtraOffset, &AlphaOffset, &AlphaOffsetSpeed, 0.17f, 0.08f, false);
|
|
else if(TheCamera.CarZoomIndicator == CAM_ZOOM_2)
|
|
WellBufferMe(ZmTwoAlphaOffset[index] + ExtraOffset, &AlphaOffset, &AlphaOffsetSpeed, 0.17f, 0.08f, false);
|
|
else if(TheCamera.CarZoomIndicator == CAM_ZOOM_3)
|
|
WellBufferMe(ZmThreeAlphaOffset[index] + ExtraOffset, &AlphaOffset, &AlphaOffsetSpeed, 0.17f, 0.08f, false);
|
|
|
|
float Length = (Source - TargetCoors).Magnitude2D();
|
|
|
|
CVector Forward = CamTargetEntity->GetForward();
|
|
float CarAlpha = CGeneral::GetATanOfXY(Forward.Magnitude2D(), Forward.z);
|
|
// this shouldn't be necessary....
|
|
while(CarAlpha >= PI) CarAlpha -= 2*PI;
|
|
while(CarAlpha < -PI) CarAlpha += 2*PI;
|
|
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
|
|
float DeltaBeta = Beta - TargetOrientation;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
|
|
float BehindCarNess = Cos(DeltaBeta); // 1 if behind car, 0 if side, -1 if in front
|
|
CarAlpha = -CarAlpha * BehindCarNess;
|
|
|
|
float fwdSpeed = DotProduct(((CPhysical*)CamTargetEntity)->m_vecMoveSpeed, CamTargetEntity->GetForward())*180.0f;
|
|
if(CamTargetEntity->GetModelIndex() == MI_FIRETRUCK && CPad::GetPad(0)->GetCarGunFired()){
|
|
CarAlpha = DEGTORAD(10.0f);
|
|
}else if(isHeli){
|
|
CarAlpha = 0.0f;
|
|
float heliFwdZ = CamTargetEntity->GetForward().z;
|
|
float heliFwdXY = CamTargetEntity->GetForward().Magnitude2D();
|
|
float alphaAmount = Min(Abs(fwdSpeed/90.0f), 1.0f);
|
|
if(heliFwdXY != 0.0f || heliFwdZ != 0.0f)
|
|
CarAlpha = CGeneral::GetATanOfXY(heliFwdXY, Abs(heliFwdZ)) * alphaAmount;
|
|
|
|
CColPoint point;
|
|
CEntity *entity = nil;
|
|
CVector Test = Source;
|
|
Test.z = TargetCoors.z + 0.2f + Length*Sin(CarAlpha+AlphaOffset) + m_fCloseInCarHeightOffset;
|
|
if(CWorld::ProcessVerticalLine(Test, CamTargetEntity->GetPosition().z, point, entity, true, false, false, false, false, false, nil)){
|
|
float sin = (point.point.z - TargetCoors.z - 0.2f - m_fCloseInCarHeightOffset)/Length;
|
|
CarAlpha = Asin(clamp(sin, -1.0f, 1.0f)) - AlphaOffset;
|
|
if(CarAlpha < 0.0f)
|
|
AlphaOffset += CarAlpha;
|
|
}
|
|
}
|
|
|
|
CarAlpha = CGeneral::LimitRadianAngle(CarAlpha);
|
|
if(CarAlpha < 0.0f) CarAlpha = 0.0f;
|
|
if(CarAlpha > DEGTORAD(89.0f)) CarAlpha = DEGTORAD(89.0f);
|
|
|
|
if(ResetStatics)
|
|
Alpha = CarAlpha;
|
|
|
|
float TargetAlpha = Alpha;
|
|
float DeltaAlpha = CarAlpha - TargetAlpha;
|
|
while(DeltaAlpha >= PI) DeltaAlpha -= 2*PI;
|
|
while(DeltaAlpha < -PI) DeltaAlpha += 2*PI;
|
|
if(Abs(DeltaAlpha) > 0.0f && !TheCamera.m_bVehicleSuspenHigh)
|
|
TargetAlpha = CarAlpha;
|
|
|
|
if(isBike)
|
|
WellBufferMe(TargetAlpha, &Alpha, &AlphaSpeed, 0.09f, 0.04f, true);
|
|
else if(isHeli)
|
|
WellBufferMe(TargetAlpha, &Alpha, &AlphaSpeed, 0.09f, 0.04f, true);
|
|
else
|
|
WellBufferMe(TargetAlpha, &Alpha, &AlphaSpeed, 0.15f, 0.07f, true);
|
|
|
|
Source.z = TargetCoors.z + Sin(Alpha + AlphaOffset)*Length + m_fCloseInCarHeightOffset;
|
|
AlphaOffset -= AlphaDec;
|
|
}
|
|
|
|
// Rotate cam behind the car when the car is moving forward
|
|
bool
|
|
CCam::RotCamIfInFrontCar(CVector &TargetCoors, float TargetOrientation)
|
|
{
|
|
float BetaMaxSpeed = 0.15f;
|
|
float BetaAcceleration = 0.007f;
|
|
bool MovingForward = false;
|
|
float MaxDiffBeta = DEGTORAD(160.0f);
|
|
CPhysical *phys = (CPhysical*)CamTargetEntity;
|
|
|
|
float ForwardSpeed = DotProduct(phys->GetForward(), phys->GetSpeed(CVector(0.0f, 0.0f, 0.0f)));
|
|
if(ForwardSpeed > 0.02f)
|
|
MovingForward = true;
|
|
|
|
if(phys->IsVehicle() && (phys->GetModelIndex() == MI_SPARROW || phys->GetModelIndex() == MI_HUNTER)){
|
|
MaxDiffBeta = DEGTORAD(160.0f);
|
|
BetaMaxSpeed = 0.1f;
|
|
BetaAcceleration = 0.003f;
|
|
CVector speed = phys->GetSpeed(CVector(0.0f, 0.0f, 0.0f));
|
|
speed.z = 0.0f;
|
|
if(50.0f*speed.Magnitude() > 3.13f)
|
|
TargetOrientation = CGeneral::GetATanOfXY(speed.x, speed.y);
|
|
}
|
|
|
|
float Dist = (Source - TargetCoors).Magnitude2D();
|
|
|
|
float DeltaBeta = TargetOrientation - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
|
|
if(Abs(DeltaBeta) > PI-MaxDiffBeta && MovingForward && TheCamera.m_uiTransitionState == 0)
|
|
m_bFixingBeta = true;
|
|
|
|
CPad *pad = CPad::GetPad(0);
|
|
if(!(pad->GetLookBehindForCar() || pad->GetLookBehindForPed() || pad->GetLookLeft() || pad->GetLookRight()))
|
|
if(DirectionWasLooking != LOOKING_FORWARD)
|
|
TheCamera.m_bCamDirectlyBehind = true;
|
|
|
|
if(!m_bFixingBeta && !TheCamera.m_bUseTransitionBeta && !TheCamera.m_bCamDirectlyBehind && !TheCamera.m_bCamDirectlyInFront)
|
|
return false;
|
|
|
|
bool SetBeta = false;
|
|
if(TheCamera.m_bCamDirectlyBehind || TheCamera.m_bCamDirectlyInFront || TheCamera.m_bUseTransitionBeta)
|
|
if(&TheCamera.Cams[TheCamera.ActiveCam] == this)
|
|
SetBeta = true;
|
|
|
|
if(m_bFixingBeta || SetBeta){
|
|
WellBufferMe(TargetOrientation, &Beta, &BetaSpeed, BetaMaxSpeed, BetaAcceleration, true);
|
|
|
|
if(TheCamera.m_bCamDirectlyBehind && &TheCamera.Cams[TheCamera.ActiveCam] == this)
|
|
Beta = TargetOrientation;
|
|
if(TheCamera.m_bCamDirectlyInFront && &TheCamera.Cams[TheCamera.ActiveCam] == this)
|
|
Beta = TargetOrientation + PI;
|
|
if(TheCamera.m_bUseTransitionBeta && &TheCamera.Cams[TheCamera.ActiveCam] == this)
|
|
Beta = m_fTransitionBeta;
|
|
|
|
Source.x = TargetCoors.x - Cos(Beta)*Dist;
|
|
Source.y = TargetCoors.y - Sin(Beta)*Dist;
|
|
|
|
// Check if we're done
|
|
DeltaBeta = TargetOrientation - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
if(Abs(DeltaBeta) < DEGTORAD(2.0f))
|
|
m_bFixingBeta = false;
|
|
}
|
|
TheCamera.m_bCamDirectlyBehind = false;
|
|
TheCamera.m_bCamDirectlyInFront = false;
|
|
return true;
|
|
}
|
|
|
|
float FIRETRUCK_TRACKING_MULT = 0.1f;
|
|
float fTestShiftHeliCamTarget = 0.6f;
|
|
float TiltTopSpeed[] = { 0.035f, 0.035f, 0.001f, 0.005f, 0.035f };
|
|
float TiltSpeedStep[] = { 0.016f, 0.016f, 0.0002f, 0.0014f, 0.016f };
|
|
float TiltOverShoot[] = { 1.05f, 1.05f, 0.0f, 0.0f, 1.0f };
|
|
|
|
void
|
|
CCam::Process_Cam_On_A_String(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsVehicle())
|
|
return;
|
|
|
|
// unused
|
|
// ((CVehicle*)CamTargetEntity)->GetVehicleAppearance();
|
|
|
|
FOV = DefaultFOV;
|
|
|
|
if(ResetStatics){
|
|
AlphaSpeed = 0.0f;
|
|
m_fTilt = 0.0f;
|
|
m_fTiltSpeed = 0.0;
|
|
}
|
|
|
|
CBaseModelInfo *mi = CModelInfo::GetModelInfo(CamTargetEntity->GetModelIndex());
|
|
CVector Dimensions = mi->GetColModel()->boundingBox.max - mi->GetColModel()->boundingBox.min;
|
|
CVector TargetCoors = CameraTarget;
|
|
float BaseDist = Dimensions.Magnitude();
|
|
|
|
if(((CVehicle*)CamTargetEntity)->IsBike())
|
|
BaseDist *= 1.45f;
|
|
if(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI &&
|
|
CamTargetEntity->GetStatus() != STATUS_PLAYER_REMOTE)
|
|
TargetCoors += fTestShiftHeliCamTarget * CamTargetEntity->GetUp() * Dimensions.z;
|
|
else
|
|
TargetCoors.z += 0.8f*Dimensions.z;
|
|
|
|
Beta = CGeneral::GetATanOfXY(TargetCoors.x - Source.x, TargetCoors.y - Source.y);
|
|
Alpha = CGeneral::LimitRadianAngle(Alpha);
|
|
Beta = CGeneral::LimitRadianAngle(Beta);
|
|
|
|
if(CamTargetEntity->GetModelIndex() == MI_FIRETRUCK && CPad::GetPad(0)->GetCarGunFired() &&
|
|
((CVehicle*)CamTargetEntity)->m_vecMoveSpeed.Magnitude2D() < 0.01f){
|
|
float TargetBeta = CamTargetEntity->GetForward().Heading() - ((CAutomobile*)CamTargetEntity)->m_fCarGunLR + HALFPI;
|
|
TargetBeta = CGeneral::LimitRadianAngle(TargetBeta);
|
|
float DeltaBeta = TargetBeta - Beta;
|
|
if(DeltaBeta > PI) DeltaBeta -= TWOPI;
|
|
else if(DeltaBeta < -PI) DeltaBeta += TWOPI;
|
|
float dist = (TargetCoors - Source).Magnitude();
|
|
dist = FIRETRUCK_TRACKING_MULT*dist*clamp(DeltaBeta, -0.8f, 0.8f);
|
|
Source += dist*CrossProduct(Front, CVector(0.0f, 0.0f, 1.0f));
|
|
}
|
|
|
|
m_fDistanceBeforeChanges = (Source - TargetCoors).Magnitude2D();
|
|
|
|
Cam_On_A_String_Unobscured(TargetCoors, BaseDist);
|
|
WorkOutCamHeight(TargetCoors, TargetOrientation, Dimensions.z);
|
|
RotCamIfInFrontCar(TargetCoors, TargetOrientation);
|
|
FixCamWhenObscuredByVehicle(TargetCoors);
|
|
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
CVector OrigSource = Source;
|
|
if(CWorld::GetIsLineOfSightClear(CamTargetEntity->GetPosition(), m_cvecTargetCoorsForFudgeInter, true, false, false, true, false, false, true))
|
|
TheCamera.AvoidTheGeometry(OrigSource, m_cvecTargetCoorsForFudgeInter, Source, FOV);
|
|
else
|
|
TheCamera.AvoidTheGeometry(OrigSource, CamTargetEntity->GetPosition(), Source, FOV);
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
|
|
int appearance = ((CVehicle*)CamTargetEntity)->GetVehicleAppearance();
|
|
int index = 0;
|
|
TheCamera.GetArrPosForVehicleType(appearance, index);
|
|
|
|
if(appearance == VEHICLE_APPEARANCE_HELI){
|
|
float TargetTilt = DotProduct(Front, ((CVehicle*)CamTargetEntity)->GetSpeed(CVector(0.0f, 0.0f, 0.0f)));
|
|
CVector UpTarget = CamTargetEntity->GetUp();
|
|
UpTarget.Normalise();
|
|
int dir = TargetTilt < 0.0f ? -1 : 1;
|
|
if(m_fTilt != 0.0f)
|
|
TargetTilt += TiltOverShoot[index]*TargetTilt/m_fTilt * dir;
|
|
WellBufferMe(TargetTilt, &m_fTilt, &m_fTiltSpeed, TiltTopSpeed[index], TiltSpeedStep[index], false);
|
|
|
|
Up = CVector(0.0f, 0.0f, 1.0f) - (CVector(0.0f, 0.0f, 1.0f) - UpTarget)*m_fTilt;
|
|
Up.Normalise();
|
|
Front.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Up = CrossProduct(Front, Left);
|
|
Up.Normalise();
|
|
}else{
|
|
float TargetRoll;
|
|
if(CPad::GetPad(0)->GetDPadLeft() || CPad::GetPad(0)->GetDPadRight()){
|
|
float fwdSpeed = 180.0f*DotProduct(((CVehicle*)CamTargetEntity)->m_vecMoveSpeed, CamTargetEntity->GetForward());
|
|
if(fwdSpeed > 210.0f) fwdSpeed = 210.0f;
|
|
if(CPad::GetPad(0)->GetDPadLeft())
|
|
TargetRoll = DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle;
|
|
else
|
|
TargetRoll = -(DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle);
|
|
CVector FwdTarget = CamTargetEntity->GetForward();
|
|
FwdTarget.Normalise();
|
|
float AngleDiff = DotProduct(FwdTarget, Front);
|
|
AngleDiff = Acos(Min(Abs(AngleDiff), 1.0f));
|
|
TargetRoll *= fwdSpeed/210.0f * Sin(AngleDiff);
|
|
}else{
|
|
float fwdSpeed = 180.0f*DotProduct(((CVehicle*)CamTargetEntity)->m_vecMoveSpeed, CamTargetEntity->GetForward());
|
|
if(fwdSpeed > 210.0f) fwdSpeed = 210.0f;
|
|
TargetRoll = CPad::GetPad(0)->GetLeftStickX()/128.0f * fwdSpeed/210.0f;
|
|
CVector FwdTarget = CamTargetEntity->GetForward();
|
|
FwdTarget.Normalise();
|
|
float AngleDiff = DotProduct(FwdTarget, Front);
|
|
AngleDiff = Acos(Min(Abs(AngleDiff), 1.0f));
|
|
TargetRoll *= (DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle) * Sin(AngleDiff);
|
|
}
|
|
|
|
WellBufferMe(TargetRoll, &f_Roll, &f_rollSpeed, 0.15f, 0.07f, false);
|
|
Up = CVector(Cos(f_Roll + HALFPI), 0.0f, Sin(f_Roll + HALFPI));
|
|
Up.Normalise();
|
|
Front.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Left.Normalise();
|
|
Up = CrossProduct(Front, Left);
|
|
Up.Normalise();
|
|
}
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
// Basic Cam on a string algorithm
|
|
void
|
|
CCam::Cam_On_A_String_Unobscured(const CVector &TargetCoors, float BaseDist)
|
|
{
|
|
int id = CamTargetEntity->GetModelIndex();
|
|
float ExtraDist = 0.0f;
|
|
if(id == MI_RCRAIDER || id == MI_RCGOBLIN)
|
|
ExtraDist = INIT_RC_HELI_HORI_EXTRA;
|
|
else if(id == MI_RCBARON)
|
|
ExtraDist = INIT_RC_PLANE_HORI_EXTRA;
|
|
|
|
CA_MAX_DISTANCE = BaseDist + 0.1f + TheCamera.CarZoomValueSmooth + ExtraDist;
|
|
CA_MIN_DISTANCE = Min(BaseDist*0.6f, 3.5f);
|
|
if(CA_MIN_DISTANCE > CA_MAX_DISTANCE)
|
|
CA_MIN_DISTANCE = CA_MAX_DISTANCE - 0.05f;
|
|
|
|
CVector Dist = Source - TargetCoors;
|
|
|
|
if(ResetStatics)
|
|
Source = TargetCoors + Dist*(CA_MAX_DISTANCE + 1.0f);
|
|
|
|
Dist = Source - TargetCoors;
|
|
|
|
float Length = Dist.Magnitude2D();
|
|
if(Length < 0.001f){
|
|
// This probably shouldn't happen. reset view
|
|
CVector Forward = CamTargetEntity->GetForward();
|
|
Forward.z = 0.0f;
|
|
Forward.Normalise();
|
|
Source = TargetCoors - Forward*CA_MAX_DISTANCE;
|
|
Dist = Source - TargetCoors;
|
|
Length = Dist.Magnitude2D();
|
|
}
|
|
|
|
if(Length > CA_MAX_DISTANCE){
|
|
Source.x = TargetCoors.x + Dist.x/Length * CA_MAX_DISTANCE;
|
|
Source.y = TargetCoors.y + Dist.y/Length * CA_MAX_DISTANCE;
|
|
}else if(Length < CA_MIN_DISTANCE){
|
|
Source.x = TargetCoors.x + Dist.x/Length * CA_MIN_DISTANCE;
|
|
Source.y = TargetCoors.y + Dist.y/Length * CA_MIN_DISTANCE;
|
|
}
|
|
}
|
|
|
|
void
|
|
CCam::FixCamWhenObscuredByVehicle(const CVector &TargetCoors)
|
|
{
|
|
// BUG? is this never reset
|
|
static float HeightFixerCarsObscuring = 0.0f;
|
|
static float HeightFixerCarsObscuringSpeed = 0.0f;
|
|
CColPoint colPoint;
|
|
CEntity *entity = nil;
|
|
|
|
float HeightTarget = 0.0f;
|
|
if(CWorld::ProcessLineOfSight(TargetCoors, Source, colPoint, entity, false, true, false, false, false, false, false)){
|
|
CBaseModelInfo *mi = CModelInfo::GetModelInfo(entity->GetModelIndex());
|
|
HeightTarget = mi->GetColModel()->boundingBox.max.z + 1.0f + TargetCoors.z - Source.z;
|
|
if(HeightTarget < 0.0f)
|
|
HeightTarget = 0.0f;
|
|
}
|
|
WellBufferMe(HeightTarget, &HeightFixerCarsObscuring, &HeightFixerCarsObscuringSpeed, 0.2f, 0.025f, false);
|
|
Source.z += HeightFixerCarsObscuring;
|
|
}
|
|
|
|
void
|
|
CCam::Process_TopDown(const CVector &CameraTarget, float TargetOrientation, float SpeedVar, float TargetSpeedVar)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
if(!CamTargetEntity->IsVehicle())
|
|
return;
|
|
|
|
float Dist;
|
|
float HeightTarget = 0.0f;
|
|
static float AdjustHeightTargetMoveBuffer = 0.0f;
|
|
static float AdjustHeightTargetMoveSpeed = 0.0f;
|
|
static float NearClipDistance = 1.5f;
|
|
const float FarClipDistance = 200.0f;
|
|
CVector TargetFront, Target;
|
|
CVector TestSource, TestTarget;
|
|
CColPoint colPoint;
|
|
CEntity *entity;
|
|
|
|
TargetFront = CameraTarget;
|
|
TargetFront.x += 18.0f*CamTargetEntity->GetForward().x*SpeedVar;
|
|
TargetFront.y += 18.0f*CamTargetEntity->GetForward().y*SpeedVar;
|
|
|
|
if(ResetStatics){
|
|
AdjustHeightTargetMoveBuffer = 0.0f;
|
|
AdjustHeightTargetMoveSpeed = 0.0f;
|
|
}
|
|
|
|
float f = Pow(0.8f, 4.0f);
|
|
Target = f*CameraTarget + (1.0f-f)*TargetFront;
|
|
if(Mode == MODE_GTACLASSIC)
|
|
SpeedVar = TargetSpeedVar;
|
|
Source = Target + CVector(0.0f, 0.0f, (40.0f*SpeedVar + 30.0f)*0.8f);
|
|
// What is this? looks horrible
|
|
if(Mode == MODE_GTACLASSIC)
|
|
Source.x += (uint8)(100.0f*CameraTarget.x)/500.0f;
|
|
|
|
TestSource = Source;
|
|
TestTarget = TestSource;
|
|
TestTarget.z = Target.z;
|
|
if(CWorld::ProcessLineOfSight(TestTarget, TestSource, colPoint, entity, true, false, false, false, false, false, false)){
|
|
if(Source.z < colPoint.point.z+3.0f)
|
|
HeightTarget = colPoint.point.z+3.0f - Source.z;
|
|
}else{
|
|
TestSource = Source;
|
|
TestTarget = TestSource;
|
|
TestTarget.z += 10.0f;
|
|
if(CWorld::ProcessLineOfSight(TestTarget, TestSource, colPoint, entity, true, false, false, false, false, false, false))
|
|
if(Source.z < colPoint.point.z+3.0f)
|
|
HeightTarget = colPoint.point.z+3.0f - Source.z;
|
|
}
|
|
WellBufferMe(HeightTarget, &AdjustHeightTargetMoveBuffer, &AdjustHeightTargetMoveSpeed, 0.2f, 0.02f, false);
|
|
Source.z += AdjustHeightTargetMoveBuffer;
|
|
|
|
if(RwCameraGetFarClipPlane(Scene.camera) > FarClipDistance)
|
|
RwCameraSetFarClipPlane(Scene.camera, FarClipDistance);
|
|
RwCameraSetNearClipPlane(Scene.camera, NearClipDistance);
|
|
|
|
Front = CVector(-0.01f, -0.01f, -1.0f); // look down
|
|
Front.Normalise();
|
|
Dist = (Source - CameraTarget).Magnitude();
|
|
m_cvecTargetCoorsForFudgeInter = Dist*Front + Source;
|
|
Up = CVector(0.0f, 1.0f, 0.0f);
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
void
|
|
CCam::AvoidWallsTopDownPed(const CVector &TargetCoors, const CVector &Offset, float *Adjuster, float *AdjusterSpeed, float yDistLimit)
|
|
{
|
|
float Target = 0.0f;
|
|
float MaxSpeed = 0.13f;
|
|
float Acceleration = 0.015f;
|
|
float SpeedMult;
|
|
float dy;
|
|
CVector TestPoint2;
|
|
CVector TestPoint1;
|
|
CColPoint colPoint;
|
|
CEntity *entity;
|
|
|
|
TestPoint2 = TargetCoors + Offset;
|
|
TestPoint1 = TargetCoors;
|
|
TestPoint1.z = TestPoint2.z;
|
|
if(CWorld::ProcessLineOfSight(TestPoint1, TestPoint2, colPoint, entity, true, false, false, false, false, false, false)){
|
|
// What is this even?
|
|
dy = TestPoint1.y - colPoint.point.y;
|
|
if(dy > yDistLimit)
|
|
dy = yDistLimit;
|
|
SpeedMult = yDistLimit - Abs(dy/yDistLimit);
|
|
|
|
Target = 2.5f;
|
|
MaxSpeed += SpeedMult*0.3f;
|
|
Acceleration += SpeedMult*0.03f;
|
|
}
|
|
WellBufferMe(Target, Adjuster, AdjusterSpeed, MaxSpeed, Acceleration, false);
|
|
}
|
|
|
|
void
|
|
CCam::Process_TopDownPed(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
float Dist;
|
|
float HeightTarget;
|
|
static int NumPedPosCountsSoFar = 0;
|
|
static float PedAverageSpeed = 0.0f;
|
|
static float AdjustHeightTargetMoveBuffer = 0.0f;
|
|
static float AdjustHeightTargetMoveSpeed = 0.0f;
|
|
static float PedSpeedSoFar = 0.0f;
|
|
static float FarClipDistance = 200.0f;
|
|
static float NearClipDistance = 1.5f;
|
|
static float TargetAdjusterForSouth = 0.0f;
|
|
static float TargetAdjusterSpeedForSouth = 0.0f;
|
|
static float TargetAdjusterForNorth = 0.0f;
|
|
static float TargetAdjusterSpeedForNorth = 0.0f;
|
|
static float TargetAdjusterForEast = 0.0f;
|
|
static float TargetAdjusterSpeedForEast = 0.0f;
|
|
static float TargetAdjusterForWest = 0.0f;
|
|
static float TargetAdjusterSpeedForWest = 0.0f;
|
|
static CVector PreviousPlayerMoveSpeedVec;
|
|
CVector TargetCoors, PlayerMoveSpeed;
|
|
CVector TestSource, TestTarget;
|
|
CColPoint colPoint;
|
|
CEntity *entity;
|
|
|
|
FOV = DefaultFOV;
|
|
TargetCoors = CameraTarget;
|
|
PlayerMoveSpeed = ((CPed*)CamTargetEntity)->GetMoveSpeed();
|
|
|
|
if(ResetStatics){
|
|
PreviousPlayerMoveSpeedVec = PlayerMoveSpeed;
|
|
AdjustHeightTargetMoveBuffer = 0.0f;
|
|
AdjustHeightTargetMoveSpeed = 0.0f;
|
|
NumPedPosCountsSoFar = 0;
|
|
PedSpeedSoFar = 0.0f;
|
|
PedAverageSpeed = 0.0f;
|
|
TargetAdjusterForWest = 0.0f;
|
|
TargetAdjusterSpeedForWest = 0.0f;
|
|
TargetAdjusterForEast = 0.0f;
|
|
TargetAdjusterSpeedForEast = 0.0f;
|
|
TargetAdjusterForNorth = 0.0f;
|
|
TargetAdjusterSpeedForNorth = 0.0f;
|
|
TargetAdjusterForSouth = 0.0f;
|
|
TargetAdjusterSpeedForSouth = 0.0f;
|
|
}
|
|
|
|
if(RwCameraGetFarClipPlane(Scene.camera) > FarClipDistance)
|
|
RwCameraSetFarClipPlane(Scene.camera, FarClipDistance);
|
|
RwCameraSetNearClipPlane(Scene.camera, NearClipDistance);
|
|
|
|
// Average ped speed
|
|
NumPedPosCountsSoFar++;
|
|
PedSpeedSoFar += PlayerMoveSpeed.Magnitude();
|
|
if(NumPedPosCountsSoFar == 5){
|
|
PedAverageSpeed = 0.4f*PedAverageSpeed + 0.6*(PedSpeedSoFar/5.0f);
|
|
NumPedPosCountsSoFar = 0;
|
|
PedSpeedSoFar = 0.0f;
|
|
}
|
|
PreviousPlayerMoveSpeedVec = PlayerMoveSpeed;
|
|
|
|
// Zoom out depending on speed
|
|
if(PedAverageSpeed > 0.01f && PedAverageSpeed <= 0.04f)
|
|
HeightTarget = 2.5f;
|
|
else if(PedAverageSpeed > 0.04f && PedAverageSpeed <= 0.145f)
|
|
HeightTarget = 4.5f;
|
|
else if(PedAverageSpeed > 0.145f)
|
|
HeightTarget = 7.0f;
|
|
else
|
|
HeightTarget = 0.0f;
|
|
|
|
// Zoom out if locked on target is far away
|
|
if(FindPlayerPed()->m_pPointGunAt){
|
|
Dist = (FindPlayerPed()->m_pPointGunAt->GetPosition() - CameraTarget).Magnitude2D();
|
|
if(Dist > 6.0f)
|
|
HeightTarget = Max(HeightTarget, Dist/22.0f*37.0f);
|
|
}
|
|
|
|
Source = TargetCoors + CVector(0.0f, -1.0f, 9.0f);
|
|
|
|
// Collision checks
|
|
entity = nil;
|
|
TestSource = TargetCoors + CVector(0.0f, -1.0f, 9.0f);
|
|
TestTarget = TestSource;
|
|
TestTarget.z = TargetCoors.z;
|
|
if(CWorld::ProcessLineOfSight(TestTarget, TestSource, colPoint, entity, true, false, false, false, false, false, false)){
|
|
if(TargetCoors.z+9.0f+HeightTarget < colPoint.point.z+3.0f)
|
|
HeightTarget = colPoint.point.z+3.0f - (TargetCoors.z+9.0f);
|
|
}else{
|
|
TestSource = TargetCoors + CVector(0.0f, -1.0f, 9.0f);
|
|
TestTarget = TestSource;
|
|
TestSource.z += HeightTarget;
|
|
TestTarget.z = TestSource.z + 10.0f;
|
|
if(CWorld::ProcessLineOfSight(TestTarget, TestSource, colPoint, entity, true, false, false, false, false, false, false)){
|
|
if(TargetCoors.z+9.0f+HeightTarget < colPoint.point.z+3.0f)
|
|
HeightTarget = colPoint.point.z+3.0f - (TargetCoors.z+9.0f);
|
|
}
|
|
}
|
|
|
|
WellBufferMe(HeightTarget, &AdjustHeightTargetMoveBuffer, &AdjustHeightTargetMoveSpeed, 0.3f, 0.03f, false);
|
|
Source.z += AdjustHeightTargetMoveBuffer;
|
|
|
|
// Wall checks
|
|
AvoidWallsTopDownPed(TargetCoors, CVector(0.0f, -3.0f, 3.0f), &TargetAdjusterForSouth, &TargetAdjusterSpeedForSouth, 1.0f);
|
|
Source.y += TargetAdjusterForSouth;
|
|
AvoidWallsTopDownPed(TargetCoors, CVector(0.0f, 3.0f, 3.0f), &TargetAdjusterForNorth, &TargetAdjusterSpeedForNorth, 1.0f);
|
|
Source.y -= TargetAdjusterForNorth;
|
|
// BUG: east and west flipped
|
|
AvoidWallsTopDownPed(TargetCoors, CVector(3.0f, 0.0f, 3.0f), &TargetAdjusterForWest, &TargetAdjusterSpeedForWest, 1.0f);
|
|
Source.x -= TargetAdjusterForWest;
|
|
AvoidWallsTopDownPed(TargetCoors, CVector(-3.0f, 0.0f, 3.0f), &TargetAdjusterForEast, &TargetAdjusterSpeedForEast, 1.0f);
|
|
Source.x += TargetAdjusterForEast;
|
|
|
|
TargetCoors.y = Source.y + 1.0f;
|
|
TargetCoors.y += TargetAdjusterForSouth;
|
|
TargetCoors.x += TargetAdjusterForEast;
|
|
TargetCoors.x -= TargetAdjusterForWest;
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
#ifdef FIX_BUGS
|
|
if(Front.x == 0.0f && Front.y == 0.0f)
|
|
Front.y = 0.0001f;
|
|
#else
|
|
// someone used = instead of == in the above check by accident
|
|
Front.x = 0.0f;
|
|
#endif
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
Up = CrossProduct(Front, CVector(-1.0f, 0.0f, 0.0f));
|
|
Up.Normalise();
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
void
|
|
CCam::Process_Rocket(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
float BackOffset = 0.19f;
|
|
static bool FailedTestTwelveFramesAgo = false;
|
|
RwV3d HeadPos;
|
|
CVector TargetCoors;
|
|
|
|
FOV = DefaultFOV;
|
|
TargetCoors = CameraTarget;
|
|
|
|
if(ResetStatics){
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
FailedTestTwelveFramesAgo = false;
|
|
// static DPadVertical unused
|
|
// static DPadHorizontal unused
|
|
m_bCollisionChecksOn = true;
|
|
ResetStatics = false;
|
|
}
|
|
|
|
if(((CPed*)CamTargetEntity)->bIsDucking)
|
|
BackOffset = 0.8f;
|
|
CamTargetEntity->GetMatrix().UpdateRW();
|
|
CamTargetEntity->UpdateRwFrame();
|
|
CamTargetEntity->UpdateRpHAnim();
|
|
((CPed*)CamTargetEntity)->m_pedIK.GetComponentPosition(HeadPos, PED_HEAD);
|
|
Source = HeadPos;
|
|
Source.z += 0.1f;
|
|
Source.x -= BackOffset*Cos(m_fInitialPlayerOrientation);
|
|
Source.y -= BackOffset*Sin(m_fInitialPlayerOrientation);
|
|
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
if(MouseX != 0.0f || MouseY != 0.0f){
|
|
UseMouse = true;
|
|
LookLeftRight = -3.0f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else{
|
|
LookLeftRight = -CPad::GetPad(0)->SniperModeLookLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->SniperModeLookUpDown();
|
|
}
|
|
if(UseMouse){
|
|
Beta += TheCamera.m_fMouseAccelHorzntl * LookLeftRight * FOV/80.0f;
|
|
Alpha += TheCamera.m_fMouseAccelVertical * LookUpDown * FOV/80.0f;
|
|
}else{
|
|
float xdir = LookLeftRight < 0.0f ? -1.0f : 1.0f;
|
|
float ydir = LookUpDown < 0.0f ? -1.0f : 1.0f;
|
|
Beta += SQR(LookLeftRight/100.0f)*xdir*0.8f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += SQR(LookUpDown/150.0f)*ydir*1.0f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
if(Alpha > DEGTORAD(60.0f)) Alpha = DEGTORAD(60.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
TargetCoors.x = 3.0f * Cos(Alpha) * Cos(Beta) + Source.x;
|
|
TargetCoors.y = 3.0f * Cos(Alpha) * Sin(Beta) + Source.y;
|
|
TargetCoors.z = 3.0f * Sin(Alpha) + Source.z;
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source += Front*0.4f;
|
|
|
|
if(m_bCollisionChecksOn){
|
|
if(!CWorld::GetIsLineOfSightClear(TargetCoors, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
CVector TestPoint;
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta + DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta + DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta - DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta - DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else
|
|
FailedTestTwelveFramesAgo = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FailedTestTwelveFramesAgo)
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
Source -= Front*0.4f;
|
|
|
|
GetVectorsReadyForRW();
|
|
float Rotation = CGeneral::GetATanOfXY(Front.x, Front.y) - HALFPI;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Rotation;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Rotation;
|
|
}
|
|
|
|
float fDuckingBackOffset = 0.5f;
|
|
float fDuckingRightOffset = 0.18f;
|
|
|
|
void
|
|
CCam::Process_M16_1stPerson(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
float BackOffset = 0.3f;
|
|
static bool FailedTestTwelveFramesAgo = false;
|
|
RwV3d HeadPos;
|
|
CVector TargetCoors;
|
|
|
|
bool isAttached = ((CPed*)CamTargetEntity)->IsPlayer() && ((CPed*)CamTargetEntity)->m_attachedTo;
|
|
|
|
FOV = DefaultFOV;
|
|
TargetCoors = CameraTarget;
|
|
|
|
if(ResetStatics){
|
|
if(isAttached)
|
|
Beta = 0.0f;
|
|
else
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
FailedTestTwelveFramesAgo = false;
|
|
// static DPadVertical unused
|
|
// static DPadHorizontal unused
|
|
m_bCollisionChecksOn = true;
|
|
ResetStatics = false;
|
|
}
|
|
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
if(MouseX != 0.0f || MouseY != 0.0f){
|
|
UseMouse = true;
|
|
LookLeftRight = -3.0f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else{
|
|
LookLeftRight = -CPad::GetPad(0)->SniperModeLookLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->SniperModeLookUpDown();
|
|
}
|
|
if(UseMouse){
|
|
Beta += TheCamera.m_fMouseAccelHorzntl * LookLeftRight * FOV/80.0f;
|
|
Alpha += TheCamera.m_fMouseAccelVertical * LookUpDown * FOV/80.0f;
|
|
}else if(Mode == MODE_HELICANNON_1STPERSON){
|
|
LookLeftRight /= 128.0f;
|
|
LookUpDown /= 128.0f;
|
|
Beta += LookLeftRight*Abs(LookLeftRight)*0.56f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += LookUpDown*Abs(LookUpDown)*0.48f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
}else{
|
|
float xdir = LookLeftRight < 0.0f ? -1.0f : 1.0f;
|
|
float ydir = LookUpDown < 0.0f ? -1.0f : 1.0f;
|
|
Beta += SQR(LookLeftRight/100.0f)*xdir*0.8f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += SQR(LookUpDown/150.0f)*ydir*1.0f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
if (!isAttached) {
|
|
while(Beta >= TWOPI) Beta -= TWOPI;
|
|
while(Beta < 0) Beta += TWOPI;
|
|
}
|
|
if(Alpha > DEGTORAD(60.0f)) Alpha = DEGTORAD(60.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
if(((CPed*)CamTargetEntity)->bIsDucking)
|
|
BackOffset = 0.8f;
|
|
if(isAttached){
|
|
CMatrix mat, rot;
|
|
CPed *TargetPed = (CPed*)CamTargetEntity;
|
|
TargetPed->PositionAttachedPed();
|
|
CamTargetEntity->GetMatrix().UpdateRW();
|
|
CamTargetEntity->UpdateRwFrame();
|
|
CamTargetEntity->UpdateRpHAnim();
|
|
|
|
HeadPos.x = 0.0f;
|
|
HeadPos.y = 0.0f;
|
|
HeadPos.z = 0.0f;
|
|
TargetPed->m_pedIK.GetComponentPosition(HeadPos, PED_HEAD);
|
|
Source = HeadPos;
|
|
Source += 0.1f*CamTargetEntity->GetUp();
|
|
Source -= BackOffset*CamTargetEntity->GetForward();
|
|
|
|
if(TargetPed->m_attachRotStep < PI){
|
|
if(Beta > TargetPed->m_attachRotStep){
|
|
Beta = TargetPed->m_attachRotStep;
|
|
CAutomobile *heli = (CAutomobile*)TargetPed->m_attachedTo;
|
|
if(heli->IsVehicle() && heli->IsCar() && heli->IsRealHeli() && heli->m_fHeliOrientation > 0.0f){
|
|
float heliOrient = heli->m_fHeliOrientation + CTimer::GetTimeStep()*0.01f;
|
|
if(heliOrient < 0.0f) heliOrient += TWOPI;
|
|
else if(heliOrient > TWOPI) heliOrient -= TWOPI;
|
|
heli->SetHeliOrientation(heliOrient);
|
|
}
|
|
}else if(Beta < -TargetPed->m_attachRotStep){
|
|
Beta = -TargetPed->m_attachRotStep;
|
|
CAutomobile *heli = (CAutomobile*)TargetPed->m_attachedTo;
|
|
if(heli->IsVehicle() && heli->IsCar() && heli->IsRealHeli() && heli->m_fHeliOrientation > 0.0f){
|
|
float heliOrient = heli->m_fHeliOrientation - CTimer::GetTimeStep()*0.01f;
|
|
if(heliOrient < 0.0f) heliOrient += TWOPI;
|
|
else if(heliOrient > TWOPI) heliOrient -= TWOPI;
|
|
heli->SetHeliOrientation(heliOrient);
|
|
}
|
|
}
|
|
}else{
|
|
while(Beta < -PI) Beta += TWOPI;
|
|
while(Beta >= PI) Beta -= TWOPI;
|
|
}
|
|
|
|
mat = TargetPed->m_attachedTo->GetMatrix();
|
|
rot.SetRotateX(Alpha);
|
|
switch(TargetPed->m_attachType){
|
|
case 0: rot.RotateZ(Beta); break;
|
|
case 1: rot.RotateZ(Beta + HALFPI); break;
|
|
case 2: rot.RotateZ(Beta + PI); break;
|
|
case 3: rot.RotateZ(Beta - HALFPI); break;
|
|
}
|
|
mat = mat * rot;
|
|
Front = mat.GetForward();
|
|
Up = mat.GetUp();
|
|
TargetCoors = Source + 3.0f*Front;
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
|
|
float Rotation = CGeneral::GetATanOfXY(Front.x, Front.y) - HALFPI;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Rotation;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Rotation;
|
|
}else{
|
|
CamTargetEntity->GetMatrix().UpdateRW();
|
|
CamTargetEntity->UpdateRwFrame();
|
|
CamTargetEntity->UpdateRpHAnim();
|
|
HeadPos.x = 0.0f;
|
|
HeadPos.y = 0.0f;
|
|
HeadPos.z = 0.0f;
|
|
((CPed*)CamTargetEntity)->m_pedIK.GetComponentPosition(HeadPos, PED_HEAD);
|
|
Source = HeadPos;
|
|
Source.z += 0.1f;
|
|
if(((CPed*)CamTargetEntity)->bIsDucking){
|
|
Source.x -= fDuckingBackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= fDuckingBackOffset*CamTargetEntity->GetForward().y;
|
|
Source.x -= fDuckingRightOffset*CamTargetEntity->GetRight().x;
|
|
Source.y -= fDuckingRightOffset*CamTargetEntity->GetRight().y;
|
|
}else{
|
|
Source.x -= BackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= BackOffset*CamTargetEntity->GetForward().y;
|
|
}
|
|
|
|
TargetCoors.x = 3.0f * Cos(Alpha) * Cos(Beta) + Source.x;
|
|
TargetCoors.y = 3.0f * Cos(Alpha) * Sin(Beta) + Source.y;
|
|
TargetCoors.z = 3.0f * Sin(Alpha) + Source.z;
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source += Front*0.4f;
|
|
|
|
if(m_bCollisionChecksOn){
|
|
if(!CWorld::GetIsLineOfSightClear(TargetCoors, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
CVector TestPoint;
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta + DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta + DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta - DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta - DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else
|
|
FailedTestTwelveFramesAgo = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FailedTestTwelveFramesAgo)
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
Source -= Front*0.4f;
|
|
|
|
GetVectorsReadyForRW();
|
|
float Rotation = CGeneral::GetATanOfXY(Front.x, Front.y) - HALFPI;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Rotation;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Rotation;
|
|
}
|
|
}
|
|
|
|
float fBike1stPersonOffsetZ = 0.15f;
|
|
|
|
void
|
|
CCam::Process_1stPerson(const CVector &CameraTarget, float TargetOrientation, float SpeedVar, float TargetSpeedVar)
|
|
{
|
|
float BackOffset = 0.3f;
|
|
static float DontLookThroughWorldFixer = 0.0f;
|
|
CVector TargetCoors;
|
|
|
|
FOV = DefaultFOV;
|
|
TargetCoors = CameraTarget;
|
|
if(CamTargetEntity->m_rwObject == nil)
|
|
return;
|
|
|
|
if(ResetStatics){
|
|
Beta = TargetOrientation;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = TargetOrientation;
|
|
if(CamTargetEntity->IsPed()){
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
}
|
|
TheCamera.m_fAvoidTheGeometryProbsTimer = 0.0f;
|
|
DontLookThroughWorldFixer = 0.0f;
|
|
}
|
|
|
|
if(CamTargetEntity->IsPed()){
|
|
static bool FailedTestTwelveFramesAgo = false;
|
|
RwV3d HeadPos;
|
|
|
|
TargetCoors = CameraTarget;
|
|
|
|
if(ResetStatics){
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
FailedTestTwelveFramesAgo = false;
|
|
// static DPadVertical unused
|
|
// static DPadHorizontal unused
|
|
m_bCollisionChecksOn = true;
|
|
ResetStatics = false;
|
|
}
|
|
|
|
CamTargetEntity->GetMatrix().UpdateRW();
|
|
CamTargetEntity->UpdateRwFrame();
|
|
CamTargetEntity->UpdateRpHAnim();
|
|
|
|
((CPed*)CamTargetEntity)->m_pedIK.GetComponentPosition(HeadPos, PED_HEAD);
|
|
Source = HeadPos;
|
|
Source.z += 0.1f;
|
|
if(((CPed*)CamTargetEntity)->bIsDucking){
|
|
Source.x -= fDuckingBackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= fDuckingBackOffset*CamTargetEntity->GetForward().y;
|
|
Source.x -= fDuckingRightOffset*CamTargetEntity->GetRight().x;
|
|
Source.y -= fDuckingRightOffset*CamTargetEntity->GetRight().y;
|
|
}else{
|
|
Source.x -= BackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= BackOffset*CamTargetEntity->GetForward().y;
|
|
}
|
|
|
|
float LookLeftRight, LookUpDown;
|
|
LookLeftRight = -CPad::GetPad(0)->LookAroundLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->LookAroundUpDown();
|
|
float xdir = LookLeftRight < 0.0f ? -1.0f : 1.0f;
|
|
float ydir = LookUpDown < 0.0f ? -1.0f : 1.0f;
|
|
Beta += SQR(LookLeftRight/100.0f)*xdir*0.8f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += SQR(LookUpDown/150.0f)*ydir*1.0f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
if(Alpha > DEGTORAD(60.0f)) Alpha = DEGTORAD(60.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
TargetCoors.x = 3.0f * Cos(Alpha) * Cos(Beta) + Source.x;
|
|
TargetCoors.y = 3.0f * Cos(Alpha) * Sin(Beta) + Source.y;
|
|
TargetCoors.z = 3.0f * Sin(Alpha) + Source.z;
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source += Front*0.4f;
|
|
|
|
if(m_bCollisionChecksOn){
|
|
if(!CWorld::GetIsLineOfSightClear(TargetCoors, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
CVector TestPoint;
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta + DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta + DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta - DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta - DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else
|
|
FailedTestTwelveFramesAgo = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FailedTestTwelveFramesAgo)
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
Source -= Front*0.4f;
|
|
|
|
GetVectorsReadyForRW();
|
|
float Rotation = CGeneral::GetATanOfXY(Front.x, Front.y) - HALFPI;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Rotation;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Rotation;
|
|
}else{
|
|
assert(CamTargetEntity->IsVehicle());
|
|
|
|
if(((CVehicle*)CamTargetEntity)->IsBike() &&
|
|
(((CBike*)CamTargetEntity)->bWheelieCam || TheCamera.m_fAvoidTheGeometryProbsTimer > 0.0f)){
|
|
if(CPad::GetPad(0)->GetLeftShoulder2() || CPad::GetPad(0)->GetRightShoulder2()){
|
|
TheCamera.m_fAvoidTheGeometryProbsTimer = 0.0f;
|
|
((CBike*)CamTargetEntity)->bWheelieCam = false;
|
|
}else if(Process_WheelCam(CameraTarget, TargetOrientation, SpeedVar, TargetSpeedVar)){
|
|
if(((CBike*)CamTargetEntity)->bWheelieCam)
|
|
TheCamera.m_fAvoidTheGeometryProbsTimer = 50.0f;
|
|
else{
|
|
TheCamera.m_fAvoidTheGeometryProbsTimer -= CTimer::GetTimeStep();
|
|
((CBike*)CamTargetEntity)->bWheelieCam = true;
|
|
}
|
|
return;
|
|
}else{
|
|
TheCamera.m_fAvoidTheGeometryProbsTimer = 0.0f;
|
|
((CBike*)CamTargetEntity)->bWheelieCam = false;
|
|
}
|
|
}
|
|
|
|
CMatrix *matrix = &CamTargetEntity->GetMatrix();
|
|
if(((CVehicle*)CamTargetEntity)->IsBike()){
|
|
((CBike*)CamTargetEntity)->CalculateLeanMatrix();
|
|
matrix = &((CBike*)CamTargetEntity)->m_leanMatrix;
|
|
}
|
|
|
|
CVehicleModelInfo *mi = (CVehicleModelInfo*)CModelInfo::GetModelInfo(CamTargetEntity->GetModelIndex());
|
|
CVector CamPos = mi->GetFrontSeatPosn();
|
|
CamPos.x = 0.0f;
|
|
CamPos.y += 0.08f;
|
|
CamPos.z += 0.62f;
|
|
FOV = 60.0f;
|
|
Source = Multiply3x3(*matrix, CamPos);
|
|
Source += CamTargetEntity->GetPosition();
|
|
if(((CVehicle*)CamTargetEntity)->IsBoat())
|
|
Source.z += 0.5f;
|
|
else if(((CVehicle*)CamTargetEntity)->IsBike() && ((CVehicle*)CamTargetEntity)->pDriver){
|
|
CVector Neck(0.0f, 0.0f, 0.0f);
|
|
((CVehicle*)CamTargetEntity)->pDriver->m_pedIK.GetComponentPosition(Neck, PED_NECK);
|
|
Neck += ((CVehicle*)CamTargetEntity)->m_vecMoveSpeed * CTimer::GetTimeStep();
|
|
Source.z = Neck.z + fBike1stPersonOffsetZ;
|
|
}
|
|
|
|
if(((CVehicle*)CamTargetEntity)->IsUpsideDown()){
|
|
if(DontLookThroughWorldFixer < 0.5f)
|
|
DontLookThroughWorldFixer += 0.03f;
|
|
else
|
|
DontLookThroughWorldFixer = 0.5f;
|
|
}else{
|
|
if(DontLookThroughWorldFixer < 0.0f)
|
|
#ifdef FIX_BUGS
|
|
DontLookThroughWorldFixer += 0.03f;
|
|
#else
|
|
DontLookThroughWorldFixer -= 0.03f;
|
|
#endif
|
|
else
|
|
DontLookThroughWorldFixer = 0.0f;
|
|
}
|
|
Source.z += DontLookThroughWorldFixer;
|
|
Front = matrix->GetForward();
|
|
Front.Normalise();
|
|
Up = matrix->GetUp();
|
|
Up.Normalise();
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
Up.Normalise();
|
|
}
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
static CVector vecHeadCamOffset(0.06f, 0.05f, 0.0f);
|
|
|
|
void
|
|
CCam::Process_1rstPersonPedOnPC(const CVector&, float TargetOrientation, float, float)
|
|
{
|
|
// static int DontLookThroughWorldFixer = 0; // unused
|
|
static CVector InitialHeadPos;
|
|
|
|
if(Mode != MODE_SNIPER_RUNABOUT)
|
|
FOV = DefaultFOV;
|
|
TheCamera.m_1rstPersonRunCloseToAWall = false;
|
|
if(CamTargetEntity->m_rwObject == nil)
|
|
return;
|
|
|
|
if(CamTargetEntity->IsPed()){
|
|
// static bool FailedTestTwelveFramesAgo = false; // unused
|
|
CVector HeadPos = vecHeadCamOffset;
|
|
CVector TargetCoors;
|
|
|
|
((CPed*)CamTargetEntity)->TransformToNode(HeadPos, PED_HEAD);
|
|
RpHAnimHierarchy *hier = GetAnimHierarchyFromSkinClump(CamTargetEntity->GetClump());
|
|
int32 idx = RpHAnimIDGetIndex(hier, ConvertPedNode2BoneTag(PED_HEAD));
|
|
RwMatrix *mats = RpHAnimHierarchyGetMatrixArray(hier);
|
|
RwV3dTransformPoints(&HeadPos, &HeadPos, 1, &mats[idx]);
|
|
RwV3d scl = { 0.0f, 0.0f, 0.0f };
|
|
RwMatrixScale(&mats[idx], &scl, rwCOMBINEPRECONCAT);
|
|
|
|
if(ResetStatics){
|
|
Beta = TargetOrientation;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = TargetOrientation;
|
|
if(CamTargetEntity->IsPed()){ // useless check
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
// FailedTestTwelveFramesAgo = false;
|
|
m_bCollisionChecksOn = true;
|
|
}
|
|
// DontLookThroughWorldFixer = false;
|
|
m_vecBufferedPlayerBodyOffset = HeadPos;
|
|
InitialHeadPos = HeadPos;
|
|
}
|
|
|
|
m_vecBufferedPlayerBodyOffset.y = HeadPos.y;
|
|
|
|
if(TheCamera.m_bHeadBob){
|
|
m_vecBufferedPlayerBodyOffset.x =
|
|
TheCamera.m_fGaitSwayBuffer * m_vecBufferedPlayerBodyOffset.x +
|
|
(1.0f-TheCamera.m_fGaitSwayBuffer) * HeadPos.x;
|
|
m_vecBufferedPlayerBodyOffset.z =
|
|
TheCamera.m_fGaitSwayBuffer * m_vecBufferedPlayerBodyOffset.z +
|
|
(1.0f-TheCamera.m_fGaitSwayBuffer) * HeadPos.z;
|
|
HeadPos = (CamTargetEntity->GetMatrix() * m_vecBufferedPlayerBodyOffset);
|
|
}else{
|
|
float HeadDelta = (HeadPos - InitialHeadPos).Magnitude2D();
|
|
CVector Fwd = CamTargetEntity->GetForward();
|
|
Fwd.z = 0.0f;
|
|
Fwd.Normalise();
|
|
HeadPos = HeadDelta*1.23f*Fwd + CamTargetEntity->GetPosition();
|
|
HeadPos.z += 0.59f;
|
|
}
|
|
Source = HeadPos;
|
|
|
|
// unused:
|
|
// ((CPed*)CamTargetEntity)->m_pedIK.GetComponentPosition(MidPos, PED_MID);
|
|
// Source - MidPos;
|
|
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
if(MouseX != 0.0f || MouseY != 0.0f){
|
|
UseMouse = true;
|
|
LookLeftRight = -3.0f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else{
|
|
LookLeftRight = -CPad::GetPad(0)->LookAroundLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->LookAroundUpDown();
|
|
}
|
|
if(UseMouse){
|
|
Beta += TheCamera.m_fMouseAccelHorzntl * LookLeftRight * FOV/80.0f;
|
|
Alpha += TheCamera.m_fMouseAccelVertical * LookUpDown * FOV/80.0f;
|
|
}else{
|
|
float xdir = LookLeftRight < 0.0f ? -1.0f : 1.0f;
|
|
float ydir = LookUpDown < 0.0f ? -1.0f : 1.0f;
|
|
Beta += SQR(LookLeftRight/100.0f)*xdir*0.8f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += SQR(LookUpDown/150.0f)*ydir*1.0f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
if(Alpha > DEGTORAD(60.0f)) Alpha = DEGTORAD(60.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
if(((CPed*)CamTargetEntity)->IsPlayer() && ((CPed*)CamTargetEntity)->m_attachedTo){
|
|
CPed *pedTarget = ((CPed*)CamTargetEntity);
|
|
float NewBeta;
|
|
switch(pedTarget->m_attachType){
|
|
case 0:
|
|
NewBeta = pedTarget->GetForward().Heading() + HALFPI;
|
|
break;
|
|
case 1:
|
|
NewBeta = pedTarget->GetForward().Heading() + PI;
|
|
break;
|
|
case 2:
|
|
NewBeta = pedTarget->GetForward().Heading() - HALFPI;
|
|
break;
|
|
case 3:
|
|
NewBeta = pedTarget->GetForward().Heading();
|
|
break;
|
|
}
|
|
|
|
float BetaOffset = Beta - NewBeta;
|
|
if(BetaOffset > PI) BetaOffset -= TWOPI;
|
|
else if(BetaOffset < PI) BetaOffset += TWOPI;
|
|
|
|
BetaOffset = clamp(BetaOffset, -pedTarget->m_attachRotStep, pedTarget->m_attachRotStep);
|
|
Beta = NewBeta + BetaOffset;
|
|
}
|
|
|
|
TargetCoors.x = 3.0f * Cos(Alpha) * Cos(Beta) + Source.x;
|
|
TargetCoors.y = 3.0f * Cos(Alpha) * Sin(Beta) + Source.y;
|
|
TargetCoors.z = 3.0f * Sin(Alpha) + Source.z;
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source += Front*0.4f;
|
|
|
|
TheCamera.m_AlphaForPlayerAnim1rstPerson = Alpha;
|
|
|
|
GetVectorsReadyForRW();
|
|
|
|
float Heading = Front.Heading();
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Heading;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Heading;
|
|
TheCamera.pTargetEntity->SetHeading(Heading);
|
|
TheCamera.pTargetEntity->GetMatrix().UpdateRW();
|
|
|
|
if(Mode == MODE_SNIPER_RUNABOUT){
|
|
// no mouse wheel FOV buffering here like in normal sniper mode
|
|
if(CPad::GetPad(0)->SniperZoomIn() || CPad::GetPad(0)->SniperZoomOut()){
|
|
if(CPad::GetPad(0)->SniperZoomOut())
|
|
FOV *= (255.0f*CTimer::GetTimeStep() + 10000.0f) / 10000.0f;
|
|
else
|
|
FOV /= (255.0f*CTimer::GetTimeStep() + 10000.0f) / 10000.0f;
|
|
}
|
|
|
|
TheCamera.SetMotionBlur(180, 255, 180, 120, MOTION_BLUR_SNIPER);
|
|
|
|
if(FOV > DefaultFOV)
|
|
FOV = DefaultFOV;
|
|
if(FOV < 15.0f)
|
|
FOV = 15.0f;
|
|
}
|
|
}
|
|
|
|
ResetStatics = false;
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.05f);
|
|
}
|
|
|
|
float fCameraNearClipMult = 0.15f;
|
|
|
|
void
|
|
CCam::Process_Sniper(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
float BackOffset = 0.19f;
|
|
static bool FailedTestTwelveFramesAgo = false;
|
|
RwV3d HeadPos;
|
|
CVector TargetCoors;
|
|
TargetCoors = CameraTarget;
|
|
|
|
static float TargetFOV = 0.0f;
|
|
|
|
if(ResetStatics){
|
|
Beta = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
Alpha = 0.0f;
|
|
m_fInitialPlayerOrientation = ((CPed*)CamTargetEntity)->m_fRotationCur + HALFPI;
|
|
FailedTestTwelveFramesAgo = false;
|
|
// static DPadVertical unused
|
|
// static DPadHorizontal unused
|
|
m_bCollisionChecksOn = true;
|
|
FOVSpeed = 0.0f;
|
|
TargetFOV = FOV;
|
|
ResetStatics = false;
|
|
}
|
|
|
|
if(((CPed*)CamTargetEntity)->bIsDucking)
|
|
BackOffset = 0.8f;
|
|
CamTargetEntity->GetMatrix().UpdateRW();
|
|
CamTargetEntity->UpdateRwFrame();
|
|
CamTargetEntity->UpdateRpHAnim();
|
|
((CPed*)CamTargetEntity)->m_pedIK.GetComponentPosition(HeadPos, PED_HEAD);
|
|
Source = HeadPos;
|
|
Source.z += 0.1f;
|
|
if(((CPed*)CamTargetEntity)->bIsDucking){
|
|
Source.x -= fDuckingBackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= fDuckingBackOffset*CamTargetEntity->GetForward().y;
|
|
Source.x -= fDuckingRightOffset*CamTargetEntity->GetRight().x;
|
|
Source.y -= fDuckingRightOffset*CamTargetEntity->GetRight().y;
|
|
}else{
|
|
Source.x -= BackOffset*CamTargetEntity->GetForward().x;
|
|
Source.y -= BackOffset*CamTargetEntity->GetForward().y;
|
|
}
|
|
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
if(MouseX != 0.0f || MouseY != 0.0f){
|
|
UseMouse = true;
|
|
LookLeftRight = -3.0f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else{
|
|
LookLeftRight = -CPad::GetPad(0)->SniperModeLookLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->SniperModeLookUpDown();
|
|
}
|
|
if(UseMouse){
|
|
Beta += TheCamera.m_fMouseAccelHorzntl * LookLeftRight * FOV/80.0f;
|
|
Alpha += TheCamera.m_fMouseAccelVertical * LookUpDown * FOV/80.0f;
|
|
}else{
|
|
float xdir = LookLeftRight < 0.0f ? -1.0f : 1.0f;
|
|
float ydir = LookUpDown < 0.0f ? -1.0f : 1.0f;
|
|
Beta += SQR(LookLeftRight/100.0f)*xdir*0.8f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
Alpha += SQR(LookUpDown/150.0f)*ydir*1.0f/14.0f * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
if(Alpha > DEGTORAD(60.0f)) Alpha = DEGTORAD(60.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
TargetCoors.x = 3.0f * Cos(Alpha) * Cos(Beta) + Source.x;
|
|
TargetCoors.y = 3.0f * Cos(Alpha) * Sin(Beta) + Source.y;
|
|
TargetCoors.z = 3.0f * Sin(Alpha) + Source.z;
|
|
|
|
UseMouse = false;
|
|
int ZoomInButton = ControlsManager.GetMouseButtonAssociatedWithAction(PED_SNIPER_ZOOM_IN);
|
|
int ZoomOutButton = ControlsManager.GetMouseButtonAssociatedWithAction(PED_SNIPER_ZOOM_OUT);
|
|
if(ZoomInButton == rsMOUSEWHEELUPBUTTON || ZoomInButton == rsMOUSEWHEELDOWNBUTTON || ZoomOutButton == rsMOUSEWHEELUPBUTTON || ZoomOutButton == rsMOUSEWHEELDOWNBUTTON){
|
|
if(CPad::GetPad(0)->GetMouseWheelUp() || CPad::GetPad(0)->GetMouseWheelDown()){
|
|
if(CPad::GetPad(0)->SniperZoomIn()){
|
|
TargetFOV = FOV - 10.0f;
|
|
UseMouse = true;
|
|
}
|
|
if(CPad::GetPad(0)->SniperZoomOut()){
|
|
TargetFOV = FOV + 10.0f;
|
|
UseMouse = true;
|
|
}
|
|
}
|
|
}
|
|
if((CPad::GetPad(0)->SniperZoomIn() || CPad::GetPad(0)->SniperZoomOut()) && !UseMouse){
|
|
if(CPad::GetPad(0)->SniperZoomOut()){
|
|
FOV *= (255.0f*CTimer::GetTimeStep() + 10000.0f) / 10000.0f;
|
|
TargetFOV = FOV;
|
|
FOVSpeed = 0.0f;
|
|
}else{
|
|
FOV /= (255.0f*CTimer::GetTimeStep() + 10000.0f) / 10000.0f;
|
|
TargetFOV = FOV;
|
|
FOVSpeed = 0.0f;
|
|
}
|
|
}else{
|
|
if(Abs(TargetFOV - FOV) > 0.5f)
|
|
WellBufferMe(TargetFOV, &FOV, &FOVSpeed, 0.5f, 0.25f, false);
|
|
else
|
|
FOVSpeed = 0.0f;
|
|
}
|
|
|
|
TheCamera.SetMotionBlur(180, 255, 180, 120, MOTION_BLUR_SNIPER);
|
|
|
|
if(FOV > DefaultFOV)
|
|
FOV = DefaultFOV;
|
|
if(Mode == MODE_CAMERA){
|
|
if(FOV < 3.0f)
|
|
FOV = 3.0f;
|
|
}else{
|
|
if(FOV < 15.0f)
|
|
FOV = 15.0f;
|
|
}
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source += Front*0.4f;
|
|
|
|
if(m_bCollisionChecksOn){
|
|
if(!CWorld::GetIsLineOfSightClear(TargetCoors, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
CVector TestPoint;
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta + DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta + DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else{
|
|
TestPoint.x = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Cos(Beta - DEGTORAD(35.0f)) + Source.x;
|
|
TestPoint.y = 3.0f * Cos(Alpha - DEGTORAD(20.0f)) * Sin(Beta - DEGTORAD(35.0f)) + Source.y;
|
|
TestPoint.z = 3.0f * Sin(Alpha - DEGTORAD(20.0f)) + Source.z;
|
|
if(!CWorld::GetIsLineOfSightClear(TestPoint, Source, true, true, false, true, false, true, true)){
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
FailedTestTwelveFramesAgo = true;
|
|
}else
|
|
FailedTestTwelveFramesAgo = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(FailedTestTwelveFramesAgo)
|
|
RwCameraSetNearClipPlane(Scene.camera, 0.4f);
|
|
else if(Mode == MODE_CAMERA)
|
|
RwCameraSetNearClipPlane(Scene.camera, ((15.0f - Min(FOV, 15.0f))*fCameraNearClipMult + 1.0f)*DEFAULT_NEAR);
|
|
Source -= Front*0.4f;
|
|
|
|
GetVectorsReadyForRW();
|
|
float Rotation = CGeneral::GetATanOfXY(Front.x, Front.y) - HALFPI;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Rotation;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Rotation;
|
|
}
|
|
|
|
float INIT_SYPHON_GROUND_DIST = 2.419f;
|
|
float INIT_SYPHON_ALPHA_OFFSET = -DEGTORAD(3.0f);
|
|
float INIT_SYPHON_DEGREE_OFFSET = -DEGTORAD(30.0f);
|
|
float FrontOffsetSyphon = -DEGTORAD(25.5f); // unused
|
|
float INIT_SYPHON_Z_OFFSET = -0.5f;
|
|
|
|
void
|
|
CCam::Process_Syphon(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
static bool CameraObscured = false;
|
|
// unused FailedClippingTestPrevously
|
|
static float BetaOffset = INIT_SYPHON_DEGREE_OFFSET;
|
|
// unused AngleToGoTo
|
|
// unused AngleToGoToSpeed
|
|
// unused DistBetweenPedAndPlayerPreviouslyOn
|
|
static float HeightDown = INIT_SYPHON_Z_OFFSET;
|
|
static float AlphaOffset = INIT_SYPHON_ALPHA_OFFSET;
|
|
static bool NegateBetaOffset = true;
|
|
CVector TargetCoors;
|
|
float fAimingDist;
|
|
float TargetAlpha;
|
|
|
|
bool StandingOnMovingThing = false;
|
|
TargetCoors = CameraTarget;
|
|
AlphaOffset = INIT_SYPHON_ALPHA_OFFSET;
|
|
float GroundDist = INIT_SYPHON_GROUND_DIST;
|
|
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
|
|
float NewBeta = CGeneral::GetATanOfXY(TheCamera.m_cvecAimingTargetCoors.x - TargetCoors.x, TheCamera.m_cvecAimingTargetCoors.y - TargetCoors.y) + PI;
|
|
if(ResetStatics){
|
|
BetaOffset = INIT_SYPHON_DEGREE_OFFSET;
|
|
Beta = CGeneral::GetATanOfXY(Source.x - TargetCoors.x, Source.y - TargetCoors.y);
|
|
// some unuseds
|
|
ResetStatics = false;
|
|
}
|
|
if(NegateBetaOffset)
|
|
BetaOffset = -INIT_SYPHON_DEGREE_OFFSET;
|
|
Beta = NewBeta + BetaOffset;
|
|
Source = TargetCoors;
|
|
Source.x += GroundDist*Cos(Beta);
|
|
Source.y += GroundDist*Sin(Beta);
|
|
CPhysical *ground = (CPhysical*)((CPed*)CamTargetEntity)->m_pCurSurface;
|
|
if(ground && (ground->IsVehicle() || ground->IsObject()))
|
|
StandingOnMovingThing = true;
|
|
TargetCoors.z += m_fSyphonModeTargetZOffSet;
|
|
|
|
bool PlayerTooClose = false;
|
|
fAimingDist = (TheCamera.m_cvecAimingTargetCoors - TargetCoors).Magnitude2D();
|
|
if(fAimingDist < 6.5f){
|
|
fAimingDist = 6.5f;
|
|
PlayerTooClose = true;
|
|
}
|
|
TargetAlpha = CGeneral::GetATanOfXY(fAimingDist, TheCamera.m_cvecAimingTargetCoors.z - TargetCoors.z);
|
|
if(ResetStatics) // BUG: can never happen
|
|
Alpha = -TargetAlpha;
|
|
while(TargetAlpha >= PI) TargetAlpha -= 2*PI;
|
|
while(TargetAlpha < -PI) TargetAlpha += 2*PI;
|
|
while(Alpha >= PI) Alpha -= 2*PI;
|
|
while(Alpha < -PI) Alpha += 2*PI;
|
|
|
|
// inlined
|
|
if(StandingOnMovingThing)
|
|
WellBufferMe(-TargetAlpha, &Alpha, &AlphaSpeed, 0.07f/2.0f, 0.015f/2.0f, true);
|
|
else
|
|
WellBufferMe(-TargetAlpha, &Alpha, &AlphaSpeed, 0.07f, 0.015f, true);
|
|
|
|
Source.z += GroundDist*Sin(Alpha+AlphaOffset) + GroundDist*0.2f;
|
|
if(Source.z < TargetCoors.z + HeightDown)
|
|
Source.z = TargetCoors.z + HeightDown;
|
|
|
|
if(!PlayerTooClose){
|
|
CColPoint point;
|
|
CEntity *entity = nil;
|
|
CWorld::pIgnoreEntity = CamTargetEntity;
|
|
if(CWorld::ProcessLineOfSight(TheCamera.m_cvecAimingTargetCoors, Source, point, entity, true, false, false, true, false, false, true)){
|
|
CVector TestFront = TheCamera.m_cvecAimingTargetCoors - Source;
|
|
TestFront.Normalise();
|
|
CVector CamToPlayer = CameraTarget - Source;
|
|
CVector CamToCol = point.point - Source;
|
|
if(DotProduct(TestFront, CamToCol) > DotProduct(TestFront, CamToPlayer)){
|
|
// collision is beyond player
|
|
float ColDist = (TheCamera.m_cvecAimingTargetCoors - point.point).Magnitude();
|
|
CVector PlayerToTarget = TheCamera.m_cvecAimingTargetCoors - CameraTarget;
|
|
float PlayerToTargetDist = PlayerToTarget.Magnitude();
|
|
PlayerToTarget.Normalise();
|
|
CVector Center = TheCamera.m_cvecAimingTargetCoors - ColDist*PlayerToTarget;
|
|
float Radius = (point.point - Center).Magnitude();
|
|
if(CWorld::TestSphereAgainstWorld(Center, Radius, nil, true, false, false, true, false, true)){
|
|
CVector LineToCol = gaTempSphereColPoints[0].point - Center;
|
|
LineToCol -= DotProduct(LineToCol, PlayerToTarget)*PlayerToTarget;
|
|
// unused
|
|
CVector LineToPrevCol = point.point - Center;
|
|
LineToPrevCol -= DotProduct(LineToPrevCol, PlayerToTarget)*PlayerToTarget;
|
|
float LineDist = LineToCol.Magnitude();
|
|
float NewBetaOffset = 0.0f;
|
|
if(LineDist > 0.0f && ColDist > 0.1f){
|
|
// scale offset at center to offset at player
|
|
float DistOffset = LineDist/ColDist * PlayerToTargetDist;
|
|
// turn into an angle
|
|
NewBetaOffset = 0.9f*Asin(Min(DistOffset/GroundDist, 1.0f));
|
|
}
|
|
if(NewBetaOffset < BetaOffset){
|
|
float Ratio = NewBetaOffset / BetaOffset;
|
|
BetaOffset = NewBetaOffset;
|
|
Beta = NewBeta + NewBetaOffset;
|
|
GroundDist *= Max(Ratio, 0.5f);
|
|
Source.x = TargetCoors.x + GroundDist*Cos(Beta);
|
|
Source.y = TargetCoors.y + GroundDist*Sin(Beta);
|
|
Source.z += (1.0f-Ratio)*0.5f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
CWorld::pIgnoreEntity = nil;
|
|
}
|
|
|
|
Front = TheCamera.m_cvecAimingTargetCoors - Source;
|
|
float TargetDistGround = Front.Magnitude2D();
|
|
Front.Normalise();
|
|
m_cvecTargetCoorsForFudgeInter = Source + TargetDistGround*Front;
|
|
m_cvecTargetCoorsForFudgeInter.z = TargetCoors.z;
|
|
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, CameraTarget + CVector(0.0f, 0.0f, 0.75f), Source, FOV);
|
|
Source.z = OrigSource.z;
|
|
|
|
GetVectorsReadyForRW();
|
|
}
|
|
|
|
void
|
|
CCam::Process_Syphon_Crim_In_Front(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
CVector TargetCoors = CameraTarget;
|
|
CVector vDist;
|
|
float fDist, TargetDist;
|
|
float zOffset;
|
|
float AimingAngle;
|
|
|
|
TargetDist = TheCamera.m_fPedZoomValueSmooth * 0.5f + 4.0f;
|
|
vDist = Source - TargetCoors;
|
|
fDist = vDist.Magnitude2D();
|
|
zOffset = TargetDist - 2.65f;
|
|
if(zOffset < 0.0f)
|
|
zOffset = 0.0f;
|
|
if(zOffset == 0.0f)
|
|
Source = TargetCoors + CVector(1.0f, 1.0f, zOffset);
|
|
else
|
|
Source = TargetCoors + CVector(vDist.x/fDist*TargetDist, vDist.y/fDist*TargetDist, zOffset);
|
|
|
|
AimingAngle = CGeneral::GetATanOfXY(TheCamera.m_cvecAimingTargetCoors.x - TargetCoors.x, TheCamera.m_cvecAimingTargetCoors.y - TargetCoors.y);
|
|
while(AimingAngle >= PI) AimingAngle -= 2*PI;
|
|
while(AimingAngle < -PI) AimingAngle += 2*PI;
|
|
|
|
if(ResetStatics){
|
|
if(AimingAngle > 0.0f)
|
|
m_fPlayerInFrontSyphonAngleOffSet = -m_fPlayerInFrontSyphonAngleOffSet;
|
|
ResetStatics = false;
|
|
}
|
|
|
|
if(TheCamera.PlayerWeaponMode.Mode == MODE_SYPHON)
|
|
Beta = AimingAngle + m_fPlayerInFrontSyphonAngleOffSet;
|
|
|
|
Source.x = TargetCoors.x;
|
|
Source.y = TargetCoors.y;
|
|
Source.x += Cos(Beta) * TargetDist;
|
|
Source.y += Sin(Beta) * TargetDist;
|
|
|
|
TargetCoors = CameraTarget;
|
|
TargetCoors.z += m_fSyphonModeTargetZOffSet;
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
|
|
Front = TargetCoors - Source;
|
|
GetVectorsReadyForRW();
|
|
}
|
|
|
|
float MAX_HEIGHT_UP = 15.0f;
|
|
float WATER_Z_ADDITION = 2.75f;
|
|
float WATER_Z_ADDITION_MIN = 1.5f;
|
|
float SMALLBOAT_CLOSE_ALPHA_MINUS = 0.2f;
|
|
float afBoatBetaDiffMult[3] = { 0.15f, 0.07f, 0.01f };
|
|
float afBoatBetaSpeedDiffMult[3] = { 0.02f, 0.015f, 0.005f };
|
|
|
|
void
|
|
CCam::Process_BehindBoat(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsVehicle()){
|
|
ResetStatics = false;
|
|
return;
|
|
}
|
|
|
|
CVector TargetCoors = CameraTarget;
|
|
float DeltaBeta = 0.0f;
|
|
static float TargetWhenChecksWereOn = 0.0f;
|
|
static float CenterObscuredWhenChecksWereOn = 0.0f;
|
|
static float WaterZAddition = 2.75f;
|
|
float WaterLevel = 0.0f;
|
|
float MaxHeightUp = MAX_HEIGHT_UP;
|
|
static float WaterLevelBuffered = 0.0f;
|
|
static float WaterLevelSpeed = 0.0f;
|
|
float BetaDiffMult = 0.0f;
|
|
float BetaSpeedDiffMult = 0.0f;
|
|
|
|
Beta = CGeneral::GetATanOfXY(TargetCoors.x - Source.x, TargetCoors.y - Source.y);
|
|
FOV = DefaultFOV;
|
|
float TargetAlpha = 0.0f;
|
|
|
|
if(ResetStatics){
|
|
CenterObscuredWhenChecksWereOn = 0.0f;
|
|
TargetWhenChecksWereOn = 0.0f;
|
|
}else if(DirectionWasLooking != LOOKING_FORWARD)
|
|
Beta = TargetOrientation;
|
|
|
|
if(!CWaterLevel::GetWaterLevelNoWaves(TargetCoors.x, TargetCoors.y, TargetCoors.z, &WaterLevel))
|
|
WaterLevel = TargetCoors.z - 0.5f;
|
|
if(ResetStatics){
|
|
WaterLevelBuffered = WaterLevel;
|
|
WaterLevelSpeed = 0.0f;
|
|
}
|
|
WellBufferMe(WaterLevel, &WaterLevelBuffered, &WaterLevelSpeed, 0.2f, 0.07f, false);
|
|
|
|
static float FixerForGoingBelowGround = 0.4f;
|
|
if(-FixerForGoingBelowGround < TargetCoors.z-WaterLevelBuffered+WATER_Z_ADDITION)
|
|
WaterLevelBuffered += TargetCoors.z-WaterLevelBuffered+WATER_Z_ADDITION - FixerForGoingBelowGround;
|
|
|
|
CVector BoatDimensions = CamTargetEntity->GetColModel()->boundingBox.GetSize();
|
|
float BoatSize = BoatDimensions.Magnitude2D();
|
|
int index = 0;
|
|
TheCamera.GetArrPosForVehicleType(((CVehicle*)CamTargetEntity)->GetVehicleAppearance(), index);
|
|
if(TheCamera.CarZoomIndicator == CAM_ZOOM_1){
|
|
TargetAlpha = ZmOneAlphaOffset[index];
|
|
BetaDiffMult = afBoatBetaDiffMult[0];
|
|
BetaSpeedDiffMult = afBoatBetaSpeedDiffMult[0];
|
|
}else if(TheCamera.CarZoomIndicator == CAM_ZOOM_2){
|
|
TargetAlpha = ZmTwoAlphaOffset[index];
|
|
BetaDiffMult = afBoatBetaDiffMult[1];
|
|
BetaSpeedDiffMult = afBoatBetaSpeedDiffMult[1];
|
|
}else if(TheCamera.CarZoomIndicator == CAM_ZOOM_3){
|
|
TargetAlpha = ZmThreeAlphaOffset[index];
|
|
BetaDiffMult = afBoatBetaDiffMult[2];
|
|
BetaSpeedDiffMult = afBoatBetaSpeedDiffMult[2];
|
|
}
|
|
if(TheCamera.CarZoomIndicator == CAM_ZOOM_1 && BoatSize < 10.0f){
|
|
TargetAlpha -= SMALLBOAT_CLOSE_ALPHA_MINUS;
|
|
BoatSize = 10.0f;
|
|
}else if(CCullZones::Cam1stPersonForPlayer()){
|
|
float Water = 0.0f;
|
|
// useless call
|
|
//CWaterLevel::GetWaterLevelNoWaves(TargetCoors.x, TargetCoors.y, TargetCoors.z, &Water);
|
|
Water = (WaterLevel + WATER_Z_ADDITION_MIN - WaterLevelBuffered - WATER_Z_ADDITION)/(BoatDimensions.z/2.0f + MaxHeightUp);
|
|
TargetAlpha = Asin(clamp(Water, -1.0f, 1.0f));
|
|
}
|
|
|
|
if(ResetStatics){
|
|
Alpha = TargetAlpha;
|
|
AlphaSpeed = 0.0f;
|
|
}
|
|
WellBufferMe(TargetAlpha, &Alpha, &AlphaSpeed, 0.15f, 0.07f, true);
|
|
|
|
if(ResetStatics){
|
|
Beta = TargetOrientation;
|
|
DeltaBeta = 0.0f;
|
|
}
|
|
// inlined
|
|
WellBufferMe(TargetOrientation, &Beta, &BetaSpeed, BetaDiffMult * ((CVehicle*)CamTargetEntity)->m_vecMoveSpeed.Magnitude(), BetaSpeedDiffMult, true);
|
|
|
|
Source = (TheCamera.CarZoomValueSmooth+BoatSize) * CVector(-Cos(Beta), -Sin(Beta), 0.0f) + TargetCoors;
|
|
Source.z = WaterLevelBuffered + WATER_Z_ADDITION + (BoatDimensions.z/2.0f + MaxHeightUp) * Sin(Alpha);
|
|
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
|
|
|
|
float TargetRoll;
|
|
if(CPad::GetPad(0)->GetDPadLeft() || CPad::GetPad(0)->GetDPadRight()){
|
|
#ifdef FIX_BUGS
|
|
float fwdSpeed = 180.0f*DotProduct(((CVehicle*)CamTargetEntity)->m_vecMoveSpeed, CamTargetEntity->GetForward());
|
|
if(fwdSpeed > 210.0f) fwdSpeed = 210.0f;
|
|
#endif
|
|
if(CPad::GetPad(0)->GetDPadLeft())
|
|
TargetRoll = DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle;
|
|
else
|
|
TargetRoll = -(DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle);
|
|
CVector FwdTarget = CamTargetEntity->GetForward();
|
|
FwdTarget.Normalise();
|
|
float AngleDiff = DotProduct(FwdTarget, Front);
|
|
AngleDiff = Acos(Min(Abs(AngleDiff), 1.0f));
|
|
#ifdef FIX_BUGS
|
|
TargetRoll *= fwdSpeed/210.0f * Sin(AngleDiff);
|
|
#else
|
|
TargetRoll *= Sin(AngleDiff);
|
|
#endif
|
|
}else{
|
|
float fwdSpeed = 180.0f*DotProduct(((CVehicle*)CamTargetEntity)->m_vecMoveSpeed, CamTargetEntity->GetForward());
|
|
if(fwdSpeed > 210.0f) fwdSpeed = 210.0f;
|
|
TargetRoll = CPad::GetPad(0)->GetLeftStickX()/128.0f * fwdSpeed/210.0f;
|
|
CVector FwdTarget = CamTargetEntity->GetForward();
|
|
FwdTarget.Normalise();
|
|
float AngleDiff = DotProduct(FwdTarget, Front);
|
|
AngleDiff = Acos(Min(Abs(AngleDiff), 1.0f));
|
|
TargetRoll *= (DEGTORAD(10.0f)*TiltOverShoot[index] + f_max_role_angle) * Sin(AngleDiff);
|
|
}
|
|
|
|
WellBufferMe(TargetRoll, &f_Roll, &f_rollSpeed, 0.15f, 0.07f, false);
|
|
Up = CVector(Cos(f_Roll + HALFPI), 0.0f, Sin(f_Roll + HALFPI));
|
|
Up.Normalise();
|
|
Front.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Left.Normalise();
|
|
Up = CrossProduct(Front, Left);
|
|
Up.Normalise();
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
float FIGHT_HORIZ_DIST = 3.0f;
|
|
float FIGHT_VERT_DIST = 1.0f;
|
|
float FIGHT_BETA_ANGLE = 125.0f;
|
|
|
|
void
|
|
CCam::Process_Fight_Cam(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
if(!CamTargetEntity->IsPed())
|
|
return;
|
|
|
|
FOV = DefaultFOV;
|
|
float HorizDist = FIGHT_HORIZ_DIST;
|
|
float VertDist = FIGHT_VERT_DIST;
|
|
float BetaLeft, BetaRight, DeltaBetaLeft, DeltaBetaRight;
|
|
static bool PreviouslyFailedBuildingChecks = false;
|
|
float TargetCamHeight;
|
|
CVector TargetCoors;
|
|
|
|
m_fMinDistAwayFromCamWhenInterPolating = FIGHT_HORIZ_DIST;
|
|
Front = Source - CameraTarget;
|
|
if(ResetStatics)
|
|
Beta = CGeneral::GetATanOfXY(Front.x, Front.y);
|
|
while(TargetOrientation >= PI) TargetOrientation -= 2*PI;
|
|
while(TargetOrientation < -PI) TargetOrientation += 2*PI;
|
|
while(Beta >= PI) Beta -= 2*PI;
|
|
while(Beta < -PI) Beta += 2*PI;
|
|
|
|
// Figure out Beta
|
|
BetaLeft = TargetOrientation - DEGTORAD(FIGHT_BETA_ANGLE);
|
|
BetaRight = TargetOrientation + DEGTORAD(FIGHT_BETA_ANGLE);
|
|
DeltaBetaLeft = Beta - BetaLeft;
|
|
DeltaBetaRight = Beta - BetaRight;
|
|
while(DeltaBetaLeft >= PI) DeltaBetaLeft -= 2*PI;
|
|
while(DeltaBetaLeft < -PI) DeltaBetaLeft += 2*PI;
|
|
while(DeltaBetaRight >= PI) DeltaBetaRight -= 2*PI;
|
|
while(DeltaBetaRight < -PI) DeltaBetaRight += 2*PI;
|
|
|
|
if(ResetStatics){
|
|
if(Abs(DeltaBetaLeft) < Abs(DeltaBetaRight))
|
|
m_fTargetBeta = DeltaBetaLeft;
|
|
else
|
|
m_fTargetBeta = DeltaBetaRight;
|
|
m_fBufferedTargetOrientation = TargetOrientation;
|
|
m_fBufferedTargetOrientationSpeed = 0.0f;
|
|
m_bCollisionChecksOn = true;
|
|
BetaSpeed = 0.0f;
|
|
}else if(CPad::GetPad(0)->WeaponJustDown()){
|
|
if(Abs(DeltaBetaLeft) < Abs(DeltaBetaRight))
|
|
m_fTargetBeta = DeltaBetaLeft;
|
|
else
|
|
m_fTargetBeta = DeltaBetaRight;
|
|
}
|
|
|
|
WellBufferMe(m_fTargetBeta, &Beta, &BetaSpeed, 0.015f, 0.007f, true);
|
|
|
|
Source = CameraTarget + HorizDist*CVector(Cos(Beta), Sin(Beta), 0.0f);
|
|
Source.z += VertDist;
|
|
|
|
WellBufferMe(TargetOrientation, &m_fBufferedTargetOrientation, &m_fBufferedTargetOrientationSpeed, 0.07f, 0.004f, true);
|
|
TargetCoors = CameraTarget + 0.1f*CVector(Cos(m_fBufferedTargetOrientation), Sin(m_fBufferedTargetOrientation), 0.0f);
|
|
|
|
TargetCamHeight = CameraTarget.z - Source.z + Max(m_fPedBetweenCameraHeightOffset, m_fDimensionOfHighestNearCar) + VertDist;
|
|
if(TargetCamHeight > m_fCamBufferedHeight)
|
|
WellBufferMe(TargetCamHeight, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.15f, 0.04f, false);
|
|
else
|
|
WellBufferMe(0.0f, &m_fCamBufferedHeight, &m_fCamBufferedHeightSpeed, 0.08f, 0.0175f, false);
|
|
Source.z += m_fCamBufferedHeight;
|
|
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
GetVectorsReadyForRW();
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
/*
|
|
// Spline format is this, but game doesn't seem to use any kind of struct:
|
|
struct Spline
|
|
{
|
|
float numFrames;
|
|
struct {
|
|
float time;
|
|
float f[3]; // CVector for Vector spline
|
|
} frames[1]; // numFrames
|
|
};
|
|
*/
|
|
|
|
// These two functions are pretty ugly
|
|
|
|
#define MS(t) (uint32)((t)*1000.0f)
|
|
|
|
void
|
|
FindSplinePathPositionFloat(float *out, float *spline, uint32 time, uint32 &marker)
|
|
{
|
|
// marker is at time
|
|
uint32 numFrames = spline[0];
|
|
uint32 timeDelta = MS(spline[marker] - spline[marker-4]);
|
|
uint32 endTime = MS(spline[4*(numFrames-1) + 1]);
|
|
if(time < endTime){
|
|
bool canAdvance = true;
|
|
if((marker-1)/4 > numFrames){
|
|
canAdvance = false;
|
|
marker = 4*(numFrames-1) + 1;
|
|
}
|
|
// skipping over small time deltas apparently?
|
|
while(timeDelta <= 75 && canAdvance){
|
|
marker += 4;
|
|
if((marker-1)/4 > numFrames){
|
|
canAdvance = false;
|
|
marker = 4*(numFrames-1) + 1;
|
|
}
|
|
timeDelta = (spline[marker] - spline[marker-4]) * 1000.0f;
|
|
}
|
|
}
|
|
float a = ((float)time - (float)MS(spline[marker-4])) / (float)MS(spline[marker] - spline[marker-4]);
|
|
a = clamp(a, 0.0f, 1.0f);
|
|
float b = 1.0f - a;
|
|
*out = b*b*b * spline[marker-3] +
|
|
3.0f*a*b*b * spline[marker-1] +
|
|
3.0f*a*a*b * spline[marker+2] +
|
|
a*a*a * spline[marker+1];
|
|
}
|
|
|
|
void
|
|
FindSplinePathPositionVector(CVector *out, float *spline, uint32 time, uint32 &marker)
|
|
{
|
|
// marker is at time
|
|
uint32 numFrames = spline[0];
|
|
uint32 timeDelta = MS(spline[marker] - spline[marker-10]);
|
|
uint32 endTime = MS(spline[10*(numFrames-1) + 1]);
|
|
if(time < endTime){
|
|
bool canAdvance = true;
|
|
if((marker-1)/10 > numFrames){
|
|
canAdvance = false;
|
|
marker = 10*(numFrames-1) + 1;
|
|
}
|
|
// skipping over small time deltas apparently?
|
|
while(timeDelta <= 75 && canAdvance){
|
|
marker += 10;
|
|
if((marker-1)/10 > numFrames){
|
|
canAdvance = false;
|
|
marker = 10*(numFrames-1) + 1;
|
|
}
|
|
timeDelta = (spline[marker] - spline[marker-10]) * 1000.0f;
|
|
}
|
|
}
|
|
|
|
if((marker-1)/10 > numFrames){
|
|
printf("Arraymarker %i \n", marker);
|
|
printf("Path zero %i \n", numFrames);
|
|
}
|
|
|
|
float a = ((float)time - (float)MS(spline[marker-10])) / (float)MS(spline[marker] - spline[marker-10]);
|
|
a = clamp(a, 0.0f, 1.0f);
|
|
float b = 1.0f - a;
|
|
out->x =
|
|
b*b*b * spline[marker-9] +
|
|
3.0f*a*b*b * spline[marker-3] +
|
|
3.0f*a*a*b * spline[marker+4] +
|
|
a*a*a * spline[marker+1];
|
|
out->y =
|
|
b*b*b * spline[marker-8] +
|
|
3.0f*a*b*b * spline[marker-2] +
|
|
3.0f*a*a*b * spline[marker+5] +
|
|
a*a*a * spline[marker+2];
|
|
out->z =
|
|
b*b*b * spline[marker-7] +
|
|
3.0f*a*b*b * spline[marker-1] +
|
|
3.0f*a*a*b * spline[marker+6] +
|
|
a*a*a * spline[marker+3];
|
|
*out += TheCamera.m_vecCutSceneOffset;
|
|
}
|
|
|
|
void
|
|
CCam::Process_FlyBy(const CVector&, float, float, float)
|
|
{
|
|
float UpAngle = 0.0f;
|
|
static float FirstFOVValue = 0.0f;
|
|
static float PsuedoFOV;
|
|
static uint32 ArrayMarkerFOV;
|
|
static uint32 ArrayMarkerUp;
|
|
static uint32 ArrayMarkerSource;
|
|
static uint32 ArrayMarkerFront;
|
|
|
|
if(TheCamera.m_bcutsceneFinished)
|
|
return;
|
|
#ifdef FIX_BUGS
|
|
// this would crash, not nice when cycling debug mode
|
|
if(TheCamera.m_arrPathArray[0].m_arr_PathData == nil)
|
|
return;
|
|
#endif
|
|
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
if(TheCamera.m_bStartingSpline)
|
|
m_fTimeElapsedFloat += CTimer::GetTimeStepNonClippedInMilliseconds();
|
|
else{
|
|
m_fTimeElapsedFloat = 0.0f;
|
|
m_uiFinishTime = MS(TheCamera.m_arrPathArray[2].m_arr_PathData[10*((int)TheCamera.m_arrPathArray[2].m_arr_PathData[0]-1) + 1]);
|
|
TheCamera.m_bStartingSpline = true;
|
|
FirstFOVValue = TheCamera.m_arrPathArray[0].m_arr_PathData[2];
|
|
PsuedoFOV = TheCamera.m_arrPathArray[0].m_arr_PathData[2];
|
|
ArrayMarkerFOV = 5;
|
|
ArrayMarkerUp = 5;
|
|
ArrayMarkerSource = 11;
|
|
ArrayMarkerFront = 11;
|
|
}
|
|
|
|
float fTime = m_fTimeElapsedFloat;
|
|
uint32 uiFinishTime = m_uiFinishTime;
|
|
uint32 uiTime = fTime;
|
|
if(uiTime < uiFinishTime){
|
|
TheCamera.m_fPositionAlongSpline = (float) uiTime / uiFinishTime;
|
|
|
|
while(uiTime >= (TheCamera.m_arrPathArray[2].m_arr_PathData[ArrayMarkerSource] - TheCamera.m_arrPathArray[2].m_arr_PathData[1])*1000.0f)
|
|
ArrayMarkerSource += 10;
|
|
FindSplinePathPositionVector(&Source, TheCamera.m_arrPathArray[2].m_arr_PathData, uiTime, ArrayMarkerSource);
|
|
|
|
while(uiTime >= (TheCamera.m_arrPathArray[3].m_arr_PathData[ArrayMarkerFront] - TheCamera.m_arrPathArray[3].m_arr_PathData[1])*1000.0f)
|
|
ArrayMarkerFront += 10;
|
|
FindSplinePathPositionVector(&Front, TheCamera.m_arrPathArray[3].m_arr_PathData, uiTime, ArrayMarkerFront);
|
|
|
|
while(uiTime >= (TheCamera.m_arrPathArray[1].m_arr_PathData[ArrayMarkerUp] - TheCamera.m_arrPathArray[1].m_arr_PathData[1])*1000.0f)
|
|
ArrayMarkerUp += 4;
|
|
FindSplinePathPositionFloat(&UpAngle, TheCamera.m_arrPathArray[1].m_arr_PathData, uiTime, ArrayMarkerUp);
|
|
UpAngle = DEGTORAD(UpAngle) + HALFPI;
|
|
Up.x = Cos(UpAngle);
|
|
Up.z = Sin(UpAngle);
|
|
|
|
while(uiTime >= (TheCamera.m_arrPathArray[0].m_arr_PathData[ArrayMarkerFOV] - TheCamera.m_arrPathArray[0].m_arr_PathData[1])*1000.0f)
|
|
ArrayMarkerFOV += 4;
|
|
FindSplinePathPositionFloat(&PsuedoFOV, TheCamera.m_arrPathArray[0].m_arr_PathData, uiTime, ArrayMarkerFOV);
|
|
|
|
m_cvecTargetCoorsForFudgeInter = Front;
|
|
Front = Front - Source;
|
|
Front.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Up = CrossProduct(Front, Left);
|
|
Up.Normalise();
|
|
}else if(uiTime >= uiFinishTime){
|
|
// end
|
|
ArrayMarkerSource = (TheCamera.m_arrPathArray[2].m_arr_PathData[0] - 1)*10 + 1;
|
|
ArrayMarkerFront = (TheCamera.m_arrPathArray[3].m_arr_PathData[0] - 1)*10 + 1;
|
|
ArrayMarkerUp = (TheCamera.m_arrPathArray[1].m_arr_PathData[0] - 1)*4 + 1;
|
|
ArrayMarkerFOV = (TheCamera.m_arrPathArray[0].m_arr_PathData[0] - 1)*4 + 1;
|
|
|
|
FindSplinePathPositionVector(&Source, TheCamera.m_arrPathArray[2].m_arr_PathData, uiTime, ArrayMarkerSource);
|
|
FindSplinePathPositionVector(&Front, TheCamera.m_arrPathArray[3].m_arr_PathData, uiTime, ArrayMarkerFront);
|
|
FindSplinePathPositionFloat(&UpAngle, TheCamera.m_arrPathArray[1].m_arr_PathData, uiTime, ArrayMarkerUp);
|
|
UpAngle = DEGTORAD(UpAngle) + HALFPI;
|
|
Up.x = Cos(UpAngle);
|
|
Up.z = Sin(UpAngle);
|
|
FindSplinePathPositionFloat(&PsuedoFOV, TheCamera.m_arrPathArray[0].m_arr_PathData, uiTime, ArrayMarkerFOV);
|
|
|
|
TheCamera.m_fPositionAlongSpline = 1.0f;
|
|
ArrayMarkerFOV = 0;
|
|
ArrayMarkerUp = 0;
|
|
ArrayMarkerSource = 0;
|
|
ArrayMarkerFront = 0;
|
|
|
|
m_cvecTargetCoorsForFudgeInter = Front;
|
|
Front = Front - Source;
|
|
Front.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Up = CrossProduct(Front, Left);
|
|
Up.Normalise();
|
|
}
|
|
FOV = PsuedoFOV;
|
|
}
|
|
|
|
CVector vecWheelCamBoatOffset(-0.5f, -0.8f, 0.3f);
|
|
CVector vecWheelCamBoatOffsetAlt(0.2f, -0.2f, -0.3f);
|
|
float fWheelCamCarXOffset = 0.33f;
|
|
float fWheelCamBikeXOffset = 0.2f;
|
|
|
|
bool
|
|
CCam::Process_WheelCam(const CVector&, float, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
CVector WheelPos;
|
|
if(CamTargetEntity->IsPed()){
|
|
// what? ped with wheels or what?
|
|
Source = Multiply3x3(CamTargetEntity->GetMatrix(), CVector(-0.3f, -0.5f, 0.1f));
|
|
Source += CamTargetEntity->GetPosition();
|
|
Front = CVector(1.0f, 0.0f, 0.0f);
|
|
}else{
|
|
WheelPos = CamTargetEntity->GetColModel()->boundingBox.min;
|
|
WheelPos.x -= 0.33f;
|
|
WheelPos.y = -2.3f;
|
|
WheelPos.z = 0.3f;
|
|
Source = CamTargetEntity->GetMatrix() * WheelPos;
|
|
Front = CamTargetEntity->GetForward();
|
|
}
|
|
|
|
CVector NewUp, Right;
|
|
if(CamTargetEntity->IsVehicle() &&
|
|
(((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI ||
|
|
((CVehicle*)CamTargetEntity)->GetVehicleAppearance() == VEHICLE_APPEARANCE_PLANE)){
|
|
WheelPos.x = -1.55f;
|
|
Right = CamTargetEntity->GetRight();
|
|
NewUp = CamTargetEntity->GetUp();
|
|
Source = CamTargetEntity->GetMatrix() * WheelPos;
|
|
}else if(CamTargetEntity->IsVehicle() && ((CVehicle*)CamTargetEntity)->IsBoat()){
|
|
NewUp = CVector(0.0f, 0.0f, 1.0f);
|
|
Right = CrossProduct(Front, NewUp);
|
|
Right.Normalise();
|
|
NewUp = CrossProduct(Right, Front);
|
|
NewUp.Normalise();
|
|
|
|
CVector BoatCamPos(0.0f, 0.0f, 0.0f);
|
|
if(((CVehicle*)CamTargetEntity)->pDriver){
|
|
((CVehicle*)CamTargetEntity)->pDriver->m_pedIK.GetComponentPosition(BoatCamPos, PED_HEAD);
|
|
BoatCamPos += ((CVehicle*)CamTargetEntity)->m_vecMoveSpeed * CTimer::GetTimeStep();
|
|
BoatCamPos += vecWheelCamBoatOffset.x * Right;
|
|
BoatCamPos += vecWheelCamBoatOffset.y * CamTargetEntity->GetForward();
|
|
BoatCamPos.z += vecWheelCamBoatOffset.z;
|
|
if(CamTargetEntity->GetModelIndex() == MI_PREDATOR){
|
|
BoatCamPos += vecWheelCamBoatOffsetAlt.x * Right;
|
|
BoatCamPos += vecWheelCamBoatOffsetAlt.y * CamTargetEntity->GetForward();
|
|
BoatCamPos.z += vecWheelCamBoatOffsetAlt.z;
|
|
}
|
|
Source = BoatCamPos;
|
|
}else
|
|
Source.z += 2.0f*vecWheelCamBoatOffset.z;
|
|
}else if(CamTargetEntity->IsVehicle() && ((CVehicle*)CamTargetEntity)->IsBike()){
|
|
NewUp = CVector(0.0f, 0.0f, 1.0f);
|
|
Right = CrossProduct(Front, NewUp);
|
|
Right.Normalise();
|
|
NewUp = CrossProduct(Right, Front);
|
|
NewUp.Normalise();
|
|
|
|
WheelPos.z += fWheelCamCarXOffset - fWheelCamBikeXOffset;
|
|
Source = CamTargetEntity->GetPosition();
|
|
Source += WheelPos.x * CamTargetEntity->GetRight();
|
|
Source += WheelPos.y * Front;
|
|
Source += WheelPos.z * Up;
|
|
}else{
|
|
NewUp = CVector(0.0f, 0.0f, 1.0f);
|
|
Right = CrossProduct(Front, NewUp);
|
|
Right.Normalise();
|
|
NewUp = CrossProduct(Right, Front);
|
|
NewUp.Normalise();
|
|
}
|
|
|
|
float Roll = Cos((CTimer::GetTimeInMilliseconds()&0x1FFFF)/(float)0x1FFFF * TWOPI);
|
|
Up = Cos(Roll*0.4f)*NewUp + Sin(Roll*0.4f)*Right;
|
|
|
|
CEntity *entity = nil;
|
|
CColPoint point;
|
|
CWorld::pIgnoreEntity = CamTargetEntity;
|
|
bool blocked = CWorld::ProcessLineOfSight(Source, CamTargetEntity->GetPosition(), point, entity, true, false, false, true, false, false, true);
|
|
CWorld::pIgnoreEntity = nil;
|
|
return !blocked;
|
|
}
|
|
|
|
int BOAT_UNDERWATER_CAM_BLUR = 20;
|
|
float BOAT_UNDERWATER_CAM_COLORMAG_LIMIT = 10.0f;
|
|
|
|
//--MIAIM: done
|
|
void
|
|
CCam::Process_Fixed(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
if(DirectionWasLooking != LOOKING_FORWARD)
|
|
DirectionWasLooking = LOOKING_FORWARD;
|
|
|
|
Source = m_cvecCamFixedModeSource;
|
|
Front = CameraTarget - Source;
|
|
Front.Normalise();
|
|
m_cvecTargetCoorsForFudgeInter = CameraTarget;
|
|
GetVectorsReadyForRW();
|
|
|
|
Up = CVector(0.0f, 0.0f, 1.0f) + m_cvecCamFixedModeUpOffSet;
|
|
Up.Normalise();
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
|
|
FOV = DefaultFOV;
|
|
if(TheCamera.m_bUseSpecialFovTrain)
|
|
FOV = TheCamera.m_fFovForTrain;
|
|
|
|
float WaterZ = 0.0f;
|
|
if(CWaterLevel::GetWaterLevel(Source, &WaterZ, true) && Source.z < WaterZ){
|
|
float WaterLum = Sqrt(SQR(CTimeCycle::GetWaterRed()) + SQR(CTimeCycle::GetWaterGreen()) + SQR(CTimeCycle::GetWaterBlue()));
|
|
if(WaterLum > BOAT_UNDERWATER_CAM_COLORMAG_LIMIT){
|
|
float f = BOAT_UNDERWATER_CAM_COLORMAG_LIMIT/WaterLum;
|
|
TheCamera.SetMotionBlur(CTimeCycle::GetWaterRed()*f,
|
|
CTimeCycle::GetWaterGreen()*f,
|
|
CTimeCycle::GetWaterBlue()*f, BOAT_UNDERWATER_CAM_BLUR, MOTION_BLUR_LIGHT_SCENE);
|
|
}else{
|
|
TheCamera.SetMotionBlur(CTimeCycle::GetWaterRed(),
|
|
CTimeCycle::GetWaterGreen(),
|
|
CTimeCycle::GetWaterBlue(), BOAT_UNDERWATER_CAM_BLUR, MOTION_BLUR_LIGHT_SCENE);
|
|
}
|
|
}
|
|
|
|
#ifdef PC_PLAYER_CONTROLS
|
|
if(FrontEndMenuManager.m_ControlMethod == CONTROL_STANDARD && Using3rdPersonMouseCam()){
|
|
CPed *player = FindPlayerPed();
|
|
if(player && player->CanStrafeOrMouseControl()){
|
|
float Heading = Front.Heading();
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationCur = Heading;
|
|
((CPed*)TheCamera.pTargetEntity)->m_fRotationDest = Heading;
|
|
TheCamera.pTargetEntity->SetHeading(Heading);
|
|
TheCamera.pTargetEntity->GetMatrix().UpdateRW();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CCam::Process_LightHouse(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
static float Timer;
|
|
|
|
Source = CameraTarget;
|
|
Source.x = 474.3f;
|
|
Source.y = -1717.6f;
|
|
|
|
int CamMode;
|
|
if(CameraTarget.z > 57.0f && (CameraTarget-Source).Magnitude2D() > 3.2f){
|
|
// Outside at top
|
|
if(Timer > 0.0f){
|
|
Timer -= CTimer::GetTimeStep();
|
|
CamMode = 1;
|
|
}else{
|
|
Timer = -24.0f;
|
|
CamMode = 2;
|
|
}
|
|
}else if(CameraTarget.z > 57.0f){
|
|
// Inside at top
|
|
if(Timer < 0.0f){
|
|
Timer += CTimer::GetTimeStep();
|
|
CamMode = 2;
|
|
}else{
|
|
Timer = 24.0f;
|
|
CamMode = 1;
|
|
}
|
|
}else{
|
|
Timer = 0.0f;
|
|
CamMode = 0;
|
|
}
|
|
|
|
if(CamMode == 2){
|
|
Source.z = 57.5f;
|
|
Front = Source - CameraTarget;
|
|
Front.Normalise();
|
|
Source.x = CameraTarget.x - 5.0f*Front.x;
|
|
Source.y = CameraTarget.y - 5.0f*Front.y;
|
|
}else if(CamMode == 1){
|
|
Front = CameraTarget - Source;
|
|
Front.Normalise();
|
|
Source.x = CameraTarget.x - 2.0f*Front.x;
|
|
Source.y = CameraTarget.y - 2.0f*Front.y;
|
|
}else{
|
|
Source.z += 4.0f;
|
|
Front = CameraTarget - Source;
|
|
Front.Normalise();
|
|
Source -= 4.0f*Front;
|
|
Source.z = Min(Source.z, 55.0f);
|
|
Front = CameraTarget - Source;
|
|
}
|
|
|
|
m_cvecTargetCoorsForFudgeInter = CameraTarget;
|
|
GetVectorsReadyForRW();
|
|
|
|
Up = CVector(0.0f, 0.0f, 1.0f) + m_cvecCamFixedModeUpOffSet;
|
|
Up.Normalise();
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
|
|
FOV = DefaultFOV;
|
|
if(TheCamera.m_bUseSpecialFovTrain) // uh, sure...
|
|
FOV = TheCamera.m_fFovForTrain;
|
|
}
|
|
|
|
void
|
|
CCam::Process_Player_Fallen_Water(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
CColPoint colPoint;
|
|
CEntity *entity = nil;
|
|
|
|
FOV = DefaultFOV;
|
|
Source = m_vecLastAboveWaterCamPosition;
|
|
Source.z += 4.0f;
|
|
|
|
m_cvecTargetCoorsForFudgeInter = CameraTarget;
|
|
Front = CameraTarget - Source;
|
|
Front.Normalise();
|
|
if(CWorld::ProcessLineOfSight(CameraTarget, Source, colPoint, entity, true, false, false, true, false, true, true))
|
|
Source = colPoint.point;
|
|
GetVectorsReadyForRW();
|
|
Front = CameraTarget - Source;
|
|
Front.Normalise();
|
|
}
|
|
|
|
void
|
|
CCam::Process_SpecialFixedForSyphon(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
Source = m_cvecCamFixedModeSource;
|
|
m_cvecTargetCoorsForFudgeInter = CameraTarget;
|
|
m_cvecTargetCoorsForFudgeInter.z += m_fSyphonModeTargetZOffSet;
|
|
Front = CameraTarget - Source;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, m_cvecTargetCoorsForFudgeInter, Source, FOV);
|
|
Front.z += m_fSyphonModeTargetZOffSet;
|
|
|
|
GetVectorsReadyForRW();
|
|
|
|
Up += m_cvecCamFixedModeUpOffSet;
|
|
Up.Normalise();
|
|
CVector Left = CrossProduct(Up, Front);
|
|
Left.Normalise();
|
|
Front = CrossProduct(Left, Up);
|
|
Front.Normalise();
|
|
FOV = DefaultFOV;
|
|
}
|
|
|
|
#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))
|
|
|
|
|
|
void
|
|
CCam::Process_Debug(const CVector&, float, float, float)
|
|
{
|
|
static float Speed = 0.0f;
|
|
static float PanSpeedX = 0.0f;
|
|
static float PanSpeedY = 0.0f;
|
|
CVector TargetCoors;
|
|
|
|
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;
|
|
if(CPad::GetPad(0)->GetLeftMouse()){
|
|
Alpha += DEGTORAD(CPad::GetPad(0)->GetMouseY()/2.0f);
|
|
Beta += DEGTORAD(CPad::GetPad(0)->GetMouseX()/2.0f);
|
|
}
|
|
|
|
TargetCoors.x = Source.x + Cos(Alpha) * Sin(Beta) * 7.0f;
|
|
TargetCoors.y = Source.y + Cos(Alpha) * Cos(Beta) * 7.0f;
|
|
TargetCoors.z = Source.z + Sin(Alpha) * 3.0f;
|
|
|
|
if(Alpha > DEGTORAD(89.5f)) Alpha = DEGTORAD(89.5f);
|
|
else if(Alpha < DEGTORAD(-89.5f)) Alpha = DEGTORAD(-89.5f);
|
|
|
|
if(CPad::GetPad(1)->GetSquare() || KEYDOWN('W'))
|
|
Speed += 0.1f;
|
|
else if(CPad::GetPad(1)->GetCross() || KEYDOWN('S'))
|
|
Speed -= 0.1f;
|
|
else
|
|
Speed = 0.0f;
|
|
if(Speed > 70.0f) Speed = 70.0f;
|
|
if(Speed < -70.0f) Speed = -70.0f;
|
|
|
|
|
|
if(KEYDOWN(rsRIGHT) || KEYDOWN('D'))
|
|
PanSpeedX += 0.1f;
|
|
else if(KEYDOWN(rsLEFT) || KEYDOWN('A'))
|
|
PanSpeedX -= 0.1f;
|
|
else
|
|
PanSpeedX = 0.0f;
|
|
if(PanSpeedX > 70.0f) PanSpeedX = 70.0f;
|
|
if(PanSpeedX < -70.0f) PanSpeedX = -70.0f;
|
|
|
|
|
|
if(KEYDOWN(rsUP))
|
|
PanSpeedY += 0.1f;
|
|
else if(KEYDOWN(rsDOWN))
|
|
PanSpeedY -= 0.1f;
|
|
else
|
|
PanSpeedY = 0.0f;
|
|
if(PanSpeedY > 70.0f) PanSpeedY = 70.0f;
|
|
if(PanSpeedY < -70.0f) PanSpeedY = -70.0f;
|
|
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source = Source + Front*Speed;
|
|
|
|
Up = CVector{ 0.0f, 0.0f, 1.0f };
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Up = CrossProduct(Right, Front);
|
|
Source = Source + Up*PanSpeedY + Right*PanSpeedX;
|
|
|
|
if(Source.z < -450.0f)
|
|
Source.z = -450.0f;
|
|
|
|
if(CPad::GetPad(1)->GetRightShoulder2JustDown() || KEYJUSTDOWN(rsENTER)){
|
|
if(FindPlayerVehicle())
|
|
FindPlayerVehicle()->Teleport(Source);
|
|
else
|
|
CWorld::Players[CWorld::PlayerInFocus].m_pPed->SetPosition(Source);
|
|
}
|
|
|
|
// stay inside sectors
|
|
while(CWorld::GetSectorX(Source.x) > NUMSECTORS_X-5.0f)
|
|
Source.x -= 1.0f;
|
|
while(CWorld::GetSectorX(Source.x) < 5.0f)
|
|
Source.x += 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) > NUMSECTORS_X-5.0f)
|
|
Source.y -= 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) < 5.0f)
|
|
Source.y += 1.0f;
|
|
GetVectorsReadyForRW();
|
|
|
|
#ifdef FIX_BUGS
|
|
CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_CAMERA);
|
|
#else
|
|
CPad::GetPad(0)->DisablePlayerControls = PLAYERCONTROL_CAMERA;
|
|
#endif
|
|
|
|
if(CPad::GetPad(1)->GetLeftShockJustDown() && gbBigWhiteDebugLightSwitchedOn)
|
|
CShadows::StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowExplosionTex, &Source,
|
|
12.0f, 0.0f, 0.0f, -12.0f,
|
|
128, 128, 128, 128, 1000.0f, false, 1.0f, nil, false);
|
|
|
|
if(CHud::m_Wants_To_Draw_Hud){
|
|
char str[256];
|
|
sprintf(str, "CamX: %f CamY: %f CamZ: %f", Source.x, Source.y, Source.z);
|
|
sprintf(str, "Frontx: %f, Fronty: %f, Frontz: %f ", Front.x, Front.y, Front.z);
|
|
sprintf(str, "Look@: %f, Look@: %f, Look@: %f ", Front.x + Source.x, Front.y + Source.y, Front.z + Source.z);
|
|
}
|
|
}
|
|
#else
|
|
void
|
|
CCam::Process_Debug(const CVector&, float, float, float)
|
|
{
|
|
static float Speed = 0.0f;
|
|
CVector TargetCoors;
|
|
|
|
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;
|
|
|
|
TargetCoors.x = Source.x + Cos(Alpha) * Sin(Beta) * 7.0f;
|
|
TargetCoors.y = Source.y + Cos(Alpha) * Cos(Beta) * 7.0f;
|
|
TargetCoors.z = Source.z + Sin(Alpha) * 3.0f;
|
|
|
|
if(Alpha > DEGTORAD(89.5f)) Alpha = DEGTORAD(89.5f);
|
|
else if(Alpha < DEGTORAD(-89.5f)) Alpha = DEGTORAD(-89.5f);
|
|
|
|
if(CPad::GetPad(1)->GetSquare() || CPad::GetPad(1)->GetLeftMouse())
|
|
Speed += 0.1f;
|
|
else if(CPad::GetPad(1)->GetCross() || CPad::GetPad(1)->GetRightMouse())
|
|
Speed -= 0.1f;
|
|
else
|
|
Speed = 0.0f;
|
|
if(Speed > 70.0f) Speed = 70.0f;
|
|
if(Speed < -70.0f) Speed = -70.0f;
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source = Source + Front*Speed;
|
|
|
|
if(Source.z < -450.0f)
|
|
Source.z = -450.0f;
|
|
|
|
if(CPad::GetPad(1)->GetRightShoulder2JustDown()){
|
|
if(FindPlayerVehicle())
|
|
FindPlayerVehicle()->Teleport(Source);
|
|
else
|
|
CWorld::Players[CWorld::PlayerInFocus].m_pPed->SetPosition(Source);
|
|
}
|
|
|
|
// stay inside sectors
|
|
while(CWorld::GetSectorX(Source.x) > NUMSECTORS_X-5.0f)
|
|
Source.x -= 1.0f;
|
|
while(CWorld::GetSectorX(Source.x) < 5.0f)
|
|
Source.x += 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) > NUMSECTORS_X-5.0f)
|
|
Source.y -= 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) < 5.0f)
|
|
Source.y += 1.0f;
|
|
GetVectorsReadyForRW();
|
|
|
|
if(CPad::GetPad(1)->GetLeftShockJustDown() && gbBigWhiteDebugLightSwitchedOn)
|
|
CShadows::StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowExplosionTex, &Source,
|
|
12.0f, 0.0f, 0.0f, -12.0f,
|
|
128, 128, 128, 128, 1000.0f, false, 1.0f);
|
|
|
|
if(CHud::m_Wants_To_Draw_Hud){
|
|
char str[256];
|
|
sprintf(str, "CamX: %f CamY: %f CamZ: %f", Source.x, Source.y, Source.z);
|
|
sprintf(str, "Frontx: %f, Fronty: %f, Frontz: %f ", Front.x, Front.y, Front.z);
|
|
sprintf(str, "Look@: %f, Look@: %f, Look@: %f ", Front.x + Source.x, Front.y + Source.y, Front.z + Source.z);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef GTA_SCENE_EDIT
|
|
void
|
|
CCam::Process_Editor(const CVector&, float, float, float)
|
|
{
|
|
static float Speed = 0.0f;
|
|
CVector TargetCoors;
|
|
|
|
if(ResetStatics){
|
|
Source = CVector(796.0f, -937.0, 40.0f);
|
|
CamTargetEntity = nil;
|
|
}
|
|
ResetStatics = false;
|
|
|
|
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;
|
|
|
|
if(CamTargetEntity && CSceneEdit::m_bCameraFollowActor){
|
|
TargetCoors = CamTargetEntity->GetPosition();
|
|
}else if(CSceneEdit::m_bRecording){
|
|
TargetCoors.x = Source.x + Cos(Alpha) * Sin(Beta) * 7.0f;
|
|
TargetCoors.y = Source.y + Cos(Alpha) * Cos(Beta) * 7.0f;
|
|
TargetCoors.z = Source.z + Sin(Alpha) * 7.0f;
|
|
}else
|
|
TargetCoors = CSceneEdit::m_vecCamHeading + Source;
|
|
CSceneEdit::m_vecCurrentPosition = TargetCoors;
|
|
CSceneEdit::m_vecCamHeading = TargetCoors - Source;
|
|
|
|
if(Alpha > DEGTORAD(89.5f)) Alpha = DEGTORAD(89.5f);
|
|
else if(Alpha < DEGTORAD(-89.5f)) Alpha = DEGTORAD(-89.5f);
|
|
|
|
if(CPad::GetPad(1)->GetSquare() || CPad::GetPad(1)->GetLeftMouse())
|
|
Speed += 0.1f;
|
|
else if(CPad::GetPad(1)->GetCross() || CPad::GetPad(1)->GetRightMouse())
|
|
Speed -= 0.1f;
|
|
else
|
|
Speed = 0.0f;
|
|
if(Speed > 70.0f) Speed = 70.0f;
|
|
if(Speed < -70.0f) Speed = -70.0f;
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
Source = Source + Front*Speed;
|
|
|
|
if(Source.z < -450.0f)
|
|
Source.z = -450.0f;
|
|
|
|
if(CPad::GetPad(1)->GetRightShoulder2JustDown()){
|
|
if(FindPlayerVehicle())
|
|
FindPlayerVehicle()->Teleport(Source);
|
|
else
|
|
CWorld::Players[CWorld::PlayerInFocus].m_pPed->SetPosition(Source);
|
|
|
|
}
|
|
|
|
// stay inside sectors
|
|
while(CWorld::GetSectorX(Source.x) > NUMSECTORS_X-5.0f)
|
|
Source.x -= 1.0f;
|
|
while(CWorld::GetSectorX(Source.x) < 5.0f)
|
|
Source.x += 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) > NUMSECTORS_X-5.0f)
|
|
Source.y -= 1.0f;
|
|
while(CWorld::GetSectorY(Source.y) < 5.0f)
|
|
Source.y += 1.0f;
|
|
GetVectorsReadyForRW();
|
|
|
|
if(CPad::GetPad(1)->GetLeftShockJustDown() && gbBigWhiteDebugLightSwitchedOn)
|
|
CShadows::StoreShadowToBeRendered(SHADOWTYPE_ADDITIVE, gpShadowExplosionTex, &Source,
|
|
12.0f, 0.0f, 0.0f, -12.0f,
|
|
128, 128, 128, 128, 1000.0f, false, 1.0f, nil, false);
|
|
|
|
if(CHud::m_Wants_To_Draw_Hud){
|
|
char str[256];
|
|
sprintf(str, "CamX: %f CamY: %f CamZ: %f", Source.x, Source.y, Source.z);
|
|
sprintf(str, "Frontx: %f, Fronty: %f, Frontz: %f ", Front.x, Front.y, Front.z);
|
|
sprintf(str, "Look@: %f, Look@: %f, Look@: %f ", Front.x + Source.x, Front.y + Source.y, Front.z + Source.z);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void
|
|
CCam::Process_ModelView(const CVector &CameraTarget, float, float, float)
|
|
{
|
|
CVector TargetCoors = CameraTarget;
|
|
float Angle = Atan2(Front.x, Front.y);
|
|
FOV = DefaultFOV;
|
|
|
|
Angle += CPad::GetPad(0)->GetLeftStickX()/1280.0f;
|
|
if(Distance < 10.0f)
|
|
Distance += CPad::GetPad(0)->GetLeftStickY()/1000.0f;
|
|
else
|
|
Distance += CPad::GetPad(0)->GetLeftStickY() * ((Distance - 10.0f)/20.0f + 1.0f) / 1000.0f;
|
|
#ifdef IMPROVED_CAMERA
|
|
if(CPad::GetPad(0)->GetLeftMouse()){
|
|
Distance += DEGTORAD(CPad::GetPad(0)->GetMouseY()/2.0f);
|
|
Angle += DEGTORAD(CPad::GetPad(0)->GetMouseX()/2.0f);
|
|
}
|
|
#endif
|
|
if(Distance < 1.5f)
|
|
Distance = 1.5f;
|
|
|
|
Front.x = Cos(0.3f) * Sin(Angle);
|
|
Front.y = Cos(0.3f) * Cos(Angle);
|
|
Front.z = -Sin(0.3f);
|
|
Source = CameraTarget - Distance*Front;
|
|
|
|
GetVectorsReadyForRW();
|
|
}
|
|
|
|
float DEADCAM_HEIGHT_START = 2.0f;
|
|
float DEADCAM_HEIGHT_RATE = 0.04f;
|
|
float DEADCAM_WAFT_AMPLITUDE = 2.0f;
|
|
float DEADCAM_WAFT_RATE = 600.0f;
|
|
float DEADCAM_WAFT_TILT_AMP = -0.35f;
|
|
|
|
void
|
|
CCam::ProcessPedsDeadBaby(void)
|
|
{
|
|
CVector TargetCoors;
|
|
CVector CamPos;
|
|
|
|
if(TheCamera.pTargetEntity->IsPed())
|
|
((CPed*)TheCamera.pTargetEntity)->m_pedIK.GetComponentPosition(TargetCoors, PED_MID);
|
|
else if(TheCamera.pTargetEntity->IsVehicle()){
|
|
TargetCoors = TheCamera.pTargetEntity->GetPosition();
|
|
TargetCoors.z += TheCamera.pTargetEntity->GetColModel()->boundingBox.max.z;
|
|
}else
|
|
return;
|
|
|
|
if(ResetStatics){
|
|
TheCamera.m_uiTimeLastChange = CTimer::GetTimeInMilliseconds();
|
|
CamPos = TargetCoors;
|
|
CamPos.z += DEADCAM_HEIGHT_START;
|
|
float WaterZ = 0.0f;
|
|
if(CWaterLevel::GetWaterLevelNoWaves(TargetCoors.x, TargetCoors.y, TargetCoors.z, &WaterZ)){
|
|
if(WaterZ + 1.5f > CamPos.z)
|
|
CamPos.z = WaterZ + 1.5f;
|
|
}
|
|
CVector Right = CrossProduct(TheCamera.pTargetEntity->GetForward(), CVector(0.0f, 0.0f, 1.0f));
|
|
Right.z = 0.0f;
|
|
Right.Normalise();
|
|
Front = TargetCoors - CamPos;
|
|
Front.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
Up.Normalise();
|
|
ResetStatics = false;
|
|
}else{
|
|
CamPos = Source;
|
|
if(CWorld::TestSphereAgainstWorld(CamPos+CVector(0.0f, 0.0f, 0.2f), 0.3f, TheCamera.pTargetEntity, true, true, false, true, false, true) == nil)
|
|
CamPos.z += DEADCAM_HEIGHT_RATE*CTimer::GetTimeStep();
|
|
CVector Right = CrossProduct(TheCamera.pTargetEntity->GetForward(), CVector(0.0f, 0.0f, 1.0f));
|
|
Right.z = 0.0f;
|
|
Right.Normalise();
|
|
|
|
float Time = CTimer::GetTimeInMilliseconds() - TheCamera.m_uiTimeLastChange;
|
|
CVector WaftOffset = DEADCAM_WAFT_AMPLITUDE * Min(1000.0f,Time)/1000.0f * Sin(Time/DEADCAM_WAFT_RATE) * Right;
|
|
CVector WaftPos = TargetCoors + WaftOffset;
|
|
WaftPos.z = CamPos.z;
|
|
CVector WaftFront = WaftPos - CamPos;
|
|
WaftFront.Normalise();
|
|
if(CWorld::TestSphereAgainstWorld(CamPos+0.2f*WaftFront, 0.3f, TheCamera.pTargetEntity, true, true, false, true, false, true) == nil)
|
|
CamPos = WaftPos;
|
|
|
|
Front = CVector(0.0f, 0.0f, -1.0f);
|
|
Front += Cos(Time/DEADCAM_WAFT_RATE) * DEADCAM_WAFT_TILT_AMP * Min(2000.0f,Time)/2000.0f * Right;
|
|
|
|
Front.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
Up.Normalise();
|
|
}
|
|
|
|
Source = CamPos;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetCoors, Source, FOV);
|
|
TheCamera.m_bMoveCamToAvoidGeom = false;
|
|
}
|
|
|
|
float ARRESTDIST_BEHIND_COP = 5.0f;
|
|
float ARRESTDIST_RIGHTOF_COP = 3.0f;
|
|
float ARRESTDIST_ABOVE_COP = 1.4f; // unused
|
|
float ARRESTDIST_MINFROM_PLAYER = 8.0f;
|
|
float ARRESTCAM_LAMP_BEST_DIST = 17.0f;
|
|
float ARRESTCAM_ROTATION_SPEED = 0.1f;
|
|
float ARRESTCAM_ROTATION_UP = 0.05f;
|
|
float ARRESTCAM_S_ROTATION_UP = 0.1f;
|
|
float ARRESTDIST_ALONG_GROUND = 5.0f;
|
|
float ARRESTDIST_SIDE_GROUND = 10.0f;
|
|
float ARRESTDIST_ABOVE_GROUND = 0.7f;
|
|
float ARRESTCAM_LAMPPOST_ROTATEDIST = 10.0f;
|
|
float ARRESTCAM_LAMPPOST_TRANSLATE = 0.1f;
|
|
|
|
bool
|
|
CCam::GetLookAlongGroundPos(CEntity *Target, CPed *Cop, CVector &TargetCoors, CVector &SourceOut)
|
|
{
|
|
if(Target == nil || Cop == nil)
|
|
return false;
|
|
CVector CopToTarget = TargetCoors - Cop->GetPosition();
|
|
CopToTarget.z = 0.0f;
|
|
CopToTarget.Normalise();
|
|
SourceOut = TargetCoors + ARRESTDIST_ALONG_GROUND*CopToTarget;
|
|
CVector Side = CrossProduct(CopToTarget, CVector(0.0f, 0.0f, 1.0f));
|
|
SourceOut += ARRESTDIST_SIDE_GROUND*Side;
|
|
SourceOut.z += 5.0f;
|
|
bool found = false;
|
|
float ground = CWorld::FindGroundZFor3DCoord(SourceOut.x, SourceOut.y, SourceOut.z, &found);
|
|
if(found)
|
|
SourceOut.z = ground + ARRESTDIST_ABOVE_GROUND;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CCam::GetLookFromLampPostPos(CEntity *Target, CPed *Cop, CVector &TargetCoors, CVector &SourceOut)
|
|
{
|
|
int i;
|
|
int16 NumObjects;
|
|
CEntity *Objects[16];
|
|
CEntity *NearestLampPost = nil;
|
|
CWorld::FindObjectsInRange(TargetCoors, 30.0f, true, &NumObjects, 15, Objects, false, false, false, true, true);
|
|
float NearestDist = 10000.0f;
|
|
for(i = 0; i < NumObjects; i++){
|
|
if(Objects[i]->GetIsStatic() && Objects[i]->GetUp().z > 0.9f && IsLampPost(Objects[i]->GetModelIndex())){
|
|
float Dist = (Objects[i]->GetPosition() - TargetCoors).Magnitude2D();
|
|
if(Abs(ARRESTCAM_LAMP_BEST_DIST - Dist) < NearestDist){
|
|
CVector TestStart = Objects[i]->GetColModel()->boundingBox.max;
|
|
TestStart = Objects[i]->GetMatrix() * TestStart;
|
|
CVector TestEnd = TestStart - TargetCoors;
|
|
TestEnd.Normalise();
|
|
TestEnd += TargetCoors;
|
|
if(CWorld::GetIsLineOfSightClear(TestStart, TestEnd, true, false, false, false, false, true, true)){
|
|
NearestDist = Abs(ARRESTCAM_LAMP_BEST_DIST - Dist);
|
|
NearestLampPost = Objects[i];
|
|
SourceOut = TestStart;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NearestLampPost != nil;
|
|
}
|
|
|
|
bool
|
|
CCam::GetLookOverShoulderPos(CEntity *Target, CPed *Cop, CVector &TargetCoors, CVector &SourceOut)
|
|
{
|
|
if(Target == nil || Cop == nil)
|
|
return false;
|
|
CVector CopCoors = Cop->GetPosition();
|
|
CVector CopToTarget = TargetCoors - CopCoors;
|
|
CVector Side = CrossProduct(CopToTarget, CVector(0.0f, 0.0f, 1.0f));
|
|
Side.Normalise();
|
|
CopCoors += ARRESTDIST_RIGHTOF_COP * Side;
|
|
CopToTarget.Normalise();
|
|
if(CopToTarget.z < -0.7071f){
|
|
CopToTarget.z = -0.7071f;
|
|
float GroundDist = CopToTarget.Magnitude2D();
|
|
if(GroundDist > 0.0f){
|
|
CopToTarget.x *= 0.7071f/GroundDist;
|
|
CopToTarget.y *= 0.7071f/GroundDist;
|
|
}
|
|
CopToTarget.Normalise();
|
|
}else{
|
|
if(CopToTarget.z > 0.0f){
|
|
CopToTarget.z = 0.0f;
|
|
CopToTarget.Normalise();
|
|
}
|
|
}
|
|
CopCoors -= ARRESTDIST_BEHIND_COP * CopToTarget;
|
|
CopToTarget = TargetCoors - CopCoors;
|
|
float Dist = CopToTarget.Magnitude();
|
|
if(Dist < ARRESTDIST_MINFROM_PLAYER && Dist > 0.0f)
|
|
CopToTarget *= ARRESTDIST_MINFROM_PLAYER/Dist;
|
|
SourceOut = TargetCoors - CopToTarget;
|
|
return true;
|
|
}
|
|
|
|
enum {
|
|
ARRESTCAM_OVERSHOULDER = 1,
|
|
ARRESTCAM_ALONGGROUND,
|
|
ARRESTCAM_ALONGGROUND_RIGHT,
|
|
ARRESTCAM_ALONGGROUND_RIGHT_UP,
|
|
ARRESTCAM_ALONGGROUND_LEFT,
|
|
ARRESTCAM_ALONGGROUND_LEFT_UP,
|
|
ARRESTCAM_LAMPPOST,
|
|
};
|
|
|
|
int nUsingWhichCamera;
|
|
CPed *pStoredCopPed;
|
|
|
|
bool
|
|
CCam::ProcessArrestCamOne(void)
|
|
{
|
|
CVector TargetPos;
|
|
CVector CamSource;
|
|
CPed *cop = nil;
|
|
FOV = 45.0f;
|
|
bool foundPos = false;
|
|
int ArrestModes[5] = { -1, -1, -1, -1, -1 };
|
|
|
|
if(ResetStatics){
|
|
CPed *targetPed = (CPed*)TheCamera.pTargetEntity;
|
|
nUsingWhichCamera = 0;
|
|
if(TheCamera.pTargetEntity->IsPed()){
|
|
((CPed*)TheCamera.pTargetEntity)->m_pedIK.GetComponentPosition(TargetPos, PED_MID);
|
|
if(FindPlayerPed() && FindPlayerPed()->m_pArrestingCop)
|
|
cop = FindPlayerPed()->m_pArrestingCop;
|
|
if(cop && CGeneral::GetRandomNumberInRange(0.0f, 1.0f) > 0.5f){
|
|
ArrestModes[0] = ARRESTCAM_OVERSHOULDER;
|
|
ArrestModes[1] = ARRESTCAM_ALONGGROUND;
|
|
ArrestModes[2] = ARRESTCAM_OVERSHOULDER;
|
|
ArrestModes[3] = ARRESTCAM_LAMPPOST;
|
|
}else{
|
|
ArrestModes[0] = ARRESTCAM_ALONGGROUND;
|
|
ArrestModes[1] = ARRESTCAM_OVERSHOULDER;
|
|
ArrestModes[2] = ARRESTCAM_LAMPPOST;
|
|
}
|
|
}else if(TheCamera.pTargetEntity->IsVehicle()){
|
|
CVehicle *targetVehicle = (CVehicle*)TheCamera.pTargetEntity;
|
|
if(targetVehicle->pDriver && targetVehicle->pDriver->IsPlayer()){
|
|
targetPed = targetVehicle->pDriver;
|
|
targetPed->m_pedIK.GetComponentPosition(TargetPos, PED_MID);
|
|
}else{
|
|
targetPed = nil;
|
|
TargetPos = targetVehicle->GetPosition();
|
|
}
|
|
|
|
if(FindPlayerPed() && FindPlayerPed()->m_pArrestingCop)
|
|
cop = FindPlayerPed()->m_pArrestingCop;
|
|
if(cop && CGeneral::GetRandomNumberInRange(0.0f, 1.0f) > 0.65f){
|
|
ArrestModes[0] = ARRESTCAM_OVERSHOULDER;
|
|
ArrestModes[1] = ARRESTCAM_LAMPPOST;
|
|
ArrestModes[2] = ARRESTCAM_ALONGGROUND;
|
|
ArrestModes[3] = ARRESTCAM_OVERSHOULDER;
|
|
}else{
|
|
ArrestModes[0] = ARRESTCAM_LAMPPOST;
|
|
ArrestModes[1] = ARRESTCAM_ALONGGROUND;
|
|
ArrestModes[2] = ARRESTCAM_OVERSHOULDER;
|
|
}
|
|
}else
|
|
return false;
|
|
|
|
for(int i = 0; nUsingWhichCamera == 0 && i < ARRAY_SIZE(ArrestModes) && ArrestModes[i] > 0; i++){
|
|
switch(ArrestModes[i]){
|
|
case ARRESTCAM_OVERSHOULDER:
|
|
if(cop){
|
|
foundPos = GetLookOverShoulderPos(TheCamera.pTargetEntity, cop, TargetPos, CamSource);
|
|
pStoredCopPed = cop;
|
|
cop = nil;
|
|
}else if(targetPed){
|
|
for(int j = 0; j < targetPed->m_numNearPeds; j++){
|
|
CPed *nearPed = targetPed->m_nearPeds[j];
|
|
if(nearPed->GetPedState() == PED_ARREST_PLAYER)
|
|
foundPos = GetLookOverShoulderPos(TheCamera.pTargetEntity, nearPed, TargetPos, CamSource);
|
|
if(foundPos){
|
|
pStoredCopPed = nearPed;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ARRESTCAM_ALONGGROUND:
|
|
if(cop){
|
|
foundPos = GetLookAlongGroundPos(TheCamera.pTargetEntity, cop, TargetPos, CamSource);
|
|
pStoredCopPed = cop;
|
|
cop = nil;
|
|
}else if(targetPed){
|
|
for(int j = 0; j < targetPed->m_numNearPeds; j++){
|
|
CPed *nearPed = targetPed->m_nearPeds[j];
|
|
if(nearPed->GetPedState() == PED_ARREST_PLAYER)
|
|
foundPos = GetLookAlongGroundPos(TheCamera.pTargetEntity, nearPed, TargetPos, CamSource);
|
|
if(foundPos){
|
|
pStoredCopPed = nearPed;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ARRESTCAM_LAMPPOST:
|
|
foundPos = GetLookFromLampPostPos(TheCamera.pTargetEntity, cop, TargetPos, CamSource);
|
|
break;
|
|
}
|
|
|
|
if(foundPos){
|
|
if(pStoredCopPed)
|
|
pStoredCopPed->RegisterReference((CEntity**)&pStoredCopPed);
|
|
nUsingWhichCamera = ArrestModes[i];
|
|
if(ArrestModes[i] == ARRESTCAM_ALONGGROUND){
|
|
float rnd = CGeneral::GetRandomNumberInRange(0.0f, 5.0f);
|
|
if(rnd < 1.0f) nUsingWhichCamera = ARRESTCAM_ALONGGROUND;
|
|
else if(rnd < 2.0f) nUsingWhichCamera = ARRESTCAM_ALONGGROUND_RIGHT;
|
|
else if(rnd < 3.0f) nUsingWhichCamera = ARRESTCAM_ALONGGROUND_RIGHT_UP;
|
|
else if(rnd < 4.0f) nUsingWhichCamera = ARRESTCAM_ALONGGROUND_LEFT;
|
|
else nUsingWhichCamera = ARRESTCAM_ALONGGROUND_LEFT_UP;
|
|
}
|
|
}else
|
|
pStoredCopPed = nil;
|
|
}
|
|
|
|
Source = CamSource;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetPos, Source, FOV);
|
|
Front = TargetPos - Source;
|
|
Front.Normalise();
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
if(nUsingWhichCamera != 0)
|
|
ResetStatics = false;
|
|
return true;
|
|
}
|
|
|
|
if(TheCamera.pTargetEntity->IsPed()){
|
|
((CPed*)TheCamera.pTargetEntity)->m_pedIK.GetComponentPosition(TargetPos, PED_MID);
|
|
}else if(TheCamera.pTargetEntity->IsVehicle()){
|
|
CPed *driver = ((CVehicle*)TheCamera.pTargetEntity)->pDriver;
|
|
if(driver && driver->IsPlayer())
|
|
driver->m_pedIK.GetComponentPosition(TargetPos, PED_MID);
|
|
else
|
|
TargetPos = TheCamera.pTargetEntity->GetPosition();
|
|
}else
|
|
return false;
|
|
|
|
if(nUsingWhichCamera == ARRESTCAM_OVERSHOULDER && pStoredCopPed){
|
|
foundPos = GetLookOverShoulderPos(TheCamera.pTargetEntity, pStoredCopPed, TargetPos, CamSource);
|
|
float newZ = Source.z + ARRESTCAM_S_ROTATION_UP*CTimer::GetTimeStep();
|
|
if(CamSource.z > newZ)
|
|
CamSource.z = newZ;
|
|
}else if(nUsingWhichCamera >= ARRESTCAM_ALONGGROUND_RIGHT && nUsingWhichCamera <= ARRESTCAM_ALONGGROUND_LEFT_UP){
|
|
CamSource = Source;
|
|
Front = TargetPos - CamSource;
|
|
Front.Normalise();
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
CVector Right = CrossProduct(Front, Up);
|
|
if(nUsingWhichCamera == ARRESTCAM_ALONGGROUND_LEFT || nUsingWhichCamera == ARRESTCAM_ALONGGROUND_LEFT_UP)
|
|
Right *= -1.0f;
|
|
if(CWorld::TestSphereAgainstWorld(CamSource + 0.5f*Right, 0.4f, TheCamera.pTargetEntity, true, true, false, true, false, true) == nil){
|
|
foundPos = true;
|
|
CamSource += Right*ARRESTCAM_ROTATION_SPEED*CTimer::GetTimeStep();
|
|
if(nUsingWhichCamera == ARRESTCAM_ALONGGROUND_RIGHT_UP || nUsingWhichCamera == ARRESTCAM_ALONGGROUND_LEFT_UP){
|
|
CamSource.z += ARRESTCAM_ROTATION_UP*CTimer::GetTimeStep();
|
|
}else{
|
|
bool found = false;
|
|
float ground = CWorld::FindGroundZFor3DCoord(CamSource.x, CamSource.y, CamSource.z, &found);
|
|
if(found)
|
|
CamSource.z = ground + ARRESTDIST_ABOVE_GROUND;
|
|
}
|
|
}
|
|
}else if(nUsingWhichCamera == ARRESTCAM_LAMPPOST){
|
|
CamSource = Source;
|
|
Front = TargetPos - CamSource;
|
|
Front.z = 0.0f;
|
|
Front.Normalise();
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Front = TargetPos - CamSource + Right*ARRESTCAM_LAMPPOST_ROTATEDIST;
|
|
Front.z = 0.0f;
|
|
Front.Normalise();
|
|
if(CWorld::TestSphereAgainstWorld(CamSource + 0.5f*Front, 0.4f, TheCamera.pTargetEntity, true, true, false, true, false, true) == nil){
|
|
foundPos = true;
|
|
CamSource += Front*ARRESTCAM_LAMPPOST_TRANSLATE*CTimer::GetTimeStep();
|
|
}
|
|
}
|
|
|
|
if(foundPos){
|
|
Source = CamSource;
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetPos, Source, FOV);
|
|
Front = TargetPos - Source;
|
|
Front.Normalise();
|
|
Up = CVector(0.0f, 0.0f, 1.0f);
|
|
CVector Right = CrossProduct(Front, Up);
|
|
Right.Normalise();
|
|
Up = CrossProduct(Right, Front);
|
|
}else{
|
|
CVector OrigSource = Source;
|
|
TheCamera.AvoidTheGeometry(OrigSource, TargetPos, Source, FOV);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CCam::ProcessArrestCamTwo(void)
|
|
{
|
|
CPed *player = CWorld::Players[CWorld::PlayerInFocus].m_pPed;
|
|
if(!ResetStatics)
|
|
return true;
|
|
ResetStatics = false;
|
|
|
|
CVector TargetCoors, ToCamera;
|
|
float BetaOffset;
|
|
float SourceX, SourceY;
|
|
if(&TheCamera.Cams[TheCamera.ActiveCam] == this){
|
|
SourceX = TheCamera.Cams[(TheCamera.ActiveCam + 1) % 2].Source.x;
|
|
SourceY = TheCamera.Cams[(TheCamera.ActiveCam + 1) % 2].Source.y;
|
|
}else{
|
|
SourceX = TheCamera.Cams[TheCamera.ActiveCam].Source.x;
|
|
SourceY = TheCamera.Cams[TheCamera.ActiveCam].Source.y;
|
|
}
|
|
|
|
for(int i = 0; i <= 1; i++){
|
|
int Dir = i == 0 ? 1 : -1;
|
|
|
|
FOV = 60.0f;
|
|
TargetCoors = player->GetPosition();
|
|
Beta = CGeneral::GetATanOfXY(TargetCoors.x-SourceX, TargetCoors.y-SourceY);
|
|
BetaOffset = DEGTORAD(Dir*80);
|
|
Source = TargetCoors + 11.5f*CVector(Cos(Beta+BetaOffset), Sin(Beta+BetaOffset), 0.0f);
|
|
|
|
ToCamera = Source - TargetCoors;
|
|
ToCamera.Normalise();
|
|
TargetCoors.x += 0.4f*ToCamera.x;
|
|
TargetCoors.y += 0.4f*ToCamera.y;
|
|
if(CWorld::GetIsLineOfSightClear(Source, TargetCoors, true, true, false, true, false, true, true)){
|
|
Source.z += 5.5f;
|
|
TargetCoors += CVector(-0.8f*ToCamera.x, -0.8f*ToCamera.y, 2.2f);
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
Front = TargetCoors - Source;
|
|
ResetStatics = false;
|
|
GetVectorsReadyForRW();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
#ifdef FREE_CAM
|
|
void
|
|
CCam::Process_FollowPed_Rotation(const CVector &CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
FOV = DefaultFOV;
|
|
|
|
const float MinDist = 2.0f;
|
|
const float MaxDist = 2.0f + TheCamera.m_fPedZoomValueSmooth;
|
|
const float BaseOffset = 0.75f; // base height of camera above target
|
|
|
|
CVector TargetCoors = CameraTarget;
|
|
|
|
TargetCoors.z += m_fSyphonModeTargetZOffSet;
|
|
TargetCoors = DoAverageOnVector(TargetCoors);
|
|
TargetCoors.z += BaseOffset; // add offset so alpha evens out to 0
|
|
// TargetCoors.z += m_fRoadOffSet;
|
|
|
|
CVector Dist = Source - TargetCoors;
|
|
CVector ToCam;
|
|
|
|
bool Shooting = false;
|
|
if(((CPed*)CamTargetEntity)->GetWeapon()->m_eWeaponType != WEAPONTYPE_UNARMED)
|
|
if(CPad::GetPad(0)->GetWeapon())
|
|
Shooting = true;
|
|
if(((CPed*)CamTargetEntity)->GetWeapon()->m_eWeaponType == WEAPONTYPE_DETONATOR ||
|
|
((CPed*)CamTargetEntity)->GetWeapon()->m_eWeaponType == WEAPONTYPE_BASEBALLBAT)
|
|
Shooting = false;
|
|
|
|
|
|
if(ResetStatics){
|
|
// Coming out of top down here probably
|
|
// so keep Beta, reset alpha and calculate vectors
|
|
Beta = CGeneral::GetATanOfXY(Dist.x, Dist.y);
|
|
Alpha = 0.0f;
|
|
|
|
Dist = MaxDist*CVector(Cos(Alpha) * Cos(Beta), Cos(Alpha) * Sin(Beta), Sin(Alpha));
|
|
Source = TargetCoors + Dist;
|
|
|
|
ResetStatics = false;
|
|
}
|
|
|
|
// Drag the camera along at the look-down offset
|
|
float CamDist = Dist.Magnitude();
|
|
if(CamDist == 0.0f)
|
|
Dist = CVector(1.0f, 1.0f, 0.0f);
|
|
else if(CamDist < MinDist)
|
|
Dist *= MinDist/CamDist;
|
|
else if(CamDist > MaxDist)
|
|
Dist *= MaxDist/CamDist;
|
|
CamDist = Dist.Magnitude();
|
|
|
|
// Beta = 0 is looking east, HALFPI is north, &c.
|
|
// Alpha positive is looking up
|
|
float GroundDist = Dist.Magnitude2D();
|
|
Beta = CGeneral::GetATanOfXY(-Dist.x, -Dist.y);
|
|
Alpha = CGeneral::GetATanOfXY(GroundDist, -Dist.z);
|
|
while(Beta >= PI) Beta -= 2.0f*PI;
|
|
while(Beta < -PI) Beta += 2.0f*PI;
|
|
while(Alpha >= PI) Alpha -= 2.0f*PI;
|
|
while(Alpha < -PI) Alpha += 2.0f*PI;
|
|
|
|
// Look around
|
|
bool UseMouse = false;
|
|
float MouseX = CPad::GetPad(0)->GetMouseX();
|
|
float MouseY = CPad::GetPad(0)->GetMouseY();
|
|
float LookLeftRight, LookUpDown;
|
|
/*
|
|
if((MouseX != 0.0f || MouseY != 0.0f) && !CPad::GetPad(0)->ArePlayerControlsDisabled()){
|
|
UseMouse = true;
|
|
LookLeftRight = -2.5f*MouseX;
|
|
LookUpDown = 4.0f*MouseY;
|
|
}else
|
|
*/
|
|
{
|
|
LookLeftRight = -CPad::GetPad(0)->LookAroundLeftRight();
|
|
LookUpDown = CPad::GetPad(0)->LookAroundUpDown();
|
|
}
|
|
float AlphaOffset, BetaOffset;
|
|
if(UseMouse){
|
|
BetaOffset = LookLeftRight * TheCamera.m_fMouseAccelHorzntl * FOV/80.0f;
|
|
AlphaOffset = LookUpDown * TheCamera.m_fMouseAccelVertical * FOV/80.0f;
|
|
}else{
|
|
BetaOffset = LookLeftRight * fStickSens * (1.0f/20.0f) * FOV/80.0f * CTimer::GetTimeStep();
|
|
AlphaOffset = LookUpDown * fStickSens * (0.6f/20.0f) * FOV/80.0f * CTimer::GetTimeStep();
|
|
}
|
|
|
|
// Stop centering once stick has been touched
|
|
if(BetaOffset)
|
|
Rotating = false;
|
|
|
|
Beta += BetaOffset;
|
|
Alpha += AlphaOffset;
|
|
while(Beta >= PI) Beta -= 2.0f*PI;
|
|
while(Beta < -PI) Beta += 2.0f*PI;
|
|
if(Alpha > DEGTORAD(45.0f)) Alpha = DEGTORAD(45.0f);
|
|
else if(Alpha < -DEGTORAD(89.5f)) Alpha = -DEGTORAD(89.5f);
|
|
|
|
|
|
float BetaDiff = TargetOrientation+PI - Beta;
|
|
while(BetaDiff >= PI) BetaDiff -= 2.0f*PI;
|
|
while(BetaDiff < -PI) BetaDiff += 2.0f*PI;
|
|
float TargetAlpha = Alpha;
|
|
// 12deg to account for our little height offset. we're not working on the true alpha here
|
|
const float AlphaLimitUp = DEGTORAD(15.0f) + DEGTORAD(12.0f);
|
|
const float AlphaLimitDown = -DEGTORAD(15.0f) + DEGTORAD(12.0f);
|
|
if(Abs(BetaDiff) < DEGTORAD(25.0f) && ((CPed*)CamTargetEntity)->GetMoveSpeed().Magnitude2D() > 0.01f){
|
|
// Limit alpha when player is walking towards camera
|
|
if(TargetAlpha > AlphaLimitUp) TargetAlpha = AlphaLimitUp;
|
|
if(TargetAlpha < AlphaLimitDown) TargetAlpha = AlphaLimitDown;
|
|
}
|
|
|
|
WellBufferMe(TargetAlpha, &Alpha, &AlphaSpeed, 0.2f, 0.1f, true);
|
|
|
|
if(CPad::GetPad(0)->ForceCameraBehindPlayer() || Shooting){
|
|
m_fTargetBeta = TargetOrientation;
|
|
Rotating = true;
|
|
}
|
|
|
|
if(Rotating){
|
|
WellBufferMe(m_fTargetBeta, &Beta, &BetaSpeed, 0.1f, 0.06f, true);
|
|
float DeltaBeta = m_fTargetBeta - Beta;
|
|
while(DeltaBeta >= PI) DeltaBeta -= 2*PI;
|
|
while(DeltaBeta < -PI) DeltaBeta += 2*PI;
|
|
if(Abs(DeltaBeta) < 0.06f)
|
|
Rotating = false;
|
|
}
|
|
|
|
if(TheCamera.m_bUseTransitionBeta)
|
|
Beta = CGeneral::GetATanOfXY(-Cos(m_fTransitionBeta), -Sin(m_fTransitionBeta));
|
|
|
|
if(TheCamera.m_bUseTransitionBeta)
|
|
Beta = CGeneral::GetATanOfXY(-Cos(m_fTransitionBeta), -Sin(m_fTransitionBeta));
|
|
|
|
Front = CVector(Cos(Alpha) * Cos(Beta), Cos(Alpha) * Sin(Beta), Sin(Alpha));
|
|
Source = TargetCoors - Front*CamDist;
|
|
TargetCoors.z -= BaseOffset; // now get back to the real target coors again
|
|
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
|
|
|
|
Front = TargetCoors - Source;
|
|
Front.Normalise();
|
|
|
|
|
|
|
|
/*
|
|
* Handle collisions - taken from FollowPedWithMouse
|
|
*/
|
|
|
|
CEntity *entity;
|
|
CColPoint colPoint;
|
|
// Clip Source and fix near clip
|
|
CWorld::pIgnoreEntity = CamTargetEntity;
|
|
entity = nil;
|
|
if(CWorld::ProcessLineOfSight(TargetCoors, Source, colPoint, entity, true, true, true, true, false, false, true)){
|
|
float PedColDist = (TargetCoors - colPoint.point).Magnitude();
|
|
float ColCamDist = CamDist - PedColDist;
|
|
if(entity->IsPed() && ColCamDist > DEFAULT_NEAR + 0.1f){
|
|
// Ped in the way but not clipping through
|
|
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 < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}else{
|
|
RwCameraSetNearClipPlane(Scene.camera, Min(ColCamDist-0.35f, DEFAULT_NEAR));
|
|
}
|
|
}else{
|
|
Source = colPoint.point;
|
|
if(PedColDist < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}
|
|
}
|
|
CWorld::pIgnoreEntity = nil;
|
|
|
|
float ViewPlaneHeight = Tan(DEGTORAD(FOV) / 2.0f);
|
|
float ViewPlaneWidth = ViewPlaneHeight * CDraw::CalculateAspectRatio() * fTweakFOV;
|
|
float Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
float radius = ViewPlaneWidth*Near;
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, false);
|
|
int i = 0;
|
|
while(entity){
|
|
CVector CamToCol = gaTempSphereColPoints[0].point - Source;
|
|
float frontDist = DotProduct(CamToCol, Front);
|
|
float dist = (CamToCol - Front*frontDist).Magnitude() / ViewPlaneWidth;
|
|
|
|
// Try to decrease near clip
|
|
dist = Max(Min(Near, dist), 0.1f);
|
|
if(dist < Near)
|
|
RwCameraSetNearClipPlane(Scene.camera, dist);
|
|
|
|
// Move forward a bit
|
|
if(dist == 0.1f)
|
|
Source += (TargetCoors - Source)*0.3f;
|
|
|
|
// Keep testing
|
|
Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
radius = ViewPlaneWidth*Near;
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, false);
|
|
|
|
i++;
|
|
if(i > 5)
|
|
entity = nil;
|
|
}
|
|
|
|
GetVectorsReadyForRW();
|
|
}
|
|
|
|
// LCS cam hehe
|
|
void
|
|
CCam::Process_FollowCar_SA(const CVector& CameraTarget, float TargetOrientation, float, float)
|
|
{
|
|
// Missing things on III CCam
|
|
static CVector m_aTargetHistoryPosOne;
|
|
static CVector m_aTargetHistoryPosTwo;
|
|
static CVector m_aTargetHistoryPosThree;
|
|
static int m_nCurrentHistoryPoints = 0;
|
|
static float lastBeta = -9999.0f;
|
|
static float lastAlpha = -9999.0f;
|
|
static float stepsLeftToChangeBetaByMouse;
|
|
static float dontCollideWithCars;
|
|
static bool alphaCorrected;
|
|
static float heightIncreaseMult;
|
|
|
|
if (!CamTargetEntity->IsVehicle())
|
|
return;
|
|
|
|
CVehicle* car = (CVehicle*)CamTargetEntity;
|
|
CVector TargetCoors = CameraTarget;
|
|
uint8 camSetArrPos = 0;
|
|
|
|
// We may need those later
|
|
bool isPlane = car->GetVehicleAppearance() == VEHICLE_APPEARANCE_PLANE;
|
|
bool isHeli = car->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI;
|
|
bool isBike = car->GetVehicleAppearance() == VEHICLE_APPEARANCE_BIKE;
|
|
bool isCar = car->IsCar() && !isPlane && !isHeli && !isBike;
|
|
|
|
CPad* pad = CPad::GetPad(0);
|
|
|
|
// Next direction is non-existent in III
|
|
uint8 nextDirectionIsForward = !(pad->GetLookBehindForCar() || pad->GetLookBehindForPed() || pad->GetLookLeft() || pad->GetLookRight()) &&
|
|
DirectionWasLooking == LOOKING_FORWARD;
|
|
|
|
if (car->GetModelIndex() == MI_FIRETRUCK) {
|
|
camSetArrPos = 7;
|
|
} else if (car->GetModelIndex() == MI_RCBANDIT || car->GetModelIndex() == MI_RCBARON) {
|
|
camSetArrPos = 5;
|
|
} else if (car->GetModelIndex() == MI_RCGOBLIN || car->GetModelIndex() == MI_RCRAIDER) {
|
|
camSetArrPos = 6;
|
|
} else if (car->IsBoat()) {
|
|
camSetArrPos = 4;
|
|
} else if (isBike) {
|
|
camSetArrPos = 1;
|
|
} else if (isPlane) {
|
|
camSetArrPos = 3;
|
|
} else if (isHeli) {
|
|
camSetArrPos = 2;
|
|
}
|
|
|
|
// LCS one but index 1(firetruck) moved to last
|
|
float CARCAM_SET[][15] = {
|
|
{1.3f, 1.0f, 0.4f, 10.0f, 15.0f, 0.5f, 1.0f, 1.0f, 0.85f, 0.2f, 0.075f, 0.05f, 0.8f, DEGTORAD(45.0f), DEGTORAD(89.0f)}, // cars
|
|
{1.1f, 1.0f, 0.1f, 10.0f, 11.0f, 0.5f, 1.0f, 1.0f, 0.85f, 0.2f, 0.075f, 0.05f, 0.75f, DEGTORAD(45.0f), DEGTORAD(89.0f)}, // bike
|
|
{1.1f, 1.0f, 0.2f, 10.0f, 15.0f, 0.05f, 0.05f, 0.0f, 0.9f, 0.05f, 0.01f, 0.05f, 1.0f, DEGTORAD(10.0f), DEGTORAD(70.0f)}, // heli (SA values)
|
|
{1.1f, 3.5f, 0.2f, 10.0f, 25.0f, 0.5f, 1.0f, 1.0f, 0.75f, 0.1f, 0.005f, 0.2f, 1.0f, DEGTORAD(89.0f), DEGTORAD(89.0f)}, // plane (SA values)
|
|
{0.9f, 1.0f, 0.1f, 10.0f, 15.0f, 0.5f, 1.0f, 0.0f, 0.9f, 0.05f, 0.005f, 0.05f, 1.0f, -0.2f, DEGTORAD(70.0f)}, // boat
|
|
{1.1f, 1.0f, 0.2f, 10.0f, 5.0f, 0.5f, 1.0f, 1.0f, 0.75f, 0.1f, 0.005f, 0.2f, 1.0f, DEGTORAD(45.0f), DEGTORAD(89.0f)}, // rc cars
|
|
{1.1f, 1.0f, 0.2f, 10.0f, 5.0f, 0.5f, 1.0f, 1.0f, 0.75f, 0.1f, 0.005f, 0.2f, 1.0f, DEGTORAD(20.0f), DEGTORAD(70.0f)}, // rc heli/planes
|
|
{1.3f, 1.0f, 0.4f, 10.0f, 15.0f, 0.5f, 1.0f, 1.0f, 0.85f, 0.2f, 0.075f, 0.05f, 0.8f, -0.18f, DEGTORAD(40.0f)}, // firetruck...
|
|
};
|
|
|
|
// RC Heli/planes use same alpha values with heli/planes (LCS firetruck will fallback to 0)
|
|
uint8 alphaArrPos = (camSetArrPos > 4 ? (isPlane ? 3 : (isHeli ? 2 : 0)) : camSetArrPos);
|
|
float zoomModeAlphaOffset = 0.0f;
|
|
static float ZmOneAlphaOffsetLCS[] = { 0.12f, 0.08f, 0.15f, 0.08f, 0.08f };
|
|
static float ZmTwoAlphaOffsetLCS[] = { 0.1f, 0.08f, 0.3f, 0.08f, 0.08f };
|
|
static float ZmThreeAlphaOffsetLCS[] = { 0.065f, 0.05f, 0.15f, 0.06f, 0.08f };
|
|
|
|
if (isHeli && car->GetStatus() == STATUS_PLAYER_REMOTE)
|
|
zoomModeAlphaOffset = ZmTwoAlphaOffsetLCS[alphaArrPos];
|
|
else {
|
|
switch ((int)TheCamera.CarZoomIndicator) {
|
|
// near
|
|
case CAM_ZOOM_1:
|
|
zoomModeAlphaOffset = ZmOneAlphaOffsetLCS[alphaArrPos];
|
|
break;
|
|
// mid
|
|
case CAM_ZOOM_2:
|
|
zoomModeAlphaOffset = ZmTwoAlphaOffsetLCS[alphaArrPos];
|
|
break;
|
|
// far
|
|
case CAM_ZOOM_3:
|
|
zoomModeAlphaOffset = ZmThreeAlphaOffsetLCS[alphaArrPos];
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
CColModel* carCol = (CColModel*)car->GetColModel();
|
|
float colMaxZ = carCol->boundingBox.max.z; // As opposed to LCS and SA, VC does this: carCol->boundingBox.max.z - carCol->boundingBox.min.z;
|
|
float approxCarLength = 2.0f * Abs(carCol->boundingBox.min.y); // SA taxi min.y = -2.95, max.z = 0.883502f
|
|
|
|
float newDistance = TheCamera.CarZoomValueSmooth + CARCAM_SET[camSetArrPos][1] + approxCarLength;
|
|
|
|
// Taken from VC CCam::Cam_On_A_String_Unobscured. If we don't this, we will end up seeing the world from the inside of RC Goblin/Raider.
|
|
// I couldn't find where SA does that. It's possible that they've increased the size of these veh.'s collision bounding box.
|
|
|
|
if (car->m_modelIndex == MI_RCRAIDER || car->m_modelIndex == MI_RCGOBLIN)
|
|
newDistance += INIT_RC_HELI_HORI_EXTRA;
|
|
else if (car->m_modelIndex == MI_RCBARON)
|
|
newDistance += INIT_RC_PLANE_HORI_EXTRA;
|
|
|
|
float minDistForThisCar = approxCarLength * CARCAM_SET[camSetArrPos][3];
|
|
|
|
if (!isHeli || car->GetStatus() == STATUS_PLAYER_REMOTE) {
|
|
float radiusToStayOutside = colMaxZ * CARCAM_SET[camSetArrPos][0] - CARCAM_SET[camSetArrPos][2];
|
|
if (radiusToStayOutside > 0.0f) {
|
|
TargetCoors.z += radiusToStayOutside;
|
|
newDistance += radiusToStayOutside;
|
|
zoomModeAlphaOffset += 0.3f / newDistance * radiusToStayOutside;
|
|
}
|
|
} else {
|
|
// 0.6f = fTestShiftHeliCamTarget
|
|
TargetCoors += 0.6f * car->GetUp() * colMaxZ;
|
|
}
|
|
|
|
if (car->m_modelIndex == MI_RCGOBLIN)
|
|
zoomModeAlphaOffset += 0.178997f;
|
|
|
|
float minDistForVehType = CARCAM_SET[camSetArrPos][4];
|
|
|
|
if (TheCamera.CarZoomIndicator == CAM_ZOOM_1 && (camSetArrPos < 2 || camSetArrPos == 7)) {
|
|
minDistForVehType = minDistForVehType * 0.65f;
|
|
}
|
|
|
|
float nextDistance = Max(newDistance, minDistForVehType);
|
|
|
|
CA_MAX_DISTANCE = newDistance;
|
|
CA_MIN_DISTANCE = 3.5f;
|
|
|
|
if (ResetStatics) {
|
|
FOV = DefaultFOV;
|
|
} else {
|
|
if (isCar || isBike) {
|
|
// 0.4f: CAR_FOV_START_SPEED
|
|
if (DotProduct(car->GetForward(), car->m_vecMoveSpeed) > 0.4f)
|
|
FOV += (DotProduct(car->GetForward(), car->m_vecMoveSpeed) - 0.4f) * CTimer::GetTimeStep();
|
|
}
|
|
|
|
if (FOV > DefaultFOV)
|
|
// 0.98f: CAR_FOV_FADE_MULT
|
|
FOV = Pow(0.98f, CTimer::GetTimeStep()) * (FOV - DefaultFOV) + DefaultFOV;
|
|
|
|
FOV = clamp(FOV, DefaultFOV, DefaultFOV + 30.0f);
|
|
}
|
|
|
|
// WORKAROUND: I still don't know how looking behind works (m_bCamDirectlyInFront is unused in III, they seem to use m_bUseTransitionBeta)
|
|
if (pad->GetLookBehindForCar())
|
|
if (DirectionWasLooking == LOOKING_FORWARD || !LookingBehind)
|
|
TheCamera.m_bCamDirectlyInFront = true;
|
|
|
|
// Taken from RotCamIfInFrontCar, because we don't call it anymore
|
|
if (!(pad->GetLookBehindForCar() || pad->GetLookBehindForPed() || pad->GetLookLeft() || pad->GetLookRight()))
|
|
if (DirectionWasLooking != LOOKING_FORWARD)
|
|
TheCamera.m_bCamDirectlyBehind = true;
|
|
|
|
// Called when we just entered the car, just started to look behind or returned back from looking left, right or behind
|
|
if (ResetStatics || TheCamera.m_bCamDirectlyBehind || TheCamera.m_bCamDirectlyInFront) {
|
|
ResetStatics = false;
|
|
Rotating = false;
|
|
m_bCollisionChecksOn = true;
|
|
|
|
if (!TheCamera.m_bJustCameOutOfGarage) {
|
|
Alpha = 0.0f;
|
|
Beta = car->GetForward().Heading() - HALFPI;
|
|
if (TheCamera.m_bCamDirectlyInFront) {
|
|
Beta += PI;
|
|
}
|
|
}
|
|
|
|
BetaSpeed = 0.0;
|
|
AlphaSpeed = 0.0;
|
|
Distance = 1000.0;
|
|
|
|
Front.x = -(cos(Beta) * cos(Alpha));
|
|
Front.y = -(sin(Beta) * cos(Alpha));
|
|
Front.z = sin(Alpha);
|
|
|
|
m_aTargetHistoryPosOne = TargetCoors - nextDistance * Front;
|
|
|
|
m_aTargetHistoryPosTwo = TargetCoors - newDistance * Front;
|
|
|
|
m_nCurrentHistoryPoints = 0;
|
|
if (!TheCamera.m_bJustCameOutOfGarage)
|
|
Alpha = -zoomModeAlphaOffset;
|
|
}
|
|
|
|
Front = TargetCoors - m_aTargetHistoryPosOne;
|
|
Front.Normalise();
|
|
|
|
// Code that makes cam rotate around the car
|
|
float camRightHeading = Front.Heading() - HALFPI;
|
|
if (camRightHeading < -PI)
|
|
camRightHeading = camRightHeading + TWOPI;
|
|
|
|
float velocityRightHeading;
|
|
if (car->m_vecMoveSpeed.Magnitude2D() <= 0.02f)
|
|
velocityRightHeading = camRightHeading;
|
|
else
|
|
velocityRightHeading = car->m_vecMoveSpeed.Heading() - HALFPI;
|
|
|
|
if (velocityRightHeading < camRightHeading - PI)
|
|
velocityRightHeading = velocityRightHeading + TWOPI;
|
|
else if (velocityRightHeading > camRightHeading + PI)
|
|
velocityRightHeading = velocityRightHeading - TWOPI;
|
|
|
|
float betaChangeMult1 = CTimer::GetTimeStep() * CARCAM_SET[camSetArrPos][10];
|
|
float betaChangeLimit = CTimer::GetTimeStep() * CARCAM_SET[camSetArrPos][11];
|
|
|
|
float betaChangeMult2 = (car->m_vecMoveSpeed - DotProduct(car->m_vecMoveSpeed, Front) * Front).Magnitude();
|
|
|
|
float betaChange = Min(1.0f, betaChangeMult1 * betaChangeMult2) * (velocityRightHeading - camRightHeading);
|
|
if (betaChange <= betaChangeLimit) {
|
|
if (betaChange < -betaChangeLimit)
|
|
betaChange = -betaChangeLimit;
|
|
} else {
|
|
betaChange = betaChangeLimit;
|
|
}
|
|
float targetBeta = camRightHeading + betaChange;
|
|
|
|
if (targetBeta < Beta - HALFPI)
|
|
targetBeta += TWOPI;
|
|
else if (targetBeta > Beta + PI)
|
|
targetBeta -= TWOPI;
|
|
|
|
float carPosChange = (TargetCoors - m_aTargetHistoryPosTwo).Magnitude();
|
|
if (carPosChange < newDistance && newDistance > minDistForThisCar) {
|
|
newDistance = Max(minDistForThisCar, carPosChange);
|
|
}
|
|
float maxAlphaAllowed = CARCAM_SET[camSetArrPos][13];
|
|
|
|
// Originally this is to prevent camera enter into car while we're stopping, but what about moving???
|
|
// This is also original LCS and SA bug, or some attempt to fix lag. We'll never know
|
|
|
|
// if (car->m_vecMoveSpeed.MagnitudeSqr() < sq(0.2f))
|
|
if (car->GetModelIndex() != MI_FIRETRUCK)
|
|
if (!isBike || ((CBike*)car)->m_nWheelsOnGround > 3)
|
|
if (!isHeli && (!isPlane || ((CAutomobile*)car)->m_nWheelsOnGround)) {
|
|
|
|
CVector left = CrossProduct(car->GetForward(), CVector(0.0f, 0.0f, 1.0f));
|
|
left.Normalise();
|
|
CVector up = CrossProduct(left, car->GetForward());
|
|
up.Normalise();
|
|
float lookingUp = DotProduct(up, Front);
|
|
if (lookingUp > 0.0f) {
|
|
float v88 = Asin(Abs(Sin(Beta - (car->GetForward().Heading() - HALFPI))));
|
|
float v200;
|
|
if (v88 <= Atan2(carCol->boundingBox.max.x, -carCol->boundingBox.min.y)) {
|
|
v200 = (1.5f - carCol->boundingBox.min.y) / Cos(v88);
|
|
} else {
|
|
float a6g = 1.2f + carCol->boundingBox.max.x;
|
|
v200 = a6g / Cos(Max(0.0f, HALFPI - v88));
|
|
}
|
|
maxAlphaAllowed = Cos(Beta - (car->GetForward().Heading() - HALFPI)) * Atan2(car->GetForward().z, car->GetForward().Magnitude2D())
|
|
+ Atan2(TargetCoors.z - car->GetPosition().z + car->GetHeightAboveRoad(), v200 * 1.2f);
|
|
|
|
if (isCar && ((CAutomobile*)car)->m_nWheelsOnGround > 1 && Abs(DotProduct(car->m_vecTurnSpeed, car->GetForward())) < 0.05f) {
|
|
maxAlphaAllowed += Cos(Beta - (car->GetForward().Heading() - HALFPI) + HALFPI) * Atan2(car->GetRight().z, car->GetRight().Magnitude2D());
|
|
}
|
|
}
|
|
}
|
|
|
|
float targetAlpha = Asin(clamp(Front.z, -1.0f, 1.0f)) - zoomModeAlphaOffset;
|
|
if (targetAlpha <= maxAlphaAllowed) {
|
|
if (targetAlpha < -CARCAM_SET[camSetArrPos][14])
|
|
targetAlpha = -CARCAM_SET[camSetArrPos][14];
|
|
} else {
|
|
targetAlpha = maxAlphaAllowed;
|
|
}
|
|
float maxAlphaBlendAmount = CTimer::GetTimeStep() * CARCAM_SET[camSetArrPos][6];
|
|
float targetAlphaBlendAmount = (1.0f - Pow(CARCAM_SET[camSetArrPos][5], CTimer::GetTimeStep())) * (targetAlpha - Alpha);
|
|
if (targetAlphaBlendAmount <= maxAlphaBlendAmount) {
|
|
if (targetAlphaBlendAmount < -maxAlphaBlendAmount)
|
|
targetAlphaBlendAmount = -maxAlphaBlendAmount;
|
|
} else {
|
|
targetAlphaBlendAmount = maxAlphaBlendAmount;
|
|
}
|
|
|
|
// Using GetCarGun(LR/UD) will give us same unprocessed RightStick value as SA
|
|
float stickX = -(pad->GetCarGunLeftRight());
|
|
float stickY = -pad->GetCarGunUpDown();
|
|
|
|
// In SA this checks for m_bUseMouse3rdPerson so num2 / num8 do not move camera
|
|
// when Keyboard & Mouse controls are used. To make it work better with III/VC, check for actual pad state instead
|
|
if (!CPad::IsAffectedByController && !isCar)
|
|
stickY = 0.0f;
|
|
else if (CPad::bInvertLook4Pad)
|
|
stickY = -stickY;
|
|
|
|
float xMovement = Abs(stickX) * (FOV / 80.0f * 5.f / 70.f) * stickX * 0.007f * 0.007f;
|
|
float yMovement = Abs(stickY) * (FOV / 80.0f * 3.f / 70.f) * stickY * 0.007f * 0.007f;
|
|
|
|
bool correctAlpha = true;
|
|
// if (SA checks if we aren't in work car, why?) {
|
|
if (!isCar || car->GetModelIndex() != MI_VOODOO) {
|
|
correctAlpha = false;
|
|
}
|
|
else {
|
|
xMovement = 0.0f;
|
|
yMovement = 0.0f;
|
|
}
|
|
// } else
|
|
// yMovement = 0.0;
|
|
|
|
if (!nextDirectionIsForward) {
|
|
yMovement = 0.0f;
|
|
xMovement = 0.0f;
|
|
}
|
|
|
|
if (camSetArrPos == 0 || camSetArrPos == 7) {
|
|
// This is not working on cars as SA
|
|
// Because III/VC doesn't have any buttons tied to LeftStick if you're not in Classic Configuration, using Dodo or using GInput/Pad, so :shrug:
|
|
if (Abs(pad->GetSteeringUpDown()) > 120.0f) {
|
|
if (car->pDriver && car->pDriver->m_objective != OBJECTIVE_LEAVE_CAR) {
|
|
yMovement += Abs(pad->GetSteeringUpDown()) * (FOV / 80.0f * 3.f / 70.f) * pad->GetSteeringUpDown() * 0.007f * 0.007f * 0.5;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (yMovement > 0.0)
|
|
yMovement = yMovement * 0.5;
|
|
|
|
bool mouseChangesBeta = false;
|
|
|
|
// FIX: Disable mouse movement in drive-by, it's buggy. Original SA bug.
|
|
if (/*bFreeMouseCam &&*/ CCamera::m_bUseMouse3rdPerson && !pad->ArePlayerControlsDisabled() && nextDirectionIsForward) {
|
|
float mouseY = pad->GetMouseY() * 2.0f;
|
|
float mouseX = pad->GetMouseX() * -2.0f;
|
|
|
|
// If you want an ability to toggle free cam while steering with mouse, you can add an OR after DisableMouseSteering.
|
|
// There was a pad->NewState.m_bVehicleMouseLook in SA, which doesn't exists in III.
|
|
|
|
if ((mouseX != 0.0 || mouseY != 0.0) && (CVehicle::m_bDisableMouseSteering)) {
|
|
yMovement = mouseY * FOV / 80.0f * TheCamera.m_fMouseAccelHorzntl; // Same as SA, horizontal sensitivity.
|
|
BetaSpeed = 0.0;
|
|
AlphaSpeed = 0.0;
|
|
xMovement = mouseX * FOV / 80.0f * TheCamera.m_fMouseAccelHorzntl;
|
|
targetAlpha = Alpha;
|
|
stepsLeftToChangeBetaByMouse = 1.0f * 50.0f;
|
|
mouseChangesBeta = true;
|
|
} else if (stepsLeftToChangeBetaByMouse > 0.0f) {
|
|
// Finish rotation by decreasing speed when we stopped moving mouse
|
|
BetaSpeed = 0.0;
|
|
AlphaSpeed = 0.0;
|
|
yMovement = 0.0;
|
|
xMovement = 0.0;
|
|
targetAlpha = Alpha;
|
|
stepsLeftToChangeBetaByMouse = Max(0.0f, stepsLeftToChangeBetaByMouse - CTimer::GetTimeStep());
|
|
mouseChangesBeta = true;
|
|
}
|
|
}
|
|
|
|
if (correctAlpha) {
|
|
if (nPreviousMode != MODE_CAM_ON_A_STRING)
|
|
alphaCorrected = false;
|
|
|
|
if (!alphaCorrected && Abs(zoomModeAlphaOffset + Alpha) > 0.05f) {
|
|
yMovement = (-zoomModeAlphaOffset - Alpha) * 0.05f;
|
|
} else
|
|
alphaCorrected = true;
|
|
}
|
|
float alphaSpeedFromStickY = yMovement * CARCAM_SET[camSetArrPos][12];
|
|
float betaSpeedFromStickX = xMovement * CARCAM_SET[camSetArrPos][12];
|
|
|
|
float newAngleSpeedMaxBlendAmount = CARCAM_SET[camSetArrPos][9];
|
|
float angleChangeStep = Pow(CARCAM_SET[camSetArrPos][8], CTimer::GetTimeStep());
|
|
float targetBetaWithStickBlendAmount = betaSpeedFromStickX + (targetBeta - Beta) / Max(CTimer::GetTimeStep(), 1.0f);
|
|
|
|
if (targetBetaWithStickBlendAmount < -newAngleSpeedMaxBlendAmount)
|
|
targetBetaWithStickBlendAmount = -newAngleSpeedMaxBlendAmount;
|
|
else if (targetBetaWithStickBlendAmount > newAngleSpeedMaxBlendAmount)
|
|
targetBetaWithStickBlendAmount = newAngleSpeedMaxBlendAmount;
|
|
|
|
float angleChangeStepLeft = 1.0f - angleChangeStep;
|
|
BetaSpeed = targetBetaWithStickBlendAmount * angleChangeStepLeft + angleChangeStep * BetaSpeed;
|
|
if (Abs(BetaSpeed) < 0.0001f)
|
|
BetaSpeed = 0.0f;
|
|
|
|
float betaChangePerFrame;
|
|
if (mouseChangesBeta)
|
|
betaChangePerFrame = betaSpeedFromStickX;
|
|
else
|
|
betaChangePerFrame = CTimer::GetTimeStep() * BetaSpeed;
|
|
Beta = betaChangePerFrame + Beta;
|
|
|
|
if (TheCamera.m_bJustCameOutOfGarage) {
|
|
float invHeading = Atan2(Front.y, Front.x);
|
|
if (invHeading < 0.0f)
|
|
invHeading += TWOPI;
|
|
|
|
Beta = invHeading + PI;
|
|
}
|
|
|
|
Beta = CGeneral::LimitRadianAngle(Beta);
|
|
if (Beta < 0.0f)
|
|
Beta += TWOPI;
|
|
|
|
if ((camSetArrPos <= 1 || camSetArrPos == 7) && targetAlpha < Alpha && carPosChange >= newDistance) {
|
|
if (isCar && ((CAutomobile*)car)->m_nWheelsOnGround > 1 ||
|
|
isBike && ((CBike*)car)->m_nWheelsOnGround > 1)
|
|
alphaSpeedFromStickY += (targetAlpha - Alpha) * 0.075f;
|
|
}
|
|
|
|
AlphaSpeed = angleChangeStepLeft * alphaSpeedFromStickY + angleChangeStep * AlphaSpeed;
|
|
float maxAlphaSpeed = newAngleSpeedMaxBlendAmount;
|
|
if (alphaSpeedFromStickY > 0.0f)
|
|
maxAlphaSpeed = maxAlphaSpeed * 0.5;
|
|
|
|
if (AlphaSpeed <= maxAlphaSpeed) {
|
|
float minAlphaSpeed = -maxAlphaSpeed;
|
|
if (AlphaSpeed < minAlphaSpeed)
|
|
AlphaSpeed = minAlphaSpeed;
|
|
} else {
|
|
AlphaSpeed = maxAlphaSpeed;
|
|
}
|
|
|
|
if (Abs(AlphaSpeed) < 0.0001f)
|
|
AlphaSpeed = 0.0f;
|
|
|
|
float alphaWithSpeedAccounted;
|
|
if (mouseChangesBeta) {
|
|
alphaWithSpeedAccounted = alphaSpeedFromStickY + targetAlpha;
|
|
Alpha += alphaSpeedFromStickY;
|
|
} else {
|
|
alphaWithSpeedAccounted = CTimer::GetTimeStep() * AlphaSpeed + targetAlpha;
|
|
Alpha += targetAlphaBlendAmount;
|
|
}
|
|
|
|
if (Alpha <= maxAlphaAllowed) {
|
|
float minAlphaAllowed = -CARCAM_SET[camSetArrPos][14];
|
|
if (minAlphaAllowed > Alpha) {
|
|
Alpha = minAlphaAllowed;
|
|
AlphaSpeed = 0.0f;
|
|
}
|
|
} else {
|
|
Alpha = maxAlphaAllowed;
|
|
AlphaSpeed = 0.0f;
|
|
}
|
|
|
|
// Prevent unsignificant angle changes
|
|
if (Abs(lastAlpha - Alpha) < 0.0001f)
|
|
Alpha = lastAlpha;
|
|
|
|
lastAlpha = Alpha;
|
|
|
|
if (Abs(lastBeta - Beta) < 0.0001f)
|
|
Beta = lastBeta;
|
|
|
|
lastBeta = Beta;
|
|
|
|
Front.x = -(cos(Beta) * cos(Alpha));
|
|
Front.y = -(sin(Beta) * cos(Alpha));
|
|
Front.z = sin(Alpha);
|
|
GetVectorsReadyForRW();
|
|
TheCamera.m_bCamDirectlyBehind = false;
|
|
TheCamera.m_bCamDirectlyInFront = false;
|
|
|
|
Source = TargetCoors - newDistance * Front;
|
|
|
|
m_cvecTargetCoorsForFudgeInter = TargetCoors;
|
|
m_aTargetHistoryPosThree = m_aTargetHistoryPosOne;
|
|
float nextAlpha = alphaWithSpeedAccounted + zoomModeAlphaOffset;
|
|
float nextFrontX = -(cos(Beta) * cos(nextAlpha));
|
|
float nextFrontY = -(sin(Beta) * cos(nextAlpha));
|
|
float nextFrontZ = sin(nextAlpha);
|
|
|
|
m_aTargetHistoryPosOne.x = TargetCoors.x - nextFrontX * nextDistance;
|
|
m_aTargetHistoryPosOne.y = TargetCoors.y - nextFrontY * nextDistance;
|
|
m_aTargetHistoryPosOne.z = TargetCoors.z - nextFrontZ * nextDistance;
|
|
|
|
m_aTargetHistoryPosTwo.x = TargetCoors.x - nextFrontX * newDistance;
|
|
m_aTargetHistoryPosTwo.y = TargetCoors.y - nextFrontY * newDistance;
|
|
m_aTargetHistoryPosTwo.z = TargetCoors.z - nextFrontZ * newDistance;
|
|
|
|
// SA calls SetColVarsVehicle in here
|
|
if (nextDirectionIsForward) {
|
|
|
|
// LCS uses exactly the same collision code as FollowPedWithMouse, so we will do so.
|
|
|
|
// This is only in LCS!
|
|
float timestepFactor = Pow(0.99f, CTimer::GetTimeStep());
|
|
dontCollideWithCars = (timestepFactor * dontCollideWithCars) + ((1.0f - timestepFactor) * car->m_vecMoveSpeed.Magnitude());
|
|
|
|
// Our addition
|
|
#define IS_TRAFFIC_LIGHT(ent) (ent->IsObject() && IsLightObject(ent->GetModelIndex()))
|
|
|
|
// Clip Source and fix near clip
|
|
CColPoint colPoint;
|
|
CEntity* entity;
|
|
CWorld::pIgnoreEntity = CamTargetEntity;
|
|
if(CWorld::ProcessLineOfSight(TargetCoors, Source, colPoint, entity, true, dontCollideWithCars < 0.1f, false, true, false, true, true) && !IS_TRAFFIC_LIGHT(entity)){
|
|
float PedColDist = (TargetCoors - colPoint.point).Magnitude();
|
|
float ColCamDist = newDistance - PedColDist;
|
|
if(entity->IsPed() && ColCamDist > DEFAULT_NEAR + 0.1f){
|
|
// Ped in the way but not clipping through
|
|
if(CWorld::ProcessLineOfSight(colPoint.point, Source, colPoint, entity, true, dontCollideWithCars < 0.1f, false, true, false, true, true) || IS_TRAFFIC_LIGHT(entity)){
|
|
PedColDist = (TargetCoors - colPoint.point).Magnitude();
|
|
Source = colPoint.point;
|
|
if(PedColDist < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}else{
|
|
RwCameraSetNearClipPlane(Scene.camera, Min(ColCamDist-0.35f, DEFAULT_NEAR));
|
|
}
|
|
}else{
|
|
Source = colPoint.point;
|
|
if(PedColDist < DEFAULT_NEAR + 0.3f)
|
|
RwCameraSetNearClipPlane(Scene.camera, Max(PedColDist-0.3f, 0.05f));
|
|
}
|
|
}
|
|
|
|
CWorld::pIgnoreEntity = nil;
|
|
|
|
// If we're seeing blue hell due to camera intersects some surface, fix it.
|
|
// SA and LCS have this unrolled.
|
|
|
|
float ViewPlaneHeight = Tan(DEGTORAD(FOV) / 2.0f);
|
|
float ViewPlaneWidth = ViewPlaneHeight * CDraw::CalculateAspectRatio() * fTweakFOV;
|
|
float Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
float radius = ViewPlaneWidth*Near;
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, true);
|
|
int i = 0;
|
|
while(entity){
|
|
|
|
if (IS_TRAFFIC_LIGHT(entity))
|
|
break;
|
|
|
|
CVector CamToCol = gaTempSphereColPoints[0].point - Source;
|
|
float frontDist = DotProduct(CamToCol, Front);
|
|
float dist = (CamToCol - Front*frontDist).Magnitude() / ViewPlaneWidth;
|
|
|
|
// Try to decrease near clip
|
|
dist = Max(Min(Near, dist), 0.1f);
|
|
if(dist < Near)
|
|
RwCameraSetNearClipPlane(Scene.camera, dist);
|
|
|
|
// Move forward a bit
|
|
if(dist == 0.1f)
|
|
Source += (TargetCoors - Source)*0.3f;
|
|
|
|
// Keep testing
|
|
Near = RwCameraGetNearClipPlane(Scene.camera);
|
|
radius = ViewPlaneWidth*Near;
|
|
entity = CWorld::TestSphereAgainstWorld(Source + Front*Near, radius, nil, true, true, false, true, false, true);
|
|
|
|
i++;
|
|
if(i > 5)
|
|
entity = nil;
|
|
}
|
|
#undef IS_TRAFFIC_LIGHT
|
|
}
|
|
TheCamera.m_bCamDirectlyBehind = false;
|
|
TheCamera.m_bCamDirectlyInFront = false;
|
|
|
|
// ------- LCS specific part starts
|
|
|
|
if (camSetArrPos == 5 && Source.z < 1.0f) // RC Bandit and Baron
|
|
Source.z = 1.0f;
|
|
|
|
// CCam::FixSourceAboveWaterLevel
|
|
if (CameraTarget.z >= -2.0f) {
|
|
float level = -6000.0;
|
|
|
|
if (CWaterLevel::GetWaterLevelNoWaves(Source.x, Source.y, Source.z, &level)) {
|
|
if (Source.z < level)
|
|
Source.z = level;
|
|
}
|
|
}
|
|
Front = TargetCoors - Source;
|
|
|
|
// -------- LCS specific part ends
|
|
|
|
GetVectorsReadyForRW();
|
|
// SA
|
|
// gTargetCoordsForLookingBehind = TargetCoors;
|
|
|
|
// SA code from CAutomobile::TankControl/FireTruckControl.
|
|
if (car->GetModelIndex() == MI_RHINO || car->GetModelIndex() == MI_FIRETRUCK) {
|
|
|
|
float &carGunLR = ((CAutomobile*)car)->m_fCarGunLR;
|
|
CVector hi = Multiply3x3(Front, car->GetMatrix());
|
|
|
|
// III/VC's firetruck turret angle is reversed
|
|
float angleToFace = (car->GetModelIndex() == MI_FIRETRUCK ? -hi.Heading() : hi.Heading());
|
|
|
|
if (angleToFace <= carGunLR + PI) {
|
|
if (angleToFace < carGunLR - PI)
|
|
angleToFace = angleToFace + TWOPI;
|
|
} else {
|
|
angleToFace = angleToFace - TWOPI;
|
|
}
|
|
|
|
float neededTurn = angleToFace - carGunLR;
|
|
float turnPerFrame = CTimer::GetTimeStep() * (car->GetModelIndex() == MI_FIRETRUCK ? 0.05f : 0.015f);
|
|
if (neededTurn <= turnPerFrame) {
|
|
if (neededTurn < -turnPerFrame)
|
|
angleToFace = carGunLR - turnPerFrame;
|
|
} else {
|
|
angleToFace = turnPerFrame + carGunLR;
|
|
}
|
|
|
|
if (car->GetModelIndex() == MI_RHINO && carGunLR != angleToFace) {
|
|
DMAudio.PlayOneShot(car->m_audioEntityId, SOUND_CAR_TANK_TURRET_ROTATE, Abs(angleToFace - carGunLR));
|
|
}
|
|
carGunLR = angleToFace;
|
|
|
|
if (carGunLR < -PI) {
|
|
carGunLR += TWOPI;
|
|
} else if (carGunLR > PI) {
|
|
carGunLR -= TWOPI;
|
|
}
|
|
|
|
// Because firetruk turret also has Y movement
|
|
if (car->GetModelIndex() == MI_FIRETRUCK) {
|
|
float &carGunUD = ((CAutomobile*)car)->m_fCarGunUD;
|
|
|
|
float alphaToFace = Atan2(hi.z, hi.Magnitude2D()) + DEGTORAD(15.0f);
|
|
float neededAlphaTurn = alphaToFace - carGunUD;
|
|
float alphaTurnPerFrame = CTimer::GetTimeStep() * 0.02f;
|
|
|
|
if (neededAlphaTurn > alphaTurnPerFrame) {
|
|
neededTurn = alphaTurnPerFrame;
|
|
carGunUD = neededTurn + carGunUD;
|
|
} else {
|
|
if (neededAlphaTurn >= -alphaTurnPerFrame) {
|
|
carGunUD = alphaToFace;
|
|
} else {
|
|
carGunUD = carGunUD - alphaTurnPerFrame;
|
|
}
|
|
}
|
|
|
|
float turretMinY = -DEGTORAD(20.0f);
|
|
float turretMaxY = DEGTORAD(20.0f);
|
|
if (turretMinY <= carGunUD) {
|
|
if (carGunUD > turretMaxY)
|
|
carGunUD = turretMaxY;
|
|
} else {
|
|
carGunUD = turretMinY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|