Test Platformu Bölüm 4

• Makine dili / Assembler
• Programlama teknikleri
• Grafik ve çizim
• Demo sahnesi
• Kurslar ve dersler
• Emülatörler ve PC

Bölüm 4 Emir 'Skate' Akaydın

Test Platformu dokü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 90'lı 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 dokü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 dokümanı okumanız olumsuz sonuçlar doğurabilir.

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 (Sprite'ları 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.

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 dokümanından öğrenilebileceği için bu noktada üzerinde çok fazla durmuyorum. Asıl bilinmesi gereken şey x=0 koordinatına basılan bir 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 ekranın en solundan 8 pixel sağda

$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 emülatörü 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.

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 borderi 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 sprite'ları kullanmak.

FLD (Flexible Line Distance)

FLD 80'lerden kalma çok eski bir teknik olmasının yanı sıra FLI, AFLI, Line Crunching 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ştirileceğ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.

$d017 stretch

Commodore 64'de sprite'ların çözünürlükleri tek renkli 24x21 ve 3 renkli 12x24'dür. Bu çözünürlük değiştirilemez ancak sprite'lar 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 $d0ld ; 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 orijinal 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 sprite'ları 2 katdan daha az ya da daha fazla genişletme imkanı elde ediyoruz. Ya da diğer bir deyişle sprite'ları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 sprite'ları 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 #$£f
sta $dül17

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

lda #$00
sta: Şdül7
eor
sta $d017

Şekil 3.

dememiz daha uygun olacaktır. Elbette ki 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'in $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;

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;

ldx #$00
Loop:

lida streteh,x
Sta $d017
eor
sta $dül17

inx
epx #63
bne loop

stretch

!byte EE EE

!byte $00,$00,$££,$00,$00,$££,$00,$00

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

Şimdi bir düşünelim. Bizim asıl elde etmek istediğimiz efekt ne? Sprite'ların orijinal yüksekliği 21 pixeldir. 21 pixelden başlayarak Şekil 4. Orijinal resim iç ekranın toplam yüksekliği olan 200 pixele kadar bu sprite'ları 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.

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 5. Uzatılmış resim

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

delta0 : Orijinal resmin yüksekliği (y20-y10 farkı)

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

-— y20-ylo
deltaU -— y2u-ylu
p - 0
for i from 1 to
a (deltao / deltaU) * (i-1)
if int(a) <> p then
print "x"
p intla)
else
ptint Vo"

deltaO = 5 ve deltaU = 11 olduğuna göre adım değerini saydırarak genişletilmiş resmin hangi satırının orijinal resmin 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;

y20-ylo
deltaU - y2u-ylu
adim deltaO / deltaU

a 0
for i from 1 to

a a *t adim
if int(a) <> p then
print "xXx"
p
else
print "o"

Ancak hala bir problem var. "adım" 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 y20-ylo
deltaU - y2u-ylu
a — 0
for i from 1 to
a a * delta0o
if a >— deltaU then
a a - deltaU : print "Xx"
else
print "ot

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ğum 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;
0;
for(i 0; i < deltaU;

1
a deltaO;
ifl(a >— deltaU)
a -—-- deltaU;
document.write("X");
)
else
document.write("o");

)
</seript>

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

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 4 kez tekrar edecek. Ancak X'den sonraki satır artık orijinal 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

<seript>
Str vu,
deltaO
for(deltaU

21; <-— 200;

a Oş
forl(i

(

0; i < deltaU;
a *- deltaO;
ifl(a >—
a deltaU;
str *—

else
Str *— "o";
)

str *- "<br>";

)
document .write(str);
</seript>

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ı "0" 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 Assembler'dan 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
—DELTA O
—DELTA U
—TABLO

$£8
21
100
$1000

*

ldy
lda
adc
sta
cmp # DELTA U
bec passl
deltaU
sbc # DELTA U
sta A
ele
lda
sta
iny
CPpY
bne
beg
a <
lda
sta
iny
CPpY
bne
res

$0900
#$00
A
# DELTA O
A

loop2

a a *t deltaOo
if a <
then passl
>-

a a -
#$Ef

tabloya
ekle

# DELTA U
loop2
out
;
passl #$00
 TABLO,y

tabloya $00
ekle

# DELTA U

loop2
out

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 zamanlı olarak oluşturabiliriz.

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,.....,geçiş renkleri,renk2,renk2,renk2,renk2,renk2,renk2,.....,geçiş renkleri

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

flash
!byte
!byte
!byte
!byte

110,10
12,12,12,15,15,15,15,13,13
13,13,1,1,1,1,13,13,13
110,14
12,12,12,15,15,15,15,13
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
lda
sta
sta
sta
sta
sta
sta
sta
sta

flashCounter
$d027
$d028
$d029
$d02a
$d02b
$d02c
$d02d
$d02e

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

ldx
lda
sta
lda
sta
inx
lda
sta

flashCounter
flash,x
$d02e

£flash,x
$d02d

£flash,x
$d02c

inx
lda flash,x
sta $d02b
inx
lda flaşh;x
sta $d02a
inx
lda flash,x
sta $d029
inx
lda flash,x
sta $d028
inx
lida 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

i,8 1
lif i ls 1 1
inx

)
l1da flash;x
sta $d0271418-i
)

Buradaki "lif" 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.

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 sinüs 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 periyodik 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 orijinal yüksekliğinden başlayacak ve bir süre bekledikten sonra gerçekleşecek. Sonra yine orijinal yüksekliğe geri dönecek.

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

sinus.htm

<script>
forl(i - O;
(
a - 1l1
*t Math.floor(89.9
*Math.sin((i4*50)/100*Math.PI));

i < 200; i*44)

if(i 0)
document .write(",");
document.writela);

)
</script>

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

sinus 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 magazin'in paketinin içerisinde bulabilirsiniz. Ayrıca "extra" klasörünün içerisinde yukarıda örneklenen kodları da bulmanız mümkündür.

Kaynak kodun içerisinde 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ında 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/

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 el 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ısma 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 dokü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 ileriki 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