Pl2 LINEA.DOC/fr
--------------------
CHAPITRE NR°8:
LES LINEAS
--------------------
*** INTRODUCTION ***
--------------------
- Les lineAs sont des fonctions graphiques, elles sont très simples
mais ont l'aventage d'ètres vraiment très rapides.
(Bien plus que le VDI...)
Les LineAs sont des commandes du 'BLITTER', c.à.d. que c'est le HARD
(Certaines composantes PHYSIQUES de l'ordinateur et les routines qui
sont ex‚cut‚es par le PROCESSEUR en personne.) qui ex‚cute ces fonc-
tions et non pas le SOFT (La partie LOGICIELLE de votre ordinateur :
ROM,programmes...).
Si votre ST est equip‚ du BLITTER bien-entendu...(Les MEGA 2ST et les
MEGA 4ST en sont ‚quipp‚s.)
NB: Il existe un BLITTER LOGICIEL qui est disponible dans le domaine
--- public sous la forme d'un accessoir de bureau...
Ces fonctions sont très rapides puisque ne provenant pas du SOFT, les
routines n'ont pas besoin d'ètres interpr‚t‚es par le PROCESSEUR.
- Pour appeller les fonctions des LINEAS, il faudra fournir les para-
mètres appropri‚s dans le TABLEAU du VDI et aussi dans un TABLEAU
INTERNE propre aux lineAs.
Certains registres seront aussi utilis‚s.
En effet, les LineAs utilisent les tableaux CONTROL,PTSIN,PTSOUT,
INTIN et INTOUT du VDI.
On se servira aussi des registres d0,d1,d2,a0,a1,a2 , il faudra donc
faire attention à ne pas perdre leur contenu...
Certains paramètres sont aussi fournis par les LineAs en retour dans
d0,a0 ou INTOUT (là aussi,attention à ne pas perdre d0!)
Nous avons vu que les LineAs utilisent un TABLEAU INTERNE:
C'est dans ce tableau que les fonctions recherchent les paramètres
que nous avons d‚pos‚,le seul problème est que l'emplacement de ce
tableau interne varie (d'o— son nom).
Pour trouver l'emplacement de ce tableau interne, il suffit
d'appeller la fonction $A000 avec:
DC.W $A000
Quelle syntaxe ‚trange n'est ce pas ??
L'explication est très simple:Lors de l'‚tape d'ASSEMBLAGE de votre
listing, les codes ASCII repr‚sentant les instructions et leurs op‚-
randes, vont être traduites en BINAIRE car le 68000 ne reconnait que
les informations cod‚es en binaire:
Ainsi un NOP sera traduit par %100111001110001, un RTS par %0100111
001110101 etc... ainsi pour toutes les instructions.
Si on traduit ces codes du binaire à l'HEXADECIMAL, on obtient des
instructions cod‚s en HEXA:
Ainsi NOP s'‚crira:$4E71
et RTS s'‚crira:$4E75
etc...
Or,
--
On peut REMPLACER, dans un programme en ASSEMBLEUR, une instruction
par son ‚quivalent en CODE HEXA si on le d‚clare en tant que tel dans
le segment TEXT, il suffirait donc d'‚crire:
DC.W $4E71 à la place d'un NOP (ou DC.B $4E,$71)
ou
DC.W $4E75 à la place d'un RTS ... (ou DC.B $4E,$75)
Ceci reste valable pour toutes les instructions du 68000 (Même pour
les labels).
Mais,
----
Aucune instruction du 68000 ne sera cod‚e en HEXA par un MOT du type:
$A... (ou $F...)
On a donc combl‚ se manque (on en a plutot profit‚ oui!) en codant
les fonctions LineAs en $A...
NB:Il existe aussi des routines $F... mais nous ne les utiliseront
-- pas parce qu'elles ne sont pas compatibles entre les versions
ANCIENNE ROM et NOUVELLE ROM du ST.
Il suffira donc d'‚crire DC.W $A... pour que le 68000 d‚code cette
instruction par l'intruction lineA de code $A...
Il existe en tout 16 commandes qui sont install‚es et qui peuvent
ètres traduites ainsi, ce sont les 16 routines LineAs:
Pour les appeller il suffit donc de les DECLARER dans le segment
TEXT:
Les LineAs:
-----------
$A000:Installe le tableau interne
$A001:Place 1 point sur l'‚cran
$A002:Donne la couleur d'un point de l'‚cran
$A003:Trace une ligne quelconque
$A004:Trace une ligne horizontale
$A005:Dessine un rectangle plein
$A006:Dessine un polygone plein
$A007:?
$A008:Permet le transfert d'un bloc de texte
$A009:Active le curseur de la SOURIS
$A00A:D‚sactive le curseur de la SOURIS
$A00B:Modifie la forme du curseur de la SOURIS
$A00C:Efface un sprite
$A00D:Dessine un sprite
$A00E:Copie un bloc de points
$A00F:Identique à la fonction CONTOUR FILL du VDI (opcode=103)
Mais revenons maintenat à notre fonction $A000:
Nous avons vu pr‚c‚dement qu'elle permet d'initialiser le TABLEAU
INTERNE dans lequel on d‚posera des paramètres:
Ce TABLEAU comporte 50 variables qui ont soit la taille d'un MOT
soit la taille d'un L-M.
Pour obtenir l'adresse ou commence le tableau, on se sert de la
fonction $A000:
DC.W $A000
La fonction nous fournit dans A0 l'adresse à laquelle se trouve le
tableau:
On peut donc maintenant atteindre toutes les variables de ce tableau
avec un mode d'adressage du type INDIRECT:
Mais les variables n'ont pas toutes la mème taille (Mot ou L-M), les
modes d'adressage (a0)+ et (a0) ne seront donc pas utilis‚s...
Nous utiliserons le mode d'adressage d(a0) pour atteindre les
diff‚rents paramètres du tableau:
Ainsi MOVE.W 0(a0) posera le MOT=0 dans le 1° paramètre du tableau
MOVE.W 2(a0) posera le MOT=0 dans le paramètre plac‚ à a0+2
etc...
Il faudrait donc connaitre toutes les valeurs des emplacements rela-
tifs des variables dans le tableau:Comme la syntaxe d(a0) n'est pas
très parlante, nous allons d‚finir (avec EQU) les emplacemants rela-
tifs de toutes ces variables:
Les voici:
; D‚finition des EQUIVALANCES du TABLEAU INTERNE des LineAs
; NOM de la valiable = D‚placement relatif
v_planes EQU 0 ;nombre de plans
v_lin_wr EQU 2 ;octet par ligne d'‚criture
ticontrol EQU 4 ;adresse du T.I de CONTROL
tiintin EQU 8 ;adresse du T.I de INTIN
tiptsin EQU 12 ;adresse du T.I de PTSIN
tiintout EQU 16 ;adreses du T.I de INTOUT
tiptsout EQU 20 ;adresse du T.T de PTSOUT
_fg_bp_1 EQU 24 ;bit 0 de la couleur
_fg_bp_2 EQU 26 ;bit 1 de la couleur
_fg_bp_3 EQU 28 ;bit 2 de la couleur
_fg_bp_4 EQU 30 ;bit 3 de la couleur
_lstlin EQU 32 ;toujours =-1
_ln_mask EQU 34 ;forme de la ligne pour $A003
_wrt_mode EQU 36 ;WRITE MODE
_x1 EQU 38 ;Coordonn‚e X du premier point
_y1 EQU 40 ;Coordonn‚e Y du premier point
_x2 EQU 42 ;Coordonn‚e X du second point
_y2 EQU 44 ;Coordonn‚e Y du second point
_patptr EQU 46 ;adresse du remplissage
_patmsk EQU 50 ;nombre de remplissage
_multifill EQU 52 ;d‚tails plus loin
_clip EQU 54 ;drapeau de clipping
_xmn_clip EQU 56 ;X le + à gauche pour le clip
_ymn_clip EQU 58 ;Y le + haut pour le clip
_xmx_clip EQU 60 ;X le + à droite pour le clip
_ymx_clip EQU 62 ;Y le + bas pour le clip
_xacc_dda EQU 64 ;pointe sur $8000 pour TXTBLT
_dda_inc EQU 66 ;facteur d'agrandissement=$FFFF
_t_sclsts EQU 68 ;=0
_mono_status EQU 70 ;type de TEXT EFFECTS
_sourcex EQU 72 ;Nr du caractère dans le JEU
_sourcey EQU 74 ;=0
_destx EQU 76 ;Coordonn‚e X du TEXT
_desty EQU 78 ;Coordonn‚e Y du TEXT
_delx EQU 80 ;Largeur du caractère
_dely EQU 82 ;Hauteur du caractère
_fbase EQU 84 ;Adresse du JEU
_fwidth EQU 88 ;X du JEU
_style EQU 90 ;FLAG pour TEXT EFFECTS
_litemark EQU 92 ;Masque des ombrages
_skewmask EQU 94 ;Masque de l'inclinaison TEXT
_weight EQU 96 ;NB de bits d'‚largissement
_r_off EQU 98 ;D‚calage pour TEXT italique
_l_off EQU 100 ;idem cot‚ gauche (Left)
_scale EQU 102 ;Flag agrandissement (1/0)
_chup EQU 104 ;Angle de rotation du TEXT
_txt_fg EQU 106 ;Couleur du 1° plan du TEXT
_scrtchp EQU 108 ;Adresse d'1 tampon pour effets
_scrpt2 EQU 112 ;D‚calage pour l'agrandissement
_text_bg EQU 114 ;Couleur de Back Ground du TEXT
_copytran EQU 116 ;FLAG pour le mode d'‚criture
On devine ici très clairement la structure et la composition du
TABLEAU INTERNE:
Les noms utilis‚s ici sont des noms souvent pris par d‚faut dans
de nombreux ouvrages.
Nous n'utiliseront qu'une petite partie des variables du tableau
interne...
Les d‚finissions des ‚quivalences pour le TABLEAU INTERNE se trouvent
dans le fichier:LINEQU.L et vous devrez l'inclure dans votre listing
au d‚but du segment TEXT.
L'utilisation des variables d‚pendra des fonctions, les d‚tails
viendront donc avec les explications...
En pratique:
Pour changer la variable '_patptr' du Tableau Interne, il suffira
d'‚crire:
MOVE source,_patptr(a0)
Pour changer la variale '_clip' du Tableau Interne, il suffira
d'‚crire:
MOVE source,_clip(a0)
etc...
C'est bien plus lisible que d'‚crire:
MOVE source,46(a0) ou MOVE source,54(a0) ...
Maintenant que notre tableau interne est mis en place avec DC.W $A000,
il faut encore fournir les adresses des TABLEAUX CONTROL,INTIN,PTSIN,
INTOUT et PTSOUT car eux aussi sont utilis‚s !
Cela se fait tout simplement en d‚posant ces adresses dans les varia-
bles tiintin,tiptsin,tiintout,tiptsout du TABLEAU INTERNE:
Il suffit donc d'‚crire:
MOVE.L #CONTROL,ticontrol(a0)
MOVE.L #INTIN,tiintin(a0)
MOVE.L #PTSIN,tiptsin(a0)
MOVE.L #INTOUT,tiintout(a0)
MOVE.L #PTSOUT,tiptsout(a0)
Pour transfèrer les adresses dans le TABLEAU INTERNE.
Cette initialisation ‚tant faite, vous pouvez enfin vous servir des
routines LineAs.
Tous les programmes que vous ‚crirez devront donc ressembler à cela
si vous utilisez les LINEAS:
TEXT
INCLUDE "INIT_TOS.L"
INCLUDE "LINEQU.L" ;les ‚quivalences pour les LineAs
SETBLOCK ;initialise le GEM
DC.W $A000 ;on initialise le T.I. ( adresse dans a0)
; On pose les adresses des TABLEAUX du VDI dans le T.I.
MOVE.L #CONTROL,ticontrol(a0)
MOVE.L #INTIN,tiintin(a0)
MOVE.L #PTSIN,tiptsin(a0)
MOVE.L #INTOUT,tiintout(a0)
MOVE.L #PTSOUT,tiptsout(a0)
. ;ICI, votre programme
.
.
DATA
. ;ICI les donn‚es
.
.
BSS
.
.
INCLUDE "TABLEAU.L" ;le Tableau du VDI
END
*** Explication des termes utilis‚s plus loin ***
-------------------------------------------------
- Les Coordonn‚es graphiques:
Celles-ci permettent de d‚finir les positions des ‚ditions graphiques
à partir de leurs coordonn‚es sur l'axe X et l'axe Y.
.L'origine du repère orthogonal ( O,x,y ) est situ‚e au point le plus
haut et le plus à gauche de votre ‚cran:il a pour coordonn‚es (0,0).
.L'axe X va de l'origine O au point oppos‚ à droite le plus en
haut de l'‚cran.
.L'axe Y descend de l'origine O au point à droite le plus bas de votre
‚cran.
.Le nombre de points disponibles selon l'axe X et l'axe Y d‚pend de la
r‚solution:
En BASSE r‚solution :(OX)=320 pixels (points) de 0 à 329
---------------- -------- -------
:(OY)=200 pixels (points) de 0 à 199
-------- -------
En MOYENNE r‚solution:(OX)=640 pixels (points) de 0 à 639
------------------ -------- -------
:(OY)=200 pixels (points) de 0 à 199
-------- -------
En HAUTE r‚soltuion :(OX)=640 pixels (points) de 0 à 639
---------------- -------- -------
:(OY)=400 pixels (points) de 0 à 399
-------- -------
ATTENTION à toujours respecter les contraintes graphiques si vous ne
voulez pas avoir de problèmes...
- Le Mode d'‚criture:d‚fini par la variable _wrt_mode du tableau interne:
4 modes d'‚criture sont disponibles:
.SI _wrt_mode=0:Mode AND,
-----------
Exemple:FOND =%111011101110110100
-------:DESSIN=%100011011010100011
--->RESULTAT=%100011011010100011 (On masque le fond)
On obtient:FOND AND DESSIN
.Si _wrt_mode=1:Mode OR,
-----------
Exemple:FOND =%101100011101010011
-------:DESSIN=%011011101110001010
--->RESULTAT=%111111111111011011
On obtient FOND OR DESSIN
.Si _wrt_mode=2:Mode (COULEUR and DESSIN) OR (FOND not DESSIN)
-----------
(C'est le mode graphique TRANSPARENT):
Les points sont plac‚s là o— il n'y en a par encore et si le point à
placer est sans couleur, on efface le point.
.Si _wrt_mode=3:Mode XOR
-----------
Exemple:FOND =%1101100111000101
-------:DESSIN=%0110011101011010
--->RESULTAT=%0110011101111010
Les pixels du FOND sont invers‚s puis on r‚alise un OR avec le DESSIN:
On obtient FOND XOR DESSIN
NB:Le mode graphique utilis‚ par d‚faut est le mode 0
--
- Les 4 _fg_bp_B sont au nombre de 4 et servent à indiquer la couleur
selon le mode suivant:
_fg_bp_1=le 1°er bit de la couleur
_fg_bp_2=le 2°ème bit de la couleur
_fg_bp_3=le 3°ème bit de la couleur
_fg_bp_4=le 4°ème bit de la couleur
Chaque variable ne peut que prendre 1 ou 0 comme valeur.
Ainsi, si on a par exemple:
_fg_bp_1=0
_fg_bp_2=1
_fg_bp_3=1
_fg_bp_4=0
La couleur utilis‚e sera la couleur nr° %0110=6
ATTENTION, n'oubliez pas que vous ne disposez pas du même nombre de
couleurs dans les diff‚rentes r‚solution graphiques.
Ainsi,En BASSE RESOLUTION:
--------------------
Vous pouvez disposer de toutes les variables _fg_bp_B
En MOYENNE RESOLUTION:
----------------------
Vous ne pouvez disposer que des variables _fg_bp_1 et _fg_bp_2.
_fg_bp_3 ainsi que _fg_bp_4 devront ètres ‚gales à 0 car vous ne
diposez que de 4 couleurs.
En HAUTE RESOLUTION:
--------------------
Vous ne pouvez disposer que de la variable _fg_bp_1 car seules 2
couleurs sont diponibles en même temps dans cette r‚solution.
- Le CLIPPING permet de d‚finir les limites dans lesquelles vos graphi-
ques pourront être dessin‚s à l'‚cran.
Il faut pour cela modifier les variables _xmn_clip,_ymn_clip et les
variables _xmx_clip,_ymx_clip du tableau interne:
_xmn_clip et _ymn_clip d‚finisent les coordonn‚es X et Y du coin haut
gauche du CADRE DU CLIPPING.
_xmx_clip et _ymx_clip d‚finissent les coordonn‚es X et Y du coin bas
droit du CADRE DU CLIPPING.
On utilise aussi un DRAPEAU (ou FLAG en Anglais), c.à.d. une variable
qui sera test‚e pour savoir si le CLIPPING est activ‚ ou non ( comme
avec un SEMAPHORE... )
. Si on N'UTILISE PAS le CLIPPING, la variable _clip doit ètre ‚gale à 0
------------------------- ----- -
. Sinon, on positionne le MOT en _clip(a0) dans le tableau interne à une
valeur quelconque.
Exemple:
--------
_clip=1 (diff‚rent de 0, donc le clipping est activ‚)
_xmn_clip=0 , _ymn_clip=0 et
_xmx_clip=50, _ymx_clip=50
Si on trace un rectangle de coordonn‚es de d‚part 10,10 et de
coordonn‚es d'arriv‚e 75,75:
Seule la partie du rectangle de coordonn‚es de d‚part 10,10 et de
coordonn‚es d'arriv‚e 50,50 serra dessin‚e car le reste du rectangle
ne rentre pas dans le CADRE du CLIPPING...
Le CLIPPING permet donc de modifier le 'rayon d'action' des fonctions
graphiques...
NB:D‚passer le CADRE DU CLIPPING n'entraine pas d'erreur, mais les
-- graphiques repr‚sent‚s hors du cadre ne seront pas affich‚s.
- La variable _multifill du tableau interne permet de cr‚er des trames
de remplissage en plusieurs couleurs.(Pour les options de remplissage)
Mous mettrons toujours cette variable à 0 (remplissage monochrome)
Cette variable du tableau interne est utilis‚e avec les fonctions qui
permettent de remplir des surfaces...
- Le PAT (PATERN) sert aux fonctions $A004,$A005,$A006 et permet de
d‚finir le type de ligne et le type de remplissage utilis‚.
Le type normalment utilis‚ par ces fonctions est '%1111111111111111'
(MOTIF PLEIN), modifier le PAT permet de modifier le type de lignes
utilis‚es ainsi que les motifs de remplissages des fonctions $A004,
$A005 et $A006.
Ainsi, si le PAT vaut %1010101010101010 (MOT) et si on utilise la
fonction $A004 par exemple, on tra‡era une ligne en pointill‚s,si
le PAT vaut %1111000011110000 (MOT), on obtiendra des pointill‚s
plus larges et plus espac‚s...
le PAT est d‚finit par 2 variables du tableau interne:
--- -----------------------
. _patptr (L-M), c'est l'adresse à laquelle se trouve un ‚chantillon
de remplissage d‚finit par un nombre PAIRE de MOTS (voir plus loin)
. _patmsk (MOT), contient le nombre de donn‚es (MOTS) à lire -1:
C'est un nombre toujours IMPAIRE (paire-1).
Ainsi, si _patptr pointe sur 'TABLE', en qu'à cette adresse on trouve
les mots:
TABLE DC.W %1111000011110000 ;adresse 'TABLE':le MOTIF
DC.W %0000111100001111
DC.W %1010101010101010
DC.W %0101010101010101 ;nombre PAIRE de MOTS
_patmsk sera ‚gal à 4-1=3
Le MOTIF de remplissage qui sera utilis‚ sera donc un MOTIF d'une largeur
de 16 pixels (les 16 Bits des diff‚rents MOTS,1=bit actif, 0=bit etteind)
et d'une hauteur de 4 lignes (4 MOTS)
NB: La repr‚sentation en BINAIRE des donn‚es est la ici plus parlante.
--
Exemples d'utilisation:
--------
On veut d‚finir des lignes avec de larges pointill‚s:
On modifie le PAT
DC.W $A000 ;a0 pointe sur le T.I.
move.l #TABLE,_patptr(a0) ;pose l'adresse du MOTIF dans _patptr
move #0,_patmsk(a0) ;1-1=0 dans _patmsk
DATA
TABLE DC.W %1111000011110000 ;le MOTIF
On veut obtenir un remplissage avec des petits carr‚s avec la fonction
$A005 (filled rectangle):
On modifie le PAT:
DC.W $A000 ;a0 pointe sur le T.I.
move.l #TABLE,_patptr(a0) ;pose l'adresse du MOTIF dans _patptr
move #5,_patmsk(a0) ;8-1=7 dans _patmsk
DATA
TABLE DC.W %1111111111111111 ;le MOTIF (8 MOTS)
DC.W %1100000000000011
DC.W %1101111111111011 ;0=pixel etteind
DC.W %1101111111111011
DC.W %1101111111111011 ;1=pixel actif
DC.W %1101111111111011
DC.W %1100000000000011
DC.W %1111111111111111
*** LES ROUTINES LINEAS ***
---------------------------
Je vais maitenant d‚crire les routines LINEAS interessantes, je vous
donnerais les exemples après ces explications dans le prochain fichier.
Les exercices viendront ensuite...
- $A000
-----
Fournit dans a0 et d0 l'adresse du tableau interne.
La fonction donne aussi en a1 l'adresse d'un autre tableau qui pointe
sur les 3 jeux de caractères utilis‚s par la routine $A008
On l'appelle par:
DC.W $A000 ;Dans le segment TEXT
;(on peut aussi ‚crire DC.B $A0,$00)
;retour des valeurs dans a0,a1,d0 (attention à ne pas
;perdre ces valeurs, sauvez les au besoin!)
NB:par la suite, avant d'utiliser les autre fonctions, penssez à ini-
-- tialiser les variables ticontrol,tiintin,tiptsin,tiintout,tiptsout
du tableau interne...
- $A001 (PUT PIXEL)
-----
Permet de placer un point de coordonn‚es (X,Y) sur l'‚cran.
Les paramètres à passer sont:
. X dans ptsin
. Y dans ptsin+2
. La couleur du point (0 à 15) dans intin (MOT)
On l'appelle ensuite par:
DC.W $A001 ;Dans le segment TEXT
- $A002 (GET PIXEL)
-----
Cette fonction permet d'obtenir la couleur d'un point de coordonn‚es
(X,Y) de l'‚cran.
Les paramètres à passer sont:
. X dans ptsin
. Y dans ptsin+2
La couleur (MOT de 0 à 15) retourne en INTOUT
On appelle la fonction par:
DC.W $A002 ;Dans le segment TEXT
- $A003 (LINE)
-----
Permet de tracer une ligne quelconque de coordonn‚es de d‚part (A,B)
et de coordonn‚es d'arriv‚e (C,D) sur l'‚cran.
On peut aussi modifier la couleur de la ligne avec les _fg_bp_B, le
type de ligne avec _ln_mask et le mode d'‚criture avec _wrt_mode.
Les paramètres à passer sont:
. A dans _x1
. B dans _y1
. C dans _x2
. D dans _y2
On peut choisir la couleur de la ligne, celle-ci est pass‚e dans
les variables: -------------------
. _fg_bp_B (Bits B utilis‚s suivant la r‚solution)
On peut aussi modifier le type de ligne utilis‚e avec la variable:
-------------------------
. _ln_mask (MOT)
Ainsi,si _ln_mask vaut %111111111111111, la ligne sera pleine, si la
variable vaut %0000111100001111 on obtient des gros pointill‚s etc...
On choisit aussi le MODE d'ECRITURE gràce à la variable:
. _wrt_mode (MOT =0 à 3)
Ensuite, on appelle la fonction par:
DC.W $A003 ;Dans le segment TEXT
- $A004 (H-LINE)
-----
Permet de tracer une ligne horizontale.(Uniquement HORIZONTALE...)
Les coordonn‚es de d‚part sont (A,B) et les coordonn‚es d'arriv‚e
sont (C,D) telles que B=D (ligne horizontale)
On peut , tout comme avec $A003, modifier la couleur de la ligne,le
mode d'‚criture, et le PAT (avec _patptr et _patmsk)
H-LINE est une fonction de base et est utilis‚e par les fonctions
$A003,$A005,$A006:
Une ligne courbe (routine $A003) n'est en effet rien d'autre qu'une
succession de portions de lignes horizontales:
Ceci explique pourquoi H-LINE est plus rapide que LINE.
Les paramètres à passer sont:
. A dans _x1
. B dans _y1
. C dans _x2
. D dans _y2 ; _y1 = _y2 (ligne horizontale)
On peut choisir la couleur de la ligne, celle-ci est pass‚e dans
les variables: -------------------
. _fg_bp_B (Bits B utilis‚s suivant la r‚solution)
On peut aussi modifier le type de ligne utilis‚e avec les variables:
-------------------------
. _patptr (L-M):l'adresse du MOTIF
. _patmsk (MOT):le nombre de donn‚es -1
On choisit aussi le MODE d'ECRITURE gràce à la variable:
. _wrt_mode (MOT =0 à 3)
On appelle la fonction par:
DC.W $A004 ;Dans le segment TEXT
- $A005 (FILLED RECTANGLE)
-----
Permet de remplir un rectangle de coordonn‚es (A,B) pour le coin haut
gauche et (C,D) pour le coin bas droit.
On peut modifier la couleur du rectangle, le type de remplissage et
le mode d'‚criture.
La fonction utilise aussi le CLIPPING si vous le d‚sirez.
En fait, la fonction $A005 utilise la fonction $A004 pour dessiner
le rectangle...
Les paramètres à passer sont:
. A dans _x1
. B dans _y1
. C dans _x2
. D dans _y2
On peut choisir la couleur du rectangle, celle-ci est pass‚e dans
les variables: --------------------
. _fg_bp_B (Bits B utilis‚s suivant la r‚solution)
On peut aussi modifier le type de PAT utilis‚ avec les variables:
----------------------
. _patptr (L-M):l'adresse du MOTIF
. _patmsk (MOT):le nombre de donn‚es -1
On choisit aussi le MODE d'ECRITURE gràce à la variable:
. _wrt_mode (MOT =0 à 3)
Ainsi que le CADRE du CLIPPING avec les coordonn‚es
. _xmn_clip ;X haut gauche
. _ymn_clip ;Y haut gauche
. _xmx_clip ;X bas droit
. _ymn_clip ;Y bas droit
et
. _clip ;0 si inutilis‚
On appelle la fonction par:
DC.W $A005 ;Dans le segment TEXT
- $A006 (FILLED POLYGONE)
-----
Permet de dessiner un POLYGONE (Une figure g‚om‚trique à N cot‚s).
$A006 utilise la fonction de base $A004 (H-LINE).
On peut modifier la couleur du polygone, le type de remplissage et
le mode d'‚criture.
La fonction utilise aussi le CLIPPING si vous le d‚sirez.
Les paramètres à fournir sont:
. sptsin contient le nombre de sommets de votre polygone.
------ -----------------
Dans le tableau ptsin , on place les coordonn‚es des N sommets du
polygone (des MOTS),il faudra obligatoirement ternimer votre tab-
leau par les coordonn‚es du 1° sommet pour boucler la figure.
. Dans ptsin, la coordonn‚e X du 1° sommet
----- - ---------
. Dans ptsin+2, la coordonn‚e Y du 1° sommet
------- - ---------
.
.
.
. Dans ptsin+Z, la coordonn‚e X du N° sommet
------- - ---------
. Dans ptsin+(Z+2), la coordonn‚e Y du N° sommet
----------- - ---------
. Dans ptsin+(Z+4), la coordonn‚e X du 1° sommet
----------- - ---------
. Dans ptsin+(Z+6), la coordonn‚e Y du 1 ° sommet
----------- - ----------
On peut choisir la couleur du polygone, celle-ci est pass‚e dans
les variables: -------------------
. _fg_bp_B (Bits B utilis‚s suivant la r‚solution)
On peut aussi modifier le type de PAT utilis‚ avec les variables:
----------------------
. _patptr (L-M):l'adresse du MOTIF
. _patmsk (MOT):le nombre de donn‚es -1
On choisit aussi le MODE d'ECRITURE gràce à la variable:
. _wrt_mode (MOT =0 à 3)
Ainsi que le CADRE du CLIPPING avec les coordonn‚es
. _xmn_clip ;X haut gauche
. _ymn_clip ;Y haut gauche
. _xmx_clip ;X bas droit
. _ymn_clip ;Y bas droit
et
. _clip ;0 si inutitilis‚
On appelle la fonction d'une manière très particulière:
------------------------------------------------------
En effet, après avoir introduit tous les paramètres dont vous avez
besoin, il faudra utiliser la routine $A006 POUR CHAQUE LIGNE de
votre polygone.
C.à.d. qu'il faudra utiliser $A006 plusieurs fois, pour qu'à chaque
ligne HORIZONTALE qui compose votre polygone les droites comprises
dans l'espace d‚finissant le polygone soient affich‚es.
En effet, $A006 utilise la routine H-LINE mais ne trace que les lignes
(dont vous fournissez l'ordonn‚e en paramètre) qui rentrent dans le po-
lygone d‚finit pr‚c‚dement.
L'ordonn‚e de la ligne du polygone à tracer doit ètre pass‚e dans _Y1.
-------- ----------- ----
En utilisant $A006 dans une boucle qui fait varier _y1 , on oppèrera
un balayage de l'‚cran et les diff‚rentes lignes qui composent le po-
lygone s'afficheront à chaque appel de la fonction.
On appelle la fonction par:
DC.W $A006 ;Dans le segment TEXT:
Dans une boucle o— l'on fait varier _y1 (0 à 199 pour BASSE et MOYENNE
r‚solution, 0 à 399 pour le HAUTE r‚solution)
Il n'est bien entendu pas utile de balayer tout l'‚cran avec $A006 pour
afficher le polygone d‚finit, seules les lignes qui contiennent effecti-
vement le polygone doivent être trac‚es...
Exemple d'utilisation:
---------------------
Vous voulez tracer un CARRE de coordonn‚es de d‚part (0,0) et d'une
largeur de 20 pixels (Donc aussi d'une hauteur de 20 pixels puisque
c'est un carr‚...)
On met:
. 4 dans sptsin :Les 4 sommets du carr‚
Les coordonn‚es des sommets dans PTSIN:
. 0 dans ptsin (0,0) : 1° sommet
. 0 dans ptsin+2
. 19 dans ptsin+4 (19,0) : 2° sommet
. 0 dans ptsin+6
. 19 dans ptsin+8 (19,19): 3° sommet
. 19 dans ptsin+10
. 0 dans ptsin+12 (0,19) : 4° sommet
. 19 dans ptsin+14
. 0 dans ptsin+16 (0,0) : pour boucler la figure
. 0 dans ptsin+18
On appelle la routine $A006 à chaque ligne horizontale du polygone
pour afficher la portion de droite qui rentre dans le carr‚:
Notre carr‚ a une hauteur de 20 lignes (de 0 à 19)
On fait varier _y1 pour ces 20 lignes et on appelle $A006 pour
chacunes d'elles.
move #0,d0 ;0 dans d0
BOUCLE move d0,_y1(a0) ;Ordonn‚es des 20 lignes du carr‚ de d0
;dans _y1
DC.W $A006 ;On trace la portion de H-LINE qui rentre
;dans le carr‚ pr‚d‚finit
add #1,d0 ;On ajoute 1 à d0
cmpi #20,d0 ;A-t-on d0 = 19+1=20 ?
bne BOUCLE ;Non ? Alors on recommence avec d0=d0+1
- $A009 (SHOW MOUSE)
-----
Permet de r‚afficher le curseur de la souris après avoir utilis‚ la
fonction $A00A (HIDE MOUSE).
En r‚alit‚, l'appel de cette fonction incr‚mente un compteur interne
et si celui est vaut 0, le curseur de la souris r‚apparait.
Comme la fonction $A00A (HIDE MOUSE) d‚cr‚mente le compteur à chaque
appel, il faudra utiliser la fonction $A009 N fois si on a utilis‚
la fonction HIDE MOUSE N fois pr‚c‚dement...
Les paramètres à passer sont:
0 dans sptsin
1 dans sintin
On appelle la fonction par:
DC.W $A009 ;Dans le segment TEXT
NB:Il existe une manière très simple d'‚viter de s'embrouiller avec
-- le compteur de HIDE et SHOW MOUSE, si on place 0 dans INTIN avant
d'utiliser $A009, le compteur sera mis à 0 et le curseur de la
souris r‚apparaitra toujours.
- $A00A (HIDE MOUSE)
-----
C'est la fonction compl‚mentaire de la fonction $A009 et elle permet
de faire dispparaitre le curseur de la souris de l'‚cran.
$A00A d‚cr‚mente le compteur vu pr‚c‚dement d'1 unit‚ à chaque appel...
Mais ATTENTION à l'utilisation de cette fonction:
En effet, HIDE MOUSE indique à l'ordi. qu'au prochain raffraichissement
de l'‚cran, le curseur de la souris doit dispparaitre et ENSUITE que ce
qui est sous la position actuelle du curseur doit être r‚affich‚.
(Voir le chapitre sur le VBL plus loin)
Seulement, pendant le temps d'ex‚cution de la fonction, l'utilisateur
peut bouger la souris et ceci provoquerai l'apparition d'un TROU rec-
tangulaire à la place de la partie de l'‚cran qui devait ètre restaur‚e.
Il faudra donc utiliser HIDE MOUSE avant d'‚ffacer votre ‚cran, mais
jamais lorsque la souris peut se trouver sous des graphimes.
$A00A n'admet pas de paramètres, pour l'appeller , on ‚crit:
DC.W $A00A ;Dans le segment TEXT
- $A00C (UNDRAW SPRITE)
-----
Permet d'‚ffacer un SPRITE d‚finit par la routine compl‚mentaire $A00D.
Les SPRITES que nous allons pouvoir dessiner sont pudiquement appell‚s
SPRITES ATARI:Ce sont des dessins d'une hauteur et d'une largeur de 16
pixels et ils sont monochromes ( Couleur du FOND et couleur du DESSIN
uniquement ).:Comme le curseur de la souris par exemple...
Le SPRITE pourra ensuite ètre affich‚ sur l'‚cran aux coordonn‚es que
vous indiquerez sans avoir à le red‚finir.
Mais il faudra d'abord d‚finir le SPRITE lui mème, il se d‚finit par:
. Un premier plan:C.à.d. le dessin du SPRITE (la flèche de la souris...)
. Un Masque:Ou encore un arrière plan qui permet d'entourer le dessin
d'une couleur de telle fa‡on qu'il reste toujours visible,
mème sur une dessin de même couleur que le premier plan.
. 2 couleurs diff‚rentes:Pour le premier plan et le masque
. Un point chaud:C'est à partir de ce point qu'on d‚finit les coordon‚es
du SPRITE.
Le point chaud de la flèche de la souris se trouve par
exemple sur la pointe de la flèche:C'est le point d'ac-
tion du curseur et il ne peut pas sortir de l'‚cran.
. Un format:VDI (mode graphique AND) ou XOR (mode XOR)
Toutes ces donn‚es devront être d‚finies avec $A00D (DRAW SPRITE), pour
effacer un SPRITE dejà d‚finit, on passe le paramètre suivant à $A00C :
Paramètre de UNDRAW SPRITE:
. Adresse du tampon de sauvegarde du SPRITE dans a2
et on appelle la fonction par:
DC.W $A00C ;Dans le segment TEXT
- $A00D (DRAW SPRITE)
-----
Permet de d‚finir et d'afficher un SPRITE.
Les paramètres à passer à $A00D sont:
. Coordonn‚e X du SPRITE dans d0
. Coordonn‚e Y du SPRITE dans d1
. Adresse du bloc de d‚finition du SPRITE dans a0
Ce bloc a une taille de 74 Octets et doit ètre organis‚ comme il suit:
Adresse: valeur (MOTs)
a0 Coordonn‚e relative X pour le point chaud
a0+2 Coordonn‚e relative Y pour le point chaud
a0+4 Le format (0 pour VDI,1 pour XOR)
a0+6 La couleur du masque
a0+8 La couleur du premier plan
a0+10 16 bits qui d‚finissent la 1° ligne du masque
a0+12 16 bits qui d‚finissent la 1° ligne du premier plan
a0+14 idem pour la 2° ligne du masque
a0+16 idem pour la 2° ligne du premier plan
.
.
.
a0+70 idem pour la 16° ligne du masque
a0+72 idem pour la 16° ligne du premier plan
Ainsi, si on veut dessiner un SPRITE qui repr‚sente un 1, les donn‚es
qui d‚finissent le dessin du sprite seront par exemple:
DC.W %0000000000000000 ;0 = pas de point
DC.W %0000000000000000 ;1 = pixel actif
DC.W %0000000010000000
DC.W %0000000110000000
DC.W %0000011110000000
DC.W %0000111110000000
DC.W %0000000110000000
DC.W %0000000110000000
DC.W %0000000110000000
DC.W %0000000110000000
DC.W %0000000110000000
DC.W %0000000110000000
DC.W %0001111111110000
DC.W %0000000000000000
DC.W %0000000000000000
DC.W %0000000000000000
Le SPRITE a une taille de 16 pixels (16 colonnes ) et de 16 lignes.
On utilise ici la notation en BINAIRE car c'est la plus lisible.
Les donn‚es du masque seront:
DC.W %*000000000000000 ;0 = pas de point
DC.W %0000000010000000 ;1 = pixel actif
DC.W %0000000111000000 ;* = point chaud (ATTENTION:=0)
DC.W %0000001111000000
DC.W %0000111111000000
DC.W %0001111111000000
DC.W %0000001111000000
DC.W %0000001111000000
DC.W %0000001111000000
DC.W %0000001111000000
DC.W %0000001111000000
DC.W %0011111111111000
DC.W %0011111111111000
DC.W %0011111111111000
DC.W %0000000000000000
DC.W %0000000000000000
On choisit aussi le point chaud, je l'ai not‚ * dans les donn‚es du
masque, ATTENTION, le * n'est là que pour vous indiquer clairement
o— j'ai plac‚ le point chaud, il occupe la place d'un BIT nul et le
* n'a en r‚alit‚ rien à faire dans ces donn‚es...
Dans mon exemple: le point chaud not‚ * a les coordonn‚es:(0,0)
Notre bloc de d‚finition pour $A00D peut donc ètre repr‚sent‚ ainsi
suivant cet exemple:
Si a0 pointe le bloc de d‚finition et si le SPRITE est au format VDI
,que le premier plan à la couleur 0 et le masque la couleur 1:
En On doit avoir:
-- --------------
a0 0:Coordonn‚e relative X pour le point chaud
a0+2 0:Coordonn‚e relative Y pour le point chaud
a0+4 0:Le format (0 pour VDI,1 pour XOR)
a0+6 1:La couleur du masque
a0+8 0:La couleur du premier plan
a0+10 %0000000000000000 :MOT du masque pour ligne 1
a0+12 %0000000000000000 :MOT du premier plan pour ligne 1
a0+14 %0000000010000000 :MOT du masque pour ligne 2
a0+16 %0000000000000000 :MOT du premier plan pour ligne 2
a0+18 %0000000111000000 etc...
a0+20 %0000000010000000
a0+22 %0000001111000000
a0+24 %0000000110000000
a0+26 %0000111111000000
a0+28 %0000011110000000
a0+30 %0001111111000000
a0+32 %0000111110000000
a0+34 %0000001111000000
a0+36 %0000000110000000
a0+38 %0000001111000000
a0+40 %0000000110000000
a0+42 %0000001111000000
a0+44 %0000000110000000
a0+46 %0000001111000000
a0+48 %0000000110000000
a0+50 %0000001111000000
a0+52 %0000000110000000
a0+54 %0011111111111000
a0+56 %0000000110000000
a0+58 %0011111111111000
a0+60 %0001111111110000
a0+62 %0011111111111000
a0+64 %0000000000000000
a0+66 %0000000000000000
a0+68 %0000000000000000
a0+70 %0000000000000000 :MOT du masque de la 16° ligne
a0+72 %0000000000000000 :MOT du premier plan de la 16° ligne
Mais revenons à notre fonction $A00D (DRAW SPRITE):
Il reste encore 1 paramètre à fournir:
. L'adresse d'un tampon de sauvegarde pour le SPRITE dans a2
Ce tampon doit avoir une taille de :
. 266 octets pour la basse r‚solution
. 138 octets pour la moyenne r‚solution
. 74 octets pour la haute r‚solution
(La taille augmente avec le nombre de couleurs disponibles)
Par la suite, il suffira d'apeller la fonction avec:
DC.W $A00D ;Dans le segment TEXT
- $A00B (TRANSFORM MOUSE)
-----
Permet de transformer la forme du curseur de la souris.
J'ai gard‚ cette routine pour la fin parce que vous la comprendrez
plus facilement après avoir vu DRAW SPRITE.
Les paramètres qui d‚finissent le nouveau curseur de la souris devront
ètres transf‚r‚es dans INTIN.
On devra y d‚poser 34 MOTS:
Dans On devra trouver:
INTIN+6 :La couleur du masque (MOT)
INTIN+8 :La couleur du premier plan (MOT)
de INTIN+10 :Les donn‚es d‚finissant
à INTIN+40 :le MASQUE (16 MOTS)
de INTIN+42 :Les donn‚es d‚finissant
à INTIN+64 :le PREMIER PLAN (16 MOTS)
La manipulation de $A00B est donc beaucoup plus ais‚e que celle de
DRAW SPRITE car ici les donn‚es d‚finissant le MASQUE et le PREMIER
PLAN n'ont pas besoin d'ètres altern‚es...
On d‚finit les donn‚es du MASQUE et du PREMIER PLAN identiquement
à celles de la fonction DRAW SPRITE.
Vu l'organisation des variables dans le tableau INTIN:
On pourra d‚poser les donn‚es du masque PUIS les donn‚es du premier
plan avec un mode d'adressage ad‚quate ( (an)+ ...) dans le tableau
INTIN... (ouf!!)
On appelle la fonction par:
DC.W $A00B ;Dans le segment TEXT
-----------------
Voilà pour la th‚orie, relisez très attentivement tout ce qui a ‚t‚
dit ici, notez le sur une fiche si besoin est...
Dans le chapitre suivant, vous allez utiliser les LineAs dans de
nombreux exercices o— toutes les routines importantes seront
utilis‚es et mises en valeur.
PIECHOCKI Laurent
8, impasse Bellevue SUITE dans le fichier:EXOS_3.DOC
57980 TENTELING ----------
Back to ASM_Tutorial