OnUpdate()

override void OnUpdate	(	float	pDt,
		out DayZPlayerCameraResult	pOutResult )

get player transform

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

update camera offset

orientation LS

create LS lag from vehicle velocities

smooth it!

setup orientation

setup position

setup rest

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

    {
        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 rotWS = m_pPlayer.GetOrientation();
        rotWS = rotWS * Math.DEG2RAD;
        rotWS[2] = 0;
        
        vector velocity = GetVelocity(vehicle);
        
        if (vehicle)
        {
            vector posDiffWS = velocity * CONST_LINEAR_VELOCITY_STRENGTH;
            posDiffLS = posDiffLS + posDiffWS.InvMultiply3(playerTransformWS);
 
            vector rotDiffWS = dBodyGetAngularVelocity(vehicle) * 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, 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.SmoothCDPI2PI(m_LagOffsetOrientation[0], rotWS[0], m_fLagOffsetVelocityYaw, 0.3, 1000, pDt);
        m_LagOffsetOrientation[1] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[1], rotWS[1], m_fLagOffsetVelocityPitch, 0.3, 1000, pDt);
        m_LagOffsetOrientation[2] = Math.SmoothCDPI2PI(m_LagOffsetOrientation[2], rotWS[2], m_fLagOffsetVelocityRoll, 0.3, 1000, pDt);
        
        vector rot = m_LagOffsetOrientation * Math.RAD2DEG;
        if (vehicle)
        {
            vector rotTM[3];
            Math3D.YawPitchRollMatrix(rot, rotTM);
            
            Math3D.MatrixInvMultiply3(playerTransformWS, rotTM, rotTM);
            
            // because we don't have m_fIgnoreParentYaw set
            vector tempRot = Math3D.MatrixToAngles(rotTM);
            rot[0] = tempRot[0];
        }
        
        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();
        
        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_UD_MAX, CONST_UD_MIN, dBodyGetAngularVelocity(), Math::DEG2RAD, g_Game, GetCurrentOrientation(), IEntity::GetOrigin(), 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.