testss

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/AnimatorMessageListener.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    /*
+     * It seems that Unity disables all motion and collision code handling usually
+     * done by the animator if the game object has a MonoBehaviour with an
+     * OnAnimatorMove or OnAnimatorIK movement. This is entirely undocumented,
+     * but other people have had similar issues:
+     * https://forum.unity.com/threads/root-animation-doesnt-move.457638/
+     * https://answers.unity.com/questions/1002771/apply-rootmotion-on-onanimatormove.html
+     * https://www.reddit.com/r/Unity3D/comments/2egh14/onanimatormove_overrides_collision/
+     * http://hutonggames.com/playmakerforum/index.php?topic=3590.msg16555#msg16555
+     * The only solution seems to be to separate the listener as a manual component.
+     */
+    [AddComponentMenu("Visual Scripting/Listeners/Animator Message Listener")]
+    public sealed class AnimatorMessageListener : MonoBehaviour
+    {
+        private void OnAnimatorMove()
+        {
+            EventBus.Trigger(EventHooks.OnAnimatorMove, gameObject);
+        }
+
+        private void OnAnimatorIK(int layerIndex)
+        {
+            EventBus.Trigger(EventHooks.OnAnimatorIK, gameObject, layerIndex);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EmptyEventArgs.cs

@@ -0,0 +1,4 @@
+namespace Unity.VisualScripting
+{
+    public struct EmptyEventArgs { }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EventBus.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    public static class EventBus
+    {
+        static EventBus()
+        {
+            events = new Dictionary<EventHook, HashSet<Delegate>>(new EventHookComparer());
+        }
+
+        private static readonly Dictionary<EventHook, HashSet<Delegate>> events;
+
+        public static void Register<TArgs>(EventHook hook, Action<TArgs> handler)
+        {
+            if (!events.TryGetValue(hook, out var handlers))
+            {
+                handlers = new HashSet<Delegate>();
+                events.Add(hook, handlers);
+            }
+
+            handlers.Add(handler);
+        }
+
+        public static void Unregister(EventHook hook, Delegate handler)
+        {
+            if (events.TryGetValue(hook, out var handlers))
+            {
+                if (handlers.Remove(handler))
+                {
+                    // Free the key references for GC collection
+                    if (handlers.Count == 0)
+                    {
+                        events.Remove(hook);
+                    }
+                }
+            }
+        }
+
+        public static void Trigger<TArgs>(EventHook hook, TArgs args)
+        {
+            HashSet<Action<TArgs>> handlers = null;
+
+            if (events.TryGetValue(hook, out var potentialHandlers))
+            {
+                foreach (var potentialHandler in potentialHandlers)
+                {
+                    if (potentialHandler is Action<TArgs> handler)
+                    {
+                        if (handlers == null)
+                        {
+                            handlers = HashSetPool<Action<TArgs>>.New();
+                        }
+
+                        handlers.Add(handler);
+                    }
+                }
+            }
+
+            if (handlers != null)
+            {
+                foreach (var handler in handlers)
+                {
+                    if (!potentialHandlers.Contains(handler))
+                    {
+                        continue;
+                    }
+
+                    handler.Invoke(args);
+                }
+
+                handlers.Free();
+            }
+        }
+
+        public static void Trigger<TArgs>(string name, GameObject target, TArgs args)
+        {
+            Trigger(new EventHook(name, target), args);
+        }
+
+        public static void Trigger(EventHook hook)
+        {
+            Trigger(hook, new EmptyEventArgs());
+        }
+
+        public static void Trigger(string name, GameObject target)
+        {
+            Trigger(new EventHook(name, target));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EventHook.cs

@@ -0,0 +1,55 @@
+namespace Unity.VisualScripting
+{
+    public struct EventHook
+    {
+        public readonly string name;
+
+        public readonly object target;
+
+        public readonly object tag;
+
+        public EventHook(string name, object target = null, object tag = null)
+        {
+            Ensure.That(nameof(name)).IsNotNull(name);
+
+            this.name = name;
+            this.target = target;
+            this.tag = tag;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is EventHook other))
+            {
+                return false;
+            }
+
+            return Equals(other);
+        }
+
+        public bool Equals(EventHook other)
+        {
+            return name == other.name && Equals(target, other.target) && Equals(tag, other.tag);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashUtility.GetHashCode(name, target, tag);
+        }
+
+        public static bool operator ==(EventHook a, EventHook b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(EventHook a, EventHook b)
+        {
+            return !(a == b);
+        }
+
+        public static implicit operator EventHook(string name)
+        {
+            return new EventHook(name);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EventHookComparer.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace Unity.VisualScripting
+{
+    // Make sure the equality comparer doesn't use boxing
+    public class EventHookComparer : IEqualityComparer<EventHook>
+    {
+        public bool Equals(EventHook x, EventHook y)
+        {
+            return x.Equals(y);
+        }
+
+        public int GetHashCode(EventHook obj)
+        {
+            return obj.GetHashCode();
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EventHooks.cs

@@ -0,0 +1,89 @@
+namespace Unity.VisualScripting
+{
+    public static class EventHooks
+    {
+        // Bolt
+        public const string Custom = nameof(Custom);
+
+        // Global
+        public const string OnGUI = nameof(OnGUI);
+        public const string OnApplicationFocus = nameof(OnApplicationFocus);
+        public const string OnApplicationLostFocus = nameof(OnApplicationLostFocus);
+        public const string OnApplicationPause = nameof(OnApplicationPause);
+        public const string OnApplicationResume = nameof(OnApplicationResume);
+        public const string OnApplicationQuit = nameof(OnApplicationQuit);
+
+        // Lifecycle
+        public const string OnEnable = nameof(OnEnable);
+        public const string Start = nameof(Start);
+        public const string Update = nameof(Update);
+        public const string FixedUpdate = nameof(FixedUpdate);
+        public const string LateUpdate = nameof(LateUpdate);
+        public const string OnDisable = nameof(OnDisable);
+        public const string OnDestroy = nameof(OnDestroy);
+
+        // External
+        public const string AnimationEvent = nameof(AnimationEvent);
+        public const string UnityEvent = nameof(UnityEvent);
+
+        // Editor
+        public const string OnDrawGizmos = nameof(OnDrawGizmos);
+        public const string OnDrawGizmosSelected = nameof(OnDrawGizmosSelected);
+
+        // Game Object
+        public const string OnPointerEnter = nameof(OnPointerEnter);
+        public const string OnPointerExit = nameof(OnPointerExit);
+        public const string OnPointerDown = nameof(OnPointerDown);
+        public const string OnPointerUp = nameof(OnPointerUp);
+        public const string OnPointerClick = nameof(OnPointerClick);
+        public const string OnBeginDrag = nameof(OnBeginDrag);
+        public const string OnDrag = nameof(OnDrag);
+        public const string OnEndDrag = nameof(OnEndDrag);
+        public const string OnDrop = nameof(OnDrop);
+        public const string OnScroll = nameof(OnScroll);
+        public const string OnSelect = nameof(OnSelect);
+        public const string OnDeselect = nameof(OnDeselect);
+        public const string OnSubmit = nameof(OnSubmit);
+        public const string OnCancel = nameof(OnCancel);
+        public const string OnMove = nameof(OnMove);
+        public const string OnBecameInvisible = nameof(OnBecameInvisible);
+        public const string OnBecameVisible = nameof(OnBecameVisible);
+        public const string OnCollisionEnter = nameof(OnCollisionEnter);
+        public const string OnCollisionExit = nameof(OnCollisionExit);
+        public const string OnCollisionStay = nameof(OnCollisionStay);
+        public const string OnCollisionEnter2D = nameof(OnCollisionEnter2D);
+        public const string OnCollisionExit2D = nameof(OnCollisionExit2D);
+        public const string OnCollisionStay2D = nameof(OnCollisionStay2D);
+        public const string OnControllerColliderHit = nameof(OnControllerColliderHit);
+        public const string OnJointBreak = nameof(OnJointBreak);
+        public const string OnJointBreak2D = nameof(OnJointBreak2D);
+        public const string OnMouseDown = nameof(OnMouseDown);
+        public const string OnMouseDrag = nameof(OnMouseDrag);
+        public const string OnMouseEnter = nameof(OnMouseEnter);
+        public const string OnMouseExit = nameof(OnMouseExit);
+        public const string OnMouseOver = nameof(OnMouseOver);
+        public const string OnMouseUp = nameof(OnMouseUp);
+        public const string OnMouseUpAsButton = nameof(OnMouseUpAsButton);
+        public const string OnParticleCollision = nameof(OnParticleCollision);
+        public const string OnTransformChildrenChanged = nameof(OnTransformChildrenChanged);
+        public const string OnTransformParentChanged = nameof(OnTransformParentChanged);
+        public const string OnTriggerEnter = nameof(OnTriggerEnter);
+        public const string OnTriggerExit = nameof(OnTriggerExit);
+        public const string OnTriggerStay = nameof(OnTriggerStay);
+        public const string OnTriggerEnter2D = nameof(OnTriggerEnter2D);
+        public const string OnTriggerExit2D = nameof(OnTriggerExit2D);
+        public const string OnTriggerStay2D = nameof(OnTriggerStay2D);
+        public const string OnAnimatorMove = nameof(OnAnimatorMove);
+        public const string OnAnimatorIK = nameof(OnAnimatorIK);
+
+        // GUI
+        public const string OnButtonClick = nameof(OnButtonClick);
+        public const string OnToggleValueChanged = nameof(OnToggleValueChanged);
+        public const string OnSliderValueChanged = nameof(OnSliderValueChanged);
+        public const string OnScrollbarValueChanged = nameof(OnScrollbarValueChanged);
+        public const string OnDropdownValueChanged = nameof(OnDropdownValueChanged);
+        public const string OnInputFieldValueChanged = nameof(OnInputFieldValueChanged);
+        public const string OnInputFieldEndEdit = nameof(OnInputFieldEndEdit);
+        public const string OnScrollRectValueChanged = nameof(OnScrollRectValueChanged);
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/EventMachine.cs

@@ -0,0 +1,133 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    public abstract class EventMachine<TGraph, TMacro> : Machine<TGraph, TMacro>, IEventMachine
+        where TGraph : class, IGraph, new()
+        where TMacro : Macro<TGraph>, new()
+    {
+        protected void TriggerEvent(string name)
+        {
+            if (hasGraph)
+            {
+                TriggerRegisteredEvent(new EventHook(name, this), new EmptyEventArgs());
+            }
+        }
+
+        protected void TriggerEvent<TArgs>(string name, TArgs args)
+        {
+            if (hasGraph)
+            {
+                TriggerRegisteredEvent(new EventHook(name, this), args);
+            }
+        }
+
+        protected void TriggerUnregisteredEvent(string name)
+        {
+            if (hasGraph)
+            {
+                TriggerUnregisteredEvent(name, new EmptyEventArgs());
+            }
+        }
+
+        protected virtual void TriggerRegisteredEvent<TArgs>(EventHook hook, TArgs args)
+        {
+            EventBus.Trigger(hook, args);
+        }
+
+        protected virtual void TriggerUnregisteredEvent<TArgs>(EventHook hook, TArgs args)
+        {
+            using (var stack = reference.ToStackPooled())
+            {
+                stack.TriggerEventHandler(_hook => _hook == hook, args, parent => true, true);
+            }
+        }
+
+        protected override void Awake()
+        {
+            base.Awake();
+
+            GlobalMessageListener.Require();
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            TriggerEvent(EventHooks.OnEnable);
+        }
+
+        protected virtual void Start()
+        {
+            TriggerEvent(EventHooks.Start);
+        }
+
+        protected override void OnInstantiateWhileEnabled()
+        {
+            base.OnInstantiateWhileEnabled();
+
+            TriggerEvent(EventHooks.OnEnable);
+        }
+
+        protected virtual void Update()
+        {
+            TriggerEvent(EventHooks.Update);
+        }
+
+        protected virtual void FixedUpdate()
+        {
+            TriggerEvent(EventHooks.FixedUpdate);
+        }
+
+        protected virtual void LateUpdate()
+        {
+            TriggerEvent(EventHooks.LateUpdate);
+        }
+
+        protected override void OnUninstantiateWhileEnabled()
+        {
+            TriggerEvent(EventHooks.OnDisable);
+
+            base.OnUninstantiateWhileEnabled();
+        }
+
+        protected override void OnDisable()
+        {
+            TriggerEvent(EventHooks.OnDisable);
+
+            base.OnDisable();
+        }
+
+        protected override void OnDestroy()
+        {
+            try
+            {
+                TriggerEvent(EventHooks.OnDestroy);
+            }
+            finally
+            {
+                base.OnDestroy();
+            }
+        }
+
+        public override void TriggerAnimationEvent(AnimationEvent animationEvent)
+        {
+            TriggerEvent(EventHooks.AnimationEvent, animationEvent);
+        }
+
+        public override void TriggerUnityEvent(string name)
+        {
+            TriggerEvent(EventHooks.UnityEvent, name);
+        }
+
+        protected virtual void OnDrawGizmos()
+        {
+            TriggerUnregisteredEvent(EventHooks.OnDrawGizmos);
+        }
+
+        protected virtual void OnDrawGizmosSelected()
+        {
+            TriggerUnregisteredEvent(EventHooks.OnDrawGizmosSelected);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/FrameDelayedCallback.cs

@@ -0,0 +1,37 @@
+#if UNITY_EDITOR
+using UnityEditor;
+
+namespace Unity.VisualScripting
+{
+    public class FrameDelayedCallback
+    {
+        private System.Action m_Callback;
+        private int m_FrameDelay;
+        public FrameDelayedCallback(System.Action function, int frameDelay)
+        {
+            m_Callback = function;
+            m_FrameDelay = frameDelay;
+            EditorApplication.update += Update;
+        }
+
+        public void Clear()
+        {
+            EditorApplication.update -= Update;
+            m_FrameDelay = 0;
+            m_Callback = null;
+        }
+
+        private void Update()
+        {
+            if (--m_FrameDelay == 0)
+            {
+                // Clear state before firing callback to ensure reset (callback could call ExitGUI)
+                var callback = m_Callback;
+                Clear();
+
+                callback?.Invoke();
+            }
+        }
+    }
+}
+#endif

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/GlobalMessageListener.cs

@@ -0,0 +1,52 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [Singleton(Name = "Global Event Listener", Automatic = true, Persistent = true)]
+    [DisableAnnotation]
+    [AddComponentMenu("")]
+    [IncludeInSettings(false)]
+    [TypeIcon(typeof(MessageListener))]
+    public sealed class GlobalMessageListener : MonoBehaviour, ISingleton
+    {
+        private void OnGUI()
+        {
+            EventBus.Trigger(EventHooks.OnGUI);
+        }
+
+        private void OnApplicationFocus(bool focus)
+        {
+            if (focus)
+            {
+                EventBus.Trigger(EventHooks.OnApplicationFocus);
+            }
+            else
+            {
+                EventBus.Trigger(EventHooks.OnApplicationLostFocus);
+            }
+        }
+
+        private void OnApplicationPause(bool paused)
+        {
+            if (paused)
+            {
+                EventBus.Trigger(EventHooks.OnApplicationPause);
+            }
+            else
+            {
+                EventBus.Trigger(EventHooks.OnApplicationResume);
+            }
+        }
+
+        private void OnApplicationQuit()
+        {
+            EventBus.Trigger(EventHooks.OnApplicationQuit);
+        }
+
+        public static void Require()
+        {
+            // Call the singleton getter to force instantiation
+            var instance = Singleton<GlobalMessageListener>.instance;
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/IEventGraph.cs

@@ -0,0 +1,63 @@
+using System;
+
+namespace Unity.VisualScripting
+{
+    public static class XEventGraph
+    {
+        public static void TriggerEventHandler<TArgs>(this GraphReference reference, Func<EventHook, bool> predicate, TArgs args, Func<IGraphParentElement, bool> recurse, bool force)
+        {
+            Ensure.That(nameof(reference)).IsNotNull(reference);
+
+            foreach (var element in reference.graph.elements)
+            {
+                if (element is IGraphEventHandler<TArgs> handler && (predicate?.Invoke(handler.GetHook(reference)) ?? true))
+                {
+                    if (force || handler.IsListening(reference))
+                    {
+                        handler.Trigger(reference, args);
+                    }
+                }
+
+                if (element is IGraphParentElement parentElement && recurse(parentElement))
+                {
+                    reference.ChildReference(parentElement, false, 0)?.TriggerEventHandler(predicate, args, recurse, force);
+                }
+            }
+        }
+
+        public static void TriggerEventHandler<TArgs>(this GraphStack stack, Func<EventHook, bool> predicate, TArgs args, Func<IGraphParentElement, bool> recurse, bool force)
+        {
+            Ensure.That(nameof(stack)).IsNotNull(stack);
+
+            GraphReference reference = null;
+
+            foreach (var element in stack.graph.elements)
+            {
+                if (element is IGraphEventHandler<TArgs> handler)
+                {
+                    if (reference == null)
+                    {
+                        reference = stack.ToReference();
+                    }
+
+                    if (predicate == null || predicate.Invoke(handler.GetHook(reference)))
+                    {
+                        if (force || handler.IsListening(reference))
+                        {
+                            handler.Trigger(reference, args);
+                        }
+                    }
+                }
+
+                if (element is IGraphParentElement parentElement && recurse(parentElement))
+                {
+                    if (stack.TryEnterParentElementUnsafe(parentElement))
+                    {
+                        stack.TriggerEventHandler(predicate, args, recurse, force);
+                        stack.ExitParentElement();
+                    }
+                }
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/IEventMachine.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    public interface IEventMachine : IMachine
+    {
+        void TriggerAnimationEvent(AnimationEvent animationEvent);
+        void TriggerUnityEvent(string name);
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/IGraphEventHandler.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    public interface IGraphEventHandler<TArgs>
+    {
+        EventHook GetHook(GraphReference reference);
+
+        void Trigger(GraphReference reference, TArgs args);
+
+        bool IsListening(GraphPointer pointer);
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/IGraphEventListener.cs

@@ -0,0 +1,58 @@
+namespace Unity.VisualScripting
+{
+    public interface IGraphEventListener
+    {
+        void StartListening(GraphStack stack);
+
+        void StopListening(GraphStack stack);
+
+        bool IsListening(GraphPointer pointer);
+    }
+
+    public static class XGraphEventListener
+    {
+        public static void StartListening(this IGraphEventListener listener, GraphReference reference)
+        {
+            using (var stack = reference.ToStackPooled())
+            {
+                listener.StartListening(stack);
+            }
+        }
+
+        public static void StopListening(this IGraphEventListener listener, GraphReference reference)
+        {
+            using (var stack = reference.ToStackPooled())
+            {
+                listener.StopListening(stack);
+            }
+        }
+
+        public static bool IsHierarchyListening(GraphReference reference)
+        {
+            using (var stack = reference.ToStackPooled())
+            {
+                // Check if any parent of the graph is not listening
+                while (stack.isChild)
+                {
+                    var parent = stack.parent;
+
+                    // Exit the parent first, as the IsListening method expects to be at the level of the parent
+                    stack.ExitParentElement();
+
+                    if (parent is IGraphEventListener listener && !listener.IsListening(stack))
+                    {
+                        return false;
+                    }
+                }
+
+                // Check if the root graph is not listening
+                if (stack.graph is IGraphEventListener graphListener && !graphListener.IsListening(stack))
+                {
+                    return false;
+                }
+
+                return true;
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/IGraphEventListenerData.cs

@@ -0,0 +1,7 @@
+namespace Unity.VisualScripting
+{
+    public interface IGraphEventListenerData : IGraphData
+    {
+        bool isListening { get; }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListener.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Assertions;
+
+namespace Unity.VisualScripting
+{
+    [DisableAnnotation]
+    [AddComponentMenu("")]
+    [IncludeInSettings(false)]
+    public abstract class MessageListener : MonoBehaviour
+    {
+        private static Type[] _listenerTypes;
+
+        [Obsolete("listenerTypes is deprecated", false)]
+        public static Type[] listenerTypes
+        {
+            get
+            {
+                if (_listenerTypes == null)
+                {
+                    _listenerTypes = RuntimeCodebase.types
+                        .Where(t => typeof(MessageListener).IsAssignableFrom(t) && t.IsConcrete() && !Attribute.IsDefined(t, typeof(ObsoleteAttribute)))
+                        .ToArray();
+                }
+
+                return _listenerTypes;
+            }
+        }
+
+        [Obsolete("Use the overload with a messageListenerType parameter instead", false)]
+        public static void AddTo(GameObject gameObject)
+        {
+            foreach (var listenerType in listenerTypes)
+            {
+                if (gameObject.GetComponent(listenerType) == null)
+                {
+                    gameObject.AddComponent(listenerType);
+                }
+            }
+        }
+
+        public static void AddTo(Type messageListenerType, GameObject gameObject)
+        {
+            Assert.IsNotNull(messageListenerType, "The messageListenerType must not be null");
+#if UNITY_2019_4_OR_NEWER
+            if (!gameObject.TryGetComponent(messageListenerType, out _))
+#else
+            if (gameObject.GetComponent(messageListenerType) != null)
+#endif
+                gameObject.AddComponent(messageListenerType);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnBecameInvisibleMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnBecameInvisibleMessageListener : MessageListener
+    {
+        private void OnBecameInvisible()
+        {
+            EventBus.Trigger(EventHooks.OnBecameInvisible, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnBecameVisibleMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnBecameVisibleMessageListener : MessageListener
+    {
+        private void OnBecameVisible()
+        {
+            EventBus.Trigger(EventHooks.OnBecameVisible, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionEnter2DMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionEnter2DMessageListener : MessageListener
+    {
+        private void OnCollisionEnter2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionEnter2D, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionEnterMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionEnterMessageListener : MessageListener
+    {
+        private void OnCollisionEnter(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionEnter, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionExit2DMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionExit2DMessageListener : MessageListener
+    {
+        private void OnCollisionExit2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionExit2D, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionExitMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionExitMessageListener : MessageListener
+    {
+        private void OnCollisionExit(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionExit, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionStay2DMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionStay2DMessageListener : MessageListener
+    {
+        private void OnCollisionStay2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionStay2D, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnCollisionStayMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnCollisionStayMessageListener : MessageListener
+    {
+        private void OnCollisionStay(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionStay, gameObject, collision);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnControllerColliderHitMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnControllerColliderHitMessageListener : MessageListener
+    {
+        private void OnControllerColliderHit(ControllerColliderHit hit)
+        {
+            EventBus.Trigger(EventHooks.OnControllerColliderHit, gameObject, hit);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnJointBreak2DMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnJointBreak2DMessageListener : MessageListener
+    {
+        private void OnJointBreak2D(Joint2D brokenJoint)
+        {
+            EventBus.Trigger(EventHooks.OnJointBreak2D, gameObject, brokenJoint);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnJointBreakMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnJointBreakMessageListener : MessageListener
+    {
+        private void OnJointBreak(float breakForce)
+        {
+            EventBus.Trigger(EventHooks.OnJointBreak, gameObject, breakForce);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseDownMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseDownMessageListener : MessageListener
+    {
+        private void OnMouseDown()
+        {
+            EventBus.Trigger(EventHooks.OnMouseDown, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseDragMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseDragMessageListener : MessageListener
+    {
+        private void OnMouseDrag()
+        {
+            EventBus.Trigger(EventHooks.OnMouseDrag, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseEnterMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseEnterMessageListener : MessageListener
+    {
+        private void OnMouseEnter()
+        {
+            EventBus.Trigger(EventHooks.OnMouseEnter, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseExitMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseExitMessageListener : MessageListener
+    {
+        private void OnMouseExit()
+        {
+            EventBus.Trigger(EventHooks.OnMouseExit, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseOverMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseOverMessageListener : MessageListener
+    {
+        private void OnMouseOver()
+        {
+            EventBus.Trigger(EventHooks.OnMouseOver, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseUpAsButtonMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseUpAsButtonMessageListener : MessageListener
+    {
+        private void OnMouseUpAsButton()
+        {
+            EventBus.Trigger(EventHooks.OnMouseUpAsButton, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnMouseUpMessageListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMouseUpMessageListener : MessageListener
+    {
+        private void OnMouseUp()
+        {
+            EventBus.Trigger(EventHooks.OnMouseUp, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnParticleCollisionMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnParticleCollisionMessageListener : MessageListener
+    {
+        private void OnParticleCollision(GameObject other)
+        {
+            EventBus.Trigger(EventHooks.OnParticleCollision, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTransformChildrenChangedMListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnTransformChildrenChangedMessageListener : MessageListener
+    {
+        private void OnTransformChildrenChanged()
+        {
+            EventBus.Trigger(EventHooks.OnTransformChildrenChanged, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTransformParentChangedMListener.cs

@@ -0,0 +1,11 @@
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnTransformParentChangedMessageListener : MessageListener
+    {
+        private void OnTransformParentChanged()
+        {
+            EventBus.Trigger(EventHooks.OnTransformParentChanged, gameObject);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerEnter2DMListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerEnter2DMessageListener : MessageListener
+    {
+        private void OnTriggerEnter2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerEnter2D, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerEnterMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerEnterMessageListener : MessageListener
+    {
+        private void OnTriggerEnter(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerEnter, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerExit2DMListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerExit2DMessageListener : MessageListener
+    {
+        private void OnTriggerExit2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerExit2D, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerExitMListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerExitMessageListener : MessageListener
+    {
+        private void OnTriggerExit(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerExit, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerStay2DMListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerStay2DMessageListener : MessageListener
+    {
+        private void OnTriggerStay2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerStay2D, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/MonoBehaviourMessageListeners/UnityOnTriggerStayMListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    public sealed class UnityOnTriggerStayMessageListener : MessageListener
+    {
+        private void OnTriggerStay(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerStay, gameObject, other);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnBeginDragMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnBeginDragMessageListener : MessageListener, IBeginDragHandler
+    {
+        public void OnBeginDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnBeginDrag, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnCancelMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnCancelMessageListener : MessageListener, ICancelHandler
+    {
+        public void OnCancel(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnCancel, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnDeselectMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnDeselectMessageListener : MessageListener, IDeselectHandler
+    {
+        public void OnDeselect(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDeselect, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnDragMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnDragMessageListener : MessageListener, IDragHandler
+    {
+        public void OnDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDrag, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnDropMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnDropMessageListener : MessageListener, IDropHandler
+    {
+        public void OnDrop(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDrop, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnEndDragMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnEndDragMessageListener : MessageListener, IEndDragHandler
+    {
+        public void OnEndDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnEndDrag, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnMoveMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnMoveMessageListener : MessageListener, IMoveHandler
+    {
+        public void OnMove(AxisEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnMove, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnPointerClickMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnPointerClickMessageListener : MessageListener, IPointerClickHandler
+    {
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerClick, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnPointerDownMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnPointerDownMessageListener : MessageListener, IPointerDownHandler
+    {
+        public void OnPointerDown(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerDown, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnPointerEnterMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnPointerEnterMessageListener : MessageListener, IPointerEnterHandler
+    {
+        public void OnPointerEnter(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerEnter, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnPointerExitMessageListener.cs

@@ -0,0 +1,11 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnPointerExitMessageListener : MessageListener, IPointerExitHandler
+    {
+        public void OnPointerExit(PointerEventData eventData) =>
+            EventBus.Trigger(EventHooks.OnPointerExit, gameObject, eventData);
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnPointerUpMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnPointerUpMessageListener : MessageListener, IPointerUpHandler
+    {
+        public void OnPointerUp(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerUp, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnScrollMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnScrollMessageListener : MessageListener, IScrollHandler
+    {
+        public void OnScroll(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnScroll, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnSelectMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnSelectMessageListener : MessageListener, ISelectHandler
+    {
+        public void OnSelect(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnSelect, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsInterfacesListeners/UnityOnSubmitMessageListener.cs

@@ -0,0 +1,13 @@
+using UnityEngine.EventSystems;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnSubmitMessageListener : MessageListener, ISubmitHandler
+    {
+        public void OnSubmit(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnSubmit, gameObject, eventData);
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnButtonClickMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnButtonClickMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<Button>()?.onClick
+            ?.AddListener(() => EventBus.Trigger(EventHooks.OnButtonClick, gameObject));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnDropdownValueChangedMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnDropdownValueChangedMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<Dropdown>()?.onValueChanged?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnDropdownValueChanged, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnInputFieldEndEditMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnInputFieldEndEditMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<InputField>()?.onEndEdit?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnInputFieldEndEdit, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnInputFieldValueChangedMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnInputFieldValueChangedMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<InputField>()?.onValueChanged?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnInputFieldValueChanged, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnScrollRectValueChangedMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnScrollRectValueChangedMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<ScrollRect>()?.onValueChanged?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnScrollRectValueChanged, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnScrollbarValueChangedMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnScrollbarValueChangedMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<Scrollbar>()?.onValueChanged?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnScrollbarValueChanged, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnSliderValueChangedMessageListener.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnSliderValueChangedMessageListener : MessageListener
+    {
+        private void Start()
+        {
+            GetComponent<Slider>()?.onValueChanged?.AddListener((value) =>
+                EventBus.Trigger(EventHooks.OnSliderValueChanged, gameObject, value));
+        }
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/MessageListeners/UIEventsListeners/UnityOnToggleValueChangedMessageListener.cs

@@ -0,0 +1,11 @@
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [UnityEngine.AddComponentMenu("")]
+    public sealed class UnityOnToggleValueChangedMessageListener : MessageListener
+    {
+        private void Start() => GetComponent<Toggle>()?.onValueChanged?.AddListener((value) =>
+            EventBus.Trigger(EventHooks.OnToggleValueChanged, gameObject, value));
+    }
+}

Library/PackageCache/com.unity.visualscripting@1.6.1/Runtime/VisualScripting.Core/Events/UnityMessageListener.cs

@@ -0,0 +1,266 @@
+using System;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace Unity.VisualScripting
+{
+    [AddComponentMenu("")]
+    [Obsolete("UnityMessageListener is deprecated and has been replaced by separate message listeners for each event, eg. UnityOnCollisionEnterMessageListener or UnityOnButtonClickMessageListener.")]
+    public sealed class UnityMessageListener : MessageListener,
+                                               IPointerEnterHandler,
+                                               IPointerExitHandler,
+                                               IPointerDownHandler,
+                                               IPointerUpHandler,
+                                               IPointerClickHandler,
+
+                                               IBeginDragHandler,
+                                               IDragHandler,
+                                               IEndDragHandler,
+                                               IDropHandler,
+                                               IScrollHandler,
+
+                                               ISelectHandler,
+                                               IDeselectHandler,
+
+                                               ISubmitHandler,
+                                               ICancelHandler,
+
+                                               IMoveHandler
+    {
+        private void Start()
+        {
+            AddGUIListeners();
+        }
+
+        #region GUI
+
+        public void AddGUIListeners()
+        {
+            GetComponent<Button>()?.onClick?.AddListener(() => EventBus.Trigger(EventHooks.OnButtonClick, gameObject));
+            GetComponent<Toggle>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnToggleValueChanged, gameObject, value));
+            GetComponent<Slider>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnSliderValueChanged, gameObject, value));
+            GetComponent<Scrollbar>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnScrollbarValueChanged, gameObject, value));
+            GetComponent<Dropdown>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnDropdownValueChanged, gameObject, value));
+            GetComponent<InputField>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnInputFieldValueChanged, gameObject, value));
+            GetComponent<InputField>()?.onEndEdit?.AddListener((value) => EventBus.Trigger(EventHooks.OnInputFieldEndEdit, gameObject, value));
+            GetComponent<ScrollRect>()?.onValueChanged?.AddListener((value) => EventBus.Trigger(EventHooks.OnScrollRectValueChanged, gameObject, value));
+        }
+
+        // TODO: Profile performance on these. If they add significant overhead,
+        // we should detect whether there is a GUI component on the object before
+        // adding a separate UnityEventSystemListener component with these interfaces
+
+        public void OnPointerEnter(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerEnter, gameObject, eventData);
+        }
+
+        public void OnPointerExit(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerExit, gameObject, eventData);
+        }
+
+        public void OnPointerDown(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerDown, gameObject, eventData);
+        }
+
+        public void OnPointerUp(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerUp, gameObject, eventData);
+        }
+
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnPointerClick, gameObject, eventData);
+        }
+
+        public void OnBeginDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnBeginDrag, gameObject, eventData);
+        }
+
+        public void OnDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDrag, gameObject, eventData);
+        }
+
+        public void OnEndDrag(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnEndDrag, gameObject, eventData);
+        }
+
+        public void OnDrop(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDrop, gameObject, eventData);
+        }
+
+        public void OnScroll(PointerEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnScroll, gameObject, eventData);
+        }
+
+        public void OnSelect(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnSelect, gameObject, eventData);
+        }
+
+        public void OnDeselect(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnDeselect, gameObject, eventData);
+        }
+
+        public void OnSubmit(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnSubmit, gameObject, eventData);
+        }
+
+        public void OnCancel(BaseEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnCancel, gameObject, eventData);
+        }
+
+        public void OnMove(AxisEventData eventData)
+        {
+            EventBus.Trigger(EventHooks.OnMove, gameObject, eventData);
+        }
+
+        #endregion
+
+        private void OnBecameInvisible()
+        {
+            EventBus.Trigger(EventHooks.OnBecameInvisible, gameObject);
+        }
+
+        private void OnBecameVisible()
+        {
+            EventBus.Trigger(EventHooks.OnBecameVisible, gameObject);
+        }
+
+        private void OnCollisionEnter(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionEnter, gameObject, collision);
+        }
+
+        private void OnCollisionExit(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionExit, gameObject, collision);
+        }
+
+        private void OnCollisionStay(Collision collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionStay, gameObject, collision); ;
+        }
+
+        private void OnCollisionEnter2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionEnter2D, gameObject, collision);
+        }
+
+        private void OnCollisionExit2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionExit2D, gameObject, collision);
+        }
+
+        private void OnCollisionStay2D(Collision2D collision)
+        {
+            EventBus.Trigger(EventHooks.OnCollisionStay2D, gameObject, collision);
+        }
+
+        private void OnControllerColliderHit(ControllerColliderHit hit)
+        {
+            EventBus.Trigger(EventHooks.OnControllerColliderHit, gameObject, hit);
+        }
+
+        private void OnJointBreak(float breakForce)
+        {
+            EventBus.Trigger(EventHooks.OnJointBreak, gameObject, breakForce);
+        }
+
+        private void OnJointBreak2D(Joint2D brokenJoint)
+        {
+            EventBus.Trigger(EventHooks.OnJointBreak2D, gameObject, brokenJoint);
+        }
+
+        private void OnMouseDown()
+        {
+            EventBus.Trigger(EventHooks.OnMouseDown, gameObject);
+        }
+
+        private void OnMouseDrag()
+        {
+            EventBus.Trigger(EventHooks.OnMouseDrag, gameObject);
+        }
+
+        private void OnMouseEnter()
+        {
+            EventBus.Trigger(EventHooks.OnMouseEnter, gameObject);
+        }
+
+        private void OnMouseExit()
+        {
+            EventBus.Trigger(EventHooks.OnMouseExit, gameObject);
+        }
+
+        private void OnMouseOver()
+        {
+            EventBus.Trigger(EventHooks.OnMouseOver, gameObject);
+        }
+
+        private void OnMouseUp()
+        {
+            EventBus.Trigger(EventHooks.OnMouseUp, gameObject);
+        }
+
+        private void OnMouseUpAsButton()
+        {
+            EventBus.Trigger(EventHooks.OnMouseUpAsButton, gameObject);
+        }
+
+        private void OnParticleCollision(GameObject other)
+        {
+            EventBus.Trigger(EventHooks.OnParticleCollision, gameObject, other);
+        }
+
+        private void OnTransformChildrenChanged()
+        {
+            EventBus.Trigger(EventHooks.OnTransformChildrenChanged, gameObject);
+        }
+
+        private void OnTransformParentChanged()
+        {
+            EventBus.Trigger(EventHooks.OnTransformParentChanged, gameObject);
+        }
+
+        private void OnTriggerEnter(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerEnter, gameObject, other);
+        }
+
+        private void OnTriggerExit(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerExit, gameObject, other);
+        }
+
+        private void OnTriggerStay(Collider other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerStay, gameObject, other);
+        }
+
+        private void OnTriggerEnter2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerEnter2D, gameObject, other);
+        }
+
+        private void OnTriggerExit2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerExit2D, gameObject, other);
+        }
+
+        private void OnTriggerStay2D(Collider2D other)
+        {
+            EventBus.Trigger(EventHooks.OnTriggerStay2D, gameObject, other);
+        }
+    }
+}