home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti_darkcoder / plasma / plasm3.s < prev    next >
Encoding:
Text File  |  1995-12-06  |  17.2 KB  |  490 lines
  1.  
  2. ; Plasma3.s    Plasma RGB a 0-bitplanes
  3. ;        tasto destro per attivare ondulazione, 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    48        ; larghezza del plasma espressa
  19.                     ; come numero di gruppi di 8 pixel
  20.                     ; il plasma e` piu` largo dello schermo
  21.  
  22. BytesPerRiga    equ    (Largh_plasm+2)*4    ; numero di bytes occupati
  23.                         ; nella copperlist da ogni riga
  24.                         ; del plasma: ogni istruzione
  25.                         ; copper occupa 4 bytes
  26.  
  27. Alt_plasm    equ    190        ; altezza del plasma espressa
  28.                     ; come numero di linee
  29.  
  30. NuovaRigaR    equ    4        ; valore sommato all'indice R nella
  31.                     ; SinTab tra una riga e l'altra
  32.                     ; Puo` essere variato ottenendo plasmi
  33.                     ; diversi, ma DEVE ESSERE SEMPRE PARI!!
  34.  
  35. NuovoFrameR    equ    6        ; valore sottratto all'indice R nella
  36.                     ; SinTab tra un frame e l'altro
  37.                     ; Puo` essere variato ottenendo plasmi
  38.                     ; diversi, ma DEVE ESSERE SEMPRE PARI!!
  39.  
  40. NuovaRigaG    equ    2        ; come "NuovaRigaR" ma per componente G
  41. NuovoFrameG    equ    8        ; come "NuovoFrameR" ma componente G
  42.  
  43. NuovaRigaB    equ    8        ; come "NuovaRigaR" ma per componente B
  44. NuovoFrameB    equ    4        ; come "NuovoFrameR" ma componente B
  45.  
  46. NuovaRigaO    equ    4        ; come "NuovaRigaR" ma per oscillazioni
  47. NuovoFrameO    equ    2        ; come "NuovoFrameR" ma oscillazioni
  48.  
  49.  
  50. START:
  51.     lea    $dff000,a5        ; CUSTOM REGISTER in a5
  52.  
  53.     bsr    InitPlasma        ; inizializza la copperlist
  54.  
  55. ; Inizializza i registri del blitter
  56.  
  57.     Btst    #6,2(a5)
  58. WaitBlit_init:
  59.     Btst    #6,2(a5)        ; aspetta il blitter
  60.     bne.s    WaitBlit_init
  61.  
  62.     move.l    #$4FFE8000,$40(a5)    ; BLTCON0/1 - D=A+B+C
  63.                     ; shift A = 4 pixel
  64.                     ; shift B = 8 pixel
  65.                     
  66.     moveq    #-1,d0            ; D0 = $FFFFFFFF
  67.     move.l    d0,$44(a5)        ; BLTAFWM/BLTALWM
  68.  
  69. mod_A    set    0            ; modulo canale A
  70. mod_D    set    BytesPerRiga-2        ; modulo canale D: va a riga seguente
  71.  
  72.     move.l    #mod_A<<16+mod_D,$64(a5)    ; carica i registri modulo
  73.  
  74. ; moduli canali B e C = 0
  75.  
  76.     moveq    #0,d0
  77.     move.l    d0,$60(a5)        ; scrive BLTBMOD e BLTCMOD
  78.  
  79. ; Inizializza altri registri hardware
  80.  
  81.     MOVE.W    #DMASET,$96(a5)        ; DMACON - abilita bitplane, copper
  82.     move.l    #COPPERLIST1,$80(a5)    ; Puntiamo la nostra COP
  83.     move.w    d0,$88(a5)        ; Facciamo partire la COP
  84.     move.w    #0,$1fc(a5)        ; Disattiva l'AGA
  85.     move.w    #$c00,$106(a5)        ; Disattiva l'AGA
  86.     move.w    #$11,$10c(a5)        ; Disattiva l'AGA
  87.     move.w    #$000,$180(a5)        ; COLOR00 - nero
  88.     move.w    #$0200,$100(a5)        ; BPLCON0 - no bitplanes attivi
  89.  
  90. ; primo loop: senza oscillazione orizzontale
  91.  
  92. mouse1:
  93.     MOVE.L    #$1ff00,d1    ; bit per la selezione tramite AND
  94.     MOVE.L    #$13000,d2    ; linea da aspettare = $130, ossia 304
  95. Waity1:
  96.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  97.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  98.     CMPI.L    D2,D0        ; aspetta la linea $130 (304)
  99.     BNE.S    Waity1
  100.  
  101.     bsr    ScambiaClists    ; scambia le copperlist
  102.  
  103.     bsr    DoPlasma    ; routine plasma
  104.  
  105.     btst    #2,$dff016    ; tasto destro del mouse premuto?
  106.     bne.s    mouse1
  107.  
  108. ; secondo loop: con oscillazione orizzontale
  109.  
  110. mouse2:
  111.     MOVE.L    #$1ff00,d1    ; bit per la selezione tramite AND
  112.     MOVE.L    #$13000,d2    ; linea da aspettare = $130, ossia 304
  113. Waity2:
  114.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  115.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  116.     CMPI.L    D2,D0        ; aspetta la linea $130 (304)
  117.     BNE.S    Waity2
  118.  
  119.     bsr    ScambiaClists    ; scambia le copperlist
  120.  
  121.     bsr    DoOriz        ; effetto oscillazione orizzontale
  122.     bsr    DoPlasma
  123.  
  124.     btst    #6,$bfe001    ; mouse premuto?
  125.     bne.s    mouse2
  126.  
  127.     rts
  128.  
  129. ;****************************************************************************
  130. ; Questa routine realizza l'effetto di oscillazione orizzontale. 
  131. ; L'effetto e` realizzato modificando ad ogni riga la posizione orizzontale
  132. ; di inizio del plasma, ovvero la posizione orizzontale della WAIT che inizia
  133. ; la riga. I valori della posizione vengono letti da una tabella.
  134. ;****************************************************************************
  135.  
  136. DoOriz:
  137.     lea    OrizTab(pc),a0        ; indirizzo tabella oscillazioni
  138.     move.l    draw_clist(pc),a1    ; indirizzo copperlist dove scrivere
  139.     addq.w    #1,a1            ; indirizzo secondo byte della prima
  140.                     ; word della WAIT
  141. ; legge e modifica indice
  142.  
  143.     move.w    IndiceO(pc),d4        ; legge l'indice di partenza del
  144.                     ; frame precedente
  145.     sub.w    #NuovoFrameO,d4        ; modifica l'indice nella tabella
  146.                     ; dal frame precedente
  147.     and.w    #$007F,d4        ; tiene l'indice nell'intervallo
  148.                     ; 0 - 127 (offset in una tabella di
  149.                     ; 128 bytes)
  150.     move.w    d4,IndiceO        ; memorizza l'indice di partenza per
  151.                     ; il prossimo frame
  152.  
  153.     move.w    #Alt_plasm-1,d3        ; loop per ogni riga
  154. OrizLoop:
  155.     move.b    0(a0,d4.w),d0        ; leggi valore dell'oscillazione
  156.     or.b    #$01,d0            ; setta ad 1 il bit 0 (necessario
  157.                     ; per l'istruzione WAIT)
  158.     move.b    d0,(a1)            ; scrive la posizione orizzontale
  159.                     ; della WAIT nella copperlist
  160.  
  161.     lea    BytesPerRiga(a1),a1    ; punta alla prossima riga 
  162.                     ; nella copper list
  163. ; modifica indice per prossima riga
  164.  
  165.     add.w    #NuovaRigaO,d4        ; modifica l'indice nella tabella
  166.                     ; per la prossima riga
  167.  
  168.     and.w    #$007F,d4        ; tiene l'indice nell'intervallo
  169.                     ; 0 - 127 (offset in una tabella di
  170.                     ; 128 bytes)
  171.     dbra    d3,OrizLoop
  172.     rts
  173.  
  174. ;****************************************************************************
  175. ; Questa routine realizza il "double buffer" tra le copperlist.
  176. ; In pratica prende la clist dove si e` disegnato, e la visualizza copiandone
  177. ; l'indirizzo in COP1LC. Scambia le variabili, in modo tale che nel frame
  178. ; che segue si disegna sull'altra copper list
  179. ;****************************************************************************
  180.  
  181. ScambiaClists:
  182.     move.l    draw_clist(pc),d0    ; indirizzo clist su cui si e` scritto
  183.     move.l    view_clist(pc),draw_clist    ; scambia le clists
  184.     move.l    d0,view_clist
  185.  
  186.     move.l    d0,$80(a5)        ; copia l'indirizzo della clist
  187.                     ; in COP1LC in maniera che venga
  188.                     ; visualizzata nel prossimo frame
  189.     rts
  190.  
  191.  
  192. ;****************************************************************************
  193. ; Questa routine inizializza la copperlist che genera il plasma. Sistema le
  194. ; istruzioni WAIT e le prima meta` delle COPPERMOVE. Alla fine della riga
  195. ; del plasma viene inserita un ultima COPPERMOVE che carica il colore
  196. ; nero in COLOR00.
  197. ;****************************************************************************
  198.  
  199. InitPlasma:
  200.     lea    Copperlist1,a0    ; indirizzo copperlist 1
  201.     lea    Copperlist2,a1    ; indirizzo copperlist 2
  202.     move.l    #$3025FFFE,d0    ; carica la prima istruzione wait in D0.
  203.                 ; aspetta la riga $30 e la posizione
  204.                 ; orizzontale $24
  205.     move.w    #$180,d1    ; mette in D1 la prima meta` di un istruzione 
  206.                 ; "copper move" in COLOR00 (=$dff180)
  207.  
  208.     move.w    #Alt_plasm-1,d3        ; loop per ogni riga
  209. InitLoop1:
  210.     move.l    d0,(a0)+        ; scrive la WAIT - (clist 1)
  211.     move.l    d0,(a1)+        ; scrive la WAIT - (clist 2)
  212.     add.l    #$01000000,d0        ; modifica la WAIT per aspettare
  213.                     ; la riga seguente
  214.  
  215.     moveq    #Largh_plasm,d2        ; loop per tutta la larghezza
  216.                     ; del plasma + una volta per
  217.                     ; l'ultima "copper move" che rimette
  218.                     ; il nero come sfondo
  219.  
  220. InitLoop2:
  221.     move.w    d1,(a0)+        ; scrive la prima parte della
  222.                     ; "copper move" - clist 1
  223.     addq.w    #2,a0            ; spazio per la seconda parte
  224.                     ; della "copper move" - clist 1
  225.  
  226.     move.w    d1,(a1)+        ; scrive la prima parte della
  227.                     ; "copper move" - clist 2
  228.     addq.w    #2,a1            ; spazio per la seconda parte
  229.                     ; della "copper move" - clist 2
  230.  
  231.     dbra    d2,InitLoop2
  232.     dbra    d3,InitLoop1
  233.     rts
  234.  
  235. ;****************************************************************************
  236. ; Questa routine realizza il plasma. Effettua un loop di blittate, ciascuna
  237. ; delle quali scrive una "colonna" del plasma, cioe` scrive i colori nelle
  238. ; COPPERMOVES messe in colonna.
  239. ; I colori scritti in ogni colonna sono letti da una tabella, a partire da
  240. ; un indirizzo che varia tra una colonna e l'altra in base a degli offset
  241. ; letti da un'altra tabella. Inoltre tra un frame e l'altro gli offset
  242. ; variano, realizzando l'effetto di movimento.
  243. ;****************************************************************************
  244.  
  245. DoPlasma:
  246.     lea    Color,a0        ; indirizzo colori
  247.     lea    SinTab,a6        ; indirizzo tabella offsets
  248.     move.l    draw_clist(pc),a1    ; indirizzo copperlist dove scrivere
  249.     addq.w    #6,a1            ; indirizzo prima word della prima
  250.                     ; colonna del plasma
  251. ; legge e modifica indice componente R
  252.  
  253.     move.w    IndiceR(pc),d4        ; legge l'indice di partenza del
  254.                     ; frame precedente
  255.     sub.w    #NuovoFrameR,d4        ; modifica l'indice nella tabella
  256.                     ; dal frame precedente
  257.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  258.                     ; 0 - 255 (offset in una tabella di
  259.                     ; 128 words)
  260.     move.w    d4,IndiceR        ; memorizza l'indice di partenza per
  261.                     ; il prossimo frame
  262. ; legge e modifica indice componente G
  263.  
  264.     move.w    IndiceG(pc),d5        ; legge l'indice di partenza del
  265.                     ; frame precedente
  266.     sub.w    #NuovoFrameG,d5        ; modifica l'indice nella tabella
  267.                     ; dal frame precedente
  268.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  269.                     ; 0 - 255 (offset in una tabella di
  270.                     ; 128 words)
  271.     move.w    d5,IndiceG        ; memorizza l'indice di partenza per
  272.                     ; il prossimo frame
  273. ; legge e modifica indice componente B
  274.  
  275.     move.w    IndiceB(pc),d6        ; legge l'indice di partenza del
  276.                     ; frame precedente
  277.     sub.w    #NuovoFrameB,d6        ; modifica l'indice nella tabella
  278.                     ; dal frame precedente
  279.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  280.                     ; 0 - 255 (offset in una tabella di
  281.                     ; 128 words)
  282.     move.w    d6,IndiceB        ; memorizza l'indice di partenza per
  283.                     ; il prossimo frame
  284.  
  285.     move.w    #Alt_plasm<<6+1,d3    ; dimensione blittata
  286.                     ; largh. 1 word, alta tutto il plasma
  287.  
  288.     moveq    #Largh_plasm-1,d2    ; loop per tutta la larghezza
  289. PlasmaLoop:                ; inizio loop blittate
  290.  
  291. ; calcola indirizzo di partenza componente R
  292.  
  293.     move.w    (a6,d4.w),d1        ; legge offset dalla tabella
  294.  
  295.     lea    (a0,d1.w),a2        ; indirizzo di partenza = ind. colori
  296.                     ; piu` offset
  297. ; calcola indirizzo di partenza componente G
  298.  
  299.     move.w    (a6,d5.w),d1        ; legge offset dalla tabella
  300.  
  301.     lea    (a0,d1.w),a3        ; indirizzo di partenza = ind. colori
  302.                     ; piu` offset
  303. ; calcola indirizzo di partenza componente B
  304.  
  305.     move.w    (a6,d6.w),d1        ; legge offset dalla tabella
  306.  
  307.     lea    (a0,d1.w),a4        ; indirizzo di partenza = ind. colori
  308.                     ; piu` offset
  309.     Btst    #6,2(a5)
  310. WaitBlit:
  311.     Btst    #6,2(a5)        ; aspetta il blitter
  312.     bne.s    WaitBlit
  313.  
  314.     move.l    a2,$48(a5)        ; BLTCPT - indirizzo sorgente R
  315.     move.l    a3,$50(a5)        ; BLTAPT - indirizzo sorgente G
  316.     move.l    a4,$4C(a5)        ; BLTBPT - indirizzo sorgente B
  317.     move.l    a1,$54(a5)        ; BLTDPT - indirizzo destinazione
  318.     move.w    d3,$58(a5)        ; BLTSIZE
  319.  
  320.     addq.w    #4,a1            ; punta a prossima colonna di 
  321.                     ; "copper moves" nella copper list
  322. ; modifica indice componente R per prossima riga
  323.  
  324.     add.w    #NuovaRigaR,d4        ; modifica l'indice nella tabella
  325.                     ; per la prossima riga
  326.  
  327.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  328.                     ; 0 - 255 (offset in una tabella di
  329.                     ; 128 words)
  330. ; modifica indice componente G per prossima riga
  331.  
  332.     add.w    #NuovaRigaG,d5        ; modifica l'indice nella tabella
  333.                     ; per la prossima riga
  334.  
  335.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  336.                     ; 0 - 255 (offset in una tabella di
  337.                     ; 128 words)
  338.  
  339. ; modifica indice componente B per prossima riga
  340.  
  341.     add.w    #NuovaRigaB,d6        ; modifica l'indice nella tabella
  342.                     ; per la prossima riga
  343.  
  344.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  345.                     ; 0 - 255 (offset in una tabella di
  346.                     ; 128 words)
  347.     dbra    d2,PlasmaLoop
  348.     rts
  349.  
  350.  
  351. ; Queste 2 variabili contengono gli indirizzi delle 2 copperlist
  352.  
  353. view_clist:    dc.l    COPPERLIST1    ; indirizzo clist visualizzata
  354. draw_clist:    dc.l    COPPERLIST2    ; indirizzo clist dove disegnare
  355.  
  356. ; Questa variabile contiene il valore dell'indice nella tabella delle
  357. ; oscillazioni (posizioni orizzontali delle WAIT)
  358.  
  359. IndiceO:    dc.w    0
  360.  
  361. ; Questa tabella contiene i valori delle oscillazioni (posizioni orizzontali
  362. ; delle WAIT)
  363.  
  364. OrizTab:
  365.     DC.B    $2C,$2C,$2C,$2E,$2E,$2E,$2E,$2E,$30,$30,$30,$30,$30,$30,$32,$32
  366.     DC.B    $32,$32,$32,$32,$32,$32,$34,$34,$34,$34,$34,$34,$34,$34,$34,$34
  367.     DC.B    $34,$34,$34,$34,$34,$34,$34,$34,$34,$34,$32,$32,$32,$32,$32,$32
  368.     DC.B    $32,$32,$30,$30,$30,$30,$30,$30,$2E,$2E,$2E,$2E,$2E,$2C,$2C,$2C
  369.     DC.B    $2C,$2C,$2C,$2A,$2A,$2A,$2A,$2A,$28,$28,$28,$28,$28,$28,$26,$26
  370.     DC.B    $26,$26,$26,$26,$26,$26,$24,$24,$24,$24,$24,$24,$24,$24,$24,$24
  371.     DC.B    $24,$24,$24,$24,$24,$24,$24,$24,$24,$24,$26,$26,$26,$26,$26,$26
  372.     DC.B    $26,$26,$28,$28,$28,$28,$28,$28,$2A,$2A,$2A,$2A,$2A,$2C,$2C,$2C
  373.  
  374. ; Queste variabili contengono i valori degli indici per la prima colonna
  375.  
  376. IndiceR:    dc.w    0
  377. IndiceG:    dc.w    0
  378. IndiceB:    dc.w    0
  379.  
  380. ; Questa tabella contiene gli offset per l'indirizzo di partenza nella
  381. ; tabella dei colori
  382.  
  383. SinTab:
  384.     DC.W    $0034,$0036,$0038,$003A,$003C,$0040,$0042,$0044,$0046,$0048
  385.     DC.W    $004A,$004C,$004E,$0050,$0052,$0054,$0056,$0058,$005A,$005A
  386.     DC.W    $005C,$005E,$005E,$0060,$0060,$0062,$0062,$0062,$0064,$0064
  387.     DC.W    $0064,$0064,$0064,$0064,$0064,$0064,$0062,$0062,$0062,$0060
  388.     DC.W    $0060,$005E,$005E,$005C,$005A,$005A,$0058,$0056,$0054,$0052
  389.     DC.W    $0050,$004E,$004C,$004A,$0048,$0046,$0044,$0042,$0040,$003C
  390.     DC.W    $003A,$0038,$0036,$0034,$0030,$002E,$002C,$002A,$0028,$0024
  391.     DC.W    $0022,$0020,$001E,$001C,$001A,$0018,$0016,$0014,$0012,$0010
  392.     DC.W    $000E,$000C,$000A,$000A,$0008,$0006,$0006,$0004,$0004,$0002
  393.     DC.W    $0002,$0002,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000
  394.     DC.W    $0002,$0002,$0002,$0004,$0004,$0006,$0006,$0008,$000A,$000A
  395.     DC.W    $000C,$000E,$0010,$0012,$0014,$0016,$0018,$001A,$001C,$001E
  396.     DC.W    $0020,$0022,$0024,$0028,$002A,$002C,$002E,$0030
  397. EndSinTab:
  398.  
  399. ;****************************************************************************
  400.  
  401.     SECTION    GRAPHIC,DATA_C
  402.  
  403. ; Abbiamo 2 copperlists 
  404.  
  405. COPPERLIST1:
  406.  
  407. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  408. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  409.  
  410.     dcb.b    alt_plasm*BytesPerRiga,0
  411.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  412.  
  413. ;****************************************************************************
  414.  
  415. COPPERLIST2:
  416.  
  417. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  418. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  419.  
  420.     dcb.b    alt_plasm*BytesPerRiga,0
  421.  
  422.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  423.  
  424.  
  425. ;****************************************************************************
  426. ; Qui c'e` la tabella di colori che viene scritta nel plasma.
  427. ; Devono esserci abbastanza colori da essere letti qualunque sia l'indirizzo
  428. ; di partenza. In questo esempio l'indirizzo di partenza puo` variare da
  429. ; "Color" (primo colore) fino a "Color+100" (50-esimo colore), perche`
  430. ; 100 e` il massimo offset sontenuto nella "SinTab".
  431. ; Se Alt_plasm=190 vuol dire che ogni blittata legge 190 colori.
  432. ; Quindi in totale devono esserci 240 colori.
  433. ;****************************************************************************
  434.  
  435. Color:
  436.     dc.w    $0f00,$0f00,$0e00,$0e00,$0e00,$0d00,$0d00,$0d00
  437.     dc.w    $0c00,$0c00,$0c00,$0b00,$0b00,$0b00,$0a00,$0a00,$0a00
  438.     dc.w    $0900,$0900,$0900,$0800,$0800,$0800,$0700,$0700,$0700
  439.     dc.w    $0600,$0600,$0600,$0500,$0500,$0500,$0400,$0400,$0400
  440.     dc.w    $0300,$0300,$0300,$0200,$0200,$0200,$0100,$0100,$0100
  441.     dcb.w    18,0
  442.     dc.w    $0100,$0100,$0100,$0100,$0200,$0200,$0200,$0200
  443.     dc.w    $0300,$0300,$0300,$0300,$0400,$0400,$0400,$0400
  444.     dc.w    $0500,$0500,$0500,$0500,$0600,$0600,$0600,$0600
  445.     dc.w    $0700,$0700,$0700,$0700,$0800,$0800,$0800,$0800
  446.     dc.w    $0900,$0900,$0900,$0900,$0a00,$0a00,$0a00,$0a00
  447.     dc.w    $0b00,$0b00,$0b00,$0b00,$0c00,$0c00,$0c00,$0c00
  448.     dc.w    $0d00,$0d00,$0d00,$0d00,$0e00,$0e00,$0e00,$0e00
  449.     dc.w    $0f00,$0f00,$0f00,$0f00
  450.  
  451.     dc.w    $0f00,$0f00,$0f00,$0f00,$0e00,$0e00,$0e00,$0e00
  452.     dc.w    $0d00,$0d00,$0d00,$0d00,$0c00,$0c00,$0c00,$0c00
  453.     dc.w    $0b00,$0b00,$0b00,$0b00,$0a00,$0a00,$0a00,$0a00
  454.     dc.w    $0900,$0900,$0900,$0800,$0800,$0800,$0800
  455.     dc.w    $0700,$0700,$0700,$0700,$0600,$0600,$0600,$0600
  456.     dc.w    $0500,$0500,$0500,$0500,$0400,$0400,$0400,$0400
  457.     dc.w    $0300,$0300,$0300,$0300,$0200,$0200,$0200,$0200
  458.     dc.w    $0100,$0100,$0100
  459.     dcb.w    18,0
  460.     dc.w    $0100,$0100,$0100,$0200,$0200,$0200,$0300,$0300,$0300
  461.     dc.w    $0400,$0400,$0400,$0500,$0500,$0500,$0600,$0600,$0600
  462.     dc.w    $0700,$0700,$0700,$0800,$0800,$0900,$0900,$0900
  463.     dc.w    $0a00,$0a00,$0a00,$0b00,$0b00,$0b00,$0c00,$0c00,$0c00
  464.     dc.w    $0d00,$0d00,$0d00,$0e00,$0e00,$0e00,$0f00
  465.  
  466.     end
  467.  
  468. ;****************************************************************************
  469.  
  470. In questo esempio abbiamo un plasma RGB fatto per colonna, (cioe` i colori
  471. vengono blittati nella copperlist una colonna per volta) a cui aggiungiamo
  472. un' oscillazione orizzontale. Eseguendo il programma, all'inizio l'effetto
  473. oscillazione non e` attivo. Premendo il bottone destro lo si attiva.
  474. Per realizzare l'oscillazione ci vuole un plasma, piu` largo dello schermo,
  475. che sia dunque visibile solo in parte. Variando la posizione di partenza di
  476. ogni riga (cioe` la posizione orizzontale della WAIT di inizio riga), si
  477. possono mostrare differenti zone del plasma. Nel programma si assegna ad ogni
  478. riga una differente posizione di partenza che viene letta da una tabella
  479. sinusiodale. La lettura dalla tabella avviene nella stessa maniera delle
  480. tabelle delle componenti R,G,B. Anche per questa tabella gli incrementi a cui
  481. sono sottoposti gli indici possono essere variati agendo sui parametri che si
  482. trovano all'inizio del listato.
  483. Questo effetto ha una buona resa visiva quando i parametri "NuovaRigaX"
  484. delle componenti R,G,B assumono valori bassi. Aumentando tali valori
  485. (per es. 20) si evidenziano i limiti di questo effetto. In particolare
  486. l'ondulazione orizzontale e` fatta a scatti di 4 pixel, poiche` questa e`
  487. la minima risoluzione della WAIT. Vedremo in seguito come realizzare
  488. ondulazioni meno scalettate.
  489.  
  490.