コード例 #1
0
        //有借鉴参考
        private IEnumerator SpawnMissingChunks(int originX, int originY, int originZ, int range)
        {
            int heightRange = Engine.HeightRange;

            //清空更新队列updatequeue
            ChunkUpdateQueue = new List <Chunk>();

            //flag chunk不在范围内
            ChunksToDestroy = new List <Chunk>();
            foreach (Chunk chunk in Chunks.Values)
            {
                if (Vector2.Distance(new Vector2(chunk.ChunkIndex.x, chunk.ChunkIndex.z), new Vector2(originX, originZ)) > range + Engine.ChunkDespawnDistance)
                {
                    ChunksToDestroy.Add(chunk);
                }
                else if (Mathf.Abs(chunk.ChunkIndex.y - originY) > range + Engine.ChunkDespawnDistance)
                {
                    ChunksToDestroy.Add(chunk);
                }
            }


            // main loop==看不懂了,原注释保留
            for (int currentLoop = 0; currentLoop <= range; currentLoop++)
            {
                for (var x = originX - currentLoop; x <= originX + currentLoop; x++)
                {                 // iterate through all potential chunk indexes within range
                    for (var y = originY - currentLoop; y <= originY + currentLoop; y++)
                    {
                        for (var z = originZ - currentLoop; z <= originZ + currentLoop; z++)
                        {
                            if (Mathf.Abs(y) <= heightRange)
                            {                             // skip chunks outside of height range
                                if (Mathf.Abs(originX - x) + Mathf.Abs(originZ - z) < range * 1.3f)
                                {                         // skip corners
                                    // pause loop while the queue is not empty
                                    while (ChunkUpdateQueue.Count > 0)
                                    {
                                        ProcessChunkQueue();
                                        if (frameStopwatch.Elapsed.TotalSeconds >= targetFrameDuration)
                                        {
                                            yield return(new WaitForEndOfFrame());
                                        }
                                    }

                                    Chunk currentChunk = ChunkManager.GetChunkComponent(x, y, z);


                                    // chunks that already exist but haven't had their mesh built yet should be added to the update queue
                                    if (currentChunk != null)
                                    {
                                        // chunks without meshes spawned by server should be changed to regular chunks
                                        if (currentChunk.DisableMesh || currentChunk.EnableTimeout)
                                        {
                                            currentChunk.DisableMesh   = false;
                                            currentChunk.EnableTimeout = false;
                                            currentChunk.Fresh         = true;
                                        }

                                        if (currentChunk.Fresh)
                                        {
                                            // spawn neighbor chunks
                                            for (int d = 0; d < 6; d++)
                                            {
                                                Index      neighborIndex = currentChunk.ChunkIndex.GetAdjacentIndex((Direction)d);
                                                GameObject neighborChunk = GetChunk(neighborIndex);
                                                if (neighborChunk == null)
                                                {
                                                    neighborChunk = Instantiate(ChunkObject, neighborIndex.ToVector3(), transform.rotation) as GameObject;
                                                }
                                                currentChunk.NeighborChunks[d] = neighborChunk.GetComponent <Chunk>();                                                // always add the neighbor to NeighborChunks, in case it's not there already

                                                // continue loop in next frame if the current frame time is exceeded
                                                if (frameStopwatch.Elapsed.TotalSeconds >= targetFrameDuration)
                                                {
                                                    yield return(new WaitForEndOfFrame());
                                                }
                                                if (StopSpawning)
                                                {
                                                    EndSequence();
                                                    yield break;
                                                }
                                            }

                                            if (currentChunk != null)
                                            {
                                                currentChunk.AddToQueueWhenReady();
                                            }
                                        }
                                    }

                                    else
                                    {                                                                                                           // if chunk doesn't exist, create new chunk (it adds itself to the update queue when its data is ready)
                                        // spawn chunk
                                        GameObject newChunk = Instantiate(ChunkObject, new Vector3(x, y, z), transform.rotation) as GameObject; // Spawn a new chunk.
                                        currentChunk = newChunk.GetComponent <Chunk>();

                                        // spawn neighbor chunks if they're not spawned yet
                                        for (int d = 0; d < 6; d++)
                                        {
                                            Index      neighborIndex = currentChunk.ChunkIndex.GetAdjacentIndex((Direction)d);
                                            GameObject neighborChunk = GetChunk(neighborIndex);
                                            if (neighborChunk == null)
                                            {
                                                neighborChunk = Instantiate(ChunkObject, neighborIndex.ToVector3(), transform.rotation) as GameObject;
                                            }
                                            currentChunk.NeighborChunks[d] = neighborChunk.GetComponent <Chunk>();                                            // always add the neighbor to NeighborChunks, in case it's not there already

                                            // continue loop in next frame if the current frame time is exceeded
                                            if (frameStopwatch.Elapsed.TotalSeconds >= targetFrameDuration)
                                            {
                                                yield return(new WaitForEndOfFrame());
                                            }
                                            if (StopSpawning)
                                            {
                                                EndSequence();
                                                yield break;
                                            }
                                        }

                                        if (currentChunk != null)
                                        {
                                            currentChunk.AddToQueueWhenReady();
                                        }
                                    }
                                }
                            }



                            // continue loop in next frame if the current frame time is exceeded
                            if (frameStopwatch.Elapsed.TotalSeconds >= targetFrameDuration)
                            {
                                yield return(new WaitForEndOfFrame());
                            }
                            if (StopSpawning)
                            {
                                EndSequence();
                                yield break;
                            }
                        }
                    }
                }
            }

            yield return(new WaitForEndOfFrame());

            EndSequence();
        }
コード例 #2
0
 private void OnDestroy()
 {
     ChunkManager.UnregisterChunk(this);
 }
コード例 #3
0
        //以下的check都没有必要
        // ==== initialization ====
        public void Awake()
        {
            Engine.EngineInstance       = this;
            Engine.ChunkManagerInstance = GetComponent <ChunkManager>();

            WorldName = lWorldName;
            UpdateWorldPath();

            BlocksPath    = lBlocksPath;
            Engine.Blocks = lBlocks;

            TargetFPS            = lTargetFPS;
            MaxChunkSaves        = lMaxChunkSaves;
            MaxChunkDataRequests = lMaxChunkDataRequests;

            TextureUnit       = lTextureUnit;
            TexturePadding    = lTexturePadding;
            GenerateColliders = lGenerateColliders;
            ShowBorderFaces   = lShowBorderFaces;
            SaveVoxelData     = lSaveVoxelData;
            GenerateMeshes    = lGenerateMeshes;

            ChunkSpawnDistance   = lChunkSpawnDistance;
            HeightRange          = lHeightRange;
            ChunkDespawnDistance = lChunkDespawnDistance;

            SendCameraLookEvents = lSendCameraLookEvents;
            SendCursorEvents     = lSendCursorEvents;

            ChunkSideLength   = lChunkSideLength;
            SquaredSideLength = lChunkSideLength * lChunkSideLength;

            ChunkDataFiles.LoadedRegions = new Dictionary <string, string[]>();
            ChunkDataFiles.TempChunkData = new Dictionary <string, string>();

            if (lChunkTimeout <= 0.00001f)
            {
                EnableChunkTimeout = false;
            }
            else
            {
                EnableChunkTimeout = true;
                ChunkTimeout       = lChunkTimeout;
            }

            for (int i = 0; i < 31; i++)
            {
                Physics.IgnoreLayerCollision(i, 26);
            }


            // check block array
            if (Engine.Blocks.Length < 1)
            {
                Debug.LogError("CubeMaster: The blocks array is empty! Use the Block Editor to update the blocks array.");
                Debug.Break();
            }

            if (Engine.Blocks[0] == null)
            {
                Debug.LogError("CubeMaster: Cannot find the empty block prefab (id 0)!");
                Debug.Break();
            }
            else if (Engine.Blocks[0].GetComponent <Voxel>() == null)
            {
                Debug.LogError("CubeMaster: Voxel id 0 does not have the Voxel component attached!");
                Debug.Break();
            }

            // check settings
            if (Engine.ChunkSideLength < 1)
            {
                Debug.LogError("CubeMaster: Chunk side length must be greater than 0!");
                Debug.Break();
            }

            if (Engine.ChunkSpawnDistance < 1)
            {
                Engine.ChunkSpawnDistance = 0;
                Debug.LogWarning("CubeMaster: Chunk spawn distance is 0. No chunks will spawn!");
            }

            if (Engine.HeightRange < 0)
            {
                Engine.HeightRange = 0;
                Debug.LogWarning("CubeMaster: Chunk height range can't be a negative number! Setting chunk height range to 0.");
            }

            if (Engine.MaxChunkDataRequests < 0)
            {
                Engine.MaxChunkDataRequests = 0;
                Debug.LogWarning("CubeMaster: Max chunk data requests can't be a negative number! Setting max chunk data requests to 0.");
            }

            // check materials
            GameObject chunkPrefab   = GetComponent <ChunkManager>().ChunkObject;
            int        materialCount = chunkPrefab.GetComponent <Renderer>().sharedMaterials.Length - 1;

            for (ushort i = 0; i < Engine.Blocks.Length; i++)
            {
                if (Engine.Blocks[i] != null)
                {
                    Voxel voxel = Engine.Blocks[i].GetComponent <Voxel>();

                    if (voxel.VSubmeshIndex < 0)
                    {
                        Debug.LogError("CubeMaster: Voxel " + i + " has a material index lower than 0! Material index must be 0 or greater.");
                        Debug.Break();
                    }

                    if (voxel.VSubmeshIndex > materialCount)
                    {
                        Debug.LogError("CubeMaster: Voxel " + i + " uses material index " + voxel.VSubmeshIndex + ", but the chunk prefab only has " + (materialCount + 1) + " material(s) attached. Set a lower material index or attach more materials to the chunk prefab.");
                        Debug.Break();
                    }
                }
            }

            // check anti-aliasing
            if (QualitySettings.antiAliasing > 0)
            {
                Debug.LogWarning("CubeMaster: Anti-aliasing is enabled. This may cause seam lines to appear between blocks. If you see lines between blocks, try disabling anti-aliasing, switching to deferred rendering path, or adding some texture padding in the engine settings.");
            }


            Engine.Initialized = true;
        }