fr.jeanf.universal.player 0.8.43 → 0.8.45

package/Runtime/scripts/Debug/MissingReferenceDetector.cs

@@ -0,0 +1,111 @@
+using UnityEngine;
+using System.Reflection;
+using System.Collections.Generic;
+
+namespace jeanf.vrplayer
+{
+    /// <summary>
+    /// Detects and logs missing references in MonoBehaviour components using reflection.
+    /// Attach this to any GameObject to check its hierarchy for missing references.
+    /// </summary>
+    public class MissingReferenceDetector : MonoBehaviour
+    {
+        [Header("Detection Settings")]
+        [Tooltip("Check this GameObject and all its children")]
+        [SerializeField] private bool checkChildren = true;
+
+        [Tooltip("Log even if no missing references are found")]
+        [SerializeField] private bool verboseLogging = true;
+
+        [Tooltip("Run check on Start")]
+        [SerializeField] private bool checkOnStart = true;
+
+        private void Start()
+        {
+            if (checkOnStart)
+            {
+                CheckForMissingReferences();
+            }
+        }
+
+        [ContextMenu("Check For Missing References")]
+        public void CheckForMissingReferences()
+        {
+            int missingCount = 0;
+            List<string> missingReferencesList = new List<string>();
+
+            Transform[] transforms = checkChildren ? GetComponentsInChildren<Transform>(true) : new Transform[] { transform };
+
+            Debug.Log($"<color=cyan>Starting missing reference check on: <b>{gameObject.name}</b></color>");
+
+            foreach (Transform t in transforms)
+            {
+                MonoBehaviour[] components = t.GetComponents<MonoBehaviour>();
+
+                foreach (MonoBehaviour component in components)
+                {
+                    if (component == null)
+                    {
+                        string msg = $"[MISSING SCRIPT] on GameObject: {t.name}";
+                        Debug.LogError(msg, t.gameObject);
+                        missingReferencesList.Add(msg);
+                        missingCount++;
+                        continue;
+                    }
+
+                    // Use reflection to check all serialized fields
+                    FieldInfo[] fields = component.GetType().GetFields(
+                        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+                    foreach (FieldInfo field in fields)
+                    {
+                        // Check if field is serialized
+                        if (!field.IsPublic && field.GetCustomAttribute<SerializeField>() == null)
+                            continue;
+
+                        // Check if it's a Unity Object reference type
+                        if (!typeof(Object).IsAssignableFrom(field.FieldType))
+                            continue;
+
+                        // Get the field value
+                        object fieldValue = field.GetValue(component);
+
+                        // Check if it's null
+                        if (fieldValue == null || fieldValue.Equals(null))
+                        {
+                            // Try to determine if this should be assigned (not just optional)
+                            // We'll log it and let the user decide
+                            string msg = $"[NULL REFERENCE] GameObject: {t.name} | " +
+                                       $"Component: {component.GetType().Name} | " +
+                                       $"Field: {field.Name} (Type: {field.FieldType.Name})";
+                            Debug.LogWarning(msg, t.gameObject);
+                            missingReferencesList.Add(msg);
+                            missingCount++;
+                        }
+                        // Special check for destroyed Unity objects
+                        else if (fieldValue is Object unityObj && unityObj == null)
+                        {
+                            string msg = $"[DESTROYED REFERENCE] GameObject: {t.name} | " +
+                                       $"Component: {component.GetType().Name} | " +
+                                       $"Field: {field.Name}";
+                            Debug.LogError(msg, t.gameObject);
+                            missingReferencesList.Add(msg);
+                            missingCount++;
+                        }
+                    }
+                }
+            }
+
+            // Summary
+            if (missingCount > 0)
+            {
+                Debug.LogError($"MISSING/NULL REFERENCES DETECTED: {missingCount} issues found on {gameObject.name}\n" +
+                             "Check console for details.", gameObject);
+            }
+            else if (verboseLogging)
+            {
+                Debug.Log($"<color=green>No missing references found in {gameObject.name} hierarchy</color>", gameObject);
+            }
+        }
+    }
+}

package/Runtime/scripts/Debug/MissingReferenceDetector.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 86a8bd9ca25a9aa479d5fc5c9fb65749

package/Runtime/scripts/Debug.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 16cd441c33a822941a488eadfbdeab18
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/scripts/Fade/FadeMask.cs

@@ -458,7 +458,7 @@ namespace jeanf.universalplayer
                 return;
             }
 
-            switch (fadeType)
+            switch (fadeType)   
             {
                 case FadeType.Loading:
                     SetVolumeTo_FadeToBlack(); // Black fade

package/Runtime/scripts/HandInteraction/HandsAppearanceManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using UnityEngine;
 using jeanf.EventSystem;
 using LitMotion;
@@ -57,33 +56,30 @@ namespace jeanf.universalplayer
         [ReadOnly] [SerializeField] private bool lastHandVisibility = true;
         [ReadOnly] [SerializeField] private bool canUpdate = false;
 
-
         private float tolerance = 0.01f;
+        
+        private List<int> _nullHandIndices = new List<int>(4); 
+        private int _frameCounter = 0;
+        private const int CleanupInterval = 300; 
 
         [Header("Action binding")]
         [SerializeField] private InputActionReference shiftTypeHandAction;
         
-        //[SerializeField] private Material skin;
-        //[SerializeField] private Material nail;
         private static readonly int SkinBaseColor = Shader.PropertyToID("_BaseColor");
-        //private static readonly int SkinDarness = Shader.PropertyToID("_SkinDarkness");
         private static readonly int _gloveValue = Shader.PropertyToID("_Switch_Gloves");
-
         [SerializeField] private readonly int _genderValue = Shader.PropertyToID("_Switch_Woman");
-        //[Range(0,100)]
-        //[SerializeField] private float nailDarkness = 10f;
-
 
         [Header("Listening on:")]
         [SerializeField] private BoolEventChannelSO gloveStateChannel;
 
-        //[SerializeField] private BoolEventChannelSO hmdStateChannel;
         private void OnEnable()
         {
             BlendableHand.AddHand += AddHand;
             BlendableHand.RemoveHand += RemoveHand;
-            gloveStateChannel.OnEventRaised += SetGloveState;
-            //hmdStateChannel.OnEventRaised += SetUpdateState;
+            if (gloveStateChannel != null)
+            {
+                gloveStateChannel.OnEventRaised += SetGloveState;
+            }
         }
 
         private void OnDisable() => Unsubscribe();
@@ -95,12 +91,21 @@ namespace jeanf.universalplayer
             _hands.TrimExcess();
             BlendableHand.AddHand -= AddHand;
             BlendableHand.RemoveHand -= RemoveHand;
-            gloveStateChannel.OnEventRaised -= SetGloveState;
-            //hmdStateChannel.OnEventRaised -= SetUpdateState;
+            if (gloveStateChannel != null)
+            {
+                gloveStateChannel.OnEventRaised -= SetGloveState;
+            }
         }
 
         private void Update()
         {
+            _frameCounter++;
+            if (_frameCounter >= CleanupInterval)
+            {
+                _frameCounter = 0;
+                CleanupNullHands_GCFree();
+            }
+            
             if(BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR)
             {
                 SetHandsVisibility(true);
@@ -110,84 +115,244 @@ namespace jeanf.universalplayer
                 SetBodyMass(_hands, bodyMass);
                 SetSkinDarkness(_hands, skinDarkness);
             }
-            //SetBlendValueFromGender(gender);
         }
+        
+        private void CleanupNullHands_GCFree()
+        {
+            if (_hands is null || _hands.Count is 0) return;
+            
+            _nullHandIndices.Clear();
+            
+            for (int i = 0; i < _hands.Count; i++)
+            {
+                if (_hands[i] is null)
+                {
+                    _nullHandIndices.Add(i);
+                }
+            }
+            
+            for (int i = _nullHandIndices.Count - 1; i >= 0; i--)
+            {
+                _hands.RemoveAt(_nullHandIndices[i]);
+            }
+        }
+        
         private void AddHand(SkinnedMeshRenderer hand)
         {
+            if (hand is null)
+            {
+                if (isDebug) Debug.LogWarning("[HandsAppearanceManager] Attempted to add null hand!");
+                return;
+            }
+            
+            if (hand.sharedMesh is null)
+            {
+                if (isDebug) 
+                {
+                    Debug.LogWarning("[HandsAppearanceManager] Hand has no mesh: " + hand.name);
+                }
+                return;
+            }
+
             if (!_hands.Contains(hand))
             {
                 _hands.Add(hand);
-                SetGender(_hands, gender);
+                
+                if (ValidateBlendShapes(hand))
+                {
+                    SetGender(_hands, gender);
+                }
+                else
+                {
+                    if (isDebug) 
+                    {
+                        Debug.LogWarning("[HandsAppearanceManager] Hand missing blend shapes: " + hand.name);
+                    }
+                }
+                
                 SetHandsVisibility(isHandVisible);
             }
-
         }
+        
+        private bool ValidateBlendShapes(SkinnedMeshRenderer hand)
+        {
+            if (hand is null || hand.sharedMesh is null) return false;
+            
+            int blendShapeCount = hand.sharedMesh.blendShapeCount;
+            
+            if (blendShapeCount < 1)
+            {
+                if (isDebug)
+                {
+                    Debug.LogWarning("[HandsAppearanceManager] Hand has no blend shapes: " + hand.name);
+                }
+                return false;
+            }
+            
+            if (blendShapeCount < 3)
+            {
+                if (isDebug)
+                {
+                    Debug.LogWarning("[HandsAppearanceManager] Hand missing body mass blend shape: " + hand.name);
+                }
+            }
+            
+            return true;
+        }
+        
         private void RemoveHand(SkinnedMeshRenderer hand)
         {
-            if(_hands.Count > 0 && _hands.Contains(hand)) _hands.Remove(hand);
+            if(_hands != null && _hands.Count > 0 && _hands.Contains(hand))
+            {
+                _hands.Remove(hand);
+            }
         }
 
-        
         private void SetBlendValueFromGender(bool gender)
         {
             _blendValue = gender ? 100f : 0f;
         }
 
-        
         private void SetGender(List<SkinnedMeshRenderer> hands, float value)
         {
-            foreach (var hand in hands)
+            if (hands is null || hands.Count is 0) return;
+            
+            for (int i = 0; i < hands.Count; i++)
             {
-                hand.SetBlendShapeWeight(0, value);
+                var hand = hands[i];
+                if (hand is null || hand.sharedMesh is null) continue;
+                
+                if (hand.sharedMesh.blendShapeCount < 1)
+                {
+                    if (isDebug)
+                    {
+                        Debug.LogWarning("[HandsAppearanceManager] Hand has no blend shapes for gender: " + hand.name);
+                    }
+                    continue;
+                }
+                
+                try
+                {
+                    hand.SetBlendShapeWeight(0, value);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("[HandsAppearanceManager] Error setting gender blend shape on " + hand.name + ": " + e.Message);
+                }
             }
         }
         
         private void SetBodyMass(List<SkinnedMeshRenderer> hands, float value)
         {
-            foreach (var hand in hands)
+            if (hands is null || hands.Count is 0) return;
+            
+            for (int i = 0; i < hands.Count; i++)
             {
-                hand.SetBlendShapeWeight(2, value);
+                var hand = hands[i];
+                if (hand is null || hand.sharedMesh is null) continue;
+                
+                if (hand.sharedMesh.blendShapeCount < 3)
+                {
+                    if (isDebug)
+                    {
+                        Debug.LogWarning("[HandsAppearanceManager] Hand doesn't have body mass blend shape: " + hand.name);
+                    }
+                    continue;
+                }
+                
+                try
+                {
+                    hand.SetBlendShapeWeight(2, value);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("[HandsAppearanceManager] Error setting body mass blend shape on " + hand.name + ": " + e.Message);
+                }
             }
         }
 
-
         private void SetHandMaterials(List<SkinnedMeshRenderer> hands, float value)
         {
-            if(hands.Count < 1) return;
-            foreach (var hand in hands)
+            if (hands is null || hands.Count < 1) return;
+            
+            for (int i = 0; i < hands.Count; i++)
             {
-                hand.sharedMaterial.SetFloat(_genderValue, value);
+                var hand = hands[i];
+                if (hand is null || hand.sharedMaterial is null) continue;
+                
+                try
+                {
+                    hand.sharedMaterial.SetFloat(_genderValue, value);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("[HandsAppearanceManager] Error setting material on " + hand.name + ": " + e.Message);
+                }
             }
         }
 
         private void SetSkinDarkness(List<SkinnedMeshRenderer> hands, float skinDarness)
         {
-            if(hands.Count < 1) return;
+            if (hands is null || hands.Count < 1) return;
+            
             var blend = Color.Lerp(lightSkinColor, darkSkinColor, skinDarkness);
-            foreach (var hand in hands)
+            
+            for (int i = 0; i < hands.Count; i++)
             {
-                hand.sharedMaterials[0].SetColor(SkinBaseColor, blend);
+                var hand = hands[i];
+                if (hand is null || hand.sharedMaterials is null || hand.sharedMaterials.Length is 0) continue;
+                
+                if (hand.sharedMaterials[0] is null) continue;
+                
+                try
+                {
+                    hand.sharedMaterials[0].SetColor(SkinBaseColor, blend);
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("[HandsAppearanceManager] Error setting skin darkness on " + hand.name + ": " + e.Message);
+                }
             }
         }
 
         private void SetGloveValue(List<SkinnedMeshRenderer> hands, float value)
         {
-            if(hands.Count < 1) return;
-            foreach (var mat in hands.SelectMany(hand => hand.sharedMaterials))
+            if (hands is null || hands.Count < 1) return;
+            
+            for (int i = 0; i < hands.Count; i++)
             {
-                mat.SetFloat(_gloveValue, value);
+                var hand = hands[i];
+                if (hand is null || hand.sharedMaterials is null) continue;
+                
+                for (int j = 0; j < hand.sharedMaterials.Length; j++)
+                {
+                    var mat = hand.sharedMaterials[j];
+                    if (mat is null) continue;
+                    
+                    try
+                    {
+                        mat.SetFloat(_gloveValue, value);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogError("[HandsAppearanceManager] Error setting glove value on " + hand.name + ": " + e.Message);
+                    }
+                }
             }
         }
         
         private void LerpGloveTowardsValue(float goalValue, float blendTime)
         {
-            _gloveHandle = LMotion.Create(gloveValue,goalValue,blendTime)
+            _gloveHandle = LMotion.Create(gloveValue, goalValue, blendTime)
                 .Bind(x => gloveValue = x);
         }
 
         public void SetGloveState(bool state)
         {
-            if(isDebug) Debug.Log($"glove state {state}");
+            if(isDebug)
+            {
+                Debug.Log("[HandsAppearanceManager] Glove state: " + state);
+            }
             isGlove = state;
             var goalValue = isGlove ? 1 : 0;
             LerpGloveTowardsValue(goalValue, blendTime);
@@ -201,9 +366,21 @@ namespace jeanf.universalplayer
 
         public void SetHandsVisibility(bool state)
         {
-            foreach (var hand in _hands)
+            if (_hands is null) return;
+            
+            for (int i = 0; i < _hands.Count; i++)
             {
-                hand.enabled = state;
+                var hand = _hands[i];
+                if (hand is null) continue;
+                
+                try
+                {
+                    hand.enabled = state;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError("[HandsAppearanceManager] Error setting hand visibility: " + e.Message);
+                }
             }
 
             lastHandVisibility = state;

package/Runtime/scripts/Movement/PlayerMovement.cs

@@ -24,19 +24,16 @@ namespace jeanf.universalplayer
         bool isMoving;
         Vector2 moveValue;
 
-        // Cache camera transform to avoid Camera.main lookups
         private Transform cameraTransform;
         private const float INPUT_MULTIPLIER = 50f;
 
         private void Awake()
         {
-            // Cache the camera transform once
             cameraTransform = Camera.main.transform;
         }
 
         private void OnEnable()
         {
-            // Use proper method references instead of lambdas
             fpsMoveAction.action.performed += OnFpsMovePerformed;
             fpsMoveAction.action.canceled += OnFpsMoveCanceled;
             xrMoveAction.action.performed += OnXrMovePerformed;
@@ -61,7 +58,6 @@ namespace jeanf.universalplayer
             }
         }
 
-        // Event handler methods
         private void OnFpsMovePerformed(InputAction.CallbackContext ctx)
         {
             SetMoveValue(ctx.ReadValue<Vector2>() * Time.smoothDeltaTime * INPUT_MULTIPLIER);
@@ -104,7 +100,6 @@ namespace jeanf.universalplayer
 
         private void Move(Vector2 move)
         {
-            // Use cached camera transform
             Vector3 forward = cameraTransform.forward;
             Vector3 right = cameraTransform.right;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fr.jeanf.universal.player",
 
-  "version": "0.8.43",
+  "version": "0.8.45",
 
   "displayName": "Universal Player",
   "description": "This package contains a universal player working in URP & HDRP for Mouse+Keyboard or VR",
@@ -21,14 +21,14 @@
   "dependencies": {
     "com.unity.modules.vr": "1.0.0",
     "com.unity.modules.xr": "1.0.0",
-    "com.unity.inputsystem": "1.4.4",
-    "com.unity.vectorgraphics": "2.0.0-preview.20",
-    "com.unity.xr.openxr": "1.6.0",
-    "com.unity.xr.interaction.toolkit": "2.3.2",
-    "com.unity.xr.hands": "1.1.0-pre.3",
-    "com.unity.xr.management": "4.3.3",
-    "com.unity.xr.oculus": "3.2.3",
-    "fr.jeanf.eventsystem": "0.1.96",
+    "com.unity.inputsystem": "1.14.2",
+    "com.unity.vectorgraphics": "2.0.0-preview.25",
+    "com.unity.xr.openxr": "1.15.1",
+    "com.unity.xr.interaction.toolkit": "3.0.9",
+    "com.unity.xr.hands": "1.5.1",
+    "com.unity.xr.management": "4.5.3",
+    "com.unity.xr.oculus": "4.5.2",
+    "fr.jeanf.eventsystem": "0.1.124",
     "fr.jeanf.propertydrawer": "1.1.6",
     "fr.jeanf.tooltipsystem": "0.0.7"
   },