home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti7 / lezione11l5b.s < prev    next >
Text File  |  1995-09-29  |  10KB  |  300 lines
  1.  
  2. ; Lezione11l5b.s   - "Zoom" di un'animazione che misura solo 40*29 pixel.
  3. ;             La risoluzione finale e' 320*232, ossia 8 volte tanto.
  4. ;             VERSIONE OTTIMIZZATA MEDIANTE L'USO DEL TABELLAMENTO!
  5.  
  6.     Section ZoomaPer8,code
  7.  
  8. ;    Include    "DaWorkBench.s"    ; togliere il ; prima di salvare con "WO"
  9.  
  10. *****************************************************************************
  11.     include    "startup2.s"    ; salva interrupt, dma eccetera.
  12. *****************************************************************************
  13.  
  14. ; Con DMASET decidiamo quali canali DMA aprire e quali chiudere
  15.  
  16.         ;5432109876543210
  17. DMASET    EQU    %1000001110000000    ; copper,bitplane DMA abilitati
  18.  
  19. WaitDisk    EQU    30    ; 50-150 al salvataggio (secondo i casi)
  20.  
  21. scr_bytes    = 40    ; Numero di bytes per ogni linea orizzontale.
  22.             ; Da questa si calcola la larghezza dello schermo,
  23.             ; moltiplicando i bytes per 8: schermo norm. 320/8=40
  24.             ; Es. per uno schermo largo 336 pixel, 336/8=42
  25.             ; larghezze esempio:
  26.             ; 264 pixel = 33 / 272 pixel = 34 / 280 pixel = 35
  27.             ; 360 pixel = 45 / 368 pixel = 46 / 376 pixel = 47
  28.             ; ... 640 pixel = 80 / 648 pixel = 81 ...
  29.  
  30. scr_h        = 256    ; Altezza dello schermo in linee
  31. scr_x        = $81    ; Inizio schermo, posizione XX (normale $xx81) (129)
  32. scr_y        = $2c    ; Inizio schermo, posizione YY (normale $2cxx) (44)
  33. scr_res        = 1    ; 2 = HighRes (640*xxx) / 1 = LowRes (320*xxx)
  34. scr_lace    = 0    ; 0 = non interlace (xxx*256) / 1 = interlace (xxx*512)
  35. ham        = 0    ; 0 = non ham / 1 = ham
  36. scr_bpl        = 3    ; Numero Bitplanes
  37.  
  38. ; parametri calcolati automaticamente
  39.  
  40. scr_w        = scr_bytes*8        ; larghezza dello schermo
  41. scr_size    = scr_bytes*scr_h    ; dimensione in bytes dello schermo
  42. BPLC0    = ((scr_res&2)<<14)+(scr_bpl<<12)+$200+(scr_lace<<2)+(ham<<11)
  43. DIWS    = (scr_y<<8)+scr_x
  44. DIWSt    = ((scr_y+scr_h/(scr_lace+1))&255)<<8+(scr_x+scr_w/scr_res)&255
  45. DDFS    = (scr_x-(16/scr_res+1))/2
  46. DDFSt    = DDFS+(8/scr_res)*(scr_bytes/2-scr_res)
  47.  
  48.  
  49. START:
  50.     move.l    #planexpand,d0    ; bitplanebuffer
  51.     LEA    BPLPOINTERS,A0
  52.     MOVE.W    #3-1,D7        ; Numero planes
  53. PointAnim:
  54.     MOVE.W    D0,6(A0)
  55.     SWAP    D0
  56.     MOVE.W    D0,2(A0)
  57.     ADDQ.W    #8,A0
  58.     SWAP    D0
  59.     ADDI.L    #40*29,D0    ; lunghezza del bitplane di 1 frame
  60.     DBRA    D7,PointAnim
  61.  
  62.     bsr.w    PrecalcoTabba    ; Fai tab turbo con bytes "espansi" precalcol.
  63.  
  64.     bsr.w    FaiCopallung    ; Fai la copperlist che allunga *8 coi moduli
  65.  
  66.     MOVE.W    #DMASET,$96(a5)        ; DMACON - abilita bitplane, copper
  67.                     ; e sprites.
  68.     move.l    #COPPER,$80(a5)        ; Puntiamo la nostra COP
  69.     move.w    d0,$88(a5)        ; Facciamo partire la COP
  70.     move.w    #0,$1fc(a5)        ; Disattiva l'AGA
  71.     move.w    #$c00,$106(a5)        ; Disattiva l'AGA
  72.     move.w    #$11,$10c(a5)        ; Disattiva l'AGA
  73.  
  74. mouse:
  75.     MOVE.L    #$1ff00,d1    ; bit per la selezione tramite AND
  76.     MOVE.L    #$11500,d2    ; linea da aspettare = $115
  77. Waity1:
  78.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  79.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  80.     CMPI.L    D2,D0        ; aspetta la linea $115
  81.     BNE.S    Waity1
  82. Waity2:
  83.     MOVE.L    4(A5),D0    ; VPOSR e VHPOSR - $dff004/$dff006
  84.     ANDI.L    D1,D0        ; Seleziona solo i bit della pos. verticale
  85.     CMPI.L    D2,D0        ; aspetta la linea $115
  86.     BEQ.S    Waity2
  87.  
  88.     bsr.w    CambiaFrame    ; Espandi orizzontalmente il frame attuale
  89.                 ; di 8 volte: in pratica ogni bit diventa
  90.                 ; un byte.
  91.  
  92.     btst    #6,$bfe001    ; Mouse premuto?
  93.     bne.s    mouse
  94.     rts            ; esci
  95.  
  96. ****************************************************************************
  97. ; Routine che esegue "ZoomaFrame" ogni 7 fotogrammi, per rallentare
  98. ****************************************************************************
  99.  
  100. CambiaFrame:
  101.     addq.b    #1,WaitFlag
  102.     cmp.b    #7,WaitFlag    ; Sono passati 7 frames? (per rallentare)
  103.     bne.s    NonOra
  104.     clr.b    WaitFlag
  105.     bsr.w    ZoomaFrame    ; Se si, "espandiamo" il prossimo frame!
  106. NonOra:
  107.     rts
  108.  
  109. WaitFlag:
  110.     dc.w    0
  111.  
  112. ****************************************************************************
  113. ; "espansione" delle pic: viene testato ogni bit, e a seconda se quest'ultimo
  114. ; e' settato o azzerato, viene immesso un byte $FF o $00.
  115. ; Questa e' una versione OTTIMIZZATA che fa uso di una tabella che contiene
  116. ; i valori "espansi" per ogni byte possibile (uno dei 256 possibili).
  117. ****************************************************************************
  118.  
  119. ;        .----.
  120. ;    ___ `-/\-' ____
  121. ;    \_ \_/  \_/ __/
  122. ;      \___  ___/
  123. ;       _(_\/_)_
  124. ;       \  `'  /
  125. ;        \``''/
  126. ;        :\  /:
  127. ;        ! \/ !
  128. ;         _|l_
  129.  
  130. ZoomaFrame:
  131.     move.l    AnimPointer(PC),A0 ; Fotogramma piccolo attuale (40*29)
  132.     lea    Planexpand,A1       ; Buffer destinazione (per 320*29)
  133.     MOVE.W    #(5*29*3)-1,D7       ; 5 bytes a linea * 29 linee * 3 bitplanes
  134. Animloop:
  135.     moveq    #0,d0
  136.     move.b    (A0)+,d0    ; Prossimo byte in d0
  137.     lsl.w    #3,d0        ; d0*8 per trovare il valore nella tabba
  138.                 ; (ossia l'offset dal suo inizio)
  139.     lea    Precalctabba,a2
  140.     lea    0(a2,d0.w),a2    ; In a2 l'indirizzo nella tabba degli 8 byte
  141.                 ; giusti per "l'espansione" degli 8 bit.
  142.     move.l    (a2)+,(a1)+    ; 4 bytes espansi
  143.     move.l    (a2),(a1)+    ; 4 bytes espansi (totale 8 bytes!!)
  144.  
  145.     DBRA    D7,Animloop    ; Converti tutto il fotogramma
  146.  
  147.     add.l    #(5*29)*3,AnimPointer    ; Punta al prossimo fotogramma
  148.     move.l    AnimPointer(PC),A0
  149.     lea    FineAnim(PC),a1
  150.     cmp.l    a0,a1            ; Era l'ultimo fotogramma?
  151.     bne.s    NonRiparti
  152.     move.l    #cannoanim,AnimPointer    ; Se si, ripartiamo dal primo
  153. NonRiparti:
  154.     rts
  155.  
  156. AnimPointer:
  157.     dc.l    cannoanim
  158.  
  159. ****************************************************************************
  160. ; Routine che crea la copperlist che allunga la pic di 8 volte, usando i
  161. ; moduli in questo modo: waita una linea, poi mette i moduli a 0, in modo
  162. ; che si scatti alla linea dopo, poi riwaita la linea sotto e mette il
  163. ; modulo a -40, in modo che la stessa linea venga "replicata" ogni linea
  164. ; sotto. Dopo 7 linee waita, mette il modulo a 0 per una linea, facendo
  165. ; scattare a quella sotto, poi rimette il modulo a -40 per altre 7 linee
  166. ; per replicarla. Il risultato e' che ogni linea e' ripetuta 8 volte.
  167. ****************************************************************************
  168.  
  169. FaiCopallung:
  170.     lea    AllungaCop,a0    ; Buffer in copperlist
  171.     move.l    #$3407fffe,d0    ; wait start
  172.     move.l    #$1080000,d1    ; bpl1mod 0
  173.     move.l    #$10a0000,d2    ; bpl2mod 0
  174.     move.l    #$108FFD8,d3    ; bpl1mod -40
  175.     move.l    #$10aFFD8,d4    ; bpl1mod -40
  176.     moveq    #28-1,d7    ; numero di loops
  177. FaiCoppa:
  178.     move.l    d0,(a0)+    ; wait1
  179.     move.l    d1,(a0)+    ; bpl1mod = 0
  180.     move.l    d2,(a0)+    ; bpl2mod = 0
  181.     add.l    #$01000000,d0    ; salta 1 linea
  182.     move.l    d0,(a0)+    ; wait2
  183.     move.l    d3,(a0)+    ; bpl1mod = -40
  184.     move.l    d4,(a0)+    ; bpl2mod = -40
  185.     add.l    #$07000000,d0    ; salta 7 linee
  186.     cmp.l    #$0407fffe,d0    ; Siamo sotto $ff?
  187.     bne.s    NonPAl
  188.     move.l    #$ffdffffe,(a0)+ ; per accedere alla zona pal
  189. NonPal:
  190.     dbra    d7,FaiCoppa
  191.     move.l    d0,(a0)+    ; wait finale
  192.     rts
  193.  
  194. ****************************************************************************
  195. ; Routine che precalcola tutti i possibili 8 bytes abbinati ai possibili
  196. ; 8 bit. Per tutti si intende $FF, ossia 255.
  197. ****************************************************************************
  198.  
  199. PrecalcoTabba:
  200.     lea    Precalctabba,a1    ; Destinazione
  201.     moveq    #0,d0        ; Parti dal valore zero
  202. FaiTabba:
  203.     MOVEQ    #8-1,D1        ; 8 bit da controllare e espandere.
  204. BYTELOOP:
  205.     BTST.l    D1,d0        ; Testa il bit del loop attuale
  206.     BEQ.S    bitclear    ; E' azzerato?
  207.     ST.B    (A1)+        ; Se no, setta il byte (=$FF)
  208.     BRA.S    bitset
  209. bitclear:
  210.     clr.B    (A1)+        ; Se e' azzerato, azzera il byte
  211. bitset:
  212.     DBRA    D1,BYTELOOP    ; Controlla ed espandi tutti i bit del byte:
  213.                 ; D1 calando ogni volta fa fare il btst di
  214.                 ; tutti i bit.
  215.     ADDQ.W    #1,D0        ; Prossimo valore
  216.     CMP.W    #256,d0        ; Li abbiamo fatti tutti? (max $FF)
  217.     bne.s    FaiTabba
  218.     rts
  219.  
  220. ****************************************************************************
  221. ; ANIMAZIONE: 8 fotogrammi larghi 40*29 pixel, a 8 colori (3 bitplanes)
  222. ****************************************************************************
  223.  
  224. ; Animazione. ogni frame misura 40*29 pixel, 3 bitplanes. Tot. 8 frames
  225.  
  226. cannoanim:
  227.     incbin    "frame1"    ; 40*29 a 3 bitplanes (8 colori)
  228.     incbin    "frame2"
  229.     incbin    "frame3"
  230.     incbin    "frame4"
  231.     incbin    "frame5"
  232.     incbin    "frame6"
  233.     incbin    "frame7"
  234.     incbin    "frame8"
  235. FineAnim:
  236.  
  237. ****************************************************************************
  238. ;            COPPERLISTOZZA
  239. ****************************************************************************
  240.  
  241.     Section    Copper,DATA_C
  242.  
  243. COPPER:
  244.     dc.w    $8e,DIWS    ; DiwStrt
  245.     dc.w    $90,DIWSt    ; DiwStop
  246.     dc.w    $92,DDFS    ; DdfStart
  247.     dc.w    $94,DDFSt    ; DdfStop
  248.  
  249.     dc.w    $102,0        ; BplCon1
  250.     dc.w    $104,0        ; BplCon2
  251.     dc.w    $108,0        ; Bpl1Mod
  252.     dc.w    $10a,0        ; Bpl2Mod
  253.  
  254. BPLPOINTERS:
  255.     dc.w $e0,0,$e2,0        ;primo      bitplane
  256.     dc.w $e4,0,$e6,0        ;secondo    "
  257.     dc.w $e8,0,$ea,0        ;terzo      "
  258.  
  259. ; 8 Colori
  260.  
  261.     dc.w    $180,$000,$182,$080,$184,$8c6
  262.     dc.w    $186,$c20,$188,$d50,$18a,$e80,$18c,$0fb0
  263.     dc.w    $18e,$ff0
  264.  
  265.     dc.w    $2c07,$FFFE    ; wait
  266.  
  267.     dc.w    $100,BPLC0    ; bplcon0 - 3 planes
  268.  
  269.     dc.w    $108,-40    ; modulo negativo - ripeti stessa linea!
  270.     dc.w    $10A,-40
  271. AllungaCop:
  272.     ds.b    6*4*28        ; 2 wait + 4 move = 6*4 bytes * 21 loops
  273.                 ; Questa copperlist allunga *8 cio' che e'
  274.                 ; visualizzato, usando i moduli 0 e -40
  275.                 ; alternati ogni 8 linee.
  276.     ds.b    4*2        ; Per il $ffdffffe e per l'ultimo wait
  277.  
  278.     dc.w    $100,$200    ; bplcon0 - no bitplanes
  279.     dc.w    $FFFF,$FFFE    ; Fine copperlist
  280.  
  281. ****************************************************************************
  282. ; Buffer per la tabella per lo zoom "precalcolato"
  283. ****************************************************************************
  284.  
  285.     section    precalcolone,bss
  286.  
  287. PrecalcTabba:
  288.     ds.b    256*8
  289.  
  290. ****************************************************************************
  291. ; Buffer dove viene "espanso" ogni fotogramma.
  292. ****************************************************************************
  293.  
  294.     SECTION    BitPlanes,BSS_C
  295.  
  296. PLANEXPAND:            ; Dove viene espanso ogni fotogramma.
  297.     ds.b    40*29*3        ; 40 bytes * 29 linee * 3 bitplanes
  298.  
  299.     end
  300.