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 : Assembleur 68k - défilement qui ondule verticalement
(Article écrit par François Fleuret et extrait de Génération 4 - avril 1989)
|
|
Pour continuer notre découverte des défilements sur Amiga, nous allons faire ici un défilement
qui ondule verticalement avec une ombre portée, comme celui de la Workbench Demo de Wild-Coppers.
L'ombre portée est facilement réalisable en utilisant deux plans de bits qui pointent sur la même
mémoire vidéo avec un décalage de 320 octets, soit huit lignes verticalement, et un décalage horizontal
réalisé avec le registre BPLCON1 prévu à cet effet (car si on le fait avec les adresses, on voit apparaître
à gauche de l'écran l'ombre de la partie du texte la plus à droite). Le vrai problème se trouve donc au
niveau du défilement lui-même.
Contrairement à ce que l'on pourrait penser, l'utilisation du Copper n'est pas la meilleure méthode pour
réaliser une telle animation car la liste Copper aurait une longueur de 20 ko et il faudrait recalculer
2560 MOVE à chaque VBL avec le 68000. Donc, il faut la faire avec le Blitter, le Copper n'étant utilisé
que pour des tâches secondaires telles que les dégradés de couleurs. Bien que l'utilisation du Blitter
soit en général déconseillée, il faut bien reconnaître que les transferts de blocs permettent de produire
certains effets irréalisables sans eux. Ici, nous devons faire un défilement ondulant, il est donc hors
de question de faire un gros transfert pour décaler tout le texte, il faut gérer le bloc en plusieurs
morceaux. La précision horizontale de l'ondulation (largeur des "marches d'escalier" dans les courbes)
sera de quatre points. La méthode retenue consiste donc à faire le défilement en découpant le bloc
en tranches de quatre points de largeur. La théorie est simple et limpide, la pratique l'est moins.
Le programme se déroule ainsi : dans une table nommée "TABLE_ONDE" se trouvent les adresses correspondant
aux "altitudes" où doivent se trouver chacune de ces tranches. Cette table est calculée avec un programme
BASIC (voir fin d'article) à l'aide d'une fonction sinus. Dans une seconde table qui se trouve au label
"TABLE_HAUTEURS" se trouvent les hauteurs actuelles de chacune de ces tranches. On sait donc où aller chercher
la tranche et où la recopier. Dans trois autres tables (TABLE_SRC, TABLE_DST et TABLE_MSK) se trouvent
les adresses de départ et d'arrivée des transferts théorique (sans le mouvement vertical) ainsi que
l'adresse où se trouve le masque.
On fait le défilement ainsi : on gère les tranches une par une de la gauche vers la droite ;
pour chacune d'entre elles, on doit calculer l'adresse de départ et d'arrivée avec les tables citées
ci-dessus. On commence par prendre la somme de l'adresse de base du plan de bits et de l'adresse où
doit se faire le défilement. On ajoute ensuite à cette adresse l'adresse de départ du transfert (TABLE_SRC)
et l'adresse où se trouve la tranche actuelle (TABLE_HAUTEURS) et on obtient ainsi l'adresse du pointeur
pour la source A. On fait de même avec la table TABLE_DST, mais on ajoute ensuite l'adresse prise dans
TABLE_ONDE. On obtient ainsi les adresses pour la destination ; on sauve ensuite dans TABLE_HAUTEURS la
nouvelle hauteur prise dans TABLE_ONDE. On a donc l'adresse de départ et celle d'arrivée, il reste
le problème des masques car on gère des blocs des quatre points de large au milieu de mots de 16 points,
il faut donc utiliser un masque pour recopier la tranche que l'on est en train de traiter sans écraser
les mots où elle doit être recopiée, on utilise donc les sources B et C, B pointant sur l'adresse où
l'on va recopier la tranche et C sur le masque. Avec cette opération, on garde tout le mot destination
sauf les quatre points où l'on place la tranche. L'opération logique sera donc (les lettres en minuscules
représentent le "NOT") :
D=(A.c),(B*C)
...que l'on peut transformer en :
D=(A*c)*(B+b),(B.C)*(A+a)
D=A*B*c+A*b*c+A*b*c+a*b*c
D=ABc+Abc+Abc+abc
Donc les bits 6, 4, 7 et 3 de BLTCON0.
Les déplacements de quatre points vers la gauche se font avec un décalage de 12 pts vers la droite car
comme les rotations fonctionnent avec un barillet, ce qui sort à droite revient à gauche ; malheureusement,
lorsque l'on fait cela, le bloc descend d'une ligne c'est pourquoi les adresses de TABLE_DST sont parfois
négatives, elles remontent le bloc pour corriger ce défaut.
Pour faire entrer les lettres à droite de l'écran, on utilise un tampon où se trouve la lettre en cours
d'apparition, ce tampon fait 64x32 points. A chaque VBL, on le décale de quatre points vers la gauche
après avoir recopié la colonne de gauche dans le plan de bits.
Il faut noter également que pour éviter
que les tranches laissent des traces en haut et en bas, on rajoute quatre lignes vides au-dessus et
en dessous en déplaçant des blocs de 40 lignes (au lieu de 32) et en faisant commencer le défilement
quatre lignes plus haut que normalement ; ainsi, ces huit lignes noires effacent ce qui restait de
la tranche. Si vous voulez utiliser une table qui fait des déplacements verticaux de plus de quatre
points, il faudra modifier ce nombre de lignes noires pour qu'il corresponde au déplacement vertical
maximum.
Pour que l'ondulation soit dynamique, il faut que la TABLE_ONDE varie, c'est pourquoi on utilise
un pointeur (POINTEUR_TABLE) plutôt qu'une adresse fixe pour pouvoir donner l'impression que l'onde
se déplace sur le texte. La vitesse de déplacement du pointeur est contenue dans VITESSE, et on peut
la modifier en plaçant des codes négatifs dans le texte. Lorqu'il rencontre un tel code, le programme
le rend positif puis le multiplie par 4 pour obtenir une vitesse de déplacement en nombre d'octets
par VBL (on multiplie par 4 car la table est faite d'adresses chacune sur un mot long).
Comme ce défilement est réalisé avec le Blitter, il prend beaucoup de temps dans la VBL, il faut donc
éviter que le balayage passe sur le texte pendant que l'on déplace les tranches (il y aurait dans ce
cas un "décrochage" très laid) pour cela, il faut placer le texte en bas de l'écran ou bien attendre
un peu après l'IRQ du Copper avant d'appeler la routine SCROLL.
Pour ce qui est du jeu de caractères, l'image qu'il faut utiliser est la même que celle du
défilement
qui s'enroule (320x256 monochrome non compactée) ainsi que la table des adresses (que vous pouvez donc
réutiliser). Les lettres doivent faire au maximum 30 points de haut, évitez d'utiliser la première et
la dernière ligne car elles laisseraient des traces pendant les déplacements rapides.
Le listing est prévu pour le KSeka mais il est facilement adaptable à d'autres assembleurs.
Voici le petit programme BASIC qui vous fait un fichier ".s" qui contient la table de la trajectoire.
En changeant la formule qui calcule la forme de l'onde, vous pouvez faire varier les effets ;
par exemple, on peut faire une partie de la table avec une fréquence et l'autre avec une autre,
on crée ainsi l'effet d'une "vague" qui se déplace sur le texte.
Et voilà, un défilement de plus pour vos démos. Le gros défaut de ce défilement est le temps qu'il
prend dans la VBL (presque le tiers), ce qui est gênant, surtout si vous le faites sur deux
plans de bits. Néanmoins, il était intéressant de voir ce que le Blitter peut faire de plus complexe
que de simples transferts rectangulaires.
|
