home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti5 / lezione9f2.s < prev    next >
Text File  |  1995-10-23  |  11KB  |  321 lines
  1.  
  2. ; Lezione9f2.s    Scrittura caratteri col blitter
  3.  
  4.     SECTION    CiriCop,CODE
  5.  
  6. ;    Include    "DaWorkBench.s"    ; togliere il ; prima di salvare con "WO"
  7.  
  8. *****************************************************************************
  9.     include    "startup1.s"    ; Salva Copperlist Etc.
  10. *****************************************************************************
  11.  
  12.         ;5432109876543210
  13. DMASET    EQU    %1000001111000000    ; copper,bitplane,blitter DMA
  14.  
  15.  
  16. START:
  17.  
  18. ;    Puntiamo la PIC "vuota"
  19.     MOVE.L    #BITPLANE,d0    ; dove puntare
  20.     LEA    BPLPOINTERS,A1    ; puntatori COP
  21.     MOVEQ    #2-1,D1        ; numero di bitplanes (qua sono 2)
  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 bitplane (qua e' alto 256 linee)
  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.     LEA    TESTO(PC),A0    ; Indirizzo del testo da stampare in a0
  40.     LEA    BITPLANE,A3    ; Indirizzo del bitplane destinazione in a3
  41.     bsr.w    Stampa        ; Stampa le linee di testo sullo schermo
  42.  
  43.     LEA    TESTO2(PC),A0    ; Indirizzo del testo da stampare in a0
  44.     LEA    BITPLANE2,A3    ; Indirizzo del bitplane destinazione in a3
  45.     bsr.w    Stampa        ; Stampa le linee di testo sullo schermo
  46.  
  47. mouse:
  48.     btst    #6,$bfe001    ; tasto sinistro del mouse premuto?
  49.     bne.s    mouse        ; se no, torna a mouse:
  50.  
  51.     rts
  52.  
  53.  
  54. ;***************************************************************************
  55. ;    Routine che stampa caratteri larghi 16x20 pixel
  56. ;
  57. ;    A0 = punta alla mappa che contiene i caratteri da stampare
  58. ;    A3 = punta al bitplane su cui stampare
  59. ;***************************************************************************
  60.  
  61. ;    ........................
  62. ;    :     .______.         :
  63. ;    :     l_  _ ¬l    xCz  ¦
  64. ;    ¦     C©)(®) ·)        |
  65. ;    |     l¯C.   T .       |
  66. ;    |    __¯¯¯¯) l ::.     |
  67. ;    |   (__¯¯¯¯__) ::::.   |
  68. ;    ¦    __T¯¯T__  ::::::. |
  69. ;    `---/  `--'  \---------'
  70. ;        ¯¯¯¯¯¬¯¯¯¯
  71.  
  72. STAMPA:
  73.     MOVEQ    #10-1,D3    ; NUMERO RIGHE DA STAMPARE: 10
  74.  
  75. PRINTRIGA:
  76.     MOVEQ    #20-1,D0    ; NUMERO COLONNE PER RIGA: 20
  77.  
  78. PRINTCHAR2:
  79.     MOVEQ    #0,D2        ; Pulisci d2
  80.     MOVE.B    (A0)+,D2    ; Prossimo carattere in d2
  81.     SUB.B    #$20,D2        ; TOGLI 32 AL VALORE ASCII DEL CARATTERE, IN
  82.                 ; MODO DA TRASFORMARE, AD ESEMPIO, QUELLO
  83.                 ; DELLO SPAZIO (che e' $20), in $00, quello
  84.                 ; DELL'ASTERISCO ($21), in $01...
  85.     ADD.L    D2,D2        ; MOLTIPLICA PER 2 IL NUMERO PRECEDENTE,
  86.                 ; perche` ogni carattere e` largo 16 pixel.
  87.                 ; In questo modo troviamo l'offset.
  88.     MOVE.L    D2,A2
  89.  
  90.     ADD.L    #FONT,A2    ; TROVA IL CARATTERE DESIDERATO NEL FONT...
  91.  
  92.     btst    #6,$02(a5)    ; aspetta che il blitter finisca
  93. waitblit:
  94.     btst    #6,$02(a5)
  95.     bne.s    waitblit
  96.  
  97.     move.l    #$09f00000,$40(a5)    ; BLTCON0: copia da A a D
  98.     move.l    #$ffffffff,$44(a5)    ; BLTAFWM e BLTALWM li spieghiamo dopo
  99.  
  100.     move.l    a2,$50(a5)    ; BLTAPT: indirizzo font (sorgente A)
  101.     move.l    a3,$54(a5)    ; BLTDPT; indirizzo bitplane (destinazione D)
  102.     move    #120-2,$64(a5)    ; BLTAMOD: modulo font
  103.     move    #40-2,$66(a5)    ; BLTDMOD: modulo bit planes
  104.     move    #(20<<6)+1,$58(a5) ; BLTSIZE: 16 pixel, ossia 1 word di larg.
  105.                    ; * 20 linee di altezza. Da notare che per
  106.                    ; shiftare il 20 si e' usato il comodo
  107.                    ; simbolo <<, che shifta a sinistra.
  108.                    ; (20<<6) e' equivalente a (20*64).
  109.  
  110.     ADDQ.w    #2,A3        ; A3+2,avanziamo di 16 bit (PROSSIMO CARATTERE)
  111.  
  112.     DBRA    D0,PRINTCHAR2    ; STAMPIAMO D0 (20) CARATTERI PER RIGA
  113.  
  114.     ADD.W    #40*19,A3    ; ANDIAMO A CAPO
  115.                 ; ci spostiamo in basso di 19 righe.
  116.  
  117.     DBRA    D3,PRINTRIGA    ; FACCIAMO D3 RIGHE
  118.     RTS
  119.  
  120.  
  121.  
  122. ; Attenzione! nel font sono disponibili solo questi caratteri:
  123. ;
  124. ; !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ
  125.  
  126.         ; numero caratteri per linea: 20
  127. TESTO:            ;         11111111112
  128.         ;12345678901234567890
  129.     dc.b    ' PRIMA RIGA TESTO 1 ' ; 1
  130.     dc.b    '                    ' ; 2
  131.     dc.b    '     /   /          ' ; 3
  132.     dc.b    '    /   /           ' ; 4
  133.     dc.b    '                    ' ; 5
  134.     dc.b    'S S A R G           ' ; 6
  135.     dc.b    '                    ' ; 7
  136.     dc.b    '                    ' ; 8
  137.     dc.b    'FABIO CIUCCI        ' ; 9
  138.     dc.b    '                    ' ; 10
  139.  
  140.     EVEN
  141.  
  142.  
  143.         ; numero caratteri per linea: 20
  144. TESTO2:            ;         11111111112
  145.         ;12345678901234567890
  146.     dc.b    '                    ' ; 1
  147.     dc.b    'SECONDA RIGA TESTO 2' ; 2
  148.     dc.b    '     /   /          ' ; 3
  149.     dc.b    '    /   /           ' ; 4
  150.     dc.b    '                    ' ; 5
  151.     dc.b    'SESTA RIGA          ' ; 6
  152.     dc.b    '                    ' ; 7
  153.     dc.b    '                    ' ; 8
  154.     dc.b    'F B O C U C         ' ; 9
  155.     dc.b    '    AMIGA RULEZ     ' ; 10
  156.  
  157.     EVEN
  158.  
  159. ;****************************************************************************
  160.  
  161.     SECTION    GRAPHIC,DATA_C
  162.  
  163. COPPERLIST:
  164.     dc.w    $8E,$2c81    ; DiwStrt
  165.     dc.w    $90,$2cc1    ; DiwStop
  166.     dc.w    $92,$38        ; DdfStart
  167.     dc.w    $94,$d0        ; DdfStop
  168.     dc.w    $102,0        ; BplCon1
  169.     dc.w    $104,0        ; BplCon2
  170.     dc.w    $108,0        ; Bpl1Mod
  171.     dc.w    $10a,0        ; Bpl2Mod
  172.  
  173.     dc.w    $100,$2200    ; bplcon0 - 2 bitplane lowres
  174.  
  175. BPLPOINTERS:
  176.     dc.w $e0,$0000,$e2,$0000    ;primo     bitplane
  177. BPLPOINTERS2:
  178.     dc.w $e4,0,$e6,0    ;secondo bitplane
  179.  
  180.     dc.w    $180,$000    ; color0 - SFONDO
  181.     dc.w    $182,$19a    ; color1 - SCRITTE primo bitplane
  182.     dc.w    $184,$f62    ; color2 - SCRITTE secondo bitplane
  183.     dc.w    $186,$1e4    ; color3 - SCRITTE primo+secondo bitplane
  184.  
  185.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  186.  
  187.  
  188. ;****************************************************************************
  189.  
  190. ; Qui e` memorizzato il FONT di caratteri 16x20. IN CHIP RAM, perche' e'
  191. ; copiato col blitter, e non col processore!
  192.  
  193. FONT:
  194.     incbin    "assembler2:sorgenti6/font16x20.raw"
  195.  
  196. ;****************************************************************************
  197.  
  198.     SECTION    PLANEVUOTO,BSS_C
  199.  
  200. BITPLANE:
  201.     ds.b    40*256        ; bitplane azzerato lowres
  202. BITPLANE2:
  203.     ds.b    40*256        ; bitplane azzerato lowres
  204.  
  205.     end
  206.  
  207. ;****************************************************************************
  208.  
  209. In questo esempio usiamo il blitter per stampare caratteri sullo schermo.
  210. Vengono stampate 10 righe di 20 caratteri ciascuna.
  211. Come sorgente abbiamo un font formato da un solo bitplane.
  212. Lo schermo destinazione, invece, e` formato da 2 bitplanes: in questo modo
  213. abbiamo a disposizione 3 colori per i caratteri (cioe` i colori 1,2 e 3,
  214. perche` il colore 0 serve per lo sfondo).
  215. Per stampare un carattere con il colore 1, lo copiamo solo nel bitplane 1, per
  216. stamparlo con il colore 2 lo copiamo solo nel bitplane 2 e per stamparlo con
  217. il colore 3 lo copiamo in entrambi i bitplanes.
  218. Abbiamo fatto una cosa analoga nella Lezione6h.s usando il font 8x8.
  219. La stampa avviene un bitplane per volta. Il testo da stampare e` contenuto
  220. in 2 "mappe" ascii (una per bitplane) alle label TESTO e TESTO2.
  221. Ogni "mappa" o paginata ascii sara' convertita byte per byte nell'offset da
  222. aggiungere all'indirizzo del font per sapere quale carattere stampare. 
  223. Il lavoro e` svolto dalla routine Stampa, che viene richiamata una volta per
  224. ogni bitplane.
  225. La routine e` composta da 2 cicli annidati (messi uno dentro l'altro).
  226. Il ciclo piu` interno stampa una riga di caratteri da sinistra verso destra.
  227. Il ciclo esterno ripete il ciclo interno 10 volte, facendo stampare dunque 10
  228. righe in totale.
  229. Esaminiamo ora in dettaglio come avviene la blittata.
  230. Utiliziamo un font di 60 caratteri 16*20.
  231. Il font e` contenuto in un bitplane "invisibile" (perche` non lo facciamo
  232. puntare dai BPLxPT) largo 960 pixel e alto 20 righe, nel quale sono disegnati
  233. tutti e 60 i caratteri uno di fianco all'altro (infatti 60*16=960) in
  234. quest'ordine (quello ASCII):
  235.  
  236.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ
  237.  
  238. E' presente il file Font16x20.iff che e' la figura originale del font.
  239. Attenzione al fatto che mancano i caratteri dopo il sessantesimo:
  240.  
  241.     [\]^_`abcdefghijklmnopqrstuvwxyz{|}~
  242.  
  243. Se volete le lettere minuscole e altri simboli, fatevi un vostro font e una
  244. vostra routine in grado di leggerlo. Fatevi il vostro "standard".
  245. Poiche` i font sono larghi 1 word (16 pixel) e alti 20 righe, tale sara` la
  246. dimensione della blittata. I moduli sono calcolati con la solita formula.
  247. Il bitplane sorgente e` largo 60 words (cioe` 960 pixel, cioe` 120 bytes)
  248. e quindi il modulo sorgente vale 2*(60-1)=120-2=118.
  249. Il bitplane destinazione e` largo 20 words (cioe` 320 pixel, cioe` 40 bytes)
  250. e quindi il modulo sorgente vale 2*(20-1)=40-2=38.
  251. Vediamo come vengono gestiti i puntatori. Il puntatore alla destinazione varia
  252. ad ogni blittata per disegnare il carattere in una diversa posizione dello
  253. schermo, procedendo da sinistra a destra e dall'alto in basso.
  254. Il meccanismo e` lo stesso che abbiamo visto nell'esempio lezione9c2.s.
  255. Il puntatore alla sorgente invece deve puntare ogni volta al carattere che deve
  256. essere stampato. I dati del bitplane sorgente sono organizzati cosi`:
  257.  
  258. INDIRIZZO    CONTENUTO
  259. FONT        prima riga(16 pixel quindi 1 word) del carattere ' ' 
  260. FONT+2         prima riga del carattere '!'
  261. FONT+4      prima riga del carattere '"'
  262.  
  263. .
  264. .
  265. .
  266. FONT+120      prima riga del carattere 'Z'
  267. FONT+122      seconda riga del carattere ' '
  268. FONT+124      seconda riga del carattere '!'
  269. .
  270. .
  271. .
  272.  
  273. FONT+2282     ultima riga del carattere ' '
  274. FONT+2284     ultima riga del carattere '!'
  275. .
  276. FONT+2398     ultima riga del carattere 'Z'
  277.  
  278.  
  279. La routine legge dalla mappa il codice ASCII del carattere che deve stampare
  280. e da esso calcola l'indirizzo. Il metodo e` molto simile a quello che abbiamo
  281. visto nella lezione 6 quando abbiamo fatto la stessa cosa con il processore.
  282. Dal codice ASCII possiamo ricavare la distanza del carattere dall'inizio del
  283. font. Per farlo prima sottraiamo 32 (cioe` il codice ASCII dello spazio) al
  284. codice ASCII del carattere che stamperemo, perche` il primo carattere del font
  285. e` lo spazio. A questo punto procediamo diversamente dal metodo della lezione
  286. 6. Infatti il font della lezione 6 era disegnato "in verticale", cioe`:
  287.  
  288.  
  289. !
  290. "
  291. #
  292.  
  293. ecc.
  294.  
  295. >
  296. ?
  297. @
  298. A
  299. B
  300. C
  301. D
  302. E
  303. F
  304. G
  305.  
  306. ecc.
  307.  
  308. In quel caso, quindi per calcolare l'indirizzo dovevamo moltiplicare il codice
  309. ASCII (meno 32) per la quantita` di memoria occupata da un carattere.
  310. In questo caso, invece, il font e` disegnato "in orizzontale", siccome a noi
  311. interessa l'indirizzo della prima word del carattere da disegnare, dovremo
  312. moltiplicare il codice ASCII (meno 32) per la quantita` di memoria occupata
  313. dalla PRIMA RIGA di ogni carattere, in quanto la prima riga del carattere
  314. che ci interessa e` memorizzata DOPO la prima riga dei caratteri che lo
  315. precedono ma PRIMA di tutte le altre righe (a differenza del caso della lezione
  316. 6, nel quale tutte le righe di un carattere erano memorizzate prima del
  317. carattere successivo). Siccome una riga occupa 2 byte (1 word = 16 pixel)
  318. dobbiamo moltiplicare per 2, cosa che possiamo fare con una semplice ADD,
  319. risparmiandoci una lenta MULU.
  320.  
  321.