Confused about using libGDX dispose()

Question

Can anyone please help me to understand the proper use of the dispose().
Does dispose() get called automatically or do I have to make a call to it?

In a game I'm writing, I use a texture atlas and an asset manager for all of the textures I use. I have an abstract class called Enemy and every type of enemy extends it. I have an arraylist that holds all of my enemies, and when an enemy is dead, I remove it from the arraylist. Do I need to make a call to the dispose() method in the individual enemy classes to remove the textures from memory before removing it from the arraylist or does it happen automatically or is that not how dispose() gets used period? (Each individual type of enemy class sets its own textures by using a TextureRegion)

Answer 1

Dispose() is not called automatically. You have to call it manually whenever you with to dispose a texture (or anything that implements disposable). The only dispose() that's called automatically is ApplicationListener.dispose() and Game.dispose(), since it implements ApplicationListener.

As for solving the memory leak I'd suggest only using AssetManager for ALL (textures, sound, atlases, skins etc.) of your assets. This way you only have to call AssetManager.dispose() on your AssetManager when you exit your program, and in turn this will dispose of all of your assets automatically.

I can also vouch for not removing objects once they die. Instead, re-use them if you need more enemies. Only remove them once you absolutely have to. Although this might be a bit overkill if your game is not very big, or you're not using a lot of enemies.

Hopefully this answered your question!

Answer 2

libGDX's Game.dispose() method gets called automatically when you quit the game. The Screen.dispose() method should be called manually when you want to exit a screen. When you want to dispose of your textures, you could call the dispose method in your Enemy class from the Screen or Game dispose methods. You should never explicitly call the Game dispose method yourself. However, if you meant the Texture.dispose() or TextureAtlas.dispose() methods then yes, you need to call these once for every texture or texture atlas, respectively, that you want to dispose of.

Answer 3

You don't need to to dispose those enemies,Instead use an zOrdering and hide the enemies from the screen and put a condition to prevent the enemies from rendering onto the screen ,If you want to reuse those dead enemies just set enemy.setZorder(1 or some greater value) :

ArrayList<Enemy>EnemyList;

EnemyList.add(enemy);

if(enemy.life<=0)
{
            enemy.setZorder(0);

}

• setZorder method should be custom written since libgdx does not support setZorder unlike most other engines
• setZorder method is also capable of preventing the enemy sprites in the array list to be rendered on the screen

If you need setZorder code sample I can post some sample codes here.

Answer 4

In Libgdx some objects need to be disposed, as they are not managed by the garbage collector. The dispose() methode is supposed to dispose all of this objects, to release their ressources. The objects, which need to be disposed are mentioned here.
The dispose-method of the Game/ApplicationListener is called by LibGDX automatically, while the Screens dispose() is not called automatically (This is mentioned in the Screen API).
The Screens should generally be disposed, when the user probably won't return to it for a longer time. This might be the case for a Splash-Screen which shows only when the game is started.
Also, every not disposed Screen should be disposed when the ApplicationListener/Game gets disposed.