Exemple #1
0
        // Redo later while cycling through world chunk references rather then all worlds
        public void DestroyWorld(Entity worldEntity)
        {
            if (!World.EntityManager.Exists(worldEntity))
            {
                return;
            }
            List <int> removeIDs = new List <int>();
            World      world     = World.EntityManager.GetComponentData <World>(worldEntity);
            var        worldID   = World.EntityManager.GetComponentData <ZoxID>(worldEntity).id;

            //foreach (Entity e in chunks.Values)
            for (int i = 0; i < world.chunks.Length; i++)
            {
                var e       = world.chunks[i];
                var chunk   = World.EntityManager.GetComponentData <Chunk>(e);
                var chunkID = World.EntityManager.GetComponentData <ZoxID>(e).id;
                //if (chunk.worldID == worldID)
                //{
                var lookupTable = worldSpawnSystem.worldLookups[worldID];
                lookupTable.chunks.Remove(chunk.Value.chunkPosition);
                worldSpawnSystem.worldLookups[worldID] = lookupTable;

                removeIDs.Add(chunkID);
                // chunk.renderIDs
                if (World.EntityManager.HasComponent <MonsterSpawnZone>(e))
                {
                    var monsterSpawner = World.EntityManager.GetComponentData <MonsterSpawnZone>(e);
                    for (int a = 0; a < monsterSpawner.spawnedIDs.Length; a++)
                    {
                        characterDeathSystem.DestroyCharacter(monsterSpawner.spawnedIDs[a]);
                    }
                }

                // for all chunkRenders (should be)
                for (int a = 0; a < chunk.chunkRenders.Length; a++)
                {
                    var chunkRender = chunk.chunkRenders[a];
                    ChunkRenderSystem.DestroyChunkRender(World.EntityManager, chunkRender);
                }
                if (World.EntityManager.Exists(e))
                {
                    World.EntityManager.DestroyEntity(e);
                }
                //}
            }
            foreach (int removeID in removeIDs)
            {
                chunks.Remove(removeID);
            }
        }
Exemple #2
0
 public void RemoveRenderEntitiesFromChunk(ref Chunk chunk)
 {
     if (ChunkSpawnSystem.isDebugLog)
     {
         Debug.LogError("Removing chunk renders from chunk: " + chunk.Value.chunkPosition);
     }
     if (chunk.chunkRenders.Length != 0)
     {
         for (int i = 0; i < chunk.chunkRenders.Length; i++)
         {
             var chunkRenderEntity = chunk.chunkRenders[i];
             ChunkRenderSystem.DestroyChunkRender(World.EntityManager, chunkRenderEntity);
         }
         chunk.chunkRenders = new BlitableArray <Entity>(0, Allocator.Persistent);
     }
 }
Exemple #3
0
 public void RemoveChunk(Entity chunkEntity, bool isRemoveFromWorld = true)
 {
     //if (chunks.ContainsKey(chunkID))
     {
         //Entity chunkEntity = chunks[chunkID];
         Chunk chunk       = World.EntityManager.GetComponentData <Chunk>(chunkEntity);
         var   chunkID     = World.EntityManager.GetComponentData <ZoxID>(chunkEntity).id;
         var   worldID     = World.EntityManager.GetComponentData <ZoxID>(chunkEntity).creatorID;
         var   lookupTable = worldSpawnSystem.worldLookups[worldID];
         lookupTable.chunks.Remove(chunk.Value.chunkPosition);
         worldSpawnSystem.worldLookups[worldID] = lookupTable;
         if (isRemoveFromWorld)
         {
             Entity worldEntity   = chunk.world;
             World  world         = World.EntityManager.GetComponentData <World>(worldEntity);
             int3[] positions     = new int3[0];
             var    chunkPosition = chunk.Value.chunkPosition;
             RemovePositionIndex(ref world, chunkPosition, chunkID, positions, int3.Forward()); //new float3(0, 0, 1));
             RemovePositionIndex(ref world, chunkPosition, chunkID, positions, int3.Back());    //new float3(0, 0, -1));
             RemovePositionIndex(ref world, chunkPosition, chunkID, positions, int3.Right());   // new float3(1, 0, 0));
             RemovePositionIndex(ref world, chunkPosition, chunkID, positions, int3.Left());    //new float3(-1, 0, 0));
             World.EntityManager.SetComponentData(worldEntity, world);
         }
         for (int j = 0; j < chunk.chunkRenders.Length; j++)
         {
             Entity chunkRender = chunk.chunkRenders[j];
             if (World.EntityManager.Exists(chunkRender))
             {
                 ChunkRenderSystem.DestroyChunkRender(World.EntityManager, chunkRender);
             }
         }
         if (World.EntityManager.HasComponent <MonsterSpawnZone>(chunkEntity))
         {
             MonsterSpawnZone monsterSpawner = World.EntityManager.GetComponentData <MonsterSpawnZone>(chunkEntity);
             int[]            spawnedIDs     = monsterSpawner.spawnedIDs.ToArray();
             for (int j = 0; j < spawnedIDs.Length; j++)
             {
                 characterDeathSystem.DestroyCharacter(spawnedIDs[j]);
             }
         }
         chunks.Remove(chunkID);
         Chunk.Destroy(World.EntityManager, chunkEntity);
     }
 }
Exemple #4
0
        public void Initialize(Unity.Entities.World space)
        {
            // entity spawn
            worldSpawnSystem = space.GetOrCreateSystem <WorldSpawnSystem>();
            AddSystemToUpdateList(worldSpawnSystem);
            chunkSpawnSystem = space.GetOrCreateSystem <ChunkSpawnSystem>();
            AddSystemToUpdateList(chunkSpawnSystem);
            chunkRenderSystem = space.GetOrCreateSystem <ChunkRenderSystem>();
            AddSystemToUpdateList(chunkRenderSystem);
            voxelSpawnSystem = space.GetOrCreateSystem <VoxelSpawnSystem>();
            AddSystemToUpdateList(voxelSpawnSystem);

            // mesh gen
            chunkSideSystem = space.GetOrCreateSystem <ChunkSidesSystem>();
            AddSystemToUpdateList(chunkSideSystem);
            chunkSideCullSystem = space.GetOrCreateSystem <ChunkSideCullingSystem>();
            AddSystemToUpdateList(chunkSideCullSystem);
            chunkToRendererSystem = space.GetOrCreateSystem <ChunkToRendererSystem>();
            AddSystemToUpdateList(chunkToRendererSystem);
            chunkMeshBuildSystem = space.GetOrCreateSystem <ChunkMeshBuilderSystem>();
            AddSystemToUpdateList(chunkMeshBuildSystem);
            chunkMeshEndSystem = space.GetOrCreateSystem <ChunkMeshEndingSystem>();
            AddSystemToUpdateList(chunkMeshEndSystem);

            chunkWeightBuilder = space.GetOrCreateSystem <ChunkWeightBuilder>();
            AddSystemToUpdateList(chunkWeightBuilder);

            // maps
            chunkMapStarterSystem = space.GetOrCreateSystem <ChunkMapStarterSystem>();
            AddSystemToUpdateList(chunkMapStarterSystem);
            chunkMapBuilderSystem = space.GetOrCreateSystem <ChunkMapBuilderSystem>();
            AddSystemToUpdateList(chunkMapBuilderSystem);
            chunkMapCompleterSystem = space.GetOrCreateSystem <ChunkMapCompleterSystem>();
            AddSystemToUpdateList(chunkMapCompleterSystem);

            // player streaming
            worldStreamSystem = space.GetOrCreateSystem <WorldStreamSystem>();
            AddSystemToUpdateList(worldStreamSystem);
            chunkStreamSystem = space.GetOrCreateSystem <ChunkStreamSystem>();
            AddSystemToUpdateList(chunkStreamSystem);
            chunkStreamEndSystem = space.GetOrCreateSystem <ChunkStreamEndSystem>();
            AddSystemToUpdateList(chunkStreamEndSystem);

            // interact
            voxelRaycastSystem = space.GetOrCreateSystem <VoxelRaycastSystem>();
            AddSystemToUpdateList(voxelRaycastSystem);
            voxelPreviewSystem = space.GetOrCreateSystem <VoxelPreviewSystem>();
            AddSystemToUpdateList(voxelPreviewSystem);
            characterRaycastSystem = space.GetOrCreateSystem <CharacterRaycastSystem>();
            AddSystemToUpdateList(characterRaycastSystem);

            renderSystem = space.GetOrCreateSystem <RenderSystem>();
            AddSystemToUpdateList(renderSystem);

            if (Bootstrap.instance.isAnimateRenders)
            {
                chunkRendererAnimationSystem = space.GetOrCreateSystem <ChunkRendererAnimationSystem>();
                AddSystemToUpdateList(chunkRendererAnimationSystem);
            }

            if (Bootstrap.DebugChunks)
            {
                debugChunkSystem = space.GetOrCreateSystem <DebugChunkSystem>();
                AddSystemToUpdateList(debugChunkSystem);
            }
            if (!Bootstrap.isRenderChunks)
            {
                chunkSideSystem.Enabled = false;
            }
            SetLinks();
        }
Exemple #5
0
        public void SpawnChunks(SpawnChunkCommand command)
        {
            var worldEntity = command.world;
            int worldID     = World.EntityManager.GetComponentData <ZoxID>(worldEntity).id;
            var world       = World.EntityManager.GetComponentData <World>(worldEntity);

            if (ChunkSpawnSystem.isDebugLog)
            {
                Debug.LogError("Spawning World's Chunks [" + command.chunkIDs.Length + "] with dimensions: " + world.voxelDimensions + ", id: " + worldID);
            }
            Translation          worldTranslation = World.EntityManager.GetComponentData <Translation>(worldEntity);
            NativeArray <Entity> entities         = new NativeArray <Entity>(command.chunkPositions.Length, Allocator.Temp);
            // materials
            int renderEntitiesCount = 0;

            for (int i = 0; i < command.isRender.Length; i++)
            {
                if (command.isRender[i] == 1)
                {
                    renderEntitiesCount++;
                }
            }
            List <Material> materials = GetWorldMaterials(worldID);
            MapDatam        map       = null;
            VoxData         model     = new VoxData();

            //NativeArray<Entity> renderEntities = new NativeArray<Entity>(renderEntitiesCount * materials.Count, Allocator.Temp);
            if (worldSpawnSystem.maps.ContainsKey(worldID))
            {
                map = worldSpawnSystem.maps[worldID];
                World.EntityManager.Instantiate(chunkPrefab, entities);
                //World.EntityManager.Instantiate(worldChunkRenderPrefab, renderEntities);
            }
            else if (worldSpawnSystem.models.ContainsKey(worldID))
            {
                model = worldSpawnSystem.models[worldID];
                World.EntityManager.Instantiate(modelChunkPrefab, entities);
                //World.EntityManager.Instantiate(modelChunkRenderPrefab, renderEntities);
            }
            // for all bullets, set custom data using indexes entity
            int renderEntityCount = 0;
            var chunkIDs          = command.chunkIDs.ToArray();
            var chunkPositions    = command.chunkPositions.ToArray();

            for (int i = 0; i < entities.Length; i++)
            {
                Entity chunkEntity = entities[i];
                if (chunks.ContainsKey(chunkIDs[i]))
                {
                    World.EntityManager.DestroyEntity(chunkEntity);
                    continue;
                }
                chunks.Add(chunkIDs[i], entities[i]);
                var lookupTable = worldSpawnSystem.worldLookups[worldID];
                if (lookupTable.chunks.ContainsKey(chunkPositions[i]))
                {
                    lookupTable.chunks[chunkPositions[i]] = chunkEntity;
                }
                else
                {
                    lookupTable.chunks.Add(chunkPositions[i], chunkEntity);
                }
                worldSpawnSystem.worldLookups[worldID] = lookupTable;
                World.EntityManager.SetComponentData(entities[i], new ZoxID {
                    id        = chunkIDs[i],
                    creatorID = worldID
                });
                Chunk chunk = World.EntityManager.GetComponentData <Chunk>(chunkEntity);
                chunk.world = worldEntity;
                chunk.Value.chunkPosition   = chunkPositions[i];
                chunk.Value.worldScale      = world.scale;
                chunk.Value.voxelDimensions = world.voxelDimensions;
                chunk.Init(world.voxelDimensions);
                if (model.id != 0)
                {
                    UpdateChunkWithModel(chunkEntity, ref chunk, model);
                }
                SetChunkSurroundingIndexes(chunkEntity, ref chunk);
                float3 spawnPosition = new float3( // worldOffset +
                    chunk.Value.chunkPosition.x * chunk.Value.worldScale.x * chunk.Value.voxelDimensions.x,
                    chunk.Value.chunkPosition.y * chunk.Value.worldScale.y * chunk.Value.voxelDimensions.y,
                    chunk.Value.chunkPosition.z * chunk.Value.worldScale.z * chunk.Value.voxelDimensions.z);
                World.EntityManager.SetComponentData(chunkEntity, new Translation {
                    Value = spawnPosition
                });
                World.EntityManager.SetComponentData(chunkEntity, new NonUniformScale {
                    Value = new float3(1, 1, 1)
                });
                World.EntityManager.SetComponentData(chunkEntity, new Rotation {
                    Value = quaternion.identity
                });
                World.EntityManager.SetComponentData(chunkEntity, new Parent {
                    Value = chunk.world
                });
                // set depending on biome type - biomeDatam has CharacterDatam linked
                //World.EntityManager.SetComponentData(entities[i], chunk);
                World.EntityManager.SetComponentData(entities[i], chunk);
            }
            var entitiesArray = entities.ToArray();;

            world.chunks = new BlitableArray <Entity>(entitiesArray.Length, Allocator.Persistent);
            for (int i = 0; i < world.chunks.Length; i++)
            {
                world.chunks[i] = entitiesArray[i];
            }
            World.EntityManager.SetComponentData(worldEntity, world);
            ChunkRenderSystem.SpawnChunkRenders(World.EntityManager, worldEntity, renderEntitiesCount, materials.Count, command.isRender.ToArray());
            entities.Dispose();
        }