Exemplo n.º 1
0
        public void Update(GameTime gameTime)
        {
            var  any = false;
            Mesh _mesh;

            while (IncomingChunks.TryTake(out _mesh))
            {
                any = true;
                var mesh = _mesh as ChunkMesh;
                if (ActiveMeshes.Contains(mesh.Chunk.Coordinates))
                {
                    int existing = ChunkMeshes.FindIndex(m => m.Chunk.Coordinates == mesh.Chunk.Coordinates);
                    ChunkMeshes[existing] = mesh;
                }
                else
                {
                    ActiveMeshes.Add(mesh.Chunk.Coordinates);
                    ChunkMeshes.Add(mesh);
                }
            }
            if (any)
            {
                Game.FlushMainThreadActions();
            }
            WorldLighting.TryLightNext();
        }
Exemplo n.º 2
0
 //reading data chunks
 public override void Start()
 {
     StartTime = DateTime.Now;
     try
     {
         using (var inFileStream = new FileStream(InFileName, FileMode.Open))
         {
             InFileStream = inFileStream;
             for (ChunkCounter = 0; inFileStream.Length - inFileStream.Position > 0; ChunkCounter++)
             {
                 if (StopRequested)
                 {
                     return;
                 }
                 //check the percentage of remaining memory to initial
                 while ((float)CompInfo.AvailablePhysicalMemory / InitialFreeRam < 0.1)
                 {
                     //forcing garbage collector cleanup
                     GC.Collect(2, GCCollectionMode.Forced);
                     Thread.Sleep(1000);
                 }
                 //optimal data read chunk size based on ram and cpu cores
                 var dataChunkSize = (long)CompInfo.AvailablePhysicalMemory / CoreCount / 1;
                 //size of chunk for the last chunck
                 if (inFileStream.Length - inFileStream.Position <= dataChunkSize)
                 {
                     dataChunkSize = inFileStream.Length - inFileStream.Position;
                 }
                 //size of chunk for small files
                 if (inFileStream.Length < dataChunkSize)
                 {
                     dataChunkSize = inFileStream.Length / CoreCount + 1;
                 }
                 //constant size of chunk for huge files
                 if (dataChunkSize > 256 * 1024 * 1024)
                 {
                     dataChunkSize = 256 * 1024 * 1024;
                 }
                 var dataChunk = new byte[dataChunkSize];
                 //read file
                 inFileStream.Read(dataChunk, 0, (int)dataChunkSize);
                 lock (Locker)
                     IncomingChunks.Add(ChunkCounter, dataChunk);
                 //starting new thread with chunk number as an argument
                 var chunkNumber    = ChunkCounter;
                 var compressThread = new Thread(() => ProcessChunk(chunkNumber));
                 compressThread.Start();
             }
             IncomingFinished = true;
         }
     }
     catch (Exception ex)
     {
         StopRequested = true;
         Console.Write("There is the problem at the compression process:{0}", ex.Message);
     }
 }
Exemplo n.º 3
0
        protected override void Update(GameTime gameTime)
        {
            GameTime = gameTime;

            foreach (var i in Interfaces)
            {
                i.Update(gameTime);
            }

            Mesh mesh;

            while (IncomingChunks.TryTake(out mesh))
            {
                ChunkMeshes.Add(mesh);
            }
            Action action;

            if (PendingMainThreadActions.TryTake(out action))
            {
                action();
            }

            if (NextPhysicsUpdate < DateTime.UtcNow && Client.LoggedIn)
            {
                IChunk chunk;
                var    adjusted = Client.World.World.FindBlockPosition(new Coordinates3D((int)Client.Position.X, 0, (int)Client.Position.Z), out chunk);
                if (chunk != null)
                {
                    if (chunk.GetHeight((byte)adjusted.X, (byte)adjusted.Z) != 0)
                    {
                        Client.Physics.Update();
                    }
                }
                // NOTE: This is to make the vanilla server send us chunk packets
                // We should eventually make some means of detecing that we're on a vanilla server to enable this
                // It's a waste of bandwidth to do it on a TrueCraft server
                Client.QueuePacket(new PlayerGroundedPacket {
                    OnGround = true
                });
                Client.QueuePacket(new PlayerPositionAndLookPacket(Client.Position.X, Client.Position.Y,
                                                                   Client.Position.Y + MultiplayerClient.Height, Client.Position.Z, Client.Yaw, Client.Pitch, false));
                NextPhysicsUpdate = DateTime.UtcNow.AddMilliseconds(1000 / 20);
            }

            if (Delta != Microsoft.Xna.Framework.Vector3.Zero)
            {
                var lookAt = Microsoft.Xna.Framework.Vector3.Transform(
                    Delta, Matrix.CreateRotationY(Microsoft.Xna.Framework.MathHelper.ToRadians(Client.Yaw)));

                Client.Position += new TrueCraft.API.Vector3(lookAt.X, lookAt.Y, lookAt.Z)
                                   * (gameTime.ElapsedGameTime.TotalSeconds * 4.3717);
            }

            base.Update(gameTime);
        }
Exemplo n.º 4
0
 //compress data chunk
 protected override void ProcessChunk(int chunkNumber)
 {
     if (StopRequested)
     {
         return;
     }
     ProcessSemaphore.WaitOne();
     try
     {
         KeyValuePair <int, byte[]> chunk;
         lock (Locker)
             chunk = IncomingChunks.FirstOrDefault(b => b.Key == chunkNumber);
         //stream for processed data
         using (var outMemStream = new MemoryStream())
         {
             using (var zipStream = new GZipStream(outMemStream, CompressionMode.Compress))
             {
                 using (var inMemStream = new MemoryStream(chunk.Value, 0, chunk.Value.Length))
                 {
                     inMemStream.CopyTo(zipStream);
                 }
             }
             //compressed bytes
             var bytes = outMemStream.ToArray();
             lock (Locker)
             {
                 //add new data chunk to collection of compressed data
                 OutgoingChunks.Add(chunkNumber, bytes);
                 //remove chunk from collection of uncompressed data
                 IncomingChunks.Remove(chunkNumber);
             }
         }
     }
     catch (Exception ex)
     {
         StopRequested = true;
         Console.Write("There is an exception at the compressing process: {0}", ex.Message);
     }
     ProcessSemaphore.Release();
     //if this is the first chunk - start writing to disk in a separate thread
     if (chunkNumber == 0 && WritingThread.ThreadState != ThreadState.Running && !StopRequested)
     {
         WritingThread.Start();
     }
 }
Exemplo n.º 5
0
 //read compressed data chunks from disk
 public override void Start()
 {
     StartTime = DateTime.Now;
     try
     {
         using (var inFileStream = new FileStream(InFileName, FileMode.Open))
         {
             InFileStream = inFileStream;
             var header = new byte[8];
             for (ChunkCounter = 0; inFileStream.Length - inFileStream.Position > 0; ChunkCounter++)
             {
                 if (StopRequested)
                 {
                     return;
                 }
                 //ram overload - wait
                 while ((float)CompInfo.AvailablePhysicalMemory / InitialFreeRam < 0.1)
                 {
                     //force gc cleanup
                     GC.Collect(2, GCCollectionMode.Forced);
                     Thread.Sleep(1000);
                 }
                 //extract compressed data chunk size from gzip header
                 inFileStream.Read(header, 0, 8);
                 var dataChunkSize   = BitConverter.ToInt32(header, 4);
                 var compressedChunk = new byte[dataChunkSize];
                 header.CopyTo(compressedChunk, 0);
                 //get the rest bytes of data block
                 inFileStream.Read(compressedChunk, 8, dataChunkSize - 9);
                 lock (Locker)
                     IncomingChunks.Add(ChunkCounter, compressedChunk);
                 var chunkNumber      = ChunkCounter;
                 var decompressThread = new Thread(() => ProcessChunk(chunkNumber));
                 decompressThread.Start();
             }
             IncomingFinished = true;
         }
     }
     catch (Exception ex)
     {
         StopRequested = true;
         Console.Write("There is tecompression process:{0}", ex.Message);
     }
 }
Exemplo n.º 6
0
 void MeshCompleted(object sender, RendererEventArgs <ReadOnlyChunk> e)
 {
     IncomingChunks.Add(e.Result);
 }
Exemplo n.º 7
0
 void ChunkConverter_MeshGenerated(object sender, RendererEventArgs <ReadOnlyChunk> e)
 {
     IncomingChunks.Add(e.Result);
 }