Initial Commit

2026-03-16 14:38:46 +02:00
commit b8f7327a21
2327 changed files with 253610 additions and 0 deletions
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 610ec45090eac884ba824be81ada42fb
+folderAsset: yes
+timeCreated: 1521277428
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,67 @@
+using System;
+using ModestTree;
+
+namespace Zenject
+{
+    public class BindSignalFromBinder<TObject, TSignal>
+    {
+        readonly BindStatement _bindStatement;
+        readonly Func<TObject, Action<TSignal>> _methodGetter;
+        readonly DiContainer _container;
+        readonly SignalBindingBindInfo _signalBindInfo;
+
+        public BindSignalFromBinder(
+            SignalBindingBindInfo signalBindInfo, BindStatement bindStatement, Func<TObject, Action<TSignal>> methodGetter,
+            DiContainer container)
+        {
+            _signalBindInfo = signalBindInfo;
+            _bindStatement = bindStatement;
+            _methodGetter = methodGetter;
+            _container = container;
+        }
+
+        public SignalCopyBinder FromResolve()
+        {
+            return From(x => x.FromResolve().AsCached());
+        }
+
+        public SignalCopyBinder FromResolveAll()
+        {
+            return From(x => x.FromResolveAll().AsCached());
+        }
+
+        public SignalCopyBinder FromNew()
+        {
+            return From(x => x.FromNew().AsCached());
+        }
+
+        public SignalCopyBinder From(Action<ConcreteBinderGeneric<TObject>> objectBindCallback)
+        {
+            Assert.That(!_bindStatement.HasFinalizer);
+            _bindStatement.SetFinalizer(new NullBindingFinalizer());
+
+            var objectLookupId = Guid.NewGuid();
+
+            // Very important here that we use NoFlush otherwise the main binding will be finalized early
+            var objectBinder = _container.BindNoFlush<TObject>().WithId(objectLookupId);
+
+            objectBindCallback(objectBinder);
+
+            // We need to do this to make sure SignalCallbackWithLookupWrapper does not have
+            // generic types to avoid AOT issues
+            Func<object, Action<object>> methodGetterMapper =
+                obj => s => _methodGetter((TObject)obj)((TSignal)s);
+
+            var wrapperBinder = _container.Bind<IDisposable>()
+                .To<SignalCallbackWithLookupWrapper>()
+                .AsCached()
+                .WithArguments(_signalBindInfo, typeof(TObject), objectLookupId, methodGetterMapper)
+                .NonLazy();
+
+            var copyBinder = new SignalCopyBinder( wrapperBinder.BindInfo);
+            // Make sure if they use one of the Copy/Move methods that it applies to both bindings
+            copyBinder.AddCopyBindInfo(objectBinder.BindInfo);
+            return copyBinder;
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c779f758eaadfd54fb9c66f7acc75716
+timeCreated: 1521288279
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,20 @@
+using System;
+using ModestTree;
+
+namespace Zenject
+{
+    public class BindSignalIdToBinder<TSignal> : BindSignalToBinder<TSignal>
+    {
+        public BindSignalIdToBinder(DiContainer container, SignalBindingBindInfo signalBindInfo)
+            : base(container, signalBindInfo)
+        {
+        }
+
+        public BindSignalToBinder<TSignal> WithId(object identifier)
+        {
+            SignalBindInfo.Identifier = identifier;
+            return this;
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ecce6d44c178e564c8937125741f3c8c
+timeCreated: 1538401230
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,64 @@
+using System;
+using ModestTree;
+
+namespace Zenject
+{
+    public class BindSignalToBinder<TSignal>
+    {
+        DiContainer _container;
+        BindStatement _bindStatement;
+        SignalBindingBindInfo _signalBindInfo;
+
+        public BindSignalToBinder(DiContainer container, SignalBindingBindInfo signalBindInfo)
+        {
+            _container = container;
+
+            _signalBindInfo = signalBindInfo;
+            // This will ensure that they finish the binding
+            _bindStatement = container.StartBinding();
+        }
+
+        protected SignalBindingBindInfo SignalBindInfo
+        {
+            get { return _signalBindInfo; }
+        }
+
+        public SignalCopyBinder ToMethod(Action<TSignal> callback)
+        {
+            Assert.That(!_bindStatement.HasFinalizer);
+            _bindStatement.SetFinalizer(new NullBindingFinalizer());
+
+            var bindInfo = _container.Bind<IDisposable>()
+                .To<SignalCallbackWrapper>()
+                .AsCached()
+                // Note that there's a reason we don't just make SignalCallbackWrapper have a generic
+                // argument for signal type - because when using struct type signals it throws
+                // exceptions on AOT platforms
+                .WithArguments(_signalBindInfo, (Action<object>)(o => callback((TSignal)o)))
+                .NonLazy().BindInfo;
+
+            return new SignalCopyBinder(bindInfo);
+        }
+
+        public SignalCopyBinder ToMethod(Action callback)
+        {
+            return ToMethod(signal => callback());
+        }
+
+        public BindSignalFromBinder<TObject, TSignal> ToMethod<TObject>(Action<TObject, TSignal> handler)
+        {
+            return ToMethod<TObject>(x => (Action<TSignal>)(s => handler(x, s)));
+        }
+
+        public BindSignalFromBinder<TObject, TSignal> ToMethod<TObject>(Func<TObject, Action> handlerGetter)
+        {
+            return ToMethod<TObject>(x => (Action<TSignal>)(s => handlerGetter(x)()));
+        }
+
+        public BindSignalFromBinder<TObject, TSignal> ToMethod<TObject>(Func<TObject, Action<TSignal>> handlerGetter)
+        {
+            return new BindSignalFromBinder<TObject, TSignal>(
+                _signalBindInfo, _bindStatement, handlerGetter, _container);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 6df1bca64a984074fb4af41dc1d42a07
+timeCreated: 1521288279
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,53 @@
+using System;
+
+namespace Zenject
+{
+    // Note that there's a reason we don't just have a generic
+    // argument for signal type - because when using struct type signals it throws
+    // exceptions on AOT platforms
+    public class SignalCallbackWithLookupWrapper : IDisposable
+    {
+        readonly DiContainer _container;
+        readonly SignalBus _signalBus;
+        readonly Guid _lookupId;
+        readonly Func<object, Action<object>> _methodGetter;
+        readonly Type _objectType;
+        readonly Type _signalType;
+        readonly object _identifier;
+
+        public SignalCallbackWithLookupWrapper(
+            SignalBindingBindInfo signalBindInfo,
+            Type objectType,
+            Guid lookupId,
+            Func<object, Action<object>> methodGetter,
+            SignalBus signalBus,
+            DiContainer container)
+        {
+            _objectType = objectType;
+            _signalType = signalBindInfo.SignalType;
+            _identifier = signalBindInfo.Identifier;
+            _container = container;
+            _methodGetter = methodGetter;
+            _signalBus = signalBus;
+            _lookupId = lookupId;
+
+            signalBus.SubscribeId(signalBindInfo.SignalType, _identifier, OnSignalFired);
+        }
+
+        void OnSignalFired(object signal)
+        {
+            var objects = _container.ResolveIdAll(_objectType, _lookupId);
+
+            for (int i = 0; i < objects.Count; i++)
+            {
+                _methodGetter(objects[i])(signal);
+            }
+        }
+
+        public void Dispose()
+        {
+            _signalBus.UnsubscribeId(_signalType, _identifier, OnSignalFired);
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 2b11a635fa1263c4f9a9a0d70d7efcf2
+timeCreated: 1521293791
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,38 @@
+using System;
+
+namespace Zenject
+{
+    // Note that there's a reason we don't just have a generic
+    // argument for signal type - because when using struct type signals it throws
+    // exceptions on AOT platforms
+    public class SignalCallbackWrapper : IDisposable
+    {
+        readonly SignalBus _signalBus;
+        readonly Action<object> _action;
+        readonly Type _signalType;
+        readonly object _identifier;
+
+        public SignalCallbackWrapper(
+            SignalBindingBindInfo bindInfo,
+            Action<object> action,
+            SignalBus signalBus)
+        {
+            _signalType = bindInfo.SignalType;
+            _identifier = bindInfo.Identifier;
+            _signalBus = signalBus;
+            _action = action;
+
+            signalBus.SubscribeId(bindInfo.SignalType, _identifier, OnSignalFired);
+        }
+
+        void OnSignalFired(object signal)
+        {
+            _action(signal);
+        }
+
+        public void Dispose()
+        {
+            _signalBus.UnsubscribeId(_signalType, _identifier, OnSignalFired);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 9a8599dbdf9033e468671e40de134ccf
+timeCreated: 1521289018
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7fe74811bfda2ef4ca9791eab479b27a
+folderAsset: yes
+timeCreated: 1521277428
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,24 @@
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class DeclareSignalAsyncTickPriorityCopyBinder : SignalTickPriorityCopyBinder
+    {
+        public DeclareSignalAsyncTickPriorityCopyBinder(SignalDeclarationBindInfo signalBindInfo)
+            : base(signalBindInfo)
+        {
+        }
+
+        public SignalTickPriorityCopyBinder RunAsync()
+        {
+            SignalBindInfo.RunAsync = true;
+            return this;
+        }
+
+        public SignalCopyBinder RunSync()
+        {
+            SignalBindInfo.RunAsync = false;
+            return this;
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b81f91889a4f58f45a186d306ec19a76
+timeCreated: 1529046908
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,20 @@
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder : DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder
+    {
+        public DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder(
+            SignalDeclarationBindInfo signalBindInfo)
+            : base(signalBindInfo)
+        {
+        }
+
+        public DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder WithId(object identifier)
+        {
+            SignalBindInfo.Identifier = identifier;
+            return this;
+        }
+    }
+}
+
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 183994f131b561a43a9967cceb7c949d
+timeCreated: 1538037476
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,31 @@
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder : DeclareSignalAsyncTickPriorityCopyBinder
+    {
+        public DeclareSignalRequireHandlerAsyncTickPriorityCopyBinder(
+            SignalDeclarationBindInfo signalBindInfo)
+            : base(signalBindInfo)
+        {
+        }
+
+        public DeclareSignalAsyncTickPriorityCopyBinder RequireSubscriber()
+        {
+            SignalBindInfo.MissingHandlerResponse = SignalMissingHandlerResponses.Throw;
+            return this;
+        }
+
+        public DeclareSignalAsyncTickPriorityCopyBinder OptionalSubscriber()
+        {
+            SignalBindInfo.MissingHandlerResponse = SignalMissingHandlerResponses.Ignore;
+            return this;
+        }
+
+        public DeclareSignalAsyncTickPriorityCopyBinder OptionalSubscriberWithWarning()
+        {
+            SignalBindInfo.MissingHandlerResponse = SignalMissingHandlerResponses.Warn;
+            return this;
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 7cc67ec88be096e4a89e01987d671cb9
+timeCreated: 1529046908
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,24 @@
+using System;
+
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class SignalBindingBindInfo
+    {
+        public SignalBindingBindInfo(Type signalType)
+        {
+            SignalType = signalType;
+        }
+
+        public object Identifier
+        {
+            get; set;
+        }
+
+        public Type SignalType
+        {
+            get; private set;
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 054ec2c1e404fd04f99dcab4d9012db2
+timeCreated: 1538401117
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,38 @@
+using System;
+
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class SignalDeclarationBindInfo
+    {
+        public SignalDeclarationBindInfo(Type signalType)
+        {
+            SignalType = signalType;
+        }
+
+        public object Identifier
+        {
+            get; set;
+        }
+
+        public Type SignalType
+        {
+            get; private set;
+        }
+
+        public bool RunAsync
+        {
+            get; set;
+        }
+
+        public int TickPriority
+        {
+            get; set;
+        }
+
+        public SignalMissingHandlerResponses MissingHandlerResponse
+        {
+            get; set;
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1e83db91ff836874fb4fcf3ae4e16f0b
+timeCreated: 1521277428
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class SignalCopyBinder
+    {
+        readonly List<BindInfo> _bindInfos;
+
+        public SignalCopyBinder()
+        {
+            _bindInfos = new List<BindInfo>();
+        }
+
+        public SignalCopyBinder(BindInfo bindInfo)
+        {
+            _bindInfos = new List<BindInfo>
+            {
+                bindInfo
+            };
+        }
+
+        // This is used in cases where you have multiple bindings that depend on each other so should
+        // be inherited together
+        public void AddCopyBindInfo(BindInfo bindInfo)
+        {
+            _bindInfos.Add(bindInfo);
+        }
+
+        public void CopyIntoAllSubContainers()
+        {
+            SetInheritanceMethod(BindingInheritanceMethods.CopyIntoAll);
+        }
+
+        // Only copy the binding into children and not grandchildren
+        public void CopyIntoDirectSubContainers()
+        {
+            SetInheritanceMethod(BindingInheritanceMethods.CopyDirectOnly);
+        }
+
+        // Do not apply the binding on the current container
+        public void MoveIntoAllSubContainers()
+        {
+            SetInheritanceMethod(BindingInheritanceMethods.MoveIntoAll);
+        }
+
+        // Do not apply the binding on the current container
+        public void MoveIntoDirectSubContainers()
+        {
+            SetInheritanceMethod(BindingInheritanceMethods.MoveDirectOnly);
+        }
+
+        void SetInheritanceMethod(BindingInheritanceMethods method)
+        {
+            for (int i = 0; i < _bindInfos.Count; i++)
+            {
+                _bindInfos[i].BindingInheritanceMethod = method;
+            }
+        }
+    }
+}
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 604fe2d23cc79c7498be851b6970af1b
+timeCreated: 1521266917
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,57 @@
+using System;
+namespace Zenject
+{
+    public static class SignalExtensions
+    {
+        public static SignalDeclarationBindInfo CreateDefaultSignalDeclarationBindInfo(DiContainer container, Type signalType)
+        {
+            return new SignalDeclarationBindInfo(signalType)
+            {
+                RunAsync = container.Settings.Signals.DefaultSyncMode == SignalDefaultSyncModes.Asynchronous,
+                MissingHandlerResponse = container.Settings.Signals.MissingHandlerDefaultResponse,
+                TickPriority = container.Settings.Signals.DefaultAsyncTickPriority
+            };
+        }
+
+        public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignal(this DiContainer container, Type type)
+        {
+            var signalBindInfo = CreateDefaultSignalDeclarationBindInfo(container, type);
+
+            var bindInfo = container.Bind<SignalDeclaration>().AsCached()
+                .WithArguments(signalBindInfo).WhenInjectedInto(typeof(SignalBus), typeof(SignalDeclarationAsyncInitializer)).BindInfo;
+
+            var signalBinder = new DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder(signalBindInfo);
+            signalBinder.AddCopyBindInfo(bindInfo);
+            return signalBinder;
+        }
+
+        public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignal<TSignal>(this DiContainer container)
+        {
+            return container.DeclareSignal(typeof(TSignal));
+        }
+
+        public static DeclareSignalIdRequireHandlerAsyncTickPriorityCopyBinder DeclareSignalWithInterfaces<TSignal>(this DiContainer container)
+        {
+            Type type = typeof(TSignal);
+
+            var declaration = container.DeclareSignal(type);
+
+            Type[] interfaces = type.GetInterfaces();
+            int numOfInterfaces = interfaces.Length;
+            for (int i = 0; i < numOfInterfaces; i++)
+            {
+                container.DeclareSignal(interfaces[i]);
+            }
+
+            return declaration;
+        }
+
+        public static BindSignalIdToBinder<TSignal> BindSignal<TSignal>(this DiContainer container)
+        {
+            var signalBindInfo = new SignalBindingBindInfo(typeof(TSignal));
+
+            return new BindSignalIdToBinder<TSignal>(container, signalBindInfo);
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ca6f0ad40fd1abc4a8fb5e8a50134aa4
+timeCreated: 1521266917
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,25 @@
+namespace Zenject
+{
+    [NoReflectionBaking]
+    public class SignalTickPriorityCopyBinder : SignalCopyBinder
+    {
+        public SignalTickPriorityCopyBinder(
+            SignalDeclarationBindInfo signalBindInfo)
+        {
+            SignalBindInfo = signalBindInfo;
+        }
+
+        protected SignalDeclarationBindInfo SignalBindInfo
+        {
+            get; private set;
+        }
+
+        public SignalCopyBinder WithTickPriority(int priority)
+        {
+            SignalBindInfo.TickPriority = priority;
+            SignalBindInfo.RunAsync = true;
+            return this;
+        }
+    }
+}
+
@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: fb1dbf2ad8637f340a532132f4555abd
+timeCreated: 1529046908
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: