Problème avec SDL_BlitSurface [Résolu]

[edgarjacobs]

Bonjour,

J'ai créé une surface de la manière suivante:

Code :

1
2
3
4
5
6
 
int textHeight=19;
int nlines=2368;
SDL_Surface *osd;
 
osd=SDL_CreateRGbSurface(SDL_HWSURFACE,10,nlines*textHeight,32,0,0,0,0);

Le problème n'est pas la surface, le problème est d'y blitter quelque choe (à partir d'un certain point):

Code :

1
2
3
4
5
6
7
8
 
SDL_Rect coo;
SDL_Surface *toBlit=.......
int numline=2200;
 
coo.x=0;
coo.y=textHeight*numline;
SDL_BlitSurface(toBlit,NULL,osd,&coo);

Pourquoi? Car la déclaration de SDL_Rect est la suivante:

Code :

1
2
3
4
typedef struct SDL_Rect {
	Sint16 x, y;
	Uint16 w, h;
} SDL_Rect;

Et 2200*19 est largement supérieur à 32767....

Si quelqu'un avait une idée (à part recompiler la sdl en modifiant les sources ) pour contourner ce problème....

Merci d'avance,

Edgar.

[Anything]

Je dirais que si tu veux créer une surface de 10*44000 c'est qu'il y a un problème dans la facon d'aborder le problème.

Tu veux faire quoi avec cette surface?
Tu peux toujours segmenter la surface ou mettre plusieurs colonnes plutot qu'une seule de 10 pixel. Mais sans le but final de la manoeuvre c'est un peu dur de te guider.

[edgarjacobs]

Merci Anything,

Ben non, il n'y a pas de doute (dans mon esprit en tout cas) quant à la disposition de l'écran. J'ai un (fameux) paquet de mots (>300000) sur lesquels je fais 5 types de recherches différentes, et tous les résultats doivent pouvoir être visibles en même temps... je ne vois pas d'autre solution que 5 colonnes.

Mais je pense avoir trouvé la solution: diminuer la taille de la font en fonction du nombre de mots à afficher, tant qu'elle reste lisible (disons, >=8, 7 étant vraiment la limite inférieure). Et sinon, proposer une sortie dans un fichier.

Si quelqu'un a une autre idée... c'est avec plaisir.

Edgar.

[Anything]

Euh j'ai toujours l'impression que tu nous donne trop partiellement les détails pour vraiment t'aider.

Ta limite de 2368 lignes, doit on comprendre que c'est ton nombre max de résultats? Tu dois forcément les afficher tout sur le même écran ou tu as droit de faire des scrollings?
Pourquoi créer une surface intermédiaire de x * 44000 alors que ton écran est d'une résolution bien inférieur(enfin sauf si tu es dans un cas spécifique: mosaique d'écran, etc...)?

[LittleWhite]

Bonjour,

Pour afficher des mots, j'ai l'impression que le choix de la bibliothèque est erroné (je pense à Qt et son QGraphicsScene, qui me semble déjà plus approprié).
Et même si vous devez afficher X mots, cela ne vous oblige pas à les afficher sur une seule surface. En fait, la taille de la surface pourra être qu'un peu plus grande que la taille de l'écran. Dans le sens que si la surface est plus grande ou pas que l'écran, cela ne se verra pas pour l'utilisateur. Bien sur, dans ce cas, il faudra utiliser un système de camera (dessiner et afficher uniquement ce qui est visible).

[edgarjacobs]

Bien, j'explique plus longuement. J'ai un fichier de + de 300 000 mots. Le résultat d'une recherche me fournit (par exemple) 6412 mots, qui ne sont pas consécutifs dans le fichier.

La font ouverte (TTF_Font) a un hauteur de 11 pixels. J'ai donc besoin de 11*6142 pixels pour tout afficher, soit

Code :

srfc=SDL_Surface(...,width,11*6412,...);

soit 70532 pixels verticalement).

Imaginons que les mots soient stockés en mémoire dans un buffer quelconque (ce n'est pas ça qui a de l'importance).

Pour remplir ma surface, je fais:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
SDL_Rect coo;
int fontHeight=TTF_FontHeight(font);
char *mot;
 
coo.x=coo.y=0;
mot=1er mot
while(compteur<nombre_de_mot) {
    text=TTF_Render...(mot);
    SDL_BlitSurface(mot,NULL,srfc,&coo);
    coo.y+=fontHeight;
    mot=mot_suivant;
    compteur++;
   }

Pour les afficher à l'écran, je fais comme l'a suggéré LittleWhite: j'emploie un SDL_Rect que je déplace sur srfc:

Code :

1
2
3
4
5
6
SDL_Rect view_part;
 
view_part.x=view_part.y=0;
view_part.w=peu importe;
view_part.h=550; // En imaginant que la fenêtre d'affichage ne peut afficher plus de 550 pixels
SDL_BlitSurface(srfc,&view_part,fenêtre,NULL);

Pour 'descendre' l'affichage aux mots suivants: view_part.y+=550;
Pour 'remonter' l'affichage aux mots précédents: view_part.y-=550;

Tout cela fonctionne parfaitement bien, testé, éprouvé et approuvé. Comme le dit LittleWhite, je ne suis pas le premier à faire ça.

Mais comme je le disais, le bât blesse ici:

Code :

coo.y+=fontHeight;

puisque coo.y est Sint16 (signed int sur 16 bits) soit une valeur max de 32765. Avec 6412 mots trouvés, on pulvérise joyeusement cette valeur.

Reste éventuellement à bypasser (en partie) SDL, et à jouer directement avec surface->pixels... (mais je n'ai pas encore examiné cette éventualité).

@LittleWhite:

(je pense à Qt et son QGraphicsScene, qui me semble déjà plus approprié)

Je ne connais pas encore Qt, j'avais prévu de commencer cet été, mais je crois que je vais devoir encore reporter. Mais d'après ce que j'ai vu à gauche et à droite, il semblerait que Qt facilite énormement la création de gui... j'aurais dû commencer l'été passé !

[Anything]

Envoyé par edgarjacobs

Tout cela fonctionne parfaitement bien, testé, éprouvé et approuvé. Comme le dit LittleWhite, je ne suis pas le premier à faire ça.

Effectivement tu n'es pas le premier à faire un simili scrolling. Mais il y a aucune de vieille console/PC qui aurait pu faire fonctionner des jeux à scrolling avec cette façon de l'implémenter

En gros se qu'explique Littlewhite c'est que tu va te balader dans une surface "virtuelle".
Plutot que de blit un bout de ta bien trop grande surface, tu va déterminer quel sont les strings à afficher. Et les placer en conséquence sur ton écran.

Prennons un exemple tu as 5000 mots en retour. Chaque mot prends 10 pixels de hauteur. Donc la hauteur de ta surface virtuelle sera de 50000 pixels. Et ton offset de déplacement dans cette surface sera comprise entre 0 et 50000-hauteur de l'écran.
Si l'utilisateur s'arrête à l'offset 15200, tu sais que le le premier mot que tu affichera sera la 1519e de ton tableau et le dernier 1519e+nombre de ligne affichable sur l'écran. Je me suis un peu simplifier la vie à prendre des comptes ronds mais c'est pas tellement plus dur de faire un scrolling qui avance par pixel.

[edgarjacobs]

Envoyé par Anything
Chaque mot prends 10 pixels de hauteur. Donc la hauteur de ta surface virtuelle sera de 50000 pixels. Et ton offset de déplacement dans cette surface sera comprise entre 0 et 50000

Je suis parfaitement d'accord avec tout ce que tu dis, la seule chose que je dis (et que je souhaite contourner) c'est qu'il est impossible avec SDL_BlitSurface de remplir une surface dont le positionnement y est > 32765. Or, pour remplir la surface virtuelle dont tu parles (avant d'y faire un simili-scrolling) il faut faire des blit avec un offset y > 32765.

[LittleWhite]

Si je compte bien, si vous avez besoin de faire un blit positionné avec des valeurs > 32k, cela veut dire que soit :
- vous avez un écran plus grand que 32k de résolution
- vous avez une surface de plus de 32k

J'imagine que d'une part, seule la seconde affirmation est possible et d'une autre part, que cela est complètement contournable, car votre écran ne faisant qu'une résolution, disons 800x600, alors vous pouvez faire en sorte que si une surface est positionnée en dehors de -800 / 1600 en X et -600 / 1200 en Y qu'elle soit totalement oubliée et donc, qu'aucun blit ne soit nécessaire.

[Anything]

Quand je parle de surface "virtuelle" (fantôme? imaginaire?), il faut comprendre qu'elle n'existe pas réellement en mémoire, enfin pas en tant SDL_Surface. C'est juste une image pour essayer de te faire comprendre comment ça peut marcher.
C'est toi qui va gérer l'offset en int 32 bits ou 64bits ce n'est pas le problème.

Tu ne va pas blit un bout d'une surface précalulée sur l'écran, mais tu va blit directement tout les textes(dont tu peux connaitre les index des mots à afficher via une bête rêgle de trois) sur l'écran.

[edgarjacobs]

Je vous remercie tous les deux. J'ai fini par adopter la solution suivante: je retiens l'offset des mots en mémoire, ce qui me premet de n'avoi qu'une petite surface 'réelle' à retenir pour l'affichage.

Merci d'avoir pris de votre temps,

Edgar.

[Mat.M]

Envoyé par edgarjacobs

Bonjour,

Et 2200*19 est largement supérieur à 32767....

Si quelqu'un avait une idée (à part recompiler la sdl en modifiant les sources ) pour contourner ce problème....

Merci d'avance,

Edgar.

ce que tu veux faire ça ne fonctionnera pas et c'est une très mauvaise méthode..
une SDL_Surface ça représente une sorte de "tampon mémoire" de l'écran..
si l'écran est de 1024*768 alors il faut allouer une SDL_Surface de ces dimensions..
parce que une SDL_Surface sous Windows ( si tu est sous Windows) c'est un reliquat d'une DirectDrawSurface qui permet d'accèder directement à la mémoire vidéo comme on faisait du temps des jeux sous Ms-Dos...

pour le jeu que tu veux faire il faut créer des zones de "clipping"

[Mat.M]

Envoyé par LittleWhite

Dans le sens que si la surface est plus grande ou pas que l'écran, cela ne se verra pas pour l'utilisateur. Bien sur, dans ce cas, il faudra utiliser un système de camera (dessiner et afficher uniquement ce qui est visible).

c'est exact mais plutôt que de parler de caméra qui s'applique à la 3d là on devrait parler plutôt de fenêtre écran ou zone visible pour la 2d
Par contre je ne vois pas l'intérêt d'utiliser Qt ça peut très bien fonctionner avec SDL...

[LittleWhite]

Envoyé par Mat.M

c'est exact mais plutôt que de parler de caméra qui s'applique à la 3d là on devrait parler plutôt de fenêtre écran ou zone visible pour la 2d
Par contre je ne vois pas l'intérêt d'utiliser Qt ça peut très bien fonctionner avec SDL...

Je pensais à Qt, notamment si on voulait naviguer dans les éléments, ou encore les déplacer à la volée. Mais, je n'ai jamais dit que cela n'était pas possible avec la SDL. Je pense juste que cela est plus facile avec Qt (et possède plus de liberté pour le rendu, mais une fois encore si on en a pas besoin, alors Qt n'est pas utile ). Je pense beaucoup à cet exemple : http://qt.developpez.com/doc/4.7/demos-chip/