Pfthb

I have two identical classes: Screen1 and Screen2. The problem is that when I open Screen2 from Screen1 the animated sprite of Screen1 continues to render. I see it in the log. And after a while memory overflow occurs. How to stop rendering a closed screen?

public class Screen1 extends Game implements Screen, InputProcessor 

 private SpriteBatch batch;
 private TextureAtlas atlasBarrelBlue;
 private Sprite sprite1;
 private float sprite1positionX;
 private float sprite1positionY;
 private float spriteBarrelWidth;
 private float spriteBarrelHeight;
 private Texture backgroundTexture;
 private Animation<TextureAtlas.AtlasRegion> animationBarrelBlue;
 private float dTime = 0;
 private Vector2 vector2;

 @Override
 public void show() 

 batch = new SpriteBatch();
 vector2 = new Vector2();
 atlasBarrelBlue = new TextureAtlas(Gdx.files.internal("data/barrels/barr4"));
 animationBarrelBlue = new Animation<TextureAtlas.AtlasRegion>(1 / 24f, atlasBarrelBlue.getRegions(), Animation.PlayMode.LOOP);

 spriteBarrelWidth = Gdx.graphics.getWidth() / 50 * 4;
 spriteBarrelHeight = Gdx.graphics.getHeight() / 50 * 11;
 backgroundTexture = new Texture("data/fones/fone1.png");

 sprite1positionX = Gdx.graphics.getWidth() / 50 * 7;
 sprite1positionY = Gdx.graphics.getHeight() / 50 * 32;

 Gdx.input.setInputProcessor(this);

 

 @Override
 public void render(float delta) 

 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

 dTime += Gdx.graphics.getDeltaTime();

 sprite1 = new Sprite(animationBarrelBlue.getKeyFrame(dTime, true));
 Gdx.app.log("111", "111");
 sprite1.setPosition(sprite1positionX, sprite1positionY);
 sprite1.setSize(spriteBarrelWidth, spriteBarrelHeight);

 batch.begin();
 batch.draw(backgroundTexture, 0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
 sprite1.draw(batch);
 batch.end();

 super.render();
 

 @Override
 public void dispose() 
 batch.dispose();
 atlasBarrelBlue.dispose();
 backgroundTexture.dispose();
 

 @Override
 public boolean touchDown(int screenX, int screenY, int pointer, int button) 

 vector2.set(screenX, Gdx.graphics.getHeight() - screenY);
 if (sprite1.getBoundingRectangle().contains(vector2))
 setScreen(new Screen2());
 

 return false;
 

Dyspose() and hide() methods do not help. When i go from Screen2 to Screen1 the same thing happens.

Your problem is that you extend Game, implements Screen and call super.update().

libgdx will call the render method of the Game class.

While the Game class holds a screen and call the render method of the current screen you set with setScreen().

When we look at the render method of the Game class:

@Override
public void render () 
 if (screen != null) screen.render(Gdx.graphics.getDeltaTime());

screen is the screen you have set with setScreen()

So Libgdx call => Game.render() and Game.render() call => Screen.render(float delta)

Now when we look on your code. You override the method: render(float delta) which is the render method of the Screen. (The render method of the Game has no parameter).

So first libgdx call Game.render(); this calls the render method of Screen1 and at the end of your overridden Screen1.render(float delta); method, you call again the Game.render() function with super.render();.

So you recursively call the Screen1.render(float delta); method. This is the reason why you become a memory overflow.

I will recommend you to not extend Game and implement Screen in the same class
The class which will be created in the DesktopLauncher should extend Game.

In my case TextAdventure:

public class TextAdventure extends Game 

 @Override
 public void create () 
 setScreen(new Screen1(this));
 

 @Override
 public void render() 
 Gdx.gl.glClearColor(1, 1, 1, 1);
 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

 super.render();
 

And in the Screen1 class only implements Screen and don't call super.render()!:

public class Screen1 implements Screen 

 Game myGame;

 public Screen1(Game myGame) 
 this.myGame = myGame;
 

 public void changeToScreen2()
 myGame.setScreen(new Screen2(myGame));
 

 ...

To change the Screen in Screen1 pass the Game class in the Constructor.