Documentation du TileMap Engine v0.3 (19/01/2004)

• Introduction
• Comment utiliser le TileMap Engine ?
• Description des fonctions
• Structures de données
• Fonctions de haut niveau
• Fonctions de bas niveau
• Remerciements
• Annexe
• Historique
• A faire
• Contact

Introduction

Le TileMap Engine est une librairie graphique qui permet d'afficher des maps constituées de tiles.
Voici ses principales caractéristiques :

• Fonctions en Niveaux de gris ou noir et blanc
• Sprites 16x16 ou 8x8
• Matrices de char ou de short
• Beaucoup de modes d'affichage différents, dont deux par transparence (ce qui permet d'avoir plusieurs plans de profondeur)
• Gestion automatique des tiles animées
• Décalages verticaux et horizontaux propres à chaque ligne

• Les RPG
• Les jeux de plate-forme (éventuellement avec plusieurs plans de profondeur)

• Les jeux de plateau où le décor est constitué de sprites affichés à des coordonnées multiples de leur largeur (ex : SimCity) - voir les fonctions Tile... d'ExtGraph pour faire cela
• Les shoot'em up

+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|01|01|01|00|00|00|00|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|01|01|01|01|01|01|00|00|00|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|01|01|01|01|01|01|01|01|01|01|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|01|01|01|01|00|00|01|01|01|01|01|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|01|01|01|01|00|00|00|01|01|01|01|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|01|01|01|01|01|01|00|01|01|01|00|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|01|01|01|01|01|01|01|01|01|01|01|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|01|01|01|01|01|01|01|01|01|01|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|01|01|01|01|01|01|01|01|01|01|01|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|00|01|01|01|01|01|01|01|01|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|00|00|00|01|01|01|01|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|00|00|00|00|00|00|00|00|00|00|00|00|01|00|00|00|00|00|00|00|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

              272
     <----------------->
   ^ +-----------------+
   | |    ######       |
   | |   ##########    |
   | |   ####  #####   |
   | |  ####   ####    |
160| |  ###### ###     |
   | |   ###########   |
   | |      ########## |
   | |      ###########|
   | |       ########  |
   | |         ####    |
   v +-----------------+

            16
    <---------------->
  ^ +----------------+----------------+----------------+---------------
  | |             |  |           ^ |  |             |  |             | 
  | |             |  |           | |  |             |  |             | 
  | |             |  |         11| |  |             |  |             | 
16| |      13     |  |           | |  |             |  |             | 
  | |<----------->|  |           v |  |             |  |             | 
  | |-------------+--|-------------+--|-------------+--|-------------+-
  | |             |  |             |  |             |  |             | 
  | |             |  |             |  |             |  |             | 
  v +----------------+----------------+----------------+---------------
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |-------------+--|-------------+--|-------------+--|-------------+-
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    +----------------+----------------+----------------+---------------
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |             |  |             |  |             |  |             | 
    |-------------+--|-------------+--|-------------+--|-------------+-
    |             |  |             |  |             |  |             | 

Comment utiliser la librairie dans vos programme ?

Les fonctions de la librairie

Spécifications des structures de données

Depuis le début, nous parlons de matrice de tiles, de liste de sprites, de grand écran virtuel, ou d'écran virtuel simple, sans vraiment avoir précisé quelles étaient leurs spécificités.



Matrice de tiles

Tableau de char ou de short, à deux dimensions, ayant au minimum 8 lignes et 15 colonnes si on utilise des sprites 16x16, ou 16 lignes et 30 colonnes avec des sprites 8x8.





Sprites

Les sprites peuvent être en noir et blanc ou en niveaux de gris, et de taille 8x8 pixels ou 16x16. Il y a des fonctions spécifiques pour chaque type de sprite, il ne faut donc pas se tromper en les choisissant.
Les sprites en noir et blanc sont classiques : un tableau de 8 char pour les sprites 8x8, ou un tableau de 16 short pour les sprites 16x16, contenant successivement chaque ligne du sprite.
Les sprites en niveaux de gris utilisent un format un peu plus compliqué : c'est un tableau de 16 char pour les sprites 8x8 ou 32 short pour les sprites 16x16 qui est organisé comme ceci : ligne1/plan1, puis ligne1/plan2, puis ligne2/plan1, puis ligne2/plan2, etc... On appelle cela un format entrelacé. Le plan1 peut-être celui correspondant au gris clair au au gris foncé, cela n'a pas d'importance tant que vous respectez la même convention pour les écrans virtuels (voir plus bas).





Liste de sprites

La liste peut être vue comme un tableau à une dimension contenant des sprites, mais en réalité, c'est un tableau à deux dimensions, puisque les sprites eux aussi sont des tableaux à une dimension.





Tableau d'animation

Tableau de short à deux dimensions : le nombre d'étape d'animation et le nombre d'animations. Chaque ligne représente une étape, et chaque colonne représente une animation, ainsi l'élément du tableau situé sur la colonne c et la ligne l sera le numéro du sprite de la l^ième étape de la c^ième animation.
Le tableau ne peut être qu'un tableau de short, car j'ai pensé que si vous utilisez des tiles animés vous aurez probablement beaucoup de sprites.





Table de décalage horizontal

Tableau de char à une dimension, de 128 éléments. Chaque élément représente le décalage individuel horizontal à ajouter à celui de la ligne courante lors de la recopie du grand écran virtuel vers l'écran. Les valeurs autorisées sont comprises entre 0 et 16.





Table de décalage vertical

Tableau de short à une dimension, de 128 éléments. Chaque élément représente la valeur à ajouter à l'adresse source à la fin de chaque ligne lors de la recopie du grand écran virtuel vers l'écran. Toutes les valeurs sont permises, mais faites attention à ne pas sortir du grand écran virtuel.





Grand écran virtuel

Zone mémoire de 5440 octets si vous travaillez en noir et blanc, ou bien deux fois plus grande (10880 octets) si vous travaillez en niveaux de gris (dans ce cas, les 5440 premiers octets correspondront au Plan1, et les 5440 suivant correspondront au Plan2, vous choisissez comme il vous arrange de définir le Plan1 gris clair ou gris foncé, mais respectez cette convention dans vos sprites).





Ecran virtuel

Zone mémoire de 3840 octets en noir et blanc, ou le double (7680 octets) si vous travaillez en niveaux de gris (dans ce cas, comme pour le grand écran virtuel, les deux plans seront adjacents, à vous de choisir lequel sera le plan foncé et lequel sera le plan clair).





Les fonctions de haut niveau


Notez que les prototypes et l'utilisation des fonctions de ce tilemap engine peuvent/vont changer dans ExtGraph 2.00 Beta 3.


• void DrawPlane(short x,short y,Plane *plane,void *dest,TM_Mode mode,TM_Type type);


Cette fonction affiche le plan plane à partir des coordonnées x et y, dans l'écran (virtuel ou non) d'adresse dest.
Elle s'occupe toute seule de rafraichir le grand écran virtuel lorsque c'est nécessaire.
Les paramètres plane, type et mode ont des types particuliers, voici à quoi ils correspondent :
plane est l'adresse d'une structure de type Plane, dont voici la définition :

typedef struct
{
    void *matrix;  // Matrice de tiles
    unsigned short width;  // Largeur de la map
    void *sprites; // Tableau de sprites
    char *big_vscreen;  // Grand écran virtuel
    long mask;  // Contient le mask, lorsqu'on veut afficher en mode BLIT
    long reserved1;  // Utilisé en interne (ne pas modifier)
    short force_update; // Pour forcer l'actualisation du grand écran virtuel.
}Plane;


type indique le type de plan : taille des sprites (8x8 ou 16x16), matrice codée sur des char ou sur des short, utilisation des niveaux de gris ou non. C'est un paramètre de type TM_Type, ce type étant complexe, regardez dans le header si vous voulez vraiment savoir à quoi il correspond, mais ce n'est pas indispensable pour pouvoir utiliser la fonction, car j'ai défini des macros qui peuvent s'utiliser directement en paramètre (reportez vous à l'annexe à la fin de ce document pour les connaître).
mode permet de spécifier le mode d'affichage : RPLC, OR, XOR, AND, TRANW, TRANB ou BLIT. Ce paramètre est de type TM_Mode, ce type est également compliqué, si vous voulez savoir à quoi il correspond, regardez dans le header. J'ai également défini plusieurs macros qui peuvent être utilisées directement en paramètre, reportez vous à l'annexe à la fin de ce document.

Cette fonction actualise le grand écran virtuel si nécessaire seulement. Pour forcer la réactualisation, mettez une valeur non nulle dans le champ force_update de votre Plane, la fonction DrawBuffer remettra ce champ à 0 après que l'actualisation ait eu lieu. Il est indispensable de faire ça à l'initialisation, avant que le plane n'ait été affiché.

Pour utiliser la fonction avec un mode d'affichage BLIT, précisez au préalable la valeur du masque que vous voulez dans le champ mask de votre Plane.

Pour voir un exemple d'utilisation de cette fonction, jetez un coup d'oeil à l'exemple1 fourni avec la librairie (demo13 pour ExtGraph).

Note : Il est recommandé d'utiliser les macros prévues à cet effet pour les paramètres type et mode.



• void DrawAnimatedPlane(short x,short y,AnimatedPlane *plane,void *dest,TM_Mode mode,TM_AnimType type);


Affiche le plan animé plane à partir des coordonnées x et y, dans l'écran (virtuel ou non) d'adresse dest.
Met automatiquement le grand écran virtuel du plane à jour lorsque c'est nécessaire.
Le paramètre plane est l'adresse d'une structure AnimatedPlane, voici sa définition :


typedef struct
{
    Plane p;
    void *tabanim; // Matrice d'animations
    short nb_anim; // Nombre d'animations
    short nb_step; // Nombre d'étapes d'animation
    short step; // Numéro de l'étape d'animation courante
    short step_length; // Durée d'une étape (en nombre d'images)
    short frame; // Numéro de l'image de l'étape courante
}AnimatedPlane;

Cette structure contient donc un Plane suivi de toutes les informations nécessaires pour l'animer.
La matrice du Plane ne contiendra pas des numéros de sprites, mais des numéros d'animation, et la fonction ira chercher le numéro de sprite correspondant dans la tableau d'animations tabanim.
Le paramètre mode est exactement le même que pour la fonction précédente, reportez vous à l'annexe pour connaître toutes ses valeurs possibles.
Le paramètre type fonctionne comme dans la fonction précédente, mais ses valeurs possibles ne sont pas les mêmes, elles sont également données dans l'annexe.

Cette fonction est utilisée dans l'exemple 3 fourni avec la librairie (demo15 pour ExtGraph).





Les fonctions de bas niveau


Notez que les prototypes et l'utilisation des fonctions de ce tilemap engine peuvent/vont changer dans ExtGraph 2.00 Beta 3.

Il y a plusieurs familles de fonctions qui effectuent les deux tâches primaires de plusieurs façons différentes, pour donner au total pas moins de 64 fonctions différentes, et plus de 380 combinaisons d'utilisation...



• La famille RefreshBuffer


Les fonctions du type RefreshBuffer servent à mettre à jour le contenu du grand écran virtuel.

Leurs prototypes sont de la forme :
void Refresh[Gray]BufferXY(short larg,void *tile,void *dest,void *sprts);
Où : Gray est optionnel, il indique si la fonction est en niveaux de gris ou non.
X indique la taille des sprites et peut prendre les valeurs 16 (sprites de 16x16 pixels) ou 8 (sprites de 8x8 pixels) seulement.
Y indique la taille des tiles de la matrice, peut prendre les valeurs W (matrice de words [2 octets]) et B (matrice d'octets).
Par exemple, pour utiliser cette fonction sur une matrice d'octets, avec des sprites de 16x16 pixels et en niveaux de gris, il faudra utiliser la fonction RefreshGrayBuffer16B.

Et voici la description des paramètres que prennent ces fonctions :
larg : largeur de la matrice de tiles.
tile : adresse du premier tile (celui dans le coin en haut à gauche) que vous voulez afficher dans le grand écran virtuel.
dest : adresse du grand écran virtuel de destination (il doit faire 5440 octets en noir et blanc, et 10880 octets en niveaux de gris).
sprts : adresse de la liste des sprites du plan.

Je vous conseille de regarder l'exemple2 pour voir un exemple d'utilisation de cette fonction (demo14 pour ExtGraph).



• La famille RefreshAnimatedBuffer


Les fonctions du type RefreshAnimatedBuffer servent à mettre à jour le contenu du grand écran virtuel tout en animant ses tiles.

Leurs prototypes sont de la forme :
void Refresh[Gray]AnimatedBufferXY(short larg,void *tile,void *dest,void *sprts,void *tabanim);
Où : Gray est optionnel, il indique si la fonction est en niveaux de gris ou non.
X indique la taille des sprites et peut prendre les valeurs 16 (sprites de 16x16 pixels) ou 8 (sprites de 8x8 pixels) seulement.
Y indique la taille des tiles de la matrice, peut prendre les valeurs W (matrice de words [2 octets]) et B (matrice d'octets).
Par exemple, pour utiliser cette fonction sur une matrice d'octets, avec des sprites de 16x16 pixels et en niveaux de gris, il faudra utiliser la fonction RefreshGrayBuffer16B.

Et voici la description des paramètres que prennent ces fonctions :
larg : largeur de la matrice de tiles.
tile : adresse du premier tile (celui dans le coin en haut à gauche) que vous voulez afficher dans le grand écran virtuel. Ce tile ne contiendra pas le numéro du sprite correspondant, contrairement à la fonction précédente, mais il contiendra un numéro d'animation.
dest : adresse du grand écran virtuel de destination (il doit faire 5440 octets en noir et blanc, et 10880 octets en niveaux de gris).
sprts : adresse de la liste des sprites du plan.
tabanim : adresse de la liste des numéros de sprites. C'est un tableau de short à une dimension. L'élément n de ce tableau contient le numéro du sprite correspondant à l'étape courante de l'animation n.


Il n'y a pour l'instant pas d'exemple d'utilisation de cette fonction, donc voici un pseudo exemple :


char matrix[MAP_WIDTH][MAP_HEIGHT]={...};  // Contient des n° d'animation
short anim[NB_ETAPES][NB_ANIM]={...}; // Contient des n° de sprites
short sprts[NB_SPRITES][16]={...}; // Contient les sprites (en noir et blanc)

void _main(void)
{
  char big_vscreen[BIG_VSCREEN_SIZE];
  short old_sr,n_frame,n_etape;

  old_sr=OSSetSR(0x0200);

  n_frame=n_etape=0;

  do
  {
    if(!n_frame) // Si on est à la première image d'une étape, on rafraichit
      RefreshAnimatedBuffer(MAP_WIDTH,matrix,big_vscreen,sprts,anim[n_etape]);

    DrawBuffer_RPLC(big_vscreen,0,0,LCD_MEM);

    if(!(++n_frame % 16)) // Toutes les 16 images, on change d'étape d'animation
      n_etape = (n_etape+1) % NB_ETAPES;
  }while(!_keytest(RR_ESC));

  OSSetSR(old_sr);
}

On note que la libraire est mal utilisée car les coordonnées passées à la fonction DrawBuffer sont nulles toutes les deux. C'est juste pour que l'exemple soit plus court.
À chaque image, on incrémente un compteur, qui arrivé à une certaine valeur (16 dans notre exemple) change le numéro de l'étape d'animation.
Pour chaque étape, le numéro de l'image correspondant à chaque animation est donnée dans le tableau anim.
La plupart du temps, on ne souhaite pas animer tous les tiles d'une map, mais seulement une partie d'entre eux, dans ce cas, il suffit d'affecter à l'animation le même numéro de sprite à toutes ses étapes.
Cela soulève un problème qui est que si seulement quelques tiles sont animés, le tableau anim devient trop redondant. Dans ce cas, procédez autrement, n'utilisez qu'une liste de numéros de sprites (plutôt que NB_ETAPES listes comme dans l'exemple), et mettez à jour directement la liste quand vous le voulez.



• La famille DrawBuffer


Les fonctions du type DrawBuffer recopient le contenu du grand ecran virtuel en le scrollant, vers un écran de taille normale (virtuel ou non).

Leurs prototypes sont de la forme :
void Draw[Gray]Buffer[89]_MODE(void *src,short x,short y,void *dest);
Où : Gray est optionnel, il indique si la fonction est en niveaux de gris.
89 est également optionnel, il permet de ne recopier vers la destination que la partie visible par une TI-89 (c'est donc beaucoup plus rapide).
MODE spécifie le mode d'affichage, il peut prendre les valeurs RPLC, OR, XOR, AND, TRANW, TRANB ou BLIT. La description des différents modes d'affichage est disponible en annexe.
Par exemple, pour afficher un plan en mode RPLC, et en niveaux de gris, on utilisera la fonction DrawGrayBuffer_RPLC.

Et voici la description des paramètres que prennent ces fonctions :
src : adresse du grand écran virtuel que l'on souhaite afficher.
x : décalage horizontal à effectuer, en pixels (Attention : doit être compris en 0 et 31).
y : décalage vertical à effectuer, en pixels (Attention : doit être compris entre 0 et 31).
dest : adresse du l'écran de destination (sa taille doit être de 3840 octets en noir et blanc, et de 7680 octets en niveaux de gris).

En réalité, les fonctions en mode BLIT sont légèrement différentes des autres, elles prennent un paramètre supplémentaire, le masque. Leurs prototypes sont de la forme :
void Draw[Gray]Buffer[89]_BLIT(void *src, short x, short y, long mask, void *dest);
Où mask contient la valeur du masque. Attention : ce masque est sur 32 bits, afin de permettre une plus grande souplesse d'utilisation, mais cela peut être à l'origine de problèmes si vous n'y faites pas attention.



• La famille DrawBufferWithShifts


Les fonctions du type DrawBufferWithShifts recopient le contenu du grand écran virtuel en le scrollant, vers un écran de taille normale, mais contrairement à la fonction précédente, il est possible de spécifier la valeur du décalage horizontal pour chaque ligne, et il est aussi possible de rajouter des décalages verticaux entre les lignes.
Cela permet de faire énormément d'effets graphiques.

Leurs prototypes sont de la forme :
void Draw[Gray]BufferWithShifts[89]_MODE(void *src,short x,short y,void *dest,char *dh,short *dv);
Où Gray est optionnel, il indique si la fonction est en niveaux de gris.
89 est également optionnel, il permet de ne recopier vers la destination que la partie visible par une TI-89 (c'est donc plus rapide).
MODE spécifie le mode d'affichage, il peut prendre les même valeurs que pour DrawBuffer, c'est-à-dire : RPLC, OR, XOR, AND, TRANW, TRANB ou BLIT. La description des différents modes d'affichage est disponible en annexe.

Description des paramètres que prennent ces fonctions :
src : adresse du grand écran virtuel que l'on souhaite afficher.
x : décalage horizontal, en pixels (Attention : doit être compris entre 0 et 15).
y : décalage vertical, en pixels (Attention : doit être compris entre 0 et 15).
dest : adresse de l'écran de destination.
dh : adresse de la table de décalage horizontal. Lors de la recopie du grand écran virtuel vers la destination, pour chaque ligne, on ajoutera la valeur correspondante de la table à x pour avoir le décalage horizontal de la ligne. Leur somme est comprise entre 0 et 31.
dv : adresse de la table de décalage vertical. Lors de la recopie du grand écran virtuel vers la destination, à la fin de la recopie de chaque ligne, on ajoutera la valeur correspondante de la table au pointeur qui contient l'adresse de la source (le grand écran virtuel à afficher). Ainsi pour afficher deux fois une même ligne, par exemple, il vous suffit de mettre la valeur -34 quelque part dans le tableau (et pour sauter une ligne, mettez 34).

Les fonctions en mode BLIT, comme pour DrawBuffer, sont différentes en réalité, elles prennent un paramètre masque supplémentaire, donc leurs prototypes sont de la forme :
void Draw[Gray]BufferWithShifts[89]_BLIT(void *src,short x,short y,long mask,void *dest,char *dh,short *dv);
Où mask contient la valeur du masque.

Le fonctionnement de ces fonctions n'est pas très évident à comprendre au premier abord, c'est pourquoi je vous recommande de regarder l'exemple 4 pour vous aider à assimiler leur principe de fonctionnement. Une fois compris, vous verrez que les possibilités qu'offrent ces fonctions sont très étendues et puissantes.

Remerciements

Annexe

Description des différents modes d'affichage :

RPLC

RemPLaCe complètement la destination (il est donc inutile de l'effacer auparavant). Vous devriez utiliser ce mode pour afficher un arrière-plan.

OR

OU logique entre la source et la destination.

XOR

OU eXclusif logique entre la source et la destination.

AND

ET logique entre la source et la destination.

BLIT

Ce mode utilise le champ mask du Plane (ou bien le mask peut être passé directement en paramètre avec les fonctions de bas niveau). Un ET logique est effectué entre le mask et la destination, puis le plan est affiché en mode OR. Ce mode peut être utile pour faire des effets de transitions.

TRANW

La couleur blanche est TRANsparente, les autres couleurs sont opaques. Ce mode est très utile pour afficher des plans par-dessus un arrière-plan.

TRANB

La couleur noire est TRANsparente, les autres couleurs sont opaques. Ce mode est également très utile pour afficher des plans par-dessus un arrière-plan.

Tableau récapitulatif des différents types de plan :

("valeurs" de type TM_Type)

	Matrice de char		Matrice de short
	Sprites 8x8	Sprites 16x16	Sprites 8x8	Sprites 16x16
Noir et blanc	TM_8B	TM_16B	TM_8W	TM_16W
Niveaux de gris	TM_G8B	TM_G16B	TM_G8W	TM_G16W

Tableau récapitulatif des différents types de plan animés :

("valeurs" de type TM_AnimType)

	Matrice de char		Matrice de short
	Sprites 8x8	Sprites 16x16	Sprites 8x8	Sprites 16x16
Noir et blanc	TM_A8B	TM_A16B	TM_A8W	TM_A16W
Niveaux de gris	TM_GA8B	TM_GA16B	TM_GA8W	TM_GA16W

Tableau récapitulatif des différents modes d'affichage :

("valeurs" de type TM_Mode)

		RPLC	OR	XOR	AND	BLIT	TRANW	TRANB
Noir et blanc	TI92+	TM_RPLC	TM_OR	TM_XOR	TM_AND	TM_BLIT
	TI89	TM_RPLC89	TM_OR89	TM_XOR89	TM_AND89	TM_BLIT89
Niveaux de gris	TI92+	TM_GRPLC	TM_GOR	TM_GXOR	TM_GAND	TM_GBLIT	TM_GTRANW	TM_GTRANB
	TI89	TM_GRPLC89	TM_GOR89	TM_GXOR89	TM_GAND89	TM_GBLIT89	TM_GTRANW89	TM_GTRANB89

Historique

v 0.3 (19/04/2004)

Traduction de la documentation en anglais

v0.2 (26/12/2003)

Fonctions d'animation automatique de tiles et de décalages individuels horizontaux et verticaux.
Correction de quelques bugs sur les fonction BLIT.

v0.1b (21/12/2003)

Aucune nouvelle fonction n'a été ajoutée, mais elles ont toutes été réécrites car la taille du grand écran virtuel a été changée, pour lui permettre une meilleure évolution.
L'utilisation des fonctions de haut niveau ne devrait pas avoir changé, mais celle des fonctions de bas niveau a changé.

v0.1 (19/12/2003)

Première version publique

A faire

Contact