DayZPlayerCamera_Base.c

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

float   Limit(float pV, float pMin, float pMax)
{
    if (pV >= pMin && pV <= pMax)
    {
        return pV;
    }
    else if (pV < pMin)
    {
        return pMin;
    }
    else
    {
        return pMax;
    }   
}
 
 
float fixAngle_PI_PI(float pAngle)
{
    while (pAngle > Math.PI)
    {
 
        pAngle -=  Math.PI2;
    }
 
    while (pAngle < -Math.PI)
    {
 
        pAngle +=  Math.PI2;
    }
 
    return pAngle;
}
 
float fixAngle_180_180(float pAngle)
{
    while (pAngle > 180)
    {
 
        pAngle -=  360;
    }
 
    while (pAngle < -180)
    {
 
        pAngle +=  360;
    }
 
    return pAngle;
}
 
 
enum NVTypes
{
    NONE = 0,
    NV_GOGGLES,
    NV_GOGGLES_2D,
    NV_GOGGLES_OFF,
    NV_OPTICS_ON,
    NV_OPTICS_OFF,
    NV_PUMPKIN,
    NV_OPTICS_KAZUAR_DAY,
    NV_OPTICS_KAZUAR_NIGHT,
    NV_OPTICS_STARLIGHT_DAY,
    NV_OPTICS_STARLIGHT_NIGHT,
    
    // ---- Optics condition variants ----
    NV_OPTICS_UNDERGROUND,
    NV_OPTICS_SANDSTORM_DAY,
    NV_OPTICS_SANDSTORM_NIGHT,
    NV_OPTICS_UNDERGROUND_SANDSTORM,
    
    // ---- Glasses/goggles condition variants ----
    NV_GOGGLES_DAY,
    NV_GOGGLES_UNDERGROUND,
    NV_GOGGLES_SANDSTORM,
    NV_GOGGLES_UNDERGROUND_SANDSTORM,
    
    // ---- Pumpkin condition variants ----
    NV_PUMPKIN_DAY,
    NV_PUMPKIN_UNDERGROUND,
    NV_PUMPKIN_SANDSTORM,
    NV_PUMPKIN_UNDERGROUND_SANDSTORM,
    
    MAX
}
 
class DayZPlayerCameraBase extends DayZPlayerCamera
{
    static const float  CONST_NEARPLANE_OPTICS_MIN = 0.04; //Minimal safe near plane value, artifacts on the far plane otherwise!
    const float SANDSTORM_NVG_THRESHOLD = 0.15;
    
    protected   Weapon_Base      m_weaponUsed;
    protected   ItemOptics        m_opticsUsed;
    protected   ref CameraShake      m_CameraShake;
    
    void    DayZPlayerCameraBase(DayZPlayer pPlayer, HumanInputController pInput)
    {
        m_fLRAngleVel[0] = 0;
        m_fUDAngleVel[0] = 0;
        m_fFovAbsVel[0] = 0;
        m_WeaponSwayModifier = 1;
        
        m_fFovAbsolute = GetDayZGame().GetFOVByZoomType(m_pPlayer.GetEyeZoomLevel());
        /*
        {
            int perItemCamUD = pPlayer.GetCurrentPerItemCameraUD();
            string      a   = "Per Item Camera User Data: " + perItemCamUD.ToString();
            Print(a);
        }
        */
        m_CameraPPDelay = 0;
 
        m_CommandWeapons = pPlayer.GetCommandModifier_Weapons();
        Init();
        HandleShoulderCameraOverride(pInput);
    };
    
    //disabled by default, overrides on select 3rd person cameras
    void HandleShoulderCameraOverride(HumanInputController pInput)
    {
        m_pInput.Override3rdIsRightShoulder(HumanInputControllerOverrideType.DISABLED, false);
    }
    
    void ProcessCameraShake(float delta, out float leftRight, out float upDown)
    {
        if (m_CameraShake)
        {
            float x,y;
            m_CameraShake.Update(delta, x, y);
            leftRight += x;
            upDown += y;
        }
    }
    
    void Init()
    {
        PlayerBase player = PlayerBase.Cast(m_pPlayer);
        if ( player && player.IsNVGWorking() != IsCameraNV() )
        {
            SetCameraNV(player.IsNVGWorking());
            SetCameraNVType(player.GetNVType());
        }
    }
 
    float UpdateUDAngleUnlocked(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
    {
        float target = 0.0;
        
        if (m_pInput.CameraIsTracking())    
        {
            pAngleAdd = m_pInput.GetTracking()[1] * Math.RAD2DEG;
            pAngle = target;
 
            m_fUDAngleVel[0] = 0;
        }
        else
        {
            if (m_pInput.CameraIsFreeLook())    
            {
                pAngleAdd += m_pInput.GetAimDelta(pDt)[1] * Math.RAD2DEG;
     
                m_fUDAngleVel[0] = 0;
            }
            else
            {
                target = m_CommandWeapons.GetBaseAimingAngleUD();
                pAngleAdd   = pAngle + pAngleAdd - target;
                pAngle      = target;
 
                PlayerBase player = PlayerBase.Cast(m_pPlayer);
                if (player) // handle locking of camera U/D angle movement when performing an action and not in freelook
                {       
                    float pitch = pAngle + pAngleAdd; 
                    float downLimit, upLimit, leftLimit, rightLimit;
                    player.GetLookLimits(downLimit, upLimit, leftLimit, rightLimit);
                    
                    if (pitch < (upLimit + 1) && pitch > (downLimit - 1)) // stop smoothing once within sufficiently small difference
                    {
                        pMin = downLimit;
                        pMax = upLimit;
                    }
                    else // smooth camera to locked angle, avoiding snap from the angle we started the action to the limit
                    {
                        float velMin[1] = m_fUDAngleVel;
                        pMin = Math.SmoothCD(pitch, downLimit, velMin, 0.2, 1000, pDt);
 
                        float velMax[1] = m_fUDAngleVel;
                        pMax = Math.SmoothCD(pitch, upLimit, velMax, 0.2, 1000, pDt);
                    }
                }
                
                pAngleAdd = Math.SmoothCD(pAngleAdd, 0.0, m_fUDAngleVel, 0.14, 1000, pDt);
            }
    
            if (!m_pInput.CameraIsFreeLook())
            {
                pAngle += m_pInput.GetAimDelta(pDt)[1] * Math.RAD2DEG;
            }
        }
 
        pAngle = Limit(pAngle, pMin, pMax);
        pAngleAdd = Limit(pAngle + pAngleAdd, pMin, pMax) - pAngle;
 
        return pAngle + pAngleAdd;
    }
 
    float UpdateLRAngleUnlocked(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
    {
        float target = 0;
        
        if (m_pInput.CameraIsTracking())    
        {
            pAngleAdd = m_pInput.GetTracking()[0] * Math.RAD2DEG;
            pAngle = target;
 
            m_fUDAngleVel[0] = 0;
        }
        else
        {
            if (Math.AbsFloat(pAngleAdd) > 0.001)
            {
                pAngleAdd   = pAngle + pAngleAdd - target;
                pAngle      = target;
            }
            
            if (m_pInput.CameraIsFreeLook() || m_bForceFreeLook)    
            {
                pAngleAdd += m_pInput.GetAimDelta(pDt)[0] * Math.RAD2DEG;
     
                m_fLRAngleVel[0] = 0;
            }
            else
            {
                pAngleAdd = Math.SmoothCD(pAngleAdd, 0.0, m_fLRAngleVel, 0.14, 1000, pDt);
            }
            
            pAngleAdd = pAngleAdd + pAngle;
        }
        
        pAngle = Limit(pAngle, pMin, pMax);
        pAngleAdd = Limit(pAngle + pAngleAdd, pMin, pMax) - pAngle;
        
        return pAngle + pAngleAdd;
    }
 
    float UpdateUDAngle(out float pAngle, out float pAngleAdd, float pMin, float pMax, float pDt)
    {
        if (Math.AbsFloat(pAngleAdd) > 0.001)
        {
            float aimingUDAngle = m_CommandWeapons.GetBaseAimingAngleUD();

 
            // override actual angle
            pAngleAdd   = pAngle + pAngleAdd - aimingUDAngle;
            pAngle      = aimingUDAngle;
 
            // Print("Angle: " + pAngle.ToString() + " Aim: " + actualUDAngle.ToString() );
        }

        if( m_pInput.CameraIsFreeLook() )   
        {
            pAngleAdd   += m_pInput.GetAimChange()[1] * Math.RAD2DEG;
            pAngleAdd   = Limit(pAngleAdd, pMin, pMax);
 
            m_fUDAngleVel[0]   = 0;
        }
        else
        {
            if( m_pInput.CameraIsTracking() )
            {
                pAngleAdd   = m_pInput.GetTracking()[1] * Math.RAD2DEG;
                pAngleAdd   = Limit(pAngleAdd, pMin, pMax);
 
                m_fUDAngleVel[0]   = 0;
            }
            else
            {   
                pAngle  += m_pInput.GetAimChange()[1] * Math.RAD2DEG;
                pAngle  = Limit(pAngle, pMin, pMax);
 
                pAngleAdd   = Math.SmoothCD(pAngleAdd, 0, m_fUDAngleVel, 0.14, 1000, pDt);
            }
        }
        
        /*{
            float change = m_pInput.GetAimChange()[1] * Math.RAD2DEG;
 
            Print ("Script: Camera ud angle: " +  pAngle.ToString() + " change: " + change.ToString() );
        }*/     
 
        return Limit(pAngle + pAngleAdd, pMin, pMax);
    }
 
    float UpdateLRAngle(float pAngle, float pMin, float pMax, float pDt)
    {
        if (m_pInput.CameraIsFreeLook() || m_bForceFreeLook)    
        {
            pAngle  += m_pInput.GetAimChange()[0] * Math.RAD2DEG;
            pAngle  = Limit(pAngle, pMin, pMax);
 
            m_fLRAngleVel[0]   = 0;    // reset filter
 
        }
        else
        {
            if( m_pInput.CameraIsTracking() )
            {
                pAngle = m_pInput.GetTracking()[0] * Math.RAD2DEG;
                pAngle  = Limit(-pAngle, pMin, pMax);
                
                m_fLRAngleVel[0]   = 0;    // reset filter
            }
            else
            {   
                // smooth value back to 0 
                pAngle      = Math.SmoothCD(pAngle, 0, m_fLRAngleVel, 0.14, 1000, pDt);
                // m_fLeftRightAngle    = 0.9 * (1.0 - pDt);            
            }
        }
 
        return pAngle;
    }
 
    
 
    void StdFovUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
    {
        ECameraZoomType zoomType = m_pPlayer.GetEyeZoomLevel();
        m_fFovAbsolute = Math.SmoothCD(m_fFovAbsolute, GetDayZGame().GetFOVByZoomType(zoomType), m_fFovAbsVel, 0.1, 1000, pDt);
        
        pOutResult.m_fFovAbsolute = m_fFovAbsolute;

        if (!m_pPlayer.IsShootingFromCamera())
        {
            pOutResult.m_fShootFromCamera = 0.0;
        }
    }
 
    override void SpawnCameraShakeProper(float strength, float radius, float smoothness, float radius_decay_speed)
    {
        m_CameraShake = new CameraShake(strength, radius, smoothness, radius_decay_speed);
    }   
 
    override void OnUpdate(float pDt, out DayZPlayerCameraResult pOutResult)
    {
        if (!m_pPlayer || !PlayerBase.Cast(m_pPlayer))
        {
            Debug.Log("DayZPlayerCameraBase | OnUpdate | no player!");
            return;
        }
        
        if (PlayerBase.Cast(m_pPlayer).GetCurrentCamera() != this)
        {
            //Print("DayZPlayerCameraBase | OnUpdate | unused camera! | " + this + "/" + PlayerBase.Cast(m_pPlayer).GetCurrentCamera());
            return;
        }
        
        super.OnUpdate(pDt, pOutResult);
        StdFovUpdate(pDt, pOutResult);
        UpdateCameraNV(PlayerBase.Cast(m_pPlayer));
        InitCameraOnPlayer();
    }
 
    override void OnActivate(DayZPlayerCamera pPrevCamera, DayZPlayerCameraResult pPrevCameraResult)
    {
        InitCameraOnPlayer(true);
        SetCameraPPDelay(pPrevCamera);
        
        if (DayZPlayerCameraBase.Cast(pPrevCamera) && DayZPlayerCameraBase.Cast(pPrevCamera).IsCameraNV() && !IsCameraNV())
        {
            PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_TRANSITIVE) );
        }
        
        g_Game.GetCallQueue(CALL_CATEGORY_GUI).CallLater(SetCameraPP,m_CameraPPDelay*1000,false,true,this); // this takes care of weapon/optics postprocessing
        DayZPlayerCameraOptics optic_camera;
        if (DayZPlayerCamera.CastTo(optic_camera,pPrevCamera))
        {
            g_Game.GetCallQueue(CALL_CATEGORY_GUI).Call(PlayerBase.Cast(m_pPlayer).HideClothing,null,false);
        }
    }
    
    float GetWeaponSwayModifier()
    {
        return m_WeaponSwayModifier;
    }
    
    override string GetCameraName()
    {
        return "DayZPlayerCameraBase";
    }
    
    void SetCameraPPDelay(DayZPlayerCamera pPrevCamera)
    {
    }
    
    void SetCameraNV(bool nightvision)
    {
        m_IsNightvision = nightvision;
    }
    
    bool IsCameraNV()
    {
        return m_IsNightvision;
    }
    
    void SetCameraNVType(int type)
    {
        m_NightvisionType = type;
    }
    
    int GetCameraNVType()
    {
        return m_NightvisionType;
    }
    
    void UpdateCameraNV(PlayerBase player)
    {
        if ( !player )
            return;
    
        bool nvStateChanged = player.IsNVGWorking() != IsCameraNV() || player.GetNVType() != GetCameraNVType();
    
        // Re-resolve every tick so the effective variant follows the player between
        // surface / tunnel / sandstorm without needing to toggle the NVG off and on.
        // Only triggers a re-apply when the resolved variant actually differs, so a
        // stable environment causes no extra SetCameraPP calls.
        bool envChanged = IsCameraNV() && ResolveNVType(player.GetNVType(), player) != m_ResolvedNVType;
    
        if ( nvStateChanged || envChanged )
        {
            SetCameraNV(player.IsNVGWorking());
            SetCameraNVType(player.GetNVType());
            SetCameraPP(true, this);   // SetCameraPP re-resolves and stores m_ResolvedNVType
        }
    }
    
    void SetCameraPP(bool state, DayZPlayerCamera launchedFrom)
    {
        PPERequesterBank.GetRequester(PPERequester_CameraADS).Stop();
    
        if (IsCameraNV())
        {
            // Resolve the raw NV type to its underground / sandstorm variant before applying.
            int resolvedType = ResolveNVType(GetCameraNVType(), PlayerBase.Cast(m_pPlayer));
            m_ResolvedNVType = resolvedType;
            SetNVPostprocess(resolvedType);
        }
        else
        {
            m_ResolvedNVType = NVTypes.NONE;
            SetNVPostprocess(NVTypes.NONE);
        }
    
        m_weaponUsed = Weapon_Base.Cast(m_pPlayer.GetEntityInHands());
        if (m_weaponUsed)
        {
            m_weaponUsed.HideWeaponBarrel(false);
        }
    }
    
    override float GetCurrentYaw()
    {
        return m_CurrentCameraYaw;
    }
    
    override float GetCurrentPitch()
    {
        return m_CurrentCameraPitch;
    }
    
    override float GetCurrentRoll()
    {
        return m_CurrentCameraRoll;
    }
    
    void ForceFreelook(bool state)
    {
        m_bForceFreeLook = state;
    }
    
    //TODO - better handling of distinct occluder types
    void SetNVPostprocess(int NVtype)
    {
        //remove ALL conflicting NV occluders first
        Mission mission = g_Game.GetMission();
        if (mission && mission.GetEffectWidgets())
            mission.GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER,EffectWidgetsTypes.PUMPKIN_OCCLUDER});
        
        switch (NVtype)
        {
            case NVTypes.NONE:
            {
                PPERequesterBank.GetRequester(PPERequester_CameraNV).Stop();
            }
            break;
            
            //night-vision modes
            case NVTypes.NV_OPTICS_KAZUAR_NIGHT:
            case NVTypes.NV_OPTICS_STARLIGHT_NIGHT:
            case NVTypes.NV_OPTICS_ON:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DEFAULT_OPTICS) );
            }
            break;
            
            //daytime filter modes
            case NVTypes.NV_OPTICS_KAZUAR_DAY:
            case NVTypes.NV_OPTICS_STARLIGHT_DAY:
            case NVTypes.NV_OPTICS_SANDSTORM_DAY:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DAYTIME_OPTICS) );
            }
            break;
            
            case NVTypes.NV_GOGGLES_OFF:
            case NVTypes.NV_OPTICS_OFF:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_NO_BATTERY) );
            }
            break;
            
            case NVTypes.NV_GOGGLES:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DEFAULT_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
            
            case NVTypes.NV_GOGGLES_2D:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DEFAULT_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
            
            case NVTypes.NV_PUMPKIN:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_PUMPKIN) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
            }
            break;
            
            // ====================== OPTICS condition variants ======================
            case NVTypes.NV_OPTICS_UNDERGROUND:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_OPTICS) );
            }
            break;
    
            case NVTypes.NV_OPTICS_SANDSTORM_NIGHT:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_SANDSTORM_OPTICS) );
            }
            break;
    
            case NVTypes.NV_OPTICS_UNDERGROUND_SANDSTORM:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_SANDSTORM_OPTICS) );
            }
            break;
    
            // ====================== GLASSES condition variants =====================
            case NVTypes.NV_GOGGLES_DAY:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DAYTIME_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_GOGGLES_UNDERGROUND:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_GOGGLES_SANDSTORM:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_SANDSTORM_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_GOGGLES_UNDERGROUND_SANDSTORM:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_SANDSTORM_GLASSES) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.NVG_OCCLUDER});
            }
            break;
    
            // ====================== PUMPKIN condition variants =====================
            case NVTypes.NV_PUMPKIN_DAY:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_DAYTIME_PUMPKIN) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_PUMPKIN_UNDERGROUND:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_PUMPKIN) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_PUMPKIN_SANDSTORM:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_SANDSTORM_PUMPKIN) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
            }
            break;
    
            case NVTypes.NV_PUMPKIN_UNDERGROUND_SANDSTORM:
            {
                PPERequesterBank.GetRequester(PPERequesterBank.REQ_CAMERANV).Start( new Param1<int>(PPERequester_CameraNV.NV_UNDERGROUND_SANDSTORM_PUMPKIN) );
                if (mission && mission.GetEffectWidgets())
                    mission.GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.PUMPKIN_OCCLUDER});
            }
            break;
        }
        
        if (PlayerBaseClient.Cast(m_pPlayer))
        {
            PlayerBaseClient.Cast(m_pPlayer).SwitchPersonalLight(NVtype < 1);
        }
    }
    
    void InitCameraOnPlayer(bool force = false)
    {
        PlayerBase player = PlayerBase.Cast(m_pPlayer);
        if (!player.GetCurrentPlayerCamera() || (force && player.GetCurrentPlayerCamera() != this))
        {
            player.OnCameraChanged(this);
        }
    }
    
    int ResolveNVType(int rawType, PlayerBase player)
    {
        if (!player)
            return rawType;
    
        // Only the generic "device is on" states get environment upgrades. OFF states,
        // NONE, and the explicit Kazuar/Starlight day/night variants keep their own handling.
        bool isOpticsOn = (rawType == NVTypes.NV_OPTICS_ON || rawType == NVTypes.NV_OPTICS_KAZUAR_DAY || rawType == NVTypes.NV_OPTICS_KAZUAR_NIGHT || rawType == NVTypes.NV_OPTICS_STARLIGHT_DAY || rawType == NVTypes.NV_OPTICS_STARLIGHT_NIGHT);
        bool isGogglesOn = (rawType == NVTypes.NV_GOGGLES || rawType == NVTypes.NV_GOGGLES_2D);
        bool isPumpkinOn = (rawType == NVTypes.NV_PUMPKIN);
        
        if (!isOpticsOn && !isGogglesOn && !isPumpkinOn)
            return rawType;
        
        bool underground = IsPlayerUnderground(player);
        bool sandstorm   = IsSandstormActiveForPlayer(player);
        
        
        // Nothing special about the environment -> keep the raw type.
        if (!underground && !sandstorm)
            return rawType;
    
        if (isOpticsOn)
        {
            bool isNight = (rawType == NVTypes.NV_OPTICS_ON || rawType == NVTypes.NV_OPTICS_KAZUAR_NIGHT || rawType == NVTypes.NV_OPTICS_STARLIGHT_NIGHT);
            if (underground && sandstorm)
            {
                return NVTypes.NV_OPTICS_UNDERGROUND_SANDSTORM;
            }
            
            if (underground)
            {
                return NVTypes.NV_OPTICS_UNDERGROUND;
            }
            
            if (isNight)
                return NVTypes.NV_OPTICS_SANDSTORM_NIGHT;
            return NVTypes.NV_OPTICS_SANDSTORM_DAY;
        }
    
        if (isGogglesOn)
        {
            if (underground && sandstorm) 
                return NVTypes.NV_GOGGLES_UNDERGROUND_SANDSTORM;
            if (underground)              
                return NVTypes.NV_GOGGLES_UNDERGROUND;
            return NVTypes.NV_GOGGLES_SANDSTORM;
        }
    
        // isPumpkinOn
        if (underground && sandstorm)
            return NVTypes.NV_PUMPKIN_UNDERGROUND_SANDSTORM;
        if (underground)              
            return NVTypes.NV_PUMPKIN_UNDERGROUND;
        return NVTypes.NV_PUMPKIN_SANDSTORM;
    }
    
    bool IsPlayerUnderground(PlayerBase player)
    {
        if (!player)
            return false;
    
        // Prefer a dedicated check if available:
        //   return player.IsUnderground();
        // Fallback using the roof/shadow signals shown on the debug overlay:
        return player.GetUndergroundPresence() != EUndergroundPresence.NONE;
    }
    
    bool IsSandstormActiveForPlayer(PlayerBase player)
    {
        if (!player || !g_Game)
            return false;
    
        Weather weather = g_Game.GetWeather();
        if (!weather)
            return false;
    
        ScriptedSandstormController sandstorm = ScriptedSandstormController.Cast(weather.GetSandstorm());
        if (!sandstorm || !sandstorm.IsActive())
            return false;
        
        float intensity = sandstorm.GetIntensity(player.GetPosition());
        return intensity > SANDSTORM_NVG_THRESHOLD;
    }
    
    protected float                 m_fLRAngleVel[1];
    protected float                 m_fUDAngleVel[1];
    protected float                 m_fFovAbsVel[1];
    protected float                 m_fFovAbsolute;
    protected bool                  m_bForceFreeLook;
    protected float                 m_WeaponSwayModifier;
    protected float                 m_CameraPPDelay;
 
    protected float                 m_CurrentCameraYaw;
    protected float                 m_CurrentCameraPitch;
    protected float                 m_CurrentCameraRoll;
 
    protected HumanCommandWeapons    m_CommandWeapons;
    protected bool                  m_IsNightvision;
    protected int                   m_NightvisionType;
    protected int                   m_ResolvedNVType; 
}