dayzplayercamera_base.c

Go to the documentation of this file.

float Limit(float pV, float pMin, float pMax)
{
 if (pV >= pMin && pV <= pMax)
 {
 return pV;
 }
 else if (pV < pMin)
 {
 return pMin;
 }
 else
 {
 return pMax;
 } 
}
 
 
float fixAngle_PI_PI(float pAngle)
{
 while (pAngle > Math.PI)
 {
 
 pAngle -= Math.PI2;
 }
 
 while (pAngle < -Math.PI)
 {
 
 pAngle += Math.PI2;
 }
 
 return pAngle;
}
 
float fixAngle_180_180(float pAngle)
{
 while (pAngle > 180)
 {
 
 pAngle -= 360;
 }
 
 while (pAngle < -180)
 {
 
 pAngle += 360;
 }
 
 return pAngle;
}
 
 
enum NVTypes
{
 NONE = 0,
 NV_GOGGLES,
 NV_GOGGLES_OFF,
 NV_OPTICS_ON,
 NV_OPTICS_OFF,
 NV_PUMPKIN,
 NV_OPTICS_KAZUAR_DAY,
 NV_OPTICS_KAZUAR_NIGHT,
 NV_OPTICS_STARLIGHT_DAY,
 NV_OPTICS_STARLIGHT_NIGHT,
 MAX
}
 
class DayZPlayerCameraBase extends DayZPlayerCamera
{
 static const float CONST_NEARPLANE_OPTICS_MIN = 0.04; //Minimal safe near plane value, artifacts on the far plane otherwise!
 
 protected Weapon_Base m_weaponUsed;
 protected ItemOptics m_opticsUsed;
 protected ref CameraShake m_CameraShake;
 
 void DayZPlayerCameraBase(DayZPlayer pPlayer, HumanInputController pInput)
 {
 m_fLRAngleVel[0] = 0;
 m_fUDAngleVel[0] = 0;
 m_fFovAbsVel[0] = 0;
 m_WeaponSwayModifier = 1;
 
 m_fFovAbsolute = GetDayZGame().GetFOVByZoomType(m_pPlayer.GetEyeZoomLevel());
 /*
 {
 int perItemCamUD = pPlayer.GetCurrentPerItemCameraUD();
 string a = "Per Item Camera User Data: " + perItemCamUD.ToString();
 Print(a);
 }
 */
 m_CameraPPDelay = 0;
 
 m_CommandWeapons = pPlayer.GetCommandModifier_Weapons();
 Init();
 HandleShoulderCameraOverride(pInput);
 };
 
 //disabled by default, overrides on select 3rd person cameras
 void HandleShoulderCameraOverride(HumanInputController pInput)
 {
 m_pInput.Override3rdIsRightShoulder(HumanInputControllerOverrideType.DISABLED, false);
 }
 
 void ProcessCameraShake(float delta, out float leftRight, out float upDown)
 {
 if (m_CameraShake)
 {
 float x,y;
 m_CameraShake.Update(delta, x, y);
 leftRight += x;
 upDown += y;
 }
 }
 
 void Init()
 {
 PlayerBase player = PlayerBase.Cast(m_pPlayer);
 if ( player && player.IsNVGWorking() != IsCameraNV() )
 {
 SetCameraNV(player.IsNVGWorking());
 SetCameraNVType(player.GetNVType());
 }
 }
 
 float UpdateUDAngleUnlocked(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
 {
 float target = m_CommandWeapons.GetBaseAimingAngleUD();
 
 if (m_pInput.CameraIsTracking()) 
 {
 pAngleAdd = m_pInput.GetTracking()[1] * Math.RAD2DEG;
 pAngle = target;
 
 m_fUDAngleVel[0] = 0;
 }
 else
 {
 if (Math.AbsFloat(pAngleAdd) > 0.001)
 {
 pAngleAdd = pAngle + pAngleAdd - target;
 pAngle = target;
 }
 
 if (m_pInput.CameraIsFreeLook()) 
 {
 pAngleAdd += m_pInput.GetAimDelta(pDt)[1] * Math.RAD2DEG;
 
 m_fUDAngleVel[0] = 0;
 }
 else
 {
 pAngleAdd = Math.SmoothCD(pAngleAdd, 0.0, m_fUDAngleVel, 0.14, 1000, pDt);
 }
 
 if (!m_pInput.CameraIsFreeLook())
 {
 pAngle += m_pInput.GetAimDelta(pDt)[1] * Math.RAD2DEG;
 }
 }
 
 pAngle = Limit(pAngle, pMin, pMax);
 pAngleAdd = Limit(pAngle + pAngleAdd, pMin, pMax) - pAngle;
 return pAngle + pAngleAdd;
 }
 
 float UpdateLRAngleUnlocked(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
 {
 float target = 0;
 
 if (m_pInput.CameraIsTracking()) 
 {
 pAngleAdd = m_pInput.GetTracking()[0] * Math.RAD2DEG;
 pAngle = target;
 
 m_fUDAngleVel[0] = 0;
 }
 else
 {
 if (Math.AbsFloat(pAngleAdd) > 0.001)
 {
 pAngleAdd = pAngle + pAngleAdd - target;
 pAngle = target;
 }
 
 if (m_pInput.CameraIsFreeLook() || m_bForceFreeLook) 
 {
 pAngleAdd += m_pInput.GetAimDelta(pDt)[0] * Math.RAD2DEG;
 
 m_fLRAngleVel[0] = 0;
 }
 else
 {
 pAngleAdd = Math.SmoothCD(pAngleAdd, 0.0, m_fLRAngleVel, 0.14, 1000, pDt);
 }
 
 pAngleAdd = pAngleAdd + pAngle;
 }
 
 pAngle = Limit(pAngle, pMin, pMax);
 pAngleAdd = Limit(pAngle + pAngleAdd, pMin, pMax) - pAngle;
 
 return pAngle + pAngleAdd;
 }
 
 float UpdateUDAngle(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
 {
 if (Math.AbsFloat(pAngleAdd) > 0.001)
 {
 float aimingUDAngle = m_CommandWeapons.GetBaseAimingAngleUD();
 
 
 // override actual angle
 pAngleAdd = pAngle + pAngleAdd - aimingUDAngle;
 pAngle = aimingUDAngle;
 
 // Print("Angle: " + pAngle.ToString() + " Aim: " + actualUDAngle.ToString() );
 }
 
 if( m_pInput.CameraIsFreeLook() ) 
 {
 pAngleAdd += m_pInput.GetAimChange()[1] * Math.RAD2DEG;
 pAngleAdd = Limit(pAngleAdd, pMin, pMax);
 
 m_fUDAngleVel[0] = 0;
 }
 else
 {
 if( m_pInput.CameraIsTracking() )
 {
 pAngleAdd = m_pInput.GetTracking()[1] * Math.RAD2DEG;
 pAngleAdd = Limit(pAngleAdd, pMin, pMax);
 
 m_fUDAngleVel[0] = 0;
 }
 else
 { 
 pAngle += m_pInput.GetAimChange()[1] * Math.RAD2DEG;
 pAngle = Limit(pAngle, pMin, pMax);
 
 pAngleAdd = Math.SmoothCD(pAngleAdd, 0, m_fUDAngleVel, 0.14, 1000, pDt);
 }
 }
 
 /*{
 float change = m_pInput.GetAimChange()[1] * Math.RAD2DEG;
 
 Print ("Script: Camera ud angle: " + pAngle.ToString() + " change: " + change.ToString() );
 }*/ 
 
 return Limit(pAngle + pAngleAdd, pMin, pMax);
 }
 
 float UpdateLRAngle(float pAngle, float pMin, float pMax, float pDt)
 {
 if (m_pInput.CameraIsFreeLook() || m_bForceFreeLook) 
 {
 pAngle += m_pInput.GetAimChange()[0] * Math.RAD2DEG;
 pAngle = Limit(pAngle, pMin, pMax);
 
 m_fLRAngleVel[0] = 0; // reset filter
 
 }
 else
 {
 if( m_pInput.CameraIsTracking() )
 {
 pAngle = m_pInput.GetTracking()[0] * Math.RAD2DEG;
 pAngle = Limit(-pAngle, pMin, pMax);
 
 m_fLRAngleVel[0] = 0; // reset filter
 }
 else
 { 
 // smooth value back to 0 
 pAngle = Math.SmoothCD(pAngle, 0, m_fLRAngleVel, 0.14, 1000, pDt);
 // m_fLeftRightAngle = 0.9 * (1.0 - pDt); 
 }
 }
 
 return pAngle;
 }
 
 
 
 void StdFovUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
 {
 switch (m_pPlayer.GetEyeZoomLevel())
 {
 // ordered in likelihood of occurance for perf. reasons
 case ECameraZoomType.NONE:
 m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GetDayZGame().GetFOVByZoomType(ECameraZoomType.NONE), m_fFovAbsVel, 0.1, 1000, pDt);
 break;
 case ECameraZoomType.NORMAL:
 m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GetDayZGame().GetFOVByZoomType(ECameraZoomType.NORMAL), m_fFovAbsVel, 0.1, 1000, pDt);
 break;
 case ECameraZoomType.SHALLOW:
 m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GetDayZGame().GetFOVByZoomType(ECameraZoomType.SHALLOW), m_fFovAbsVel, 0.1, 1000, pDt);
 break;
 default:
 m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GetDayZGame().GetFOVByZoomType(ECameraZoomType.NONE), m_fFovAbsVel, 0.1, 1000, pDt);
 break;
 }
 
 pOutResult.m_fFovAbsolute = m_fFovAbsolute;
 
 if (!m_pPlayer.IsShootingFromCamera())
 {
 pOutResult.m_fShootFromCamera = 0.0;
 }
 }
 
 override void SpawnCameraShakeProper(float strength, float radius, float smoothness, float radius_decay_speed)
 {
 m_CameraShake = new CameraShake(strength, radius, smoothness, radius_decay_speed);
 } 
 
 override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
 {
 if (!m_pPlayer || !PlayerBase.Cast(m_pPlayer))
 {
 Debug.Log("DayZPlayerCameraBase | OnUpdate | no player!");
 return;
 }
 
 if (PlayerBase.Cast(m_pPlayer).GetCurrentCamera() != this)
 {
 //Print("DayZPlayerCameraBase | OnUpdate | unused camera! | " + this + "/" + PlayerBase.Cast(m_pPlayer).GetCurrentCamera());
 return;
 }
 
 super.OnUpdate(pDt, pOutResult);
 StdFovUpdate(pDt, pOutResult);
 UpdateCameraNV(PlayerBase.Cast(m_pPlayer));
 InitCameraOnPlayer();
 }
 
 override void OnActivate(DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult pPrevCameraResult)
 {
 InitCameraOnPlayer(true);
 SetCameraPPDelay(pPrevCamera);
 
 if (DayZPlayerCameraBase.Cast(pPrevCamera) && DayZPlayerCameraBase.Cast(pPrevCamera).IsCameraNV() && !IsCameraNV())
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_TRANSITIVE) );
 }
 
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).CallLater(SetCameraPP,m_CameraPPDelay*1000,false,true,this); // this takes care of weapon/optics postprocessing
 DayZPlayerCameraOptics optic_camera;
 if (DayZPlayerCamera.CastTo(optic_camera,pPrevCamera))
 {
 GetGame().GetCallQueue(CALL_CATEGORY_GUI).Call(PlayerBase.Cast(m_pPlayer).HideClothing,null,false);
 }
 }
 
 float GetWeaponSwayModifier()
 {
 return m_WeaponSwayModifier;
 }
 
 override string GetCameraName()
 {
 return "DayZPlayerCameraBase";
 }
 
 void SetCameraPPDelay(DayZPlayerCamera pPrevCamera)
 {
 }
 
 void SetCameraNV(bool nightvision)
 {
 m_IsNightvision = nightvision;
 }
 
 bool IsCameraNV()
 {
 return m_IsNightvision;
 }
 
 void SetCameraNVType(int type)
 {
 m_NightvisionType = type;
 }
 
 int GetCameraNVType()
 {
 return m_NightvisionType;
 }
 
 void UpdateCameraNV(PlayerBase player)
 {
 if ( !player )
 return;
 
 if ( player.IsNVGWorking() != IsCameraNV() || player.GetNVType() != GetCameraNVType() )
 {
 SetCameraNV(player.IsNVGWorking());
 SetCameraNVType(player.GetNVType());
 SetCameraPP(true, this);
 }
 }
 
 void SetCameraPP(bool state, DayZPlayerCamera launchedFrom)
 {
 PPERequesterBank.GetRequester(PPERequester_CameraADS).Stop();
 
 if (IsCameraNV())
 {
 SetNVPostprocess(GetCameraNVType());
 }
 else
 {
 SetNVPostprocess(NVTypes.NONE);
 }
 
 m_weaponUsed = Weapon_Base.Cast(m_pPlayer.GetHumanInventory().GetEntityInHands());
 if (m_weaponUsed)
 {
 m_weaponUsed.HideWeaponBarrel(false);
 }
 }
 
 override float GetCurrentYaw()
 {
 return m_CurrentCameraYaw;
 }
 
 override float GetCurrentPitch()
 {
 return m_CurrentCameraPitch;
 }
 
 override float GetCurrentRoll()
 {
 return m_CurrentCameraRoll;
 }
 
 void ForceFreelook(bool state)
 {
 m_bForceFreeLook = state;
 }
 
 //TODO - better handling of distinct occluder types
 void SetNVPostprocess(int NVtype)
 {
 //Print("+++Setting NV type: " + NVtype + " +++");
 switch (NVtype)
 {
 case NVTypes.NONE:
 {
 PPERequesterBank.GetRequester(PPERequester_CameraNV).Stop();
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 }
 }
 break;
 
 //night-vision modes
 case NVTypes.NV_OPTICS_KAZUAR_NIGHT:
 case NVTypes.NV_OPTICS_STARLIGHT_NIGHT:
 case NVTypes.NV_OPTICS_ON:
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DEFAULT_OPTICS) );
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 }
 }
 break;
 
 //daytime filter modes
 case NVTypes.NV_OPTICS_KAZUAR_DAY:
 case NVTypes.NV_OPTICS_STARLIGHT_DAY:
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DAYTIME_OPTICS) );
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 }
 }
 break;
 
 case NVTypes.NV_GOGGLES_OFF:
 case NVTypes.NV_OPTICS_OFF:
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_NO_BATTERY) );
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 }
 }
 break;
 
 case NVTypes.NV_GOGGLES:
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DEFAULT_GLASSES) );
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 }
 }
 break;
 
 case NVTypes.NV_PUMPKIN:
 {
 PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_PUMPKIN) );
 if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
 {
 GetGame().GetMission().GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
 }
 }
 break;
 }
 
 if (PlayerBaseClient.Cast(m_pPlayer))
 {
 PlayerBaseClient.Cast(m_pPlayer).SwitchPersonalLight(NVtype < 1);
 }
 }
 
 void InitCameraOnPlayer(bool force = false)
 {
 PlayerBase player = PlayerBase.Cast(m_pPlayer);
 if (!player.GetCurrentPlayerCamera() || (force && player.GetCurrentPlayerCamera() != this))
 {
 player.OnCameraChanged(this);
 }
 }
 
 protected float m_fLRAngleVel[1];
 protected float m_fUDAngleVel[1];
 protected float m_fFovAbsVel[1];
 protected float m_fFovAbsolute;
 protected bool m_bForceFreeLook;
 protected float m_WeaponSwayModifier;
 protected float m_CameraPPDelay;
 
 protected float m_CurrentCameraYaw;
 protected float m_CurrentCameraPitch;
 protected float m_CurrentCameraRoll;
 
 protected HumanCommandWeapons m_CommandWeapons;
 protected bool m_IsNightvision;
 protected int m_NightvisionType;
}