-------------------- 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'HEXADÉCIMAL, 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 DÉCLARER 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 RÉSOLUTION: -------------------- Vous pouvez disposer de toutes les variables _fg_bp_B En MOYENNE RÉSOLUTION: ---------------------- 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 RÉSOLUTION: -------------------- 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'ÉCRITURE 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'ÉCRITURE 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'ÉCRITURE 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'ÉCRITURE 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 CARRÉ 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 ----------