🕹️ EK BÖLÜM

Eski Donanım Grafikleri

8-bit çağında bellek sınırlamaları grafik tasarımını nasıl şekillendirdi? Mühendisler ve sanatçılar bu kısıtlamalara hangi yaratıcı çözümleri üretti?

📖 Araştırma Raporu
🎮 C64 · NES · Apple II · Atari 2600
📺 The 8-Bit Guy Video Serisi

1. Giriş: Bellek ve Grafik Arasındaki Denge

📌 Bu Bölüm Neden Önemli?

Bugünün GPU'ları gigabaytlarca belleğe sahipken, 1980'lerin ev bilgisayarları yalnızca 16 KB–64 KB RAM ile tüm sistem işlemlerini yürütmek zorundaydı. Bu kısıtlamalar, grafik donanımı tasarımında son derece yaratıcı mühendislik çözümlerini zorunlu kıldı. Bu bölümde, eski donanımların grafik sınırlamalarını ve bu sınırlamaların nasıl aşıldığını detaylı inceliyoruz.

1980'lerin başında tipik bir ev bilgisayarının RAM miktarı 16 KB ile 64 KB arasında değişiyordu. Şimdi basit bir hesap yapalım:

Renk Derinliği Bit/Piksel 320×200 için Gereken Bellek Durum
Siyah-Beyaz (1-bit)18 KB✅ Çoğu bilgisayarda uygulanabilir
16 Renk (4-bit)432 KB⚠️ Birçok bilgisayarın toplam RAM'inden fazla
256 Renk (8-bit)864 KB❌ En pahalı bilgisayarın bile tüm RAM'i
True Color (24-bit)24192 KB❌ Tamamen imkânsız

📊 Bellek Bütçesi: 320×200 Ekran

Farklı renk derinliklerinin gerektirdiği bellek miktarı, dönemin bilgisayar RAM kapasiteleriyle karşılaştırıldığında:

Gördüğünüz gibi, 16 renk bile kullanmak istediğinizde ekran belleği tek başına birçok bilgisayarın toplam RAM kapasitesini aşıyordu. Üstelik video çipi kendi belleğine sahip değildi — CPU ile aynı RAM'i paylaşmak zorundaydı. Kod için yer kalması gerektiğinden, mühendisler bu bellek kısıtlamalarını aşmak için üç temel yöntem geliştirdi:

  1. Renk Hücreleri (Color Cells) — Commodore 64, NES, ZX Spectrum
  2. NTSC Artifact Renklendirme — Apple II, Tandy Color Computer
  3. CPU-Güdümlü Grafikler — Atari 2600, Sinclair ZX81

2. Renk Hücreleri (Color Cells) ve Attribute Clash

Renk hücreleri sistemi, 8-bit grafiklerin en yaygın kullanılan yöntemiydi. Temel fikir şuydu: ekranı 8×8 piksellik küçük bloklara (hücrelere) bölüp, her hücre için yalnızca 2 renk (ön plan ve arka plan) tanımlamak. Bu şekilde hem renkli bir görüntü elde ediliyor hem de bellek tüketimi minimum düzeyde tutuluyordu.

Nasıl Çalışır?

Ekran 320×200 çözünürlükte olduğunda, 40×25 = 1000 hücre oluşur. Her hücre için 1 byte renk bilgisi yeterlidir (4 bit ön plan rengi + 4 bit arka plan rengi). Böylece:

🎮 İnteraktif Demo: Renk Hücresi Kısıtlaması

Paletinden bir renk seçip ızgaradaki piksellere tıklayarak çizim yapın. Her 8×8 hücrede yalnızca 2 renk kullanılabilir — üçüncü bir renk denediğinizde attribute clash oluşur!

C64 Paleti (16 Renk):

Bu muazzam bir tasarruftu. Ancak bedeli vardı: her 8×8 piksellik blokta yalnızca 2 renk kullanılabilirdi. Bu kısıtlama, "attribute clash" (nitelik çakışması) olarak bilinen görsel artefaktlara yol açıyordu.

Attribute Clash (Nitelik Çakışması)

ZX Spectrum'da Laser Squad oyununda attribute clash etkisi
ZX Spectrum'da Laser Squad oyunu — ekranın farklı renkli bloklara bölündüğü açıkça görülüyor. Her 8×8 blokta yalnızca 2 renk kullanılabiliyor (Kaynak: Wikipedia, CC BY-SA).

ZX Spectrum bu sorunun en belirgin yaşandığı platformdu. Spectrum'un görüntü belleği şöyle düzenlenmişti:

Her nitelik byte'ı şu bilgileri kodluyordu: 3-bit INK (mürekkep/ön plan rengi), 3-bit PAPER (kâğıt/arka plan rengi), 1-bit BRIGHT (parlaklık), 1-bit FLASH (yanıp sönme). Bu sayede her 8×8 blokta yalnızca 2 renk + parlaklık seçeneği mevcuttu.

MSX bilgisayarında renk kısıtlaması etkisi
MSX 1'de attribute clash etkisi — 8×1 piksellik gruplarda yalnızca 2 renk. Spectrum'a göre daha az ciddi ama yine de belirgin (Kaynak: Wikipedia, CC BY-SA).
⚠️ Attribute Clash Neden Sorundu?

Hareketli grafiklerde (özellikle oyunlarda) bir sprite bir hücreye dokunduğunda, o hücredeki tüm piksellerin rengi değişiyordu. Bu da sprite'ların etrafında çirkin, hızla değişen renk saçaklarına neden oluyordu. Oyun geliştiricileri bu sorunu çözmek için çeşitli stratejiler geliştirdi:

  • Hareketli grafikleri monokrom yapıp, rengi yalnızca statik arka planlarda kullanmak
  • Sprite'ları hücre sınırlarına hizalayarak dikkatli tasarım yapmak
  • Raster trick'leri ile her tarama satırında nitelik değerlerini değiştirmek
  • Büyük, karikatürvari sprite'lar kullanarak hücre sınırlarını maskelemek

Commodore 64'te Renk Hücreleri

Commodore 64 bilgisayarı
Commodore 64 — Tarihte en çok satan masaüstü bilgisayar modeli (~17 milyon adet). VIC-II grafik çipi ile 16 renk, 8 donanım sprite'ı ve 320×200 çözünürlük sunuyordu (Kaynak: Wikipedia, CC BY-SA).

Commodore 64'ün VIC-II grafik çipi, 320×200 piksel çözünürlükte 16 renk paletine sahipti. Ekran 40×25 karakter hücresine bölünmüş olup, her hücrede 2 renk (1 ön plan + 1 arka plan) kullanılabiliyordu.

The 8-Bit Guy'ın videosunda çarpıcı bir örnek paylaşılıyor: C64'te yapılmış renkli bir sanat eseri ilk bakışta son derece renkli ve canlı görünüyor. Ancak 8×8 piksellik hücre sınırlarını üst üste bindirdiğinizde, gerçekten de hiçbir hücrede 2'den fazla rengin kullanılmadığını görüyorsunuz. Sanatçı, renk geçişlerini hücre sınırlarıyla mükemmel biçimde hizalayarak bu kısıtlamayı görünmez kılmış.

"But, the artist has worked very hard to make his work line up with the edges of the cells to the point that it appears seamless. Knowing this should cause you to give these guys a little bit more respect for the work they do."

— The 8-Bit Guy, "How 'Oldschool' Graphics Worked Part 1"

3. Çok Renkli Mod (Multi-Color Mode)

C64 mühendisleri, renk hücrelerinin kısıtlamalarını aşmak için ek bir seçenek sundular: Multi-Color Mode. Bu modda pikseller yatay olarak iki katına genişletiliyordu. Bu, etkin çözünürlüğü 160×200'e düşürüyordu, ancak her hücrede 4 renk kullanılmasına izin veriyordu.

Özellik Standart Mod (Hi-Res) Multi-Color Mod
Çözünürlük320×200160×200 (pikseller 2× geniş)
Hücre başına renk24
Bellek kullanımı~9 KB~9 KB
Tercih edilen kullanımMetin, iş uygulamalarıOyunlar, sanat eserleri

Çoğu C64 oyunu, yüksek çözünürlük yerine daha fazla renk sunan multi-color modunu tercih ediyordu. Çünkü renk, oyun deneyimi açısından çoğu zaman çözünürlükten daha önemliydi.

"Most games for the Commodore 64 actually used this mode, since color was often more important than high resolution."

— The 8-Bit Guy, "How 'Oldschool' Graphics Worked Part 1"

4. Donanım Sprite'ları (Hardware Sprites)

Renk hücreleri ekranın genel görüntüsünü oluştururken, donanım sprite'ları hareketli nesneler için devrimci bir çözüm sunuyordu. Sprite, ekrandaki arka plandan bağımsız olarak hareket ettirilebilen bir grafik nesnesiydi. Renk hücreleri kural ve kısıtlamalarından tamamen bağımsızdı.

Sprite Nasıl Çalışır?

The 8-Bit Guy, videosunda C64 sprite'ını kareli kâğıt üzerinde piksel piksel tasarlayarak gösteriyor. Her piksel 0 (kapalı) veya 1 (açık) olarak kodlanır, 8 piksellik gruplar binary sayıya dönüştürülür. Bu sayısal veri bilgisayarın belleğine yazıldıktan sonra, donanım registerları kullanılarak:

Sistem Karşılaştırması

Sistem Sprite Sayısı Sprite Boyutu Renk Notlar
Atari 2600 (TIA) 5 nesne 8 piksel geniş 1 renk 2 oyuncu, 2 mermi, 1 top; gerçek anlamda sprite değil, CPU tarama satırı başına günceller
Commodore 64 (VIC-II) 8 24×21 piksel 1 renk (hi-res) / 3 renk (multi-color) Sprite çarpışma algılama donanımda; multiplexing ile daha fazla gösterilebilir
NES (RP2C02 PPU) 64 (maks. 8/satır) 8×8 veya 8×16 3 renk + şeffaf Mario gibi karakterler birden fazla sprite birleştirilerek oluşturulur
MSX 1 (TMS9918) 32 (maks. 4/satır) 8×8 veya 16×16 1 renk Monokrom sprite'lar; renk kısıtlamaları attribute clash'e bağlı değil
Atari 8-bit (ANTIC+GTIA) 4 oyuncu + 4 mermi 8 piksel geniş, tam ekran yüksekliğinde 1-3 renk "Player/Missile Graphics"; GTIA ile renk kaplama desteği
Nintendo Entertainment System (NES) konsolu
Nintendo Entertainment System (NES) — RP2C02 PPU çipi ile 64 sprite destekliyor, ancak tarama satırı başına en fazla 8 sprite gösterilebiliyordu. Mario karakteri birden fazla sprite'ın birleşimiyle oluşturuluyordu (Kaynak: Wikipedia, CC BY-SA).
💡 NES'te Mario Nasıl Oluşturuluyordu?

NES'in sprite'ları yalnızca 8×8 veya 8×16 piksel boyutundaydı. Mario gibi nispeten büyük bir karakter, birden fazla küçük sprite'ın yan yana dizilmesiyle oluşturuluyordu. Geliştiriciler bu sprite'ları o kadar iyi senkronize ediyorlardı ki, oyuncu için tek bir karakter gibi görünüyordu.

Ancak tarama satırı başına 8 sprite sınırı dolduğunda bazı sprite'lar görünmez oluyordu — eski NES oyunlarındaki "sprite flickering" (sprite titremesi) sorunu budur.

5. NTSC Artifact Renklendirme — Apple II

Apple II Plus bilgisayarı
Apple II Plus — 1977'de piyasaya çıkan Apple II, NES ve C64'ten 5 yıl öncesine ait bir makine. Yalnızca 6 yüksek çözünürlük rengine sahipti ama NTSC artifact renklendirmesi ile bu bile o dönem için etkileyiciydi (Kaynak: Wikipedia, CC BY-SA).

Apple II'nin grafik sistemi belki de tüm 8-bit bilgisayarlar arasında en karmaşık ve anlaşılması en zor olanıydı. Makine, üzerinde monokrom mu yoksa renkli monitör mü bağlı olduğuna göre tamamen farklı görüntüler üretiyordu.

Monokrom Ekran

Monokrom monitörde Apple II, 280×192 çözünürlükte son derece keskin bir görüntü sunuyordu. Pikseller basitçe açık ya da kapalıydı. Bu nedenle iş uygulamaları için idealdir.

Renkli Ekran — NTSC Artifact Coloring

Renkli monitör bağlandığındaysa durum tamamen değişiyordu. Apple II, renkleri NTSC televizyon sinyalinin fiziksel özelliklerinden yararlanarak üretiyordu. Ekran 7 piksellik bölümlere ayrılmış olup, her bölüm 8 bit bellekle tanımlanıyordu (7 piksel + 1 kontrol biti):

📺 İnteraktif Demo: NTSC Artifact Renklendirmesi

Piksellere tıklayarak açıp kapatın. Piksel konumunun ve kontrol bitinin (CB) rengi nasıl belirlediğini gözlemleyin.

⚠️ Renk Kısıtlaması

Yeşil/mor renk grubu ile turuncu/mavi renk grubu aynı 7-bit bölüm içinde bir arada kullanılamıyordu. Mavi ve yeşili yan yana getirmek ancak bölüm sınırlarını mükemmel hizalayarak mümkündü. Bu nedenle Apple II'nin renkli ekranda metin gösteriminde harfler gökkuşağı renklerinde görünüyordu.

"If you found that confusing, don't feel bad. There are very few people that really comprehend how Apple II graphics work."

— The 8-Bit Guy, "How 'Oldschool' Graphics Worked Part 2"

Apple II ayrıca 40×48 piksellik bir düşük çözünürlük modu sunuyordu. Pikseller çok büyük ve kaba görünüyordu, ancak 16 renk kullanılabiliyordu — Apple II'nin "16 renkli bilgisayar" olarak pazarlanmasının sebebi buydu.

6. CPU-Güdümlü Grafikler: "Racing the Beam"

Atari 2600 konsolu
Atari 2600 (1977) — Tarihte en radikal grafik mimarisine sahip konsol. RAM'siz TIA çipi, framebuffer yerine CPU'nun tarama satırı satırı görüntü oluşturmasını gerektiriyordu (Kaynak: Wikipedia, CC BY-SA).

Tüm eski sistemler arasında belki de en çarpıcı olanı Atari 2600'ün yaklaşımıdır. Bu konsol, hiçbir video framebuffer'ı olmadan çalışıyordu. Yani bellekte ekranın görüntüsünü tutan bir alan yoktu.

TIA Çipinin RAM'siz Tasarımı

Atari 2600'ün Television Interface Adaptor (TIA) çipi, Jay Miner tarafından tasarlanmıştı. O dönemde RAM son derece pahalıydı — megabayt başına on binlerce dolar. 80×48 piksellik basit bir framebuffer bile binlerce dolara mal olurdu. Bu nedenle TIA, framebuffer olmadan çalışmak üzere tasarlandı.

TIA şu grafik nesnelerini destekliyordu:

Tüm bu nesneler yalnızca tek bir tarama satırı için tanımlanabiliyordu. Bir sonraki satır için tüm register'lar yeniden yazılmalıydı. Bu yüzden oyun programı, televizyonun elektron ışınıyla yarışmak zorundaydı — bu teknik "racing the beam" olarak adlandırıldı.

Atari 2600 Barnstorming oyununda gökkuşağı efekti
Atari 2600'de Barnstorming oyunu — gökkuşağı efekti, programcıların her tarama satırında renk register'larını değiştirmesiyle elde ediliyor. "Racing the beam" tekniğinin güzel bir örneği (Kaynak: Wikipedia, CC BY-SA).

Zorluklar

Bu mimari, oyun geliştiricileri için muazzam zorluklar yaratıyordu:

"If you ever noticed in some games, if you look over to the left side of the screen and see these mysterious black lines, those are there because game code is running and there's just not enough time to draw the screen and run the game code at the same time."

— The 8-Bit Guy, "How 'Oldschool' Graphics Worked Part 2"
📖 Önerilen Kitap: "Racing the Beam"

Nick Montfort ve Ian Bogost'un Racing the Beam: The Atari Video Computer System (MIT Press, 2009) adlı kitabı, Atari 2600'ün TIA çipini ve programcıların bu kısıtlamalarla nasıl başa çıktığını detaylı şekilde anlatmaktadır. Platform studies (platform çalışmaları) alanının öncü eserlerinden biridir.

Yaratıcı Çözümler

Programcılar TIA'nın kısıtlamalarıyla başa çıkmak için önemli teknikler geliştirdiler:

  1. Renk register'larını her satırda değiştirmek: Playfield'ın 1 ve 0 değerlerinin renklerini her tarama satırında değiştirerek gökkuşağı benzeri efektler oluşturuldu.
  2. Sprite verilerini satır satır güncellemek: Space Invaders portunda, her satırda "player" register'ları değiştirilerek çok sayıda düşman illüzyonu yaratıldı.
  3. Asimetrik playfield: İleri düzey oyunlar, satır ortasında playfield verilerini değiştirerek simetrik olmayan ekranlar oluşturabildi.
  4. Ekran verisini kod olarak depolamak: Adventure oyunu, ekran verisini ROM'daki sabit veri yerine CPU komutları olarak kodlayarak 30 farklı oda oluşturmayı başardı.

7. Raster Trick'leri — Sınırları Aşmak

Atari 2600'ün "racing the beam" tekniğinin daha hafif bir versiyonu, geleneksel grafik çipine sahip sistemlerde de kullanılıyordu. Bu teknikler genel olarak "raster trick" olarak adlandırılır.

Temel fikir şuydu: CPU, ekranın her tarama satırının çizildiği anı takip ederek, o sırada grafik çipinin register'larını değiştirebiliyordu. Bu sayede:

Commodore 64'te VIC-II çipinin raster interrupt özelliği buna olanak tanıyordu. The 8-Bit Guy'ın belirttiği gibi, bu teknikle C64'te son derece etkileyici sanat eserleri üretildi — ancak CPU'nun neredeyse tamamını tükettiği için oyunlarda nadiren kullanılabildi.

"If a programmer wanted, he could use the CPU to change the color palette on each scanline. This allowed some pretty fantastic artwork on the Commodore 64, but this was never used in games because it pretty much chewed up all of the available CPU time."

— The 8-Bit Guy, "How 'Oldschool' Graphics Worked Part 2"

8. CGA ve IBM PC Grafikleri

IBM PC dünyası da benzer kısıtlamalardan muaf değildi. 1981'de tanıtılan Color Graphics Adapter (CGA), IBM'in ilk renkli grafik kartıydı. Motorola 6845 tabanlı olan CGA, 16 KB video belleğine sahipti.

Mod Çözünürlük Renk Sayısı Kısıtlama
Düşük çözünürlük320×2004 renkSabit 2 palet seçeneği
Yüksek çözünürlük640×2002 renkYalnızca siyah-beyaz
Metin modu80×25 karakter16 renk ön plan + 8 arka planGrafik değil, karakter tabanlı
Tweaked mod160×10016 renkBelgesiz, metin modu hack'i

CGA'nın 320×200 modundaki 4 renklik sabit paletler (cyan-magenta-beyaz veya kırmızı-yeşil-sarı) oldukça kısıtlayıcıydı. Geliştiriciler bu kısıtlamaları aşmak için çeşitli yöntemler kullandılar:

Dithering

Sınırlı renklerin birbirine karıştırılarak daha fazla renk tonu illüzyonu yaratılması. Özellikle grafik macera oyunlarında (Sierra'nın King's Quest serisi gibi) yaygın olarak kullanıldı.

Composite Artifact Renkleri

CGA, Apple II gibi NTSC composite çıkışından yararlanılarak 16'dan fazla renk üretebiliyordu. Kompozit video sinyalindeki parazitleri bilinçli olarak kullanarak, normalde mümkün olmayan renkler elde ediliyordu. Bu teknik özellikle bazı oyunlarda çarpıcı sonuçlar veriyordu.

9. Genel Karşılaştırma: 8-Bit Grafik Mimarileri

Sistem Yıl Grafik Çipi Çözünürlük Renk Paleti Temel Teknik
Apple II 1977 280×192 / 40×48 6 hi-res / 16 lo-res NTSC Artifact
Atari 2600 1977 TIA 160×192 (değişken) 128 (NTSC) Racing the Beam
ZX Spectrum 1982 ULA 256×192 15 (8×2 parlaklık - 1 tekrar) Attribute Clash
Commodore 64 1982 VIC-II 320×200 / 160×200 16 Color Cells + Sprites
NES 1983 RP2C02 PPU 256×240 54 (52 kullanılabilir) Color Cells + OAM Sprites
IBM CGA 1981 Motorola 6845 320×200 / 640×200 16 (RGBI) Sabit Palet + Dithering
MSX 1 1983 TMS9918 256×192 15 8×1 Attribute + 32 Sprite

10. Demoscene: Donanım Sınırlarını Zorlama Kültürü

8-bit grafik kısıtlamalarının yarattığı en önemli kültürel miras, demoscene hareketidir. Demoscene, bilgisayar donanımının sınırlarını zorlayarak görsel-işitsel sunumlar (demo) üreten uluslararası bir bilgisayar sanatı alt kültürüdür.

🏛️ UNESCO Somut Olmayan Kültürel Miras

Demoscene, 2020'de Finlandiya tarafından UNESCO somut olmayan kültürel miras listesine eklenen ilk dijital alt kültür oldu. Ardından Almanya (2021), Polonya (2021), Hollanda (2023), İsveç ve Fransa (2025) de kendi listelerine ekledi.

Kısa Tarihçe

Demoscene, 1980'lerin başında yazılım korsanlarının (cracker) kırdıkları oyunlara ekledikleri imza ekranlarından (crack intro) doğdu. Bu giriş ekranları zamanla müzik ve animasyon içeren etkileyici sunumlara evrildi. 1986'da C64 üzerinde 1001 Crew ve The Judges gibi Hollandalı grupların yarışması, bağımsız demoscene hareketinin başlangıcı kabul edilir.

Demoscene, oyun sektörü üzerinde de derin etkiler bıraktı. Remedy Entertainment (Max Payne) Future Crew demo grubundan, DICE (Battlefield) İsveç demo sahnesinden doğdu. Angry Birds'ün baş tasarımcısı Jaakko Iisalo da aktif bir demoscener'dı. John Carmack, 2011'de 64k intro programcılarına duyduğu saygıyı dile getirmiştir.

VIC-II Demo Teknikleri

C64 demo programcıları, VIC-II çipinin belgelenmemiş yan etkilerini keşfederek olağanüstü efektler oluşturdular:

TeknikAçıklamaNasıl Çalışır?
Border TrickNormalde boş olan kenarlık alanında sprite göstermeDonanımı kenarlık çizmemesi için kandırıp sprite'ları bu alana taşıma
FLI (Flexible Line Interpretation)Her 8-piksel satırda farklı renk bilgisiRaster interrupt ile her satırda renk RAM'ini yeniden yönlendirme
FLD (Flexible Line Distance)Karakter satırlarını dikey eksende serbest konumlamaVIC-II kontrol register'ını her satırda manipüle etme
VSP (Variable Screen Positioning)Bitmap'i yatay eksende piksel hassasiyetinde kaydırma$D011 register'ının cycle-exact manipülasyonu
AGSPVSP + Linecruncher birleşimi, tam hareket özgürlüğüRenkli bitmap grafiklerin her yöne kaydırılması
120+ Sprite Multiplexing8 donanım sprite sınırını 120'nin üzerine çıkarmaHer sprite çizildikten sonra Y koordinatını hızla değiştirme

Bu tekniklerin çoğu, CPU'nun VIC-II ile cycle-exact (döngü-hassas) senkronizasyonunu gerektiriyordu. Raster interrupt'ın doğru tarama satırında tetiklenmesi ve ardından her CPU döngüsünün hassas şekilde planlanması zorunluydu.

11. Terimler Sözlüğü

Bu bölümde geçen teknik terimlerin kısa açıklamaları:

Attribute Clash

Renk hücresi sistemlerinde, bir 8×8 blok içinde 2'den fazla renk kullanılamadığı için oluşan görsel artefakt. Özellikle ZX Spectrum'da belirgin.

Artifact Coloring (Composite)

NTSC sinyalinin fiziksel özelliklerinden yararlanarak, piksellerin yatay pozisyonuna göre renk üretme. Apple II, CGA, TRS-80 CoCo ve Atari 8-bit'te kullanıldı.

Racing the Beam

Framebuffer olmadan, CPU'nun TV tarama ışınıyla senkronize çalışarak her satırı anlık oluşturması. Atari 2600 TIA çipinin temel prensibi.

Raster Interrupt

Grafik çipinin belirli bir tarama satırına ulaştığında CPU'ya sinyal göndermesi. Mid-frame register değişikliklerine olanak tanır. VIC-II, ANTIC, Amiga Copper gibi çiplerde desteklenir.

Sprite Multiplexing

Sınırlı sayıda donanım sprite'ını, tarama ilerledikçe yeniden konumlandırarak ekranda daha fazla nesne gösterme. NES'te 64 sprite/8 per scanline, C64'te 8→120+.

Color Cell

Ekranı 8×8 piksellik bloklara bölüp, her blok için sınırlı sayıda renk tanımlama. 320×200 @ 16 renk için 32 KB yerine ~9 KB bellek yeterli olur.

Dithering

Sınırlı renk paletinde, farklı renkteki pikselleri düzenli desenlerle karıştırarak ara tonlar illüzyonu oluşturma. CGA oyunlarında ve pixel art'ta temel teknik.

Framebuffer

Ekrandaki her pikselin rengini depolayan bellek bölgesi. Çoğu sistemde standart, ancak Atari 2600 framebuffer'sız çalışan nadir bir tasarımdır.

Playfield (TIA)

Atari 2600'de arka plan grafiğini tanımlayan 20-bit register. Ekranın yalnızca yarısını temsil eder; simetri veya kopyalama ile tamamlanır.

FLI / IFLI / SHIFLI

C64 demo teknikleri: Her piksel satırında farklı renk bilgisi kullanarak attribute clash'i minimize etme. Sprite ve interlace ile genişletilebilir.

NTSC vs PAL

NTSC: Kuzey Amerika (60 Hz, 525 satır). PAL: Avrupa (50 Hz, 625 satır). Artifact renklendirme yalnızca NTSC'de güvenilir; PAL'da sınırlı ve tutarsız.

Demoscene

Donanım sınırlarını zorlayarak görsel-işitsel sunumlar üreten uluslararası alt kültür. 2020'den beri UNESCO somut olmayan kültürel miras listesinde.

12. Kısıtlamalar ve Yaratıcılık

🎨 Sınırlamalar Sanatı Nasıl Şekillendirdi?

8-bit dönemin grafik kısıtlamaları, geliştiricileri ve sanatçıları son derece yaratıcı olmaya zorladı. Bu dönemin mirası, bugün de oyun ve grafik tasarımını etkilemeye devam ediyor.

8-bit çağının kısıtlamaları, paradoks olarak bazı önemli sanatsal ve teknik yeniliklere yol açtı:

  1. Dithering sanatı: Sınırlı renk paletlerinde ton geçişleri oluşturmak, pixel art'ın temel tekniklerinden biri oldu. Bu teknik bugün retro oyunlarda ve indie oyunlarda estetik bir tercih olarak yaşamaya devam ediyor.
  2. Piksel hizalama ustalığı: C64 sanatçılarının renk hücre sınırlarına göre çalışması, "sınırlar içinde yaratıcılık" kavramının güçlü bir örneğidir.
  3. Sprite multiplexing: Donanım sınırlarını yazılım ile aşmak; bugünkü shader ve LOD optimizasyonlarının öncüsüdür.
  4. Demoscene kültürü: Donanım sınırlarını zorlama arzusu, C64 ile başlayan demoscene hareketini doğurdu. Bu kültür hâlâ aktiftir ve grafik programlamada önemli bir öğrenme alanıdır.
  5. Platform farkındalığı: Her sistemin benzersiz kısıtlamaları, geliştiricileri donanımı derinlemesine anlamaya zorladı. Bugünkü "donanıma yakın programlama" felsefesinin temelleri burada atıldı.

"Some of the graphics modes on the 64 are really strange, and they have no analogs to the Atari or Apple, like the ability to change color of the character basis across the screen. That gave us a lot of color capability that had not been exploited."

— Craig Nelson (Epyx), 1986

13. Kaynak Videolar ve Transkriptler

Bu bölümün temelini oluşturan video kaynakları, David Murray (The 8-Bit Guy) tarafından hazırlanmış iki bölümlük grafik donanımı belgeselidir:

📺 Video 1: "How 'Oldschool' Graphics Worked Part 1 — Commodore and Nintendo"

Konu: Ekran belleği matematik hesabı, renk hücreleri sistemi, C64 hi-res ve multi-color modları, donanım sprite'ları (C64'te 8 sprite, NES'te 64 sprite).

İzle: YouTube — The 8-Bit Guy

📜 Video 1 Transkripti (İngilizce — tıklayarak aç)
Welcome! In this episode I'm gonna explain how old-school graphics worked. Let's talk about some basic math real quick. Back in the early 1980s, your typical home computer had 16K of RAM, some had 32K, and if you really had money to burn, then you might have 64K. Now, let's talk about screen memory. The video chip back then didn't have its own bank of memory, so it had to share with the CPU. Back then a typical screen resolution was 320 x 200 pixels. And if you do the math, you'll see there are 64,000 pixels on the screen. Now, let's talk about color. If you just wanted 1-bit color, which is essentially black and white, then you would need 8 kilobytes of memory just to hold the screen information. Okay, so that takes a decent chunk of memory from all of these computers. But, it still leaves enough left over for your game code. Now, if you bump that up to 16 colors, suddenly you need 32K, which is more than many computers even had. By the time you get to 256 colors, you've eaten up all of the RAM, even in high-end computers, so now there's no room left for any code. And doing a modern-style 24-bit "true color" would be impossible. So the engineers were pretty smart and they figured out ways to get more color out of these old machines without using up so much RAM, and there were essentially three different methods used for this and I'm going to cover them. Color cells, which were used by many systems such as Commodore and Nintendo; artifact coloring, used primarily on the Apple II and the Tandy Color Computer; CPU driven graphics, such as on the Atari 2600 and the Sinclair ZX81. Ok, so the first type of system we're going to cover was arguably the most popular. Now what they did was they basically took the screen and shrunk it down into smaller sections and these sections were called cells or color cells. That way you could change the color of each specific cell. Let me illustrate how this works. Let's pretend this is a black screen, and let's zoom into the pixels. Now I've drawn this so that you can see imaginary lines where the pixels would be. Now, let's put some example text on the screen. At this point the screen is essentially a 1-bit screen so pixels are either on or they're off. So, how can we add color to this? Well, divide up the screen into areas that are 8 pixels wide and 8 pixels tall. Now, we'll make these areas where you can define a foreground and a background color. So, I could turn this letter yellow, and this letter blue. And I could make the background blue. So, you can see how this certainly adds some color to an otherwise black and white display. And each color cell only requires 1 byte of memory to define the foreground and background colors. That means the whole screen only used 9 kilobytes, instead of 8 kilobytes for a traditional monochrome screen. So, that was a pretty good tradeoff. But, here's where you start to run into problems. Let's just say, for example, that you wanted to put a white line here. This would actually not be possible, because you can only have two colors per cell. So, you can see how this method was able to give computers 16 colors on screen at the same time, you just couldn't always put the colors exactly where you wanted them to go. And you could imagine that this made artwork pretty challenging. Nevertheless, take a look at this piece of artwork done on the Commodore 64. It looks very colorful. And, to the layman, they may not even be aware of the color limitations of the computer. But, let's zoom into this piece of art, and look at it a little bit closer. If I overlay some imaginary lines to show you where the color cells are, you'll be able to see that, in fact, there are never more than 2 colors per cell. But, the artist has worked very hard to make his work line up with the edges of the cells to the point that it appears seamless. Knowing this should cause you to give these guys a little bit more respect for the work they do. And, if you were a player of the Nintendo Entertainment System, then keep in mind just about every game had to deal with this exact same issue. The color cells worked a little bit different than the Commodore 64, but it's basically the same headache. So the engineers knew that these color limitations might be a problem, so they gave the software designers another option they could use. Let's go back to our 2-color example. The C64 had a mode called "multi-color mode". Now, what it did was literally made the pixels twice as wide, which cut the screen resolution in half. Small text looks really bad like this. But the machine rewards you for your sacrifice. You have traded in some resolution for some color. But, it still only consumes 9 kilobytes of RAM, just like the other system. Now, each color cell will allow you up to 4 colors. So, now, you could do something like this. And here's an example of a piece of art done in multi-color mode. And again, I'll zoom in and show you the fine detail, and you can see how the colors were used in this picture. You will still never see more than 4 colors used in a single cell. Most games for the Commodore 64 actually used this mode, since color was often more important than high resolution. And then there was one other tool the engineers gave us. It's called a hardware sprite generator. Now let me show you how this works. I'm going to create a sprite on graph paper. This is actually how I learned to do this back in the early 1980s. Next, we have to convert this to binary data. So, let me show you how to break this down. Every pixel corresponds to a 0 or a 1. Now I've divided this up into three sections of 8 pixels each. So, let's take the first 8 pixels. There's nothing here, so we'll write in a 0 for this section. Ok, the next section does have some pixels, and for simplicity I'll use a calculator to convert from binary to decimal. So, we get 124. And the last section will also be a 0. Okay, so now to finish all the way down the paper. Ok, next I entered these numbers into the computer's memory. And, I can turn the sprite on like this. Notice that I cannot type over the sprite, nor can I erase it using the keyboard. Even if I change the color of the text, it doesn't matter. The sprite is independent from the rest of the screen, and it doesn't even care about the color cells. I can modify a different register and change the color of the sprite. I can change a different register, and move the sprite somewhere else on the screen. Even a clear screen command won't get rid of it. Sprites were heavily used in gaming. Different systems had different numbers of sprites. The Commodore 64 had 8 different sprites. Um, the Nintendo had 64 sprites, but, the sprites were very small, meaning you would usually need to use a lot more of them to accomplish the same goal. So, Mario here was actually made up of several different sprites, but they just do a good job of keeping them all together so it looks and behaves like one. All right, so this concludes part one. Stick around for part two, where I'm going to show you how Apple II graphics and some of the early CPU-driven graphics modes worked.
📺 Video 2: "How 'Oldschool' Graphics Work, Part 2 — Apple and Atari"

Konu: Apple II NTSC artifact renklendirmesi, Atari 2600 CPU-güdümlü grafikler (racing the beam), raster trick'leri ile C64'te tarama satırı başına palet değiştirme.

İzle: YouTube — The 8-Bit Guy

📜 Video 2 Transkripti (İngilizce — tıklayarak aç)
Welcome to part 2 of "How Old School Graphics Work". Now, in the last episode, I covered some of the more popular systems in the eighties, like the Nintendo and the Commodore systems, and in this episode I'm going to cover the Apple II and some other systems. Now, the Apple II is one of the more complicated and hard to explain graphics of all, and to be honest it actually works like two completely different computers depending upon whether you have a monochrome monitor or color monitor attached to it take this example this is a zoomed in view of what the pixels would look like on each type. Now, to better understand why it works this way let's break it down a bit further. The screen is divided up into sections of 7 pixels each. So, let's see what goes on inside these sections. Eight bits of memory are used to define the 7 pixels. The leftover bit is used to change the palette. So, here's how this works: on a monochrome monitor, if you turn on some bits in memory like this, the corresponding pixels will turn on, and you'll get the result you pretty much expected. So, what happens when we toggle this bit on and off? Pretty much nothing. So, on a monochrome screen, the Apple II had a very crisp graphics display and was generally great for business applications. OK, now let's add a color monitor for comparison. One of the first things you might notice when looking at an Apple II on a color monitor is that the text often looks rainbow-colored. Now, there's actually a reason for this and it has to do with the way the machine produces color. So, let's go back to our pixel diagram. If you turn on some bits you'll end up with colors, and you change the color by moving the location of the pixel like this. If you move the pixel to one side, you get green, and on the other side you get violet. Now, if you put two pixels next to each other you get white. So, that gives you four possible colors. But remember this control bit here? Watch what happens when we turn it on now. Notice the colors change to orange and blue. So, that extra control bit allows you to use two additional colors. But keep in mind that you can't use these colors in the same 7-bit section as these colors, so it's very difficult to have blue and green next to each other on the screen, unless you line it up just perfectly. And now you can see why text would look rainbow-colored when using a color monitor. Now, we've been talking about high resolution mode, which almost all games were designed for, but Apple also gave us a low resolution mode with 40 by 48 pixels. The pixels are huge and chunky, but you do get a total of 16 colors, hence why the Apple II claims to be a 16-color computer. Now, later on, when Apple introduced the Apple IIc and Apple IIe computers, they did add the ability for more colors in high resolution mode, but it was rarely used because game developers wanted to maintain compatibility with older Apples. All right. So if you found that confusing, don't feel bad. There are very few people that really comprehend how Apple II graphics work. And also I want to defend the computer a little bit for those who might say, "Wow! It can only do six colors when in high resolution graphics mode for games and stuff. That's terrible!" But you kind of have to keep it in perspective that this machine came out in 1977, which was a good five years earlier than systems like the Nintendo and the Commodore. So, OK, there's one more type of graphics system I want to talk about. It's called CPU-driven graphics, and let me show you how this works. I created some oversized pixels on this illustration. First of all, you have to keep in mind that the pixels are drawn on the screen one at a time starting on the top-left, moving to the right, and then dropping down. Of course, all this happens in the blink of an eye. In fact, that happens 30 times a second. Most computers have a dedicated video chip that sends pulses to the monitor, in the correct order and timing, to draw the picture on the screen. However, some systems had no video chip at all, and use the CPU to drive the pulses directly. OK, so this does actually work, but it requires an enormous amount of the CPU's time in order to pull this off. So, that left very little CPU time left over to run game code. Imagine if they did this on a modern system, and you opened your task manager, and there was always a task running called "Video Generator", and it took up ninety percent of your computer's CPU time. What a drag that would be, huh? Games designed for the Atari 2600 were quite a challenge because of this. In fact, if you ever noticed in some games, if you look over to the left side of the screen and see these mysterious black lines, those are there because game code is running and there's just not enough time to draw the screen and run the game code at the same time. Now, one last thing I'm going to mention is it is actually possible to use a little bit of CPU-driven graphics even on a machine that has a traditional graphics chip. You know those color cells we talked about in the last episode? Well, if a programmer wanted, he could use the CPU to change the color palette on each scanline. This allowed some pretty fantastic artwork on the Commodore 64, but this was never used in games because it pretty much chewed up all of the available CPU time. All right, so that about wraps it up for this episode. In the next episode, I'm going to be covering how old school sound and music worked, and if there's enough interest I might actually make one on IBM, CGA, EGA, and VGA graphics modes. Don't forget to like my video and subscribe, and also check out my Facebook page--there's a link down at the bottom. I'll see you next time!

14. Kaynaklar ve İleri Okuma

Video Kaynakları

Kitaplar

Akademik Makaleler

Wikipedia Makaleleri

Teknik Kaynaklar