La façon de traiter avec différents rapports d'aspect dans libGDX?

J'ai mis en place quelques écrans à l'aide de libGDX qui serait évidemment utiliser les Screen classe fournie par le libGDX cadre. Cependant, la mise en œuvre de ces écrans ne fonctionne qu'avec les pré-défini les tailles d'écran. Par exemple, si le sprite qui a été conçu pour une résolution de 640 x 480 taille de l'écran (4:3 rapport d'Aspect), il ne fonctionnera pas comme prévu sur d'autres tailles d'écran, car les sprites passer par l'écran de limites et ne sont pas redimensionnées à la taille de l'écran à tous. En outre, si une simple mise à l'échelle qui aurait été fourni par le libGDX, la question, je suis confronté aurait toujours été là parce que ce serait provoquer le ratio d'aspect de l'écran de jeu pour changer.

Après des recherches sur internet, je suis tombé sur un blog/forum qui avait débattu de cette question. J'ai mis en œuvre et jusqu'à présent, il fonctionne très bien. Mais je tiens à confirmer si c'est la meilleure option pour atteindre ce ou s'il existe de meilleures alternatives. Ci-dessous est le code pour montrer comment je fais affaire avec ce problème légitime.

LIEN DU FORUM: 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);
}
}
}

Mise à JOUR: récemment, je suis venu pour savoir que libGDX a certains de ses propres fonctionnalités de maintenir les ratios d'aspect que je voudrais discuter ici. Lors de la recherche de l'aspect ratio de la question à travers l'internet, je suis tombé sur plusieurs forums/développeurs qui ont eu ce problème de "Comment maintenir le ratio d'aspect sur différentes tailles d'écran?" L'une des solutions qui a vraiment fonctionné pour moi a été posté ci-dessus.

Plus tard, lorsque je me rendis à la mise en œuvre de la touchDown() méthodes pour l'écran, j'ai trouvé que, en raison de mise à l'échelle sur les redimensionner, les coordonnées sur lequel j'avais mis en œuvre touchDown() allait changer par une grande quantité. Après avoir travaillé avec un peu de code pour traduire les coordonnées en conformité avec le redimensionnement de l'écran, j'ai réduit ce montant à une grande mesure, mais je n'ai pas réussi à les entretenir avec la broche point de précision. Par exemple, si je venais de réaliser touchDown() sur une texture, le redimensionnement de l'écran changement de la touchListener sur la texture de la région de quelques pixels vers la droite ou la gauche, selon la redimensionner et ce n'était évidemment pas souhaitable.

Plus tard, je suis venu pour savoir que la scène de classe a sa propre fonctionnalité native de maintenir le ratio d'aspect (boolean stretch = false). Maintenant que j'ai mis en œuvre mon écran à l'aide de la classe stage, le rapport d'aspect est bien entretenu par elle. Cependant sur les redimensionner ou les différentes tailles d'écran, la zone noire qui est généré apparaît toujours sur le côté droit de l'écran; c'est l'écran n'est pas centrée sur ce qui le rend assez moche si la zone noire est substantiel.

Peut tout membre de la communauté m'aider à résoudre ce problème?