DayZPlayerCameraIronsights.c

Go to the documentation of this file.

 
class DayZPlayerCameraIronsights extends DayZPlayerCameraBase
{
  static const float CONST_UD_MIN = -85.0; 
  static const float CONST_UD_MAX = 85.0; 
  static const float CONST_UD_MIN_BACK = -25.0; 
 
  static const float CONST_LR_MIN = -160.0; 
  static const float CONST_LR_MAX = 160.0; 
 
  protected bool m_isEntering = false;
  protected bool m_opticsHasWeaponOverride = false;
  protected ref array<float> temp_array; //DOF only
 
  protected PPERequester_CameraADS m_RequesterADS;
 
  float m_velocityYaw[1];
  float m_velocityPitch[1];
  float m_dynamicsStrength;
  float m_dynamicsSmoothTime;
  vector m_SightMisalignmentModifier;
 
  float m_movementTimeAcc;
  float m_movementAmplitudeX;
  float m_movementAmplitudeY;
  float m_movementFrequencyX;
  float m_movementFrequencyY;
 
 
  void DayZPlayerCameraIronsights(DayZPlayer pPlayer, HumanInputController pInput)
  {
    if (!temp_array)
      temp_array = new array<float>;
    m_iBoneIndex = pPlayer.GetBoneIndexByName("RightHand_Dummy");
 
    if (m_iBoneIndex == -1)
      Print("DayZPlayerCamera1stPerson: main bone not found");
 
    m_dynamicsStrength = 2;
    m_dynamicsSmoothTime = 0.3;
 
    SetupSightEntities();
    GetCurrentSightInfo(m_OpticsCamPos, m_OpticsCamDir);
    m_isEntering = true;
    m_WeaponSwayModifier = 0.5;
 
    m_movementTimeAcc = 0;
    m_movementAmplitudeX = 1;
    m_movementAmplitudeY = 1;
    m_movementFrequencyX = 1;
    m_movementFrequencyY = 2;
 
    Class.CastTo(m_RequesterADS, PPERequester_CameraADS.Cast(PPERequesterBank.GetRequester(PPERequester_CameraADS)));
 
    Init();
  }
 
  void SetupSightEntities()
  {
    EntityAI inHands = m_pPlayer.GetHumanInventory().GetEntityInHands();
    if (inHands)
    {
      m_weaponUsed = Weapon_Base.Cast(inHands);
      if (m_weaponUsed)
      {
        m_SightMisalignmentModifier = m_weaponUsed.GetPropertyModifierObject().m_SightMisalignment;
        m_dynamicsStrength = m_dynamicsStrength * m_SightMisalignmentModifier[0];
        m_dynamicsSmoothTime = m_dynamicsSmoothTime * m_SightMisalignmentModifier[1];
        m_opticsUsed = m_weaponUsed.GetAttachedOptics();
        if (m_opticsUsed)
          m_opticsHasWeaponOverride = m_opticsUsed.HasWeaponIronsightsOverride();
      }
      else
        m_opticsUsed = ItemOptics.Cast(inHands);
    }
  }
 
  //
  override void OnActivate(DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult pPrevCameraResult)
  {
    super.OnActivate(pPrevCamera, pPrevCameraResult);
 
    if (pPrevCamera)
    {
      vector baseAngles = pPrevCamera.GetBaseAngles();
      m_fUpDownAngle = baseAngles[0];
      m_fLeftRightAngle = baseAngles[1];
 
      vector addAngles = pPrevCamera.GetAdditiveAngles();
      m_fUpDownAngleAdd = addAngles[0];
      m_fLeftRightAngleAdd = addAngles[1];
    }
  }
 
  EntityAI GetCurrentSightEntity()
  {
    if (m_opticsHasWeaponOverride)
      return m_opticsUsed;
 
    return m_weaponUsed;
  }
 
  bool GetCurrentSightInfo(out vector camPos, out vector camDir)
  {
    EntityAI e = GetCurrentSightEntity();
    if (e)
    {
      if (e == m_weaponUsed)
      {
        m_weaponUsed.GetCameraPoint(m_weaponUsed.GetCurrentMuzzle(), camPos, camDir);
        return true;
      }
      else if (e == m_opticsUsed)
      {
        m_opticsUsed.UseWeaponIronsightsOverride(m_opticsHasWeaponOverride);
        m_opticsUsed.GetCameraPoint(camPos, camDir);
        return true;
      }
    }
    else
      ErrorEx("No sight entity found in " + this, ErrorExSeverity.INFO);
    return false;
  }
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    float min;
    DayZPlayerImplement player = DayZPlayerImplement.Cast(GetGame().GetPlayer());
    if (player && player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_RAISEDPRONE))
      min = CONST_UD_MIN_BACK;
    else
      min = CONST_UD_MIN;
 
    m_CurrentCameraYaw = UpdateLRAngleUnlocked(m_fLeftRightAngle, m_fLeftRightAngleAdd, CONST_LR_MIN, CONST_LR_MAX, pDt);
    m_CurrentCameraPitch = UpdateUDAngleUnlocked(m_fUpDownAngle, m_fUpDownAngleAdd, min, CONST_UD_MAX, pDt);
 
    // get model space transform matrix of the gun's eye vector
    vector matTM[4];
    HumanItemAccessor hia = m_pPlayer.GetItemAccessor();
    if (GetCurrentSightEntity())
      hia.WeaponGetCameraPointBoneRelative(GetCurrentSightEntity(), m_OpticsCamPos, m_OpticsCamDir, m_iBoneIndex, matTM);
 
    // aim change based on character movement
    vector aimChangeYPR;
    float aimChangeX = m_pInput.GetAimDelta(pDt)[0] * Math.RAD2DEG;
    float aimChangeY = m_pInput.GetAimDelta(pDt)[1] * Math.RAD2DEG;
 
    HumanCommandMove hcm = m_pPlayer.GetCommand_Move();
    if (hcm)
    {
      float speed = hcm.GetCurrentMovementSpeed();
 
      if (speed > 0)
        m_movementTimeAcc += pDt;
      else
        m_movementTimeAcc = 0;
 
      aimChangeX += m_movementAmplitudeX * speed * Math.Sin(Math.PI2 * m_movementFrequencyX * m_movementTimeAcc);
      aimChangeY += m_movementAmplitudeY * speed * Math.Sin(Math.PI2 * m_movementFrequencyY * m_movementTimeAcc);
    }
 
    aimChangeYPR[0] = Math.SmoothCD(aimChangeYPR[0], -(m_dynamicsStrength * aimChangeY), m_velocityYaw, m_dynamicsSmoothTime, 1000, pDt);
    aimChangeYPR[1] = Math.SmoothCD(aimChangeYPR[1], -(m_dynamicsStrength * aimChangeX), m_velocityPitch, m_dynamicsSmoothTime, 1000, pDt);
    aimChangeYPR[2] = 0;
 
    vector dynamics[4];
    Math3D.YawPitchRollMatrix(aimChangeYPR, dynamics);
    dynamics[3] = vector.Zero;
 
    // aiming model offsets
    vector aimingMatTM[4];
    hia.WeaponGetAimingModelDirTm(aimingMatTM);
 
    // final offset matrix
    Math3D.MatrixMultiply4(dynamics, aimingMatTM, dynamics);
    Math3D.MatrixMultiply4(dynamics, matTM, pOutResult.m_CameraTM);
 
    AdjustCameraParameters(pDt, pOutResult);
    UpdateBatteryOptics(GetCurrentSightEntity());
    UpdateCameraNV(PlayerBase.Cast(m_pPlayer));
 
    if (m_CameraShake)
    {
      float x, y;
      m_CameraShake.Update(pDt, x, y);
      DayZPlayerImplement.Cast(m_pPlayer).GetAimingModel().SetCamShakeValues(x, y);
    }
  }
 
  override vector GetBaseAngles()
  {
    vector a;
    a[0] = m_fUpDownAngle;
    a[1] = m_fLeftRightAngle;
    a[2] = 0;
    return a;
  }
 
  override vector GetAdditiveAngles()
  {
    vector a;
    a[0] = m_fUpDownAngleAdd;
    a[1] = m_fLeftRightAngleAdd;
    a[2] = 0;
    return a;
  }
 
  void AdjustCameraParameters(float pDt, inout DayZPlayerCameraResult pOutResult)
  {
    pOutResult.m_iDirectBone = m_iBoneIndex;
    pOutResult.m_iDirectBoneMode = 4;
 
    pOutResult.m_fFovAbsolute = HoldBreathFOVEffect(pDt);
 
    pOutResult.m_bUpdateWhenBlendOut = false;
    pOutResult.m_fDistance = 0;
    pOutResult.m_fUseHeading = 0;
    pOutResult.m_fInsideCamera = 1.0;
    pOutResult.m_fShootFromCamera = m_fShootFromCamera;
 
    pOutResult.m_fNearPlane = 0.04; //0.07 default
  }
 
  float HoldBreathFOVEffect(float pDt)
  {
    if (m_pPlayer.IsHoldingBreath())
      m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GameConstants.DZPLAYER_CAMERA_FOV_EYEZOOM, m_fFovAbsVel, 0.1, 1000, pDt);
    else if (m_isEntering) //sets FOV immediatelly to avoid "floating camera" effect
    {
      m_fFovAbsolute = GameConstants.DZPLAYER_CAMERA_FOV_IRONSIGHTS;
      m_isEntering = false;
    }
    else
      m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GameConstants.DZPLAYER_CAMERA_FOV_IRONSIGHTS, m_fFovAbsVel, 0.1, 1000, pDt);
 
    return m_fFovAbsolute;
  }
 
  // sets PP for ironsights and optics (override) cameras
  override void SetCameraPP(bool state, DayZPlayerCamera launchedFrom)
  {
    //Print("SetCameraPP - ADS");
    if (PlayerBase.Cast(m_pPlayer) && launchedFrom.Type() != PlayerBase.Cast(m_pPlayer).GetCurrentPlayerCamera().Type())
    {
      //Print("DayZPlayerCameraIronsights | SetCameraPP | skipping, wrong camera type active!");
      return;
    }
 
    //if (!state || !m_weaponUsed || (PlayerBase.Cast(m_pPlayer) && launchedFrom != PlayerBase.Cast(m_pPlayer).GetCurrentPlayerCamera()))
    if (!state || !m_weaponUsed)
    {
      m_RequesterADS.Stop();
 
      if (IsCameraNV())
        SetNVPostprocess(GetCameraNVType());
      else
        SetNVPostprocess(NVTypes.NONE);
    }
    else
    {
      temp_array = {false, 0.0, 0.0, 0.0, 0.0, 1.0};
 
      if (m_weaponUsed.GetWeaponDOF() || (m_opticsUsed && m_opticsUsed.GetOpticsDOF()))
      {
        if (m_opticsUsed && m_opticsUsed.GetOpticsDOF().Count() == 6)
          temp_array = m_opticsUsed.GetOpticsDOF();
        else
          temp_array = m_weaponUsed.GetWeaponDOF();
        if (temp_array.Count() != 6)
          temp_array = {false, 0.0, 0.0, 0.0, 0.0, 1.0};
      }
 
      m_RequesterADS.SetValuesIronsights(temp_array); //DOF only
 
      if (IsCameraNV())
        SetNVPostprocess(GetCameraNVType());
      else
        SetNVPostprocess(NVTypes.NONE);
    }
 
    if (m_weaponUsed)
      m_weaponUsed.HideWeaponBarrel(false);
  }
 
  override string GetCameraName()
  {
    return "DayZPlayerCameraIronsights";
  }
 
  override void SetCameraPPDelay(DayZPlayerCamera pPrevCamera)
  {
    if (pPrevCamera.GetCameraName() == "DayZPlayerCamera1stPerson")
    {
      //Print("---ironsights---DayZPlayerCamera1stPerson");
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_01;
    }
    else if (pPrevCamera.GetCameraName() == "DayZPlayerCameraOptics")
      m_CameraPPDelay = 0;
    else
    {
      //Print("---ironsights---else");
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_02;
    }
  }
 
  void UpdateBatteryOptics(EntityAI entity)
  {
    ItemOptics optics = ItemOptics.Cast(entity);
    if (optics)
      optics.UpdateOpticsReddotVisibility();
  }
 
  protected float m_fShootFromCamera = 0.0;
 
  protected int m_iBoneIndex; 
  protected vector m_OpticsCamPos;
  protected vector m_OpticsCamDir;
 
  protected float m_fUpDownAngle; 
  protected float m_fUpDownAngleAdd; 
  protected float m_fLeftRightAngle; 
  protected float m_fLeftRightAngleAdd; 
 
}
 
class DayZPlayerCameraOptics : DayZPlayerCameraIronsights
{
  static const float CONST_NEARPLANE_OPTICS = 0.06; //Default near plane value for this camera
  protected float m_RecoilOffsetZ = 0.0;
 
  void DayZPlayerCameraOptics(DayZPlayer pPlayer, HumanInputController pInput)
  {
    if (!temp_array)
      temp_array = new array<float>;
    m_fShootFromCamera = 0;
  }
 
  override void Init()
  {
    if (m_opticsUsed && m_opticsUsed.IsNVOptic() && m_opticsUsed.IsWorking())
      SetCameraNV(true);
    else
      SetCameraNV(false);
  }
 
  override EntityAI GetCurrentSightEntity()
  {
    return m_opticsUsed;
  }
 
  override bool GetCurrentSightInfo(out vector camPos, out vector camDir)
  {
    if (m_opticsUsed)
    {
      m_opticsUsed.UseWeaponIronsightsOverride(false);
      m_opticsUsed.GetCameraPoint(camPos, camDir);
      return true;
    }
    return false;
  }
 
  override void OnActivate(DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult pPrevCameraResult)
  {
    super.OnActivate(pPrevCamera, pPrevCameraResult);
 
    PlayerBase player = PlayerBase.Cast(m_pPlayer);
    if (player && m_opticsUsed)
      GetGame().GetCallQueue(CALL_CATEGORY_GUI).CallLater(player.HideClothing, m_CameraPPDelay * 1000, false, m_opticsUsed, true);
  }
 
  override void AdjustCameraParameters(float pDt, inout DayZPlayerCameraResult pOutResult)
  {
    pOutResult.m_iDirectBone = m_iBoneIndex;
    pOutResult.m_iDirectBoneMode = 4;
 
    pOutResult.m_fFovAbsolute = HoldBreathFOVEffect(pDt);
 
    pOutResult.m_bUpdateWhenBlendOut = false;
    pOutResult.m_fDistance = 0;
    pOutResult.m_fUseHeading = 0;
    pOutResult.m_fInsideCamera = 1.0;
    pOutResult.m_fShootFromCamera = m_fShootFromCamera;
 
    if (!m_opticsUsed)
      pOutResult.m_fNearPlane = Math.Clamp(CONST_NEARPLANE_OPTICS - m_RecoilOffsetZ, CONST_NEARPLANE_OPTICS, 10.0);
    else
      pOutResult.m_fNearPlane = Math.Clamp(m_opticsUsed.GetNearPlaneValue() - m_RecoilOffsetZ, CONST_NEARPLANE_OPTICS, 10.0); //some sufficiently nonsensical max
  }
 
  override float HoldBreathFOVEffect(float pDt)
  {
    //hotfix; two cameras exist and update simultaneously during transition, even if optics/weapons is no longer present!
    /*PlayerBase player = PlayerBase.Cast(m_pPlayer);
      if (player && player.GetCurrentCamera() != this)
      return 0.6;*/
 
    ItemOptics optics = ItemOptics.Cast(GetCurrentSightEntity());
    if (optics)
    {
      if (optics.GetCurrentStepFOV() >= GameConstants.DZPLAYER_CAMERA_FOV_EYEZOOM && (m_pPlayer.IsHoldingBreath() || m_pPlayer.GetEyeZoomLevel()))
        m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GameConstants.DZPLAYER_CAMERA_FOV_EYEZOOM, m_fFovAbsVel, 0.1, 1000, pDt);
      else if (m_isEntering) //sets FOV immediatelly to avoid "floating camera" effect
      {
        m_fFovAbsolute = optics.GetCurrentStepFOV();
        m_isEntering = false;
      }
      else
      {
        m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, optics.GetCurrentStepFOV(), m_fFovAbsVel, 0.1, 1000, pDt);
        //m_fFovAbsolute = optics.GetCurrentStepFOV();
      }
      return m_fFovAbsolute;
    }
    else
    {
      //Error("optic camera, but there is no optic item or optic on weapon"); //camera update ticks on transitions as well, caused problems
      return 0.6; //TODO figure some other way to get original FOV here!
    }
  }
 
  override void SetCameraPP(bool state, DayZPlayerCamera launchedFrom)
  {
    //Print("SetCameraPP - optics");
    if (PlayerBase.Cast(m_pPlayer) && launchedFrom.Type() != PlayerBase.Cast(m_pPlayer).GetCurrentPlayerCamera().Type())
    {
      //Print("DayZPlayerCameraOptics | SetCameraPP | skipping, wrong camera type active!");
      return;
    }
 
    if (!state || !m_opticsUsed)
    {
      m_RequesterADS.Stop();
 
      if (IsCameraNV())
        SetNVPostprocess(GetCameraNVType());
      else
        SetNVPostprocess(NVTypes.NONE);
 
      if (m_weaponUsed)
        m_weaponUsed.HideWeaponBarrel(false);
    }
    else
    {
      array<float> lens_values = new array<float>;
      array<float> mask_values = new array<float>;
      float gauss = 0.0;
      temp_array = {false, 0.0, 0.0, 0.0, 0.0, 1.0};
 
      // 1x scopes only
      if (m_opticsUsed.AllowsDOF() && !NVGoggles.Cast(m_opticsUsed))
      {
        if (m_weaponUsed)
        {
          if (m_opticsUsed.GetOpticsDOF().Count() == 6)
            temp_array = m_opticsUsed.GetOpticsDOF();
          else
          {
            temp_array = m_weaponUsed.GetWeaponDOF(); //TODO should some optics have own DOF settings (different eye point)?
          }
 
          if (temp_array.Count() != 6)
            temp_array = {false, 0.0, 0.0, 0.0, 0.0, 1.0};
        }
 
        m_RequesterADS.SetValuesIronsights(temp_array); //DOF only
 
        // optics NV mode
        if (m_opticsUsed.IsNVOptic())
        {
          SetCameraNV(true);
          SetNVPostprocess(m_opticsUsed.GetCurrentNVType());
        }
        else
        {
          if (IsCameraNV())
            SetNVPostprocess(GetCameraNVType());
          else
            SetNVPostprocess(NVTypes.NONE);
        }
      }
      else //magnifying scopes
      {
        // optics mask
        if (m_opticsUsed.GetOpticsPPMask() && m_opticsUsed.GetOpticsPPMask().Count() == 4)
          mask_values = m_opticsUsed.GetOpticsPPMask();
 
        //optics lens
        if (m_opticsUsed.GetOpticsPPLens() && m_opticsUsed.GetOpticsPPLens().Count() == 4)
          lens_values = m_opticsUsed.GetOpticsPPLens();
 
        //optics blur
        if (m_opticsUsed.GetOpticsPPBlur() != 0)
          gauss = m_opticsUsed.GetOpticsPPBlur();
 
        m_RequesterADS.SetValuesOptics(mask_values, lens_values, gauss);
 
        // optics NV mode
        if (m_opticsUsed.IsNVOptic())
        {
          SetCameraNV(true);
          SetNVPostprocess(m_opticsUsed.GetCurrentNVType());
        }
        else
        {
          SetNVPostprocess(NVTypes.NONE); //magnifying optics do not combine with other NV sources (would render NV optics obsolete)
        }
      }
 
      if (m_weaponUsed)
        m_weaponUsed.HideWeaponBarrel(true);
    }
  }
 
  override string GetCameraName()
  {
    return "DayZPlayerCameraOptics";
  }
 
  override void SetCameraPPDelay(DayZPlayerCamera pPrevCamera)
  {
    if (pPrevCamera.GetCameraName() == "DayZPlayerCameraIronsights")
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_02 - 0.05;
    else if (pPrevCamera.GetCameraName() == "DayZPlayerCamera1stPerson")
    {
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_02 - 0.05; //changed to accomodate handheld optics, had to be changed here also
    }
    else if (!pPrevCamera.IsCamera3rdRaised())
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_03 - 0.05;
    else
      m_CameraPPDelay = DayZPlayerCameras.TIME_CAMERACHANGE_02 - 0.05;
  }
 
  override void SendRecoilOffsetZ(float offset)
  {
    m_RecoilOffsetZ = offset;
  }
};