Obligement - L'Amiga au maximum

Mardi 23 mai 2017 - 16:44  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Soutien

N'hésitez pas à soutenir le projet Obligement



Contact

David Brunet

Courriel

 


Programmation : Assembleur - liste Copper et registres du Copper
(Article écrit par Roméo Rapido et extrait d'A-News (Amiga News) - juin 1989)


Tout d'abord, quelques explications. Le Copper est le coprocesseur de l'Amiga qui gère plus particulièrement l'affichage. C'est en modifiant ses registres que l'on a accès aux diverses résolutions de l'Amiga. Mais le Copper c'est avant tout un processeur au même titre que le 68000 et, comme lui, il exécute des programmes plus connus sous le nom de "Copper List".

Qu'est-ce qu'en liste Copper ?

C'est très simple. Une liste Copper c'est tout simplement la liste des instructions que le Copper doit exécuter lors d'un balayage écran, ce qui correspond au trajet du spot du coin en haut à gauche au coin en bas à droite. Hélas pour nous ces instructions sont au nombre de trois, ce qui peut paraître restreint par rapport au jeu d'instructions du 68000, mais vous allez voir que l'on peut faire des miracles avec seulement trois instructions.

Tout d'abord, il y a l'instruction WAIT qui permet d'attendre que le spot soit à une certaine position sur l'écran. On peut attendre n'importe quelle position verticale mais seulement une position horizontale modulo 4 (quatre pixels basse résolution quel que soit le mode) ce qui correspond à la lecture de l'instruction Copper suivante en DMA. En mémoire une instruction WAIT se présente comme suit :

bits 15...8 7...1 0
V7...V0 H8...H2 1
15 14...8 7...1 0
BCB BMV6...BMV0 BMH8...BMH2 0

Vous avez remarqué que le bit 0 du premier mot est à 1 et le bit 0 du deuxième mot est à 0 c'est ce qui permet de différencier le WAIT du MOVE qui lui a le bit 0 du premier mot à 0 (le premier mot du MOVE étant l'adresse du registre ou on charge une valeur, il est donc forcément pair car il est impossible de faire des accès sur les adresses impaires avec le Copper : mot pair donc bit 0 à 0, logique).

V7 à V0 codent la position verticale à attendre (à noter que la ligne de départ est la première de l'écran physique du moniteur et non pas de l'écran affiché) de même que H8 à H2 codent la position horizontale modulo 4 (c'est pour cela que les bits commencent à H2, on ne peut donc pas avoir une valeur inférieure à 100 (en binaire) ce qui fait bien 4). Si le bit BCB (bit de contrôle du Blitter) est positionné, on attend que le Blitter ait fini ses opérations avant de continuer l'exécution de la liste Copper. Les bits BMV et BMH sont les bits de masque verticaux et horizontaux et il vaut mieux leur affecter la valeur 1. Dans la plupart des cas le deuxième mot d'un WAIT sera donc $FFFE.

Mais, puisqu'il n'y a que 8 bits pour la position verticale, on ne peut pas atteindre les lignes situées en dessous de 255 ? ($FF)

Mais si, bien sûr, c'est prévu. Il suffit d'attendre la fin de la ligne 255 avec l'instruction suivante : FFE1 FFFE puis pour attendre, par exemple, la ligne 265 on exécutera un $0A1 FFFE.

Le SKIP est une sorte de WAIT puisqu'il passe à l'instruction suivante si le spot a atteint, ou dépassé, la position spécifiée. Sa seule différence avec le WAIT est de comporter un 1 comme bit 0 du premier mot ce qui permet au Copper de faire la différence entre ces deux instructions.

Et maintenant la reine des instructions du Copper, le MOVE. En gros, une instruction MOVE se présente comme suit :

bits 15...0 15...0
registre valeur

Avec la restriction suivante que les bits 15 à 9 doivent être à 0. On peut donc adresser les registres de 0 à 1FE.

Mais les registres sont à partir de l'adresse $DFF000 ?

Exact, mais l'adressage du Copper est en relatif par rapport à la base des registres qui est effectivement $DFF000. Un exemple : pour écrire la valeur $0F00 (rouge pur) dans COLOR00 (registre de la couleur 0) dont l'adresse est $DFF180 l'instruction Copper sera $0180 0F00. Il est donc possible avec le Copper de modifier, par exemple, les registres des sprites et donc de déplacer et modifier ceux-ci avec une liste Copper bien étudiée.

Pour déplacer un sprite au lieu de modifier le registre correspondant, on modifie la liste Copper. Cela peut paraître inutile mais si on change d'écran en changeant de liste Copper on peut, par exemple, changer aussi de souris. Chaque fois que l'on basculera d'un écran à l'autre on changera automatiquement de souris et ceci de manière totalement transparente.

Un dernier mot sur les listes Copper, elles doivent toujours se terminer par une instruction impossible du type $FFFFFFFE.

Les registres du Copper

COP1LC ($80) contient le pointeur sur la nouvelle liste Copper à installer. Pour la valider, il suffit de mettre COPJMP1 ($88) à 0 par un clr.w par exemple (à noter que ce registre possède une partie haute en $80 et une partie basse en $82 puisque les adresses sont codées sur 32 bits en absolu) il existe aussi COP2LC ($84) et COPJMP2 ($8A) pour une deuxième liste Copper, mais ils ne sont peu utilisés.

DIWSTRT ($8E) et DIWSTOP ($90), "display window start" et "display window stop" qui sont les coordonnées respectives du coin supérieur gauche et du coin intérieur droit. Avec V7...V0 H9...H2 la position horizontale étant modulo 4, les valeurs courantes sont : DIWSTRT $2C81 et DIWSTOP = $F5C1 (nota : en fait, la position verticale importe peu. La preuve, le mois dernier, il y avait $3081 et $30C1 et ça marchait quand même. Mais soyons rigoureux).

DDFSTRT ($92) et DDFSTOP ($94), début et fin du "video data fetch". En gros, contrôle timing horizontal pour l'affichage en accès DMA des bitplanes. Les valeurs qui vont bien avec les précédentes sont DDFSTRT = $38 et DDFSTOP = $d0.

C'est en modifiant les valeurs de ces quatre registres que vous pouvez obtenir des affichages en suraffichage.

BPLC0N0 ($100), registre de contrôle du mode d'affichage.

bits 15 : mode HR (640 points horizontaux) 0 = non, 1 = oui
14...12 : nombre de plans 1...6 (notez que l'on pourrait avoir sept plans)
11 : mode HAM (4096 couleurs)
10 : mode DUAL PLAYFIELD
9 : mode couleur
8 : mode genlock audio
7...4 : inutilisés
3 : crayon optique
2 : mode entrelacé (512 lignes en PAL)
1 : mode genlock vidéo
0 : inutilisé

BPLCON1 ($102) registre qui permet de décaler les plans d'une valeur entre 0 et 7. Très peu utile et donc presque toujours à 0.

BELCON2 ($104) utilisé en mode dual playfield sinon mis à 0. Dans le cas d'une utilisation :

bit 6 : priorité du playfield 2 par rapport au 1.
bits 5...3 : priorité des sprites par rapport au playfield 2.
bits 2...0 : priorité des sprites par rapport au playfield 1.

Restent les registres BPLxPT ("x" est un chiffre de 1 à 6) qui sont les registres pointeurs bitplane. Ils sont donc au nombre de six et comportent une partie haute et une partie basse (BPLxPTH et BPLxPTL) leurs adresses sont :

BPL1PTH ($E0) et BPL1PTL ($E2)
BPL2PTH ($E4) et BPL2PTL ($Eb)
BPL3PTH ($E8) et BPL3PTL ($EA)
BPL4PTH ($EC) et BPL4PTL ($EE)
BPL5PTH ($F0) et BPL5PTL ($F2)
BPL6PTH ($F4) et BPL6PTL ($F6)

Et enfin, le dernier de la liste, DMACON ($96) qui permet de lancer le DMA et donc l'affichage. Ce registre est un peu spécial car il sert aussi pour le contrôle du Blitter et de Paula (audio). Le bit 15 sert de set/clear et les autres bits de masque.

Je m'explique, les 14 bits inférieurs servent de masque ce qui veut dire que seuls les bits qui sont mis à 1 dans le masque seront modifiés, si le bit 15 est à 0 les bits sont mis à 0 et à 1 si le bit 15 est à 1.

Les bits de ce registre :

bits 0...3 : contrôle des canaux audio de 0 à 3.
4 : DMA disque
5 : DMA sprite
6 : DMA Blitter
7 : DMA Copper
8 : DMA Bitplanes
9 : valide tous les DMA
10 : priorité du Blitter sur le 68000 (mode "nasty").
11...14 : inutilisés.
15 : set/clear.

Exemple : $0020 vire tous les sprites. $84C0 lance le DMA pour le Copper et le Blitter en mode "nasty" (priorité du Blitter sur le 68000 pour les accès au bus).

Il faut remarquer que tous ces registres sont des "Write Only", c'est-à-dire que l'on peut y écrire mais pas les lire, sauf DMACON qui possède un homologue nommé DMACONR ($2) ("R" pour "read", lecture) ce qui permet de vérifier si le DMA est autorisé pour tel ou tel circuit. De même, cela permet de sauvegarder l'état du registre DMACON pour pouvoir le restituer plus tard. Il suffit de faire un "move.w $DFF002,_dmacon_save" puis un "or.w #$8000,_dmacon_save" pour activer le bit set/clear et en fin de programme il ne reste plus qu'à restituer le registre en faisant un "move.w #$7FFF,$DFF096" qui nettoie le registre (le système de bit set/clear empèche d'utiliser un clr.w) puis un "move.w _dmacon_save,$DFF096" qui remet tout en place.

Exemple avec un écran avec plein de jolies bandes de couleurs différentes

C'est très simple, il suffit d'écrire une liste Copper qui attende le début de chaque ligne et modifie la valeur du registre COLOR00. On peut donc avoir autant de couleurs que de lignes affichées. Et si vous changez la couleur sur une position horizontale vous obtenez un damier (vous pouvez avoir au mieux 320/4=80 (écran 320x256) tests de position par ligne, le Copper ayant besoin d'un temps équivalant à un déplacement de quatre pixels pour lire une instruction. On perd une position sur deux pour modifier le registre COLOR00, on peut donc avoir, théoriquement, au plus 40 couleurs par lignes chacune occupant 8 pixels. Et ceci en utilisant seulement la couleur 0 ce qui laisse les 31 autres registres indépendants.

Bien sûr, à chaque ligne les couleurs peuvent être différentes ce qui fait, si je compte bien, 40x256=10240 ; l'Amiga ayant une palette de "seulement" 4096 couleurs il vous faudra utiliser des couleurs en double ou utiliser seulement 16 couleurs par ligne (16x256=4096). Je vous souhaite bien du plaisir pour écrire la liste Copper qui réalise ceci car elle devra comporter 4096 instructions WAIT et autant de MOVE dans COLOR00 avec chaque fois une valeur différente soit un total de 8192 mots longs. Mais de là à dire que c'est joli cela dépend du choix judicieux (ou non) des couleurs.

Vous aurez droit à un exemple complet le mois prochain en attendant digérez bien cet article.


[Retour en haut] / [Retour aux articles]