OnUpdate()

override void DayZPlayerCamera3rdPersonVehicleMotorbike::OnUpdate ( float pDt, out DayZPlayerCameraResult pOutResult )

inlineprotected

get player transform

update camera offset

orientation LS

create LS lag from vehicle velocities

smooth it!

setup orientation

setup position

setup rest

get vehicle and set it as ignore entity for camera collision solver

См. определение в файле DayZPlayerCameraVehicles.c строка 320

    {
        vector playerTransformWS[4];
        m_pPlayer.GetTransform(playerTransformWS);

        vector cameraPosition = vector.Zero;
        if (m_Transport)
        {
            vector vehiclePositionWS = m_Transport.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 rotWS = m_pPlayer.GetOrientation();
        rotWS = rotWS * Math.DEG2RAD;
        rotWS[2] = 0;
        
        vector velocity = GetVelocity(m_Transport);
        
        if (m_Transport)
        {
            vector posDiffWS = velocity * CONST_LINEAR_VELOCITY_STRENGTH;
            posDiffLS = posDiffLS + posDiffWS.InvMultiply3(playerTransformWS);
 
            vector rotDiffWS = dBodyGetAngularVelocity(m_Transport) * CONST_ANGULAR_VELOCITY_STRENGTH;
            rotDiffLS = rotDiffLS + rotDiffWS.InvMultiply3(playerTransformWS);
            
            vector tempRot1 = rotDiffLS;
            rotDiffLS[0] = tempRot1[1];
            rotDiffLS[1] = tempRot1[2];
            rotDiffLS[2] = tempRot1[0];
            
            rotWS[0] = rotWS[0] + rotDiffLS[0];
            rotWS[1] = rotWS[1] + rotDiffLS[1];
            rotWS[2] = rotWS[2] + rotDiffLS[2];
        }       
            
        m_LagOffsetPosition[0] = Math.SmoothCD(m_LagOffsetPosition[0], posDiffLS[0], m_fLagOffsetVelocityX, CONST_SPRING_SMOOTHTIME_POS_X, 1000, pDt);
        m_LagOffsetPosition[1] = Math.SmoothCD(m_LagOffsetPosition[1], posDiffLS[1], m_fLagOffsetVelocityY, CONST_SPRING_SMOOTHTIME_POS_Y, 1000, pDt);
        m_LagOffsetPosition[2] = Math.SmoothCD(m_LagOffsetPosition[2], posDiffLS[2], m_fLagOffsetVelocityZ, CONST_SPRING_SMOOTHTIME_POS_Z, 1000, pDt);
 
        m_LagOffsetOrientation[0] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[0], rotWS[0], m_fLagOffsetVelocityYaw, CONST_SPRING_SMOOTHTIME_YAW, 1000, pDt);
        m_LagOffsetOrientation[1] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[1], rotWS[1], m_fLagOffsetVelocityPitch, CONST_SPRING_SMOOTHTIME_PITCH, 1000, pDt);
        m_LagOffsetOrientation[2] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[2], rotWS[2], m_fLagOffsetVelocityRoll, CONST_SPRING_SMOOTHTIME_ROLL, 1000, pDt);
        
        vector rot = m_LagOffsetOrientation * Math.RAD2DEG;
        if (m_Transport)
        {
            vector rotTM[3];
            Math3D.YawPitchRollMatrix(rot, rotTM);
            
            Math3D.MatrixInvMultiply3(playerTransformWS, rotTM, rotTM);
            
            vector tempRot = Math3D.MatrixToAngles(rotTM);
            float lagYaw = tempRot[0];
            if (lagYaw > 180.0)
                lagYaw -= 360.0; // normalize to [-180,180]
            rot[0] = -lagYaw * CONST_YAW_LAG_REVERSE; // reverse + dampen the yaw lag swing
        }
        
        rot[0] = rot[0] * (1.0 + (Math.InverseLerp(0.0, 1.0 + CONST_ANGULAR_LAG_YAW_STRENGTH, Math.AbsFloat(rotDiffLS[0])) * CONST_ANGULAR_LAG_YAW_STRENGTH));
        rot[1] = rot[1] * (1.0 + (Math.InverseLerp(0.0, 1.0 + CONST_ANGULAR_LAG_PITCH_STRENGTH, Math.AbsFloat(rotDiffLS[1])) * CONST_ANGULAR_LAG_PITCH_STRENGTH));
        rot[2] = rot[2] * (1.0 + (Math.InverseLerp(0.0, 1.0 + CONST_ANGULAR_LAG_ROLL_STRENGTH, Math.AbsFloat(rotDiffLS[2])) * CONST_ANGULAR_LAG_ROLL_STRENGTH));
                
        rot = GetCurrentOrientation() + rot;
        
        float distance = m_fDistance;        
        distance -= (2 * Math.Clamp(Math.InverseLerp(UP_ANGLE_CAP * 0.5, CONST_UD_MAX, rot[1]), 0, 1));
        
        if (rot[1] > UP_ANGLE_CAP)
        {
            rot[1] = UP_ANGLE_CAP;
        }
        
        Math3D.YawPitchRollMatrix(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_fIgnoreParentYaw   = 0.0;
        pOutResult.m_bUpdateEveryFrame  = g_Game.IsPhysicsExtrapolationEnabled();
        
        pOutResult.m_CollisionIgnoreEntity = m_Transport;
        pOutResult.m_fPredictCollisionRadius = 1.0;
        
        StdFovUpdate(pDt, pOutResult);
        
        super.OnUpdate(pDt, pOutResult);
    }

Перекрестные ссылки Math::AbsFloat(), Math::Clamp(), CONST_ANGULAR_LAG_PITCH_STRENGTH, CONST_ANGULAR_LAG_ROLL_STRENGTH, CONST_ANGULAR_LAG_YAW_STRENGTH, CONST_ANGULAR_VELOCITY_STRENGTH, CONST_LINEAR_VELOCITY_STRENGTH, CONST_LR_MAX, CONST_LR_MIN, CONST_SPRING_SMOOTHTIME_PITCH, CONST_SPRING_SMOOTHTIME_POS_X, CONST_SPRING_SMOOTHTIME_POS_Y, CONST_SPRING_SMOOTHTIME_POS_Z, CONST_SPRING_SMOOTHTIME_ROLL, CONST_SPRING_SMOOTHTIME_YAW, CONST_UD_MAX, CONST_UD_MIN, CONST_YAW_LAG_REVERSE, dBodyGetAngularVelocity(), Math::DEG2RAD, g_Game, GetCurrentOrientation(), GetVelocity(), Math::InverseLerp(), vector::InvMultiply3(), vector::InvMultiply4(), m_CameraOffsetMS, m_CurrentCameraPitch, m_CurrentCameraRoll, m_CurrentCameraYaw, m_fDistance, m_fLagOffsetVelocityPitch, m_fLagOffsetVelocityRoll, m_fLagOffsetVelocityX, m_fLagOffsetVelocityY, m_fLagOffsetVelocityYaw, m_fLagOffsetVelocityZ, m_fLeftRightAngle, m_fLeftRightAngleAdd, m_fUpDownAngle, m_fUpDownAngleAdd, m_LagOffsetOrientation, m_LagOffsetPosition, m_pPlayer, m_Transport, Math3D::MatrixInvMultiply3(), Math3D::MatrixToAngles(), Math::RAD2DEG, Math::SmoothCD(), Math::SmoothCDPI2PI(), StdFovUpdate(), UP_ANGLE_CAP, UpdateLRAngleUnlocked(), UpdateUDAngleUnlocked(), Math3D::YawPitchRollMatrix() и vector::Zero.