示例#1
0
        public UInt64 GetXZGroup(int chunkPerDimension)
        {
            UInt64 result = ((UInt64)CoordHelpers.GetGroupedCoordinate(this.X, chunkPerDimension)) << 32;

            result |= (UInt32)CoordHelpers.GetGroupedCoordinate(this.Z, chunkPerDimension);

            return(result);
        }
示例#2
0
        public BitmapRenderBlock(Dictionary <string, Texture> textureDictionary, string texturePath, ChunkPool pool,
                                 RenderSettings renderSettings, IGraphicsApi <TImage> graphics, int chunkSize, int chunksPerDimension,
                                 ExecutionDataflowBlockOptions options)
        {
            int tileSize = chunksPerDimension * chunkSize;

            graphics.SetPoolDimensions(tileSize, tileSize);
            int chunkRenderedCounter = 0;
            ThreadLocal <RendererCombi <TImage> > renderCombi = new ThreadLocal <RendererCombi <TImage> >(() =>
                                                                                                          new RendererCombi <TImage>(textureDictionary, texturePath, renderSettings, graphics));

            Block = new TransformBlock <IEnumerable <ChunkAndData>, ImageInfo <TImage> >(chunkAndData =>
            {
                var b = graphics.GetPooledImage();
                {
                    var chunkList     = chunkAndData.ToList();
                    var firstX        = chunkList.First().C.X;
                    var firstZ        = chunkList.First().C.Z;
                    var chunkRenderer = renderCombi.Value.ChunkRenderer;

                    foreach (var chunk in chunkList)
                    {
                        var x = chunk.C.X % chunksPerDimension;
                        var z = chunk.C.Z % chunksPerDimension;
                        if (x < 0)
                        {
                            x += chunksPerDimension;
                        }
                        if (z < 0)
                        {
                            z += chunksPerDimension;
                        }
                        chunkRenderer.RenderChunk(b, chunk.C, x * chunkSize, z * chunkSize);

                        pool?.Return(chunk.C);
                    }


                    var fx = CoordHelpers.GetGroupedCoordinate(firstX, chunksPerDimension);
                    var fz = CoordHelpers.GetGroupedCoordinate(firstZ, chunksPerDimension);

                    Interlocked.Increment(ref processedCount);
                    Interlocked.Add(ref chunkRenderedCounter, chunkList.Count);

                    if (chunkRenderedCounter >= 32)
                    {
                        var v = chunkRenderedCounter;
                        ChunksRendered?.Invoke(this, new ChunksRenderedEventArgs(v));
                        Interlocked.Add(ref chunkRenderedCounter, -v);
                    }

                    return(new ImageInfo <TImage>()
                    {
                        Image = b, X = fx, Z = fz, Cd = chunkList.SelectMany(x => x.Cd)
                    });
                }
            }, options);
        }
        public CreateChunkAndRenderBlock(
            World world,
            Dictionary <string, Texture> textureDictionary,
            string texturePath,
            RenderSettings renderSettings,
            IGraphicsApi <TImage> graphics,
            int chunkSize, int chunksPerDimension,
            ExecutionDataflowBlockOptions options)
        {
            int tileSize = chunksPerDimension * chunkSize;

            graphics.SetPoolDimensions(tileSize, tileSize);
            int chunkRenderedCounter = 0;
            var renderCombiPool      = new GenericPool <RendererCombi <TImage> >(() => new RendererCombi <TImage>(textureDictionary, texturePath, renderSettings, graphics));

            Block = new TransformBlock <IEnumerable <ChunkData>, ImageInfo <TImage> >(chunkDatas =>
            {
                RendererCombi <TImage> chunkRenderer = null;
                try
                {
                    var b = graphics.GetPooledImage(); // pooled
                    //var b = graphics.CreateEmptyImage(tileSize, tileSize);

                    chunkRenderer = renderCombiPool.Get();
                    var firstX    = -1;
                    var firstZ    = -1;

                    var count         = 0;
                    var chunkDataList = chunkDatas.ToList();
                    foreach (var chunkData in chunkDataList)
                    {
                        var chunk = world.GetChunk(chunkData.X, chunkData.Z, chunkData);

                        if (firstX == -1)
                        {
                            firstX = chunkData.X;
                        }
                        if (firstZ == -1)
                        {
                            firstZ = chunkData.Z;
                        }

                        var x = chunk.X % chunksPerDimension;
                        var z = chunk.Z % chunksPerDimension;
                        if (x < 0)
                        {
                            x += chunksPerDimension;
                        }
                        if (z < 0)
                        {
                            z += chunksPerDimension;
                        }
                        chunkRenderer.ChunkRenderer.RenderChunk(b, chunk, x * chunkSize, z * chunkSize);

                        world.ChunkPool?.Return(chunk);
                        count++;
                    }


                    var fx = CoordHelpers.GetGroupedCoordinate(firstX, chunksPerDimension);
                    var fz = CoordHelpers.GetGroupedCoordinate(firstZ, chunksPerDimension);

                    Interlocked.Increment(ref processedCount);
                    Interlocked.Add(ref chunkRenderedCounter, count);

                    if (chunkRenderedCounter >= 128)
                    {
                        var v = chunkRenderedCounter;
                        ChunksRendered?.Invoke(this, new ChunksRenderedEventArgs(v));
                        Interlocked.Add(ref chunkRenderedCounter, -v);
                    }

                    /*if (r.Next(100) == 0)
                     * {
                     *  throw new ArgumentOutOfRangeException("Test Error in CreateChunkAndRender");
                     * }*/



                    return(new ImageInfo <TImage>()
                    {
                        Image = b,
                        X = fx,
                        Z = fz,
                        Cd = chunkDataList.SelectMany(x => x.SubChunks)
                    });
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Error in CreateChunkAndRenderBlock: " + ex.Message);
                    return(null);
                }
                finally
                {
                    if (chunkRenderer != null)
                    {
                        renderCombiPool.Return(chunkRenderer);
                    }
                }
            }, options);
        }