示例#1
0
        public void RebuildVoxelsThread()
        {
            Thread.CurrentThread.CurrentCulture   = CultureInfo.InvariantCulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

#if CREATE_CRASH_LOGS
            try
#endif
            {
                while (!DwarfGame.ExitGame && !ExitThreads)
                {
                    RebuildEvent.WaitOne();
                    VoxelChunk chunk = null;
                    do
                    {
                        chunk = PopInvalidChunk();
                        if (chunk != null)
                        {
                            chunk.Rebuild(GameState.Game.GraphicsDevice);
                            NeedsMinimapUpdate = true;
                        }
                    }while (chunk != null);
                }
            }
#if CREATE_CRASH_LOGS
            catch (Exception exception)
            {
                ProgramData.WriteExceptionLog(exception);
                throw;
            }
#endif
        }
示例#2
0
        public void RebuildVoxelsThread()
        {
            Console.Out.WriteLine("Starting chunk regeneration thread.");
            Thread.CurrentThread.CurrentCulture   = CultureInfo.InvariantCulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

#if !DEBUG
            try
#endif
            {
                while (!DwarfGame.ExitGame && !ExitThreads)
                {
                    try
                    {
                        RebuildEvent.WaitOne();
                    }
                    catch (ThreadAbortException exception)
                    {
                        continue;
                    }
                    VoxelChunk chunk = null;
                    do
                    {
                        chunk = PopInvalidChunk();
                        if (chunk != null)
                        {
                            chunk.Rebuild(GameState.Game.GraphicsDevice);
                            NeedsMinimapUpdate = true;
                        }
                    }while (chunk != null);
                }
            }
#if !DEBUG
            catch (Exception exception)
            {
                Console.Out.WriteLine("Chunk regeneration thread exited due to an exception.");
                ProgramData.WriteExceptionLog(exception);
                throw;
            }
#endif
            Console.Out.WriteLine(String.Format("Chunk regeneration thread exited cleanly Exit Game: {0} Exit Thread: {1}.", DwarfGame.ExitGame, ExitThreads));
        }
示例#3
0
        public void CreateGraphics(ref string message, ChunkData chunkData)
        {
            message = "Creating Graphics";
            List <VoxelChunk> toRebuild = new List <VoxelChunk>();

            while (RebuildList.Count > 0)
            {
                VoxelChunk chunk = null;
                if (!RebuildList.TryDequeue(out chunk))
                {
                    break;
                }

                if (chunk == null)
                {
                    continue;
                }

                toRebuild.Add(chunk);
            }

            message = "Creating Graphics : Updating Ramps";
            foreach (VoxelChunk chunk in toRebuild.Where(chunk => GameSettings.Default.CalculateRamps))
            {
                chunk.UpdateRamps();
            }

            message = "Creating Graphics : Calculating lighting ";
            int j = 0;

            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                message = "Creating Graphics : Calculating lighting " + j + "/" + toRebuild.Count;
                if (chunk.ShouldRecalculateLighting)
                {
                    chunk.CalculateGlobalLight();
                    chunk.ShouldRecalculateLighting = false;
                }
            }

            j = 0;
            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                message = "Creating Graphics : Calculating vertex light " + j + "/" + toRebuild.Count;
                chunk.CalculateVertexLighting();
            }

            message = "Creating Graphics: Building Vertices";
            j       = 0;
            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                message = "Creating Graphics : Building Vertices " + j + "/" + toRebuild.Count;

                if (!chunk.ShouldRebuild)
                {
                    continue;
                }

                chunk.Rebuild(Graphics);
                chunk.ShouldRebuild        = false;
                chunk.RebuildPending       = false;
                chunk.RebuildLiquidPending = false;
            }

            chunkData.RecomputeNeighbors();


            message = "Cleaning Up.";
        }
示例#4
0
        public void RebuildVoxelsThread()
        {
            EventWaitHandle[] waitHandles =
            {
                NeedsRebuildEvent,
                Program.ShutdownEvent
            };

#if CREATE_CRASH_LOGS
            try
#endif
            {
                while (!DwarfGame.ExitGame && !ExitThreads)
                {
                    EventWaitHandle wh = Datastructures.WaitFor(waitHandles);

                    if (wh == Program.ShutdownEvent)
                    {
                        break;
                    }
                    {
                        if (PauseThreads)
                        {
                            continue;
                        }

                        Dictionary <Point3, VoxelChunk> toRebuild = new Dictionary <Point3, VoxelChunk>();
                        bool calculateRamps = GameSettings.Default.CalculateRamps;
                        lock (RebuildList)
                        {
                            while (RebuildList.Count > 0)
                            {
                                VoxelChunk chunk = null;

                                if (!RebuildList.TryDequeue(out chunk))
                                {
                                    continue;
                                }

                                if (chunk == null)
                                {
                                    continue;
                                }

                                toRebuild[chunk.ID] = chunk;

                                if (PauseThreads)
                                {
                                    break;
                                }
                            }
                        }

                        if (calculateRamps)
                        {
                            foreach (VoxelChunk chunk in toRebuild.Select(chunkPair => chunkPair.Value))
                            {
                                chunk.UpdateRamps();
                            }
                        }


                        foreach (
                            VoxelChunk chunk in
                            toRebuild.Select(chunkPair => chunkPair.Value)
                            .Where(chunk => chunk.ShouldRecalculateLighting))
                        {
                            chunk.CalculateGlobalLight();
                        }

                        foreach (VoxelChunk chunk in toRebuild.Select(chunkPair => chunkPair.Value))
                        {
                            if (chunk.RebuildPending && chunk.ShouldRebuild)
                            {
                                if (chunk.ShouldRecalculateLighting)
                                {
                                    chunk.CalculateVertexLighting();
                                }
                                chunk.Rebuild(Graphics);
                                chunk.ShouldRebuild             = false;
                                chunk.RebuildPending            = false;
                                chunk.ShouldRecalculateLighting = false;
                            }
                            else
                            {
                                chunk.RebuildPending = false;
                            }
                        }
                    }
                }
            }
#if CREATE_CRASH_LOGS
            catch (Exception exception)
            {
                ProgramData.WriteExceptionLog(exception);
                throw;
            }
#endif
        }
示例#5
0
        public void CreateGraphics(Action <String> SetLoadingMessage, ChunkData chunkData)
        {
            SetLoadingMessage("Creating Graphics");
            List <VoxelChunk> toRebuild = new List <VoxelChunk>();

            while (RebuildList.Count > 0)
            {
                VoxelChunk chunk = null;
                if (!RebuildList.TryDequeue(out chunk))
                {
                    break;
                }

                if (chunk == null)
                {
                    continue;
                }

                toRebuild.Add(chunk);
            }

            SetLoadingMessage("Updating Ramps");
            foreach (VoxelChunk chunk in toRebuild.Where(chunk => GameSettings.Default.CalculateRamps))
            {
                chunk.UpdateRamps();
            }

            SetLoadingMessage("Calculating lighting ");
            int j = 0;

            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                SetLoadingMessage("Calculating lighting " + j + "/" + toRebuild.Count);
                if (chunk.ShouldRecalculateLighting)
                {
                    chunk.CalculateGlobalLight();
                    chunk.ShouldRecalculateLighting = false;
                }
            }

            j = 0;
            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                SetLoadingMessage("Calculating vertex light " + j + "/" + toRebuild.Count);
                chunk.CalculateVertexLighting();
            }

            SetLoadingMessage("Building Vertices");
            j = 0;
            foreach (VoxelChunk chunk in toRebuild)
            {
                j++;
                SetLoadingMessage("Building Vertices " + j + "/" + toRebuild.Count);

                if (!chunk.ShouldRebuild)
                {
                    continue;
                }

                chunk.Rebuild(Graphics);
                chunk.ShouldRebuild        = false;
                chunk.RebuildPending       = false;
                chunk.RebuildLiquidPending = false;
            }

            SetLoadingMessage("Cleaning Up.");
        }
示例#6
0
        public void RebuildVoxelsThread()
        {
            Console.Out.WriteLine("Starting chunk regeneration thread.");
            Thread.CurrentThread.CurrentCulture   = CultureInfo.InvariantCulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

            var liveChunks = new List <VoxelChunk>();

#if !DEBUG
            try
#endif
            {
                while (!DwarfGame.ExitGame && !ExitThreads)
                {
                    try
                    {
                        RebuildEvent.WaitOne();
                    }
                    catch (ThreadAbortException exception)
                    {
                        continue;
                    }

                    VoxelChunk chunk = null;

                    do
                    {
                        chunk = PopInvalidChunk();
                        if (chunk != null)
                        {
                            if (!chunk.Visible)
                            {
                                continue;                 // Don't bother rebuilding chunks that won't be rendered.
                            }
                            chunk.Rebuild(GameState.Game.GraphicsDevice);

                            liveChunks.Add(chunk);

                            if (liveChunks.Count() > GameSettings.Current.MaxLiveChunks)
                            {
                                liveChunks.Sort((a, b) => a.RenderCycleWhenLastVisible - b.RenderCycleWhenLastVisible);

                                while (liveChunks.Count() > GameSettings.Current.MaxLiveChunks)
                                {
                                    if (liveChunks[0].Visible)
                                    {
                                        break;
                                    }
                                    liveChunks[0].DiscardPrimitive();
                                    liveChunks.RemoveAt(0);
                                }
                            }

                            NeedsMinimapUpdate = true; // Soon to be redundant.
                        }
                    }while (chunk != null);

                    PerformanceMonitor.SetMetric("VISIBLE CHUNKS", liveChunks.Count);
                }
            }
#if !DEBUG
            catch (Exception exception)
            {
                Console.Out.WriteLine("Chunk regeneration thread encountered an exception.");
                ProgramData.WriteExceptionLog(exception);
                //throw;
            }
#endif
            Console.Out.WriteLine(String.Format("Chunk regeneration thread exited cleanly Exit Game: {0} Exit Thread: {1}.", DwarfGame.ExitGame, ExitThreads));
        }