Indépendance de résolution dans libGDX

22

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é.

cendres999
la source
Peut-être lié? gamedev.stackexchange.com/questions/34/…
thedaian
@thedaian pas tout à fait. C'est une question de résolution; Je suis plus préoccupé par l'interaction entre la densité et la résolution.
ashes999

Réponses:

12

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 );
Pascalius
la source
Ma discussion porte sur les images ainsi que sur les polices. +1 pour le rendu dynamique des polices (je le fais déjà).
ashes999
10

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); 
     } 
}
Rudy_TM
la source
Puis-je obtenir un exemple de code, s'il vous plaît?
ashes999
C'est le code, et vous créez une classe qui implémente l'interface Screen, dans le constructeur vous construisez votre scène, et dans la méthode de rendu, vous mettez stage.draw (). Si vous ne souhaitez pas utiliser Stages, vous pouvez déclarer une variable dans la classe de type Camera implémentée par écran, et faire la même chose que dans Stage, mais dans la méthode de rendu, vous appliquez une mise à jour à la caméra.
Rudy_TM
Cela fonctionne plutôt bien.
you786
4

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).

PT
la source
Même si je sélectionne parmi des collections d'images prédéfinies basées sur DPI, je ne vois pas comment je peux garantir que "ce sprite DOIT s'afficher en 64x64".
ashes999
1
Je supposais que vous régliez votre caméra OpenGL pour qu'elle corresponde à l'affichage physique, donc 1 pixel OpenGL correspond à 1 pixel d'affichage. À ce stade, une image 64x64 apparaîtra comme 64x64 sur l'écran. Comme le souligne Rudy_TM, vous pouvez jouer avec le mappage de la caméra pour obtenir une mise à l'échelle sur tout l'écran.
PT
D'accord, cela ressemble à la "sauce secrète" que je recherchais. Je vais vérifier et vous faire savoir, merci.
ashes999
0

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é.

dilom
la source