Les fonctions de bas niveau
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 84 fonctions différentes, et plus de 400 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.
- 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(0X0700);
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[1,void *dest2]);
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
, MASK
, TRANW
ou TRANB
. 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 en noir et blanc (sa taille doit être de 3840 octets).
dest1/dest2
: adresses des écrans de destination en niveaux de gris (leur taille doit être de 3840 octets chacun).
La famille DrawTiles
Les fonctions du type Drawtiles
servent à afficher un plan, à partir de sa matrice de tiles, directement à l'écran (sans passer par un big_vscreen). Ces fonctions ne permettent pas de scroller le plan au pixel près.
En fait, ces fonctions fonctionnent exactement comme celles du type RefreshBuffer
, sauf que la destination est un écran virtuel de taille normale.
L'affichage est en mode RPLC
, il est donc inutile d'effacer la destination avant d'afficher dessus.
Leurs prototypes sont de la forme :
void Draw[Gray]TilesXY[89](short larg,void *tab,void *dest[1,void *dest2],void *sprts);
Où Gray
est optionnel, il indique si la fonction est en niveaux de gris.
89
est également optionnel, il permet de n'afficher que la partie de l'écran visible par une TI-89 (c'est donc plus rapide, surtout pour les tiles 8x8).
X
indique la taille des sprites, il peut prendre les valeurs 16
(sprites 16x16) ou 8
(sprites 8x8).
Y
indique si la matrice de tiles est codée sur des char
ou des short
, il peut prendre les valeurs B
(char
) ou W
(short
).
Par exemple, pour afficher un plan défini par une matrice de char
, avec des sprites 8x8 en noir et blanc et n'afficher que la partie visible par une TI-89, on utilisera la fonction DrawTiles8B89
.
Description des paramètres attendus par ces fonctions :
larg
: largeur de la matrice de tiles (en nombre de tiles, pas en pixels).
tab
: adresse de la matrice de tiles, positionnée sur le premier tile à afficher en haut à gauche de l'écran.
dest
: adresse du l'écran de destination en noir et blanc (sa taille doit être de 3840 octets).
dest1/dest2
: adresses des écrans de destination en niveaux de gris (leur taille doit être de 3840 octets chacun).
sprts
: liste des sprites à utiliser.
L'exemple 6 fourni avec la librairie illustre une utilisation d'une de ces fonctions.
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[1,void *dest2],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
, MASK
, 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 du l'écran de destination en noir et blanc (sa taille doit être de 3840 octets).
dest1/dest2
: adresses des écrans de destination en niveaux de gris (leur taille doit être de 3840 octets chacun).
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
).
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.