DayZPlayerCameraVehicles.c

См. документацию.

// *************************************************************************************
// ! DayZPlayerCamera1stPersonVehicle - first person in vehicle
// *************************************************************************************
class DayZPlayerCamera1stPersonVehicle extends DayZPlayerCamera1stPerson
{
    override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
    {
        super.OnUpdate(pDt, pOutResult);
 
        pOutResult.m_fUseHeading        = 0.0;
        pOutResult.m_bUpdateEveryFrame  = GetGame().IsPhysicsExtrapolationEnabled();
    }
}
 
// *************************************************************************************
// ! DayZPlayerCamera3rdPersonVehicle - 3rd person in vehicle (generic)
// *************************************************************************************
class DayZPlayerCamera3rdPersonVehicle extends DayZPlayerCameraBase
{
    static const float  CONST_UD_MIN    = -85.0;        
    static const float  CONST_UD_MAX    = 85.0;         
    const float UP_ANGLE_CAP            = 10;           // max up angle, doesnt require gamecode sync
 
    static const float  CONST_LR_MIN    = -160.0;       
    static const float  CONST_LR_MAX    = 160.0;        
    
    const float CONST_LINEAR_VELOCITY_STRENGTH        = 0.025;
    const float CONST_ANGULAR_VELOCITY_STRENGTH      = 0.025;
 
    const float CONST_ANGULAR_LAG_YAW_STRENGTH        = 10.0;
    const float CONST_ANGULAR_LAG_PITCH_STRENGTH    = 50.0;
    const float CONST_ANGULAR_LAG_ROLL_STRENGTH      = 0.0;
 
    void DayZPlayerCamera3rdPersonVehicle( DayZPlayer pPlayer, HumanInputController pInput )
    {
        //Print("new camera: DayZPlayerCamera3rdPersonVehicle");
 
        m_fDistance      = 4.0;
        m_CameraOffsetMS    = "0.0 1.3 0.0";
        
        HumanCommandVehicle vehicleCommand = pPlayer.GetCommand_Vehicle();
        if ( vehicleCommand )
        {
            Transport transport = vehicleCommand.GetTransport();
            if ( transport )
            {
                m_Transport          = transport;
                m_fDistance          = transport.GetTransportCameraDistance();
                m_CameraOffsetMS    = transport.GetTransportCameraOffset();
            }
        }
    }
    
    override void OnActivate( DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult 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];
        }
                
        m_LagOffsetPosition = vector.Zero;
        m_fLagOffsetVelocityX[0] = 0;
        m_fLagOffsetVelocityY[0] = 0;
        m_fLagOffsetVelocityZ[0] = 0;
    }
 
    override void OnUpdate( float pDt, out DayZPlayerCameraResult pOutResult )
    {
        vector playerTransformWS[4];
        m_pPlayer.GetTransform(playerTransformWS);

        IEntity vehicle = m_Transport;
        pOutResult.m_CollisionIgnoreEntity = vehicle;
        
        vector cameraPosition = vector.Zero;
        if ( vehicle )
        {
            vector vehiclePositionWS = vehicle.GetOrigin();
            vector vehiclePositionMS = vehiclePositionWS.InvMultiply4(playerTransformWS);
            cameraPosition = vehiclePositionMS + m_CameraOffsetMS;
        }

        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);
        m_CurrentCameraRoll      = 0;
                
        vector posDiffLS = vector.Zero;
        vector rotDiffLS = vector.Zero;
        vector orientVeh = vector.Zero; 
        
        if (vehicle)
        {
            vector posDiffWS = GetVelocity(vehicle) * CONST_LINEAR_VELOCITY_STRENGTH;
            posDiffLS = posDiffWS.InvMultiply3(playerTransformWS);
 
            vector rotDiffWS = dBodyGetAngularVelocity(vehicle) * Math.RAD2DEG * CONST_ANGULAR_VELOCITY_STRENGTH;
            rotDiffLS = rotDiffWS.InvMultiply3(playerTransformWS);
            
            orientVeh = m_Transport.GetOrientation() * Math.DEG2RAD;
        }       
            
        m_LagOffsetPosition[0] = Math.SmoothCD(m_LagOffsetPosition[0], posDiffLS[0], m_fLagOffsetVelocityX, 0.3, 1000, pDt);
        m_LagOffsetPosition[1] = Math.SmoothCD(m_LagOffsetPosition[1], posDiffLS[1], m_fLagOffsetVelocityY, 0.3, 1000, pDt);
        m_LagOffsetPosition[2] = Math.SmoothCD(m_LagOffsetPosition[2], posDiffLS[2], m_fLagOffsetVelocityZ, 0.3, 1000, pDt);
 
        m_LagOffsetOrientation[0] = Math.SmoothCD(m_LagOffsetOrientation[0], rotDiffLS[1], m_fLagOffsetVelocityYaw, 0.3, 1000, pDt);
        m_LagOffsetOrientation[1] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[1], orientVeh[1], m_fLagOffsetVelocityPitch, 0.3, 1000, pDt);
        m_LagOffsetOrientation[2] = Math.SmoothCD(m_LagOffsetOrientation[2], rotDiffLS[0], m_fLagOffsetVelocityRoll, 0.3, 1000, pDt);
        
        vector rot;
        rot[0] = m_LagOffsetOrientation[0] * CONST_ANGULAR_LAG_YAW_STRENGTH;
        rot[1] = m_LagOffsetOrientation[1] * CONST_ANGULAR_LAG_PITCH_STRENGTH;
        rot[2] = m_LagOffsetOrientation[2] * CONST_ANGULAR_LAG_ROLL_STRENGTH;
        
        float distance = m_fDistance;
    
        if (m_CurrentCameraPitch > UP_ANGLE_CAP)    // restrict moving camera below surface level
        {
            vector clamped = GetCurrentOrientation() + rot;
            clamped[1] = UP_ANGLE_CAP;
            Math3D.YawPitchRollMatrix(clamped, pOutResult.m_CameraTM);
            
            distance = m_fDistance - (2 * Math.InverseLerp(UP_ANGLE_CAP, CONST_UD_MAX, m_CurrentCameraPitch));
            
        }
        else
            Math3D.YawPitchRollMatrix(GetCurrentOrientation() + rot, pOutResult.m_CameraTM);

        pOutResult.m_CameraTM[3] = cameraPosition - m_LagOffsetPosition;
        
        pOutResult.m_fDistance          = distance;
        pOutResult.m_fUseHeading        = 0.0;
        pOutResult.m_fInsideCamera      = 0.0;
        pOutResult.m_fIgnoreParentRoll  = 1.0;
        pOutResult.m_fIgnoreParentPitch = 1.0;
        pOutResult.m_bUpdateEveryFrame  = GetGame().IsPhysicsExtrapolationEnabled();
        
        StdFovUpdate(pDt, pOutResult);
        
        super.OnUpdate(pDt, pOutResult);
    }
 
    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;
    }

    protected   vector  m_CameraOffsetMS; 
    protected   float   m_fDistance;     
    
    protected   float   m_fUpDownAngle;           
    protected   float   m_fUpDownAngleAdd;     
    protected   float   m_fLeftRightAngle;     
    protected   float   m_fLeftRightAngleAdd;   
    
    protected   vector    m_LagOffsetPosition;
    protected   vector    m_LagOffsetOrientation;
    protected   float   m_fLagOffsetVelocityX[1];
    protected   float   m_fLagOffsetVelocityY[1];
    protected   float   m_fLagOffsetVelocityZ[1];
    protected   float   m_fLagOffsetVelocityYaw[1];
    protected   float   m_fLagOffsetVelocityPitch[1];
    protected   float   m_fLagOffsetVelocityRoll[1];
    
    protected Transport m_Transport;
}