Eu implementei algumas telas usando libGDX que obviamente usariam oScreen classe fornecida pela estrutura libGDX. No entanto, a implementação dessas telas funciona apenas com tamanhos de tela predefinidos. Por exemplo, se o sprite foi criado para uma tela de tamanho 640 x 480 (proporção 4: 3), ele não funcionará conforme o esperado em outros tamanhos de tela, porque os sprites vão além dos limites da tela e não são redimensionados para o tamanho da tela em absoluto. Além disso, se a libGDX tivesse fornecido uma escala simples, o problema que eu estou enfrentando ainda estaria lá porque isso faria com que a proporção da tela do jogo mudass

Depois de pesquisar na internet, me deparei com um blog / fórum que discutiram o mesmo problema. Eu o implementei e até agora está funcionando bem. Mas quero confirmar se essa é a melhor opção para conseguir isso ou se existem alternativas melhores. Abaixo está o código para mostrar como estou lidando com esse problema legítim

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);
        }
    }
}

ATUALIZARecentemente, vim a saber que o libGDX possui algumas de suas próprias funcionalidades para manter as proporções que eu gostaria de discutir aqui. Ao pesquisar o problema de proporção na Internet, deparei-me com vários fóruns / desenvolvedores que tiveram o problema de "Como manter a proporção em diferentes tamanhos de tela?" Uma das soluções que realmente funcionou para mim foi postada acim

ais tarde, quando prossegui com a implementação dotouchDown() métodos para a tela, descobri que, devido ao redimensionamento no redimensionamento, as coordenadas nas quais eu havia implementadotouchDown() mudaria bastante. Depois de trabalhar com algum código para traduzir as coordenadas de acordo com o redimensionamento da tela, reduzi essa quantia em grande parte, mas não consegui mantê-las com precisão. Por exemplo, se eu tivesse implementadotouchDown() em uma textura, redimensionar a tela deslocaria o touchListener na região da textura alguns pixels para a direita ou esquerda, dependendo do redimensionamento e isso obviamente era indesejáve

ais tarde, vim a saber que a classe de palco tem sua própria funcionalidade nativa para manter a proporção boolean stretch = false). Agora que implementei minha tela usando a classe stage, a proporção é mantida bem por ela. No entanto, no redimensionamento ou em diferentes tamanhos de tela, a área preta gerada sempre aparece no lado direito da tela; ou seja, a tela não está centralizada, o que a torna bastante feia se a área preta for substancialmente grand

Algum membro da comunidade pode me ajudar a resolver esse problema?