Development tools

Runtime/Scripts/Anchoring/TrackableFloor.cs → Runtime/Scripts/Extensions/MPEG/Anchoring/TrackableFloor.cs

@@ -10,14 +10,15 @@
 */
 
 using GLTFast.Schema;
-using System.Collections.Generic;
-using System.Linq;
 using UnityEngine;
+
 #if UNITY_ANDROID
+using System.Collections.Generic;
+using System.Linq;
 using UnityEngine.XR.ARFoundation;
 using UnityEngine.XR.ARSubsystems;
-#endif
 using System.Reflection;
+#endif
 
 namespace GLTFast
 {
@@ -46,6 +47,8 @@ public class TrackableFloor : MonoBehaviour, IMpegTrackable
         private Bounds m_SceneBounds;
         private Vector3 m_ScaleFactor = Vector3.one;
         private bool m_ApplyScale = false;
+        private MPEG_TrackableEvent m_TrackableEvent;
+
 
         public void InitFromGltf(Trackable  track)
         {
@@ -71,12 +74,13 @@ private void Awake()
             if(m_ArPlaneManager == null)
             {
                 m_ArPlaneManager = obj.AddComponent<ARPlaneManager>();
+                m_ArPlaneManager.planePrefab = Resources.Load<GameObject>("Plane");
             }
             m_ArPlaneManager.enabled = true;
         }
 
-        public  void Init()
-        {  
+        public void Init()
+        {
             var res  = m_ArPlaneManager.descriptor;
 
             //check if classification is supported
@@ -89,22 +93,34 @@ public  void Init()
             {
                 m_SupportClassification = m_ArPlaneManager.descriptor.supportsClassification;
             }
-
+
+            m_TrackableEvent = new MPEG_TrackableEvent();
+            m_TrackableEvent.trackableType = Schema.TrackableType.TRACKABLE_FLOOR;
             //force horizontal detection
             m_ArPlaneManager.requestedDetectionMode = PlaneDetectionMode.Horizontal;
             m_ArPlaneManager.planesChanged += PlanesChanged;  
         }
 
+        private void InvokeTrackableEvent(TrackableEventType _type, Vector3 _pos, Quaternion _rot)
+        {
+            m_TrackableEvent.trackableEventType = _type;
+            m_TrackableEvent.anchorPosition = _pos;
+            m_TrackableEvent.anchorRotation = _rot;
+            TrackableModule.GetInstance().OnAnchoringOccurs(this, m_TrackableEvent);
+        }
+
         private void PlanesChanged(ARPlanesChangedEventArgs arg)
         {
             if(arg.added != null)
             {
                 if(arg.added.Count==0)
-                {
                     return;
-                }
+
                 //Floor detection
                 ARPlane tempPlane = arg.added[0];
+                Vector3 _anchorPosition = tempPlane.gameObject.transform.position;
+                Quaternion _anchorRotation = tempPlane.gameObject.transform.rotation;
+
                 if (m_SupportClassification && tempPlane.classification == PlaneClassification.Floor)
                 {
                     //Kept first detected
@@ -132,35 +148,41 @@ private void PlanesChanged(ARPlanesChangedEventArgs arg)
                         }
                     }
                 }
+
+                InvokeTrackableEvent(TrackableEventType.ADDED, _anchorPosition, _anchorRotation);
             }
             else if(arg.removed!= null)
             {
                 if(arg.removed.Count == 0)
-                {
-                    return; 
-                }
+                    return;
 
                 ARPlane tempPlane = arg.removed[0];
+                Vector3 _anchorPosition = tempPlane.gameObject.transform.position;
+                Quaternion _anchorRotation = tempPlane.gameObject.transform.rotation;
+
                 if (tempPlane.trackableId == m_Id)
                 {
                     m_Plane = null;
                     m_Id = TrackableId.invalidId;
                     RemoveAnchor();
                 }
+                InvokeTrackableEvent(TrackableEventType.REMOVED, _anchorPosition, _anchorRotation);
             }
             else if(arg.updated != null )
             {
-                if(arg.updated.Count==0)
-                {
+                if(arg.updated.Count == 0)
                     return;  
-                }
 
                 ARPlane tempPlane = arg.updated[0];
+                Vector3 _anchorPosition = tempPlane.gameObject.transform.position;
+                Quaternion _anchorRotation = tempPlane.gameObject.transform.rotation;
+
                 if (tempPlane.trackableId == m_Id)
                 {
                     m_Plane = tempPlane;
                     m_Id = tempPlane.trackableId;
-                } 
+                }
+                InvokeTrackableEvent(TrackableEventType.UPDATED, _anchorPosition, _anchorRotation);
             }
         }
 
@@ -200,7 +222,7 @@ private bool BuildAnchorInternal()
                 var res = CheckRequiredSpace(m_Plane);
                 if(!res)
                 {
-                    return false;;
+                    return false;
                 }
             }
             Debug.Log("TrackableFloor::_requiredAlignedAndScale "+ m_RequiredAlignedAndScale);
@@ -232,7 +254,6 @@ private bool BuildAnchorInternal()
                 }
                 m_Attached = true;
             }
-            UpdatePlaneVisibility(false);  
             return true; 
         }
 
@@ -257,14 +278,6 @@ public void AttachNodeToTrackable(GameObject go)
             }         
         }
 
-        private void UpdatePlaneVisibility(bool visible)
-        {
-            foreach (var plane in m_ArPlaneManager.trackables)
-            {
-                plane.gameObject.SetActive(visible);
-            }
-        }
-
         public void RequiredSpace(UnityEngine.Vector3 requiredSpace)
         {
             Debug.Log("TrackableFloor::RequiredSpace");
@@ -409,11 +422,7 @@ void Update()
                     }
                     m_IsGoActivated = false;
                 }
-            }
-            else
-            {
-                UpdatePlaneVisibility(false);
-            }  
+            } 
         }
         public void DumpAttributs()
         {

Runtime/Scripts/Anchoring/TrackableMarker2D.cs → Runtime/Scripts/Extensions/MPEG/Anchoring/TrackableMarker2D.cs

@@ -46,6 +46,8 @@ public class TrackableMarker2D : MonoBehaviour, IMpegTrackable
         // private bool m_RequiredAlignedAndScale =false;
         // private bool m_RequiredSpace = false;
 
+        private MPEG_TrackableEvent m_TrackableEvent;
+
         /// <summary>
         /// If an image is detected but no source texture can be found,
         /// this texture is used instead.
@@ -70,6 +72,8 @@ public void Init()
             int matIndex = -1;
             int texIndex = -1;
             int sourceIndex = -1;
+            m_TrackableEvent = new MPEG_TrackableEvent();
+            m_TrackableEvent.trackableType = Schema.TrackableType.TRACKABLE_MARKER_2D;
 
             Debug.Log("TrackableMarker2D::Init");
 
@@ -198,6 +202,8 @@ void OnTrackedImagesChanged(ARTrackedImagesChangedEventArgs eventArgs)
                     {
                         imgTrack = eventArgs.added[0];
                         m_Id = imgTrack.trackableId;
+                        m_TrackableEvent.trackableEventType = TrackableEventType.ADDED;
+                        TrackableModule.GetInstance().OnAnchoringOccurs(this, m_TrackableEvent);
                     }
                 }
             }
@@ -216,6 +222,9 @@ void OnTrackedImagesChanged(ARTrackedImagesChangedEventArgs eventArgs)
                     ARTrackedImage _image = _updateImages[i];
                     m_Id = _image.trackableId;
                     m_Anchor.transform.SetPositionAndRotation(_image.transform.position, _image.transform.rotation);
+
+                    m_TrackableEvent.trackableEventType = TrackableEventType.UPDATED;
+                    TrackableModule.GetInstance().OnAnchoringOccurs(this, m_TrackableEvent);
                 }
             }
 
@@ -229,6 +238,8 @@ void OnTrackedImagesChanged(ARTrackedImagesChangedEventArgs eventArgs)
                         ClearInfo(imgTrack);
                         imgTrack = null;
                         m_Id = TrackableId.invalidId;
+                        m_TrackableEvent.trackableEventType = TrackableEventType.REMOVED;
+                        TrackableModule.GetInstance().OnAnchoringOccurs(this, m_TrackableEvent);
                     }
                 }
             }

Runtime/Scripts/Extensions/MPEG/IMPEG_Module.cs

@@ -0,0 +1,5 @@
+public interface IMPEG_Module<T>
+{
+    public void Register(System.Action<T> action, int index);
+    public void Unregister(int index);
+}

Runtime/Scripts/ActionManipulate.cs → Runtime/Scripts/Extensions/MPEG/Interactivity/ActionManipulate.cs

@@ -30,6 +30,8 @@ public class ActionManipulate : MonoBehaviour, IMpegInteractivityAction
         private object m_ReadInputValue;
         private bool m_IsInputPerformed;
         private Vector3 m_Position;
+        private MPEG_ActionManipulateEvent m_ManipulateEvent;
+
         private UnityEngine.Camera Camera
         {
             get
@@ -60,7 +62,9 @@ public void Init(Schema.Action action)
             m_Targets = VirtualSceneGraph.GetGameObjectsFromIndexes(action.nodes);
             m_Delay = action.delay;
             m_CurrentManipulateType = action.manipulateActionType;
-            m_Camera = UnityEngine.Camera.main;
+            m_Camera = Camera.main;
+            m_ManipulateEvent = new MPEG_ActionManipulateEvent();
+            m_ManipulateEvent.inputAction = m_InputAction;
         }
 
         private void OnInputCanceled(InputAction.CallbackContext _cbk)
@@ -94,14 +98,16 @@ private void Execute()
                 return;
             }
 
-            switch(m_CurrentManipulateType)
+            switch (m_CurrentManipulateType)
             {
                 case Schema.Action.ManipulateActionType.ACTION_MANIPULATE_FREE: ManipulateFree(); break;
                 case Schema.Action.ManipulateActionType.ACTION_MANIPULATE_ROTATE: ManipulateRotate(); break;
                 case Schema.Action.ManipulateActionType.ACTION_MANIPULATE_SCALE: ManipulateScale(); break;
                 case Schema.Action.ManipulateActionType.ACTION_MANIPULATE_SLIDE: ManipulateSlide(); break;
                 case Schema.Action.ManipulateActionType.ACTION_MANIPULATE_TRANSLATE: ManipulateTranslate(); break;
             }
+
+            ActionModule.GetInstance().OnActionOccurs(this, m_ManipulateEvent);
         }
 
         private void ManipulateFree()

Runtime/Scripts/Behavior.cs → Runtime/Scripts/Extensions/MPEG/Interactivity/Behavior.cs

@@ -48,10 +48,12 @@ public class Behavior : MonoBehaviour, IMpegInteractivityBehavior
         private TriggerActivationControl m_TriggerActivationControl;
         private IMpegInteractivityAction m_InterruptAction;
 
-        private List<System.Action> m_GameEngineActions;
+        private MPEG_BehaviourEvent m_BehaviourEvent;
 
         public void InitializeBehavior(Schema.Behavior bhv)
         {
+            m_BehaviourEvent = new MPEG_BehaviourEvent();
+
             // Cache trigger control
             m_TriggerActivationControl = bhv.triggersActivationControl;
 
@@ -90,7 +92,6 @@ public void InitializeBehavior(Schema.Behavior bhv)
             }
 
             // Helper to get game object actions associated with mpeg actions
-            m_GameEngineActions = new List<System.Action>();
             m_IsRunning = true;
         }
 
@@ -107,7 +108,15 @@ public bool AreTriggersActived()
             TriggerActivationControl actControl = ProcessState(m_HasEverExited, m_HasEverEntered, m_LastFrameCombinationResult, combinationResult);
             UpdateStates(actControl);
             m_LastFrameCombinationResult = combinationResult;
-            return actControl == m_TriggerActivationControl;
+
+            bool _yes = actControl == m_TriggerActivationControl;
+
+            if (_yes)
+            {
+                BehaviourModule.GetInstance().OnBehaviourOccurs(this, m_BehaviourEvent);
+            }
+
+            return _yes;
         }
 
         private void RunTriggers()
@@ -199,16 +208,6 @@ public void ActivateActions()
                     m_Action[i].Invoke();
                 }
             }
-
-            for(int i = 0; i < m_GameEngineActions.Count; i++)
-            {
-                m_GameEngineActions[i].Invoke();
-            }
-        }
-
-        public void AddGameEngineAction(System.Action action)
-        {
-            m_GameEngineActions.Add(action);
         }
 
         public void Interrupt()

Runtime/Scripts/BehaviorController.cs → Runtime/Scripts/Extensions/MPEG/Interactivity/BehaviorController.cs

@@ -9,7 +9,6 @@
 * See the License for the specific language governing permissions and limitations under the License.
 */
 
-using System;
 using System.Collections.Generic;
 using UnityEngine;
 

Runtime/Scripts/CollisionNodeTrigger.cs → Runtime/Scripts/Extensions/MPEG/Interactivity/CollisionNodeTrigger.cs

@@ -33,7 +33,6 @@ public class CollisionNodeTrigger : MonoBehaviour
 
         public void Init()
         {
-            Debug.Log("Init collision detector");
             if (!m_HasInit)
             {
                 m_Target = new List<GameObject>();