home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti_darkcoder / plasma / plasm2.s < prev    next >
Encoding:
Text File  |  1995-12-06  |  14.5 KB  |  438 lines
  1.  
  2. ; Plasma2.s    Plasma RGB a 0-bitplanes
  3. ;        tasto sinistro per uscire
  4.  
  5.     SECTION    CiriCop,CODE
  6.  
  7. ;    Include    "DaWorkBench.s"    ; togliere il ; prima di salvare con "WO"
  8.  
  9. *****************************************************************************
  10.     include    "startup2.s"    ; Salva Copperlist Etc.
  11. *****************************************************************************
  12.  
  13.         ;5432109876543210
  14. DMASET    EQU    %1000001111000000    ; copper,bitplane,blitter DMA
  15.  
  16. Waitdisk    EQU    10
  17.  
  18. Largh_plasm    equ    40        ; larghezza del plasma espressa
  19.                     ; come numero di gruppi di 8 pixel
  20.  
  21. BytesPerRiga    equ    (Largh_plasm+2)*4    ; numero di bytes occupati
  22.                         ; nella copperlist da ogni col.
  23.                         ; del plasma: ogni istruzione
  24.                         ; copper occupa 4 bytes
  25.  
  26. Alt_plasm    equ    190        ; altezza del plasma espressa
  27.                     ; come numero di linee
  28.  
  29. NuovaColR    equ    -2        ; valore sommato all'indice R nella
  30.                     ; SinTab tra una col. e l'altra
  31.                     ; Puo` essere variato ottenendo plasmi
  32.                     ; diversi, ma DEVE ESSERE SEMPRE PARI!!
  33.  
  34. NuovoFrameR    equ    8        ; valore sottratto all'indice R nella
  35.                     ; SinTab tra un frame e l'altro
  36.                     ; Puo` essere variato ottenendo plasmi
  37.                     ; diversi, ma DEVE ESSERE SEMPRE PARI!!
  38.  
  39. NuovaColG    equ    2        ; come "NuovaColR" ma per componente G
  40. NuovoFrameG    equ    2        ; come "NuovoFrameR" ma componente G
  41.  
  42. NuovaColB    equ    4        ; come "NuovaColR" ma per componente B
  43. NuovoFrameB    equ    -6        ; come "NuovoFrameR" ma componente B
  44.  
  45.  
  46. START:
  47.     lea    $dff000,a5        ; CUSTOM REGISTER in a5
  48.  
  49.     bsr    InitPlasma        ; inizializza la copperlist
  50.  
  51. ; Inizializza i registri del blitter
  52.  
  53.     Btst    #6,2(a5)
  54. WaitBlit_init:
  55.     Btst    #6,2(a5)        ; aspetta il blitter
  56.     bne.s    WaitBlit_init
  57.  
  58.     move.l    #$4FFE8000,$40(a5)    ; BLTCON0/1 - D=A+B+C
  59.                     ; shift A = 4 pixel
  60.                     ; shift B = 8 pixel
  61.                     
  62.     moveq    #-1,d0            ; D0 = $FFFFFFFF
  63.     move.l    d0,$44(a5)        ; BLTAFWM/BLTALWM
  64.  
  65. mod_A    set    0            ; modulo canale A
  66. mod_D    set    2            ; modulo canale D: colonna seguente
  67.  
  68.     move.l    #mod_A<<16+mod_D,$64(a5)    ; carica i registri modulo
  69.  
  70. ; moduli canali B e C = 0
  71.  
  72.     moveq    #0,d0
  73.     move.l    d0,$60(a5)        ; scrive BLTBMOD e BLTCMOD
  74.  
  75.  
  76. ; Inizializza altri registri hardware
  77.  
  78.     MOVE.W    #DMASET,$96(a5)        ; DMACON - abilita bitplane, copper
  79.     move.l    #COPPERLIST1,$80(a5)    ; Puntiamo la nostra COP
  80.     move.w    d0,$88(a5)        ; Facciamo partire la COP
  81.     move.w    #0,$1fc(a5)        ; Disattiva l'AGA
  82.     move.w    #$c00,$106(a5)        ; Disattiva l'AGA
  83.     move.w    #$11,$10c(a5)        ; Disattiva l'AGA
  84.     move.w    #$000,$180(a5)        ; COLOR00 - nero
  85.     move.w    #$0200,$100(a5)        ; BPLCON0 - no bitplanes attivi
  86.  
  87. mouse:
  88.     MOVE.L    #$1ff00,d1    ; bit per la selezione tramite AND
  89.     MOVE.L    #$13000,d2    ; linea da aspettare = $130, ossia 304
  90. Waity1:
  91.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  92.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  93.     CMPI.L    D2,D0        ; aspetta la linea $130 (304)
  94.     BNE.S    Waity1
  95.  
  96.     bsr.s    ScambiaClists    ; scambia le copperlist
  97.  
  98.     bsr.s    DoPlasma
  99.  
  100.     btst    #6,$bfe001    ; mouse premuto?
  101.     bne.w    mouse
  102.     rts
  103.  
  104. ;****************************************************************************
  105. ; Questa routine realizza il "double buffer" tra le copperlist.
  106. ; In pratica prende la clist dove si e` disegnato, e la visualizza copiandone
  107. ; l'indirizzo in COP1LC. Scambia le variabili, in modo tale che nel frame
  108. ; che segue si disegna sull'altra copper list
  109. ;****************************************************************************
  110.  
  111. ScambiaClists:
  112.     move.l    draw_clist(pc),d0    ; indirizzo clist su cui si e` scritto
  113.     move.l    view_clist(pc),draw_clist    ; scambia le clists
  114.     move.l    d0,view_clist
  115.  
  116.     move.l    d0,$80(a5)        ; copia l'indirizzo della clist
  117.                     ; in COP1LC in maniera che venga
  118.                     ; visualizzata nel prossimo frame
  119.  
  120.     rts
  121.  
  122.  
  123. ;****************************************************************************
  124. ; Questa routine inizializza la copperlist che genera il plasma. Sistema le
  125. ; istruzioni WAIT e le prima meta` delle COPPERMOVE. Alla fine della riga
  126. ; del plasma viene inserita un ultima COPPERMOVE che carica il colore
  127. ; nero in COLOR00.
  128. ;****************************************************************************
  129.  
  130. InitPlasma:
  131.     lea    Plasma1,a0    ; indirizzo plasma 1
  132.     lea    Plasma2,a1    ; indirizzo plasma 2
  133.     move.l    #$383dFFFE,d0    ; carica la prima istruzione wait in $3d.
  134.                 ; aspetta la riga $60 e la posizione
  135.                 ; orizzontale $58
  136.     move.w    #$180,d1    ; mette in D1 la prima meta` di un istruzione 
  137.                 ; "copper move" in COLOR00 (=$dff180)
  138.  
  139.     move.w    #Alt_plasm-1,d3        ; loop per ogni riga
  140. InitLoop1:
  141.     move.l    d0,(a0)+        ; scrive la WAIT - (clist 1)
  142.     move.l    d0,(a1)+        ; scrive la WAIT - (clist 2)
  143.     add.l    #$01000000,d0        ; modifica la WAIT per aspettare
  144.                     ; la riga seguente
  145.  
  146.     moveq    #Largh_plasm,d2        ; loop per tutta la larghezza
  147.                     ; del plasma + una volta per
  148.                     ; l'ultima "copper move" che rimette
  149.                     ; il nero come sfondo
  150.  
  151. InitLoop2:
  152.     move.w    d1,(a0)+        ; scrive la prima parte della
  153.                     ; "copper move" - clist 1
  154.     addq.l    #2,a0            ; spazio per la seconda parte
  155.                     ; della "copper move" - clist 1
  156.  
  157.     move.w    d1,(a1)+        ; scrive la prima parte della
  158.                     ; "copper move" - clist 2
  159.     addq.l    #2,a1            ; spazio per la seconda parte
  160.                     ; della "copper move" - clist 2
  161.  
  162.     dbra    d2,InitLoop2
  163.  
  164.     dbra    d3,InitLoop1    
  165.     rts
  166.  
  167.  
  168. ;****************************************************************************
  169. ; Questa routine realizza il plasma. Effettua un loop di blittate, ciascuna
  170. ; delle quali scrive una "riga" del plasma, cioe` scrive i colori nelle
  171. ; COPPERMOVES messe in riga.
  172. ; Viene realizzato un plasma RGB. La 3 componenti vengono lette separatamente
  173. ; e "OR-ate" insieme. Per le 3 componenti si usa un'unica tabella, che pero`
  174. ; viene letta in posizioni diverse e "percorsa" a velocita` differenti tra
  175. ; una riga e l'altra e tra un frame e l'altro. In questo modo e` come avere
  176. ; 3 tabelle differenti.
  177. ; La tabella contiene in realta` i valori della componente R. Per ottenere
  178. ; i valori delle altre componenti G e` necessario shiftare i dati letti a
  179. ; destra, di 4 per la G e di 8 per la B. Cio` viene fatto "al volo" dagli
  180. ; shifter del blitter.
  181. ;****************************************************************************
  182.  
  183. DoPlasma:
  184.  
  185.     lea    Color,a0        ; indirizzo colori
  186.     lea    SinTab,a6        ; indirizzo tabella offsets
  187.     move.l    draw_clist(pc),a1    ; indirizzo copperlist dove scrivere
  188.     lea    22(a1),a1        ; aggiunge offset necessario per
  189.                     ; puntare la prima word della prima
  190.                     ; riga del plasma
  191.                     ; (bisonga saltare le 4 istruzioni
  192.                     ; iniziali, la wait di inizio riga
  193.                     ; e la prima word della "copper move")
  194.  
  195. ; legge e modifica indice componente R
  196.  
  197.     move.w    IndiceR(pc),d4        ; legge l'indice di partenza del
  198.                     ; frame precedente
  199.     sub.w    #NuovoFrameR,d4        ; modifica l'indice nella tabella
  200.                     ; dal frame precedente
  201.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  202.                     ; 0 - 255 (offset in una tabella di
  203.                     ; 128 words)
  204.     move.w    d4,IndiceR        ; memorizza l'indice di partenza per
  205.                     ; il prossimo frame
  206.  
  207. ; legge e modifica indice componente G
  208.  
  209.     move.w    IndiceG(pc),d5        ; legge l'indice di partenza del
  210.                     ; frame precedente
  211.     sub.w    #NuovoFrameG,d5        ; modifica l'indice nella tabella
  212.                     ; dal frame precedente
  213.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  214.                     ; 0 - 255 (offset in una tabella di
  215.                     ; 128 words)
  216.     move.w    d5,IndiceG        ; memorizza l'indice di partenza per
  217.                     ; il prossimo frame
  218.  
  219. ; legge e modifica indice componente B
  220.  
  221.     move.w    IndiceB(pc),d6        ; legge l'indice di partenza del
  222.                     ; frame precedente
  223.     sub.w    #NuovoFrameB,d6        ; modifica l'indice nella tabella
  224.                     ; dal frame precedente
  225.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  226.                     ; 0 - 255 (offset in una tabella di
  227.                     ; 128 words)
  228.     move.w    d6,IndiceB        ; memorizza l'indice di partenza per
  229.                     ; il prossimo frame
  230.  
  231.     move.w    #Largh_plasm<<6+1,d3    ; dimensione blittata
  232.                     ; largh. 1 word, alta quanto
  233.                     ; la larghezza del plasma
  234.  
  235.     move.w    #Alt_plasm-1,d2        ; loop per tutta l'altezza
  236.  
  237. PlasmaLoop:                ; inizio loop blittate
  238.  
  239. ; calcola indirizzo di partenza componente R
  240.  
  241.     move.w    (a6,d4.w),d1        ; legge offset dalla tabella
  242.  
  243.     lea    (a0,d1.w),a2        ; indirizzo di partenza = ind. colori
  244.                     ; piu` offset
  245.  
  246. ; calcola indirizzo di partenza componente G
  247.  
  248.     move.w    (a6,d5.w),d1        ; legge offset dalla tabella
  249.  
  250.     lea    (a0,d1.w),a3        ; indirizzo di partenza = ind. colori
  251.                     ; piu` offset
  252.  
  253. ; calcola indirizzo di partenza componente B
  254.  
  255.     move.w    (a6,d6.w),d1        ; legge offset dalla tabella
  256.  
  257.     lea    (a0,d1.w),a4        ; indirizzo di partenza = ind. colori
  258.                     ; piu` offset
  259.  
  260.     Btst    #6,2(a5)
  261. WaitBlit:
  262.     Btst    #6,2(a5)        ; aspetta il blitter
  263.     bne.s    WaitBlit
  264.  
  265.     move.l    a2,$48(a5)        ; BLTCPT - indirizzo sorgente R
  266.                     ; (copiata cosi` com'e`)
  267.     move.l    a3,$50(a5)        ; BLTAPT - indirizzo sorgente G
  268.                     ; (viene shiftata di 4 a destra)
  269.     move.l    a4,$4C(a5)        ; BLTBPT - indirizzo sorgente B
  270.                     ; (viene shiftata di 8 a destra)
  271.     move.l    a1,$54(a5)        ; BLTDPT - indirizzo destinazione
  272.     move.w    d3,$58(a5)        ; BLTSIZE
  273.  
  274.     lea    BytesPerRiga(a1),a1    ; punta alla prossima riga di 
  275.                     ; "copper moves" nella copper list
  276.  
  277. ; modifica indice componente R per prossima col.
  278.  
  279.     add.w    #NuovaColR,d4        ; modifica l'indice nella tabella
  280.                     ; per la prossima col.
  281.  
  282.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  283.                     ; 0 - 255 (offset in una tabella di
  284.                     ; 128 words)
  285.  
  286. ; modifica indice componente G per prossima col.
  287.  
  288.     add.w    #NuovaColG,d5        ; modifica l'indice nella tabella
  289.                     ; per la prossima col.
  290.  
  291.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  292.                     ; 0 - 255 (offset in una tabella di
  293.                     ; 128 words)
  294.  
  295. ; modifica indice componente B per prossima col.
  296.  
  297.     add.w    #NuovaColB,d6        ; modifica l'indice nella tabella
  298.                     ; per la prossima col.
  299.  
  300.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  301.                     ; 0 - 255 (offset in una tabella di
  302.                     ; 128 words)
  303.     dbra    d2,PlasmaLoop
  304.     rts
  305.  
  306.  
  307. ; Queste 2 variabili contengono gli indirizzi delle 2 copperlist
  308.  
  309. view_clist:    dc.l    COPPERLIST1    ; indirizzo clist visualizzata
  310. draw_clist:    dc.l    COPPERLIST2    ; indirizzo clist dove disegnare
  311.  
  312.  
  313. ; Queste variabili contengono i valori degli indici per la prima colonna
  314.  
  315. IndiceR:    dc.w    0
  316. IndiceG:    dc.w    0
  317. IndiceB:    dc.w    0
  318.  
  319. ; Questa tabella contiene gli offset per l'indirizzo di partenza nella
  320. ; tabella dei colori
  321.  
  322. SinTab:
  323.     DC.W    $000E,$0010,$0010,$0010,$0012,$0012,$0012,$0014,$0014,$0014
  324.     DC.W    $0014,$0016,$0016,$0016,$0018,$0018,$0018,$0018,$001A,$001A
  325.     DC.W    $001A,$001A,$001A,$001A,$001C,$001C,$001C,$001C,$001C,$001C
  326.     DC.W    $001C,$001C,$001C,$001C,$001C,$001C,$001C,$001C,$001C,$001C
  327.     DC.W    $001A,$001A,$001A,$001A,$001A,$001A,$0018,$0018,$0018,$0018
  328.     DC.W    $0016,$0016,$0016,$0014,$0014,$0014,$0014,$0012,$0012,$0012
  329.     DC.W    $0010,$0010,$0010,$000E,$000E,$000C,$000C,$000C,$000A,$000A
  330.     DC.W    $000A,$0008,$0008,$0008,$0008,$0006,$0006,$0006,$0004,$0004
  331.     DC.W    $0004,$0004,$0002,$0002,$0002,$0002,$0002,$0002,$0000,$0000
  332.     DC.W    $0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000
  333.     DC.W    $0000,$0000,$0000,$0000,$0002,$0002,$0002,$0002,$0002,$0002
  334.     DC.W    $0004,$0004,$0004,$0004,$0006,$0006,$0006,$0008,$0008,$0008
  335.     DC.W    $0008,$000A,$000A,$000A,$000C,$000C,$000C,$000C
  336. EndSinTab:
  337.  
  338. ;****************************************************************************
  339.  
  340.     SECTION    GRAPHIC,DATA_C
  341.  
  342. ; Abbiamo 2 copperlists 
  343.  
  344. COPPERLIST1:
  345.     dc.w    $3007,$fffe    ; wait linea $40
  346.     dc.w    $0180,$c00    ; color0
  347.     dc.w    $3407,$fffe    ; wait linea $44
  348.     dc.w    $0180,$000    ; color0
  349.  
  350. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  351. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  352.  
  353. Plasma1:
  354.     dcb.b    alt_plasm*BytesPerRiga,0
  355.  
  356.     dc.w    $FA07,$fffe    ; wait linea $e0
  357.     dc.w    $0180,$c00    ; color0
  358.     dc.w    $FE07,$fffe    ; wait linea $e4
  359.     dc.w    $0180,$000    ; color0
  360.  
  361.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  362.  
  363. ;****************************************************************************
  364.  
  365. COPPERLIST2:
  366.     dc.w    $3007,$fffe    ; wait linea $40
  367.     dc.w    $0180,$c00    ; color0
  368.     dc.w    $3407,$fffe    ; wait linea $44
  369.     dc.w    $0180,$000    ; color0
  370.  
  371. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  372. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  373.  
  374. Plasma2:
  375.     dcb.b    alt_plasm*BytesPerRiga,0
  376.  
  377.     dc.w    $FA07,$fffe    ; wait linea $e0
  378.     dc.w    $0180,$c00    ; color0
  379.     dc.w    $FE07,$fffe    ; wait linea $e4
  380.     dc.w    $0180,$000    ; color0
  381.  
  382.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  383.  
  384.  
  385. ;****************************************************************************
  386. ; Qui c'e` la tabella da dove vengono lette le componenti dei colori.
  387. ; La tabella contiene delle componenti R. Per ottenere le componenti G e
  388. ; B, e` sufficente shiftare i dati letti con il blitter.
  389. ; Devono esserci abbastanza valori da essere letti qualunque sia l'indirizzo
  390. ; di partenza. In questo esempio l'indirizzo di partenza puo` variare da
  391. ; "Color" (primo colore) fino a "Color+28" (14-esimo colore), perche`
  392. ; 60 e` il massimo offset sontenuto nella "SinTab".
  393. ; Se Largh_plasm=40 vuol dire che ogni blittata legge 40 valori.
  394. ; Quindi in totale devono esserci 54 valori.
  395. ;****************************************************************************
  396.  
  397. Color:
  398.     dcb.w    2,0
  399.  
  400.     DC.W    $0100,$0300,$0500,$0600,$0800,$0A00,$0B00,$0C00,$0D00,$0E00
  401.     DC.W    $0F00,$0F00,$0F00,$0F00,$0F00,$0E00,$0D00,$0C00,$0B00,$0A00
  402.     DC.W    $0800,$0600,$0500,$0300,$0100
  403.  
  404.     dcb.w    2,0
  405.  
  406.     DC.W    $0100,$0300,$0500,$0600,$0800,$0A00,$0B00,$0C00,$0D00,$0E00
  407.     DC.W    $0F00,$0F00,$0F00,$0F00,$0F00,$0E00,$0D00,$0C00,$0B00,$0A00
  408.     DC.W    $0800,$0600,$0500,$0300,$0100
  409.  
  410.     end
  411.  
  412. ;****************************************************************************
  413.  
  414. In questo esempio vediamo un plasma RGB.
  415. Date le dimensioni del plasma e la complessita` della blittata (a 3 canali) non
  416. sarebbe possibile modificare tutta la copperlist prima che finisca il vertical
  417. blank e di conseguenza una parte della copperlist viene visualizzata prima
  418. di essere stata modificata. Per risolvere il problema e` necessario utilizzare
  419. il "double buffering" delle copperlist. Si tratta di una tecnica che abbiamo
  420. gia` visto nell'esempio lezione11i2.s: si utilizzano 2 copperlist, che vengono
  421. visualizzate alternativamente. Mentre una delle 2 viene visualizzata, la
  422. routine di plasma scrive nell'altra. Esattamente come il "double buffering"
  423. dei bitplanes. Lo scambio delle copperlist e` effettuato dalla routine
  424. "ScambiaClists".
  425. Per realizzare il plasma RGB si utilizza una blittata che combina con un
  426. operazione di OR le componenti R,G e B di un colore che vengono lette
  427. separatamente. Per risparmiare memoria, si e` usata una sola tabella di
  428. componenti. Tale tabella contiene le componenti R. Per ottenere le componenti
  429. G e B e` sufficente shiftare verso destra i dati letti, operazione che puo`
  430. essere effettuata "al volo" dal blitter. Notate comunque che i valori delle
  431. componenti vengono lette da punti differenti della tabella. Infatti per ogni
  432. componente abbiamo un indice che viene incrementato separatamente (e con una
  433. diversa velocita`).
  434. In questo plasma, a differenza di quello visto in plasm1.s le blittate
  435. avvengono "per riga". Ogni blittata cioe` riempie una riga del plasma,
  436. mentre in plsm1.s ogni blittata riempiva una colonna.
  437.  
  438.