home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti5 / lezione9h3.s < prev    next >
Text File  |  1995-10-23  |  8KB  |  245 lines
  1.  
  2. ; Lezione9h3.s    Facciamo apparire un immagine una colonna di pixel alla volta
  3. ;        Tasto destro per eseguire la blittata, sinistro per uscire.
  4.  
  5.     SECTION    CiriCop,CODE
  6.  
  7. ;    Include    "DaWorkBench.s"    ; togliere il ; prima di salvare con "WO"
  8.  
  9. *****************************************************************************
  10.     include    "startup1.s"    ; Salva Copperlist Etc.
  11. *****************************************************************************
  12.  
  13.         ;5432109876543210
  14. DMASET    EQU    %1000001111000000    ; copper,bitplane,blitter DMA
  15.  
  16.  
  17. START:
  18.  
  19.     MOVE.L    #BITPLANE,d0    ; dove puntare
  20.     LEA    BPLPOINTERS,A1    ; puntatori COP
  21.     MOVEQ    #3-1,D1        ; numero di bitplanes (qua sono 3)
  22. POINTBP:
  23.     move.w    d0,6(a1)
  24.     swap    d0
  25.     move.w    d0,2(a1)
  26.     swap    d0
  27.     ADD.L    #40*256,d0        ; + LUNGHEZZA DI UNA PLANE !!!!!
  28.     addq.w    #8,a1
  29.     dbra    d1,POINTBP
  30.  
  31.     lea    $dff000,a5        ; CUSTOM REGISTER in a5
  32.     MOVE.W    #DMASET,$96(a5)        ; DMACON - abilita bitplane, copper
  33.     move.l    #COPPERLIST,$80(a5)    ; Puntiamo la nostra COP
  34.     move.w    d0,$88(a5)        ; Facciamo partire la COP
  35.     move.w    #0,$1fc(a5)        ; Disattiva l'AGA
  36.     move.w    #$c00,$106(a5)        ; Disattiva l'AGA
  37.     move.w    #$11,$10c(a5)        ; Disattiva l'AGA
  38.  
  39. mouse1:
  40.     btst    #2,$dff016    ; tasto destro del mouse premuto?
  41.     bne.s    mouse1        ; se no, aspetta
  42.  
  43.     bsr.s    Mostra        ; esegui la routine
  44.  
  45. mouse2:
  46.     btst    #6,$bfe001    ; tasto sinistro del mouse premuto?
  47.     bne.s    mouse2        ; se no, torna a mouse2:
  48.  
  49.     rts
  50.  
  51.  
  52. ; ************************ LA ROUTINE CHE MOSTRA LA FIGURA *******************
  53.  
  54. ;         .øØØØØØø.
  55. ;         |¤¯_ _¬¤|
  56. ;        _|___ ___|_
  57. ;       (_| (·T.) l_)
  58. ;        /  ¯(_)¯  \
  59. ;       /____ _ ____\
  60. ;      //    Y Y    \\
  61. ;     //__/\_____/\__\\ xCz
  62. ;    (_________________)
  63.  
  64. Mostra:
  65.  
  66. ; valori iniziali dei puntatori
  67.  
  68.     lea    picture,a0        ; punta all'inizio della figura
  69.     lea    bitplane,a1        ; punta all'inizio del primo bitplane
  70.  
  71.     moveq    #20-1,d7        ; esegui per ogni "colonna" di word.
  72.                     ; lo schermo e` largo 20 word, quindi
  73.                     ; ci sono 20 colonne.
  74.  
  75. FaiTutteLeWord:
  76.     moveq    #16-1,d6        ; 16 pixel per ogni word.
  77.     move.w    #%1000000000000000,d0    ; valore della maschera all'inizio del
  78.                     ; loop interno. Fa passare solo il
  79.                     ; pixel piu` a sinistra della word.
  80. FaiUnaWord:
  81.  
  82. ; aspetta il vblank in modo da disegnare una colonna di pixel ad ogni
  83. ; fotogramma.
  84.  
  85. WaitWblank:
  86.     CMP.b    #$ff,$dff006        ; vhposr - aspetta la linea 255
  87.     bne.s    WaitWblank
  88. Aspetta:
  89.     CMP.b    #$ff,$dff006        ; vhposr - ancora linea 255 ?
  90.     beq.s    Aspetta
  91.  
  92.     moveq    #3-1,d5            ; ripeti per ogni plane
  93.  
  94.     move.l    a0,a2            ; copia i puntatori in altri 2 registri
  95.     move.l    a1,a3            ; questo perche` all'interno del loop
  96.                     ; che disegna i vari plane devono
  97.                     ; modificare per puntare da un plane
  98.                     ; all'altro.
  99.  
  100. FaiUnPlane:
  101.     btst    #6,2(a5)        ; aspetta che il blitter finisca
  102. waitblit:
  103.     btst    #6,2(a5)
  104.     bne.s    waitblit
  105.  
  106.     move.l    #$09f00000,$40(a5)    ; BLTCON0 e BLTCON1 - copia da A a D
  107.     move.w    #$ffff,$44(a5)        ; BLTAFWM - fa passare tutti i bit
  108.     move.w    d0,$46(a5)        ; Carica il valore della maschera nel
  109.                     ; registro BLTALWM
  110. ; carica i puntatori
  111.  
  112.     move.l    a2,$50(a5)        ; bltapt
  113.     move.l    a3,$54(a5)        ; bltdpt
  114.  
  115. ; Sia per la sorgente che per la destinazione blittiamo una word appartenente
  116. ; ad uno schermo largo 20 word. Il modulo quindi vale 2*(20-1)=38=$26.
  117. ; Poiche` i 2 registri hanno indirizzi consecutivi, si puo` usare una sola
  118. ; istruzione invece che 2:
  119.  
  120.     move.l #$00260026,$64(a5)    ; bltamod e bltdmod 
  121.  
  122. ; blittiamo una "colonna" di word alta 256 righe (tutto lo schermo)
  123.  
  124.     move.w    #(256*64)+1,$58(a5)    ; bltsize
  125.                     ; altezza 256 linee
  126.                     ; larghezza 1 word
  127.  
  128.     lea    40*256(a2),a2        ; punta al prossimo plane sorgente
  129.     lea    40*256(a3),a3        ; punta al prossimo plane destinazione
  130.  
  131.     dbra    d5,FaiUnPlane        ; ripeti per tutti i planes
  132.  
  133.     asr.w    #1,d0            ; calcola la maschera per la prossima
  134.                     ; blittata. Fa passare ogni volta un
  135.                     ; bit in piu` rispetto alla volta
  136.                     ; precedente.
  137.  
  138.     dbra    d6,FaiUnaWord        ; ripeti per tutti i pixel
  139.     
  140.     addq.w    #2,a0            ; punta alla word seguente
  141.     addq.w    #2,a1            ; punta alla word seguente
  142.  
  143.     dbra    d7,FaiTutteLeWord    ; ripeti per tutte le word
  144.  
  145.     btst    #6,$02(a5)    ; dmaconr - aspetta che il blitter finisca
  146. waitblit2:
  147.     btst    #6,$02(a5)
  148.     bne.s    waitblit2
  149.  
  150.     rts
  151.  
  152. ;****************************************************************************
  153.  
  154.     SECTION    GRAPHIC,DATA_C
  155.  
  156. COPPERLIST:
  157.     dc.w    $8E,$2c81    ; DiwStrt
  158.     dc.w    $90,$2cc1    ; DiwStop
  159.     dc.w    $92,$38        ; DdfStart
  160.     dc.w    $94,$d0        ; DdfStop
  161.     dc.w    $102,0        ; BplCon1
  162.     dc.w    $104,0        ; BplCon2
  163.     dc.w    $108,0        ; VALORE MODULO = 0
  164.     dc.w    $10a,0        ; ENTRAMBI I MODULI ALLO STESSO VALORE.
  165.  
  166.     dc.w    $100,$3200    ; bplcon0 - 3 bitplanes lowres
  167.  
  168. BPLPOINTERS:
  169.     dc.w $e0,$0000,$e2,$0000    ;primo     bitplane
  170.     dc.w $e4,$0000,$e6,$0000
  171.     dc.w $e8,$0000,$ea,$0000
  172.  
  173.     dc.w    $0180,$000    ; color0
  174.     dc.w    $0182,$475    ; color1
  175.     dc.w    $0184,$fff    ; color2
  176.     dc.w    $0186,$ccc    ; color3
  177.     dc.w    $0188,$999    ; color4
  178.     dc.w    $018a,$232    ; color5
  179.     dc.w    $018c,$777    ; color6
  180.     dc.w    $018e,$444    ; color7
  181.  
  182.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  183.  
  184. ;****************************************************************************
  185.  
  186. PICTURE:
  187.     incbin    "assembler2:sorgenti6/amiga.raw"
  188.                     ; qua carichiamo la figura in
  189.                     ; formato RAWBLIT (o interleaved),
  190.                     ; convertita col KEFCON.
  191.  
  192. ;****************************************************************************
  193.  
  194.     section    gnippi,bss_C
  195.  
  196. bitplane:
  197.         ds.b    40*256    ; 3 bitplanes
  198.         ds.b    40*256
  199.         ds.b    40*256
  200.     end
  201.  
  202. ;****************************************************************************
  203.  
  204. In questo esempio vediamo un nuovo effetto ottenuto grazie ad una maschera.
  205. Disegnamo un'immagine sullo schermo una colonna di pixel per volta partendo
  206. da destra. In pratica dobbiamo copiare sullo schermo l'immagine una "colonna"
  207. di pixel alla volta. La larghezza minima di una blittata, pero` e` di una
  208. word, pari a 16 pixel. Quindi se eseguissimo semplici copie, potremmo solo
  209. copiare gruppi di 16 pixel. Fortunatamente, pero` ci sono le maschere.
  210. Facendo blittate larghe una word, entrambe le maschere si applicano alla
  211. word blittata. A noi comunque ne basta una, per esempio BLTALWM (sarebbe
  212. comunque la stessa cosa se usassimo BLTAFWM). Il trucco e` questo:
  213. copiamo la stessa colonna di 1 word 16 volte, ogni volta nella stessa posizione
  214. dello schermo e ogni volta cambiamo la maschera in modo da far vedere una
  215. colonna di pixel in piu`.
  216. In pratica, la prima volta facciamo la copia con la maschera al valore
  217. %1000000000000000 in modo da far vedere solo la prima colonna di pixel.
  218. La seconda blittata avviene nella stessa posizione della precedente, quindi
  219. sovrascrive quello che abbiamo disegnato la prima volta. Come maschera usiamo
  220. il valore %1100000000000000, in modo che si vedranno solo le prime 2 colonne
  221. di pixel. La terza volta usiamo come maschera %1110000000000000 e disegnamo
  222. le prime 3 colonne di pixel, e cosi` via. La 16-esima volta usiamo come 
  223. maschera %1111111111111111 in modo da disegnare tutte e 16 le colonne di pixel
  224. che compongono la colonna di word. A questo punto dobbiamo iniziare a disegnare
  225. la prima colonna di pixel della colonna di word seguente, pertanto ci spostiamo
  226. di una word a destra, sia nella sorgente che nella destinazione e ricominciamo
  227. con la maschera al valore %1000000000000000. Poiche` le nostre blittate sono
  228. larghe solo una word, non sovrascriveremo la colonna di word precedente che 
  229. pertanto rimane disegnata.
  230. Notate il modo in cui sono ottenuti i valori della maschera.  All'inizio si
  231. mette il valore di partenza (%1000000000000000) nel registro D0. Tale registro
  232. viene copiato in BLTALWM, in modo che la prima blittata faccia passare solo
  233. la prima colonna di pixel. Dopo la blittata viene eseguita una ASR #1,D0.
  234. Questa istruzione, come sapete, effettua uno shift verso destra del contenuto
  235. del registro D0. Inoltre (a differenza della LSR) conserva il segno, cioe`
  236. fa entrare da sinistra un bit dello stesso valore di quello che era il bit
  237. piu` a sinistra (cioe` il bit di segno) prima della shiftata. In questo caso,
  238. il bit di segno vale 1, pertanto da sinistra entra un'altro 1. In questo modo 
  239. il registro D0 assume il valore %1100000000000000. Questo valore viene usato
  240. come maschera per la seconda blittata, e poi viene eseguita un'altra ASR
  241. che porta D0 al valore %1110000000000000. Questo meccanismo viene ripetuto
  242. ad ogni iterazione, generando tutti i valori della maschera.
  243. Per ulteriori chiarimenti sulla ASR consultate la lezione 68000-2.TXT.
  244.  
  245.