Colliders only get added to nodes/children of nodes that contain a selectability or hoverability extension if a collider is not already present.

Author: Jmangles

Runtime/Scripts/Interactivity/Playback/Context/Export/InteractivityExportContext.cs

@@ -29,31 +29,31 @@ public override void AfterSceneExport(GLTFSceneExporter exporter, GLTFRoot gltfR
             Util.Log($"InteractivityExportContext::AfterSceneExport ");
 
             if (exporter.RootTransforms == null) return;
-            GLTFInteractivityPlayback wrapper = null;
+            GLTFInteractivityPlayback playback = null;
             Transform t;
 
             // This assumes that EventWrapper exists on one of the root transforms which I think must be true due to how we import.
             foreach (var transform in exporter.RootTransforms)
             {
                 t = transform;
 
-                if (t.TryGetComponent(out wrapper))
+                if (t.TryGetComponent(out playback))
                     break;
 
                 while (t.parent != null)
                 {
-                    if (t.parent.TryGetComponent(out wrapper))
+                    if (t.parent.TryGetComponent(out playback))
                         break;
 
                     t = t.parent;
                 }
             }
 
-            if (wrapper == null)
+            if (playback == null)
                 return;
 
             exporter.DeclareExtensionUsage(InteractivityGraphExtension.EXTENSION_NAME, true);
-            gltfRoot.AddExtension(InteractivityGraphExtension.EXTENSION_NAME, new InteractivityGraphExtension(wrapper.extensionData));
+            gltfRoot.AddExtension(InteractivityGraphExtension.EXTENSION_NAME, new InteractivityGraphExtension(playback.extensionData));
         }
         public override void AfterTextureExport(GLTFSceneExporter exporter, GLTFSceneExporter.UniqueTexture texture, int index, GLTFTexture tex)
         {

Runtime/Scripts/Interactivity/Playback/Context/Import/InteractivityImportContext.cs

@@ -13,6 +13,7 @@ public class InteractivityImportContext : GLTFImportPluginContext
         private GLTFImportContext _context;
         private InteractivityGraphExtension _interactivityGraph;
         private bool _hasSelectOrHoverNode;
+        private List<GameObject> _selectableOrHoverableObjects;
 
         public InteractivityImportContext(InteractivityImportPlugin interactivityLoader, GLTFImportContext context)
         {
@@ -25,6 +26,8 @@ public InteractivityImportContext(InteractivityImportPlugin interactivityLoader,
         /// </summary>
         public override void OnBeforeImport()
         {
+            _hasSelectOrHoverNode = false;
+            _selectableOrHoverableObjects = new();
             _pointerResolver = new();
             Util.Log($"InteractivityImportContext::OnBeforeImport Complete");
         }
@@ -92,29 +95,19 @@ public override void OnBeforeImportScene(GLTFScene scene)
 
         public override void OnAfterImportNode(GLTF.Schema.Node node, int nodeIndex, GameObject nodeObject)
         {
-            AddColliderIfNecessary(node, nodeIndex, nodeObject);
+            CheckIfNodeIsInteractable(node, nodeIndex, nodeObject);
 
             Util.Log($"InteractivityImportContext::OnAfterImportNode Complete: {node.ToString()}");
             _pointerResolver.RegisterNode(node, nodeIndex, nodeObject);
         }
 
-        private void AddColliderIfNecessary(GLTF.Schema.Node node, int nodeIndex, GameObject nodeObject)
+        private void CheckIfNodeIsInteractable(GLTF.Schema.Node node, int nodeIndex, GameObject nodeObject)
         {
-            if (!_hasSelectOrHoverNode || nodeObject.TryGetComponent(out Collider collider))
+            if (!_hasSelectOrHoverNode)
                 return;
 
-            Mesh mesh = null;
-
-            if (nodeObject.TryGetComponent(out MeshFilter mf))
-                mesh = mf.sharedMesh;
-            else if (nodeObject.TryGetComponent(out SkinnedMeshRenderer smr))
-                mesh = smr.sharedMesh;
-
-            if (mesh == null)
-                return;
-
-            var selectable = true;
-            var hoverable = true;
+            var selectable = false;
+            var hoverable = false;
 
             if (node.Extensions != null)
             {
@@ -127,8 +120,8 @@ private void AddColliderIfNecessary(GLTF.Schema.Node node, int nodeIndex, GameOb
 
             if (!selectable && !hoverable)
                 return;
-            
-            nodeObject.AddComponent<BoxCollider>();
+
+            _selectableOrHoverableObjects.Add(nodeObject);
         }
 
         public override void OnAfterImportMesh(GLTFMesh mesh, int meshIndex, Mesh meshObject)
@@ -161,6 +154,11 @@ public override void OnAfterImportScene(GLTFScene scene, int sceneIndex, GameObj
             if (_interactivityGraph == null)
                 return;
 
+            for (int i = 0; i < _selectableOrHoverableObjects.Count; i++)
+            {
+                AddCollidersToChildrenOfInteractableNode(_selectableOrHoverableObjects[i]);
+            }
+
             try
             {
                 _pointerResolver.RegisterSceneData(_context.SceneImporter.Root);
@@ -206,5 +204,23 @@ public override void OnAfterImportScene(GLTFScene scene, int sceneIndex, GameObj
                 return;
             }
         }
+
+        private void AddCollidersToChildrenOfInteractableNode(GameObject nodeObject)
+        {
+            var meshFilters = nodeObject.GetComponentsInChildren<MeshFilter>();
+
+            if (meshFilters.Length <= 0)
+                return;
+
+            GameObject go;
+
+            for (int i = 0; i < meshFilters.Length; i++)
+            {
+                go = meshFilters[i].gameObject;
+
+                if (!go.TryGetComponent(out Collider collider))
+                    go.AddComponent<BoxCollider>();
+            }         
+        }
     }
 }