re-using objects

Question

I'm working with openGL ES 2.0 on Android and I've created a custom Quad class.

This allows me to make a sprite object like so:

Quad mySprite = new Quad();
mySprite.setSize(w,h);
mySprite.setTexture(myTexture);

Then, I can draw it like so:

mySprite.draw();

The draw() method uses mySprite's internal x and y coordinates which are declared within the Quad Class.

I also have another method which allows me to draw the quad specifying other 'external' co-ordinates like so:

mySprite.draw(x,y);

Now let's say that on one of the levels of my game, I have the need to draw 3 of these sprites at different positions and move them all independently of each other.

At the moment, I think I have 2 options, which are:

1) Create different quad's with the same texture and use them with their internal coordinates or....

2) Use the same object but hold an array of external coordinates and just draw it three times at different places.

My preferred option would be 1 because it's just cleaner to work with but clearly inefficient as I'm having to create multiple objects that are essentially the same (inefficient memory-wise?)

So is there a way of using just one version of the sprite? Maybe using clones or something along those lines so that I can just keep track of each clone's internal position and states rather than using external arrays?

Answer 1

Do not draw the same Sprite to represent the image at multiple locations. Holding the coordinates somewhere else - this defeats the purpose of object-oriented programming. The most memory is taken by the texture (or texture region) itself, the overhead of your custom class is negligible. Unless you will be making millions of Quads, do not worry about memory. It will grow as needed.

Premature optimization is the root of all evil, however there is one performance consideration you can make. If you are going to create a lot of objects and immediately throw them away, you can use Object Pool Pattern to reuse these objects, especially if there is any CPU intesive initialization and clean up taking place. The performance is also affected later during garbage collection, which can create peaks in CPU usage. Using Object Pool prevents that, but one must be very careful to recycle the objects properly.

I'd recommend your option 1) and don't bother with the Object Pool unless you hit the CPU usage spikes. Also the modern Java Garbage Collector is very well optimized for short-lived small objects, make use of it.