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)
1
8 KB
✅ Çoğu bilgisayarda uygulanabilir
16 Renk (4-bit)
4
32 KB
⚠️ Birçok bilgisayarın toplam RAM'inden fazla
256 Renk (8-bit)
8
64 KB
❌ En pahalı bilgisayarın bile tüm RAM'i
True Color (24-bit)
24
192 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:
Renk Hücreleri (Color Cells) — Commodore 64, NES, ZX Spectrum
NTSC Artifact Renklendirme — Apple II, Tandy Color Computer
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:
Bitmap verisi: 8 KB (siyah-beyaz piksel bilgisi)
Renk bilgisi: 1 KB (1000 hücre × 1 byte)
Toplam: ~9 KB — 32 KB yerine!
🎮 İ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 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:
Nitelik (Attribute): 768 byte (24 satır × 32 sütun, her biri 8×8 blok)
Toplam: 6912 byte — tüm ekran bilgisi
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 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 — 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."
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ük
320×200
160×200 (pikseller 2× geniş)
Hücre başına renk
2
4
Bellek kullanımı
~9 KB
~9 KB
Tercih edilen kullanım
Metin, 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."
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:
Sprite ekranda görünür hale getirilir
Rengi değiştirilebilir
Konumu taşınabilir
Metin yazma veya ekranı temizleme gibi işlemlerden etkilenmez
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) — 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 — 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):
Bir pikselin yatay konumunu değiştirmek rengini değiştiriyordu: bir tarafta yeşil, diğer tarafta mor
İki bitişik piksel açıldığında beyaz oluşuyordu
Kontrol biti etkinleştirildiğinde renkler turuncu ve maviye dönüşüyordu
Toplam 6 yüksek çözünürlük rengi elde ediliyordu
📺 İ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."
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 (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:
Playfield: 20-bit'lik register, ekranın yarısını tanımlar (simetri veya kopyalama ile tam ekran)
2 Oyuncu (Player): 8 piksel genişliğinde sprite'lar, 2× veya 4× büyütülebilir
2 Mermi (Missile): Oyuncu rengiyle aynı, 1-8 piksel genişliğinde çizgi
1 Top (Ball): Playfield rengiyle aynı, 1-8 piksel genişliğinde çizgi
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'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:
CPU zamanının yaklaşık %90'ı görüntü oluşturmaya harcanıyordu
Oyun mantığı için çok az CPU zamanı kalıyordu
MOS 6507 işlemci, donanım kesintilerini (interrupt) desteklemiyordu — sadece "RDY" pini ile senkronizasyon yapılabiliyordu
Dikey senkronizasyon bile otomatik değildi — programcının satırları sayıp doğru zamanda sinyal göndermesi gerekiyordu
"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."
📖 Ö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:
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.
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ı.
Asimetrik playfield: İleri düzey oyunlar, satır ortasında playfield verilerini değiştirerek simetrik olmayan ekranlar oluşturabildi.
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:
Her tarama satırında farklı bir renk paleti kullanılabiliyordu
Normalde ekranın tamamında geçerli olan arka plan rengi satır satır değiştirilebiliyordu
Sprite multiplexing ile donanım limitinden daha fazla sprite gösterilebiliyordu
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."
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ük
320×200
4 renk
Sabit 2 palet seçeneği
Yüksek çözünürlük
640×200
2 renk
Yalnızca siyah-beyaz
Metin modu
80×25 karakter
16 renk ön plan + 8 arka plan
Grafik değil, karakter tabanlı
Tweaked mod
160×100
16 renk
Belgesiz, 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.
VSP + Linecruncher birleşimi, tam hareket özgürlüğü
Renkli bitmap grafiklerin her yöne kaydırılması
120+ Sprite Multiplexing
8 donanım sprite sınırını 120'nin üzerine çıkarma
Her 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ı:
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.
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.
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.
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.
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."
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).
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.
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!