fr.jeanf.universal.player 0.8.20 → 0.8.22

package/Runtime/Prefabs/Player.prefab

@@ -1259,7 +1259,7 @@ Canvas:
   serializedVersion: 3
   m_RenderMode: 1
   m_Camera: {fileID: 0}
-  m_PlaneDistance: 0.1
+  m_PlaneDistance: 0.15
   m_PixelPerfect: 0
   m_ReceivesEvents: 1
   m_OverrideSorting: 0

package/Runtime/scripts/Fade/FadeMask.cs

@@ -4,7 +4,8 @@ using jeanf.EventSystem;
 using UnityEngine.Serialization;
 using UnityEngine.Rendering;
 using LitMotion;
-using UnityEngine.Rendering.HighDefinition;
+using System;
+using System.Linq;
 using Volume = UnityEngine.Rendering.Volume;
 
 namespace jeanf.universalplayer
@@ -38,11 +39,14 @@ namespace jeanf.universalplayer
         private static Material _shaderMaterial;
         private static bool _isFaded = false;
 
-        [SerializeField] private VolumeProfile HDRPVolumeProfile;
-        [SerializeField] private VolumeProfile URPVolumeProfile;
+        [Header("Volume Profiles - Only assign the one for your current pipeline")]
+        [SerializeField] private VolumeProfile volumeProfile;
         [SerializeField] private Volume postProcessVolume;
         private static Volume staticPostProcessVolume;
-        private static ColorAdjustments colorAdjustments;
+        
+        // Use objects to handle both URP and HDRP ColorAdjustments via reflection
+        private static object hdrpColorAdjustments;
+        private static object urpColorAdjustments;
 
         private static MotionHandle _fadeHandle;
         private static bool _isCurrentlyFading = false;
@@ -55,27 +59,231 @@ namespace jeanf.universalplayer
 
         public static TogglePpeDelegate TogglePPE;
 
+        // Pipeline detection
+        private enum RenderPipeline
+        {
+            BuiltIn,
+            URP,
+            HDRP,
+            Unknown
+        }
+
+        private static RenderPipeline _currentPipeline = RenderPipeline.Unknown;
 
         private void Awake()
         {
-            if (GraphicsSettings.defaultRenderPipeline == null) return;
+            DetectRenderPipeline();
+            SetupVolumeProfile();
+            SetVolumeTo_InitialSetup();
+            FadeValue(false, .5f);
+        }
+
+        private void DetectRenderPipeline()
+        {
+            if (GraphicsSettings.defaultRenderPipeline == null)
+            {
+                _currentPipeline = RenderPipeline.BuiltIn;
+                return;
+            }
+
             var renderingAssetType = GraphicsSettings.defaultRenderPipeline.GetType().ToString();
+            
             if (renderingAssetType.Contains("HDRenderPipelineAsset"))
             {
-                postProcessVolume.profile = HDRPVolumeProfile;
-                postProcessVolume.blendDistance = 10.0f;
+                _currentPipeline = RenderPipeline.HDRP;
             }
             else if (renderingAssetType.Contains("UniversalRenderPipelineAsset"))
             {
-                postProcessVolume.profile = URPVolumeProfile;
+                _currentPipeline = RenderPipeline.URP;
+            }
+            else
+            {
+                _currentPipeline = RenderPipeline.Unknown;
+            }
+
+            if (_isDebugSTATIC) Debug.Log($"FadeMask: Detected render pipeline: {_currentPipeline}");
+        }
+
+        private void SetupVolumeProfile()
+        {
+            if (postProcessVolume == null)
+            {
+                if (_isDebugSTATIC) Debug.LogError("FadeMask: postProcessVolume is not assigned!");
+                return;
+            }
+
+            // Use the assigned volume profile if available
+            if (volumeProfile != null)
+            {
+                postProcessVolume.profile = volumeProfile;
+            }
+            else if (postProcessVolume.profile == null)
+            {
+                if (_isDebugSTATIC) Debug.LogError("FadeMask: No volume profile assigned and postProcessVolume has no profile!");
+                return;
+            }
+
+            // Handle built-in pipeline
+            if (_currentPipeline == RenderPipeline.BuiltIn)
+            {
+                if (_isDebugSTATIC) Debug.LogWarning("FadeMask: Built-in pipeline detected. Volume system may not be available.");
+                return;
             }
 
+            // Set blend distance (same for all pipelines that support volumes)
+            postProcessVolume.blendDistance = 10.0f;
+
             staticPostProcessVolume = postProcessVolume;
-            staticPostProcessVolume.profile.TryGet<ColorAdjustments>(out colorAdjustments);
+            
+            // Try to get ColorAdjustments component based on current pipeline
+            if (!TryGetColorAdjustments())
+            {
+                if (_isDebugSTATIC) Debug.LogError("FadeMask: ColorAdjustments component not found in volume profile!");
+            }
+        }
 
-            SetVolumeTo_InitialSetup();
+        private bool TryGetColorAdjustments()
+        {
+            try
+            {
+                switch (_currentPipeline)
+                {
+                    case RenderPipeline.HDRP:
+                        return TryGetHDRPColorAdjustments();
+                    
+                    case RenderPipeline.URP:
+                        return TryGetURPColorAdjustments();
+                        
+                    default:
+                        if (_isDebugSTATIC) Debug.LogError($"FadeMask: Unsupported pipeline: {_currentPipeline}");
+                        break;
+                }
+                
+                return false;
+            }
+            catch (Exception e)
+            {
+                if (_isDebugSTATIC) Debug.LogError($"FadeMask: Error getting ColorAdjustments: {e.Message}");
+                return false;
+            }
+        }
 
-            FadeValue(false, .5f);
+        private bool TryGetHDRPColorAdjustments()
+        {
+            try
+            {
+                // Find HDRP ColorAdjustments type
+                System.Type hdrpColorAdjustmentsType = System.Type.GetType("UnityEngine.Rendering.HighDefinition.ColorAdjustments, Unity.RenderPipelines.HighDefinition.Runtime");
+                
+                // Fallback: search through loaded assemblies
+                if (hdrpColorAdjustmentsType == null)
+                {
+                    foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
+                    {
+                        if (assembly.GetName().Name.Contains("HighDefinition"))
+                        {
+                            hdrpColorAdjustmentsType = assembly.GetType("UnityEngine.Rendering.HighDefinition.ColorAdjustments");
+                            if (hdrpColorAdjustmentsType != null) break;
+                        }
+                    }
+                }
+                
+                if (hdrpColorAdjustmentsType == null)
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: HDRP ColorAdjustments type not found.");
+                    return false;
+                }
+                
+                // Use reflection to call TryGet<T> method
+                var profileType = staticPostProcessVolume.profile.GetType();
+                var tryGetMethods = profileType.GetMethods().Where(m => m.Name == "TryGet" && m.IsGenericMethodDefinition).ToArray();
+                
+                if (tryGetMethods.Length == 0)
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: No generic TryGet methods found on VolumeProfile");
+                    return false;
+                }
+                
+                var tryGetMethod = tryGetMethods[0].MakeGenericMethod(hdrpColorAdjustmentsType);
+                var parameters = new object[] { null };
+                var result = (bool)tryGetMethod.Invoke(staticPostProcessVolume.profile, parameters);
+                
+                if (result)
+                {
+                    hdrpColorAdjustments = parameters[0];
+                    if (_isDebugSTATIC) Debug.Log("FadeMask: Successfully got HDRP ColorAdjustments");
+                    return true;
+                }
+                else
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: Failed to get HDRP ColorAdjustments from volume profile");
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
+                if (_isDebugSTATIC) Debug.LogError($"FadeMask: Error getting HDRP ColorAdjustments: {e.Message}");
+                return false;
+            }
+        }
+
+        private bool TryGetURPColorAdjustments()
+        {
+            try
+            {
+                // Find URP ColorAdjustments type
+                System.Type urpColorAdjustmentsType = System.Type.GetType("UnityEngine.Rendering.Universal.ColorAdjustments, Unity.RenderPipelines.Universal.Runtime");
+                
+                // Fallback: search through loaded assemblies
+                if (urpColorAdjustmentsType == null)
+                {
+                    foreach (var assembly in System.AppDomain.CurrentDomain.GetAssemblies())
+                    {
+                        if (assembly.GetName().Name.Contains("Universal"))
+                        {
+                            urpColorAdjustmentsType = assembly.GetType("UnityEngine.Rendering.Universal.ColorAdjustments");
+                            if (urpColorAdjustmentsType != null) break;
+                        }
+                    }
+                }
+                
+                if (urpColorAdjustmentsType == null)
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: URP ColorAdjustments type not found.");
+                    return false;
+                }
+                
+                // Use reflection to call TryGet<T> method
+                var profileType = staticPostProcessVolume.profile.GetType();
+                var tryGetMethods = profileType.GetMethods().Where(m => m.Name == "TryGet" && m.IsGenericMethodDefinition).ToArray();
+                
+                if (tryGetMethods.Length == 0)
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: No generic TryGet methods found on VolumeProfile");
+                    return false;
+                }
+                
+                var tryGetMethod = tryGetMethods[0].MakeGenericMethod(urpColorAdjustmentsType);
+                var parameters = new object[] { null };
+                var result = (bool)tryGetMethod.Invoke(staticPostProcessVolume.profile, parameters);
+                
+                if (result)
+                {
+                    urpColorAdjustments = parameters[0];
+                    if (_isDebugSTATIC) Debug.Log("FadeMask: Successfully got URP ColorAdjustments");
+                    return true;
+                }
+                else
+                {
+                    if (_isDebugSTATIC) Debug.LogError("FadeMask: Failed to get URP ColorAdjustments from volume profile");
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
+                if (_isDebugSTATIC) Debug.LogError($"FadeMask: Error getting URP ColorAdjustments: {e.Message}");
+                return false;
+            }
         }
 
         private void OnEnable() => Subscribe();
@@ -86,15 +294,17 @@ namespace jeanf.universalplayer
         {
             inputBinding.Enable();
             inputBinding.performed += _ => SwitchFadeState();
-            fadeOutChannelSO.OnEventRaised += FadeValue;
+            if (fadeOutChannelSO != null)
+                fadeOutChannelSO.OnEventRaised += FadeValue;
             TogglePPE += ChangePostProcessing;
         }
 
         private void Unsubscribe()
         {
-            if (_shaderMaterial)_shaderMaterial.SetColor(FadeColor, color);
+            if (_shaderMaterial) _shaderMaterial.SetColor(FadeColor, color);
             inputBinding.performed -= null;
-            fadeOutChannelSO.OnEventRaised -= FadeValue;
+            if (fadeOutChannelSO != null)
+                fadeOutChannelSO.OnEventRaised -= FadeValue;
             inputBinding.Disable();
             DisableFadeHandle();
             TogglePPE -= ChangePostProcessing;
@@ -102,18 +312,149 @@ namespace jeanf.universalplayer
 
         public static void SetVolumeTo_InitialSetup()
         {
-            colorAdjustments.colorFilter.value = Color.black;
-            colorAdjustments.saturation.value = 0;
+            if (_isDebugSTATIC) Debug.Log($"FadeMask: Setting initial setup for {_currentPipeline}");
+            
+            switch (_currentPipeline)
+            {
+                case RenderPipeline.HDRP:
+                    if (hdrpColorAdjustments != null)
+                    {
+                        SetColorAdjustmentProperty(hdrpColorAdjustments, "colorFilter", Color.black);
+                        SetColorAdjustmentProperty(hdrpColorAdjustments, "saturation", 0f);
+                    }
+                    else if (_isDebugSTATIC) Debug.LogWarning("FadeMask: HDRP ColorAdjustments is null.");
+                    break;
+                
+                case RenderPipeline.URP:
+                    if (urpColorAdjustments != null)
+                    {
+                        SetColorAdjustmentProperty(urpColorAdjustments, "colorFilter", Color.black);
+                        SetColorAdjustmentProperty(urpColorAdjustments, "saturation", 0f);
+                    }
+                    else if (_isDebugSTATIC) Debug.LogWarning("FadeMask: URP ColorAdjustments is null.");
+                    break;
+                
+                default:
+                    if (_isDebugSTATIC) Debug.LogWarning($"FadeMask: Cannot set initial setup for pipeline: {_currentPipeline}");
+                    break;
+            }
         }
+
         public static void SetVolumeTo_HeadInWallSetup()
         {
-            colorAdjustments.colorFilter.value = Color.white;
-            colorAdjustments.saturation.value = -100;
+            if (_isDebugSTATIC) Debug.Log($"FadeMask: Setting head in wall setup for {_currentPipeline}");
+            
+            switch (_currentPipeline)
+            {
+                case RenderPipeline.HDRP:
+                    if (hdrpColorAdjustments != null)
+                    {
+                        SetColorAdjustmentProperty(hdrpColorAdjustments, "colorFilter", Color.white);
+                        SetColorAdjustmentProperty(hdrpColorAdjustments, "saturation", -100f);
+                    }
+                    else if (_isDebugSTATIC) Debug.LogWarning("FadeMask: HDRP ColorAdjustments is null.");
+                    break;
+                
+                case RenderPipeline.URP:
+                    if (urpColorAdjustments != null)
+                    {
+                        SetColorAdjustmentProperty(urpColorAdjustments, "colorFilter", Color.white);
+                        SetColorAdjustmentProperty(urpColorAdjustments, "saturation", -100f);
+                    }
+                    else if (_isDebugSTATIC) Debug.LogWarning("FadeMask: URP ColorAdjustments is null.");
+                    break;
+                
+                default:
+                    if (_isDebugSTATIC) Debug.LogWarning($"FadeMask: Cannot set head in wall setup for pipeline: {_currentPipeline}");
+                    break;
+            }
+        }
+
+        private static void SetColorAdjustmentProperty(object colorAdjustments, string propertyName, object value)
+        {
+            if (colorAdjustments == null) return;
+
+            try
+            {
+                var colorAdjustmentsType = colorAdjustments.GetType();
+                var parametersProperty = colorAdjustmentsType.GetProperty("parameters");
+                if (parametersProperty == null) return;
+                
+                var parameters = parametersProperty.GetValue(colorAdjustments);
+                if (parameters == null) return;
+                
+                var parametersEnumerable = parameters as System.Collections.IEnumerable;
+                if (parametersEnumerable == null) return;
+                
+                var parametersList = new System.Collections.Generic.List<object>();
+                foreach (var param in parametersEnumerable)
+                {
+                    if (param != null) parametersList.Add(param);
+                }
+                
+                object targetParameter = null;
+                
+                if (propertyName == "colorFilter")
+                {
+                    // Find ColorParameter
+                    foreach (var param in parametersList)
+                    {
+                        if (param.GetType().Name == "ColorParameter")
+                        {
+                            targetParameter = param;
+                            break;
+                        }
+                    }
+                }
+                else if (propertyName == "saturation")
+                {
+                    // Find saturation parameter - typically index 4 or by range check
+                    if (parametersList.Count > 4 && parametersList[4].GetType().Name == "ClampedFloatParameter")
+                    {
+                        targetParameter = parametersList[4];
+                    }
+                    else
+                    {
+                        // Fallback: find ClampedFloatParameter with range -100 to 100
+                        foreach (var param in parametersList)
+                        {
+                            if (param.GetType().Name == "ClampedFloatParameter")
+                            {
+                                var paramType = param.GetType();
+                                var minProp = paramType.GetProperty("min");
+                                var maxProp = paramType.GetProperty("max");
+                                if (minProp?.GetValue(param)?.ToString() == "-100" && 
+                                    maxProp?.GetValue(param)?.ToString() == "100")
+                                {
+                                    targetParameter = param;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                
+                if (targetParameter != null)
+                {
+                    var parameterType = targetParameter.GetType();
+                    var valueProperty = parameterType.GetProperty("value");
+                    
+                    if (valueProperty != null)
+                    {
+                        valueProperty.SetValue(targetParameter, value);
+                        if (_isDebugSTATIC) Debug.Log($"FadeMask: Set {propertyName} to {value}");
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                if (_isDebugSTATIC) Debug.LogError($"FadeMask: Error setting {propertyName}: {e.Message}");
+            }
         }
 
         private void Update()
         {
-            if(!checkForDebugChangeState) return;
+            if (!checkForDebugChangeState) return;
             _isDebugSTATIC = _isDebug;
         }
 
@@ -127,16 +468,15 @@ namespace jeanf.universalplayer
         {
             SetVolumeTo_InitialSetup();
             
-            if(!isInitComplete)return;
+            if (!isInitComplete) return;
 
             SetVolumeTo_HeadInWallSetup();
         }
-        
 
         public static void FadeValue(bool value)
         {
             FadeValue(value, _fadeTime);
-            if (_isDebugSTATIC) Debug.Log($"Fading to: {value}, in {_fadeTime}");
+            if (_isDebugSTATIC) Debug.Log($"FadeMask: Fading to {value} in {_fadeTime}s");
         }
 
         public static void FadeValue(bool value, float fadeTime)
@@ -152,7 +492,7 @@ namespace jeanf.universalplayer
             if (_isCurrentlyFading && _targetState == value)
                 return;
 
-            if (_isDebugSTATIC) Debug.Log($"Fading to: {value}, in {fadeTime}s");
+            if (_isDebugSTATIC) Debug.Log($"FadeMask: Fading to {value} in {fadeTime}s");
 
             // Only cancel if the handle is valid and active
             if (_fadeHandle.IsActive())
@@ -176,5 +516,13 @@ namespace jeanf.universalplayer
             _fadeHandle.Complete();
             _fadeHandle.Cancel();
         }
+
+        private void OnValidate()
+        {
+            if (postProcessVolume == null)
+            {
+                Debug.LogWarning("FadeMask: postProcessVolume is not assigned!");
+            }
+        }
     }
 }

package/Runtime/scripts/HandInteraction/GetPrimaryInHandItemWithVRController.cs

@@ -168,7 +168,7 @@ namespace jeanf.universalplayer
             else
             {
                 _ipadState = IpadState.Disabled;
-                _PrimaryItemStateChannel.RaiseEvent(false);
+                //_PrimaryItemStateChannel.RaiseEvent(false);
                 OnIpadStateChanged.Invoke(_ipadState);
                 if(_rightHandPoseManager) _rightHandPoseManager.ApplyDefaultPose();
             }

package/Runtime/scripts/jeanf.universalplayer.asmdef

@@ -6,15 +6,14 @@
         "GUID:68550284b645f4b9894995579f34290a",
         "GUID:fe685ec1767f73d42b749ea8045bfe43",
         "GUID:24e442f89618c5d4cad09e3d635b003b",
-        "GUID:457756d89b35d2941b3e7b37b4ece6f1",
         "GUID:e40ba710768534012815d3193fa296cb",
         "GUID:dc960734dc080426fa6612f1c5fe95f3",
         "GUID:ce522b6ed64c8be4c989a1d26d0e3275",
         "GUID:e134609276952144282613c65d798616",
         "GUID:e8958e6939af7314a97769de4be4ce25",
-        "GUID:df380645f10b7bc4b97d4f5eb6303d95",
         "GUID:3b570a5146f9d4f0fa107ed4559471a3",
-        "GUID:3aa1866a824b5472da50fe142777d95f"
+        "GUID:3aa1866a824b5472da50fe142777d95f",
+        "GUID:df380645f10b7bc4b97d4f5eb6303d95"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fr.jeanf.universal.player",
 
-  "version": "0.8.20",
+  "version": "0.8.22",
 
   "displayName": "Universal Player",
   "description": "This package contains a universal player working in URP & HDRP for Mouse+Keyboard or VR",