Indépendance de résolution dans libGDX

Comment rendre la résolution / densité de mon jeu libGDX indépendante? Existe-t-il un moyen de spécifier des tailles d'image comme "absolues" quelle que soit la densité sous-jacente?

Je fais un jeu pour enfants très simple; juste un tas de sprites affichés à l'écran, et du texte pour les menus (menu d'options principalement). Ce que je veux savoir, c'est: comment rendre indépendante la résolution de mes sprites / polices? (Je les ai emballés dans mes propres cours pour faciliter les choses.)

Comme il s'agit d'un simple jeu pour enfants, je n'ai pas à me soucier de la "zone jouable" du jeu; Je souhaite utiliser autant d'espace d'écran que possible.

Ce que je fais en ce moment, ce qui semble super incorrect, est de simplement créer des images adaptées à de grandes résolutions, puis de réduire (ou rarement, d'augmenter) pour s'adapter à la taille de l'écran. Cela semble fonctionner correctement (dans la version de bureau), même avec une cartographie linéaire sur mes textures, mais les petites résolutions semblent laides.

En outre, cela semble aller à l'encontre des «pixels indépendants de l'appareil» (DP) d'Android. Ou peut-être qu'il me manque quelque chose et que libGDX s'en occupe déjà d'une manière ou d'une autre?

Quelle est la meilleure façon de résoudre ce problème? J'ai trouvé ce lien; Est-ce un bon moyen de résoudre le problème?: http://www.dandeliongamestudio.com/2011/09/12/android-fragmentation-density-independent-pixel-dip/

Il mentionne comment contrôler les images, mais il ne mentionne pas comment spécifier les tailles de police / image indépendamment de la densité.

Puisque vous pouvez lire la densité du périphérique et rendre les polices pendant l'exécution dans libgdx, j'utilise cette solution pour obtenir une taille de police indépendante de la densité:

float densityIndependentSize = origFontSize * Gdx.graphics.getDensity();
int fontSize = Math.round(densityIndependentSize );
BitmapFont font = generator.generateFont(fontSize );

Pour y parvenir dans libgdx, vous pouvez utiliser la "caméra orthographique" où vous affectez la taille que vous souhaitez utiliser, et dans chaque résolution, vous pouvez voir toutes vos images mises à l'échelle à cette taille (j'utilise le 800X480 car c'est le plus grand écran d'Android ) et ça marche bien :)

public class GameStage extends Stage 
{ 
     public GameStage(float width, float height, boolean stretch) 
     { 
          this.camera = new OrthographicCamera(800, 480);
          this.camera.position.set(800/2, 480/2, 0f); 
     } 
}

Je pense que les «pixels indépendants de l'appareil» d'Android ne sont qu'un outil de mesure pour classer les appareils et ne sont pas réellement disponibles en tant que pixels pouvant être rendus. Vous ne manquez donc aucune infrastructure magique de résolution DPI. Autant que je sache l'état de l'art ici, vous avez découvert toutes les options. Il existe deux approches de base pour gérer différents appareils:

1. Mettez à l'échelle les images préexistantes pour qu'elles correspondent au DPI réel de l'appareil.
2. Choisissez parmi une variété d'images pré-mises à l'échelle au moment de l'exécution en fonction du DPI.

Bien sûr, vous pouvez faire un mélange des deux (choisir une image à peu près précise, puis la mettre à l'échelle), ou utiliser différentes approches pour différents éléments de votre interface utilisateur (par exemple, des images préexistantes pour les polices / texte et une mise à l'échelle dynamique pour le gameplay). sprites).

Ce que votre jeu spécifique essaie de faire peut vraiment faire une différence dans l'approche qui a le plus de sens. Par exemple, si vous avez un menu à l'écran, vous voudrez vous assurer que les boutons sont un multiple raisonnable de la taille du bout du doigt (donc le bouton est toujours facile à frapper, mais n'est pas plus grand que nécessaire sur gros appareils comme les tablettes). Alternativement, si vous essayez de construire un jeu de puzzle où vous voulez vous assurer que le puzzle entier est visible à la fois, vous devrez mettre à l'échelle les éléments pour les adapter à l'écran (par exemple, avec un tic-tac-toe jeu, vous aimeriez peut-être que chaque élément utilise environ 1/3 de l'écran).

Je pense que pour des choses comme les polices qui ont beaucoup de détails fins, vous voudrez avoir une variété d'images pré-rendues avec du texte, puis choisir la meilleure correspondance. Les boutons peuvent donc changer leur forme / taille relative d'un appareil à un autre, mais ils seront généralement toujours beaux.

Consultez les premiers jeux Android de Mario Zerchner pour une discussion des problèmes et des solutions. Notez que Mario est l'auteur de libGDX, donc l'approche du livre reflète celle de libGDX (notez qu'ils ne sont pas un à un, le livre couvre l'écriture d'une bibliothèque similaire à libGDX, mais pas libGDX lui-même).

Une façon de le faire est de définir un rapport d'aspect minimum et un rapport d'aspect maximum pour votre jeu. Ce seront les ratios que vous souhaitez prendre en charge. Ensuite, vous devez utiliser une fenêtre qui est maintenant fournie dans libGdx. La fenêtre fera évoluer votre monde en fonction des paramètres que vous fournissez.

Il existe plusieurs types de fenêtres et vous devez sélectionner celle qui convient le mieux à votre jeu.

Vous pouvez utiliser ExtendViewport par exemple et fixer votre hauteur ou votre largeur et calculer l'autre. Ensuite, vous devez vous assurer que tous les graphiques peuvent être vus dans votre rapport d'aspect minimum. La fenêtre étendue étendra vos graphiques au rapport d'aspect correct sans déformer les graphiques. Cependant, l'ExtendViewport fonctionne en ajoutant de l'espace supplémentaire à votre monde, vous devez donc également fournir des graphiques pour les arrière-plans, par exemple, qui couvrent toute votre étendue des rapports d'aspect couverts, lorsque le monde est plus petit que votre rapport d'aspect maximal, la partie supplémentaire des graphiques ne sera pas être montré.