Libgdx Reduzieren von Anrufen und optimieren das Spiel

Question

Ich versuche, die Anzahl der Anrufe zu reduzieren, jedes Mal, wenn ein Bildschirm an meinem Spiel aufgerufen wird, um mein Spiel schneller zu machen, und ich bemerkte, dass ich die gleiche Berechnung auf jedem Bildschirm..how kann ich das vermeiden?

Ich tue dies in praktisch jedem Bildschirm

public class ****Screen implements Screen { 
    @Override 
    public void show() { 

    float screenWidth = Gdx.graphics.getWidth(); 
    float screenHeight = Gdx.graphics.getHeight(); 
    float gameWidth = 360; 
    float gameHeight = screenHeight/(screenWidth/gameWidth); 
    midPointY = (int) (gameHeight/2); 
    cam = new OrthographicCamera(); 
    cam.setToOrtho(true, gameWidth, gameHeight); 
    viewport = new FitViewport(gameWidth, gameHeight, cam); 
    viewport.apply(); 
    stage = new Stage(viewport); 
    Gdx.input.setInputProcessor(stage); 

noch habe ich eine GameClass..How kann ich die oben in meinem gameclass implementieren (siehe unten) und nur nennen es einmal müssen? ...

public class Start extends Game { 
    @Override 
    public void create() { 
    float screenWidth = Gdx.graphics.getWidth(); 
    float screenHeight = Gdx.graphics.getHeight(); 
    float gameWidth = 360; 
    float gameHeight = screenHeight/(screenWidth/gameWidth); 

    assets = new AssetLoader(); 
    assetManager = new AssetManager(); 
    camera = new OrthographicCamera(); 
    camera.setToOrtho(true, gameWidth, gameHeight); 

    //initialize screens here 
    mainMenu = new MenuScreen(this); 
    loadingScreen = new LoadingScreen(this); 
    gameScreen = new GameScreen(this); 

    ....... 

    //call assets 
    AssetLoader.load(); 

    //start mainmenu... 
    this.setScreen(mainMenu); 
} 

Answer 1

Zuerst muss ich Ihnen sagen, dass dies Ihr Spiel nicht beschleunigen wird. Wenn Sie den Bildschirm alle 20 Sekunden wechseln, bedeutet das, dass das Spiel 1 Frame pro 1200 Frames berechnet. Aber ich bin wie du und suche wirklich nach den meisten Möglichkeiten, während des Spiels zu optimieren.

Ich habe eine Lösung für diesen Fall gefunden. Sie können Objekte, die Sie verwenden, auf allen Bildschirmen übergeben, von der Spielklasse zur Bildschirmklasse.

Screen-Klasse

public class MainMenuScreen implements Screen { 

    public MainMenuScreen(OrthographicCamera camera) { 
     this.camera=camera; 
    } 

//...Rest of class omitted for succinctness. 
} 

Spielklasse

public class Starts extends Game { 

OrthographicCamera camera; 
    public void create() { 
     camera=new OrthographicCamera(); 
     camera.setToOrtho(false, 800, 480); 
     this.setScreen(new MainMenuScreen(camera));// change screen and pass camera to new screen. 
    } 

} 

Oder Sie können auch das ganze Spiel Klasse wie folgt passieren.

public class MainMenuScreen implements Screen { 

final Starts game; 
public MainMenuScreen(final Starts game) { 
    this.game = game; 

} 

@Override 
public void render(float delta) { 
    Gdx.gl.glClearColor(0, 0, 0.2f, 1); 
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); 

    game.camera.update(); 
    game.batch.setProjectionMatrix(game.camera.combined); 

    game.batch.begin(); 
    game.font.draw(...); 
    game.font.draw(...); 
    game.batch.end(); 

    if (Gdx.input.isTouched()) { 
     game.setScreen(new AnotherScreen(game)); 
     dispose(); 
    } 
} 

} 

müssen nur so in der Spielklasse anrufen. So können Sie auf allen Bildschirmen Bühnenserien, Schriftarten usw. des Spiels verwenden.

this.setScreen(new MainMenuScreen(this)); 

Answer 2

Ich nehme an, Sie meinen Sie den kleinen Schluckauf verkürzen wollen Sie erhalten, wenn Bildschirme wechseln. (Die Bildrate Ihres Spiels ist davon nicht betroffen.)

Einfacher Weg: Verschieben Sie den Code von show in den Konstruktor jeder Bildschirmklasse.

Es ist jedoch verschwenderisch, eine neue Bühne für jeden Bildschirm zu erstellen, ohne ihm einen SpriteBatch zu übergeben, weil Sie im Wesentlichen drei separate SpriteBatches instanziieren, die schwere Objekte sind (sie haben ein großes Array für die Mesh-Daten, ein großes Mesh auf der GPU und muss einen Shader kompilieren).

Sie können gemeinsam genutzte Objekte in der Spielklasse instanziiert und sie in die Konstrukteure des Screens wie dies passieren:

public class Start extends Game { 
    SpriteBatch spriteBatch; 

    @Override 
    public void create() { 
     //... 

     //initialize screens here 

     spriteBatch = new SpriteBatch(); //must be disposed in dispose() 

     mainMenu = new MenuScreen(this, spriteBatch); 
     loadingScreen = new LoadingScreen(this, spriteBatch); 
     gameScreen = new GameScreen(this, spriteBatch); 

     //... 
    } 
} 

Aktualisieren Sie Ihre Screens Konstrukteurs entsprechend und die Sprite-Charge in der Bühnenbauer übergeben. Viewports und Kameras sind leichtgewichtig, daher würde ich es nicht für nötig halten, diese in die Game-Klasse zu verschieben, es sei denn, sie tragen dazu bei, dass der Code besser wartbar wird.

Übrigens missbrauchen Sie FitViewport irgendwie, indem Sie das Seitenverhältnis vorberechnen. Der Sinn von Viewports besteht darin, dass Sie beim Einrichten nichts berechnen müssen. Verwenden Sie new ExtendViewport(360, 1, cam), um das gleiche zu erhalten, was Sie ohne die Berechnungen tun. Und stellen Sie sicher, dass Sie es in resize() aktualisieren.