Interactivity Runtime Playback

Editor/Scripts/Interactivity/Playback/GLTFInteractivityAnimationWrapper_Inspector.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace UnityGLTF.Interactivity.Playback
+{
+    [CustomEditor(typeof(GLTFInteractivityAnimationWrapper))]
+    public class GLTFInteractivityAnimationWrapper_Inspector : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("Required to support animations during interactivity playback.");
+            EditorGUILayout.LabelField("Only works when this asset is imported with Legacy animation mode.");
+        }
+    }
+}

Editor/Scripts/Interactivity/Playback/GLTFInteractivityData_Inspector.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace UnityGLTF.Interactivity.Playback
+{
+    [CustomEditor(typeof(GLTFInteractivityData))]
+    public class GLTFInteractivityData_Inspector : Editor
+    { 
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("Contains serialized data representing this GLTF's interactivity graph.");
+            EditorGUILayout.Space();
+            var data = (GLTFInteractivityData)target;
+            data.showData = EditorGUILayout.Toggle("Show Data", data.showData);
+
+            if (data.showData)
+                base.OnInspectorGUI();
+        }
+    }
+}

Editor/Scripts/Interactivity/Playback/GLTFInteractivityPlayback_Inspector.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace UnityGLTF.Interactivity.Playback
+{
+    [CustomEditor(typeof(GLTFInteractivityPlayback))]
+    public class GLTFInteractivityPlayback_Inspector : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("Handles the onStart and onTick events for this interactive GLTF.");
+            EditorGUILayout.LabelField("Make sure colliders are enabled in the importer for hover/selection events.");
+        }
+    }
+}

Editor/Scripts/Interactivity/Playback/UnityGLTF.Interactivity.Playback.Editor.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "UnityGLTF.Interactivity.Playback.Editor",
+    "rootNamespace": "",
+    "references": [
+        "GUID:044607fd7a2ec4483a9d4a82c8ab78a7",
+        "GUID:b5e009300cbc0584fa5c0fa797ef4c5f"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Runtime/Scripts/GLTFSceneImporter.cs

@@ -519,7 +519,7 @@ public void Dispose()
 
 			if (this.progress != null)
 				await Task.Yield();
-			
+
 			onLoadComplete?.Invoke(LastLoadedScene, null);
 		}
 

Runtime/Scripts/Interactivity/Playback/BehaviourEngine.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+namespace UnityGLTF.Interactivity.Playback
+{
+    public class BehaviourEngine
+    {
+        public Graph graph { get; private set; }
+        public readonly Dictionary<Node, BehaviourEngineNode> engineNodes = new();
+        public GLTFInteractivityAnimationWrapper animationWrapper { get; private set; }
+        public readonly PointerInterpolationManager pointerInterpolationManager = new();
+        public readonly VariableInterpolationManager variableInterpolationManager = new();
+        public readonly NodeDelayManager nodeDelayManager = new();
+
+        public event Action onStart;
+
+        public event Action<RayArgs> onSelect;
+        public event Action<RayArgs> onHoverIn;
+        public event Action<RayArgs> onHoverOut;
+        public event Action onTick;
+        public event Action<int, Dictionary<string, IProperty>> onCustomEventFired;
+        public event Action<Flow> onFlowTriggered;
+
+        public PointerResolver pointerResolver { get; private set; }
+
+        public BehaviourEngine(Graph graph, PointerResolver pointerResolver)
+        {
+            this.graph = graph;
+            this.pointerResolver = pointerResolver;
+
+            for (int i = 0; i < graph.nodes.Count; i++)
+            {
+                engineNodes.Add(graph.nodes[i], NodeRegistry.CreateBehaviourEngineNode(this, graph.nodes[i]));
+            }
+        }
+
+        public void StartPlayback()
+        {
+            onStart?.Invoke();
+        }
+
+        public void Tick()
+        {
+            pointerInterpolationManager.OnTick();
+            variableInterpolationManager.OnTick();
+            nodeDelayManager.OnTick();
+
+            onTick?.Invoke();
+        }
+
+        public void Select(in RayArgs args)
+        {
+            onSelect?.Invoke(args);
+        }
+
+        public void HoverIn(in RayArgs args)
+        {
+            onHoverIn?.Invoke(args);
+        }
+
+        public void HoverOut(in RayArgs args)
+        {
+            onHoverOut?.Invoke(args);
+        }
+
+        public void ExecuteFlow(Flow flow)
+        {
+            Assert.IsNotNull(flow.toNode);
+
+            var node = engineNodes[flow.toNode];
+
+            onFlowTriggered?.Invoke(flow);
+
+            node.ValidateAndExecute(flow.toSocket);
+        }
+
+        public void FireCustomEvent(int eventIndex, Dictionary<string, IProperty> outValues = null)
+        {
+            if (eventIndex < 0 || eventIndex >= graph.customEvents.Count)
+                return; // TODO: Add error handling.
+
+            onCustomEventFired?.Invoke(eventIndex, outValues);
+        }
+
+        public IProperty ParseValue(Value v)
+        {
+            if (v.node == null)
+                return v.property;
+
+            var node = engineNodes[v.node];
+            return node.GetOutputValue(v.socket);
+        }
+
+        public IProperty GetVariableProperty(int variableIndex)
+        {
+            return graph.variables[variableIndex].property;
+        }
+
+        public bool TryGetPointer(string pointerString, BehaviourEngineNode engineNode, out IPointer pointer)
+        {
+            try
+            {
+                pointer = pointerResolver.GetPointer(pointerString, engineNode);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex); // Feeding in a really malformed pointerString could throw maybe?
+
+                pointer = PointerHelpers.InvalidPointer();
+            }
+            return !pointer.invalid;
+        }
+
+        public void SetAnimationWrapper(GLTFInteractivityAnimationWrapper wrapper, Animation animation)
+        {
+            animationWrapper = wrapper;
+            wrapper.SetData(this, animation);
+            pointerResolver.CreateAnimationPointers(wrapper);
+        }
+
+        public void PlayAnimation(in AnimationPlayData data)
+        {
+            if (!HasAnimationWrapper())
+                return;
+
+            animationWrapper.PlayAnimation(data);
+        }
+
+        public void StopAnimation(int index)
+        {
+            if (!HasAnimationWrapper())
+                return;
+
+            animationWrapper.StopAnimation(index);
+        }
+
+        public void StopAnimationAt(int index, float stopTime, Action callback)
+        {
+            if (!HasAnimationWrapper())
+                return;
+
+            animationWrapper.StopAnimationAt(index, stopTime, callback);
+        }
+
+        public bool HasAnimationWrapper()
+        {
+            if (animationWrapper == null)
+            {
+                Util.LogWarning("Tried to play an animation on a glb that has no animations.");
+                return false;
+            }
+
+            return true;
+        }
+    }
+}