public static IAddressableObservable <Object> ToObservable(this AssetReference reference)
        {
            var observable = ClassPool.Spawn <AddressableObservable <AssetReference, Object, Object> >();

            observable.Initialize(reference);
            return(observable);
        }
Example #2
0
        public IUniRoutineTask AddRoutine(IEnumerator enumerator, bool moveNextImmediately = true, Action finalAction = null)
        {
            if (enumerator == null)
            {
                return(null);
            }

            var routine = ClassPool.Spawn <UniRoutineTask>();

#if UNITY_EDITOR
            if (routine.IsCompleted == false)
            {
                GameLog.LogError("ROUTINE: routine task is not completed");
            }
#endif
            var id = idCounter++;
            routine.Initialize(id, enumerator, moveNextImmediately);
            if (finalAction != null)
            {
                routine.LifeTime.AddCleanUpAction(finalAction);
            }

            routineTasks.Add(routine);

            activeRoutines[id] = routine;

            return(routine);
        }
        public override ActorModel Create()
        {
            var cellModel = ClassPool.Spawn <CellItemModel>();

            cellModel.Initialize(this);
            return(cellModel);
        }
Example #4
0
        public IEnumerable <T> LoadCommands <T>(Func <T, bool> filter = null)
            where T : IUnityBuildCommand
        {
            var commandsBuffer = ClassPool.Spawn <List <IUnityBuildCommand> >();

            commandsBuffer.AddRange(PreBuildCommands);
            commandsBuffer.AddRange(PostBuildCommands);

            foreach (var command in commandsBuffer)
            {
                if (command.IsActive == false)
                {
                    continue;
                }

                if (!(command is T targetCommand))
                {
                    continue;
                }

                if (filter != null && !filter(targetCommand))
                {
                    continue;
                }

                yield return(targetCommand);
            }

            commandsBuffer.Despawn();
        }
        public static IDisposableItem AsDisposable(this RoutineHandle handler)
        {
            var disposable = ClassPool.Spawn <DisposableAction>();

            disposable.Initialize(() => UniRoutineManager.TryToStopRoutine(handler));
            return(disposable);
        }
Example #6
0
 public static void InitPooler()
 {
     if (s_Pooler == null)
     {
         s_Pooler = new ClassPool <T>();
     }
 }
Example #7
0
        public override void Validate()
        {
            if (string.IsNullOrEmpty(guid))
            {
                guid = System.Guid.NewGuid().ToString();
            }

            _allNodes?.Clear();
            nodes.Clear();


            serializableNodes.RemoveAll(x => x == null || x is Object);

            nodes.AddRange(GetComponents <Node>());
            nodes.RemoveAll(x => !x);
            nodes.Remove(this);

            var nodeItems = ClassPool.Spawn <List <INode> >();

            nodeItems.AddRange(serializableNodes);
            nodeItems.AddRange(nodes);

            foreach (var nodeItem in nodeItems)
            {
                nodeItem.SetUpData(this);
                nodeItem.Validate();
            }

            nodeItems.Despawn();
        }
        public static IAddressableObservable <TApi> ToObservable <TApi>(this AssetReferenceGameObject reference)
            where TApi : class
        {
            var observable = ClassPool.Spawn <AddressableObservable <AssetReference, GameObject, TApi> >();

            observable.Initialize(reference);
            return(observable);
        }
        public static IAddressableObservable <TData> ToObservable <TData>(this AssetReferenceT <TData> reference)
            where TData : Object
        {
            var observable = ClassPool.Spawn <AddressableObservable <AssetReferenceT <TData>, TData, TData> >();

            observable.Initialize(reference);
            return(observable);
        }
        public static IEnumerator WaitForEndOfFrame(this object source)
        {
            var waitForEndFrame = ClassPool.Spawn <WaitForEndOfFrame>().Initialize();

            yield return(waitForEndFrame);

            waitForEndFrame.Despawn();
        }
        public Actor Create(int type, int width, int height)
        {
            var actor = ClassPool.Spawn <Actor>();
            var model = _info.Create(type, width, height);

            actor.SetModel(model);
            return(actor);
        }
        public static IEnumerator WaitForSeconds(this object source, float delay)
        {
            var waitForSeconds = ClassPool.
                                 Spawn <WaitForSecondRoutine>().
                                 Initialize(delay);

            yield return(waitForSeconds);

            waitForSeconds.Despawn();
        }
Example #13
0
        private IEnumerable <IUnityBuildCommand> FilterActiveCommands(IEnumerable <BuildCommandStep> commands)
        {
            var commandsBuffer = ClassPool.Spawn <List <IUnityBuildCommand> >();

            foreach (var command in commands)
            {
                commandsBuffer.AddRange(command.GetCommands());
            }

            return(commandsBuffer);
        }
Example #14
0
        public static void UpdatePorts(this INode node, NodeGraph data)
        {
            var portList = ClassPool.Spawn <List <INodePort> >();

            node.Initialize(data);

            portList.AddRange(node.Ports);

            node.UpdateNodePorts();

            portList.Despawn();
        }
Example #15
0
        /// <summary>
        /// Creates a new Interaction Result pool with the given key and size.
        /// </summary>
        /// <typeparam name="T">The IPoolable type to use.</typeparam>
        /// <param name="key">The name of the pool, used to retrieve objects.</param>
        /// <returns>The newly created pool, or the existing pool if there is one with the same key.</returns>
        public ClassPool CreateInteractionResultPool <T>(string key) where T : class, IPoolable, new()
        {
            if (interactionResultPools.ContainsKey(key))
            {
                return(interactionResultPools[key]);
            }

            ClassPool pool = new ClassPool();

            interactionResultPools.Add(key, pool);

            return(pool);
        }
Example #16
0
        public static RemoteDataChange Create(string FullPath,
                                              string FieldName,
                                              object FieldValue,
                                              Action <RemoteDataChange> ApplyCallback)
        {
            var change = ClassPool.SpawnOrCreate(() => new RemoteDataChange());

            change.FullPath      = FullPath;
            change.FieldName     = FieldName;
            change.FieldValue    = FieldValue;
            change.ApplyCallback = ApplyCallback;
            return(change);
        }
Example #17
0
        public void CloseAll()
        {
            var buffer = ClassPool.Spawn <List <IView> >();

            buffer.AddRange(_views);

            _views.Clear();
            foreach (var view in buffer)
            {
                view.Close();
            }

            buffer.Despawn();
        }
Example #18
0
 public BinaryModule ToBinary()
 {
     // 生成methods的时候可能依然会修改常量池,因此先做
     BinaryMethod[] binaryMethods = Methods.Select(m => m?.ToBinary()).ToArray();
     return(new BinaryModule
     {
         ModuleNameIndex = ModuleNameIndex,
         StringPool = StringPool.ToArray(),
         ClassPool = ClassPool.ToArray(),
         MethodPool = MethodPool.ToArray(),
         FieldPool = FieldPool.ToArray(),
         Methods = binaryMethods
     });
 }
Example #19
0
        private void CreatePortConnections()
        {
            var portsConnections = ClassPool.Spawn <List <NodePortConnection> >();

            foreach (var nodeItem in uniNodes)
            {
                var nodeView = nodeItem.Value;
                var node     = nodeView.SourceNode;
                foreach (var outputPortView in nodeView.outputPorts)
                {
                    var portData   = outputPortView.portData;
                    var sourcePort = node.GetPort(portData.displayName);

                    foreach (var connection in sourcePort.Connections)
                    {
                        if (!uniNodes.TryGetValue(connection.NodeId, out var connectionNode))
                        {
                            continue;
                        }

                        var targetNode = connectionNode.SourceNode;
                        var port       = targetNode.GetPort(connection.PortName);

                        if (port.Direction != PortIO.Input)
                        {
                            continue;
                        }

                        var inputPortView = connectionNode.GetPort(nameof(connectionNode.inputs), connection.PortName);

                        portsConnections.Add(new NodePortConnection()
                        {
                            source = inputPortView,
                            target = outputPortView
                        });
                    }
                }
            }

            foreach (var nodePortConnection in portsConnections)
            {
                var inputPortView  = nodePortConnection.source;
                var outputPortView = nodePortConnection.target;

                Connect(inputPortView, outputPortView);
            }

            portsConnections.Despawn();
        }
Example #20
0
        protected override async UniTask OnContextActivate(IContext context)
        {
            var results = ClassPool.Spawn <List <AsyncContextDataSource> >();

            await sources.LoadAssetsTaskAsync(results, LifeTime);

            foreach (var dataSource in results)
            {
                await dataSource.RegisterAsync(context);
            }

            results.Despawn();

            Complete();
        }
Example #21
0
    public virtual void notifyConstructDone()
    {
        mGameFramework     = GameFramework.mGameFramework;
        mCommandSystem     = mGameFramework.getSystem(Typeof <CommandSystem>()) as CommandSystem;
        mAudioManager      = mGameFramework.getSystem(Typeof <AudioManager>()) as AudioManager;
        mGameSceneManager  = mGameFramework.getSystem(Typeof <GameSceneManager>()) as GameSceneManager;
        mCharacterManager  = mGameFramework.getSystem(Typeof <CharacterManager>()) as CharacterManager;
        mLayoutManager     = mGameFramework.getSystem(Typeof <LayoutManager>()) as LayoutManager;
        mKeyFrameManager   = mGameFramework.getSystem(Typeof <KeyFrameManager>()) as KeyFrameManager;
        mGlobalTouchSystem = mGameFramework.getSystem(Typeof <GlobalTouchSystem>()) as GlobalTouchSystem;
        mShaderManager     = mGameFramework.getSystem(Typeof <ShaderManager>()) as ShaderManager;
#if !UNITY_IOS && !NO_SQLITE
        mSQLite = mGameFramework.getSystem(Typeof <SQLite>()) as SQLite;
#endif
        mDataBase                = mGameFramework.getSystem(Typeof <DataBase>()) as DataBase;
        mCameraManager           = mGameFramework.getSystem(Typeof <CameraManager>()) as CameraManager;
        mResourceManager         = mGameFramework.getSystem(Typeof <ResourceManager>()) as ResourceManager;
        mApplicationConfig       = mGameFramework.getSystem(Typeof <ApplicationConfig>()) as ApplicationConfig;
        mFrameConfig             = mGameFramework.getSystem(Typeof <FrameConfig>()) as FrameConfig;
        mObjectPool              = mGameFramework.getSystem(Typeof <ObjectPool>()) as ObjectPool;
        mInputManager            = mGameFramework.getSystem(Typeof <InputManager>()) as InputManager;
        mSceneSystem             = mGameFramework.getSystem(Typeof <SceneSystem>()) as SceneSystem;
        mClassPool               = mGameFramework.getSystem(Typeof <ClassPool>()) as ClassPool;
        mClassPoolThread         = mGameFramework.getSystem(Typeof <ClassPoolThread>()) as ClassPoolThread;
        mListPool                = mGameFramework.getSystem(Typeof <ListPool>()) as ListPool;
        mListPoolThread          = mGameFramework.getSystem(Typeof <ListPoolThread>()) as ListPoolThread;
        mDictionaryPool          = mGameFramework.getSystem(Typeof <DictionaryPool>()) as DictionaryPool;
        mDictionaryPoolThread    = mGameFramework.getSystem(Typeof <DictionaryPoolThread>()) as DictionaryPoolThread;
        mBytesPool               = mGameFramework.getSystem(Typeof <BytesPool>()) as BytesPool;
        mBytesPoolThread         = mGameFramework.getSystem(Typeof <BytesPoolThread>()) as BytesPoolThread;
        mAndroidPluginManager    = mGameFramework.getSystem(Typeof <AndroidPluginManager>()) as AndroidPluginManager;
        mAndroidAssetLoader      = mGameFramework.getSystem(Typeof <AndroidAssetLoader>()) as AndroidAssetLoader;
        mHeadTextureManager      = mGameFramework.getSystem(Typeof <HeadTextureManager>()) as HeadTextureManager;
        mTimeManager             = mGameFramework.getSystem(Typeof <TimeManager>()) as TimeManager;
        mMovableObjectManager    = mGameFramework.getSystem(Typeof <MovableObjectManager>()) as MovableObjectManager;
        mEffectManager           = mGameFramework.getSystem(Typeof <EffectManager>()) as EffectManager;
        mTPSpriteManager         = mGameFramework.getSystem(Typeof <TPSpriteManager>()) as TPSpriteManager;
        mSocketFactory           = mGameFramework.getSystem(Typeof <SocketFactory>()) as SocketFactory;
        mSocketFactoryThread     = mGameFramework.getSystem(Typeof <SocketFactoryThread>()) as SocketFactoryThread;
        mPathKeyframeManager     = mGameFramework.getSystem(Typeof <PathKeyframeManager>()) as PathKeyframeManager;
        mEventSystem             = mGameFramework.getSystem(Typeof <EventSystem>()) as EventSystem;
        mStringBuilderPool       = mGameFramework.getSystem(Typeof <StringBuilderPool>()) as StringBuilderPool;
        mStringBuilderPoolThread = mGameFramework.getSystem(Typeof <StringBuilderPoolThread>()) as StringBuilderPoolThread;
#if USE_ILRUNTIME
        mILRSystem = mGameFramework.getSystem(Typeof <ILRSystem>()) as ILRSystem;
#endif
    }
Example #22
0
        private void ValidateGraph()
        {
            var removed = ClassPool.Spawn <List <BaseNode> >();

            foreach (var node in nodes)
            {
                if (node is UniBaseNode uniBaseNode && !uniNodes.ContainsKey(uniBaseNode.sourceId))
                {
                    removed.Add(node);
                }
            }

            removed.ForEach(RemoveNode);
            removed.Despawn();

            uniExposedParameters.RemoveAll(x => x == null);
        }
Example #23
0
        public static Getter generateGetter(OgnlContext context, string code)         // throws OgnlException
        {
            string className = NAME_FACTORY.getNewClassName();

            try
            {
                ClassPool           pool   = (ClassPool)pools [(context.getClassResolver())];
                EnhancedClassLoader loader = (EnhancedClassLoader)loaders [(context.getClassResolver())];
                CtClass             newClass;
                CtClass             ognlContextClass;
                CtClass             objectClass;
                CtClass             stringClass;
                CtMethod            method;
                byte[] byteCode;
                Type   compiledClass;

                if ((pool == null) || (loader == null))
                {
                    ClassLoader classLoader = new ContextClassLoader(typeof(OgnlContext).getClassLoader(), context);

                    pool = ClassPool.getDefault();
                    pool.insertClassPath(new LoaderClassPath(classLoader));
                    pools.Add(context.getClassResolver(), pool);

                    loader = new EnhancedClassLoader(classLoader);
                    loaders.Add(context.getClassResolver(), loader);
                }

                newClass         = pool.makeClass(className);
                ognlContextClass = pool.get(typeof(OgnlContext).Name);
                objectClass      = pool.get(typeof(object).Name);
                stringClass      = pool.get(typeof(string).Name);

                newClass.addInterface(pool.get(typeof(Getter).Name));
                method = new CtMethod(objectClass, "get", new CtClass[] { ognlContextClass, objectClass, stringClass }, newClass);
                method.setBody("{" + code + "}");
                newClass.addMethod(method);
                byteCode      = newClass.toBytecode();
                compiledClass = loader.defineClass(className, byteCode);
                return((Getter)compiledClass.newInstance());
            }
            catch (Exception ex)
            {
                throw new OgnlException("Cannot create class", ex);
            }
        }
Example #24
0
        /// <summary>
        /// WARNING complex types for field values not supported
        /// </summary>
        /// <param name="changes"></param>
        /// <returns></returns>
        public override async Task PerformBatchUpdate(IEnumerable <RemoteDataChange> changes)
        {
            var changeDictionary = ClassPool.SpawnOrCreate <Dictionary <string, object> >(() => new Dictionary <string, object>());

            foreach (var change in changes)
            {
                changeDictionary.Add(change.FullPath, change.FieldValue);
            }
            var rootRef = FirebaseDatabase.DefaultInstance.RootReference;
            await rootRef.UpdateChildrenAsync(changeDictionary);

            foreach (var change in changes)
            {
                change.ApplyCallback?.Invoke(change);
                change.Dispose();
            }
            ClassPool.Despawn <Dictionary <string, object> >(changeDictionary, null);
        }
Example #25
0
        public void ClearConnections()
        {
            var removedConnections = ClassPool.Spawn <List <PortConnection> >();

            removedConnections.AddRange(connections);

            foreach (var connection in removedConnections)
            {
                if (connection.Port == null)
                {
                    continue;
                }
                Disconnect(connection.Port);
            }

            connections.Clear();
            removedConnections.Despawn();
        }
Example #26
0
        /// <summary> Checks all connections for invalid references, and removes them. </summary>
        public void VerifyConnections()
        {
            var removedConnections = ClassPool.Spawn <List <PortConnection> >();

            for (var i = connections.Count - 1; i >= 0; i--)
            {
                var connection = connections[i];
                var targetPort = connection.Port;
                if (targetPort != null)
                {
                    continue;
                }
                removedConnections.Add(connection);
            }

            removedConnections.ForEach(x => connections.Remove(x));
            removedConnections.Despawn();
        }
        private EcsWorld ActivateWorld(ILifeTime lifeTime)
        {
            if (_world != null)
            {
                return(_world);
            }

            var world = CreateWorld();

            world.InitializeWorld();

            var destroyAction = ClassPool.Spawn <DisposableAction>();

            destroyAction.Initialize(world.Destroy);

            lifeTime.AddDispose(destroyAction);

            return(world);
        }
Example #28
0
        public override void Validate()
        {
            _allNodes?.Clear();

            OnInnerValidate();

            var nodeItems = ClassPool.Spawn <List <INode> >();

            nodeItems.AddRange(serializableNodes);
            nodeItems.AddRange(nodes);

            foreach (var nodeItem in nodeItems)
            {
                nodeItem.SetUpData(this);
                nodeItem.Validate();
            }

            nodeItems.Despawn();
        }
Example #29
0
        /// <summary>
        /// Отправляет все локально записанные изменения на сервер.
        /// ВАЖНО: все операции в рамках одной комманды не должны прерыватья вызовом
        /// метода
        /// </summary>
        /// <returns></returns>
        public async Task CommitChanges()
        {
            var updateTasks = ClassPool.SpawnOrCreate <List <Task> >(() => new List <Task>());
            List <RemoteDataChange> changes;

            lock (_pendingChanges)
            {
                changes = _pendingChanges.ToList();
                _pendingChanges.Clear();
            }

            foreach (var change in changes)
            {
                updateTasks.Add(_objectHandler.ApplyChange(change));
            }
            await Task.WhenAll(updateTasks.ToArray());

            changes.ForEach((ch) => ch.Dispose());
            changes.Clear();
        }
Example #30
0
        private List <UiViewReference> FindItemsByType(Type type, bool strongMatching)
        {
            var result = ClassPool.Spawn <List <UiViewReference> >();

            if (strongMatching)
            {
                if (views.TryGetValue(type, out var items))
                {
                    result.AddRange(items);
                }
                return(result);
            }

            foreach (var view in views)
            {
                var viewType = view.Key;
                if (type.IsAssignableFrom(viewType))
                {
                    result.AddRange(view.Value);
                }
            }

            return(result);
        }