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