Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Amiga C Manual - Sprites
(Article écrit par Anders Bjerin et extrait d'Amiga C Manual - mars 1990)
|
|
Note : traduction par Serge Hammouche.
10. Sprites
10.1 Introduction
Les sprites sont de petits objets qui peuvent être déplacés sur l'écran
sans altérer le fond de l'image. L'Amiga possède huit canaux DMA, ce qui
nous permet de bénéficier de huit sprites matériels. L'intérêt d'utiliser
les sprites matériels réside dans le fait qu'ils peuvent être déplacés,
animés, etc. sans interférer avec le processeur principal. Ils peuvent
de ce fait être déplacés extrêmement rapidement et sont également très
faciles à gérer.
Les sprites peuvent être utilisés dans de nombreuses situations. Si vous
écrivez un jeu, vous pouvez utiliser les sprites comme ennemis, missiles,
explosion, etc. Même en ce moment, alors que vous lisez ceci, un sprite est
utilisé. Le pointeur Intuition (la souris) est en effet un sprite comme
indiqué dans le chapitre 2 - Les fenêtres.
10.2 Limitations
Les sprites sont de merveilleuses petites choses mais ils possèdent quelques limitations :
- Les sprites peuvent seulement avoir 16 pixels de largeur (il n'y a
aucune limite en ce qui concerne leur hauteur). Les sprites utilisent
toujours des pixels de basse résolution. Même si vous avez un écran en
haute résolution, les sprites seront en basse résolution. Ceci montre
combien les sprites sont indépendants.
- Chaque sprite ne peut utiliser que trois couleurs plus une couleur "transparente".
- Il n'existe que huit sprites matériels.
Ces limitations peuvent être dépassées :
- Vous pouvez placer deux sprites ou plus côte à côte afin de créer un
objet de largeur supérieure à 16 pixels.
- Vous pouvez "rattacher" deux sprites et porter ainsi le nombre de
couleurs disponibles de 3 à 15 plus une transparente.
- Il est possible de réutiliser chaque sprite matériel pour "asperger"
l'écran avec plusieurs sprites (VSprites).
10.3 Couleurs
Chaque sprite peut avoir trois couleurs différentes plus une couleur
transparente. Les sprites 0 et 1 utilisent les registres de couleur 16 à
19, les sprites 2 et 3 utilisent les registres de couleur 20 à 23 et ainsi de suite :
Sprite Registres de couleur
--------------------------------------
0 et 1 16 - 19 (16 est transparente)
2 et 3 20 - 23 (20 est transparente)
4 et 5 24 - 27 (24 est transparente)
6 et 7 28 - 31 (28 est transparente)
|
Deux choses importantes à rappeler :
Les sprites 0 et 1, 2 et 3, 4 et 5, 6 et 7, utilisent les mêmes
registres de couleur. Si vous modifiez le registre de couleur 17, à la
fois le sprite 0 et le sprite 1 seront affectés.
Si vous avez un écran basse résolution de profondeur 5 (32 couleurs),
les 16 dernières couleurs seront partagées par les sprites et l'écran.
Cependant, si vous utilisez seulement un écran à 16 couleurs (profondeur
4), vous utilisez malgré tout les 16 registres de couleur supérieurs
pour les sprites. Cela signifie que vous pouvez avoir un écran à 16
couleurs et utiliser 16 autres couleurs pour les sprites.
Les registres de couleur 16, 20, 24 et 28 sont "transparents", ce qui
signifie que la couleur de fond sera visible à travers. Ces registres
peuvent contenir n'importe quel type de couleur puisqu'ils n'affectent pas
les sprites.
10.4 Accéder aux sprites matériels
Si vous désirez utiliser un sprite matériel, vous devez :
- Déclarer et initialiser quelques données graphiques sur le sprite.
- Déclarer et initialiser une structure SimpleSprite.
- Appeler la fonction GetSprite() avec, pour paramètre, un pointeur sur
votre structure SimpleSprite et une demande pour le sprite que vous voulez.
- Déplacer le sprite en appelant la fonction MoveSprite() et l'animer en
changeant les données graphiques du sprite (ChangeSprite()).
- Restituer le sprite à la machine quand vous n'en avez plus besoin en
appelant la fonction FreeSprite().
10.4.1 Données du sprite
Nous avons déjà décrit comment créer vos propres données de sprite au
cours du chapitre 2 - Les fenêtres
mais voici tout de même un court résumé :
Première étape
La première chose que vous avez à faire est de dessiner sur un papier à
quoi le sprite devrait ressembler. Souvenez-vous que le sprite peut
avoir seulement 16 pixels de largeur, mais n'importe quelle hauteur
(Vous pouvez bien sûr placer deux sprites côte à côte si vous avez
besoin d'un sprite plus large que 16 pixels). Souvenez-vous aussi que
vous ne pouvez utiliser que trois couleurs par sprite).
Imaginez que vous ayez abouti à la proposition suivante :
0000000110000000 0 : Transparente
0000001111000000 1 : Rouge
0000011111100000 2 : Jaune
0000111111110000 3 : Vert
0001111111111000
0011111111111100
0111111111111110
2222222222222222
2222222222222222
0333333333333330
0033333333333300
0003333333333000
0000333333330000
0000033333300000
0000003333000000
0000000330000000
|
Deuxième étape
Vous devez maintenant traduire ceci en données de sprite. Chaque ligne
du graphique va être traduite en deux mots de données. Le premier mot
représente le premier plan de bits, et le second mot le second plan de bits.
L'idée est la suivante : si vous voulez la couleur 0, les plans de bit 0 et
1 devront valoir 0, si vous voulez la couleur 1, le plan de bits 0 vaudra 1
et le plan de bits 1, 0 et ainsi de suite :
Couleur Plan de bits 1 Plan de bits 0 Puisque
-------------------------------------------------------------------
0 0 0 00 Binaire = Couleur 0
1 0 1 01 Binaire = Couleur 1
2 1 0 10 Binaire = Couleur 2
3 1 1 11 Binaire = Couleur 3
|
Les données pour le pointeur ressembleraient à ceci :
Plan de bits 0 Plan de bits 1
0000000110000000 0000000000000000
0000001111000000 0000000000000000
0000011111100000 0000000000000000
0000111111110000 0000000000000000
0001111111111000 0000000000000000
0011111111111100 0000000000000000
0111111111111110 0000000000000000
0000000000000000 1111111111111111
0000000000000000 1111111111111111
0111111111111110 0111111111111110
0011111111111100 0011111111111100
0001111111111000 0001111111111000
0000111111110000 0000111111110000
0000011111100000 0000011111100000
0000001111000000 0000001111000000
0000000110000000 0000000110000000
|
Troisième étape
Le dernier travail consiste à transformer les chiffres binaires en type
UWORD. Groupez les chiffres binaires par quatre et transformez-les en hexadécimal :
0000 = 0 0100 = 4 1000 = 8 1100 = C
0001 = 1 0101 = 5 1001 = 9 1101 = D
0010 = 2 0110 = 6 1010 = A 1110 = E
0011 = 3 0111 = 7 1011 = B 1111 = F
|
Le résultat ressemblera à ceci :
0 1
-------------
0180 0000 0000 0001 1000 0000 0000 0000 0000 0000
03C0 0000 0000 0011 1100 0000 0000 0000 0000 0000
07E0 0000 0000 0111 1110 0000 0000 0000 0000 0000
0FF0 0000 0000 1111 1111 0000 0000 0000 0000 0000
1FF8 0000 0001 1111 1111 1000 0000 0000 0000 0000
3FFC 0000 0011 1111 1111 1100 0000 0000 0000 0000
7FFE 0000 0111 1111 1111 1110 0000 0000 0000 0000
0000 FFFF 0000 0000 0000 0000 1111 1111 1111 1111
0000 FFFF 0000 0000 0000 0000 1111 1111 1111 1111
7FFE 7FFE 0111 1111 1111 1110 0111 1111 1111 1110
3FFC 3FFC 0011 1111 1111 1100 0011 1111 1111 1100
1FF8 1FF8 0001 1111 1111 1000 0001 1111 1111 1000
0FF0 0FF0 0000 1111 1111 0000 0000 1111 1111 0000
07E0 07E0 0000 0111 1110 0000 0000 0111 1110 0000
03C0 03C0 0000 0011 1100 0000 0000 0011 1100 0000
0180 0180 0000 0001 1000 0000 0000 0001 1000 0000
|
Quatrième étape
Puisque l'Amiga a besoin de sauvegarder la position du sprite, sa
taille, etc., vous devez aussi déclarer deux mots vides au début, et
deux mots vides à la fin des données du sprite. Ces mots seront
initialisés et maintenus par Intuition, donc vous n'avez pas à vous
préoccuper d'eux.
Une déclaration et initialisation de données du sprite pourrait donc être :
UWORD chip my_sprite_data[36]=
{
0x0000, 0x0000,
0x0180, 0x0000,
0x03C0, 0x0000,
0x07E0, 0x0000,
0x0FF0, 0x0000,
0x1FF8, 0x0000,
0x3FFC, 0x0000,
0x7FFE, 0x0000,
0x0000, 0xFFFF,
0x0000, 0xFFFF,
0x7FFE, 0x7FFE,
0x3FFC, 0x3FFC,
0x1FF8, 0x1FF8,
0x0FF0, 0x0FF0,
0x07E0, 0x07E0,
0x03C0, 0x03C0,
0x0180, 0x0180,
0x0000, 0x0000
};
|
Important : souvenez vous que toutes les données d'image doivent (toujours !)
être chargées dans la mémoire Chip (les 512 ko de mémoire inférieurs). Si vous
utilisez le Lattice C V5.00 ou supérieur, vous pouvez utiliser le mot clé
"chip" devant le nom de votre nom d'image. Vérifiez le manuel de votre compilateur.
10.4.2 La structure SimpleSprite
La structure SimpleSprite ressemble à ceci :
struct SimpleSprite
{
UWORD *posctldata;
UWORD hauteur;
UWORD x, y;
UWORD num;
};
|
- posctldata : pointeur sur un tableau de UWORDs qui est utilisé pour les données graphiques du sprite.
- hauteur : hauteur du sprite (nombre de lignes). Les sprites matériels ont toujours 16 pixels de large.
- x, y : position à l'écran relative au ViewPort/View (affichage).
- num : numéro du sprite (0-7). Lorsque vous appelez la fonction GetSprite(), elle initialise automatiquement
ce champ avec la numéro du sprite réservé, aussi mettez le à -1 pour le moment.
10.4.3 Réserver un sprite
Avant que vous n'utilisiez un sprite matériel, vous devez l'avoir réservé.
Puisque l'Amiga est multitâche, il peut arriver qu'un autre programme
utilise le sprite. Vous réservez un sprite en appelant la fonction
GetSprite() :
- Synopsis : sprite_obtenu = GetSprite( mon_sprite, sprite_désiré );
- sprite_obtenu : (long). GetSprite() renvoie le numéro du sprite que vous
avez obtenu (0-7). Si elle n'a pas pu obtenir le sprite
désiré, elle retourne la valeur -1. Pensez à vérifier si
vous avez obtenu le sprite que vous souhaitiez ! (le champ
"num" de la structure SimpleSprite sera aussi initialisé automatiquement).
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- sprite_désiré : (long) le numéro du sprite matériel que vous souhaitez
utiliser (0-7). Si vous n'avez pas besoin d'un numéro particulier, vous pouvez écrire
-1. Le système vous allouera alors n'importe quel sprite matériel disponible.
10.4.4 Jouer avec le sprite
Une fois que vous avez réservé un sprite, vous pouvez commencer à jouer
avec lui. Vous déplacez le sprite en appelant la fonction MoveSprite() :
- Synopsis : MoveSprite( view_port, mon_sprite, x, y );
- view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel le sprite
est relié, ou 0 si le sprite doit être relié à la vue (View) courante.
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- x, y : (long). La nouvelle position à l'écran (attention, les sprites utilisent des
pixels de basse résolution).
Par exemple, MoveSprite ( 0, &mon_sprite, 30, 50 ); déplace le sprite
(mon_sprite) jusqu'à la position (30, 50) (relativement à la vue courante).
Vous pouvez aussi modifier l'image (données du sprite) d'un sprite afin
de l'animer. Il suffit d'appeler la fonction ChangeSprite() avec pour
paramètre un pointeur vers de nouvelles données graphiques, et le reste est
fait à votre place.
- Synopsis : ChangeSprite( view_port, mon_sprite, nouvelle_image );
- view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel est relié
le sprite, ou 0 si le sprite est relié à la vue (View) courante.
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- nouvelle_image : (short *). Pointeur sur les nouvelles données du sprite.
10.4.5 Libérer le sprite
Quand vous n'avez plus besoin du sprite (quand votre programme se termine
par exemple), vous devez libérer le sprite pour qu'une autre tâche puisse
l'utiliser si nécessaire. Important : vous devez libérer tous les sprites
que vous avez alloués, sinon aucune autre tâche ne pourra s'en servir et le
seul moyen de libérer le matériel est alors de réinitialiser la machine.
Vous libérez un sprite en appelant la fonction FreeSprite() :
- Synopsis : FreeSprite( sprite_utilisé );
- sprite_utilisé : (long). Numéro du sprite que vous voulez libérer (0-7).
10.4.6 Structure d'un programme
Un programme utilisant des sprites ressemblerait à ceci :
/* Puisque nous utilisons les sprites nous avons besoin de ce fichier : */
#include <graphics/sprite.h>
/* 1. Déclare et initialise quelques données graphiques du sprite : */
UWORD chip données_mon_sprite[36]=
{
0x0000, 0x0000,
0x0180, 0x0000,
0x03C0, 0x0000,
0x07E0, 0x0000,
0x0FF0, 0x0000,
0x1FF8, 0x0000,
0x3FFC, 0x0000,
0x7FFE, 0x0000,
0x0000, 0xFFFF,
0x0000, 0xFFFF,
0x7FFE, 0x7FFE,
0x3FFC, 0x3FFC,
0x1FF8, 0x1FF8,
0x0FF0, 0x0FF0,
0x07E0, 0x07E0,
0x03C0, 0x03C0,
0x0180, 0x0180,
0x0000, 0x0000
};
/* 2. Déclare et initialise une structure SimpleSprite : */
struct SimpleSprite mon_sprite=
{
données_mon_sprite, /* posctldata, pointeur sur les données du sprite. */
16, /* hauteur, 16 lignes. */
40, 20, /* x, y, position à l'écran. */
-1, /* num, ce champ est automatiquement */
/* initialisé quand on appelle la */
/* fonction GetSprite(), aussi nous */
/* mettons -1 pour le moment. */
};
UWORD chip mouvelle_image_sprite[26]=
{
0x0000, 0x0000,
and so on...
main()
{
/* Ouvrir la bibliothèque Graphic.library, etc. */
/* 3. Appelle la fonction GetSprite() avec pour paramètres */
/* un pointeur sur votre structure SimpleSprite et */
/* une demande pour le sprite que vous souhaitez. */
/* Essaie de réserver le sprite numéro 2 : */
if( GetSprite( &mon_sprite, 2 ) != 2 )
{
/* ERREUR ! */
/* N'a pas pu réserver le sprite numéro 2. */
}
/* 4. Déplacer le sprite en appelant la fonction */
/* MoveSprite() et l'anime en modifiant les */
/* données graphiques du sprite à l'aide de */
/* fonction ChangeSprite(). */
/* Déplace le sprite jusqu'à la position (20,30) */
MoveSprite( 0, &mon_sprite, 20, 30 );
/* Modifie les données graphiques du sprite : */
ChangeSprite( 0, &mon_sprite, nouvelle_image_sprite );
/* 5. Rend le sprite au matériel quand vous n'en avez plus */
/* besoin en appelant la fonction FreeSprite() : */
FreeSprite( mon_sprite.num );
/* Ferme d'autres choses (bibliothèques, etc) */
}
|
10.5 Techniques
Puisque les déplacements et modifications du sprite sont effectués par le
matériel, ceci se fait à la vitesse de la lumière sans que le processeur principal
n'en ait connaissance. Si vous le pouvez, vous devriez utiliser les sprites
puisque le matériel est spécialisé dans leur gestion. Cependant il y a,
comme mentionné plus tôt, quelques limitations qui peuvent poser des
problèmes ; mais en utilisant quelques techniques spéciales, vous pouvez
arriver quasiment à tout. Les sprites peuvent également servir pour créer
quelques effets spéciaux intéressants, et sont parfaits pour l'animation.
10.5.1 Sprites plus larges
Si vous voulez un vaisseau spatial de 32 pixels de large, vous
pouvez utiliser deux sprites côte à côte afin d'obtenir l'effet souhaité.
Chaque fois que vous déplacez le vaisseau, vous appelez deux fois la
fonction MoveSprite(). Puisque les sprites se déplacent très vite,
l'utilisateur ne réalisera jamais que le vaisseau est constitué de deux sprites.
(30,50) (30+16, 50)
*--------------*----------------
| ####|#### |
| # #|# ## |
| #############|############## |
|##############|###############|
| #############|############## |
--------------------------------
Sprite 2 Sprite 3
|
Si vous utilisez tous les huit sprites, vous pouvez obtenir une image de
128 pixels de large et de n'importe quelle hauteur. Je ne pense pas que
vous ayez besoin d'un vaisseau de plus grande taille.
10.5.2 Plus de couleurs
Chaque sprite peut utiliser seulement trois couleurs plus une
transparente. Cependant, il est possible d'attacher deux sprites et donc
d'utiliser 15 couleurs plus une transparente (puisque chaque sprite
utilise deux plans de bits, ceci signifie qu'un sprite attaché possède quatre
plans de bits, ce qui donne 16 combinaisons = 15 couleurs + une transparente).
Les sprites peuvent être attachés comme suit :
- 1 à 0 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 1.
- 3 à 2 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 3.
- 5 à 4 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 5.
- 7 à 6 : positionnez le bit SPRITE_ATTACHED dans les données du sprite 7.
Les sprites pairs (0, 2, 4 et 6) sont appelés sprites inférieurs alors
que les sprites impairs (1, 3, 5 et 7) sont appelés sprites supérieurs.
Quand vous voulez utiliser un sprite attaché, vous devez :
- Déclarer et initialiser deux tableaux de données de sprites.
- Positionner le bit Attach (pour le sprite impair 1, 3, 5, 7) dans le
second mot des données du sprite.
- Une fois que vous avez réservé les deux sprites par GetSprite(), ils
peuvent être déplacés. Il est important que les deux sprites soient
déplacés ensemble pour que le mode Attach fonctionne, sinon ils
redeviendront des sprites à trois couleurs.
10.5.2.1 Données de sprites à 15 couleurs
Comme vous l'avez vu auparavant, les données de sprite sont constituées
de deux plans de bits. Quand vous attachez deux sprites, nous pouvons par
conséquent obtenir quatre plans de bits et donc 15 couleurs plus une
transparente.
Le sprite inférieur fournit les plans de bits 0 et 1, pendant que le sprite
supérieur fournit les plans de bits 2 et 3.
Aussi, si vous voulez que le sprite ressemble à ceci :
0000000000000000 0 : registre de couleur 16 (transparent)
1111111111111111 1 : registre de couleur 17 (transparent)
2222222222222222 2 : registre de couleur 18 (transparent)
3333333333333333 3 : registre de couleur 19 (transparent)
4444444444444444 4 : registre de couleur 20 (transparent)
5555555555555555 5 : registre de couleur 21 (transparent)
6666666666666666 6 : registre de couleur 22 (transparent)
7777777777777777 7 : registre de couleur 23 (transparent)
8888888888888888 8 : registre de couleur 24 (transparent)
9999999999999999 9 : registre de couleur 25 (transparent)
AAAAAAAAAAAAAAAA A : registre de couleur 26 (transparent)
BBBBBBBBBBBBBBBB B : registre de couleur 27 (transparent)
CCCCCCCCCCCCCCCC C : registre de couleur 28 (transparent)
DDDDDDDDDDDDDDDD D : registre de couleur 29 (transparent)
EEEEEEEEEEEEEEEE E : registre de couleur 30 (transparent)
FFFFFFFFFFFFFFFF F : registre de couleur 31 (transparent)
|
...les quatre plans de bits ressembleraient à ceci :
Plan de bits 3 Plan de bits 2 Plan de bits 1 Plan de bits 0
-------------------------------------------------------------------
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 1111111111111111
0000000000000000 0000000000000000 1111111111111111 0000000000000000
0000000000000000 0000000000000000 1111111111111111 1111111111111111
0000000000000000 1111111111111111 0000000000000000 0000000000000000
0000000000000000 1111111111111111 0000000000000000 1111111111111111
0000000000000000 1111111111111111 1111111111111111 0000000000000000
0000000000000000 1111111111111111 1111111111111111 1111111111111111
1111111111111111 0000000000000000 0000000000000000 0000000000000000
1111111111111111 0000000000000000 0000000000000000 1111111111111111
1111111111111111 0000000000000000 1111111111111111 0000000000000000
1111111111111111 0000000000000000 1111111111111111 1111111111111111
1111111111111111 1111111111111111 0000000000000000 0000000000000000
1111111111111111 1111111111111111 0000000000000000 1111111111111111
1111111111111111 1111111111111111 1111111111111111 0000000000000000
1111111111111111 1111111111111111 1111111111111111 1111111111111111
|
Transformé en hexadécimal, on obtiendrait :
3 2 1 0
-------------------
0000 0000 0000 0000
0000 0000 0000 FFFF
0000 0000 FFFF 0000
0000 0000 FFFF FFFF
0000 FFFF 0000 0000
0000 FFFF 0000 FFFF
0000 FFFF FFFF 0000
0000 FFFF FFFF FFFF
FFFF 0000 0000 0000
FFFF 0000 0000 FFFF
FFFF 0000 FFFF 0000
FFFF 0000 FFFF FFFF
FFFF FFFF 0000 0000
FFFF FFFF 0000 FFFF
FFFF FFFF FFFF 0000
FFFF FFFF FFFF FFFF
|
Maintenant, nous n'avons plus qu'à écrire ça dans deux tableaux de données
de sprites. Souvenez-vous que le sprite inférieur (0, 2, 4 ou 6) fournit
les plans de bits 0 et 1, alors que le sprite supérieur (1, 3, 5 ou 7) fournit
les plans de bits 2 et 3 :
/* Données pour le sprite inférieur : */
UWORD chip données_sprite_inférieur[36]=
{
0x0000, 0x0000,
/* Plan de bits */
/* 0 1 */
0x0000, 0x0000,
0xFFFF, 0x0000,
0x0000, 0xFFFF,
0xFFFF, 0xFFFF,
0x0000, 0x0000,
0xFFFF, 0x0000,
0x0000, 0xFFFF,
0xFFFF, 0xFFFF,
0x0000, 0x0000,
0xFFFF, 0x0000,
0x0000, 0xFFFF,
0xFFFF, 0xFFFF,
0x0000, 0x0000,
0xFFFF, 0x0000,
0x0000, 0xFFFF,
0xFFFF, 0xFFFF,
0x0000, 0x0000
};
/* Données pour le sprite supérieur : */
UWORD chip données_sprite_supérieur[36]=
{
0x0000, 0x0000,
/* Plan de bits */
/* 2 3 */
0x0000, 0x0000,
0x0000, 0x0000,
0x0000, 0x0000,
0x0000, 0x0000,
0xFFFF, 0x0000,
0xFFFF, 0x0000,
0xFFFF, 0x0000,
0xFFFF, 0x0000,
0x0000, 0xFFFF,
0x0000, 0xFFFF,
0x0000, 0xFFFF,
0x0000, 0xFFFF,
0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF,
0x0000, 0x0000
};
|
10.5.2.2 Attacher des sprites
Pour relier deux sprites, vous devez simplement positionner l'indicateur
SPRITE_ATTACHED dans le second mot des données du sprite supérieur. Ainsi,
si vous voulez relier le sprite 3 avec le sprite 2, vous devez positionner
l'indicateur SPRITE_ATTACHED dans les données du sprite 3.
données_sprite_supérieur[ 1 ] = SPRITE_ATTACHED;
|
ou :
UWORD chip données_sprite_supérieur[36]=
{
0x0000, SPRITE_ATTACHED,
|
Et ainsi de suite...
10.5.2.3 Déplacer des sprites attachés
Une fois que deux sprites sont attachés, vous n'avez qu'à les réserver,
et vous aurez un sprite à 15 couleurs :
/* Réserve le sprite 2 comme sprite inférieur : */
sprite_inférieur_obtenu = GetSprite( &mon_sprite_inférieur, 2 );
if( sprite_inférieur_obtenu != 2 )
/* ERREUR ! */
/* Réserve le sprite 3 comme sprite supérieur : */
sprite_supérieur_obtenu = GetSprite( &mon_sprite_supérieur, 3 );
if( sprite_supérieur_obtenu != 3 )
/* ERREUR ! */
|
Il est important que les deux sprites soient déplacés simultanément pour
que la fonction Attach fonctionne. La bonne nouvelle est que si vous
déplacez le sprite inférieur, le sprite supérieur sera aussi déplacé
automatiquement. Si par contre vous déplacez seulement le sprite
supérieur, le sprite inférieur demeurera inchangé, et la fonction spéciale
Attach ne fonctionnera pas (retour à 3 couleurs).
Si vous voulez vous amuser vous pouvez réserver le sprite 1 et
positionner l'indicateur SPRITE_ATTACHED. Puisque le sprite 0 est déjà
utilisé comme pointeur par Intuition, le sprite 1 sera attaché au pointeur,
et vous pourrez avoir un pointeur en 15 couleurs ! A chaque fois
qu'Intuition déplace le pointeur (le sprite 0, qui est le sprite
inférieur), votre sprite (le sprite 1, sprite supérieur) sera déplacé
automatiquement. Vous pouvez modifier le pointeur Intuition en appelant la
fonction SetPointer. Référez-vous au chapitre 2 - Les fenêtres
pour de plus amples informations.
10.5.3 Niveaux
Chaque sprite possède son propre "niveau" (priorité) ce qui signifie que
certains sprites se déplaceront au-dessus et d'autres au-dessous des
autres sprites quand ils se toucheront. Le plus grand numéro de sprite
possède le niveau le plus bas (priorité). Cela signifie que le sprite 3 se
déplacera au dessus du sprite 4, alors que le sprite 2 passera au dessus du sprite 3 :
--------
| 7 |
| --------
----| 6 |
| --------
----| 5 |
| --------
----| 4 |
| --------
----| 3 |
| --------
----| 2 |
| --------
----| 1 |
| --------
----| 0 |
| |
--------
|
Ceci peut être utilisé de nombreuses façons. Par exemple, si vous écrivez
un jeu avec un petit bonhomme sautant dans une boîte, vous pouvez utiliser
deux sprites : un pour le bonhomme, un deuxième pour la boîte. La chose
importante à rappeler est que cette boîte doit avoir un numéro de sprite
inférieur à celui du bonhomme. Si vous placez le bonhomme à la même
position que la boîte, il semblera entrer dans la boîte :
O
-----
|
^ #######
/ \ #######
Bonhomme Boîte
(sprite 2) (sprite 1)
O
-----
|
#######
#######
Bonhomme (sprite 2)
Boîte (sprite 1)
|
10.6 Fonctions
GetSprite()
Cette fonction réserve un sprite. Vous devez toujours réserver un sprite
avant que vous ne puissiez l'utiliser.
- Synopsis : sprite_obtenu = GetSprite( mon_sprite, sprite_désiré );
- sprite_obtenu : (long). GetSprite() renvoie le numéro du sprite que vous
avez obtenu (0-7). Si elle n'a pas pu obtenir le sprite
désiré, elle retourne la valeur -1. Pensez à vérifier si
vous avez obtenu le sprite que vous souhaitiez ! (le champ
"num" de la structure SimpleSprite sera aussi initialisé automatiquement).
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- sprite_désiré : (long). Le numéro du sprite matériel que vous souhaitez
utiliser (0-7). Si vous n'avez pas besoin d'un numéro particulier, vous pouvez écrire -1.
Le système vous allouera alors n'importe quel sprite matériel disponible.
MoveSprite()
Utilisez cette fonction pour déplacer un sprite.
- Synopsis : MoveSprite( view_port, mon_sprite, x, y );
- view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel le
sprite est relié, ou 0 si le sprite doit être relié à la vue (View) courante.
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- x, y : (long). La nouvelle position à l'écran (attention les sprites utilisent des
pixels de basse résolution).
ChangeSprite()
Cette fonction modifie les données (l'image) d'un sprite.
- Synopsis : ChangeSprite( view_port, mon_sprite, nouvelle_image );
- view_port : (struct ViewPort *). Pointeur sur le ViewPort auquel est
relié le sprite, ou 0 si le sprite est relié à la vue (View) courante.
- mon_sprite : (struct SimpleSprite *). Pointeur sur votre structure SimpleSprite.
- nouvelle_image : (short *). Pointeur sur les nouvelles données du sprite.
FreeSprite()
Cette fonction rend au matériel un sprite réservé auparavant.
- Synopsis : FreeSprite( sprite_utilisé );
- sprite_utilisé : (long). Numéro du sprite que vous voulez libérer (0-7).
WaitTOF()
Cette fonction attend que le balayage vidéo ait atteint le sommet de
l'écran. Elle peut être utilisé si vous voulez diminuer un peu la
vitesse, et rend l'animation plus souple.
10.7 Exemples
Voici des exemples
(dans le répertoire "Amiga_C_Manual/10.Sprites") montrant des sprites :
Exemple 1
Ce programme montre comment déclarer et initialiser des données de sprite
et une structure SimpleSprite. Il montre aussi comment réserver un sprite
(sprite 2) et comment le déplacer. L'utilisateur déplace le sprite en
utilisant les flèches de déplacement.
Exemple 2
Ce programme montre comment déclarer et initialiser des données de sprite
et une structure SimpleSprite. Il montre aussi comment réserver un sprite
(sprite 2) et comment le déplacer. L'utilisateur déplace le sprite en
utilisant les flèches de déplacement. Dans cet exemple, nous animons le
sprite (six images, tirées du jeu d'arcade Miniblast).
Exemple 3
Ce programme montre comment créer un sprite en 15 couleurs, et comment le déplacer.
|