protected override void OnUpdate()
    {
        EntityQuery entityQuery = GetEntityQuery(typeof(Translation), typeof(QuadrantEntity));

        quadrantMap.Clear();
        if (entityQuery.CalculateEntityCount() > quadrantMap.Capacity)
        {
            quadrantMap.Capacity = entityQuery.CalculateEntityCount();
        }

        // Create Job
        SetQuadrantDataHashMapJob job = new SetQuadrantDataHashMapJob
        {
            hashMap = quadrantMap.AsParallelWriter()
        };

        // Schedule and complete Job
        JobHandle jobHandle = JobForEachExtensions.Schedule(job, entityQuery);

        jobHandle.Complete();

        DebugDrawQuadrant(UtilsClass.GetMouseWorldPosition());

        int quadrantKey = GetKeyFromPosition(UtilsClass.GetMouseWorldPosition());
        int entityCount = GetEntityCountInQuadrant(quadrantKey);

        Debug.Log("There are " + entityCount + " in Quadrant " + quadrantKey);
    }
Beispiel #2
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var settings = GetSingleton <SettingsComponent>();

            if (_positionsQuery.CalculateEntityCount() == settings.Width * settings.Height)
            {
                return(inputDeps);
            }

            var helper = new ArrayHelper(settings.Width, settings.Height);

            var cachedEntities = new NativeArray <Entity>(settings.Width * settings.Height, Allocator.TempJob);

            var cacheJob = new CacheJob
            {
                CachedEntities = cachedEntities,
                Entities       = _positionsQuery.ToEntityArray(Allocator.TempJob),
                Positions      = _positionsQuery.ToComponentDataArray <PositionComponent>(Allocator.TempJob),
                Helper         = helper
            };

            var jobHandle = cacheJob.Schedule(_positionsQuery.CalculateEntityCount(), 32, inputDeps);

            var moveJob = new MoveJob
            {
                CachedEntities = cachedEntities,
                Position       = GetComponentDataFromEntity <PositionComponent>(),
                Helper         = helper
            };

            jobHandle = moveJob.Schedule(jobHandle);


            return(jobHandle);
        }
Beispiel #3
0
    protected override void OnUpdate()
    {
        EntityQuery entityQuery = GetEntityQuery(typeof(Translation), typeof(QuadrantEntity));

        quadrantMultiHashMap.Clear();
        if (entityQuery.CalculateEntityCount() > quadrantMultiHashMap.Capacity)
        {
            quadrantMultiHashMap.Capacity = entityQuery.CalculateEntityCount();
        }

        NativeMultiHashMap <int, QuadrantData> .ParallelWriter quadrantMultiHashMap2 = quadrantMultiHashMap.AsParallelWriter(); //TODO smells

        Entities.ForEach((Entity entity, Translation t, ref QuadrantEntity qe, in InfectionComponent ic) => {
            if (ic.infected)
            {
                int hashMapKey = GetPositionHashMapKey(t.Value);
                //Debug.Log(hashMapKey);
                quadrantMultiHashMap2.Add(hashMapKey, new QuadrantData {
                    entity         = entity,
                    position       = t.Value,
                    quadrantEntity = qe
                });
            }
        }).ScheduleParallel();
    }
        protected override void OnUpdate()
        {
            VehiclesSegmentsHashMap.Clear();
            EntityQuery entityQuery = GetEntityQuery(typeof(VehiclePositionComponent));

            if (entityQuery.CalculateEntityCount() > VehiclesSegmentsHashMap.Capacity)
            {
                VehiclesSegmentsHashMap.Capacity = entityQuery.CalculateEntityCount();
            }

            NativeMultiHashMap <Entity, VehicleSegmentData> .ParallelWriter multiHashMap = VehiclesSegmentsHashMap.AsParallelWriter();
            Dependency = Entities.ForEach((Entity entity, int entityInQueryIndex,
                                           in VehicleSegmentInfoComponent vehicleSegmentInfoComponent,
                                           in VehiclePositionComponent vehiclePositionComponent,
                                           in VehicleConfigComponent vehicleConfigComponent) =>
            {
                Entity segmentEntity = vehicleSegmentInfoComponent.IsBackInPreviousSegment
                    ? vehicleSegmentInfoComponent.PreviousSegment
                    : vehicleSegmentInfoComponent.HeadSegment;
                multiHashMap.Add(segmentEntity, new VehicleSegmentData
                {
                    Entity          = entity,
                    BackSegPosition = vehiclePositionComponent.BackSegPos,
                    VehicleSize     = vehicleConfigComponent.Length
                });
            }).ScheduleParallel(Dependency);
Beispiel #5
0
        void Generate(Entity mapEntity, float2 resize)
        {
            var mapData = EntityManager.GetComponentData <MapData>(mapEntity);

            var commandBuffer = _barrierSystem.CreateCommandBuffer();

            int monsterCount = _monstersQuery.CalculateEntityCount();

            Job.WithCode(() =>
            {
                var genData          = GenerateMap.Default;
                genData.monsterCount = monsterCount;
                commandBuffer.AddComponent(mapEntity, genData);

                mapData.width  += (int)resize.x;
                mapData.height += (int)resize.y;

                mapData.width  = math.max(15, mapData.width);
                mapData.height = math.max(15, mapData.height);

                commandBuffer.SetComponent(mapEntity, mapData);
            }).Schedule();

            _barrierSystem.AddJobHandleForProducer(Dependency);
        }
Beispiel #6
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var settings = GetSingleton <GameBoardSettingsComponent>();

            if (_positionsQuery.CalculateEntityCount() != settings.Width * settings.Height)
            {
                return(inputDeps);
            }

            var cachedEntities = new NativeArray <Entity>(settings.Width * settings.Height, Allocator.TempJob);

            var helper = new ArrayToCoordinatesConverter(settings.Width, settings.Height);

            var cacheJob = new CacheJob
            {
                CachedEntities = cachedEntities,
                Entities       = _positionsQuery.ToEntityArray(Allocator.TempJob),
                Positions      = _positionsQuery.ToComponentDataArray <CellPositionComponent>(Allocator.TempJob),
                Helper         = helper
            };

            var splitJob = new SplitJob
            {
                CachedEntities = cachedEntities,
                CellType       = GetComponentDataFromEntity <CellTypeComponent>(true),
                Helper         = helper
            };

            var jobHandle = cacheJob.Schedule(_positionsQuery.CalculateEntityCount(), 32, inputDeps);

            jobHandle = splitJob.Schedule(jobHandle);

            return(jobHandle);
        }
Beispiel #7
0
        protected override void OnUpdate()
        {
            if (m_UpdateMeshAndCommandBufferGroup.CalculateEntityCount() < 1 && m_UpdateVerticesOnlyGroup.CalculateEntityCount() < 1)
            {
                return;
            }

            if (m_UpdateMeshAndCommandBufferGroup.CalculateEntityCount() > 0)
            {
                RebuildMeshAndCommandBuffers();

                // Now sort layers:
                NativeArray <CanvasLayer> layerEntity;
                var canvasLayerIdFromEntity = GetComponentDataFromEntity <CanvasSortLayer>(true);
                using (var roots = m_AnyTarget.ToEntityArray(Allocator.TempJob))
                {
                    layerEntity = new NativeArray <CanvasLayer>(roots.Length, Allocator.TempJob);
                    for (int i = 0; i < layerEntity.Length; i++)
                    {
                        layerEntity[i] = new CanvasLayer()
                        {
                            CanvasEntity = roots[i],
                            SortId       = canvasLayerIdFromEntity[roots[i]].Value
                        }
                    }
                    ;
                    layerEntity.Sort();
                }
                NativeMultiHashMap <int, int> cameraIdToLayerIdx = new NativeMultiHashMap <int, int>(layerEntity.Length, Allocator.Temp);
                for (int i = 0; i < layerEntity.Length; i++)
                {
                    if (EntityManager.HasComponent(layerEntity[i].CanvasEntity,
                                                   typeof(CanvasTargetCamera)))
                    {
                        var camera = EntityManager.GetSharedComponentData <CanvasTargetCamera>(layerEntity[i].CanvasEntity);
                        camera.Target.InjectedCommandBuffers.Clear();
                        cameraIdToLayerIdx.Add(camera.Target.GetInstanceID(), i);
                    }
                }

                for (int i = 0; i < layerEntity.Length; i++)
                {
                    var entity = layerEntity[i].CanvasEntity;
                    if (EntityManager.HasComponent(entity, typeof(CanvasTargetCamera)))
                    {
                        var camera = EntityManager.GetSharedComponentData <CanvasTargetCamera>(entity);
                        camera.Target.InjectedCommandBuffers.Add(EntityManager.GetSharedComponentData <CanvasCommandBufferContainer>(entity).Value);
                    }
                    else if (EntityManager.HasComponent(entity, typeof(CanvasTargetRenderTexture)))
                    {
                    }
                }
                layerEntity.Dispose();
            }

            if (m_UpdateVerticesOnlyGroup.CalculateEntityCount() > 0)
            {
                UpdateVerticesOnly();
            }
        }
Beispiel #8
0
        protected override void OnUpdate()
        {
            EntityQuery eq = GetEntityQuery(typeof(Translation), typeof(CollisionComponent));

            Debug.Log("Entity count = " + eq.CalculateEntityCount());

            quadTreeMap.Clear();
            if (eq.CalculateEntityCount() > quadTreeMap.Capacity)
            {
                quadTreeMap.Capacity = eq.CalculateEntityCount();
            }

            SetQuadrantHashMapJob sqj = new SetQuadrantHashMapJob
            {
                quadTreeMap = quadTreeMap.AsParallelWriter(),
            };
            JobHandle job = JobForEachExtensions.Schedule(sqj, eq);

            job.Complete();

            //Debug.Log("Total number of entities = " + quadTreeMap.Length);

            DrawQuadrant(Camera.main.ScreenToWorldPoint(Input.mousePosition));
            //Debug.Log("Entities in Quadrant " + GetPositionHashMapKey(Camera.main.ScreenToWorldPoint(Input.mousePosition)) + " = " + GetEntityCount(quadTreeMap, GetPositionHashMapKey(Camera.main.WorldToScreenPoint(Input.mousePosition))));
        }
Beispiel #9
0
        private void CreateNewGhosts(NativeList <uint> blockedId)
        {
            if (m_InvalidGhostQuery.CalculateEntityCount() > 0)
            {
                using (var ghostArray = m_InvalidGhostQuery.ToComponentDataArray <GhostIdentifier>(Allocator.TempJob))
                {
                    foreach (var id in ghostArray)
                    {
                        m_GhostIdQueue.Enqueue(id.Value);
                    }
                }

                EntityManager.RemoveComponent <GhostIdentifier>(m_InvalidGhostQuery);
            }

            if (m_GhostWithoutIdentifierQuery.CalculateEntityCount() == 0)
            {
                return;
            }

            var addArray = new NativeArray <GhostIdentifier>(m_GhostWithoutIdentifierQuery.CalculateEntityCount(), Allocator.TempJob);

            for (int i = 0, length = addArray.Length; i < length; i++)
            {
                addArray[i] = new GhostIdentifier {
                    Value = FindGhostId(blockedId)
                }
            }
            ;

            EntityManager.AddComponentData(m_GhostWithoutIdentifierQuery, addArray);

            addArray.Dispose();
        }
Beispiel #10
0
    protected override void OnUpdate()
    {
        //calculate the number of entities we have to store (entities with translation component and QuadrantEntity component)
        EntityQuery                        entityQuery        = GetEntityQuery(quadrantQueryDesc);
        NativeArray <Entity>               entityArray        = entityQuery.ToEntityArray(Allocator.TempJob);                               // create the entity array
        NativeArray <Translation>          transArray         = entityQuery.ToComponentDataArray <Translation>(Allocator.TempJob);
        NativeArray <MovingQuadrantEntity> movingQuadEntArray = entityQuery.ToComponentDataArray <MovingQuadrantEntity>(Allocator.TempJob); // create the stationary quadrant entities array
        NativeArray <PreviousMovement>     prevMoveArray      = entityQuery.ToComponentDataArray <PreviousMovement>(Allocator.TempJob);

        //the length is calculated from above
        //NativeMultiHashMap<int, QuadrantData> quadrantMultiHashMap = new NativeMultiHashMap<int, QuadrantData>(entityQuery.CalculateLength(),Allocator.TempJob);

        quadrantMultiHashMap.Clear(); // clear the hashmap

        // if the amount of stuff to add to the hashmap is larger than the capacity of the hashmap
        if (entityQuery.CalculateEntityCount() > quadrantMultiHashMap.Capacity)
        {
            quadrantMultiHashMap.Capacity = entityQuery.CalculateEntityCount(); //Increase the hashmap to hold everything
        }

        //using jobs
        //Cycle through all entities and get their positions
        //selects all entities with a translation component and adds them to the hashmap
        SetQuadrantDataHashMapJob setQuadrantDataHashMapJob = new SetQuadrantDataHashMapJob {
            quadrantMultiHashMap = quadrantMultiHashMap.AsParallelWriter(), //ToConcurrent used to allow for concurrent writing
            entities             = entityArray,
            translations         = transArray,
            quadEntTypes         = movingQuadEntArray,
            prevMovements        = prevMoveArray
        };
        JobHandle jobHandle = IJobParallelForExtensions.Schedule(setQuadrantDataHashMapJob, entityArray.Length, 32, this.Dependency);

        //JobForEachExtensions.Schedule(setQuadrantDataHashMapJob, entityQuery);

        jobHandle.Complete();



        //Cycle through all entities and get their positions
        //selects all entities with a translation component
        //without jobs

        /*Entities.ForEach((Entity entity, ref Translation translation) =>{
         *  int hashMapKey = GetPositionHashMapKey(translation.Value);
         *  quadrantMultiHashMap.Add(hashMapKey, entity);
         * });*/

        //Debug.Log(GetPositionHashMapKey(MousePosition.GetMouseWorldPositionOnPlane(50)) + " Mouse position: " + MousePosition.GetMouseWorldPositionOnPlane(50));
        //DebugDrawQuadrant(MousePosition.GetMouseWorldPositionOnPlane(50));
        //Debug.Log(GetEntityCountInHashMap(quadrantMultiHashMap,GetPositionHashMapKey(MousePosition.GetMouseWorldPositionOnPlane(50))));

        //quadrantMultiHashMap.Dispose();
    }
Beispiel #11
0
        protected override void OnUpdate()
        {
            if (!HasSingleton <CanvasRoot>())
            {
                TextUtility.CreateCanvas(EntityManager);
                SetSingleton(default(CanvasRoot));
            }

            m_vertexCounter.Value      = 0;
            m_vertexIndexCounter.Value = 0;
            m_subMeshCounter.Value     = 0;
            var changedVerticesCount = m_vertexDataQuery.CalculateEntityCount();

            if (changedVerticesCount == 0)
            {
                return;
            }
            m_vertexDataQuery.ResetFilter();

            var length           = m_vertexDataQuery.CalculateEntityCount();
            var canvasRootEntity = GetSingletonEntity <CanvasRoot>();
            var sortedEntities   = EntityManager.GetAllSortedEntities(this, Allocator.TempJob);

            Dependency = m_vertexDataQuery.ToEntityIndexMap(EntityManager, ref m_entityIndexMap, Dependency);

            Dependency = JobHandle.CombineDependencies(
                m_offsets.Resize(length, Dependency),
                m_sharedFontIndices.Resize(length, Dependency));

            Dependency = new GatherSharedComponentIndices <FontMaterial> {
                ChunkSharedComponentType = GetArchetypeChunkSharedComponentType <FontMaterial>(),
                Indices = m_sharedFontIndices.AsDeferredJobArray()
            }.Schedule(m_vertexDataQuery, Dependency);

            CreateOffsets(
                m_entityIndexMap,
                sortedEntities,
                m_sharedFontIndices.AsDeferredJobArray(),
                m_offsets.AsDeferredJobArray(),
                m_vertexCounter,
                m_vertexIndexCounter,
                m_subMeshCounter);

            Dependency = JobHandle.CombineDependencies(
                m_canvasdRootQuery.ResizeBufferDeferred <Vertex>(this, m_vertexCounter, Dependency),
                m_canvasdRootQuery.ResizeBufferDeferred <VertexIndex>(this, m_vertexIndexCounter, Dependency),
                m_canvasdRootQuery.ResizeBufferDeferred <SubMeshInfo>(this, m_subMeshCounter, Dependency));

            MergeBatching(canvasRootEntity, m_offsets.AsDeferredJobArray());
            Dependency = sortedEntities.Dispose(Dependency);
            m_vertexDataQuery.SetChangedVersionFilter(m_filterChanged);
        }
Beispiel #12
0
    protected override JobHandle OnUpdate(JobHandle inputDependencies)
    {
        var paddleEntity = GetSingletonEntity <PaddleTag>();
        var paddleJob    = new CollideBallsWithPaddleJob
        {
            PaddleEntity = paddleEntity,

            PaddleTranslation = GetComponentDataFromEntity <Position2D>(true),
            PaddleBounds      = GetComponentDataFromEntity <RectangleBounds>(true)
        };
        var paddleHandle       = paddleJob.Schedule(this, inputDependencies);
        var collideBrickHandle = paddleHandle;

        var brickCount = m_BrickQuery.CalculateEntityCount();

        if (brickCount > 0)
        {
            var hashGrid = GetSingleton <BrickHashGrid>();
            var brickJob = new CollideBallsWithBricksJob_Accelerated
            {
                Ecb = m_EndSimECBSystem.CreateCommandBuffer().ToConcurrent(),

                BrickGrid = hashGrid,

                BrickTranslationRO     = GetComponentDataFromEntity <Position2D>(true),
                BrickRectangleBoundsRO = GetComponentDataFromEntity <RectangleBounds>(true)
            };

            collideBrickHandle = brickJob.Schedule(this, paddleHandle);
            m_EndSimECBSystem.AddJobHandleForProducer(collideBrickHandle);
        }

        return(collideBrickHandle);
    }
Beispiel #13
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            if (_moveQuery.CalculateEntityCount() == 0)
            {
                return(inputDeps);
            }

            var mapEntity = _mapQuery.GetSingletonEntity();
            var map       = EntityManager.GetBuffer <MapTiles>(mapEntity);
            var mapData   = EntityManager.GetComponentData <MapData>(mapEntity);

            inputDeps = Entities
                        .WithReadOnly(map)
                        .ForEach((ref Position p, ref Movement move) =>
            {
                int2 dest = p.value + move.value;
                int index = dest.y * mapData.width + dest.x;

                move = int2.zero;

                if (index < 0 || index >= map.Length)
                {
                    return;
                }

                if (map[index] != TileType.Wall)
                {
                    p = dest;
                }
            }).Schedule(inputDeps);

            return(inputDeps);
        }
Beispiel #14
0
        protected override void OnUpdate()
        {
            Count = _query.CalculateEntityCount();

            Entities
            .ForEach(
                (in ValueTestData testData) => { }
 protected override void OnUpdate()
 {
     if (m_vertexDataQuery.CalculateEntityCount() > 0)
     {
         RebuildMesh();
     }
 }
Beispiel #16
0
    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        EntityQuery          unitQuery       = GetEntityQuery(typeof(FluidComponent));
        NativeArray <float3> directionsArray = new NativeArray <float3>(unitQuery.CalculateEntityCount(), Allocator.TempJob);

        FindCollisionCubeSystemJob findTargetQuadrantSystemJob = new FindCollisionCubeSystemJob
        {
            quadrantMultiHashMap = CubeSystem.cubeMultiHashMap,
            finalDirectionsArray = directionsArray,
            Bounds = GameData.Bounds
        };
        JobHandle jobHandle = findTargetQuadrantSystemJob.Schedule(this, inputDeps);


        // Add HasTarget Component to Entities that have a Closest Target
        //AddComponentJob addComponentJob = new AddComponentJob
        //{
        //    offsetsArray = directionsArray,
        //    entityCommandBuffer = endSimulationEntityCommandBufferSystem.CreateCommandBuffer().ToConcurrent(),
        //};
        //jobHandle = addComponentJob.Schedule(this, jobHandle);

        endSimulationEntityCommandBufferSystem.AddJobHandleForProducer(jobHandle);

        return(jobHandle);
    }
Beispiel #17
0
    public void CountTanks()
    {
        EntityManager entityManager = world.GetExistingSystem <MoveSystem>().EntityManager;
        EntityQuery   entityQuery   = entityManager.CreateEntityQuery(ComponentType.ReadOnly <TankData>());

        UpdateTankCount(entityQuery.CalculateEntityCount());
    }
Beispiel #18
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            //test if we have any requests
            if (pokemonMoveDataQuery.CalculateEntityCount() == 0 && pokemonMoveFinishEntities.CalculateEntityCount() == 0)
            {
                return(inputDeps);
            }
            NativeArray <EntityParent>   entityParents = pokemonMoveDataQuery.ToComponentDataArray <EntityParent>(Allocator.TempJob);
            NativeArray <GroupIndexInfo> parentInfos   = new NativeArray <GroupIndexInfo>(entityParents.Length, Allocator.TempJob);

            for (int i = 0; i < entityParents.Length; i++)
            {
                parentInfos[i] = EntityManager.GetComponentData <GroupIndexInfo>(entityParents[i].entity);
            }
            //preform the job
            JobHandle jh = new RemovePokemonData
            {
                pokemonMoveDataEntities = pokemonMoveDataQuery.ToEntityArray(Allocator.TempJob),
                ecb = ecbs.CreateCommandBuffer(),
                pokemonMoveDatas          = pokemonMoveDataQuery.ToComponentDataArray <PokemonMoveDataEntity>(Allocator.TempJob),
                parents                   = entityParents,
                parentInfos               = parentInfos,
                pokemonMoveEntityEntities = pokemonMoveFinishEntities.ToEntityArray(Allocator.TempJob),
                hasParticleRemoveRequest  = GetComponentDataFromEntity <ParticleSystemRemoveRequest>(),
                pokemonMoveRemoveDatas    = pokemonMoveFinishEntities.ToComponentDataArray <PokemonMoveDataEntity>(Allocator.TempJob)
            }.Schedule(inputDeps);

            jh.Complete();
            return(jh);
        }
Beispiel #19
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            if (m_RootGroup.CalculateEntityCount() < 1)
            {
                return(inputDeps);
            }

            inputDeps = UpdateBatchIndices(inputDeps);

            var childFromEntity     = GetBufferFromEntity <Child>(true);
            var verticesFromEntity  = GetBufferFromEntity <ControlVertexData>(true);
            var trianglesFromEntity = GetBufferFromEntity <ControlVertexIndex>(true);

            using (new ProfilerSample("RenderSystem.BuildingChunks"))
            {
                MeshBatching chunkJob = new MeshBatching()
                {
                    EntityType              = GetArchetypeChunkEntityType(),
                    ChildFromEntity         = childFromEntity,
                    SubMeshList             = GetArchetypeChunkBufferType <SubMeshInfo>(),
                    EntityToMaterial        = m_EntityToMaterialID,
                    VerticesFromEntity      = verticesFromEntity,
                    TrianglesFromEntity     = trianglesFromEntity,
                    VertexPointerFromEntity = GetComponentDataFromEntity <ElementVertexPointerInMesh>(),
                    DisabledFromEntity      = GetComponentDataFromEntity <Disabled>(true),

                    VertexType      = GetArchetypeChunkBufferType <MeshVertex>(),
                    VertexIndexType = GetArchetypeChunkBufferType <MeshVertexIndex>(),
                };

                inputDeps = chunkJob.Schedule(m_RootGroup, inputDeps);
            }

            return(inputDeps);
        }
Beispiel #20
0
    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        int massCount   = massQuery.CalculateEntityCount();
        int springCount = springQuery.CalculateEntityCount();

        if (massCount == 0 || springCount == 0)
        {
            return(inputDeps);
        }

        NativeMultiHashMap <Entity, float3> hashMap = new NativeMultiHashMap <Entity, float3>(massCount * 4, Allocator.TempJob);

        HashSpringForceJob hashMassSpringJob = new HashSpringForceJob {
            _hashMap = hashMap.AsParallelWriter()
        };

        JobHandle hashMassSPringHandle = hashMassSpringJob.Schedule(this, inputDeps);

        MassSpringForceJob massSpringForceJob = new MassSpringForceJob {
            _massSpringHashMap = hashMap
        };

        JobHandle massSpringForceHandle = massSpringForceJob.Schedule(this, hashMassSPringHandle);

        massSpringForceHandle.Complete();
        hashMap.Dispose();
        return(massSpringForceHandle);
    }
Beispiel #21
0
        protected override void OnCreate()
        {
            RequireSingletonForUpdate <MapRenderTerminal>();
            RequireSingletonForUpdate <Map>();

            _renderableActors = GetEntityQuery(
                ComponentType.ReadOnly <Position>(),
                ComponentType.ReadOnly <Renderable>(),
                ComponentType.ReadOnly <Actor>());

            _renderableItems = GetEntityQuery(
                ComponentType.ReadOnly <Position>(),
                ComponentType.ReadOnly <Renderable>(),
                ComponentType.ReadOnly <Item>());

            _actorsMovedQuery = GetEntityQuery(
                ComponentType.ReadOnly <Position>()
                );
            _actorsMovedQuery.AddChangedVersionFilter(ComponentType.ReadOnly <Position>());

            _gameStateChanged = GetEntityQuery(
                ComponentType.ReadOnly <GameState>());
            _gameStateChanged.AddChangedVersionFilter(typeof(GameState));

            _terminalChangedQuery = GetEntityQuery(
                ComponentType.ReadOnly <MapRenderTerminal>(),
                ComponentType.ReadOnly <TerminalTilesBuffer>());
            _terminalChangedQuery.AddChangedVersionFilter(typeof(TerminalTilesBuffer));

            _terminalDirtyQuery = GetEntityQuery(ComponentType.ReadOnly <MapRenderTerminal>(),
                                                 ComponentType.ReadOnly <Terminal>());
            _terminalDirtyQuery.AddChangedVersionFilter(typeof(Terminal));

            _lastRenderableCount = _renderableActors.CalculateEntityCount();
        }
Beispiel #22
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var buffer = _barrier.CreateCommandBuffer().ToConcurrent();

            int actingAICount = _actingAI.CalculateEntityCount();

            NativeArray <int2> directions = new NativeArray <int2>(actingAICount, Allocator.TempJob);

            // Generate random directions
            for (int i = 0; i < actingAICount; ++i)
            {
                directions[i] = GetRandomDirection();
            }

            inputDeps = Entities
                        .WithStoreEntityQueryInField(ref _actingAI)
                        .WithAll <Enemy>()
                        // Only act when we have a turn
                        .WithAll <TurnAction>()
                        .ForEach((int entityInQueryIndex, Entity e) =>
            {
                buffer.AddComponent <TryMove>(entityInQueryIndex, e, directions[entityInQueryIndex]);
            }).Schedule(inputDeps);

            _barrier.CreateCommandBuffer().RemoveComponent <TurnAction>(_actingAI);
            _barrier.AddJobHandleForProducer(inputDeps);

            directions.Dispose(inputDeps);

            return(inputDeps);
        }
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var glyphMap = new NativeHashMap <int, Entity>(glyphQuery.CalculateEntityCount(), Allocator.TempJob);

            var glyphMapDeps = new BuildGlyphMapJob {
                GlyphMap = glyphMap.AsParallelWriter()
            }.Schedule(glyphQuery, inputDeps);

            var textMeshDeps = new BuildTextMeshJob {
                GlyphMap           = glyphMap,
                GlyphData          = GetBufferFromEntity <GlyphElement>(true),
                FontFaces          = GetComponentDataFromEntity <FontFaceInfo>(true),
                EntityType         = GetArchetypeChunkEntityType(),
                CharBufferType     = GetArchetypeChunkBufferType <CharElement>(true),
                TextOptionType     = GetArchetypeChunkComponentType <TextOptions>(true),
                TxtFontIDType      = GetArchetypeChunkComponentType <TextFontID>(true),
                ColorType          = GetArchetypeChunkComponentType <AppliedColor>(true),
                LTWType            = GetArchetypeChunkComponentType <LocalToWorld>(true),
                DimensionType      = GetArchetypeChunkComponentType <Dimensions>(true),
                MeshVertexDataType = GetArchetypeChunkBufferType <MeshVertexData>(),
                TriangleIndexType  = GetArchetypeChunkBufferType <TriangleIndexElement>(),
                CmdBuffer          = cmdBufferSystem.CreateCommandBuffer().ToConcurrent()
            }.Schedule(textQuery, glyphMapDeps);

            var finalDeps = glyphMap.Dispose(textMeshDeps);

            cmdBufferSystem.AddJobHandleForProducer(finalDeps);

            return(finalDeps);
        }
Beispiel #24
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var settings = GetSingleton <SettingsComponent>();

            var cachedEntities = new NativeArray <Entity>(settings.Width * settings.Height, Allocator.TempJob);

            var helper = new ArrayHelper(settings.Width, settings.Height);

            var cacheJob = new CacheJob
            {
                CachedEntities = cachedEntities,
                Entities       = _positionsQuery.ToEntityArray(Allocator.TempJob),
                Positions      = _positionsQuery.ToComponentDataArray <PositionComponent>(Allocator.TempJob),
                Helper         = helper
            };

            var destroyJob = new DestroyJob
            {
                CachedEntities    = cachedEntities,
                CommandBuffer     = _commandBuffer.CreateCommandBuffer(),
                ClickedComponents = _clickedQuery.ToComponentDataArray <ClickedComponent>(Allocator.TempJob),
                InGroup           = GetComponentDataFromEntity <InGroupComponent>(true),
                Helper            = helper,
                MinGroupSize      = settings.MinGroupSize
            };

            var jobHandle = cacheJob.Schedule(_positionsQuery.CalculateEntityCount(), 32, inputDeps);

            jobHandle = destroyJob.Schedule(jobHandle);

            _commandBuffer.AddJobHandleForProducer(jobHandle);

            return(jobHandle);
        }
Beispiel #25
0
        protected override void OnUpdate()
        {
            return;
            var flockSetting = _flockSetting;
            var flockEntitiesCount = _flockEntityQuery.CalculateEntityCount();
            var cohesionArray = new NativeArray<float2>(flockEntitiesCount, Allocator.TempJob);
            var alignmentArray = new NativeArray<float2>(flockEntitiesCount, Allocator.TempJob);
            var separationArray = new NativeArray<float2>(flockEntitiesCount, Allocator.TempJob);
            //var steerArray = new NativeArray<float2>(flockEntitiesCount, Allocator.TempJob);
            //flock
            var flockJobHandle = Entities.WithName("CohesionJob").WithAll<FlockEntityData>().ForEach(
                    (int entityInQueryIndex, in NeighborsData flockNeighborsData, in TransformData transformData,
                        in SteerData flockNavigationData) =>
                    {
                        if (flockNeighborsData.NeighborCount > 0)
                        {
                            cohesionArray[entityInQueryIndex] =
                                math.normalizesafe(flockNeighborsData.MeanPosition - transformData.Position);
                            alignmentArray[entityInQueryIndex] = math.normalizesafe(flockNeighborsData.MeanVelocity);
                        }

                        separationArray[entityInQueryIndex] = flockNeighborsData.SeparationVector;

                        //steerArray[entityInQueryIndex] = math.normalizesafe(flockNavigationData.Goal - localToWorld.Position.xz);
                    })
Beispiel #26
0
        /// <summary>
        /// Schedules an attribute job
        /// </summary>
        /// <param name="inputDependencies">JobHandle</param>
        /// <param name="query">The EntityQuery used for filtering group</param>
        /// <param name="AttributeHash">Attribute MultiHashMap mapping entity to attribute value</param>
        /// <param name="job">Returned job handle</param>
        /// <typeparam name="TOper">The type of operator for this attribute job</typeparam>
        private void ScheduleAttributeJob <TOper>(ref JobHandle inputDependencies, ref EntityQuery query, ref NativeMultiHashMap <Entity, float> AttributeHash, out JobHandle job)
            where TOper : struct, IAttributeOperator, IComponentData
        {
            var nEntities    = query.CalculateEntityCount();
            var hashCapacity = AttributeHash.Capacity;

            AttributeHash.Clear();
            if (nEntities == 0)
            {
                job = inputDependencies;
                return;
            }
            ;
            if (hashCapacity < nEntities)   // We need to increase hash capacity
            {
                AttributeHash.Capacity = (int)(nEntities * 1.1);
            }
            else if (hashCapacity > nEntities * 4)     // We need to reduce hash capacity
            {
                AttributeHash.Dispose();
                AttributeHash = new NativeMultiHashMap <Entity, float>(nEntities, Allocator.Persistent);
            }
            // // AttributeHash = new NativeMultiHashMap<Entity, float>(query.CalculateEntityCount(), Allocator.TempJob);
            inputDependencies = new GetAttributeValuesJob_Sum <TOper, TAttributeTag>
            {
                owners                  = GetArchetypeChunkComponentType <AttributesOwnerComponent>(false),
                attributeModifiers      = GetArchetypeChunkComponentType <AttributeModifier <TOper, TAttributeTag> >(false),
                AttributeModifierValues = AttributeHash.AsParallelWriter()
            }.Schedule(query, inputDependencies);
            job = inputDependencies;
        }
    /*public void setOnCrowdRepelStep(){
     *  Debug.Log("Started Counting");
     *  onCrowdRepelStep = true;
     * }*/
    public int checkCrowdNumber()
    {
        EntityQuery query = GetEntityQuery(ComponentType.ReadOnly <Crowd>());

        //Debug.Log("CrowdCount" + query.CalculateEntityCount());
        return(query.CalculateEntityCount());
    }
Beispiel #28
0
    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        if (m_Query.CalculateEntityCount() <= 0)
        {
            return(inputDeps);
        }

        var generator = m_GeneratorQuery.GetSingleton <LbBoardGenerator>();

        var board        = m_BoardQuery.GetSingleton <LbBoard>();
        var boardEntity  = m_BoardQuery.GetSingletonEntity();
        var bufferLookup = GetBufferFromEntity <LbDirectionMap>();

        var buffer      = bufferLookup[boardEntity];
        var bufferArray = buffer.AsNativeArray();


        var spawnerHandle = new BoardSpawnerJob()
        {
            Generator       = generator,
            Seed            = m_Random.NextUInt(),
            DirectionBuffer = bufferLookup[boardEntity].AsNativeArray(),
            CommandBuffer   = m_Barrier.CreateCommandBuffer()
        }.Schedule(inputDeps);

        var cleanUpHandle = new BoardSpawnerCleanJob()
        {
            CommandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(),
        }.Schedule(this, spawnerHandle);

        m_Barrier.AddJobHandleForProducer(cleanUpHandle);

        return(cleanUpHandle);
    }
        protected override void OnUpdate()
        {
            if (flyingQuery.CalculateEntityCount() > 0)
            {
                //跟随主角扔出的道具
                Entities
                .WithAll <Flying>()
                .WithStructuralChanges()
                .ForEach((Entity entity,
                          in OwnerPredictedState ownerState,
                          in LocalToWorld localToWorld) =>
                {
                    // FSLog.Info($"Flying Camera,entity:{entity}");
                    if (ownerState.PreOwner == Entity.Null)
                    {
                        return;
                    }

                    if (!HasComponent <LocalCharacter>(ownerState.PreOwner))
                    {
                        return;
                    }

                    MoveCamera(localToWorld);
                }).Run();
Beispiel #30
0
    protected override void OnUpdate()
    {
        // Assign values to local variables captured in your job here, so that it has
        // everything it needs to do its work when it runs later.
        // For example,
        //     float deltaTime = Time.DeltaTime;

        // This declares a new kind of job, which is a unit of work to do.
        // The job is declared as an Entities.ForEach with the target components as parameters,
        // meaning it will process all entities in the world that have both
        // Translation and Rotation components. Change it to process the component
        // types you want.
        int entitiesInQuery = query.CalculateEntityCount();


        //Create a native array to hold the intermediate sums
        //(one element per entity)
        NativeArray <int> intermediateSums = new NativeArray <int>(entitiesInQuery, Allocator.TempJob);

        Entities.WithStoreEntityQueryInField(ref query)
        .ForEach((int entityInQueryIndex, in DynamicBuffer <CIntBufferData> buffer) => {
            for (int i = 0; i < buffer.Length; i++)
            {
                intermediateSums[entityInQueryIndex] += buffer[i].Value;
            }
        }).WithName("IntermediateSums")