Ich habe einige Bildschirme mit libGDX implementiert, die offensichtlich die Screenvom libGDX-Framework bereitgestellte Klasse verwenden würden . Die Implementierung für diese Bildschirme funktioniert jedoch nur mit vordefinierten Bildschirmgrößen. Wenn das Sprite beispielsweise für einen Bildschirm mit einer Größe von 640 x 480 (Seitenverhältnis 4: 3) gedacht war, funktioniert es bei anderen Bildschirmgrößen nicht wie vorgesehen, da die Sprites entlang der Bildschirmgrenzen verlaufen und nicht auf die Bildschirmgröße skaliert sind überhaupt. Wenn die libGDX eine einfache Skalierung bereitgestellt hätte, wäre das Problem, mit dem ich konfrontiert bin, immer noch vorhanden, da sich dadurch das Seitenverhältnis des Spielbildschirms ändern würde.
Nachdem ich im Internet recherchiert hatte, stieß ich auf einen Blog / ein Forum , in dem das gleiche Thema diskutiert wurde. Ich habe es implementiert und bis jetzt funktioniert es gut. Ich möchte jedoch bestätigen, ob dies die beste Option ist, um dies zu erreichen, oder ob es bessere Alternativen gibt. Unten finden Sie den Code, der zeigt, wie ich mit diesem legitimen Problem umgehe.
FORUM-LINK: http://www.java-gaming.org/index.php?topic=25685.new
public class SplashScreen implements Screen {
// Aspect Ratio maintenance
private static final int VIRTUAL_WIDTH = 640;
private static final int VIRTUAL_HEIGHT = 480;
private static final float ASPECT_RATIO = (float) VIRTUAL_WIDTH / (float) VIRTUAL_HEIGHT;
private Camera camera;
private Rectangle viewport;
// ------end------
MainGame TempMainGame;
public Texture splashScreen;
public TextureRegion splashScreenRegion;
public SpriteBatch splashScreenSprite;
public SplashScreen(MainGame maingame) {
TempMainGame = maingame;
}
@Override
public void dispose() {
splashScreenSprite.dispose();
splashScreen.dispose();
}
@Override
public void render(float arg0) {
//----Aspect Ratio maintenance
// update camera
camera.update();
camera.apply(Gdx.gl10);
// set viewport
Gdx.gl.glViewport((int) viewport.x, (int) viewport.y,
(int) viewport.width, (int) viewport.height);
// clear previous frame
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
// DRAW EVERYTHING
//--maintenance end--
splashScreenSprite.begin();
splashScreenSprite.disableBlending();
splashScreenSprite.draw(splashScreenRegion, 0, 0);
splashScreenSprite.end();
}
@Override
public void resize(int width, int height) {
//--Aspect Ratio Maintenance--
// calculate new viewport
float aspectRatio = (float)width/(float)height;
float scale = 1f;
Vector2 crop = new Vector2(0f, 0f);
if(aspectRatio > ASPECT_RATIO) {
scale = (float) height / (float) VIRTUAL_HEIGHT;
crop.x = (width - VIRTUAL_WIDTH * scale) / 2f;
} else if(aspectRatio < ASPECT_RATIO) {
scale = (float) width / (float) VIRTUAL_WIDTH;
crop.y = (height - VIRTUAL_HEIGHT * scale) / 2f;
} else {
scale = (float) width / (float) VIRTUAL_WIDTH;
}
float w = (float) VIRTUAL_WIDTH * scale;
float h = (float) VIRTUAL_HEIGHT * scale;
viewport = new Rectangle(crop.x, crop.y, w, h);
//Maintenance ends here--
}
@Override
public void show() {
camera = new OrthographicCamera(VIRTUAL_WIDTH, VIRTUAL_HEIGHT); //Aspect Ratio Maintenance
splashScreen = new Texture(Gdx.files.internal("images/splashScreen.png"));
splashScreenRegion = new TextureRegion(splashScreen, 0, 0, 640, 480);
splashScreenSprite = new SpriteBatch();
if(Assets.load()) {
this.dispose();
TempMainGame.setScreen(TempMainGame.mainmenu);
}
}
}
UPDATE: Ich habe kürzlich erfahren, dass libGDX einige seiner eigenen Funktionen zur Aufrechterhaltung von Seitenverhältnissen hat, die ich hier diskutieren möchte. Bei der Suche nach dem Problem mit dem Seitenverhältnis im Internet bin ich auf mehrere Foren / Entwickler gestoßen, bei denen das Problem aufgetreten ist: "Wie kann das Seitenverhältnis auf verschiedenen Bildschirmgrößen beibehalten werden?" Eine der Lösungen, die wirklich für mich funktioniert haben, wurde oben veröffentlicht.
Als ich später mit der Implementierung der touchDown()Methoden für den Bildschirm fortfuhr , stellte ich fest, dass sich die von mir implementierten Koordinaten aufgrund der Skalierung beim Ändern der Größe erheblich ändern touchDown()würden. Nachdem ich mit einem Code gearbeitet hatte, um die Koordinaten gemäß der Bildschirmgröße zu übersetzen, reduzierte ich diesen Betrag erheblich, aber es gelang mir nicht, sie punktgenau zu pflegen. Wenn ich beispielsweise touchDown()eine Textur implementiert hätte, würde eine Größenänderung des Bildschirms den touchListener im Texturbereich je nach Größenänderung um einige Pixel nach rechts oder links verschieben, was offensichtlich unerwünscht war.
Später erfuhr ich, dass die Stage-Klasse über eine eigene native Funktionalität verfügt, um das Seitenverhältnis beizubehalten ( boolean stretch = false). Nachdem ich meinen Bildschirm mithilfe der Stage-Klasse implementiert habe, wird das Seitenverhältnis dadurch gut beibehalten. Bei Größenänderung oder unterschiedlichen Bildschirmgrößen wird der erzeugte schwarze Bereich jedoch immer auf der rechten Seite des Bildschirms angezeigt. Das heißt, der Bildschirm ist nicht zentriert, was es ziemlich hässlich macht, wenn der schwarze Bereich wesentlich groß ist.
Kann mir ein Community-Mitglied helfen, dieses Problem zu lösen?