Pl2 LINEA.DOC/fr

Languages:

English  • français

                           --------------------
                              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