CODEWITHSUNDEEP
c#wpf
Aaron M
Aaron M

Reputation: 2563

Improving performance of drawing Tiled bitmaps in wpf

I'm looking for a way to improve the performance of some drawing I am doing. Currently it is a 32x32 grid of tiles that I am drawing. Using the following code to draw onto the drawing context

for (int x = startX; x < endX; x++)
        {
            for (int y = startY; y < endY; y++)
            {
                dg.Children.Add(
                    new ImageDrawing(_mapTiles[GameWorldObject.GameMap[x, y].GraphicsTile.TileStartPoint],
                        new Rect(CountX * 8, CountY * 8, 8, 8)
                        ));

                dg.Children.Add(
                    new GeometryDrawing(
                        null,
                        new Pen(
                            new SolidColorBrush(
                                Color.FromRgb(255, 0, 20)), .3), 
                                new RectangleGeometry(
                                    new Rect(CountX * 8, CountY * 8, 8, 8)
                                )
                            )
                        );

                CountY++;
            }
            CountY = 0;
            CountX++;
        }

        dc.DrawDrawing(dg);

The Image I am drawing is a CachedBitmap. Even using a CachedBitmap, I still have a delay of about a half second each time I need to redraw the Canvas.

Not sure if there is a more performant way to handle drawing to this grid. Eventually I want to expand control to function as a mini-map, so I need to keep that in mind.

Also, I tried previously to just draw each bitmap directly to the drawing context but that seems a bit slower.

Upvotes: 2

Views: 1791

Answers (3)

Aaron M
Aaron M

Reputation: 2563

I added DrawingGroup.Freeze() before drawing, and it seemed to help with the performance.

Upvotes: 1

Kris
Kris

Reputation: 7170

Here's a example using WriteableBitmap, the performance of this is mainly related to the size of the whole map whereas your original method is more dependent on the amount of tiles. You could alter it to have an alpha-blended border between the tiles but leaving a gap between them would be easier and more performant. You won't need the code randomising the tiles but you should have some dirty flag so you only redraw the bitmap when its changed.

You may also want to look my answer and the others to this question. That said you don't have as many items and 32x32 using your method wasn't slow for me.

<local:Map x:Name="map" />
<RepeatButton Click="Button_Click" Content="Change" />



private void Button_Click(object sender, RoutedEventArgs e)
{
    map.seed++;
    map.InvalidateVisual();
}



public class Map : FrameworkElement
{
    private int[][] _mapTiles;

    public Map()
    {
        _mapTiles = Directory.GetFiles(@"C:\Users\Public\Pictures\Sample Pictures", "*.jpg").Select(x =>
        {
            var b = new BitmapImage(new Uri(x));
            var transform = new TransformedBitmap(b, new ScaleTransform((1.0 / b.PixelWidth)*tileSize,(1.0 / b.PixelHeight)*tileSize));
            var conv = new FormatConvertedBitmap(transform, PixelFormats.Pbgra32, null, 0);
            int[] data = new int[tileSize * tileSize];
            conv.CopyPixels(data, tileSize * 4, 0);
            return data;
        }).ToArray();

        bmp = new WriteableBitmap(w * tileSize, h * tileSize, 96, 96, PixelFormats.Pbgra32, null);
        destData = new int[bmp.PixelWidth * bmp.PixelHeight];
    }

    const int w = 64, h = 64, tileSize = 8;
    public int seed = 72141;
    private int oldSeed = -1;
    private WriteableBitmap bmp;
    int[] destData;

    protected override void OnRender(DrawingContext dc)
    {
        if(seed != oldSeed)
        {
            oldSeed = seed;
            int startX = 0, endX = w;
            int startY = 0, endY = h;
            Random rnd = new Random(seed);

            for(int x = startX; x < endX; x++)
            {
                for(int y = startY; y < endY; y++)
                {
                    var tile = _mapTiles[rnd.Next(_mapTiles.Length)];
                    var rect = new Int32Rect(x * tileSize, y * tileSize, tileSize, tileSize);
                    for(int sourceY = 0; sourceY < tileSize; sourceY++)
                    {
                        int destY = ((rect.Y + sourceY) * (w * tileSize)) + rect.X;
                        Array.Copy(tile, sourceY * tileSize, destData, destY, tileSize);
                    }
                }
            }

            bmp.WritePixels(new Int32Rect(0, 0, w * tileSize, h * tileSize), destData, w * tileSize * 4, 0);
        }

        dc.DrawImage(bmp,new Rect(0,0,w*tileSize,h*tileSize));
    }
}

Upvotes: 0

Ben
Ben

Reputation: 1043

If it's mostly static minimap draw it into an Image, and draw that image. Or you can do a big image, where you draw the whole map into it, and just draw the current visible part of it.

Edit: And maybe this blog post worth a check, whether you are drawing it with software or hardware acceleration on.

Upvotes: 0

Related Questions