                          - SEPTIC'S DEMOSKOLA -

                                 Lektion 3
                                 
                        Skriven av Vicious / Septic

                                 07 Maj 93



                                 Inledning
                                 
ntligen dags att visa bilder! Det r vl nu det brjar bli lite mer
intressant...I den hr delen ska jag g igenom hur bitplansgrafik fungerar
och hur man visar en enkel 32-frgers bild.
  De tv frsta lektionerna verkar inte ha varit ngra strre problem. I
alla fall har jag inte ftt en enda frga om ngot dr, och det r ju bara
bra, fr det mste betyda att jag lr ut allt mycket bra! (Eller?)
  Jag infr ocks en ny verskrift (som fljer direkt hr under) som kommer
att behandla det vi gr i teorin. Hitills har allt varit ganska sjlvklart
men i fortsttningen kan det bli lite knepigare, och en viktig sak fr att
man ska kunna programmera en sak r att man frstr hur den fungerar.


                                   Teori
                                   
Ett demo skulle inte vara mycket att ha om inte bitplansgrafik fanns. Det
skulle inte finnas ngra texter, inga stillbilder eller rrliga bilder
(bobs, vektorer, etc...). Det skulle kort och gott bara finnas musik och i
bsta fall ett par copperbars! Drfr mste vi vara evigt tacksamma fr att
vi kan visa grafik, och det mycket simpelt ocks! Detta r Amiga, och vi
behver knappt anstrnga oss det minsta fr att visa en liten bild.
  Men, frst och frmst, vad r en bild? - Som bekant frstr datorn
egentligen bara ettor och nollor. Kombinerar vi dessa fr vi binra tal,
som kan representera decimala eller hexadecimala tal, som vi tycker r
enklare att handskas med. I grafik-sammanhang r det dock enklare att prata
om binra tal istllet fr decimala eller hexadecimala. I en bild motsvarar
nollan en tom pixel och ettan en satt pixel. En rad med ettor i minnet ger
allts en lng rak linje p bilden.
  Nu kanske du undrar hur bara nollor och ettor kan stadkomma s mnga
frger som Amigan kan prestera. D infr vi ett nytt begrepp som kanske
lter bekant -> bitplan! Med hjlp av flera bitplan kan vi kombinera vra
ettor och nollor s att de kan representera pixlar med olika frger.
  Detta kan te sig lite mystiskt innan man frstr hur det fungerar, men
det hela bygger p en ganska ltt princip.
  Den enklaste formen av bild r 2-frgers bilden. Dr har man bara ETT
bitplan innehllande ettor och nollor, dr nollan representerar
bakgrundsfrgen, och ettan motsvarar frg 1.
  Om vi nu lgger till ett bitplan s att vi har tv bitplan i vr bild kan
vi pltsligt rita med FYRA frger. Detta beror p att vi kan f ut fyra
olika kombinationer med vra bitplan.
  Om vi t.ex. tittar p pixeln lngst upp till vnster p vr bild s ser
vi att det r en etta i frsta bitplanet och s tittar vi p pixeln lngst
upp till vnster i andra bitplanet och ser nnu en etta. En etta p bda
stllena ger frg tre!
  Lgger vi till nnu ett bitplan med en etta dr har vi pltsligt frg
SJU!
  Hur bitplanen kombineras fr att ge olika frger kan enkelt kontrolleras
genom att man ger varje bitplan ett speciellt vrde. Bitplan 1 fr vrdet
1, bitplan 2 fr vrdet 2, bitplan 3 vrdet 4 osv:

           BITPLAN    VRDE
           -------    -----
              1         1
              2         2
              3         4
              4         8
              5         16

  Nr man sen ska ta reda p vilken frg det blir kikar man bara i tur och
ordning p varje bitplan och lgger till dess VRDE bara om biten r satt.
S om en bit r satt i bitplan 3 och bitplan 5 bara, blir sammanlagda
vrdet: 4+16 = 20   Allts, frg 20! Om vi tar ett annat exempel, dr en
bit r satt i bitplan 1, en i bitplan 4 och en i bitplan 5: 1+8+16 = 25
Frg 25! Vldigt enkelt nr man vl kan det...Om man tar 2 upphjt i antal
bitplan s fr man ven max antal frger. Det kan kanske vara bra att
veta...

  Det kan vara vldigt svrt att frst hur bitplan och snt hnger ihop i
brjan...Oftast frstr man inte det frrn lngre fram, och till att brja
med rcker det att veta hur man visar bilder, inte hur de r uppbyggda.
  Hoppas du frsttt ungefr hur det fungerar, fr nu hoppar vi vidare till
registren vi behver fr att visa en bild...


                                 Register
                                 
Fr att visa en bild behver man egentligen bara sl p BITPLANS-DMA i
DMACON ($dff096). Amigan kommer d glatt att visa vad den knner fr (tja,
nstan i alla fall, men det r inte vackert...) eftersom den inte har ftt
ngra uppgifter alls om vr bild.
  Vad vi behver gra r allts att peka p vr bild, ge Amigan de rtta
frgerna och mtten p bilden och sen r det klart!
  Precis som allt annat DMA-relaterat shit mste all grafik ligga i
CHIP-mem fr att kunna visas. Det gr man enklast genom kommandot SECTION
DATA,DATA_C, s slipper man allt jobbigt minnesallokerande.
  Frst mste vi tala om var vi har vr bild. Man mste ange var varje
bitplan ligger och skriva in alla addresser i registren BPLxPTH
($DFF0E0-$DFF0F4). Precis som alla DMA-pekare mste den uppdateras varje
vertical blanking, s givetvis lter vi coppern skta det.
  Vi mste ocks ange i vilken skrmmode vi vill visa bilden. Det gr vi i
registret BPLCON0 ($DFF100). Det ser ut s hr:

   BIT#   BPLCON0   Beskrivning
   ----   -------   -----------
    15    HIRES     Hgupplsning, 640 pixlar bredd.
    14    BPU2      De hr tre bitarna anger antalet bitplan
    13    BPU1        som ska anvndas nr bilden visas. De kan
    12    BPU0        innehlla allt frn vrdet 0 till 6.
    11    HOMOD     HAM-mode! Om du ska visa en HAM-bild ska den hr
                    biten vara satt! (Annars blir bilden fuuuul...:-)
    10    DBLPF     Dubbla playfields, kan anvndas fr att gra
                    parallax-scroll vldigt ltt.
    09    COLOR     Composite Color p. (Fr genlocks-frg, har jag fr mig
                    eller ngt snt...Jag brukar alltid ha den p!)
    08    GAUD      Genlock p. Gr det mjligt fr dem med genlock att
                    kra en TV-bild p bakgrundsfrgen.
    07     X        Ej anvnda.
    06     X
    05     X
    04     X
    03    LPEN      Fr anvndning av ljuspenna.
    02    LACE      Interlace lge.
    01    ERSY      External resync. Bst att inte rra...
    00     X

Efter att vi specificerat skrmmoden ska vi ange den horisontella
scrollkoden, i register BPLCON1 ($DFF102).
  Om man ska hrdvaru scrolla sin skrm anvnder man det hr registret fr
att flytta skrmen 1-16 steg. Vi ska dock bara visa en stilla bild, s vi
stter BPLCON1 till dess normala vrde, 0.
  Registret ser ut som fljer:

   BIT#   BPLCON1   Beskrivning
   ----   -------   -----------
    15       X      Anvnds ej.
    14       X
    13       X
    12       X
    11       X
    10       X
    09       X
    08       X
    07     PF2H3    Horisontell scrollcode fr jmna bitplan.
    06     PF2H2        "           "       "    "       "
    05     PF2H1        "           "       "    "       "
    04     PF2H0        "           "       "    "       "
    03     PF1H3    Horisontell scrollcode fr udda bitplan.
    02     PF1H2        "           "       "    "     "
    01     PF1H1        "           "       "    "     "
    00     PF1H0        "           "       "    "     "

Som ni ser kan udda och jmna bitplan ha olika scrollcoder, och det r p
det sttet man kan f en svajande bild att dela p sig. Jag ska i nsta
lektion g in mer p hur det hr registret anvnds och gra ett program-
exempel som visar hur det gr till praktiskt.
  Det ytterligare ett liknande register, kallat BPLCON2 ($DFF104). Det
skter om prioriteten mellan bitplan och sprites, och ven bitplan/bitplan,
men det behver vi inte anvnda (n) s det besparar jag er en genomgng
av. Vi stter den bara till noll.
  Nu r det dax att tala om hur bred skrmen r. Det gr vi genom att ange
start och slut p skrmen i registren DDFSTRT ($DFF092) och DDFSTOP
($DFF094).
  De versta 8 bitarna i de bgge registren anvnds ej, och inte heller de
tv lgsta, bit 0 och 1, s dem ska ni inte pilla p :-).
  Det finns en enkel tabell som r bra att flja nr man ska specificera
sin skrmbredd:

   DDFSTRT (Vnster startposition)
   -------------------------------
   Mode     Bitar-> H7 H6 H5 H4 H3 H2 H1 H0
   ----------------------------------------
   Extra wide (max)  0  0  1  0  1  0  X  X   =   $28
   Wide              0  0  1  1  0  0  X  X   =   $30
   Normal            0  0  1  1  1  0  X  X   =   $38
   Narrow            0  1  0  0  0  0  X  X   =   $40

   DDFSTOP (Hger stopposition)
   ----------------------------
   Mode     Bitar-> H7 H6 H5 H4 H3 H2 H1 H0
   ----------------------------------------
   Narrow            1  1  0  0  1  0  X  X   =   $C8
   Normal            1  1  0  1  0  0  X  X   =   $D0
   Wide (max)        1  1  0  1  1  0  X  X   =   $D8

  Vljer man Normal p bgge stllena s fr vi en 320 pixlar bred skrm.
Vljer vi Extra wide och Wide fr vi 368 pixlars bredd, allts overscan.
Tnk er att Normal r 320 pixlar och lgg sen till (eller dra ifrn) 16
pixlar fr varje 8 som ni lgger till (eller drar ifrn) p start eller
slutpositionen...Allts om vi har Normal, $38 och $D0, vilket r 320 pixlar
brett, och vi vill ka skrmbredden med 32 pixlar, d kar vi
startpositionen med 8 och slutpositionen med 8 och s har vi en skrm p
352 pixlars bredd.
  Sen mste vi ocks tala om hur mycket vi vill visa av skrmen. Det gr vi
i registren DIWSTRT ($DFF08E) och DIWSTOP ($DFF090). De hgsta 8 bitarna r
den vertikala positionen och den 8 lgsta r den horisontala. P en normal
skrm brukar man stta vertikala startpositionen till $2C och horisontala
startpositionen till $81, vilket nr man slr ihop dem blir $2C81. Den
normala vertikala slutpositionen brukar vara $12C, men eftersom vi bara har
8 bitar s r det ju inte s lyckat, eftersom vi bara klarar vrden upp
till $100. Ingen fara, i den vertikala slutpositionen agerar Amigan alltid
som om den nionde biten var satt, s vi behver bara ange talet $2C, s
blir det automatiskt $12C! (Det dumma med detta r att vi inte kan
specificera slutpositioner under $80, allts ungefr p versta halvan av
skrmen...)
  Den normala horisontala slutpositionen brukar vara $C1, och de tv talen
tillsammans blir $2CC1.
  Om ni vill kan ni leka med de hr talen lite i copperlistan fr att se
hur det funkar, och hur bilden pverkas.
  S, nu var det bara en liten grej kvar - MODULO!
  Sg att vi har ritat en jttefin bild som r 512 pixlar bred i
lgupplsning och vill visa den i vrt jtteskojiga demo. Vi tittar p
DDFSTRT och DDFSTOP och finner att den maximala skrmbredden endast r 368
pixlar! Hu, va hemskt! - Men, vilken tur att vi har MODULO d! Modulon
talar nmligen om hur mycket Amigan ska hoppa ver i slutet p en rad fr
att komma till brjan p nsta!
  Om vi tar vr lilla bild, 512 pixlar bred, vilket r 512/8=64 bytes (vi
rknar nstan alltid i bytes, inte pixlar) brett. Vi stter vr skrm till
bredden 368 pixlar, vilket r 368/8=46 bytes. Det r nu modulon kommer in,
och ska ange hur mycket vi ska hoppa ver. Vi har lst 46 bytes nu och
kommit till slutet p skrmen, men det finns fortfarande kvar en del p vr
bild som var 64 bytes bred. Fr att komma till nsta rad mste vi allts
hoppa ver de bytes som r kvar, helt enkelt 64 bytes minus 46 bytes = 18
bytes. Vi har allts en modulo p 18 bytes.
  Modulon skrivs in i registren BPL1MOD ($DFF108) fr udda bitplan och
BPL2MOD ($DFF10A) fr jmna bitplan.
  En liten parentes: Tidigare har vi bara anvnt bakgrundsfrgs-registret
COLOR00 ($DFF180). Fr att stta de andra 31 frgerna anvnder man de
efterfljande registrena: $DFF182-$DFF1BE.
  Tja, det var alla register vi behver fr att f fram en bild.


                              Programexemplet
                              
Ett mycket simpelt program den hr gngen. Visar den enklaste typen av
bild, en 320 pixlar bred, 256 pixlar hg lgupplsningsbild, inte helt
oknd, utan faktiskt den vinnande bilden frn The Party II i Aars. Tyckte
den passade bttre n ngon bild som jag skulle kunna rita sjlv ;-)
  Det vanligaste bildformatet r IFF, tex sparar Deluxe Paint alla sina
bilder i IFF, men det formatet fattar egentligen inte Amigan ett dugg av.
Ska man visa det p skrmen mste det vara konverterat till RAW-format. Det
kan man gra med ngot av den uppsj program som klarar av det...Tex,
Kefrens IFF-Converter, IFF-Master, PixMate m.m.....
  Om ni vill ha ett program som konverterar IFF -> RAW s skriv ett litet
brev till mig (fr jag tnker inte sitta och uploada om ingen behver
programmet nd!).
  De tv nya rutinerna i programmet gr tv enkla grejor. Den ena rutinen
stller in pekarna p varje bitplan i bilden, och den andra stter rtt
frger.
  Om vi brjar med den frsta rutinen, SetBplPtr. Dr stller vi frst in
A0 s att det pekar p bildens brjan, och flyttar sen in den addressen i
D0. Detta mste vi gra fr att kunna anvnda kommandot SWAP.
  Sen pekar vi p bitplanspekarna i copperlistan, dr vi ska skriva in
bitplanens startaddresser.
  Eftersom coppern bara kan flytta ett word, 16 bitar, t gngen och vr
address till bitplanet r 32 bitar, mste coppern gra uppdateringen av
bitplanspekaren i tv steg. Det r drfr vi frst flyttar in de 16 lgsta
bitarna och sen, med kommandot SWAP, byter de 16 versta bitarna mot de
16 lgsta i D0 och skriver in de hgsta 16 bitarna i copperlistan.
  Efter det lgger vi till hela bitplanets storlek till D0, allts bredden
i bytes gnger hjden.
  Sen kar vi p A1 med 8 fr att komma till nsta stlle i copperlistan
och s loopar vi tillbaka.
  Den andra rutinen, SetColours, baseras p att vi sparat IFF-bilden som
RAW med paletten efter. D kan vi lsa 32 words dr, eftersom vr bild har
32 frger, och i tur och ordning fra in dem i copperlistan.
  Om vi d tittar lite lngre ner i sourcen, p copperlistan, s ser ni hur
jag satt upp de olika registren som jag gick igenom i Register-kapitlet.
  Frst stter jag DIWSTRT till $2C81 och DIWSTOP till $2CC1. Sen stter
jag de normala DDFSTRT och DFFSTOP vrdena, $38 och $D0. Efter det talar
jag om hur mnga frger bilden har, 32 frger, allts 5 bitplan. Tvan i
$5200 anger att jag vill ha COLOR mode p.
  Sen nollstller jag bde BPLCON1 och BPLCON2 och stter bde jmn och
udda modulo till noll, eftersom vi har en 320 pixlar bred skrm och vr
bild precis r 320 pixlar.
  Sen fljer de fem bitplanspekarna, och dr gr jag s att jag skriver in
de 16 hgsta bitarna frst och sen de 16 lgsta, eftersom coppern ju inte
kan flytta mer n ett word med sitt MOVE-kommando.
  Efter det kommer 32 stycken MOVE-kommando som stter alla 32 frgerna
till noll. Det r hr jag skriver in de riktiga frgerna i rutinen
SetColours.
  Det var de enda nya sakerna i programvg som jag inte tagit upp innan.
Nsta gng ska vi ta upp lite mer skojiga saker om bitplansgrafik, s hll
er till tls!
