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;
    }
}