Creation of BehaviourEngine and event/animation wrappers is now handled in the InteractivityImporterContext automatically. Unit tests updated to create their own engine and wrappers as the tests are using generated graphs and non-interactive glbs. Added import events to GltfImportPlugin for mesh, camera, vertex colored material, and load complete.

Author: Jmangles

Runtime/Scripts/GLTFSceneImporter.cs

@@ -512,7 +512,12 @@ public void Dispose()
 
 			if (this.progress != null)
 				await Task.Yield();
-			
+
+			foreach (var plugin in Context.Plugins)
+			{
+				plugin.OnLoadComplete(LastLoadedScene);
+			}
+
 			onLoadComplete?.Invoke(LastLoadedScene, null);
 		}
 

Runtime/Scripts/Interactivity/Playback/BehaviourEngine.cs

@@ -25,10 +25,10 @@ public class BehaviourEngine
 
         public readonly PointerResolver pointerResolver;
 
-        public BehaviourEngine(Graph graph, GLTFSceneImporter importer)
+        public BehaviourEngine(Graph graph, PointerResolver pointerResolver)
         {
             this.graph = graph;
-            pointerResolver = importer != null ? new PointerResolver(importer) : null;
+            this.pointerResolver = pointerResolver;
 
             for (int i = 0; i < graph.nodes.Count; i++)
             {
@@ -118,7 +118,7 @@ public void SetAnimationWrapper(AnimationWrapper wrapper, Animation animation)
         {
             animationWrapper = wrapper;
             wrapper.SetData(this, animation);
-            pointerResolver.RegisterAnimations(wrapper);
+            pointerResolver.CreateAnimationPointers(wrapper);
         }
 
         public void PlayAnimation(in AnimationPlayData data)

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

@@ -1,4 +1,5 @@
 using GLTF.Schema;
+using System;
 using UnityEngine;
 using UnityGLTF.Plugins;
 
@@ -7,17 +8,21 @@ namespace UnityGLTF.Interactivity.Playback
     public class InteractivityImportContext : GLTFImportPluginContext
     {
         internal readonly InteractivityImportPlugin settings;
+        private PointerResolver _pointerResolver;
+        private GLTFImportContext _context;
 
-        public InteractivityImportContext(InteractivityImportPlugin interactivityLoader)
+        public InteractivityImportContext(InteractivityImportPlugin interactivityLoader, GLTFImportContext context)
         {
             settings = interactivityLoader;
+            _context = context;
         }
 
         /// <summary>
         /// Called before import starts
         /// </summary>
         public override void OnBeforeImport()
         {
+            _pointerResolver = new();
             Util.Log($"InteractivityImportContext::OnBeforeImport Complete");
         }
 
@@ -32,6 +37,7 @@ public override void OnBeforeImportRoot()
         public override void OnAfterImportRoot(GLTFRoot gltfRoot)
         {
             Util.Log($"InteractivityImportContext::OnAfterImportRoot Complete: {gltfRoot.ToString()}");
+            _pointerResolver.CreateScenePointers(gltfRoot);
         }
 
         public override void OnBeforeImportScene(GLTFScene scene)
@@ -42,11 +48,25 @@ public override void OnBeforeImportScene(GLTFScene scene)
         public override void OnAfterImportNode(GLTF.Schema.Node node, int nodeIndex, GameObject nodeObject)
         {
             Util.Log($"InteractivityImportContext::OnAfterImportNode Complete: {node.ToString()}");
+            _pointerResolver.RegisterNode(node, nodeIndex, nodeObject);
         }
 
-        public override void OnAfterImportMaterial(GLTFMaterial material, int materialIndex, Material materialObject)
+        public override void OnAfterImportMesh(GLTFMesh mesh, int meshIndex, Mesh meshObject)
+        {
+            Util.Log($"InteractivityImportContext::OnAfterImportMesh Complete: {mesh.ToString()}");
+            _pointerResolver.RegisterMesh(mesh, meshIndex, meshObject);
+        }
+
+        public override void OnAfterImportMaterialWithVertexColors(GLTFMaterial material, int materialIndex, Material materialObject)
         {
             Util.Log($"InteractivityImportContext::OnAfterImportMaterial Complete: {material.ToString()}");
+            _pointerResolver.RegisterMaterial(material, materialIndex, materialObject);
+        }
+
+        public override void OnAfterImportCamera(GLTFCamera camera, int cameraIndex, Camera cameraObject)
+        {
+            Util.Log($"InteractivityImportContext::OnAfterImportCamera Complete: {camera.ToString()}");
+            _pointerResolver.RegisterCamera(camera, cameraIndex, cameraObject);
         }
 
         public override void OnAfterImportTexture(GLTFTexture texture, int textureIndex, Texture textureObject)
@@ -59,9 +79,57 @@ public override void OnAfterImportScene(GLTFScene scene, int sceneIndex, GameObj
             Util.Log($"InteractivityImportContext::OnAfterImportScene Complete: {scene.Extensions}");
         }
 
-        public override void OnAfterImport()
+        public override void OnLoadComplete(GameObject sceneObject)
         {
             Util.Log($"InteractivityImportContext::OnAfterImport Complete");
+
+            var extensions = _context.SceneImporter.Root?.Extensions;
+
+            if (extensions == null)
+            {
+                Util.Log("Extensions are null.");
+                return;
+            }
+
+            if (!extensions.TryGetValue(InteractivityGraphExtension.EXTENSION_NAME, out IExtension extensionValue))
+            {
+                Util.Log("Extensions does not contain interactivity.");
+                return;
+            }
+
+            if (extensionValue is not InteractivityGraphExtension interactivityGraph)
+            {
+                Util.Log("Extensions does not contain a graph.");
+                return;
+            }
+
+            try
+            {
+                _pointerResolver.CreatePointers();
+
+                var defaultGraphIndex = interactivityGraph.extensionData.defaultGraphIndex;
+                // Can be used to inject a graph created from code in a hacky way for testing.
+                //interactivityGraph.extensionData.graphs[defaultGraphIndex] = TestGraph.CreateTestGraph();
+                var defaultGraph = interactivityGraph.extensionData.graphs[defaultGraphIndex];
+                var eng = new BehaviourEngine(defaultGraph, _pointerResolver);
+
+                AnimationWrapper animationWrapper = null;
+                var animationComponents = sceneObject.GetComponents<Animation>();
+                if (animationComponents != null && animationComponents.Length > 0)
+                {
+                    animationWrapper = sceneObject.AddComponent<AnimationWrapper>();
+                    eng.SetAnimationWrapper(animationWrapper, animationComponents[0]);
+                }
+
+                var eventWrapper = sceneObject.AddComponent<EventWrapper>();
+
+                eventWrapper.SetData(eng, interactivityGraph.extensionData);
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+                return;
+            }
         }
     }
 

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

@@ -6,14 +6,14 @@ namespace UnityGLTF.Interactivity.Playback
     public class InteractivityImportPlugin : GLTFImportPlugin
     {
         public override string DisplayName => "KHR_interactivity_Importer";
-        public override string Description => "Imports KHR compliant interactivity graphs";
+        public override string Description => "Imports KHR compliant interactivity graphs for runtime playback.";
 
         private InteractivityImportContext _context;
 
         public override GLTFImportPluginContext CreateInstance(GLTFImportContext context)
         {
-            _context = new InteractivityImportContext(this);
             GLTFProperty.RegisterExtension(new InteractivityGraphFactory());
+            _context = new InteractivityImportContext(this, context);
 
             return _context;
         }

Runtime/Scripts/Interactivity/Playback/Pointers/CameraPointers.cs

@@ -17,8 +17,9 @@ public struct CameraPointers
         public Pointer<float> zFar;
         public Pointer<float> zNear;
 
-        public CameraPointers(Camera cam)
+        public CameraPointers(in CameraData data)
         {
+            var cam = data.unityCamera;
             // Unity does not allow you to set the width of the orthographic window directly.
             // cam.orthographicSize is the YMag and the width is then that value multiplied by your aspect ratio.
             orthographicXMag = new Pointer<float>()

Runtime/Scripts/Interactivity/Playback/Pointers/Materials/MaterialPointers.cs

@@ -46,8 +46,9 @@ public struct MaterialPointers
 
         public Material material { get; private set; }
 
-        public MaterialPointers(Material mat)
+        public MaterialPointers(in MaterialData data)
         {
+            var mat = data.unityMaterial;
             material = mat;
 
             alphaCutoff = PointerHelpers.CreateFloatPointer(mat, alphaCutoffHash);

Runtime/Scripts/Interactivity/Playback/Pointers/MeshPointers.cs

@@ -12,8 +12,9 @@ public struct MeshPointers
         public ReadOnlyPointer<int> weightsLength;
         public Pointer<float>[] weights;
 
-        public MeshPointers(GLTFMesh mesh)
+        public MeshPointers(in MeshData data)
         {
+            var mesh = data.mesh;
             if(mesh.Weights == null || mesh.Weights.Count == 0)
             {
                 weightsLength = new ReadOnlyPointer<int>(() => 0);

Runtime/Scripts/Interactivity/Playback/Pointers/NodePointers.cs

@@ -20,8 +20,10 @@ public struct NodePointers
         public Pointer<float>[] weights;
         public GameObject gameObject;
 
-        public NodePointers(GameObject go, GLTF.Schema.Node schema)
+        public NodePointers(in NodeData data)
         {
+            var go = data.unityObject;
+            var schema = data.node;
             gameObject = go;
 
             // Unity coordinate system differs from the GLTF one.