Discussion :

[ZouBi]

Bonjour,
j'aimerai savoir, suivant la taille de notre programme, si on le passe en fullscreen, soit un bout est coupé, soit une bande noir, enfin voilà...
donc j'aimerai savoir comment trouver une bonne resolution pour notre programme qui fonctionne parfaitement en fullscreen?

[D-Ray]

Salut!

Personnellement je ne l'ai jamais utilisé mais je crois que tu pourrais t'en sortir avec SDL_ListModes(). Tu envoies en paramêtre le nombre de bpp que tu veux utiliser (ou NULL pour que SDL choisisse automatiquement le meilleur nombre de bpp supporté par l'ordinateur), ainsi que les flags que tu voudrais utiliser (pour toi ça serait SDL_HWSURFACE, SDL_FULLSCREEN et SDL_DOUBLEBUF éventuellement) et ç te retourne un pointeur de tableau de SDL_Rect. L'élément à l'indice 0 est la plus grande résolution possible et ça va dans des résolutions de plus en plus basses. C'est ce que tu cherches, non?

[fearyourself]

Personnellement je ne l'ai jamais utilisé mais je crois que tu pourrais t'en sortir avec SDL_ListModes(). Tu envoies en paramêtre le nombre de bbp que tu veux utiliser (ou NULL pour que SDL choisisse automatiquement le meilleur nombre de bbp supporté par l'ordinateur), ainsi que les flags que tu voudrais utiliser (pour toi ça serait SDL_HWSURFACE, SDL_FULLSCREEN et SDL_DOUBLEBUF éventuellement) et ç te retourne un pointeur de tableau de SDL_Rect. L'élément à l'indice 0 est la plus grande résolution possible et ça va dans des résolutions de plus en plus basses. C'est ce que tu cherches, non?

En effet, voici un programme exemple, il faut faire attention de bien tester le retour de cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <SDL.h>
#include <stdio.h>
 
int main(int argc, char **argv)
{
 
    SDL_Rect **modes;
    int i;
 
    //Initialisation de SDL
    if(SDL_Init(SDL_INIT_VIDEO)!=0) {
        printf("Problème pour initialiser SDL : %s\n", SDL_GetError());
        return 1;
    }
 
    /* On recupere ce qui possible en fullscreen et en hardware */
    modes=SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_HWSURFACE);
 
    /* On verifie si un mode est possible */
    if(modes == (SDL_Rect **)0){
        printf("Aucun mode n'est possible!\n");
        exit(-1);
    }
 
    /* On verifie si toutes les resolutions sont possibles */
    if(modes == (SDL_Rect **)-1){
        printf("Toutes les resolutions sont possibles.\n");
    }
    else{
        /* Print valid modes */
        printf("Modes possibles :\n");
        for(i=0;modes[i];++i)
            printf("  %d x %d\n", modes[i]->w, modes[i]->h);
    }
 
    SDL_Quit();
    return EXIT_SUCCESS;
}

Et voici ce que ca donne sur mon ordi :

Modes possibles :
3360 x 1050
1680 x 1050
1280 x 1024
1280 x 720
1152 x 864
1024 x 768
1024 x 480
960 x 720
864 x 648
856 x 480
848 x 480
800 x 600
720 x 576
720 x 480
704 x 480
640 x 480
640 x 432
640 x 400
512 x 384
400 x 300
320 x 240
320 x 200

Jc

PS : Attention il ne faut désallouer ce tableau.

[D-Ray]

Il est désalloué lors de l'appel à SDL_Quit() ?

[ZouBi]

Un projet SDL doit donc pouvoir gerer toutes les solutions?
comment ça se passe?

[fearyourself]

Il est désalloué lors de l'appel à SDL_Quit() ?

Sûrement oui. C'est ce qui me semble le plus logique. Il va désallouer ce tableau lorsqu'il détruit la surface écran.

Un projet SDL doit donc pouvoir gerer toutes les solutions?
comment ça se passe?

C'est trop vague comme question, que veux-tu dire ?

Jc

[D-Ray]

C'est trop vague comme question, que veux-tu dire ?

A mon avis, il voulait savoir si un programme SDL devait savoir s'adapter à toutes les résolutions.

Pour moi, je pense que commencer avec une résolution choisie arbitrairement peut être plus pratique, puis faire en sorte que l'affichage s'adapte vient après. Mais c'est pas forcément pratique, surtout si on ne prépare pas le terrain dès le début.

Je n'ai jamais fait de programme SDL qui s'adapte à toutes les résolution, alors ce que je viens de dire est peut-être complètement à côté de la plaque.

[fearyourself]

A mon avis, il voulait savoir si un programme SDL devait savoir s'adapter à toutes les résolutions.

Pour moi, je pense que commencer avec une résolution choisie arbitrairement peut être plus pratique, puis faire en sorte que l'affichage s'adapte vient après. Mais c'est pas forcément pratique, surtout si on ne prépare pas le terrain dès le début.

Je n'ai jamais fait de programme SDL qui s'adapte à toutes les résolution, alors ce que je viens de dire est peut-être complètement à côté de la plaque.

Tout à fait. Déjà arriver à faire fonctionner un programme sur une résolution est déjà problématique alors avoir la gestion de multiples résolutions...

Commence par une résolution et ensuite teste les autres plus tard.
Jc

[ZouBi]

ok merci, c'est bien ca que je voulais savoir.

[Mat.M]

Un projet SDL doit donc pouvoir gerer toutes les solutions?
comment ça se passe?

C'est à toi de gérer cela ; par exemple il faut prévoir des bitmaps pour différentes résolutions si nécessaire sinon faire fonctionner le jeu à une résolution fixe.
Mais dans ce cas-là, attention du 800*600 peut paraitre gros sur un 19' et au delà.
A l'inverse si tu veux afficher une 1280*960 sur un petit moniteur cela paraitra riquiqui
Tu peux éventuellement proposer un système de zoom...
J'avais posé cette question jadis à savoir quelle résolution les gens utilisaient le plus dans le forum hardware

[Mat.M]

Tout à fait. Déjà arriver à faire fonctionner un programme sur une résolution est déjà problématique alors avoir la gestion de multiples résolutions...

C'est vrai que c'est un véritable casse-tête sans compter que maintenant il ya des écrans "wide-screen" ou écrans larges..

[TruthlessLife]

Mais dans ce cas-là, attention du 800*600 peut paraitre gros sur un 19' et au delà.
A l'inverse si tu veux afficher une 1280*960 sur un petit moniteur cela paraitra riquiqui

Je pense que c'est une erreur de voir les choses comme ça.
Pour s'adapter a toutes les résolutions il faut d'abord choisir une résolution "native" pour laquelle les graphismes vont être dessinés.
Puis, au moment de charger les images, au démarrage du jeu, il faut redimensionner celles-ci (seule contrainte => sans anti-aliasing pour par tuer les zones de transparence des sprites ) proportionnellement à la résolution que l'utilisateur a choisi.

Exemple :

Un jeu est prévu pour tourner en 640x480.

Dans cette résolution le héro est un gentil sprite qui mesure : 150x50 pixels.

L'utilisateur possède un superbe écran 19" et veut faire tourner le jeu dans la résolution native de son moniteur (ce qui est plus ou moins légitme il faut le reconnaitre) soit 1280x1024.

Pas de problème : on calcul les coeffs en hauteur et largeur.

coeff_x = 1280/640 ( = 2 )
coeff_y = 1024/480 ( = 2,1333 )

Donc au moment de charger notre sprite on multipliera sa largeur par 2 et sa hauteur par 2,13 soit 300x100 pixels.


<!> Ce qui revient à dire que la définition de l'image ne change pas. Mais le jeu peu s'afficher sur tous les moniteurs. En plus sur un écran plat l'image sera plus propre et nette avec ce système qu'en forçant la résolution en 640x480 (par exemple)...