*
* Demo für den Blitter-Kopiermodus
*
* written on 10/11/89  14:21:55  by Holger Gzella
*

                incdir "asm:"
                include "exec/exec_lib.i"
                include "graphics/graphics_lib.i"

MEMREQS         EQU     $10000|$2               * CHIP u. clear

StartProg:      lea     GfxName,a1              * Graphics öffnen
                moveq   #0,d0
                CALLEXEC OpenLibrary
                move.l  d0,GfxBase

                move.l  #2000,d0                * 2000 Bytes
                move.l  #MEMREQS,d1             * CHIP-Memory
                CALLEXEC AllocMem               * allokieren
                tst.l   d0                      * alles klar?
                beq     Fault                   * nein - beenden!
                move.l  d0,CopperList           * Zeiger sichern

                move.l  #40*256,d0              * Speicher
                move.l  #MEMREQS,d1             * für Bitplane
                CALLEXEC AllocMem               * allokieren
                tst.l   d0                      * hat's geklappt?
                beq     Fault2                  * nein!
                move.l  d0,Bitplane             * Zeiger retten

                move.l  #Length,d0              * Speicher
                move.l  #MEMREQS,d1             * für das Programm
                CALLEXEC AllocMem               * allokieren
                tst.l   d0                      * hat's geklappt?
                beq     Fault3                  * nein!
                move.l  d0,Programm             * Zeiger retten

*
* Das Programm muß nun in den allokierten Speicher
* kopiert werden ...
*

                lea     StartProg,a0
                move.l  Programm,a1
                move.w  #Length,d0

Copy:           move.b  (a0)+,(a1)+
                dbra    d0,Copy

                move.l  GfxBase,a6              * GfxBase laden
                jsr     _LVOOwnBlitter(a6)      * auch wenn das Multitasking
                                                * abgeschaltet wird, sollte
                                                * der Blitter IMMER mit
                                                * OwnBlitter übernommen
                                                * werden!
                jsr     _LVOWaitBlit(a6)        * auf Blitter warten

*
* An dieser Stelle wird der Rechner übernommen.
*

                CALLEXEC Forbid                 * kein Multitasking
                move.w  #$3e0,$DFF096           * Copper-, Sprite- und
                                                * andere DMAs sowie DMAEN
                                                * löschen

*
* Nun wird die Copperlist erstellt - KEIN Farbverlauf,
* ist doch mal was anderes, oder?
*

                move.l  CopperList,a0           * Copperlist nach a0
                move.l  Bitplane,d2             * Bitplane nach d2
                swap    d2                      * auf oberes Word richten

*
* Hier werden erstmal die Bitplane-Zeiger zurückgesetzt.
*

                move.w  #$0E0,(a0)+             * Register: BPL1PTH
                move.w  d2,(a0)+                * oberes Word des Plane-
                                                * zeigers setzen
                move.w  #$0E2,(a0)+             * Register: BPL1PTL
                swap    d2                      * unteres Word holen
                move.w  d2,(a0)+                * und setzen

*
* Jetzt geht's recht normal weiter ...
*

                move.w  #$180,(a0)+             * Farbe:
                move.w  #$000,(a0)+             * schwarzer Hintergrund
                move.l  #$fffffffe,(a0)         * Ende!

                move.l  CopperList,$DFF080      * List manipulieren
                move.w  #0,$DFF088              * COPJMP1 löschen

                move.w  #$2981,$DFF08E          * DIWSTRT setzen
                move.w  #$29C1,$DFF090          * DIWSTOP setzen
                move.w  #$0038,$DFF092          * DDFSTRT setzen
                move.w  #$00D0,$DFF094          * DDFSTOP setzen
                move.w  #$1000,$DFF100          * 1 Plane - BPLCON0 setzen
                move.w  #0,$DFF102              * kein Scrolling
                move.w  #0,$DFF104              * kein Dual-Playfield
                move.w  #0,$DFF108              * kein Modulo
                move.w  #0,$DFF10A              * soll benutzt werden

                move.w  #$83C0,$DFF096          * alle wichtigen DMAs und
                                                * und DMAEN aktivieren

*
* Nun wird das Programm selbst in die Bitplane kopiert ...
*

                move.l  Programm,$DFF050        * BLTAPTH/L (Quelle A) setzen
                move.l  Bitplane,$DFF054        * BLTDPTH/L (Ziel D) setzen
                move.w  #0,$DFF064              * BLTAMOD: kein Modulo
                move.w  #20,$DFF066             * BLTDMOD: 20 Bytes, da
                                                * der zu kopierende Daten-
                                                * block 20 Bytes breit und
                                                * die Bitplane 40 Bytes
                                                * breit sein soll
                move.w  #$9c0,$DFF040           * BLTCON0: Minterm $C0
                                                * (LF7 und LF6 gesetzt)
                                                * sowie DMA für A und D
                                                * aktivieren
                move.w  #$0,$DFF042             * BLTCON1 setzen
                move.w  #$180A,$DFF058          * BLTSIZE setzen und
                                                * Blitter starten
                                                * der Operationsbereich
                                                * beläuft sich auf 96
                                                * Zeilen zu je 10 Words

MouseLoop:      btst.b  #6,$bfe001              * Maustaste abfragen
                bne.s   MouseLoop               * nicht gedrückt

                move.l  GfxBase,a6              * GfxBase laden
                jsr     _LVOWaitBlit(a6)        * auf Blitter warten

*
* Hier wird der ursprüngliche Zustand wieder hergestellt.
*

                move.l  GfxBase,a1              * Graphics laden
                move.l  38(a1),$DFF080          * System-List wieder
                                                * aktivieren

                move.l  #0,$DFF088              * COPJMP1 löschen
                move.w  #$8020,$DFF096          * deaktivierte
                                                * DMA-Kanäle wieder
                                                * einschalten

                move.l  GfxBase,a6              * GfxBase holen
                jsr     _LVODisownBlitter(a6)   * Blitter freigeben

                move.l  a6,a1
                CALLEXEC CloseLibrary           * Graphics schließen

                CALLEXEC Permit                 * Multitasking erlauben

                move.l  Programm,a1             * Programm im
                move.l  #Length,d0              * CHIP-Memory
                CALLEXEC FreeMem                * freigeben

Fault3:         move.l  Bitplane,a1             * Bitplane im
                move.l  #40*256,d0              * CHIP-Speicher
                CALLEXEC FreeMem                * deallokieren

Fault2:         move.l  CopperList,a1           * Copperlist im
                move.l  #2000,d0                * CHIP-RAM wieder
                CALLEXEC FreeMem                * deallokieren

Fault:          moveq   #0,d0                   * Ende!
                rts

*
* Auch hier wieder ein Datenteil ...
*

GfxName:        dc.b     "graphics.library",0
 even

GfxBase:        dc.l     0

CopperList:     dc.l     0                      * Zeiger auf die Copperlist
Bitplane:       dc.l     0                      * Zeiger auf die Plane
Programm:       dc.l     0                      * Zeiger auf den Speicher
                                                * für das Programm

Ende:
Length:         EQU      *-StartProg            * Programmlänge

                END