plazma - amatör bilgisayar kültürü

Test Platformu - Bölüm 4

Emir 'Skate' Akaydın

Test Platformu dökümanlarında dördüncü ve "son" bölüme geldik. İlk üç sayıda çapraz geliştirmeyle ilgili bilmeniz gereken birçok temel kavramı irdeledik. Bundan sonrası sizin Commodore 64 üzerindeki yeteneklerinizi geliştirmeniz ve yeni efektler kodladıkça PC gibi platformlardan nasıl faydalanabileceğinizi daha iyi öğrenmenizden ibaret. Ama bu işi tamamen size bırakmadan önce son bir örnek göreceğiz. Bu seferki örneğimiz 90lı yıllarda Commodore 64 demolarında sıkça rastladığımız bir demo efekti olan $d017 sprite stretch efekti. Bir de buna yan border açma, renk geçişi ve sinüs efektleri eklenince ortaya hoş bir örnek çıkıyor.

DİKKAT!!! Aşağıda anlatılan kavramların birçoğu ileri derecede VIC (Commodore 64'ün grafik çipi) bilgisi gerektirmektedir. Eğer bu konularda başlangıç seviyesindeyseniz, belirli bir yerden sonra döküman sizin için gittikçe zevksizleşecektir. Bu durumda test platformu bölüm 1'den 3'e kadar olan kısım size daha çok hitap ediyor demektir. VIC konusunda temel bilgilere sahip olmadan bu dökümanı okumanız olumsuz sonuçlar doğurabilir.

1. Doğrudan Sonuca Gitmek

Bu son bölümde lafı hiç dolandırmadan yapmak istediğimiz efekti, efekt için çözmemiz gereken problemleri ve bunların PC kullanarak çözeceğimiz kısımlarını inceleyeceğiz. Ancak bu defaki efektimizin özelliği PC'ye ihtiyaç duymaması. PC'yi bu defa bir nevi pseudocode yazma ve bu kodu test etme aracı olarak kullanacağız. Böylece Commodore 64 üzerinde efektimizi kodlamaya başlamadan önce bazı kod parçalarımızın düzgün çalıştığından emin olacağız.

Efektimizde kullanacağımız öğeler:

  1. 8 sprite'ı sağ ve sol ekran sınırlarına denk gelecek şekilde basma

  2. Yan border açma

  3. FLD (Flexible Line Distance)

  4. $d017 stretch (Spriteları Y ekseninde uzatma)

  5. Uzama (stretch) tablosu üretme (Lineer İnterpolasyon)

  6. Yumuşak renk değiştirme

  7. Yumuşak sinüs hareketleri için bir sinüs tablosu

Bunlar efekti elde etmemiz için yapmamız gerekenler. Peki hangileri bize ne tür problemler çıkarıyor ve nasıl çözüyoruz tek tek inceleyelim.

1.1. 8 sprite

Aslında bu çok basit bir işmiş gibi görünse de bilinmesi gereken bir püf noktası var.

Şekil 1.

Öncelikle sprite koordinatları ($d000-$d00f) ve X koordinatlarının 9.bitleri ($d010) hakkında bilgi sahibi olmanız gerekiyor. Bu bilgiler programcının el kitabı ya da diğer birçok commodore 64 dökümanından öğrenilebileceği için bu noktada üzerinde çok fazla durmuyorum. Asıl bilinmesi gereken şey x = 0 koordinatına basılan bir spriteın Commodore 64 ekranının en solundan (borderlar da dahil olmak üzere) 8 pixel yana denk geldiğidir. Yani borderlar açıkken ekranın en soluna bir sprite basmak istediğinizde x = 0 demek yeterli olmaz. Negatif değerlere gitmemiz lazım. Bunu yapmanın yolu ise $d010 adresindeki 9.bitden geçiyor. Bu biti ilgili sprite için set etmek, yani 1 yapmak lazım. Eğer 0 numaralı sprite'ı kullanırsak 0.bit = 1 olduğundan;

lda #$01
sta $d010

dememiz gerekiyor. Ancak işin ilginç tarafı mantıken $d000'ın (0.sprite X koordinatı) $ff değerini aldığında $00'ın bir solundaki pozisyon olması gerekirken $ff değeri verdiğimizde (9.bit'i de set iken) spriteın ekrandan kaybolduğunu görürüz. Çünkü 0'ın solu $ff değil $f7'den başlar. Kısacası;

  • $d010 = $00; $d000 = $00 => 0.Sprite ekranin en solundan 8 pixel sagda

  • $d010 = $01; $d000 = $f7 => 0.Sprite ekranın en solundan 7 pixel sağda

  • $d010 = $01; $d000 = $f0 => 0.Sprite ekranın en soluna yapışık

$d010 set iken X ekseninde genişletilmemiş yani normal boyutlardaki bir sprite ($d01d = 0) $f0-$d9 değer aralığında, X yönünde genişletilmiş sprite (0.sprite için $d01d = 1) $f0-$c1 aralığında ekranın solunda görüntülenebilir. Elbette ki $f0 değeri küçüldükçe sprite ekranın solundan dışarı çıkmaya başlayacaktır. Sprite ekranın solundan çıktıktan sonra $78'den büyük değerler için görüntülenemez. Ancak $77 ve daha küçük değerlerde bu defa sprite ekranın sağından içeriye girecektir. Dolayısıyla ekranın sağına yapışık X ekseninde genişletilmemiş spriteın X koordinat değeri $60, genişletilmişin ise $48 olmalıdır.

Bu yukarıdaki son paragrafları anlamanızın tek yolu pratik yapmaktır. Ancak bu pratiği yapabilmek için border açmayı da öğrenmeniz gerekmektedir.

Not: Vice emulatorü borderları soldan 16 pixel, sağdan 6 pixel eksik gösterir. TV ekranları da hemen hemen Vice ile aynı sonucu verecektir. Bu örnek Vice ve TV ekranlarında da düzgün görünecek şekilde ayarlanmıştır.

1.2. Yan border açma

Aslında yan border açma yapılması gereken açısından incelenecek olursa oldukça basit bir şeydir. Tek yapmanız gereken tarama 39.karakterin bulunduğu bölgeye geldiğinde $d016 adresini değiştirerek borderı daraltmak ve yeniden genişletmektir. Bu sayede border kapanması gereken yerde kapanamayacaktır ve sağ borderda o raster satırı ve sol borderda bir alttaki raster satırı açılacaktır. İşin zor olan kısmı, yan borderları açmak istediğimiz bölge boyunca bu işlemi her satırda yapmamız gerekmesidir. Ayrıca zamanlamalar bu bölgede çok kritik olduğundan normal şartlarda titremeyen (stable) raster rutini kullanmamız gerekir. Ancak birazdan göreceğimiz örnekte bu rutin kullanılmadan yan borderların açılabileceğine tanık olacağız.

Yan border açmakla ilgili bir diğer temel problem ise 8 satırda bir DMA satırlarına denk gelindiği bölgede zamanlamanın yetersiz kalmasıdır. Ancak örneğimizde FLD tekniğiyle bu DMA satırlarından karakter ekranını kullanmamak koşuluyla kurtulabiliyoruz. Zaten amacımız şu an için yalnızca spriteları kullanmak.

1.3. FLD (Flexible Line Distance)

FLD 80lerden kalma çok eski bir teknik olmasının yanı sıra FLI, AFLI, Line Chrunching ve benzeri birçok grafik modu ve efektin atasıdır. Efekt $d011 adresi üzerine kuruludur. Normalde her sekiz raster satırında bir "bad line" adı verilen raster satırlarına gelinir ve burada ekstra 40 cycle harcanarak iç ekrandaki karakter alanları çizdirilir. Ancak $d011'in alt 3 biti ekranı Y ekseninde kaydırdıkça DMA satırları da ekranla birlikte kayarlar.

Şekil 2.

FLD tekniği de bu özellikten yararlanarak $d011'i her satırda kaydırıp tam DMA oluşacağı yerde yeniden ilk pozisyona getirerek hiç "bad line" oluşmamasını sağlayan tekniktir. Bu sayede ekran FLD'nin uygulandığı bölge kadarlık bir alanda aşağıya kayacaktır. Ancak FLD bölgesinde raster satırları zamanlamalar açısından homojen olacağı için işimiz çok daha fazla kolaylaşacaktır.

Burada dikkat edilmesi gereken nokta satırın hangi bölgesinde $d011'in değiştireleceğidir. Farklı bölgelerde değiştirmek farklı efektler ortaya çıkarabilir. FLD elde etmek için ekranın sol bölgelerinde $d011'i değiştirmek gerekir.

1.4. $d017 stretch

Commodore 64'de spriteların çözünürlükleri tek renkli 24x21 ve 3 renkli 12x24'dür. Bu çözünürlük değiştirilemez ancak spritelar X ve Y eksenlerinde iki kat genişletilebilirler. X ekseni için $d01d adresinde genişletilmek istenilen sprite'ın bitini set etmek ve Y ekseni için ise aynı işlemi $d017 adresinde yapmak gerekir. Eğer 0.Sprite'ı X ve Y'de genişletmek istersek;

lda #$01
sta $d01d ; X ekseninde genislet
sta $d017 ; Y ekseninde genislet

dememiz gerekir. X ekseni için farklı olarak yapabileceğimiz çok birşey yok, yani ya sprite orjinal boyutunda olacaktır ya da iki kat genişletilmiş halde bulunacaktır.

Y eksenine gelince işler değişiyor. Çünkü her raster satırında $d017 adresine farklı değerler verme imkanımız var. Ve yine her zamanki gibi bir VIC hatasından yararlanarak spriteları 2 katdan daha az ya da daha fazla genişletme imkanı elde ediyoruz. Ya da diğer bir deyişle spriteların her satırını birbirinden bağımsız olarak istediğimiz kadar genişletebiliyoruz. Bunun için yapmamız gereken öncelikle $d017'de ilgili sprite'ın bitini temizleyip hemen ardından o biti yeniden set etmektir. Örnek olarak tüm spriteları birden Y ekseninde genişletmek istiyorsak $d017'e öncelikle $00 değeri verip, ardından $ff değeri vermemiz gerekiyor. Bunun için;

lda #$00
sta $d017
lda #$ff
sta $d017

yazabiliriz. Ancak daha pratik ve genel bir tanım ile "eor" komutunu kullanarak;

lda #$00
sta $d017
eor #$ff
sta $d017

dememiz daha uygun olacaktır. Elbetteki her satırda $00 değeri vermemiz demek yalnızca spriteın en üst satırının uzaması demektir. Dolayısıyla istediğimiz uzunluğa ulaştığı yerde $00 yerine $ff değerini vererek bir sonraki sprite satırının görüntülenmesi sağlanabilir. Nedeni ise $ff'ine $ff ile eorlanmasının sonucunun $00 olmasıdır. Kısacası uzama bu noktada sona erecektir. Her satırın uzama miktarını belirlemek için en mantıklı yol bir tablo kullanmaktır. Yani;

ldx #$00
loop:
...
lda stretch,x
sta $d017
eor #$ff
sta $d017
...
inx
cpx #63
bne loop

stretch 
!byte $00,$00,$ff,$00,$00,$ff,$00,$00
!byte $ff,$00,$00,$ff,....,$00,$00,$ff

Yukarıdaki örnek sprite'ı tam 3 kat uzatacaktır.

Şimdi bir düşünelim. Bizim asıl elde etmek istediğimiz efekt ne? Spriteların orjinal yüksekliği 21 pixeldir. 21 pixelden başlayarak iç ekranın toplam yüksekliği olan 200 pixele kadar bu spriteları yumuşak bir şekilde uzatmak oldukça güzel görünecektir. Ancak bu iş için 21 ve 200'de dahil olmak üzere toplam 180 farklı tabloya ihtiyacımız olacak. Bu tabloları nasıl hesaplatacağız? Şimdi bu konuyu inceleyelim.

1.5. Uzama tablosu üretme

Eğer bu güne kadar çizgi (line) rutini kodlamışsanız bu problem size yabancı gelmeyecek demektir. Çizgi çekme rutininde ekrandaki A(x1,y1) ve B(x2,y2) noktaları arasında hangi adımlarla ilerlemeniz gerektiği sorusu temel problemi oluşturur. Bu konuda en çok kullanılan yöntemler Bresenham'ın çizgi algoritması ve bu algoritmanın üzerinden geliştirilmiş diğer algoritmalardır.

Şekil 3.

Uzatma rutini de temelde aynı mantıkla çözülebilir. Örneğin 5 pixel yüksekliğindeki bir resmi 11 pixele uzatmak istediğimizi varsayalım. Bu durumda yukarıdaki şekil bize her bir satırın kaçar kez tekrar etmesi gerektiğini verecektir. Yani;

Orjinal resim

Şekil 4. Orjinal resim

Uzatılmış resim

Şekil 5. Uzatılmış resim

Bu şekilde resmi uzatabiliriz. Şimdi Bresenham formülünü biraz daha basitleştirerek inceleyelim;

deltaO : Orjinal resmin yüksekliği (y2o-y1o farkı)

deltaU : Uzatılmış resmin yüksekliği (y2u-y1u farkı)

deltaO = y2o-y1o
deltaU = y2u-y1u
p = 0
for i from 1 to deltaU
    a = (deltaO / deltaU) * (i-1)
    if int(a) <> p then
        print "X"
        p = int(a)
    else
        print "o"

deltaO = 5 ve deltaU = 11 olduğuna göre adim değerini saydırarak genişletilmiş resmin hangi satırının orjinal resimin hangi satırına denk geleceği değerlerini elde edebiliriz. Ancak bunun için çarpma ve bölme işlemleri yapmak gerekiyor ki Commodore 64 için hiç de ideal bir yöntem değil bu. Çarpma işleminden kurtulalım;

deltaO = y2o-y1o
deltaU = y2u-y1u
adim = deltaO / deltaU
a = 0
for i from 1 to deltaU
    a = a + adim
    if int(a) <> p then
        print "X"
        p = int(a)
    else
        print "o"

Ancak hala bir problem var. "adim" değerini elde edebilmek için ondalıklı sayılarla çalışabilmemiz gerekiyor. Bizim yapmamız gereken tam sayılarla çalışabilecek bir formül bulmak. Neyse ki matematikçiler bunun da bir çözümünü bulmuşlar. Yine pseudocode yazacak olursak;

deltaO = y2o-y1o
deltaU = y2u-y1u
a = 0
for i from 1 to deltaU
    a = a + deltaO
    if a >= deltaU then
        a = a - deltaU : print "X"
    else
        print "o"

Dikkat ederseniz yazdığımız bu son pseudocode yalnızca toplama, çıkarma işlemleri ve koşullardan ibaret. Verdiği sonuç ise önceliklerle aynı. Bu durumda hadi bu formülün nasıl bir çıktı verdiğini test edelim. Bunun için istediğiniz dili kullanmakta serbestsiniz. Ben yine en pratik bulduğun Javascript dilini kullanacağım. Bu örnekte deltaO değerini spriteların yüksekliği olan 21 ve deltaU değerini örnek olarak 70 veriyorum. Yani 21 pixel yüksekliğindeki sprite 70 pixele uzatılsaydı her bir satır kaçar kez tekrar edecekti, bu script bize bunun sonucunu verecek.

lineer_interpolasyon1.htm

<script>
deltaO = 21;
deltaU = 70;
a = 0;
for(i = 0; i < deltaU; i++)
{
    a += deltaO;
    if(a >= deltaU)
    {
        a -= deltaU;
        document.write("X");
    }
    else
        document.write("o");
}
</script>

Bu programın çıktısı şu şekilde olacaktır.

oooXooXooXoooXooXooXoooXooXooXoooXoo...

Buradaki her X bir alt satıra geçilecek yeri ifade etmektedir. Yani bu çıktıya göre sırasıyla satırlar 4,3,3,4,3,3,4,3,3,4... kez tekrar edecektir. Başlangıçtan itibaren inceleyecek olursak 3 adet o ve ardından bir X gelmiş. Yani ilk satır 3+1=4 kez tekrar edecek. Ancak X'den sonraki satır artık orjinal resmin 2. satırı olacak anlamına geliyor.

Şimdi 21'den 200'e kadar elde etmek istediğimiz 180 tablo değerini hesaplayalım.

lineer_interpolasyon2.htm

<script>
str = "";
deltaO = 21;
for(deltaU = 21; deltaU <= 200; deltaU++)
{
    a = 0;
    for(i = 0; i < deltaU; i++)
    {
        a += deltaO;
        if(a >= deltaU)
        {
            a -= deltaU;
            str += "X";
        }
        else
            str += "o";
    }
    str += "<br>";
}
document.write(str);
</script>

Bu programın çıktısı bize istediğimiz tabloları verecektir. Bir önceki scripte göre hız optimizasyonu için her karakteri tek tek document.write ile ekrana çıktı verilmek yerine "str" ismindeki bir string değişkende biriktirip bir seferde tüm çıktıyı ekrana yazdırıyoruz. Bir diğer nokta ise her çıktının arasına <br> koyarak çıktıların alt alta dizilmesini sağlıyoruz.

Aslında bu çıktıları "o" ve "X" yerine $00 ve $ff ile alsak ve kodumuzda doğrudan kullansak istediğimiz sonucu elde etmiş oluruz. Ancak buna gerek yok, bu kodun aynısını 6510 Assemblerdan da yazmak bizi hiç zorlamayacaktır. Burada çıktının doğru olduğundan emin olmuş olduk.

lineer_interpolasyon.a

        !to "lineer_interpolasyon.prg"

_A       = $f8
_DELTA_O = 21
_DELTA_U = 100
_TABLO   = $1000

        * = $0900
        ldy #$00
loop2   lda _A
        adc #_DELTA_O   ; a = a + deltaO
        sta _A
        cmp #_DELTA_U   ; if a < deltaU
        bcc pass1       ; then pass1
; a >= deltaU
        sbc #_DELTA_U
        sta _A          ; a = a - deltaU
        clc
        lda #$ff        ; tabloya $ff
        sta _TABLO,y    ; ekle
        iny
        cpy #_DELTA_U
        bne loop2
        beq out
; a < deltaU
pass1   lda #$00        ; tabloya $00
        sta _TABLO,y    ; ekle
        iny
        cpy #_DELTA_U
        bne loop2
out     rts

Bu programı yükleyip "SYS 2304" ile çalıştırdıktan sonra monitörden (Vice'da File->Monitor) "m 1000" yazarak 1000'den itibaren oluşturulan tabloyu görebilirsiniz.

Artık stretch efektinde gerekli tabloları gerçek zamanı olarak oluşturabiliriz.

1.6. Yumuşak renk değiştirme

Bir demoda seyirciyi en çok etkileyen özelliklerden biri de renk parlamaları (flashing colors), sıralı renk geçişleri (cycling colors), kayan renkler (scrolling colors) ve benzeri renk efektleridir. Spritelarımız uzama efektini yaparken bir taraftan da renk değiştirirlerse bu seyircinin gözüne hoş gözükecektir. Ancak sürekli renk değiştirmek yerine bir süre sabit bir renkte kalıp arada bir parlayarak başka bir renge dönüşmesi zaten yeterince hareketli olan efektimiz için iyi bir seçim olabilir. Bu durumda oluşturacağımız renk tablosu şu şekilde olmalıdır.

renk1,renk1,renk1,renk1,renk1,renk1,.....,geçiş renkleri,renk2,renk2,renk2,renk2,renk2,renk2,.....,geçiş renkleri

Şimdi ACME'nin !fill ve !byte komutlarını kullanarak 256 bytelık bir tablo oluşturalım.

flash   !fill 110,10
        !byte 12,12,12,15,15,15,15,13,13
        !byte 13,13,1,1,1,1,13,13,13
        !fill 110,14
        !byte 12,12,12,15,15,15,15,13
        !byte 13,13,13,1,1,1,1,15,15,15

Aralarda 18'erden toplam 36 geçiş rengi kullanıyoruz. Bu durumda sabit renkler de (256-36)/2'den 110'ar tane olarak hesaplanabilir. Böylece "!fill 110,10" ve "!fill 110,14" diyerek Açık Kırmızı (10) ve Açık Mavi (14) renklerinden 110'ar tane oluşturmuş oluyoruz. Aralarda ise geçiş renkleri var. Renkler hızlı değişeceği için ben renk geçişine pek özenmedim. Sizler isterseniz uygun renkleri peş peşe dizerek daha yumuşak geçişler elde edebilirsiniz.

Şimdi gelelim bu renkleri nasıl okutacağımıza. İstersek;

ldx flashCounter
lda flash,x
sta $d027
sta $d028
sta $d029
sta $d02a
sta $d02b
sta $d02c
sta $d02d
sta $d02e

diyerek tablodan okunan bir değeri tüm sprite renklerine atayabiliriz. Ancak bunun yerine;

ldx flashCounter
lda flash,x
sta $d02e
inx
lda flash,x
sta $d02d
inx
lda flash,x
sta $d02c
inx
lda flash,x
sta $d02b
inx
lda flash,x
sta $d02a
inx
lda flash,x
sta $d029
inx
lda flash,x
sta $d028
inx
lda flash,x
sta $d027

kodu bu şekilde kullanacak olursak spritelar tablodan peş peşe renkler okuyarak sıralı bir geçiş yaparlar. Bu sayede hem renk parlaması hem de renk kayması efektlerini bir arada kullanmış oluruz. Şimdi gelin bu uzun kodu ACME'nin özelliklerini kullanarak daha kısa ifade edelim.

ldx flashCounter
!for i,8 {
!if i != 1 {
inx
}
lda flash,x
sta $d027+8-i
}

Buradaki "!if" bloğunun amacı ilk seferde "inx" koymayıp, ondan sonraki tekrarlarda bu komutu aralara eklemek. Programın çıktısı birebir yukarıdaki açık örnekte olduğu gibi olacaktır.

1.7. Sinüs hareket tablosu

Uzama efektini eğer tek tek adımlarla ilerletecek olursak çok lineer bir görüntü elde ederiz. Uzamaya biraz hareket katmak maksadıyla güzel bir sinus tablosu oluşturmamız lazım. Ancak bu defa bu tabloyu da aynı renk tablosunda olduğu gibi arada biraz sabit bir değerde bekleyecek şekilde oluşturacağız. Bildiğiniz gibi normalde tablolarımızın uzunluğunu 256 bytelık seçeriz. Bu sayede bir bytelık bir sayacı sürekli arttırarak tablonun üzerinde kolaylıkla hareket ederiz ve başa dönmek için ekstra bir işlem yapmamıza gerek kalmaz. Yine 256 bytelık bir tablo kullanacağız. Ancak bu defa sinüs genişliğimiz 200 olacak. Geri kalan 56 byte ise sabit bir değerde olacak. Burada çözmemiz gereken problem sinüs tablosunun başladığı ve bittiği değerin bu 56 bytelık sabit değere eşit olması.

Bir diğer problem ise tek bir sinüs'ün efekte istenilen oranda hareket katmaması. Harmonik hareketi biraz daha hoş göstermek için sinüs * cosinüs gibi bir formül kullanabiliriz. Dikkat etmemiz gereken tek şey formüldeki tüm bileşenlerin peryodik sonuçlar vermesidir.

Sprite yüksekliği 21 ile 200 arası değişeceğine göre sinüs tablomuz da bu değer aralığında olmalı. Sabit bekleyeceği değeri 21 seçersek sinüs tablomuz 21'den başlayıp yine 21'de bitmelidir. Yani uzama efekti spriteın orjinal yüksekliğinden başlayacak ve bir süre bekledikten sonra gerçekleşecek. Sonra yine orjinal yüksekliğe geri dönecek.

Bu probleme örnek bir çözüm aşağıdadır.

sinus.htm

<script>
for(i = 0; i < 200; i++)
{
  a = 111  
    + Math.floor(89.9 
                 *Math.cos((i+50)/50*Math.PI) 
                 *Math.sin((i+50)/100*Math.PI));
  if(i != 0)
    document.write(",");
  document.write(a);
}
</script>

Bu scriptin çıktısını programımıza şu şekilde eklememiz gerekiyor.

sinus   !fill 56,21
        !byte <sinus.htm'in ciktisini buraya kopyala>

Yukarıda Anlatılanların Bir Araya Gelmesiyle Oluşan "stretch.prg" Programının Çıktısı

Şekil 6.

Programın kaynak kodunu (stretch.a) ve çalıştırılabilir dosyasını (stretch.prg) disk magazinin paketinin içersinde bulabilirsiniz. Ayrıca "extra" klasörünün içersinde yukarıda örneklenen kodları da bulmanız mümkündür.

Kaynak kodun içersinde yukarıda anlatılanlara ek bazı bölümler de bulacaksınız. Hiç endişe etmeyin kodların tamamının açıklamaları yanlarından yer alıyor. Ancak elbette ki hiç Commodore 64 temeli olmayan biri için bunlar da yeterli olmayacaktır. Bu örneği tamamen anlayabilmek için özellikle VIC konusunda kendinizi geliştirmeniz şart. Bunun için Türkçe kaynak olarak size Nightlord'un yazdığı ve yakında sitesinden yayınlayacağı "C64 Grafik Programlama" serisini takip etmenizi tavsiye ederim. Link: http://www.nightnetwork.org/

2. Son Söz

Böylece "Test Platformu" serisinin sonuna gelmiş bulunuyoruz. Aslında çapraz geliştirme kapsamlı bir konu ve anlatılabilecek çok fazla ileri düzey konu var. Örneğin Commodore 64 üzerinde bir vektör şehri yaratmak ya da basit bir video göstericisi programlamak. Ancak şu anki durumda bu son verdiğim örneğin bile Türkiye'de çok sınırlı bir kesime hitap edeceğini düşünüyorum. Dolayısıyla da daha ileri düzey konulara al atmak yerine, yeni bir yazı dizisine başlamak ve yalnızca çapraz geliştirmeye dayanan konularla sınırlı kalmamak bana daha uygun geliyor.

Özellikle bu son bölümü okuyan kişiler bu yazıyı biraz eksik bulabilirler. Evet, bazı kavramlar yeterince detaylı açıklanmıyor ancak bu yazının eksikliği değil, aksine fazlalığından kaynaklanıyor. Bu yazıda çapraz geliştirmeyle doğrudan ilgili kısımlar lineer interpolasyon hesapları ve sinüs hesapları. Bunun haricindeki kısımlar fazladan ve biraz da mecburiyetten anlatılmış bölümler. Aslında yan border açmayla ilgili kısıma da bir cycle hesaplayıcı eklemeyi düşündüm ancak bunun da şu an için kafa karıştırmaktan daha öteye gitmeyeceği kanısına vardım.

Özetlemek gerekirse "Yan Border Açma", "FLD", "$d017 Stretch", "Yumuşak Renk Değiştirme" konuları fazladan açıklanmış konulardır. Amaç, diğer dökümanlardan okuyup öğreneceğinizi varsaydığım bu konuları buradaki örnekle bağdaştırabilmenizi kolaylaştırmaktır.

Bu bölümün yazının son bölümü olması, Test Platformu - Bölüm 5'in olmayacağı anlamına gelse de, zamanla bana gelecek talepler doğrultusunda böyle bir devam bölümünün olma ihtimali de var. Yalnızca Plazma'da her sayı devam eden seri burada sona eriyor. Belki ilerki sayılarda yeni bir Test Platformu ile yeniden karşınıza çıkabilirim. Şimdi eğer hala denemediyseniz "stretch.prg" dosyasını emülatörden çalıştırın ve mini şovu izleyin :)

emir (at) akaydin (nokta) com

plazma - 2008