CODEWITHSUNDEEP
javaperformanceframe-rateslick2drectangles
M0rgenstern
M0rgenstern

Reputation: 411

Slick is getting very slow but only drawin rectangles

I am using slick for java since a few days and got a serious problem. If i run a completely empty apllication (it just shows the fps) with a solution of 800x600 i get a fps count between 700 and 800. If I now draw an array with 13300 entries as a grid of green and white rectangles, the fps drop to something around 70.

With more entries in the array it becomes really slow. For example in a solution of 1024x768 and an array with 21760 entries the fps drop to 40.

How i draw a single entry:

public void draw(Graphics graphics){
    graphics.setColor(new Color(getColor().getRed(), getColor().getGreen(), getColor().getBlue(), getColor().getAlpha()));

    graphics.fillRect(getPosition().x, getPosition().y, getSize().x, getSize().y);

    Color_ARGB white = new Color_ARGB(Color_ARGB.ColorNames.WHITE);
    graphics.setColor(new Color(white.getRed(), white.getGreen(), white.getBlue(), white.getAlpha()));
}

And this is how I draw the complete array:

public void draw(Graphics graphics) {
    for (int ix = 0; ix < getWidth(); ix++) {
        for (int iy = 0; iy < getHeight(); iy++) {
            getGameGridAt(ix, iy).draw(graphics);
        }
    }
}

In my opinion 21760 is not that much. Is there anything wrong with my code or is slick just too slow to draw so much rectangles?

Upvotes: 1

Views: 1433

Answers (5)

theDazzler
theDazzler

Reputation: 1059

You only want to draw rectangles that are on the screen. If your screen bounds go from 0 to 1024 in the x direction and from 0 to 768 in the y direction, then you only want to loop through rectangles that are inside those bounds and then only draw those rectangles. I can't imagine you are trying to draw 21760 rectangles inside those bounds.

If you are, then try creating one static rectangle and then just try drawing that ONE in all of the different positions you need to draw it at rather than creating a new one every time. For example, in a game I am making, I might have 1000 tiles that are "grass" tiles, but all 1000 of those share the same static texture. So I only need to reference one image rather than each tile creating its own.

Each rectangle can still have a unique state. Just make your own rectangle class and have a static final Image that holds a 5*5 image. Each rectangle will use this image when it needs to be drawn. You can still have unique properties for each rectangle. For example, private Vector2f position, private boolean isAlive, etc

Upvotes: 1

xception
xception

Reputation: 4297

Just noticed in another answer you have an integral size grid (5x5) ... in this case the fastest way to go about this would seem to be to draw each item a single pixel (you can do this directly in memory using a 2-dimensional array) and scale it to 500% or use it as a texture and draw a single rectangle with it the final size you desire ... should be quite fast. Sorry for all the confusion caused by previous answers, you should have said what you're doing more clearly from the start. If scaling and textures are not available you can still draw in memory using something like this (written in c++, please translate it to java yourself)

for( int x = 0; x < grid.width(); x++ ) {
   for( int y = 0; y < grid.height(); y++ ) {
      image[x*5][y*5] = grid.color[x][y];
      image[x*5][y*5 + 1] = grid.color[x][y];
      image[x*5][y*5 + 2] = grid.color[x][y];
      image[x*5][y*5 + 3] = grid.color[x][y];
      image[x*5][y*5 + 4] = grid.color[x][y];
   }
   memcpy(image[x*5+1], image[x*5], grid.height() * sizeof(image[0][0]) );
   memcpy(image[x*5+2], image[x*5], grid.height() * sizeof(image[0][0]) );
   memcpy(image[x*5+3], image[x*5], grid.height() * sizeof(image[0][0]) );
   memcpy(image[x*5+4], image[x*5], grid.height() * sizeof(image[0][0]) );
}

I'm not sure, but perhaps for graphics the x and y might be represented in the reversed order than used here, so change the code accordingly if it that's the case (you'll figure that out as soon as a few iterations run), also your data is probably structured a bit differently but I think the idea should be clear.

Upvotes: 0

xception
xception

Reputation: 4297

Since you're only repeatedly using just a few colors creating a new Color object for every single one is bound to be slow... use new only once for each different color used and store the re-usable colors somewhere in your class, than call the functions with those, constantly allocating and freeing memory is very slow.

And while this might not be as much a benefit as not using new each time but have you considered caching the results of all those function calls and rewriting code as

public void draw(Graphics graphics) {
    int ixmax = getWidth();
    int iymax = getHeight();
    for (int ix = 0; ix < ixmax; ix++) {
        for (int iy = 0; iy < iymax; iy++) {
            getGameGridAt(ix, iy).draw(graphics);
        }
    }
}

Or if you'd prefer not to declare new variables

public void draw(Graphics graphics) {
    for (int ix = getWidth() - 1; ix >= 0; ix--) {
        for (int iy = getHeight() - 1; iy >= 0; iy--) {
            getGameGridAt(ix, iy).draw(graphics);
        }
    }
}

Upvotes: 0

xception
xception

Reputation: 4297

Not sure if Slick will allow it, but if this thing looks anything like a chessboard grid... you could draw just 4 rectangles, grab them and use the resulting image as a texture for your whole image. I'm not even a java programmer just trying to come up with a solution.

Upvotes: 0

Ben Voigt
Ben Voigt

Reputation: 283971

You're probably not going to be able to draw individual rectangles any faster than that.

Games that render millions of polygons per second do so using vertex buffer objects (VBO). For that, you'll probably need to code against the OpenGL API (LWJGL) itself, not a wrapper.

Upvotes: 0

Related Questions