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