CODEWITHSUNDEEP
javaperformancegraphics2d
user3047181
user3047181

Reputation:

Graphics2D performance issue

I'm new to Java's graphics library and I'm still coming to grips with its limitations. Below I have a draw function for a Grid class, which draws a 2D array of tiles as filled rectangles.

Not that it's pertinent to the question but the the scale and offset arguments are there to adjust the Grid's tiles and tileSize variables such that it's drawn in the correct position and scale on the screen.

My question is it normal for this to lag considerably when the tiles variable is quite big? I normally get around 500 fps without any Grids on screen, and no noticeable reduction with a Grid of tiles[10][10] to [50][50]. But at tiles[1000][1000], or 1,000,000 total rectangles to draw, fps drops to 7.

I know a million is a lot, but they are just rectangles after all, and my pc can play a game like Skyrim on full settings no problem. I'd imagine there's more than a million polygons on display in Skyrim, and they comes with all sorts of highres textures and lighting and all so, why should a million gray squares be such a problem? Is Java's graphics library really poor? Am I expecting too much? Or, as I suspect, is there a much better way of drawing something like this?

I can provide the main class's paintComponent if that's important, but it's just a call to _Grid.draw() so I don't think the problem's there..

public Graphics draw(Graphics g, double scale, Point offset) {

    Graphics2D g2 = (Graphics2D) g;

    for(int i = 0; i != this.tiles.length; i++) {
        for(int j = 0; j != this.tiles[0].length; j++) {

            boolean draw = true;

            if(this.tiles[i][j].type.equals("EMPTY")) {
                draw = false;
            } else if(this.tiles[i][j].type.equals("PATH")) {
                g2.setColor(Color.LIGHT_GRAY);
            } else if(this.tiles[i][j].type.equals("WALL")) {
                g2.setColor(Color.DARK_GRAY);
            }

            if(draw) {
                g2.fillRect((int)((this.xPos+i*this.tileSize)*scale + offset.x), 
                            (int)((this.yPos+j*this.tileSize)*scale + offset.y), 
                            (int)(this.tileSize*scale), 
                            (int)(this.tileSize*scale));
            }
        }
    }

    return g2;

}

Upvotes: 2

Views: 479

Answers (2)

CodeBlind
CodeBlind

Reputation: 4569

A few things you might consider trying:

  1. If your original Graphics object is being created by a BufferedImage, consider using VolatileImage instead. As others have said, everything in this draw method is happening on the CPU via the Swing Event Dispatch Thread, so you are limited to a single CPU for drawing (unless you spawn more Threads somewhere). VolatileImage, when used for double-buffering, takes advantage of the graphics hardware and can be MUCH faster for this kind of thing.

  2. You're doing a TON of String comparisons, which can be very slow. I'd consider refactoring your type field to be a custom enum instead, then have that enum define its own draw method that takes a Graphics object and draws itself. That way, you could call this.tyles[i][j].type.draw(g2) and rely on late binding to draw the right colored rectangle, thereby eliminating the String comparisons.

  3. Make sure you're only drawing the stuff that's on screen. I don't know anything about your tiles array, but if it's significantly larger than what's actually being rendered to screen, you could be wasting a lot of CPU cycles there.

  4. This might sound silly, but you're actually doing twice as many memory accesses as you really need. I'm going to assume you have Tile[][] tiles ... defined somewhere in your source code. In the outer loop, grab the row first by writing something like Tile[] row = tiles[i];, then in your inner loop, get the type by calling row[j].type. This will cut your memory access count in half when iterating over the tile array.

Upvotes: 3

Tim B
Tim B

Reputation: 41168

Java's BufferedImage class is slow. It's a known fact. If you want to do fast image manipulation then it's the wrong tool to use.

Additionally games like Skyrim are using the graphics card to do most of the work, using the Java Image stuff it is all being done in the CPU.

You should really look into using a game framework - there are 2d ones like Slick2d and 3d ones like jMonkeyEngine3.

Upvotes: 3

Related Questions