DayZPlayerCamera3rdPerson.c

Go to the documentation of this file.

// *************************************************************************************
// ! DayZPlayerCamera3rdPerson - base for 3rd person cameras
// *************************************************************************************
class DayZPlayerCamera3rdPerson extends DayZPlayerCameraBase
{
  static const float CONST_UD_MIN = -85.0; 
  static const float CONST_UD_MAX = 85.0; 
 
  static const float CONST_LR_MIN = -160.0; 
  static const float CONST_LR_MAX = 160.0; 
 
  void DayZPlayerCamera3rdPerson(DayZPlayer pPlayer, HumanInputController pInput)
  {
    if (pInput.Camera3rdIsRightShoulder())
      m_fCameraLRShoulder = 1.0;
    else
      m_fCameraLRShoulder = -1.0;
 
    m_fCameraLRShoulderVel[0] = 0.0;
    m_CurrentCameraRoll = 0.0;
    m_WeaponSwayModifier = 1;
    m_fLeanDistance = 0.3;
    m_fPredictCollisionRadius = 0.5;
  }
 
 
  //
  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];
    }
  }
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    m_pPlayer.GetMovementState(m_MovementState);
 
    m_CurrentCameraYaw = UpdateLRAngleUnlocked(m_fLeftRightAngle, m_fLeftRightAngleAdd, CONST_LR_MIN, CONST_LR_MAX, pDt);
    m_CurrentCameraPitch = UpdateUDAngleUnlocked(m_fUpDownAngle, m_fUpDownAngleAdd, CONST_UD_MIN, CONST_UD_MAX, pDt);
 
    ProcessCameraShake(pDt, m_fLeftRightAngle, m_fUpDownAngleAdd);
 
    // update l/r offsets and set it as
    if (m_pInput.Camera3rdIsRightShoulder())
      m_fCameraLRShoulder = Math.SmoothCD(m_fCameraLRShoulder, 1.0, m_fCameraLRShoulderVel, 0.14, 1000, pDt);
    else
      m_fCameraLRShoulder = Math.SmoothCD(m_fCameraLRShoulder, -1.0, m_fCameraLRShoulderVel, 0.14, 1000, pDt);
 
    float shoulderDist = m_fCameraLRShoulder * m_fShoulderWidth + m_MovementState.m_fLeaning * m_fLeanDistance;
 
    Math3D.YawPitchRollMatrix(GetCurrentOrientation(), pOutResult.m_CameraTM);
 
    if (m_iBoneIndex != -1)
      pOutResult.m_CameraTM[3] = m_pPlayer.GetBonePositionMS(m_iBoneIndex);
    else
      pOutResult.m_CameraTM[3] = "0 0 0";
 
    vector msOffset = m_CameraOffsetMS;
    vector lsOffset = m_CameraOffsetLS;
 
    if (m_bShoulderInLS)
      lsOffset[0] = lsOffset[0] + shoulderDist;
    else
      msOffset[0] = msOffset[0] + shoulderDist;
 
    // ls offset + ms offset + shoulder width
    pOutResult.m_CameraTM[3] = pOutResult.m_CameraTM[3] + pOutResult.m_CameraTM[0] * lsOffset[0] + pOutResult.m_CameraTM[1] * lsOffset[1] + pOutResult.m_CameraTM[2] * lsOffset[2] + msOffset;
 
    pOutResult.m_fDistance = m_fDistance;
    pOutResult.m_fUseHeading = 1.0;
    pOutResult.m_fInsideCamera = 0.0;
    pOutResult.m_fPredictCollisionRadius = m_fPredictCollisionRadius;
 
    InitCameraOnPlayer();
    StdFovUpdate(pDt, pOutResult);
    UpdateCameraNV(PlayerBase.Cast(m_pPlayer));
  }
 
  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;
  }
 
  override string GetCameraName()
  {
    return "DayZPlayerCamera3rdPerson";
  }
 
  protected int m_iBoneIndex = -1; 
  protected vector m_CameraOffsetMS; 
  protected vector m_CameraOffsetLS; 
  protected float m_fDistance; 
  protected float m_fShoulderWidth; 
  protected bool m_bShoulderInLS; 
  protected float m_fRoll; 
  protected float m_fLeanDistance; 
 
 
  protected float m_fUpDownAngle; 
  protected float m_fUpDownAngleAdd; 
  protected float m_fLeftRightAngle; 
  protected float m_fLeftRightAngleAdd; 
 
  protected float m_fCameraLRShoulder; // -1..1 shoulderness :)
  protected float m_fCameraLRShoulderVel[1]; // 0
 
  protected float m_fPredictCollisionRadius;
 
  ref HumanMovementState m_MovementState = new HumanMovementState();
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonErc - 3rd person erected
// *************************************************************************************
class DayZPlayerCamera3rdPersonErc extends DayZPlayerCamera3rdPerson
{
  void DayZPlayerCamera3rdPersonErc(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonErc");
 
    m_fDistance = 1.6;
    m_CameraOffsetMS = "0.0 1.4 0.0";
    m_CameraOffsetLS = "0.0 0.3 0.0";
    m_fShoulderWidth = 0.3;
    m_fPredictCollisionRadius = 1.2;
  }
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonJump - 3rd person jump
// *************************************************************************************
class DayZPlayerCamera3rdPersonJump extends DayZPlayerCamera3rdPersonErc
{
  void DayZPlayerCamera3rdPersonJump(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonJump");
 
    m_fDelay = 0.15;
    m_fDamping = 0.25;
 
    m_fJumpStartY = pPlayer.GetOrigin()[1];
    m_fJumpOffset = 0;
    m_fDelayTimer = 0;
  }
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    super.OnUpdate(pDt, pOutResult);
 
    float yPos = m_pPlayer.GetOrigin()[1];
    float yDiff = yPos - m_fJumpStartY;
    yDiff = Math.Clamp(yDiff, 0.0, 2.0);
 
    if (m_fDelayTimer < m_fDelay)
    {
      m_fDelayTimer += pDt;
      m_fJumpOffset = yDiff;
    }
    else
      m_fJumpOffset = Math.SmoothCD(m_fJumpOffset, -(m_fDamping * yDiff), m_jumpOffsetVelocity, 0.3, 1000, pDt);
 
    float newY = pOutResult.m_CameraTM[3][1] - m_fJumpOffset;
    pOutResult.m_CameraTM[3][1] = newY;
  }
 
  float m_fDelay;
  float m_fDamping;
 
  float m_fDelayTimer;
  float m_fJumpStartY;
  float m_fJumpOffset;
  float m_jumpOffsetVelocity[1];
}
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonJump - 3rd person jump
// *************************************************************************************
class DayZPlayerCamera3rdPersonClimb extends DayZPlayerCamera3rdPersonErc
{
  void DayZPlayerCamera3rdPersonClimb(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonClimb");
    m_fDistance = 1.0;
    m_CameraOffsetMS = "0.0 0.3 -0.6";
    m_iBoneIndex = pPlayer.GetBoneIndexByName("Spine");
    m_fPredictCollisionRadius = 0.5;
  }
}
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonErc - 3rd person erected sprint
// *************************************************************************************
class DayZPlayerCamera3rdPersonErcSpr extends DayZPlayerCamera3rdPersonErc
{
  void DayZPlayerCamera3rdPersonErcSpr(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonErcSpr");
 
    m_fDistance = 2.0;
    m_CameraOffsetMS = "0.0 1.3 0.0";
    m_CameraOffsetLS = "0.0 0.3 0.0";
    m_fShoulderWidth = 0.15;
 
    m_iPelvisBone = pPlayer.GetBoneIndexByName("Pelvis");
    if (m_iPelvisBone == -1)
      Print("DayZPlayerCamera3rdPersonErcSpr: hips bone not found");
 
    m_fTime = 0.0;
  }
 
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    m_fTime += pDt * 5;
 
    vector tm[4];
 
    m_pPlayer.GetBoneTransformLS(m_iPelvisBone, tm);
    float xShift = tm[1][0];
    m_CurrentCameraRoll = xShift * 3.0; // 3 is just made up value i like :)
 
    // m_CurrentCameraRoll = (sin(1.5 * m_fTime)); //  + 0.3 * sin(3.6 * m_fTime) + 0.2 * sin(0.7 * m_fTime)) / 1.3 * 3;
 
    super.OnUpdate(pDt, pOutResult);
 
    //pOutResult.m_fFovMultiplier = 1.2;
  }
 
 
  protected int m_iPelvisBone;
  protected float m_fTime;
 
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonErcRaised - 3rd person erected raised
// *************************************************************************************
class DayZPlayerCamera3rdPersonErcRaised extends DayZPlayerCamera3rdPersonErc
{
  void DayZPlayerCamera3rdPersonErcRaised(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonErcRaised");
    m_fPredictCollisionRadius = 0.2;
 
    if (pPlayer.GetCurrentPerItemCameraUD() == DayZPlayerCameras.PERITEMUD_EMPTYHANDED)
    {
      // no item in hands
      m_fDistance = 1.2;
      m_fShoulderWidth = 0.4;
      m_CameraOffsetMS = "0.0 1.3 0.2";
      m_CameraOffsetLS = "0.0 0.3 0.0";
 
    }
    else if (pPlayer.GetCurrentPerItemCameraUD() == DayZPlayerCameras.PERITEMUD_TWOHANDED)
    {
      // two handed
      m_fDistance = 1.2;
      m_fShoulderWidth = 0.4;
      m_CameraOffsetMS = "0.0 1.3 0.2";
      m_CameraOffsetLS = "0.0 0.3 0.0";
    }
    else if (pPlayer.GetCurrentPerItemCameraUD() == DayZPlayerCameras.PERITEMUD_ONEHANDED)
    {
      // one handed
      m_fDistance = 1.2;
      m_fShoulderWidth = 0.4;
      m_CameraOffsetMS = "0.0 1.3 0.2";
      m_CameraOffsetLS = "0.0 0.3 0.0";
    }
    else
    {
      // weapons in hands
      m_fDistance = 0.8;
      m_CameraOffsetMS = "0.0 1.3 0.2";
      m_CameraOffsetLS = "0.0 0.3 0.0";
      m_fShoulderWidth = 0.5;
    }
  }
 
  override bool IsCamera3rdRaised()
  {
    return true;
  }
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonErcRaised - 3rd person erected raised
// *************************************************************************************
class DayZPlayerCamera3rdPersonErcRaisedMelee extends DayZPlayerCamera3rdPersonErcRaised
{
  override void HandleShoulderCameraOverride(HumanInputController pInput)
  {
    pInput.Override3rdIsRightShoulder(HumanInputControllerOverrideType.ENABLED, pInput.Camera3rdIsRightShoulder());
  }
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonCrouch - 3rd person crouch
// *************************************************************************************
class DayZPlayerCamera3rdPersonCrouch extends DayZPlayerCamera3rdPerson
{
  static const float CONST_CAMERAMOVEMENTHEIGH = 0.4; // 0 idle, 0.15 walk 0.3 run/sprint
 
  void DayZPlayerCamera3rdPersonCrouch(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonCrouch");
 
    m_fDistance = 1.4;
    m_CameraOffsetMS = "0.0 0.7 0.1";
    m_CameraOffsetLS = "0.0 0.3 0.0";
    m_fShoulderWidth = 0.3;
  }
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    m_pPlayer.GetMovementState(m_MovementState);
 
    float movement = (Limit(m_MovementState.m_iMovement, 1, 3) - 1.0) * 0.5;
    movement *= CONST_CAMERAMOVEMENTHEIGH;
    m_fCameraHeight = Math.SmoothCD(m_fCameraHeight, movement, m_fCameraHeightVel, 0.2, 1000, pDt);
    m_CameraOffsetMS[1] = 0.7 + m_fCameraHeight;
 
    super.OnUpdate(pDt, pOutResult);
  }
 
  protected float m_fCameraHeight; // -1..1 shoulderness :)
  protected float m_fCameraHeightVel[1]; // 0
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonCrouchRaised- 3rd person crouch raised
// *************************************************************************************
class DayZPlayerCamera3rdPersonCrouchRaised extends DayZPlayerCamera3rdPersonCrouch
{
  void DayZPlayerCamera3rdPersonCrouchRaised(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonCrouchRaised");
 
    m_fDistance = 0.8;
    m_CameraOffsetMS = "0.0 0.8 0.1"; // being overwritten by m_CameraOffsetMS[1] from DayZPlayerCamera3rdPersonCrouch
    m_CameraOffsetLS = "0.0 0.3 0.0";
    m_fShoulderWidth = 0.5;
  }
 
  override bool IsCamera3rdRaised()
  {
    return true;
  }
}
 
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonProneRaised - 3rd person prone raised
// *************************************************************************************
class DayZPlayerCamera3rdPersonProneBase extends DayZPlayerCamera3rdPerson
{
  protected vector m_BaseOffset
  protected float m_BaseOffsetVelX[1], m_BaseOffsetVelY[1], m_BaseOffsetVelZ[1];
  protected float m_LookAtLRAngle;
 
  float UpdateLRAngleLookAt(float pMin, float pMax, float pDt)
  {
    if (m_pInput.CameraIsFreeLook() || m_bForceFreeLook)
    {
      m_LookAtLRAngle += m_pInput.GetAimChange()[0] * Math.RAD2DEG;
      m_LookAtLRAngle = Limit(m_LookAtLRAngle, pMin, pMax);
 
      m_fLRAngleVel[0] = 0; // reset filter
    }
    else
    {
      // smooth value back to 0
      m_LookAtLRAngle = Math.SmoothCD(m_LookAtLRAngle, 0, m_fLRAngleVel, 0.14, 1000, pDt);
      // m_fLeftRightAngle  = 0.9 * (1.0 - pDt);
    }
 
    return m_LookAtLRAngle;
  }
 
  override void OnActivate(DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult pPrevCameraResult)
  {
    super.OnActivate(pPrevCamera, pPrevCameraResult);
 
    if (m_iBoneIndex != -1)
      m_BaseOffset = m_pPlayer.GetBonePositionMS(m_iBoneIndex);
    else
      m_BaseOffset = "0 0 0";
  }
 
 
  //
  override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
  {
    m_CurrentCameraPitch = UpdateUDAngleUnlocked(m_fUpDownAngle, m_fUpDownAngleAdd, CONST_UD_MIN, CONST_UD_MAX, pDt);
 
    float orientYaw = m_pPlayer.GetOrientation()[0];
    float headYaw = m_pInput.GetHeadingAngle() * Math.RAD2DEG; 
    m_CurrentCameraYaw = -fixAngle_180_180(orientYaw + headYaw);
 
    // Print("OY: " + orientYaw.ToString() + " HY: " + headYaw.ToString());
 
    // update l/r offsets and set it as
 
    ProcessCameraShake(pDt, m_fLeftRightAngle, m_fUpDownAngleAdd);
 
    if (m_pInput.Camera3rdIsRightShoulder())
      m_fCameraLRShoulder = Math.SmoothCD(m_fCameraLRShoulder, 1.0, m_fCameraLRShoulderVel, 0.14, 1000, pDt);
    else
      m_fCameraLRShoulder = Math.SmoothCD(m_fCameraLRShoulder, -1.0, m_fCameraLRShoulderVel, 0.14, 1000, pDt);
 
    float shoulderDist = m_fCameraLRShoulder * m_fShoulderWidth;
 
    Math3D.YawPitchRollMatrix(GetCurrentOrientation(), pOutResult.m_CameraTM);
 
    if (m_iBoneIndex != -1)
    {
      vector bonePos = m_pPlayer.GetBonePositionMS(m_iBoneIndex);
      m_BaseOffset[0] = Math.SmoothCD(m_BaseOffset[0], bonePos[0], m_BaseOffsetVelX, 0.14, 1000, pDt);
      m_BaseOffset[1] = Math.SmoothCD(m_BaseOffset[1], bonePos[1], m_BaseOffsetVelY, 0.14, 1000, pDt);
      m_BaseOffset[2] = Math.SmoothCD(m_BaseOffset[2], bonePos[2], m_BaseOffsetVelZ, 0.14, 1000, pDt);
    }
 
    vector msOffset = m_CameraOffsetMS;
    vector lsOffset = m_CameraOffsetLS;
 
    lsOffset[0] = lsOffset[0] + shoulderDist;
 
    // ls offset + ms offset + shoulder width
    pOutResult.m_CameraTM[3] = m_BaseOffset + pOutResult.m_CameraTM[0] * lsOffset[0] + pOutResult.m_CameraTM[1] * lsOffset[1] + pOutResult.m_CameraTM[2] * lsOffset[2] + msOffset;
 
    m_CurrentCameraYaw = UpdateLRAngleLookAt(-180, 180, pDt);
    Math3D.YawPitchRollMatrix(GetCurrentOrientation(), pOutResult.m_CameraTM);
 
    pOutResult.m_fDistance = m_fDistance;
    pOutResult.m_fUseHeading = 1.0;
    pOutResult.m_fInsideCamera = 0.0;
    pOutResult.m_fPositionModelSpace = 1.0;
    pOutResult.m_bUpdateWhenBlendOut = false;
 
    InitCameraOnPlayer();
    StdFovUpdate(pDt, pOutResult);
    UpdateCameraNV(PlayerBase.Cast(m_pPlayer));
  }
}
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonProne - 3rd person prone
// *************************************************************************************
class DayZPlayerCamera3rdPersonProne extends DayZPlayerCamera3rdPersonProneBase
{
  void DayZPlayerCamera3rdPersonProne(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonProne");
    m_iBoneIndex = pPlayer.GetBoneIndexByName("Camera3rd_Helper");
    m_fDistance = 1.0;
    m_CameraOffsetMS = "0.0 0.4 0.0";
    m_CameraOffsetLS = "0.0 0.2 0.0";
    m_fShoulderWidth = 0.5;
  }
 
}
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonProneRaised - 3rd person prone raised
// *************************************************************************************
class DayZPlayerCamera3rdPersonProneRaised extends DayZPlayerCamera3rdPersonProneBase
{
  void DayZPlayerCamera3rdPersonProneRaised(DayZPlayer pPlayer, HumanInputController pInput)
  {
    //Print("new camera: DayZPlayerCamera3rdPersonProneRaised");
    m_iBoneIndex = pPlayer.GetBoneIndexByName("Camera3rd_Helper");
    m_fDistance = 1.0;
    m_CameraOffsetMS = "0.0 0.4 0.0";
    m_CameraOffsetLS = "0.0 0.2 0.0";
    m_fShoulderWidth = 0.5;
  }
 
  override bool IsCamera3rdRaised()
  {
    return true;
  }
}