                          - SEPTIC'S DEMOSKOLA -

                                 Lektion 8
                                 
                        Skriven av Vicious / Septic

                                 10 Aug 93



                                 Inledning
                                 
Frst av allt, urskta att den hr delen av skolan blev ngra dagar
frsenad. Jag hade helt enkelt inte tid att gra den frrn nu.
nu kan vi traska vidare i Amigans hrdvara och - efter att ha
lrt oss att scrolla med blittern - kika p Blitter OBjectS, s kallade
BOBS.


                                   Teori
                                   
Som jag sa frra gngen, s kan man med blittern kopiera data frn ett
stlle till ett annat. Genom diverse manipulationer kan man d f fram
bobs, som r objekt liknande spritar, fast med nstan obegrnsad bredd och
hjd, plus att de kan ha fler frger och inte r begrnsade till antal.
  Nr man kopierar med blittern specificerar man som bekant ett fyrkantigt
flt som skall flyttas. En bob brukar dock inte vara ett snt exakt,
fyrkantigt flt, utan kanske r runt eller mngformat, som tex en liten
gubbe. Det r d man ska plocka fram masken (som fiskaren sa :-) och vid
kopieringen maska boben s att bakgrunden lyser igenom dr objektet inte
har ngon grafik. P det sttet kan ett runt objekt flyta runt p skrmen
utan en svart fyrkant runt om sig.
  En mask r helt enkelt en 1-bitplansversion av boben dr alla bitplanen
finns lagrade (?!?!) genom logisk OR. Hmmmm, kanske inte s bra
frklaring...Om vi sger att vi har en 4-bitplansbob som vi vill gra en
mask till och en rad i den 16 pixlar breda boben ser ut s hr:

   %0101110110101110   ; Frsta bitplanet
   %1001000010000011   ; Andra bitplanet
   %0000010110100101   ; Tredje shitplanet
   %1001010111100000   ; Fjrde bitplanet

D kommer masken att se ut s hr:

   %1101110111101111   ; Mask

Som ni ser s (och p det sttet funkar ju ocks OR) r masken 0 (noll)
ENDAST nr ALLA bitplanen r noll. Och NR r alla bitplanen NOLL? Jo! Nr
frg 0 ska visas i boben, och frg noll brukar alltid vara transparent
vilket betyder att nr masken r noll s ska bakgrunden synas igenom.
  Vi kan allts utan strre problem tnka ut en minterm som passar.
Blittern ska lsa frn bobgrafiken nr masken r 1, och lsa frn
bakgrunden (s att den syns igenom boben) nr masken r 0. Om vi anvnder
alla tre kllor i blittern s kan vi lta den frsta peka p masken, den
andra p boben och den tredje p bakgrundsgrafiken.
  Vr minterm ser d ut s hr:

   AB + aC   (Eller (A&B)!(NA&C))

Detta lser vi som A and B or not A and C, vilket betyder att blittern ska
lsa frn klla B om A r 1, och frn klla C om A r 0. Det senare
uttrycket ((A&B)!(NA&C)) kan sttas in precis som det r i programmet,
eftersom jag redan har frdefinerade vrden fr mintermarna och det gr det
hela mycket lttare att handskas med. (Titta i slutet p programexemplet s
ser du en massa konstiga siffror...DET r mina frdefinerade mintermar, om
du inte visste det!)
  S lngt, allt vl, s vi kan hoppa vidare p hur shiftningen ska g till
nr man flyttar bobs.
  I frra lektionen gick jag igenom varfr shiftningen fanns, och fr den
som inte minns, kan jag tala om att den anvnds fr att flytta data till de
pixlar som ligger mellan WORD-kanterna, allts mellan var 16:de pixel. Jag
anvnde ocks shiftningen fr att scrolla texten t sidan.
  Shiftning vid bobhantering fixar allts s att man kan placera sin bob p
ojmna pixlar som 11, 75 eller 120 (som inte ligger p jmn 16-pixel-adress
allts) istllet fr bara 16, 32, 48, 64 osv...Det r ju frtrffligt bra,
eller hur?!
  S, hur puttar man ut sin lilla fina gubbe p en speciell koordinat nu
d? - Jo, om vi sger att vi ska stta boben p X-koordinat 57, s mste vi
frst ta reda p vad vi ska ha fr shiftvrde, allts hur lngt in p
wordet som boben sitter.
  Detta kan man gra genom att dividera vrdet med 16, och sedan kika p
divisionsresten i det hga wordet. S rekommenderar mnga att man gr, men
jag skrattar blott t dem, ty jag vet bttre vgar att frdas :-) (hmmm,
sitter visst och blir poetisk hr....grrmhgfmhf....) En division tar MNGA
cykler att utfra, och vi vill ju inte ha sla rutiner i ondan, s
istllet plockar vi helt enkelt bara ut de 4 lgsta bitarna, som p talet
57 (binrt %00111001) r %1001. Decimalt r %1001 9, s 9 r allts
shift-talet! Magiskt eller hur?!
  Sedan shiftar vi vrt 57 t hger 4 steg, vilket r samma sak som att
dividera med 16 (fast snabbare) och d vet vi i vilket word boben finns i.
Vi multiplicerar d med 2 fr att f bytevrdet vi ska addera till
skrmpekaren och s r vi frdiga!
  Ja, svrare r det inte, men man mste komma ihg fljande:

 * Shiftningen sker alltid t HGER, om man inte befinner sig i DESCending
mode, och det gr ni inte n, fr det kommer nr jag tar upp area-fyllning!

 * Grafiken shiftas RUNT! S bobgrafik som shiftas 8 steg t hger kommer
in p bobens hgerkant igen och det ser inte alls snyggt ut! Drfr: Blitta
alltid ett word extra, med BLTAxWM ($dff044) som maskar bort grafiken dr,
s att genomskinlig data shiftas in frn hger istllet!

En anvndning man ocks kan ha blittern till r att rensa areor, tex en hel
skrm. Detta r mycket bra om man tex gr en effekt med processorn, fr d
kan blittern rensa en separat skrm medan man ritar sin effekt med
processorn samtidigt p en annan skrm. Det sparar man ganska mycket tid
p.
  Fr att rensa med blittern behver man inte kopiera svart bakgrund eller
ngot snt, utan helt enkelt bara strunta i kllorna. Man anvnder allts
BARA destinationen, och vips! s RENSAR blittern, eftersom den inte har
ngot speciellt, mer n nollor, att skriva med! Och mintermen skall
givetvis ocks vara noll...


                                 Register
                                 
Inte mycket nytt i registervg den hr gngen. Frutom att vi mste anvnda
oss av BLTCON1 nu ocks, nr vi anvnder fler kllor. (Titta i frra
lektionen om ni inte minns dess uppstllning.) Vi fr helt enkelt in samma
shiftvrde i BLTCON1 som i BLTCON0, fr att bobgrafiken ska shiftas ocks,
och inte bara masken, vilket bara leder till fel.
  BLTAFWM ($dff044) och BLTALWM ($dff046) r blitterns maskregister som
kommer till anvndning nr man jobbar med bobs. BLTAFWM (BLiTter source A
First Word Mask) och BLTALWM (BLiTter source A Last Word Mask) brukar jag
beteckna som BLTAxWM istllet, och adressera det som ett helt longword, dr
hga wordet r First Word Masken och lga wordet r Last Word Masken. Att
maska bort grs med logisk AND, och fr att tex maska bort de sexton sista
pixlarna p boben (nr vi har blittat ett word fr mycket, fr att kunna
shifta utan buggar, till exempel) skickar man bara #$ffff0000 till BLTAxWM,
s behandlas inte de 16 sista bitarna p varje rad.
  Man kan ven anvnda maskning om man vill kopiera saker som inte ligger
p jmna words. Kanske ett grafisk block som brjar p pixel 18 i och
slutar p pixel 125 i x-led. D blittar man helt enkelt frn pixel 16 (som
ju r jmnt) till pixel 128 (ocks jmnt :-D ), och maskar bort de tv
pixlarna i brjan och de tre i slutet. Enkelt, eller hur?


                              Programexemplet
                              
Ngot "Unlimited Bobs"-rekord blir det inte den hr gngen, utan endast 20
stycken sm 16*16 pixels bollar som ker p skrmen. Jag sger ker,
eftersom de inte glider fram p en sinuskurva...Det r nmligen UTMANINGEN!
Yippi! Ls mera lngre ner!
  Rutinen r allts inte srskilt optimerad, men den visar hur man anvnder
bobs (och de r ju i FYRA bitplan, vilket r ganska mycket att hlla p och
kopiera fr den stackars lille blittern), och det r ju huvudsaken.
  Jag har ocks (fr frsta gngen i hr i demoskolan) anvnt mig utav
dubbelbuffring! Med dubbelbuffring menas att man har tv istllet fr en
skrm, och medan man VISAR den ena s RITAR man p den andra. Nr man s
ritat frdigt p RITA-SKRMEN, s byter man dem helt enkelt, s att det man
ritat kommer fram! Med den hr metoden undviker man dumma flimmer-buggar p
ett trevligt stt! Man kan d ven gra rutiner som inte flyter fram i 50
frames per sekund, men de blir ju lite hackigare d...
  Okej, ska vi titta p vad programmet sysslar med?
  Som alltid gr vi det vanliga i brjan, initialiserar, stter vr DMA och
bitplanspekare...Men, efter det kommer en rutin som heter CreateMask! Den
gr precis vad man kan tnka sig, nmligen skapar en mask av vr boll-bob.
Som ni ser i den rutinen, s stegar jag i tur och ordning genom alla fyra
bitplanen och ORar dem p masken. Inga svrigheter alls...
  Sen hoppar jag till en rutin som heter InitCoords. Vad den gr r att
stta upp koordinater fr alla bollarna, samt infra dess riktning i X och
Y, i en speciell tabell som vi kan lsa av sedan nr vi puttar ut bobsen
(eller heter det bobarna? Eller bobsingarna? :-D)
  Sedan hoppar vi raskt vidare till MAIN, dr jag frst syncar, som alltid,
och s hoppar jag till SwapPages, som helt enkelt skter om
dubbelbuffringen...Den flippar fram skrmen vi senast ritade p och lter
den som senast visades bli den nya "rit-skrmen".
  Nsta rutin r ShowBobs. Vi hoppar ner och tittar vad den gr...
  Frst nollstller vi D0 och D1 fr att det inte ska intrffa konstiga
buggar nr vi jobbar med words lngre ner. Sen hmtar vi adressen till
"rit-skrmen", allts the DrawPage! Vi pekar ocks p ballen - eh, ooops...
sorry... - allts, p the ball, som r bob-bollen och p masken. Varfr vi
gr detta s tidigt r fr att slippa gra det tjugo gnger inne i bob-
puttnings-loopen och allts spara ngra vrdefulla rasterrader.
  Frst rensar vi de gamla bollarna i en liten rutin som lser
koordinaterna frn vr lilla tabell i tur och ordning och sedan hoppar till
ClearBob-rutinen.
  I ClearBob-rutinen hnder fljande...
  Frst subtraherar jag 8 frn D1, allts Y-koordinaten, eftersom jag vill
rensa runt om bollen och behver lite extra kanter. Sedan multiplicerar jag
det med skrmbredden i bytes (kan gras snabbare, men det fr ni lista ut
sjlva :-) Jag lr ut grunden, sen fr ni lra er fortsttningen med
tiden...) Jag lgger p vrdet p skrmpekaren s att vi kommer ner till
rtt Y-rad. Sen subtraherar jag frn X-koordinaten ocks, p samma stt, 8
pixlar, skiftar det t hger fyra steg (=division med 16) och multiplicerar
med 2, genom aritmetisk skift t vnster ett steg. Ocks detta vrde lgger
jag p skrmpekaren.
  Drefter fr jag in BLTCON-vrdet, som ju bara r DEST nr man ska rensa
med blittern, i D0, stter antal bitplan, fr loopen, i D1, och vntar p
att blittern ska bli frdig.
  Sen fr jag in BLTCON-vrdet i - hr och hpna! - BLTCON0!!! Wow! Och
efter det stter vi masken #$ffffffff, fr vi behver inte maska bort ngot
nu, och s stller jag in BLTDPT och stter korrekt modulo. Storleken
stter jag till 48 pixlar bred, vilket allts blir 8 extra p hgerkanten
nr vi flyttade 8 steg t vnster tidigare, och 32 pixlar hg, vilket blir
samma sak.
  Sen adderar jag till bitplans-pekaren s att vi kommer till nsta bitplan
och s loopar jag tillbaka.
  Sdr...Tillbaks till ShowBobs-rutinen, dr jag direkt hoppar vidare till
MoveBobs. MoveBobs gr kort och gott detta:
  Hmtar X och Y-koordinat i tur och ordning, kar dem med deras
ADD-vrden, kollar om de r utanfr en viss skrmgrns och negerar i s
fall ADD-vrdet s att den byter riktning.
  terigen i ShowBobs-rutinen...Hr kommer en kodsnutt som liknar
ClearBob-grejen tidigare, fast den hr puttar ut bollarna istllet fr att
plocka bort dem.
  I rutinen PutBob multiplicerar jag frst Y-koordinaten (precis som i
ClearBob-rutinen) och adderar den till skrmpekaren.
  Sen fr jag in en krnglig minterm i D7, som sger: "Anvnd klla A, B
och C, plus destination D. Mintermen ska vara (B&A)!(C&NA), allts ls frn
klla B om A r 1, och frn klla C om A r 0."
  Jag kr en swap p D7 sen, fr att krnga upp talet i hga wordet
(eftersom jag ska skriva till BLTCON som ett helt longword) och s hmtar
jag lga byten av X-koordinaten. Jag ANDar med 15 eftersom vi bara behver
de 4 lgsta bitarna.
  Sen delar jag med 16 och gngar med 2 fr att f fram rtt bytevrde.
Detta vrde adderar jag till skrmpekaren.
  Sedan skiftar jag runt D6 fyra steg t hger, s att skiftvrdet vi
plockade fram innan hamnar p rtt position och s ORar jag p det p
BLTCON-vrdet vi har i D7. Sen swappar jag D6 och ORar p det igen,
eftersom vi ska skifta klla B ocks!
  Sen stller jag in skrmmodulon och bobmodulon. Hmmm, minus 2?! Ja,
eftersom boben bara r 16 pixlar bred, och vi blittar 32 pixlar (fr att
kunna shifta rtt, om du kommer ihg?) s modulon mste allts vara negativ
fr att hoppa tillbaka till rtt rad...
  .BltWt vntar p att blittern ska bli frdig, och nr vi fr klartecken
skriver jag in D7 i BLTCON, stter masken till #$ffff0000 (som vi kom
verens om ovan, fr att shiftningen ska g bra) och stller in en massa
pekare p bde masken, boben och skrmen.
  Efter det stller jag in rtt modulo fr A, B, C och D och slutligen
startar vi blittern genom att ange storlek p vrt blit-flt. Tv words,
allts 32 pixlar, och 16 hgt.
  Sen adderar jag bitplansstorleken till skrmpekaren, s att vi hamnar p
exakt samma stlle fast i nsta bitplan, och gr samma sak med boben.
Notera att vi INTE ska addera ngot till maskpekaren, eftersom den bara r
i ett bitplan, och fungerar fr alla bitplan i boben.
  Sdr, det var det mesta om det mesta...Hoppas verkligen att ni hnger
med och att ni frstr.
  Notera att jag inkluderat en liten rutin jag ftt frn Leviticus ocks
(hej, hej!), som gr en Setclock Load, allts stller in systemklockan rtt.
Detta r bra att ha, eftersom demos - nr man stnger av multitasking och
gr allmnt stygga saker - gr s att klockan gr fel. Tack fr det,
Leviticus!

Det var allt om programmet den hr gngen. Fr att enklare flja det hela
kan ni ju printa ut den hr textfilen och lsa den samtidigt som ni tittar
p programmet, eller s kan ni ladda in det i ngon texteditor som klarar
av flera filer t gngen i olika fnster (typ Cygnus Ed, yeah!) som jag
sjlv anvnder.

