version 1.4b
Table des matières:
Pourquoi Drawlib
Nouveautés par rapport à la version 1.4
Utilisation
Commentaires
Le fait d'afficher des sprites est devenu quelque chose d'extrêmement courant dans les programmes que l'on écrit actuellement pour notre petite caltoche, qu'il s'agisse de jeux ou d'autre chose. Tout le monde souhaite pouvoir les utiliser le plus rapidement possible, alors qu'en fait l'affichage d'une image à l'écran n'a rien d'une opération facile! Si on travaille en gris, il faut gérer les 3 couleurs, la transparence, le clipping, tout ca sur un écran dont la configuration n'est pas des plus simples. En plus, puisqu'un pixel est représenté par un (ou 2) bit en mémoire et qu'on manipule toujours des octets et des mots (c'est-à-dire des groupes de 8 ou 16 bits), on doit toujours essayer de travailler avec des sprites de 8 ou 16 pixels de large parce que c'est plus simple à manipuler etc...
L'idée ici est de fournir (non plus une seule mais) plusieurs fonctions générales capables de tout faire à la fois, quelles que soient les dimensions du sprite que l'on souhaite afficher. Ces fonctions servent uniquement pour le mode DB, peuvent gérer la transparence en utilisant des masques, et peuvent également gérer le clipping (donc veiller à ce que ce qui sort d'un côté de l'écran n'apparaisse pas de l'autre côté). Elles travaillent avec des données compressées, c'est-à-dire que les 3 couches (masque/avant-plan/arrière-plan) ont été rassemblées en 2. Une ligne de 8 pixels sera donc codée en 2 octets, et plus en 3.
Ces fonctions ont donc quelques avantages:
Plutôt que d'avoir une seule fonction qui gère à la fois les masques et le clipping, on peut maintenant choisir si oui ou non on veut utiliser des masques et si oui ou non on doit veiller à éviter le clipping.
Les sprites peuvent maintenant être facilement dessinés et encodés avec le logiciel Sprite Maker (reportez-vous au fichier readme de ce prog ;)).
L'affichage n'est pas plus difficile qu'auparavant: il faut maintenant appeler drawspr(), de lui donner des coordonnées à l'écran (abscisse (ou colonne) et ordonnée (ou ligne)), de lui indiquer le sprite à afficher à cet endroit, et le mode d'affichage, grâce à l'une des 4 macros suivantes:
Pour indiquer ce sprite, il faut en fait lui fournir l'adresse en mémoire du premier élément du tableau dans lequel est enregistré le sprite en question, grâce à un pointeur. Si ceci ne vous dit rien, sachez simplement que de manière générale le nom d'un tableau peut être utilisé comme étant justement un pointeur vers son premier élément, et que donc pour afficher un sprite enregistré dans un tableau il suffit de donner à drawsprite... le nom du tableau. ;)
Pour ceux qui ne voient toujours pas, voici un petit exemple:
Bien sur ça c'est vraiment une utilisation basique, on peut également utiliser
un tableau de pointeurs avec les noms de tous les sprites, comme ca chaque
sprite recoit un numéro et pour afficher celui qu'on veut il suffit de connaître
son numéro pour désigner le bon élément du tableau de pointeurs:
uchar UnSprite[]={ ... };
uchar UnAutreSprite[]={ ... };
uchar EncoreUnSprite[]={ ... };
uchar ToujoursUnSprite[]={ ... }; // code des sprites
uchar * les_sprites[] =
{ UnSprite, UnAutreSprite, EncoreUnSprite, ToujoursUnSprite };
// tableau de "pointeurs" (y'a une étoile) contenant le nom
// de chaque sprite, donc l'adresse vers le premier élément
// de chacun d'entre eux
// affichage de EncoreUnSprite (3eme, donc n°2) sans gestion du clipping
// -> ce sprite ne peut pas dépasser de l'écran
drawspr(20,10,les_sprites[2],MODE_MASK_NOCLIP);
// affichage de UnSprite (1er, donc n°0) sans appliquer son masque
// -> le blanc du sprite devient transparent
drawspr(50,10,les_sprites[0],MODE_NOMASK_CLIP);
On peut également utiliser des pointeurs far pour désigner des sprites situés dans une memzone par exemple!
NB: ce que j'ai décrit là est vraiment la base du C, mais j'ai pris la peine d'expliquer ça en détail parce qu'il y a beaucoup de chances pour que cette lib soient utilisée par des débutants par facilité (mais non, je ne vise personne ;p)
Idéalement chaque mode se choisit grâce à la fonction drawspr(). Pour les férus de l'optimisation, on peut également utiliser 4 fonctions différentes ayant chacune leur propre mode; ces 4 fonctions s'utilisent comme drawspr() mais sans avoir besoin de spécifer un mode, et sont:
L'ancien appel drawsprite(x,y,spr) est encore valable, et revient à écrire drawspr(x,y,spr,MODE_MASK_CLIP).
En général, afficher directement à l'écran est fortement déconseillé. Il est toujours préférable d'afficher progressivement ses dessins en buffers, c'est-à-dire quelque part en dehors de l'écran, et de faire un raffraichissement d'écran lorsque tout a été dessiné en buffers.
Les 2 "couches" qui apparaissent en mode DB sont des zones mémoire de 1024 octets situées respectivement aux segments 0x1A20 et 0x1AA0 de la mémoire video. Par défaut, drawsprite() considère que les segments 0x1A60 (juste entre les 2 couches) et 0x1AE0 (juste derrière la 2eme) sont utilisés comme buffers. Ceci représente une certaine limitation, c'est pourquoi il est quand même possible de modifier les segments qui seront utilisés pour les buffers, mais uniquement lors de la création du programme et jamais pendant son exécution.
Deux macros sont définies dans Drawlib.h:
Ces valeurs peuvent être modifiées au besoin, mais uniquement avant la compilation du programme. On peut donc configurer drawsprite pour afficher directement à l'écran par exemple, mais je rappelle que c'est vivement déconseillé si on veut éviter les clignotements...
L'origine de chaque sprite se définit avant leur encodage. L'origine est le point du sprite qui sera réellement affiché en (x,y) lorsqu'on affiche le sprite en (x,y). Si l'origine est (a,b), cela revient à afficher le sprite en (x-a,y-b).
Par exemple si ceci représente un sprite 6*4 ayant une origine définie en 3,1:
(chaque case étant un des pixels du sprite), si l'on affiche ce sprite en
(10,15) à l'écran, c'est en fait le pixel noir qui sera réellement en (10,15),
tandis que le coin supérieur gauche du sprite (le pixel gris) sera en (10-3,15-1)
donc en (7,14).
Le fichier drawlib.h possède les 6 lignes suivantes:
Chacune de ces lignes correpond à une des fonctions de la lib. Si vous ne souhaitez pas utiliser une de ces fonctions, mettez simplement la ligne correspondante en commentaire (ne la supprimez jamais!!!) et elle sera remplacée par une fonction qui ne fait rien. Si vous souhaitez réutiliser la fonction, il suffit de retirer les commentaires de la ligne.
Notez que la fonction drawspr() utilise les 4 fonctions correspondant à chaque mode: si vous utilisez le mode mask+clip par exemple, vous ne pouvez pas mettre en commentaire la macro FUNC_DRAW_MASK_CLIP !
Pour certains programmes (jeux ou autres), il peut être utile d'empecher drawspr() de dessiner sur une certaine zone de l'écran. Par exemple, on peut maintenant empecher de dessiner des sprites en dehors d'un cadre situé à 5 pixels du bord de l'écran. Ceci permet par exemple de représenter une scene de jeu dans un cadre et d'afficher d'autres informations sur les côtés de ce cadre (par exemple avec les 2 autres fonctions qui n'ont pas besoin de tester le clipping).
Il n'y a plus de limitations sur les valeurs possibles, mais les limites haut et bas, gauche et droite se modifient toujours AVANT la compilation grâce aux macros (dans drawlib.h) DRAW_CLIPH, DRAW_CLIPB, DRAW_CLIPG, et DRAW_CLIPD. Toutes les valeurs sont maintenant autorisées, du moment qu'elles sont entières et à l'intérieur de l'écran. Un sprite peut à présent dépasser de tous les côtés en même temps.
En connaissant les dimensions d'un sprite, il est parfois utile de savoir quelle place il prendra en mémoire, notamment pour le chargement à partir d'un fichier externe par exemple. La fonction sizesprite(uchar Haut, uchar Larg) renvoie le nombre d'octets que prendrait un tableau de hauteur Haut et de largeur Larg.
Voilà, je crois que tout est dit...
J'ai inclus un petit exemple dans la lib, pour montrer son utilisation.
Utilisez:
Pour toute remarque ou suggestion, pensez à m'envoyer un mail!
06/07/2004