예제 #1
0
 public void CopyFrom(ListCopyable <T> other)
 {
     this.Count       = other.Count;
     this.Capacity    = other.Capacity;
     this.isValueType = other.isValueType;
     ArrayUtils.Copy(other.innerArray, ref this.innerArray);
 }
예제 #2
0
        protected ListCopyable <Node> AstarSearch(Graph graph, ListCopyable <Node> visited, Node startNode, Node endNode, Constraint constraint, int threadIndex)
        {
            var openList = PoolQueue <Node> .Spawn(10);

            startNode.startToCurNodeLen[threadIndex] = 0f;

            openList.Enqueue(startNode);
            startNode.isOpened[threadIndex] = true;

            while (openList.Count > 0)
            {
                var node = openList.Dequeue();
                node.isClosed[threadIndex] = true;

                visited.Add(node);

                if (node.index == endNode.index)
                {
                    PoolQueue <Node> .Recycle(ref openList);

                    return(this.RetracePath(threadIndex, endNode));
                }

                var neighbors = node.GetConnections();
                foreach (var conn in neighbors)
                {
                    if (conn.index < 0)
                    {
                        continue;
                    }

                    var neighbor = graph.nodes[conn.index];
                    if (neighbor.isClosed[threadIndex] == true)
                    {
                        continue;
                    }
                    if (neighbor.IsSuitable(constraint) == false)
                    {
                        continue;
                    }

                    float ng = node.startToCurNodeLen[threadIndex] + conn.cost;
                    if (neighbor.isOpened[threadIndex] == false || ng < neighbor.startToCurNodeLen[threadIndex])
                    {
                        neighbor.startToCurNodeLen[threadIndex] = ng;
                        neighbor.parent[threadIndex]            = node;
                        if (neighbor.isOpened[threadIndex] == false)
                        {
                            openList.Enqueue(neighbor);
                            visited.Add(neighbor);
                            neighbor.isOpened[threadIndex] = true;
                        }
                    }
                }
            }

            PoolQueue <Node> .Recycle(ref openList);

            return(null);
        }
예제 #3
0
 public void Recycle(ref ListCopyable <T> value)
 {
     if (value != null)
     {
         PoolListCopyable <T> .Recycle(ref value);
     }
 }
예제 #4
0
        public static ListCopyable <Vector3> Bezier(ListCopyable <Vector3> points, int subdivisions = 2, float tangentLength = 0.5f)
        {
            subdivisions = Mathf.Max(subdivisions, 0);

            var segmentsCount = 1 << subdivisions;
            var outputPoints  = PoolListCopyable <Vector3> .Spawn(points.Count *segmentsCount + 1);

            for (int i = 0; i < points.Count - 1; i++)
            {
                var t1 = (points[i + 1] - points[i == 0 ? i : i - 1]) * tangentLength;
                var t2 = (points[i] - points[i == points.Count - 2 ? i + 1 : i + 2]) * tangentLength;

                var p0 = points[i];
                var p1 = p0 + t1;
                var p2 = points[i + 1];
                var p3 = p2 + t2;

                for (int j = 0; j < segmentsCount; j++)
                {
                    outputPoints.Add(CubicBezier(p0, p1, p3, p2, (float)j / segmentsCount));
                }
            }

            outputPoints.Add(points[points.Count - 1]);

            return(outputPoints);
        }
예제 #5
0
 public void GetNodesInBounds(ListCopyable <Node> result, Bounds bounds)
 {
     if (this.graphs != null)
     {
         for (int i = 0; i < this.graphs.Count; ++i)
         {
             this.graphs[i].GetNodesInBounds(result, bounds);
         }
     }
 }
예제 #6
0
 public void Initialize()
 {
     if (this.globalEventLogicItems == null)
     {
         this.globalEventLogicItems = PoolListCopyable <GlobalEventFrameItem> .Spawn(10);
     }
     if (this.globalEventLogicEvents == null)
     {
         this.globalEventLogicEvents = PoolHashSetCopyable <long> .Spawn();
     }
 }
예제 #7
0
            public bool MoveNext()
            {
                ListCopyable <T> list = this._list;

                if ((uint)this._index >= (uint)list.Count)
                {
                    return(false);
                }
                this._current = list.innerArray[this._index];
                ++this._index;
                return(true);
            }
예제 #8
0
        public void AddRange(ListCopyable <T> items)
        {
            var arrayLength = items.Count;

            this.EnsureCapacity(this.Count + arrayLength + 1);
            System.Array.Copy(items.innerArray.arr, 0, this.innerArray.arr, this.Count, arrayLength);
            this.Count += arrayLength;

            /*for (var i = 0; i < arrayLength; i++) {
             *  this.innerArray.arr[this.Count++] = items[i];
             * }*/
        }
예제 #9
0
        public static void Recycle <T, TCopy>(ref ListCopyable <T> item, TCopy copy) where TCopy : IArrayElementCopy <T>
        {
            if (item != null)
            {
                for (int i = 0; i < item.Count; ++i)
                {
                    copy.Recycle(item[i]);
                }

                PoolList <T> .Recycle(ref item);
            }
        }
예제 #10
0
        public void GetNodesInBounds(ListCopyable <Node> result, Bounds bounds, Constraint constraint)
        {
            if (this.graphs != null)
            {
                for (int i = 0; i < this.graphs.Count; ++i)
                {
                    if (constraint.graphMask >= 0 && (constraint.graphMask & (1 << this.graphs[i].index)) == 0)
                    {
                        continue;
                    }

                    this.graphs[i].GetNodesInBounds(result, bounds, constraint);
                }
            }
        }
예제 #11
0
        public static void Copy <T, TCopy>(ListCopyable <T> fromArr, ref ListCopyable <T> arr, TCopy copy) where TCopy : IArrayElementCopy <T>
        {
            if (fromArr == null)
            {
                if (arr != null)
                {
                    for (int i = 0; i < arr.Count; ++i)
                    {
                        copy.Recycle(arr[i]);
                    }

                    PoolListCopyable <T> .Recycle(ref arr);
                }

                arr = null;
                return;
            }

            if (arr == null || fromArr.Count != arr.Count)
            {
                if (arr != null)
                {
                    ArrayUtils.Recycle(ref arr, copy);
                }
                arr = PoolListCopyable <T> .Spawn(fromArr.Count);
            }

            var cnt = arr.Count;

            for (int i = 0; i < fromArr.Count; ++i)
            {
                var isDefault = i >= cnt;

                T item = (isDefault ? default : arr[i]);
                copy.Copy(fromArr[i], ref item);
                if (isDefault == true)
                {
                    arr.Add(item);
                }
                else
                {
                    arr[i] = item;
                }
            }
        }
예제 #12
0
        public void Add(IView view)
        {
            if (this.mainView == null)
            {
                this.mainView = view;
            }
            else
            {
                if (this.otherViews == null)
                {
                    this.otherViews = PoolList <IView> .Spawn(1);
                }

                this.otherViews.Add(view);
            }

            this.isNotEmpty = true;
        }
예제 #13
0
        public static void Copy <T>(ListCopyable <T> fromArr, ref ListCopyable <T> arr) where T : struct
        {
            if (fromArr == null)
            {
                if (arr != null)
                {
                    PoolList <T> .Recycle(ref arr);
                }

                arr = null;
                return;
            }

            if (arr == null)
            {
                arr = PoolList <T> .Spawn(fromArr.Count);
            }

            arr.CopyFrom(fromArr);
        }
예제 #14
0
 internal Enumerator(ListCopyable <T> list)
 {
     this._list    = list;
     this._index   = 0;
     this._current = default(T);
 }
예제 #15
0
 public void CopyTo(ListCopyable <T> target)
 {
     System.Array.Copy(this.innerArray.arr, 0, target.innerArray.arr, 0, this.Count);
     target.Count    = this.Count;
     target.Capacity = this.Capacity;
 }
예제 #16
0
 public abstract void GetNodesInBounds(ListCopyable <Node> output, Bounds bounds, Constraint constraint);
예제 #17
0
 public abstract void GetNodesInBounds(ListCopyable <Node> output, Bounds bounds);
예제 #18
0
 public static void Recycle(ListCopyable <TValue> dic)
 {
     PoolListCopyable <TValue> .pool.Recycle(dic);
 }
            public bool MoveNext()
            {
                if (FiltersArchetype.FiltersArchetypeStorage.CheckStaticShared(this.filterData.data.containsShared, this.filterData.data.notContainsShared) == false)
                {
                    return(false);
                }

                var onChanged      = this.filterData.data.onChanged;
                var changedTracked = onChanged.Count;

                var connectedFilters = this.filterData.data.connectedFilters;
                var connectedTracked = connectedFilters.Count;

                while (true)
                {
                    if (this.archIndex >= this.archetypes.Count)
                    {
                        return(false);
                    }

                    ++this.index;
                    ref var arch = ref this.allArchetypes[this.archetypes[this.archIndex]];
                    if (this.index >= arch.entitiesArr.Count)
                    {
                        ++this.archIndex;
                        if (this.archIndex < this.archetypes.Count)
                        {
                            this.arr = this.allArchetypes[this.archetypes[this.archIndex]].entitiesArr;
                        }

                        this.index = -1;
                        continue;
                    }

                    var entityId = this.arr[this.index];
                    this.current = this.filterData.storage.GetEntityById(entityId);

                    if (connectedTracked > 0)
                    {
                        // Check if all custom filters contains connected entity
                        var found = true;
                        for (int i = 0, cnt = connectedTracked; i < cnt; ++i)
                        {
                            var connectedFilter = connectedFilters[i];
                            if (connectedFilter.filter.Contains(connectedFilter.get.Invoke(this.current)) == false)
                            {
                                found = false;
                                break;
                            }
                        }

                        if (found == false)
                        {
                            continue;
                        }
                    }

                    if (changedTracked > 0)
                    {
                        // Check if any component has changed on this entity
                        var hasChanged = false;
                        for (int i = 0, cnt = changedTracked; i < cnt; ++i)
                        {
                            var typeId = onChanged[i];
                            var reg    = Worlds.current.currentState.structComponents.list.arr[typeId];
                            if (reg.HasChanged(entityId) == true)
                            {
                                hasChanged = true;
                                break;
                            }
                        }

                        if (hasChanged == false)
                        {
                            continue;
                        }
                    }

                    return(true);
                }
예제 #20
0
        public static void Recycle(ref ListCopyable <TValue> dic)
        {
            PoolListCopyable <TValue> .pool.Recycle(dic);

            dic = null;
        }
예제 #21
0
 public void Set(ListCopyable <T> value)
 {
     this.dataObject.Set(value);
 }
예제 #22
0
 public DataList(ListCopyable <T> data)
 {
     this.dataObject = new DataObject <ListCopyable <T>, DataListProvider <T> >(data);
 }
예제 #23
0
        public override void Update(BufferArray <Views> list, float deltaTime, bool hasChanged)
        {
            if (this.world.settings.useJobsForViews == false || this.world.settings.viewsSettings.unityGameObjectProviderDisableJobs == true)
            {
                return;
            }

            if (list.isNotEmpty == true)
            {
                if (hasChanged == true)
                {
                    if (this.tempList == null)
                    {
                        this.tempList = PoolList <MonoBehaviourView> .Spawn(list.Length);
                    }

                    var changed = false; //ArrayUtils.Resize(list.Length - 1, ref this.currentTransforms);

                    var k = 0;
                    for (int i = 0, length = list.Length; i < length; ++i)
                    {
                        var item = list.arr[i];
                        if (item.isNotEmpty == false)
                        {
                            continue;
                        }

                        for (int j = 0, count = item.Length; j < count; ++j)
                        {
                            var view = item[j] as MonoBehaviourView;
                            if (view == null)
                            {
                                continue;
                            }
                            if (view.applyStateJob == true && view.entity.IsAlive() == true)
                            {
                                changed |= ArrayUtils.Resize(k, ref this.currentTransforms);
                                var isNew = false;
                                if (k >= this.tempList.Count)
                                {
                                    this.tempList.Add(view);
                                    this.currentTransforms.arr[k] = view.transform;
                                    isNew = true;
                                }

                                var tempItem = this.tempList[k];
                                if (isNew == true ||
                                    tempItem.prefabSourceId != view.prefabSourceId ||
                                    tempItem.creationTick != view.creationTick ||
                                    tempItem.entity != view.entity)
                                {
                                    this.tempList[k] = view;
                                    this.currentTransforms.arr[k] = view.transform;
                                    changed = true;
                                }

                                ++k;
                            }
                        }
                    }

                    if (this.currentTransformArray.isCreated == false)
                    {
                        this.currentTransformArray = new TransformAccessArray(k);
                    }

                    if (changed == true)
                    {
                        this.currentTransformArray.SetTransforms(this.currentTransforms.arr);
                        //if (UnityGameObjectProvider.resultList != null) PoolList<MonoBehaviourView>.Recycle(ref UnityGameObjectProvider.resultList);
                        //var result = PoolList<MonoBehaviourView>.Spawn(this.tempList.Count);
                        //result.AddRange(this.tempList);
                        UnityGameObjectProvider.resultList  = this.tempList;
                        UnityGameObjectProvider.resultCount = k;
                    }
                }

                if (UnityGameObjectProvider.resultCount > 0 && this.currentTransformArray.isCreated == true)
                {
                    var job = new Job()
                    {
                        deltaTime = deltaTime,
                        length    = UnityGameObjectProvider.resultCount
                    };

                    var handle = job.Schedule(this.currentTransformArray);
                    handle.Complete();
                }
            }
        }
예제 #24
0
 public void GetNodesInBounds(ListCopyable <Node> output, UnityEngine.Bounds bounds)
 {
     this.pathfindingEntity.GetComponent <PathfindingInstance>().pathfinding.GetNodesInBounds(output, bounds);
 }
예제 #25
0
        public void Clone(ListCopyable <T> from, ref ListCopyable <T> to)
        {
            to = PoolListCopyable <T> .Spawn(from.Capacity);

            to.CopyFrom(from);
        }
예제 #26
0
 public static void Recycle(ref ListCopyable <TValue> dic)
 {
     Pools.current.PoolRecycle(ref dic);
 }