home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti_darkcoder / plasma / plasm5.s < prev    next >
Encoding:
Text File  |  1995-12-06  |  18.3 KB  |  539 lines
  1.  
  2. ; Plasma5.s    Plasma RGB a 2-bitplanes e ondulazione
  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    36        ; larghezza del plasma espressa
  19.                     ; come numero di gruppi di 8 pixel
  20.  
  21. ; numero di bytes occupati nella copperlist da ogni riga del plasma: ogni
  22. ; istruzione copper occupa 4 bytes. Ogni riga e` formata da 1 "copper move" in
  23. ; BPLCON1, 1 WAIT,Largh_plasm "copper moves" per il plasma
  24.  
  25. BytesPerRiga    equ    (Largh_plasm+2)*4
  26.  
  27. Alt_plasm    equ    235        ; altezza del plasma espressa
  28.                     ; come numero di linee
  29.  
  30. NuovaRigaR    equ    6        ; 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    2        ; 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    -12        ; come "NuovaRigaR" ma per componente B
  44. NuovoFrameB    equ    -6        ; come "NuovoFrameR" ma componente B
  45.  
  46. NuovaRigaO    equ    12        ; come "NuovaRigaR" ma per oscillazioni
  47. NuovoFrameO    equ    -4        ; come "NuovoFrameR" ma oscillazioni
  48.  
  49.  
  50. START:
  51.  
  52. ;    Puntiamo i bitplanes nelle copperlist
  53.  
  54.     MOVE.L    #BITPLANE,d0    ; bitplane 1 (plasma)
  55.     LEA    COPPERLIST1,A1    ; puntatori COP 1
  56.     LEA    COPPERLIST2,A2    ; puntatori COP 2
  57.     move.w    d0,6(a1)    ; scrive in copperlist 1 
  58.     move.w    d0,6(a2)    ; scrive in copperlist 2
  59.     swap    d0
  60.     move.w    d0,2(a1)    ; scrive in copperlist 1
  61.     move.w    d0,2(a2)    ; scrive in copperlist 2
  62.  
  63.     MOVE.L    #PIC,d0        ; bitplane 2 (maschera)
  64.     move.w    d0,14(a1)    ; scrive in copperlist 1 
  65.     move.w    d0,14(a2)    ; scrive in copperlist 2
  66.     swap    d0
  67.     move.w    d0,10(a1)    ; scrive in copperlist 1
  68.     move.w    d0,10(a2)    ; scrive in copperlist 2
  69.  
  70.  
  71.     lea    $dff000,a5        ; CUSTOM REGISTER in a5
  72.  
  73.     bsr    InitPlasma        ; inizializza la copperlist
  74.  
  75. ; Inizializza i registri del blitter
  76.  
  77.     Btst    #6,2(a5)
  78. WaitBlit_init:
  79.     Btst    #6,2(a5)        ; aspetta il blitter
  80.     bne.s    WaitBlit_init
  81.  
  82.     move.l    #$4FFE8000,$40(a5)    ; BLTCON0/1 - D=A+B+C
  83.                     ; shift A = 4 pixel
  84.                     ; shift B = 8 pixel
  85.                     
  86.     moveq    #-1,d0            ; D0 = $FFFFFFFF
  87.     move.l    d0,$44(a5)        ; BLTAFWM/BLTALWM
  88.  
  89. mod_A    set    0            ; modulo canale A
  90. mod_D    set    BytesPerRiga-2        ; modulo canale D: va a riga seguente
  91.  
  92.     move.l    #mod_A<<16+mod_D,$64(a5)    ; carica i registri modulo
  93.  
  94. ; moduli canali B e C = 0
  95.  
  96.     moveq    #0,d0
  97.     move.l    d0,$60(a5)        ; scrive BLTBMOD e BLTCMOD
  98.  
  99.     MOVE.W    #DMASET,$96(a5)        ; DMACON - abilita bitplane, copper
  100.     move.l    #COPPERLIST1,$80(a5)    ; Puntiamo la nostra COP
  101.     move.w    d0,$88(a5)        ; Facciamo partire la COP
  102.  
  103. ; Inizializza altri registri hardware
  104. ; D0=0
  105.     move.w    d0,$1fc(a5)        ; Disattiva l'AGA
  106.     move.w    #$c00,$106(a5)        ; Disattiva l'AGA
  107.     move.w    #$11,$10c(a5)        ; Disattiva l'AGA
  108.     move.l    d0,$180(a5)        ; COLOR00 e COLOR01 - nero
  109.     move.w    #$3e90,$8e(a5)        ; DiwStrt - usiamo una finestra piu`
  110.                     ; piccola dello schermo
  111.     move.w    #$E6b1,$90(a5)        ; DiwStop
  112.     move.w    #$0036,$92(a5)        ; DDFStrt - vengono fetchati 40 bytes
  113.     move.w    #$00ce,$94(a5)        ; DDFStop
  114.     move.l    d0,$102(a5)        ; BPLCON1/2
  115.     move.w    #-40,$108(a5)        ; BPL1MOD = -40 ripete sempre la stessa
  116.                     ; riga
  117.     move.w    #0,$10a(a5)        ; BPL2MOD = 0 normale
  118.     move.w    #$2200,$100(a5)        ; BPLCON0 - 2 bitplane attivi
  119.  
  120. mouse2:
  121.     MOVE.L    #$1ff00,d1    ; bit per la selezione tramite AND
  122.     MOVE.L    #$13000,d2    ; linea da aspettare = $130, ossia 304
  123. Waity2:
  124.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  125.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  126.     CMPI.L    D2,D0        ; aspetta la linea $130 (304)
  127.     BNE.S    Waity2
  128.  
  129.     bsr    ScambiaClists    ; scambia le copperlist
  130.  
  131.     bsr    DoOriz        ; effetto oscillazione orizzontale
  132.     bsr    DoPlasma
  133.  
  134.     btst    #6,$bfe001    ; mouse premuto?
  135.     bne.s    mouse2
  136.  
  137.     rts
  138.  
  139. ;****************************************************************************
  140. ; Questa routine realizza l'effetto di oscillazione orizzontale. 
  141. ; L'effetto e` realizzato modificando ad ogni riga il valore di scroll hardware
  142. ; del bitplane 1. I valori vengono letti da una tabella e scritti nella
  143. ; copperlist.
  144. ;****************************************************************************
  145.  
  146. DoOriz:
  147.     lea    OrizTab(pc),a0        ; indirizzo tabella oscillazioni
  148.     move.l    draw_clist(pc),a1    ; indirizzo copperlist dove scrivere
  149.     lea    19(a1),a1        ; indirizzo secondo byte della seconda
  150.                     ; word della "copper move" in BPLCON1
  151. ; legge e modifica indice
  152.  
  153.     move.w    IndiceO(pc),d4        ; legge l'indice di partenza del
  154.                     ; frame precedente
  155.     sub.w    #NuovoFrameO,d4        ; modifica l'indice nella tabella
  156.                     ; dal frame precedente
  157.     and.w    #$007F,d4        ; tiene l'indice nell'intervallo
  158.                     ; 0 - 127 (offset in una tabella di
  159.                     ; 128 bytes)
  160.     move.w    d4,IndiceO        ; memorizza l'indice di partenza per
  161.                     ; il prossimo frame
  162.  
  163.     move.w    #Alt_plasm-1,d3        ; loop per ogni riga
  164. OrizLoop:
  165.     move.b    0(a0,d4.w),d0        ; leggi valore dell'oscillazione
  166.  
  167.     move.b    d0,(a1)            ; scrive il valore di scroll nella
  168.                     ; "copper move" in BPLCON1
  169.  
  170.     lea    BytesPerRiga(a1),a1    ; punta alla prossima riga 
  171.                     ; nella copper list
  172. ; modifica indice per prossima riga
  173.  
  174.     add.w    #NuovaRigaO,d4        ; modifica l'indice nella tabella
  175.                     ; per la prossima riga
  176.  
  177.     and.w    #$007F,d4        ; tiene l'indice nell'intervallo
  178.                     ; 0 - 127 (offset in una tabella di
  179.                     ; 128 bytes)
  180.  
  181.     dbra    d3,OrizLoop
  182.  
  183.     rts
  184.  
  185. ;****************************************************************************
  186. ; Questa routine realizza il "double buffer" tra le copperlist.
  187. ; In pratica prende la clist dove si e` disegnato, e la visualizza copiandone
  188. ; l'indirizzo in COP1LC. Scambia le variabili, in modo tale che nel frame
  189. ; che segue si disegna sull'altra copper list
  190. ;****************************************************************************
  191.  
  192. ScambiaClists:
  193.     move.l    draw_clist(pc),d0    ; indirizzo clist su cui si e` scritto
  194.     move.l    view_clist(pc),draw_clist    ; scambia le clists
  195.     move.l    d0,view_clist
  196.  
  197.     move.l    d0,$80(a5)        ; copia l'indirizzo della clist
  198.                     ; in COP1LC in maniera che venga
  199.                     ; visualizzata nel prossimo frame
  200.     rts
  201.  
  202.  
  203. ;****************************************************************************
  204. ; Questa routine inizializza la copperlist che genera il plasma. Sistema le
  205. ; istruzioni WAIT e le prima meta` delle COPPERMOVE.
  206. ;****************************************************************************
  207.  
  208. InitPlasma:
  209.     lea    Plasma1,a0    ; indirizzo plasma 1
  210.     lea    Plasma2,a1    ; indirizzo plasma 2
  211.     move.l    #$3e43FFFE,d0    ; carica la prima istruzione wait in D0.
  212.                 ; aspetta la riga $30 e la posizione
  213.                 ; orizzontale $24
  214.     move.w    #$184,d1    ; mette in D1 la prima meta` di un istruzione 
  215.                 ; "copper move" in COLOR02 (=$dff184)
  216.     move.w    #$186,d4    ; mette in D4 la prima meta` di un istruzione 
  217.                 ; "copper move" in COLOR03 (=$dff186)
  218.     move.w    #$102,d5    ; mette in D4 la prima meta` di un istruzione 
  219.                 ; "copper move" in BPLCON1 (=$dff102)
  220.  
  221.     move.w    #Alt_plasm-1,d3        ; loop per ogni riga
  222. InitLoop1:
  223.     move.w    d5,(a0)+        ; scrive la prima parte della
  224.                     ; "copper move" in BPLCON1 - clist 1
  225.     addq.w    #2,a0            ; spazio per la seconda parte
  226.                     ; della "copper move" - clist 1
  227.  
  228.     move.w    d5,(a1)+        ; scrive la prima parte della
  229.                     ; "copper move" in BPLCON1 - clist 2
  230.     addq.w    #2,a1            ; spazio per la seconda parte
  231.                     ; della "copper move" - clist 2
  232.  
  233.     move.l    d0,(a0)+        ; scrive la WAIT - (clist 1)
  234.     move.l    d0,(a1)+        ; scrive la WAIT - (clist 2)
  235.     add.l    #$01000000,d0        ; modifica la WAIT per aspettare
  236.                     ; la riga seguente
  237.  
  238.     moveq    #Largh_plasm/2-1,d2    ; loop per tutta la larghezza
  239.  
  240. InitLoop2:
  241.     move.w    d4,(a0)+        ; scrive la prima parte della
  242.                     ; "copper move" in COLOR02 - clist 1
  243.     addq.w    #2,a0            ; spazio per la seconda parte
  244.                     ; della "copper move" - clist 1
  245.  
  246.     move.w    d4,(a1)+        ; scrive la prima parte della
  247.                     ; "copper move" in COLOR02 - clist 2
  248.     addq.w    #2,a1            ; spazio per la seconda parte
  249.                     ; della "copper move" - clist 2
  250.  
  251.     move.w    d1,(a0)+        ; scrive la prima parte della
  252.                     ; "copper move" in COLOR03 - clist 1
  253.     addq.w    #2,a0            ; spazio per la seconda parte
  254.                     ; della "copper move" - clist 1
  255.  
  256.     move.w    d1,(a1)+        ; scrive la prima parte della
  257.                     ; "copper move" in COLOR03 - clist 2
  258.     addq.w    #2,a1            ; spazio per la seconda parte
  259.                     ; della "copper move" - clist 2
  260.     dbra    d2,InitLoop2
  261.     dbra    d3,InitLoop1
  262.     rts
  263.  
  264.  
  265. ;****************************************************************************
  266. ; Questa routine realizza il plasma. Effettua un loop di blittate, ciascuna
  267. ; delle quali scrive una "colonna" del plasma, cioe` scrive i colori nelle
  268. ; COPPERMOVES messe in colonna.
  269. ; I colori scritti in ogni colonna sono letti da una tabella, a partire da
  270. ; un indirizzo che varia tra una colonna e l'altra in base a degli offset
  271. ; letti da un'altra tabella. Inoltre tra un frame e l'altro gli offset
  272. ; variano, realizzando l'effetto di movimento.
  273. ;****************************************************************************
  274.  
  275. DoPlasma:
  276.     lea    Color,a0        ; indirizzo colori
  277.     lea    SinTab,a6        ; indirizzo tabella offsets
  278.     move.l    draw_clist(pc),a1    ; indirizzo copperlist dove scrivere
  279.     lea    26(a1),a1        ; indirizzo prima word della prima
  280.                     ; colonna del plasma
  281. ; legge e modifica indice componente R
  282.  
  283.     move.w    IndiceR(pc),d4        ; legge l'indice di partenza del
  284.                     ; frame precedente
  285.     sub.w    #NuovoFrameR,d4        ; modifica l'indice nella tabella
  286.                     ; dal frame precedente
  287.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  288.                     ; 0 - 255 (offset in una tabella di
  289.                     ; 128 words)
  290.     move.w    d4,IndiceR        ; memorizza l'indice di partenza per
  291.                     ; il prossimo frame
  292. ; legge e modifica indice componente G
  293.  
  294.     move.w    IndiceG(pc),d5        ; legge l'indice di partenza del
  295.                     ; frame precedente
  296.     sub.w    #NuovoFrameG,d5        ; modifica l'indice nella tabella
  297.                     ; dal frame precedente
  298.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  299.                     ; 0 - 255 (offset in una tabella di
  300.                     ; 128 words)
  301.     move.w    d5,IndiceG        ; memorizza l'indice di partenza per
  302.                     ; il prossimo frame
  303. ; legge e modifica indice componente B
  304.  
  305.     move.w    IndiceB(pc),d6        ; legge l'indice di partenza del
  306.                     ; frame precedente
  307.     sub.w    #NuovoFrameB,d6        ; modifica l'indice nella tabella
  308.                     ; dal frame precedente
  309.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  310.                     ; 0 - 255 (offset in una tabella di
  311.                     ; 128 words)
  312.     move.w    d6,IndiceB        ; memorizza l'indice di partenza per
  313.                     ; il prossimo frame
  314.  
  315.     move.w    #Alt_plasm<<6+1,d3    ; dimensione blittata
  316.                     ; largh. 1 word, alta tutto il plasma
  317.  
  318.     moveq    #Largh_plasm-1,d2    ; il loop NON viene ripetuto per tutta
  319.                     ; la larghezza. Le ultime 2 colonne
  320.                     ; vengono lascate stare in modo che
  321.                     ; esse riscrivano il colore nero nei
  322.                     ; registri COLOR01 e COLOR00
  323.  
  324. PlasmaLoop:                ; inizio loop blittate
  325.  
  326. ; calcola indirizzo di partenza componente R
  327.  
  328.     move.w    (a6,d4.w),d1        ; legge offset dalla tabella
  329.  
  330.     lea    (a0,d1.w),a2        ; indirizzo di partenza = ind. colori
  331.                     ; piu` offset
  332.  
  333. ; calcola indirizzo di partenza componente G
  334.  
  335.     move.w    (a6,d5.w),d1        ; legge offset dalla tabella
  336.  
  337.     lea    (a0,d1.w),a3        ; indirizzo di partenza = ind. colori
  338.                     ; piu` offset
  339.  
  340. ; calcola indirizzo di partenza componente B
  341.  
  342.     move.w    (a6,d6.w),d1        ; legge offset dalla tabella
  343.  
  344.     lea    (a0,d1.w),a4        ; indirizzo di partenza = ind. colori
  345.                     ; piu` offset
  346.  
  347.     Btst    #6,2(a5)
  348. WaitBlit:
  349.     Btst    #6,2(a5)        ; aspetta il blitter
  350.     bne.s    WaitBlit
  351.  
  352.     move.l    a2,$48(a5)        ; BLTCPT - indirizzo sorgente R
  353.     move.l    a3,$50(a5)        ; BLTAPT - indirizzo sorgente G
  354.     move.l    a4,$4C(a5)        ; BLTBPT - indirizzo sorgente B
  355.     move.l    a1,$54(a5)        ; BLTDPT - indirizzo destinazione
  356.     move.w    d3,$58(a5)        ; BLTSIZE
  357.  
  358.     addq.w    #4,a1            ; punta a prossima colonna di 
  359.                     ; "copper moves" nella copper list
  360.  
  361. ; modifica indice componente R per prossima riga
  362.  
  363.     add.w    #NuovaRigaR,d4        ; modifica l'indice nella tabella
  364.                     ; per la prossima riga
  365.  
  366.     and.w    #$00FF,d4        ; tiene l'indice nell'intervallo
  367.                     ; 0 - 255 (offset in una tabella di
  368.                     ; 128 words)
  369.  
  370. ; modifica indice componente G per prossima riga
  371.  
  372.     add.w    #NuovaRigaG,d5        ; modifica l'indice nella tabella
  373.                     ; per la prossima riga
  374.  
  375.     and.w    #$00FF,d5        ; tiene l'indice nell'intervallo
  376.                     ; 0 - 255 (offset in una tabella di
  377.                     ; 128 words)
  378.  
  379. ; modifica indice componente B per prossima riga
  380.  
  381.     add.w    #NuovaRigaB,d6        ; modifica l'indice nella tabella
  382.                     ; per la prossima riga
  383.  
  384.     and.w    #$00FF,d6        ; tiene l'indice nell'intervallo
  385.                     ; 0 - 255 (offset in una tabella di
  386.                     ; 128 words)
  387.     dbra    d2,PlasmaLoop
  388.     rts
  389.  
  390.  
  391. ; Queste 2 variabili contengono gli indirizzi delle 2 copperlist
  392.  
  393. view_clist:    dc.l    COPPERLIST1    ; indirizzo clist visualizzata
  394. draw_clist:    dc.l    COPPERLIST2    ; indirizzo clist dove disegnare
  395.  
  396. ; Questa variabile contiene il valore dell'indice nella tabella delle
  397. ; oscillazioni (posizioni orizzontali delle WAIT)
  398.  
  399. IndiceO:    dc.w    0
  400.  
  401. ; Questa tabella contiene i valori delle oscillazioni (valori di scroll del
  402. ; bitplane 1)
  403.  
  404. OrizTab:
  405.     DC.B    $03,$03,$03,$03,$04,$04,$04,$04,$04,$04,$04,$05,$05,$05,$05,$05
  406.     DC.B    $05,$05,$05,$05,$05,$06,$06,$06,$06,$06,$06,$06,$06,$06,$06,$06
  407.     DC.B    $06,$06,$06,$06,$06,$06,$06,$06,$06,$06,$06,$06,$05,$05,$05,$05
  408.     DC.B    $05,$05,$05,$05,$05,$05,$04,$04,$04,$04,$04,$04,$04,$03,$03,$03
  409.     DC.B    $03,$03,$03,$03,$02,$02,$02,$02,$02,$02,$02,$01,$01,$01,$01,$01
  410.     DC.B    $01,$01,$01,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00
  411.     DC.B    $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01,$01,$01
  412.     DC.B    $01,$01,$01,$01,$01,$01,$02,$02,$02,$02,$02,$02,$02,$03,$03,$03
  413.  
  414. ; Queste variabili contengono i valori degli indici per la prima colonna
  415.  
  416. IndiceR:    dc.w    0
  417. IndiceG:    dc.w    0
  418. IndiceB:    dc.w    0
  419.  
  420. ; Questa tabella contiene gli offset per l'indirizzo di partenza nella
  421. ; tabella dei colori
  422.  
  423. SinTab:
  424.     DC.W    $0034,$0036,$0038,$003A,$003C,$0040,$0042,$0044,$0046,$0048
  425.     DC.W    $004A,$004C,$004E,$0050,$0052,$0054,$0056,$0058,$005A,$005A
  426.     DC.W    $005C,$005E,$005E,$0060,$0060,$0062,$0062,$0062,$0064,$0064
  427.     DC.W    $0064,$0064,$0064,$0064,$0064,$0064,$0062,$0062,$0062,$0060
  428.     DC.W    $0060,$005E,$005E,$005C,$005A,$005A,$0058,$0056,$0054,$0052
  429.     DC.W    $0050,$004E,$004C,$004A,$0048,$0046,$0044,$0042,$0040,$003C
  430.     DC.W    $003A,$0038,$0036,$0034,$0030,$002E,$002C,$002A,$0028,$0024
  431.     DC.W    $0022,$0020,$001E,$001C,$001A,$0018,$0016,$0014,$0012,$0010
  432.     DC.W    $000E,$000C,$000A,$000A,$0008,$0006,$0006,$0004,$0004,$0002
  433.     DC.W    $0002,$0002,$0000,$0000,$0000,$0000,$0000,$0000,$0000,$0000
  434.     DC.W    $0002,$0002,$0002,$0004,$0004,$0006,$0006,$0008,$000A,$000A
  435.     DC.W    $000C,$000E,$0010,$0012,$0014,$0016,$0018,$001A,$001C,$001E
  436.     DC.W    $0020,$0022,$0024,$0028,$002A,$002C,$002E,$0030
  437. EndSinTab:
  438.  
  439. ;****************************************************************************
  440.  
  441.     SECTION    GRAPHIC,DATA_C
  442.  
  443. ; Abbiamo 2 copperlists 
  444.  
  445. COPPERLIST1:
  446.     dc.w    $e0,$0000,$e2,$0000    ; bitplane 1
  447.     dc.w    $e4,$0000,$e6,$0000    ; bitplane 2
  448.  
  449. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  450. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  451.  
  452. PLASMA1:
  453.     dcb.b    alt_plasm*BytesPerRiga,0
  454.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  455.  
  456. ;****************************************************************************
  457.  
  458. COPPERLIST2:
  459.     dc.w    $e0,$0000,$e2,$0000    ; bitplane 1
  460.     dc.w    $e4,$0000,$e6,$0000    ; bitplane 2
  461.  
  462. ; Qui viene lasciato dello spazio vuoto per il pezzo di copperlist che genera
  463. ; il plasma. Questo spazio viene riempito dalle routine dell'effetto.
  464.  
  465. PLASMA2:
  466.     dcb.b    alt_plasm*BytesPerRiga,0
  467.  
  468.     dc.w    $FFFF,$FFFE    ; Fine della copperlist
  469.  
  470.  
  471. ;****************************************************************************
  472. ; Qui c'e` la tabella di colori che viene scritta nel plasma.
  473. ; Devono esserci abbastanza colori da essere letti qualunque sia l'indirizzo
  474. ; di partenza. In questo esempio l'indirizzo di partenza puo` variare da
  475. ; "Color" (primo colore) fino a "Color+100" (50-esimo colore), perche`
  476. ; 100 e` il massimo offset sontenuto nella "SinTab".
  477. ; Se Alt_plasm=190 vuol dire che ogni blittata legge 190 colori.
  478. ; Quindi in totale devono esserci 240 colori.
  479. ;****************************************************************************
  480.  
  481. Color:
  482.     dc.w    $0f00,$0f00,$0e00,$0e00,$0e00,$0d00,$0d00,$0d00
  483.     dc.w    $0c00,$0c00,$0c00,$0b00,$0b00,$0b00,$0a00,$0a00,$0a00
  484.     dc.w    $0900,$0900,$0900,$0800,$0800,$0800,$0700,$0700,$0700
  485.     dc.w    $0600,$0600,$0600,$0500,$0500,$0500,$0400,$0400,$0400
  486.     dc.w    $0300,$0300,$0300,$0200,$0200,$0200,$0100,$0100,$0100
  487.     dcb.w    18,0
  488.     dc.w    $0100,$0100,$0100,$0100,$0200,$0200,$0200,$0200
  489.     dc.w    $0300,$0300,$0300,$0300,$0400,$0400,$0400,$0400
  490.     dc.w    $0500,$0500,$0500,$0500,$0600,$0600,$0600,$0600
  491.     dc.w    $0700,$0700,$0700,$0700,$0800,$0800,$0800,$0800
  492.     dc.w    $0900,$0900,$0900,$0900,$0a00,$0a00,$0a00,$0a00
  493.     dc.w    $0b00,$0b00,$0b00,$0b00,$0c00,$0c00,$0c00,$0c00
  494.     dc.w    $0d00,$0d00,$0d00,$0d00,$0e00,$0e00,$0e00,$0e00
  495.     dc.w    $0f00,$0f00,$0f00,$0f00
  496.  
  497.     dc.w    $0f00,$0f00,$0f00,$0f00,$0e00,$0e00,$0e00,$0e00
  498.     dc.w    $0d00,$0d00,$0d00,$0d00,$0c00,$0c00,$0c00,$0c00
  499.     dc.w    $0b00,$0b00,$0b00,$0b00,$0a00,$0a00,$0a00,$0a00
  500.     dc.w    $0900,$0900,$0900,$0800,$0800,$0800,$0800
  501.     dc.w    $0700,$0700,$0700,$0700,$0600,$0600,$0600,$0600
  502.     dc.w    $0500,$0500,$0500,$0500,$0400,$0400,$0400,$0400
  503.     dc.w    $0300,$0300,$0300,$0300,$0200,$0200,$0200,$0200
  504.     dc.w    $0100,$0100,$0100
  505.     dcb.w    18,0
  506.     dc.w    $0100,$0100,$0100,$0200,$0200,$0200,$0300,$0300,$0300
  507.     dc.w    $0400,$0400,$0400,$0500,$0500,$0500,$0600,$0600,$0600
  508.     dc.w    $0700,$0700,$0700,$0800,$0800,$0900,$0900,$0900
  509.     dc.w    $0a00,$0a00,$0a00,$0b00,$0b00,$0b00,$0c00,$0c00,$0c00
  510.     dc.w    $0d00,$0d00,$0d00,$0e00,$0e00,$0e00,$0f00
  511.  
  512. ; Riga dell'immagine che viene ripetuta con il BPLMOD1
  513. ; e` formata da 40 bytes alternativamente a 0 o a $FF
  514.  
  515. BITPLANE:    dcb.w    20,$00FF
  516.  
  517. ; Maschera del plasma: e` un immagine 320*168 pixel a 1 bitplane
  518.  
  519. Pic:    incbin    plasm_msk.raw
  520.  
  521.     end
  522.  
  523. ;****************************************************************************
  524.  
  525. In questo esempio vediamo un plasma a 2 bitplanes. Si tratta di una
  526. semplice variante del plasma 1 bitplane. Si usa il bitplane 1 per fare il
  527. plasma e il 2 come maschera. Il plasma utilizza i colori 2 e 3.
  528. Quindi il plasma apparira` in corrispondenza dei pixel di valore 1 del
  529. bitplane maschera.
  530. Questa tecnica ha anche il vantaggio che non e` necessario scrivere il nero
  531. alla fine della riga, perche` il colore 0 (di sfondo) non viene toccato.
  532. In questo modo, possiamo utilizzare un plasma piu` stretto rispetto a quello
  533. usato nell'esempio plasm4.s anche se la larghezza visibile e` la stessa
  534. (risparmiamo le ultime 2 "copper moves" di ogni riga; confrontate i diversi
  535. valori del parametro "Largh_plasm").
  536. Ovviamente il bitplane di maschera viene visualizzato normalmente, quindi
  537. senza scroll e con modulo azzerato.
  538.  
  539.