fr.jeanf.universal.player 0.8.44 → 0.8.46

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/HandInteraction/Core/HandsPhysics.cs

@@ -53,10 +53,7 @@ namespace jeanf.universalplayer
             {
                 nonPhysicalHand.SetActive(false);
             }
-        }
-        void FixedUpdate()
-        {
-            rb.linearVelocity = (target.position - transform.position)/Time.fixedDeltaTime;
+            rb.linearVelocity = (target.position - transform.position)/Time.deltaTime;
         
 
             Quaternion rotationDifference = target.rotation * Quaternion.Inverse(transform.rotation*offset);
@@ -67,6 +64,7 @@ namespace jeanf.universalplayer
             rb.angularVelocity = (rotationDifferenceInDegree * Mathf.Deg2Rad/Time.deltaTime);
         }
 
+
         private void CheckXRStatus()
         {
             if (BroadcastControlsStatus.controlScheme == BroadcastControlsStatus.ControlScheme.XR)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fr.jeanf.universal.player",
 
-  "version": "0.8.44",
+  "version": "0.8.46",
 
   "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"
   },