logo

Ces pages ne sont plus mises à jour !

Mais restent ici quand même. Attention: tout est vieux, et parfois faux. Tout se passe maintenant sur la wiki NeoGeo Development Wiki

Préface et documents
Architecture
Spécifications résumées
Architecture, Memory Map
BIOS
Structure des ROMs
Structure des CDs
Registres RAM
Vidéo
Système vidéo
Les palettes
Le fix
Les sprites
Audio
Système audio
Communication Z80
YM2610: ADPCM et SSG
Les pistes CDDA
Developpement
L'ASM 68K
Outils
Devkit ASM
Erreurs courantes
Portage MVS / NGCD
Electronique
Electronique
Cartouche flash MVS
Problèmes de lecteur CD
Productions
Astrosmash
Unleashed
Knackiballs
Bootloader et cable NGCD

Test MVS #01

Les sprites

Les sprites sont constitués d'un ou plusieurs tiles de 16x16 pixels, provenant des ROMs C (ou des fichiers .SPR sur NeoGeo CD).
Chaque sprite est en réalité une map (un tableau à une colonne) , et son affichés sous forme de bandes verticales de tiles, allant de 1x1 tiles à 1x32 tiles (soit 16x16 à 16x512 pixels).
La largeur des sprites est toujours fixée à 1 tile, seule leur hauteur peut être modifiée. La NeoGeo est capable de faire le rendu de 96 sprites par scanline au maximum, et 384 sur tout l'écran.

Bien qu'étant un seul et même objet tennant dans un rectangle de 4x6 tiles, il ne peut pas être constitué que d'un seul sprite.

Chaque sprite étant limité à un tile de largeur, il faut en mettre plusieurs côte-à-côte pour créer des objets plus larges.


Si les 4 sprites étaient séparés de quelques pixels, cet objet ressemblerait à ceci.

Quand plusieurs sprites doivent être groupés, ils doivent avoir des numéros successifs (d'où la notation en n+x...).

Chacun des 32 tiles pouvant constituer un sprite est modifiable, ainsi que sa palette, son orientation (effets mirroir) et ses caractèristiques d'auto-animation.

Les attributs d'un sprite sont: sa position (X/Y), sa hauteur en tiles, sa map, s'il est pilotant ou piloté, et ses coefficients de rétrécissement (X/Y).


Un sprite est positionné à partir de son coin haut gauche (origine). D'un point de vue performances, la NeoGeo ne fait pas la différence entre un sprite de 1x1 tile et un sprite de 1x32 tiles.

La taille (hauteur) du sprite doit être définie. Chaque tile constituant le sprite possède des paramètres qui lui sont propres (effet de mirroir horizontal, vertical, numéro de palette à utiliser...).

Certains jeux ne mappent que quelques tiles dans des sprites qui ont leur hauteur définie comme plus grande, sans raison apparente.
Par exemple, ne définir que 3 tiles visibles dans la map du sprite, et le déclarer comme en faisant 7 de haut. Ca ne change rien, mais c'est inutile.

Notez bien que les palettes sont individuellement attribuées aux tiles constituant le sprite, et non au sprite globalement.
Un sprite peut très bien contenir 16 tiles, utilisant chacun une palette différente (soit 16*16 = 256 couleurs en tout dans le sprite).


Une fonction très pratique permet de "grouper" les sprites, pour palier à la limite d'un seul tile en largeur.
Un bit à 1 dans la configuration du sprite permet de le lier au précédent. Sa position sera alors automatiquement calculée (X+16 pixels, Y identique), il aura la même hauteur et le même rétrécisseur Y, ceci est expliqué en détail après...

Par exemple:
Ici le sprite A est dit "pilotant", le sprite B y est lié (flèche blanche), il est donc de la même hauteur, et est collé 16 pixels à sa droite. Le sprite C est lié au sprite B et ainsi de suite, dans une certaine limite (32 ? A vérifier).
C'est à dire que par exemple, on peut très bien coller 15 sprites de 28 tiles de haut côte-à-côte pour controler un bloc de 240x448 pixels.

Notez également qu'un sprite reste un sprite. Ce n'est pas parce qu'il est lié à un autre qu'il ne compte plus comme tel.


Mélange bordelique des différentes couches, pour montrer à quoi ressemblent les sprites en bandes dans un vrai jeu:

On peut voir comment son constitués les objets en désactivant les sprites un par un dans les "screenshot factory" de certains émulateurs, comme WinKawaks.
On peut aussi voir qu'ils servent aussi bien à constituer les fonds.

Remarque: Il est fréquent de voir des graphismes qui ne sont jamais affichés à l'écran.
Par exemple, on ne voit jamais le bas des trois tourelles dans cette partie du jeu (une dizaine de pixels).
Quand on a la possibilité de remplir 64Mo de ROM dans une cartouche, on est plus à 1Ko près...

Ne JAMAIS utiliser le sprite N°0, c'est un cas spécial dangereux et aucun jeu ne l'utilise.

 

SCB1 (VRAM $0000): Map des sprites. 64 mots par sprite.

Comme il y a 2 mots par tile, et qu'un sprite fait au maximum 32 tiles, une map fait alors 64 mots.
Il suffit dont de faire N*64 pour avoir l'adresse de départ en SCB1 du sprite N.

Le format des maps est le suivant:

Mots pairs: numéro du tile à utiliser.
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
Numéro du tile à utiliser

Mots impairs: attributs du tile.
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
Numéro de palette à utiliser pour ce tile ? Bank de tiles à utiliser Animation auto sur 3 bits (8 tiles) Animation auto sur 2 bits (4 tiles) Mirroir vertical Mirroir horizontal

Pour trouver l'adresse effective du tile dans les ROMs C (ou le fichier .SPR), le GPU multiplie simplement le numéro du tile demandé par la taille d'un tile (128 octets).


Tileset de Mutation Nation, une roue de camion.

L'animation automatique

Le numéro du tile donné dans la map a ses 2 ou 3 premiers bits remplacés par le compteur d'animation automatique.
La vitesse d'incrémentation du compteur d'animation se règle dans les 8 MSB de $3C0006, elle est commune à tous les tiles auto-animés.
Le premier tile d'une séquence de tiles auto-animés doit alors être aligné tous les 4 ou 8 octets dans le tileset.

Exemple: Le numéro du tile indiqué dans la map est 8 (%1000), si il est auto-animé sur 2bits, la séquence sera la suivante: 8,9,10,11,8,9,10,11,8...
Si le numéro du tile indiqué en VRAM était 9, 10, ou 11 elle resterait 8,9,10,11,8,9... car le compteur d'animation remplace, et ne s'ajoute pas.
Par contre, si le numéro était 12, elle deviendrait 12,13,14,15,12,13,14...

Exemples de données en SCB1:
#$19C8 puis #$0308 à l'adresse $0000 indique que le premier tile du sprite 0 sera le tile n°$19C8, utilisant la palette 3, auto-animé sur 3 bits.
#$0148 puis #$0916 à l'adresse $0040 indique que le premier tile du sprite 1 sera le tile n°$10148, utilisant la palette 9, auto-animé sur 2 bits et retourné verticalement.
#$0149 puis #$2019 à l'adresse $0041 indique que le deuxième tile du sprite 1 sera le tile n°$10149, utilisant la palette 32, auto-animé sur 3bits et retourné horizontalement.

 

SCB2 (VRAM $8000): Coefs de rétrécissement. Un mot par sprite.

Utiliser #$8000+N pour avoir l'adresse en SCB2 du sprite N.

Contrairement à ce qu'on peut entendre, la NeoGeo ne sait pas "zoomer" des sprites, mais seulement les rétrécire.
Comme les sprites ont leur origine sur leur coin haut gauche, il faudra les décaler en conséquence si on veut les rétrécire depuis une autre origine. Format des mots:

15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
?
Rétrécissement horizontal
Rétrécissement vertical

Rétrécissement horizontal sur 4 bits ($0F = taille réelle, se propage pas aux sprite liés)
Rétrécissement vertical sur 8 bits ($FF = taille réelle, se propage aux sprites liés)

Comme le rétrécissement horizontal ne se propage pas, il faut gérer le rétrécissement des sprites groupés au niveau logiciel (distribution des rétrécissements).

Exemples:
#$0FFF à $8003 laisse le sprite n°3 tel quel.
#$08FF à $801C réduit le sprite n°$1C à 8 pixels de large.

 

SCB3 (VRAM $8200): Hauteur et position Y. Un mot par sprite.

Utiliser #$8200+N pour avoir l'adresse en SCB3 du sprite N.

15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
496-Position Y
Sprite piloté
Nombre de tiles dans le sprite (hauteur)

Utiliser #((496-Y)<<7) pour laisser le compilateur calculer la bonne valeur de la position Y.
La position verticale du sprite se fait à partir du haut de l'écran.

Le bit 6 indique que c'est le sprite précedent qui contrôle celui-ci.

Exemples:
#((496-48)<<7)+5 à $8201 donne une position Y de 48 pixels, une hauteur de 5 tiles, non piloté, au sprite n°1.
#((496-21)<<7)+7+64 à $8235 donne une position Y de 21 pixels, une hauteur de 7 tiles, piloté par le précedant, au sprite n°$35.

 

SCB4 (VRAM $8400): Position X. Un mot par sprite.

Utiliser #$8400+N pour avoir l'adresse en SCB4 du sprite N.

15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
8+Position X
?

Utiliser #((8+X)<<7) pour laisser le compilateur calculer la bonne valeur.
La position horizontale du sprite se fait à partir du bord gauche de l'écran.

Exemple:
#((8+35)<<7) à $8401 donne une position X de 35 pixels au sprite n°1.

footer
symbol symbol symbol symbol symbol