Learn OpenGL – Graphics Programming İnceleme

Özet

Bu kitap, Joey de Vries isimli Hollandalı grafik programcısı tarafından yazılan ve günümüzde artık yeni içerik eklenmeyen, dünyanın belki de en kapsamlı ücretsiz modern OpenGL derslerinin yer aldığı Learn OpenGL web sitesinin basılı bir versiyonudur. Web sitesinde yer alan tüm bilgiler bu kitapda da yer almaktadır. O nedenle incelemeyi yaparken kitaptan ziyade bir nevi web sitesinin incelemesini yapıyor gibi olacağım. OpenGL programlamaya başlayacak olan kişiler için çok iyi anlatım, görsel ve örneklerle donatılmış bu kitap, sadece yeni başlayanlar için değil, daha ileri seviyelerdeki geliştiricilere de oldukça faydalı bilgiler sağlamaktadır. Kitaptaki örneklerin reposuna buradan ulaşabilirsiniz. Ayrıca kitabın (ve elbette web sitesinin) büyük bir bölümü Türkçe’ye çeviri çalışması yapılmaktadır. Türkçe çeviri sayfasına da buradan ulaşabilirsiniz.

İnceleme

Bölüm 1: Introduction (Giriş)

Bu bölümde kitapta yer alan yazım şekillerinin ve formatların tam olarak ne anlama geldiği açıklanmaktadır.

Parça 1: Getting Started (Başlarken)

Bu parçada OpenGL ile ilgili en temel bilgiler ele alınmaktadır.

Bölüm 2: OpenGL

Bu bölüme OpenGL’in Khronos Group tarafından geliştirilen bir API spesifikasyonu olduğu, core-profile ve immediate-mode isimli iki modunun bulunduğu ve OpenGL’in (bu kitap yazılırken) hangi versiyonlarının bulunduğu gibi bilgiler aktarılmaktadır. OpenGL’in eklentileri (extensions) hakkında bilgi verilmekte ve OpenGL’in kendisinin aslında büyük bir state machine olduğundan bahsedilmektedir. Son olarak da OpenGL’deki nesnelere (object) değinilmektedir.

Bölüm 3: Creating a Window (Bir Pencere Oluşturma)

Bu bölümde öncelikle GLFW kütüphanesini indirme, derleme ve bağlama anlatılmakta; GNU/Linux veya Windows üzerinde bu kütüphanenin nasıl kullanılacağı gösterilmektedir. Daha sonra kullandığınız işletim sisteminde yer alan OpenGL fonksiyon göstericilerini alıp programınızda kullanmanıza olanak sağlayan GLAD kütüphanesinin kurulumu ve kullanımından bahsedilmektedir.

Bölüm 4: Hello Window (Merhaba Pencere)

Bu bölümde GLFW kütüphanesini kullanarak bir pencere oluşturma ve GLAD kütüphanesini başlatma anlatılmaktadır. Görüş alanı (viewport) kavramından bahsedilmekte ve OpenGL ile görüş alanının boyutunu ayarlama gösterilmektedir. Ayrıca GLFW callback fonksiyonları ile ilgili bilgi verilmekte ve pencereyi yeniden boyutlandırma, GLFW’nin girdileri yakalaması gibi olayların nasıl implement edileceği anlatılmaktadır. Bu bölümde ayrıca tampon (buffer) kavramına da girilmekte ve GUI uygulamalarında pencerelerin kullandığı çift tamponlama (double buffering) olayı da anlatılmaktadır. Bölümün sonunda pencere çizme uygulaması tamamlanmaktadır.

Bölüm 5: Hello Triangle (Merhaba Üçgen)

Bu bölümde belki de grafik API derslerinin bir "Hello World" örneği olan, OpenGL ile ekrana basit bir üçgen çizdirme olayı anlatılmaktadır. İlk başta grafik iş hattından (graphics pipeline) bahsedilmekte ve OpenGL’de bu iş hattında özelleştirilebilir alanlardan bahsedilmektedir. Shader, OpenGL Shading Language (GLSL), Vertex, Vertex Attribute, Vertex Shader, Fragment Shader, Fragment, Geometry Shader, Rasterization, Clipping, Blending gibi pek çok kavrama yine bu bölümde değinilmektedir.

Bu kavramların hepsine kısaca değindikten sonra, normalleştirilmiş cihaz koordinatları (normalized device coordinates) ve Vertex verilerinin alınıp Vertex Buffer Objects (VBO) yoluyla GPU’ya aktarılması anlatılmaktadır. Bu bölümde yine ekrana üçgen çizdirmek için basit bir Vertex Shader ve Fragment Shader’ın yazımı, derlenmesi, (Shader Program içinde) bağlanması ve kullanılması anlatılmaktadır. Daha sonra VBO’ya yerleştirilen verilerin GPU tarafından düzgün bir şekilde okunabilmesini sağlayan Vertex Attribute’ların oluşturulması ve Vertex Array Object (VAO) denen nesne içinde bağlanması anlatılmaktadır. Son olarak da OpenGL’deki çizim komutları ve tüm bu ayarlamalar ile ekrana üçgen çizme örneği tamamlanmaktadır.

Bu bölümde yine ekstra olarak, daha az Vertex bilgisi kullanarak ve Vertex’lerin çizim sırasını belirterek ekrana çizim yapmanıza olanak sağlayan Element Buffer Objects (EBO) nesnesinden bahsedilmekte ve onunla ilgili de bir örnek verilmektedir. Son olarak "glPolygonMode" ile Wireframe modunda çizim yapma gösterilmektedir.

Bölüm 6: Shaders (Gölgelendiriciler)

Bu bölümde OpenGL’de Shader yazımına olanak sağlayan GLSL dili ile ilgili daha ayrıntılı bilgiler verilmektedir. Bir GLSL kodunun yapısı ve kullanımı daha ayrıntılı gösterilmektedir. GLSL’deki temel türler, bu türlerin kullanımı, bir Shader’dan diğerine bilgi aktarmak için kullanılan "in" ve "out" anahtar kelimeleri ve GLSL türlerinden değişkenleri esnek bir şekilde kullanmaya yarayan Swizzling isimli özellik anlatılmaktadır. Bu bilgileri kullanarak ekrana daha önce çizdiğimiz üçgene renk verme olayı gösterilmektedir.

Daha sonra Shader’lara dışarıdan bilgi aktarmak için kullanılan Uniform’lar ve onların GLSL kodlarında kullanımı anlatılmaktadır. Uniform değişkenlerine dışarıdan nasıl erişebileceğimiz ve türlerine göre nasıl değer atayabileceğimiz gösterilmektedir. Uniform ile ilgili çeşitli fonksiyonlar gösterildikten sonra, Vertex yoluyla renk aktarımı örneği verilmektedir. Son olarak Shader’ları kitabın geri kalan uygulamalrında da daha rahat kullanabilmeniz için "Shader" isimli sınıfın yazımı ve kullanımı gösterilmektedir.

Bölüm 7: Textures (Kaplamalar)

Bu bölümde bir nesnenin pikselleri üzerine daha karmaşık renk bilgileri aktarmak için kullanılan kaplamalar (textures) konusu ele alınmaktadır. OpenGL’de kaplamalar için sarmalama (wrapping) ve filtreleme (filtering) modları anlatılmakta ve görseller ile aralarındaki farklar açıklanmaya çalışılmaktadır. Yine Mipmap’lerden kısaca bahsedilmekte ve modları anlatılmaktadır.

Sadece başlık dosyasından oluşan (header only) popüler bir kütüphane olan "stb_image.h" ile bir resim dosyası verilerini programınıza nasıl yükleyebileceğiniz gösterilmektedir. Bu yüklediğiniz verileri GPU tarafına nasıl aktarabileceğiniz de gösterilmektedir. GPU tarafında yer alan kaplamaları nesne üzerinde doğru bir şekilde uygulamak için Texture Coordinate denen koordinat bilgilerinden nasıl yararlanacağınız ve bunları Vertex verisi ile yine GPU’ya nasıl aktarabileceğiniz anlatılmaktadır. Bütün bunların sonunda üzerine kaplama uygulanmış bir dikdörtgen örneği verilmektedir. Bölümün sonunda ise resim dosyasının alınması ile ilgili bazı ipuçlarından ve Texture Unit kavramından bahsedilmekte ve bir başka örnek verilmektedir.

Bölüm 8: Transformations (Dönüşümler)

Bu bölümde vektörler ve onlarla yapılan işlemler, iç çarpım (dot product), çapraz çarpım (cross product), matrisler ve onlarla yapılan işlemler, ölçekleme (scaling), öteleme (translation), döndürme (rotation) ve genel dönüşüm matrisi (transformation matrix) matematiksel olarak anlatılmaktadır. Daha sonra bu işlemleri kolayca uygulayabileceğiniz bir kütüphane olan OpenGL Mathematics (GLM) isimli kütüphanenin kurulumu ve kullanımından bahsedilmektedir. Son olarak anlatılan dönüşüm işlemlerinin bu kütüphane ile son OpenGL uygulamamıza entegre edilmesi ile ilgili bir örnek verilmektedir.

Parça 9: Coordinate Systems (Koordinat Sistemleri)

Bu bölümde koordinat sistemleri üzerinde konuşulmaktadır. OpenGL ile çizmeye çalıştığımız geometrik şekillerin şu dönüşümlerden geçerek iki boyutlu ekrana basıldığı anlatılmaktadır:

• Yerel Uzay (Local Space) veya Nesne Uzayı (Object Space)
• Dünya Uzayı (World Space)
• Görüş Uzayı (View Space) veya Göz Uzayı (Eye Space)
• Kırpma Uzayı (Clip Space)
• Ekran Uzayı (Screen Space)

Bu bölüm özellikle ortogonal projeksiyon (orthogonal projection) ve perspektif projeksiyon (perspective projection) kavramlarını matematiksel ve görsel olarak açıklama konusunda da önem taşımaktadır. Bölümün sonunda ise bütün anlatılan bilgileri bir araya getirilerek, OpenGL’de 3 boyutlu bir nesneyi nasıl çizeceğimizin örneği gösterilmektedir. Elbette bunu yaparken de Z-tamponu (Z-buffer) veya derinlik tamponu (depth buffer) adı verilen tampon ile ilgili bilgiler de verilmektedir.

Bölüm 10: Camera (Kamera)

Bu bölümde öncelikle OpenGL’in kendisinin kamera gibi bir kavrama sahip olmadığı ve OpenGL dünyasında kamerayı matematiksel dönüşümlerle nasıl simüle edebileceğimizden bahsedilmektedir. Bu bilgileri kullanarak OpenGL’de sahnede dolaşma ile ilgili bir örnek gösterilmektedir. Yine bilgisayar grafiklerinde hareketin stabil hale getirilmesinde önemli bir yeri olan delta zamanı (deltatime) kavramına da burada değinilmektedir. Bölümün sonunda kamera ile zoom yapma örneği verilmekte ve genelleştirilmiş kamera sınıfının implementasyonu verilmektedir.

Bölüm 11: Review (Gözden Geçirme)

Bu bölüm anlatılan ilk 10 bölümün özetini içermektedir.

Parça 2: Lighting (Işıklandırma)

Bu parçada OpenGL’de temel ışıklandırma terimlerinden ve implementasyonlarından bahsedilmektedir.

Bölüm 12: Colors (Renkler)

Bu bölümde kısaca renk kavramının ne olduğundan ve OpenGL’de renkleri vektörel olarak nasıl ifade edebileceğimizden bahsedilmektedir. Daha sonra sahneye ayrı bir Shader’a sahip ışık kaynağı ekleme ve tek renk olarak bir nesneyi aydınlatma örneği gösterilmektedir.

Bölüm 13: Basic Lighting (Temel Işıklandırma)

Bu bölümde OpenGL’de temel ışıklandırma modeli olarak kullanılan Phong ışıklandırma modeli (Phong lighting model) anlatılmaktadır. Phong ışıklandırma modelinin 3 temel bileşeni olan Ambient, Diffuse ve Specular ışıklandırma bileşenleri açıklanmaktadır. Daha sonra bu bileşenleri ışıklandırma formülüne sırasıyla tek tek ekleyerek çeşitli örnekler gösterilmektedir.

Bölüm 14: Materials (Materyaller)

Bu bölümde bilgisayar grafiklerindeki materyal kavramından ve OpenGL’de materyalleri nasıl implement edebileceğimizden bahsedilmektedir. GLSL’de yer alan bir yapının elemanlarına Uniform’lar vasıtasıyla nasıl değer atayabileceğimizden bahsedilip çeşitli materyallerin kullanımları ile iglili örnekler verilmektedir.

Bölüm 15: Lighting Maps (Işıklandırma Eşlemeleri)

Bu bölümde bir nesnenin Diffuse ve Specular ışıklandırmalarını tek bir renk verisinden değil de bir kaplama (texture) üzerinden okuyup daha karmaşık Diffuse ve Specular ışıklandırma hesaplarını nasıl yapabileceğimiz anlatılmaktadır. Böylelikle üzerinde farklı metalik bölgeler bulunan bir nesnenin aydınlatmasını kaplamalar yoluyla nasıl daha gerçekçi yapabileceğimiz örneklerle açıklanmaktadır.

Bölüm 16: Light Casters (Işık Kaynakları)

Bu bölümde aşağıdaki ışık kaynakları ve onların matematiksel özellikleri hakkında konuşulup her biri ile iglili örnek verilmektedir:

• Doğrusal Işık (Directional Light)
• Noktasal Işık (Point Light)
• Spot Işığı (Spotlight)
• Flaş Işığı (Flashlight)

Bölüm 17: Multiple Lights (Çoklu Işıklar)

Bu bölümde birden çok ışık kaynağından gelen ışığın bir nesne üzerinde toplam bir ışıklandırma nasıl yapabileceği ve bunu OpenGL’de nasıl uygulayabileceğimiz anlatılmaktadır ve bununla ilgili genel bir örnek gösterilmektedir.

Bölüm 18: Review (Gözden Geçirme)

Bu bölüm ışıklandırma ile ilgili anlatılan 6 bölümün özetini içermektedir.

Parça 3: Model Loading (Model Yükleme)

Bu parçada genel olarak 3 boyutlu bir model dosyasının bir OpenGL projesinde nasıl kullanılabileceği anlatılmaktadır.

Bölüm 19: Assimp

Bu bölümde pek çok 3 boyulu model dosyasını açma ve uygun veri yapılarına atama işlemini başarılı bir şekilde gerçekleştiren Assimp kütüphanesinin genel tanıtımı, sınıf hiyerarşisi ve derlenmesi anlatılmaktadır.

Bölüm 20: Mesh

Bu bölümde bilgisayar grafiklerindeki tek bir geometrik şekli belirten Mesh kavramı açıklanmakta ve Assimp kütüphanesi ile bir model dosyasından okunan Mesh bilgisini, OpenGL örneklerimizde rahatça kullanabilmemize yarayan sınıfın tasarımı anlatılmaktadır.

Bölüm 21: Model

Bu bölümde birden fazla Mesh’in bir araya gelerek oluşturduğu Model kavramından bahsedilmektedir. Assimp ile daha önce Mesh için oluşturduğumuz sınıfın da yardımıyla modelleri ele alabilecek bir sınıfın yazımı açıklanmaktadır. Bölümün sonunda ise dosyadan okunan 3 boyutlu modelin bu yazdığımız sınıflar yardımıyla ekranda nasıl gösterileceği ile ilgili bir örnek verilmektedir.

Parça 4: Advanced OpenGL (İleri Seviye OpenGL)

Bu parçada bilgisayar grafiklerinde, OpenGL’de ve GLSL’de karşımıza çıkabilecek ileri düzey kavramlar ve teknikler açıklanmaktadır.

Bölüm 22: Depth Testing (Derinlik Testi)

Bu bölümde daha önce bahsedilen derinlik tamponu (depth buffer) kavramına daha derin bir bakış atılmakta ve OpenGL iş hattında (pipeline) yer alan derinlik testine (depth test) değinilmektedir. OpenGL’de kullanabileceğimiz derinlik testi fonksiyonlarından (depth test functions) bahsedilmekte ve bazılarının kullanımı ile ilgili örnekler verilmketedir. Derinlik tamponunu hata ayıklama (debug) amaçlı olarak nasıl görselleştirebileceğimiz hakkında konuşulmakta ve bununla ilgili örnek verilmektedir. Son olarak da Z-çatışması (Z-fighting) sorunu hakkında konuşulmakta, örnek gösterilmekte ve bununla ilgili çözümlerden bir tanesi anlatılmaktadır.

Bölüm 23: Stencil Testing (Kalıp Testi)

Bu bölümde ekranda ilginç efektler oluşturmak için kullanabileceğimiz kalıp tamponundan (stencil buffer) ve kalıp testinden (stencil test) bahsedilmektedir. OpenGL’de kalıp tamponunu nasıl etkinleştirebileceğimiz, kalıp maskesi, kalıp fonksiyonları (stencil functions) gibi konular açıklanmaktadır. Son olarak ise OpenGL’de kalıp tamponu ve kalıp testi ile bir nesnenin etrafına nasıl dış hat çizgileri (outline) çizebileceğimiz anlatılmakta ve bununla ilgili bir örnek verilmektedir.

Bölüm 24: Blending (Karıştırma)

Bu bölümde saydam nesnelerin bilgisayar grafiklerinde nasıl simüle edilebileceği anlatılmaktadır. Öncelikle bir kaplamanın renk olmayan kısımlarının render işleminden nasıl çıkarılabileceği anlatılmakta ve bir ot kaplaması üzerinden örnek verilmektedir. Daha sonra OpenGL’de Blending kavramı anlatılmakta ve onu nasıl etkinleştirebileceğiniz gösterilmektedir. OpenGL’de yer alan çeşitli Blending fonksiyonları, bunların işlevleri ve kullanımları açıklanmaktadır. Bu açıklamalardan sonra yarı saydam kaplamaların OpenGL’de nasıl uygulanabileceği gösterilmektedir. En son ise çizilen nesneleri sıralayarak saydam alanlar ile ilgili çizim problemlerinin giderilmesi gösterilmektedir.

Bölüm 25: Face Culling (Yüz Ayırma)

Bu bölümde öncelikle çizilen nesnenin bir yüzünün (face) hangi sarım sırasına göre (winding order) nasıl çizildiği anlatılmaktadır. Buna göre iki sarım sırası bulunmaktadır:

• Saat yönü (clockwise)
• Saay yönünün tersi (counter-clockwise)

Bu kısa bilgilendirmeden sonra OpenGL’de yüz ayırma (face culling) kavramına giriş yapılmakta ve onu nasıl etkinleştirebileceğiniz anlatılmaktadır. Yüz ayırma ile bazı durumlarda nasıl performans artışı sağlayabileceğiniz, yüzün hangi tarafının (ön, arka, ön ve arka) render işleminden çıkarılacağını nasıl belirtebileceğiniz, render işleminden çıkarmada sarım sırasını (winding order) nasıl belirtebileceğiniz tek tek anlatılmakta ve örnekleri gösterilmektedir.

Bölüm 26: Framebuffers

Bu bölümde renk, derinlik ve kalıp tamponlarının üçünü de üzerinde barındıran ve OpenGL’in en son çizim yaptığı yer olan Framebuffer kavramı anlatılmaktadır. OpenGL’de bir Framebuffer nesnesini nasıl oluşturabileceğiniz ve ona farklı türden tamponları nasıl bağlayabileceğiniz gösterilmektedir. Kitaba göre ona bağlayabileceğiniz iki tür bağ (attachment) bulunmaktadır:

• Kaplama bağı (texture attachment)
• Renderbuffer nesnesi bağı (renderbuffer object attachment)

Bütün bu bilgileri verdikten sonra bir kaplamanın üzerine bütün bir sahneyi nasıl render edebileceğiniz gösterilmektedir. Daha sonra ise Framebuffer’ları kullanarak yine bilgisayar grafiklerinde önemli bir yeri olan Post-processing efektlerini nasıl implement edebileceğiniz anlatılmaktadır. Burada anlatılan efetler şunlardır:

• Tersine çevirme (inversion)
• Gri tonlama (grayscale)
• Bulanıklaştırma (blur)
• Kenar algılama (edge detection)

Bölüm 27: Cubemaps (Küp Eşlemeleri)

Bu bölümde birden fazla kaplamanın tek bir kaplama olarak ele alınıp kullanılmasını sağlayan küp eşleme (cubemap) tekniği ve onun OpenGL ile implementasyonu anlatılmaktadır. Öncelikle bu tür bir kaplamayı nasıl oluşturabileceğiniz ve onun yüzlerine nasıl farklı kaplamalar atayabileceğiniz gösterilmektedir. Bu bilgileri kullanarak genellikle 3 boyutlu sahnelerde gökyüzü havası vermek için kullanılan gökyüzü kutularını (skybox) nasıl oluşturabileceğiniz anlatılmaktadır. Son olarak şu çevresel eşleme teknikleri anlatılmakta ve onlarla ilgili örnekler verilmemtedir.

• Yansıma (reflection)
• Kırılma (refraction)

Bölüm 28: Advanced Data (İleri Seviye Veriler)

Bu bölümde OpenGL’de ileri düzey veri yönetimini nasıl yapabileceğiniz ile ilgili teknik ve komutlar gösterilmektedir. Vertex Attribute’larını nasıl harmanlayabileceğiniz (batching), tamponları birbirine nasıl kopyalayabileceğiniz anlatılmakta ve örnekleri gösterilmektedir.

Bölüm 29: Advanced GLSL (İleri Seviye GLSL)

Bu bölümde GLSL ile ilgili bazı ileri düzey özelliklere değinilmektedir. GLSL’de yer alan bazı gömülü (built-in) değişkenler, Vertex Shader değişkenleri, Fragment Shader değişkenleri, arayüz blokları (interface blocks), Uniform tampon nesneleri, Uniform blok şablonu gibi konulardan kısaca bahsedilmekte ve en son ise genel bir örnek verilmektedir.

Bölüm 30: Geometry Shader (Geometri Gölgelendirici)

Bu bölümde Vertex Shader ve Fragment Shader arasında yer alan, Vertex’leri gruplar halinde ele alıp yeni Vertex’lerin o anda oluşmasını sağlayabilen Geometry Shader ele alınmaktadır. Geometry Shader’ın bazı kullanım senaryoları ile ilgili örnekler verilmektedir.

Bölüm 31: Instancing (Örnekleme)

Bu bölümde benzer nesneleri ayrı ayrı çizim çağrıları (draw call) ile çizmek yerine, tek bir sefer veri göndererek birden fazla örneğini çizme tekniği olan örnekleme (instancing) isimli teknik anlatılmakta ve bunu OpenGL’de nasıl yapabileceğiniz örneklerle gösterilmektedir.

Bölüm 32: Anti Aliasing (Kenar Yumuşatma)

Bu bölümde çizilen nesnelerin kenarlarında sıklıkla görebileceğiniz testereli kenarların (jagged edges), ismine kenar yumuşatma (anti aliasing) adı verilen yöntemler ile nasıl giderilebileceği basitçe gösterilmektedir. Her şeyden önce Multisampling kavramına girilmekte ve bu kavramın detayları görsellerle açıklanmaktadır. Daha sonra OpenGL’de MSAA (multisample anti-aliasing) tekniği ile kenar yumuşatmanın nasıl yapılabileceği anlatılmakta ve örnekleri verilmektedir. Ayrıca ekran dışı (off-screen) MSAA implementasyonu da gösterilmektedir. Son olarak ise kendi kenar yumuşatma algoritmalarınızı nasıl yazabileceğiniz hakkında çeşitli fikirler verilmektedir.

Parça 5: Advanced Lighting (İleri Seviye Işıklandırma)

Bu parçada OpenGL’de ileri ışıklandırma teknikleri ve onların uygulamaları anlatılmaktadır.

Bölüm 33: Advanced Lighting (İleri Seviye Işıklandırma)

Bu bölümde Phong ışıklandırma modelinde (Phong lighting model) yer alan bazı sorunları çözen Blinn-Phong ışıklandırma modeli anlatılmaktadır. Blinn-Phong ile ilgili genel bir örnek yapılmakta ve hem matematiksel hem de görsel olarak Phong ile Blinn-Phong modelleri arasındaki farklar açıklanmaktadır.

Bölüm 34: Gamma Correction (Gama Düzeltmesi)

Bu bölümde öncelikle her ekranda yer alan aydınlık geçişinin aynı ve lineer olmayabileceği anlatılmakta ve ekranlardaki bu farklılığı OpenGL’de çizim yaptığınız renklere uygulamaya yarayan gama düzeltmesi (gamma correction) tekniği anlatılmaktadır. Gama düzeltmesi tekniğinin ne olduğu ve basitçe nasıl implement edebileceğimizden bahsedilmektedir. Ayrıca sRGB kaplamalar hakkında da bilgiler verilip örnek bir sRGB kaplamasının kullanımı da gösterilmektedir.

Bölüm 35: Shadow Mapping (Gölge Eşleme)

Bu bölümde OpenGL ile gölge oluşturma tekniklerine giriş yapılmaktadır. Gölge eşleme (shadow mapping) tekinği, bu tekniğin teorisi, derinlik haritası (depth map) ve ışık uzayı dönüşümü (light space transform) gibi konular kısaca ele alınmaktadır. Daha sonra bütün bu bilgiler ile gölgeleri nasıl render edebileceğiniz örneklerle açıklanmaktadır. Verilen örnekte yer alan pek çok sorunun nasıl düzeltilebileceği de tek tek açıklanmaktadır.

Bölüm 36: Point Shadows (Noktasal Gölgeler)

Bu bölümde tek yönlü gölge eşlemeden ziyade çok yönlü gölge eşleme (omnidirectional shadow mapping) tekniği ve bir Cubemap ile bunu nasıl implement edebileceğiniz anlatılmaktadır. Bununla ilgili bir örnek yapılmakta ve bir önceki bölümde olduğu gibi bu örnekte meydana gelen hataların tek tek çözümü verilmektedir.

Bölüm 37: Normal Mapping (Normal Eşleme)

Bu bölümde öncelikle normal eşlemenin (normal mapping) ne olduğu, ona neden ihtiyaç duyulduğu ve ne gibi avantajları olduğu ele alınmaktadır. Daha sonra tanjant uzayı (tangent space) konusu ele alınmakta ve OpenGL’de bunun hesaplamasını nasıl yapabileceğiniz gösterilmektedir. Ayrıca karmaşık nesnelerde normal eşleme yapma ile ilgili bilgiler de verilmektedir.

Bölüm 38: Parallax Mapping (Paralaks Eşleme)

Bu bölümde yer değiştirme eşlemelerinden (displacement mapping) biri olan paralaks eşleme (parallax mapping) konusu ele alınmakta ve bazı yüzeylerde daha iyi bir derinlik hissi oluşturma tekniği anlatılmaktadır. Yine bu tekniğin türevleri olan dik paralaks eşleme (steep parallax mapping) ve paralaks oklüzyon eşleme (parallax occlusion mapping) teknikleri de anlatılmakta ve örneklendirilmektedir.

Bölüm 39: HDR

Bu bölümde sahnelerde bazen toplam ışık miktarının maksimum değer sınırını geçmesi ile gerçekçi olmayan ışıklandırmalar çıkabileceği, bunu ise HDR (High Dynamic Range) adı verilen bir teknik ile kolaylıkla çözebileceğimiz anlatılmaktadır. Kayan noktalı sayı değerleri tutan Framebuffer’lar ve ton eşleme (tone mapping) gibi konular ele alınıp HDR ile ilgili genel bir örnek verilmektedir.

Bölüm 40: Bloom (Kamaşma)

Bu bölümde adını sahnede yer alan ışıklara doğrudan bakıldığında göz kamaştırma hissi oluşturmaktan alan Bloom efektinin ne olduğu ve nasıl implement edildiği anlatılmaktadır. Bloom efekti oluşturmak için sahnenin farklı geçiş çıktılarını almak, HDR ve bulanıklık efektleri kullanmak, Gaussian bulanıklığının (Gaussian blur) teorisi ve implementasyonu, kaplamaları karıştırıp final sahnesi ortaya çıkarmak gibi konular ile bölüm sonlandırılmaktadır.

Bölüm 41: Deferred Shading (Gecikmeli Gölgelendirme)

Bu bölümde öncelikle sahnenin farklı çıktılarını depolamaya yarayan G-tamponu (G-buffer) isimli tampon ele alınmaktadır. G-tamponu ile çok sayıda farklı çıktıyı depolama ve bunları birleştirme anlatılmaktadır. Yine bu tamponu kullanarak gecikmeli gölgelendirme (deferred shading) tekniğini nasıl uygulayabilieceğimiz anlatılmakta ve bir örnek verilmektedir.

Bölüm 42: SSAO

Bu bölümde 2007 yılında Crytek firmasının yayımladığı SSAO (Screen-Space Ambient Occlusion) isimli tekniğin teorisi ve uygulaması anlatılmaktadır.

Parça 6: PBR

Bu parçada PBR (Physically Based Rendering) isimli render tekniğinin teorisi ve uygulaması gösterilmektedir.

Bölüm 43: Theory (Teori)

Bu bölümde PBR (Physically Based Rendering) isimli ve fiziksel dünyadaki ışıklandırma mantığına oldukça yakın olan bir render tekniğinin teorisi verilmektedir. Microfacet modeli, yüzey biçimleri, enerji dönüşümü, yansıtma (reflectance) denklemi, parlaklık (irradiance), BRDF (Bidirectional Reflective Distribution Function), geometri fonksiyonu, Fresnel denklemi, Cook-Torrance yansıma denklemi gibi teorik konular matematiksel olarak ele alınmakta ve anlatılmaktadır. Son olarak da PBR materyallerden kısaca bahsedilmektedir.

Bölüm 44: Lighting (Işıklandırma)

Bu bölümde bir önceki bölümdeki teorik anlatımlar koda dökülmeye çalışılmaktadır. Öncelikle PBR yüzey modeli ve bunun bir Shader içinde nasıl yazılacağı gösterilmekte, önceki bölümde gösterilen denklemler yine Shader içinde tanımlanmaktadır. Yapılan işleme HDR ve gama düzeltmesi de uygulanmaktadır. Kaplamalı yüzeyler için PBR’ın uygulanması da gösterilmektedir.

Bölüm 45: IBL – Diffuse Irradiance

Bu bölümde ışıklandırmanın doğrudan sahne hesaplamalarından değil de bir tür resim dosyasından değerlerin okunarak yapıldığı IBL (Image Based Lighting) tekniğine giriş yapılmaktadır. Bu bölümde sadece genel denklemin Diffuse kısmının implementasyonu gösterilmektedir.

Bölüm 46: IBL – Specular IBL

Bu bölümde, bir önceki bölümde bahsedilen IBL tekniğinde kullanılan denklemin Specular kısmı gösterilmekte ve parça tamamlanmaktadır.

Parça 7: In Practice (Uygulama)

Bu parçada OpenGL’de hata ayıklama ve ekrana metin yazdırma uygulamaları anlatılmaktadır.

Bölüm 47: Debugging (Hata Ayıklama)

Bu bölümde OpenGL’de hata ayıklama (debugging) işleminin nasıl yapılabileceği ile ilgili bilgiler verilmektedir. Hata ayıklama çıktısının nasıl elde edilebileceği ve yorumlanabileceği anlatılmaktadır. Ayrıca hata ayıklama çıktısını yorumlayıp daha anlamlı çıktılar üreten bir fonksiyonun implementasyonu gösterilmektedir. Yine bu bölümde GLSL Shader’larında nasıl hata ayıklama yapılabileceği hakkında bilgiler verilmektedir. Son olarak da OpenGL’de hata ayıklama için kullanabileceğiniz diğer programlar gösterilmektedir.

Bölüm 48: Text Rendering (Yazı Görselleştirme)

Bu bölümde OpenGL ile ekrana basitçe nasıl yazı yazdırabileceğimizden bahsedilmektedir. Bitmap Font kavramı anlatılmakta ve onu daha modern bir şekilde ele alan bir kütüphane olan FreeType kütüphanesinden kısaca bahsedilmektedir. Font ile ilgili genel kavramların açıklaması yapıldıktan sonra Font ile ilgili Shader’ın yazımı gösterilmektedir. Son olarak da OpenGL uygulamasında verdiğimiz herhangi bir yazının ekranın herhangi bir konumunda bu Shader ile yazdırılmasının uygulaması verilmektedir.

Parça 8: 2D Game (2B Oyun)

Bu bölümde 1976 yılında Atari firması tarafından yayımlanan popüler bir oyun olan Breakout oyununun bir kopyasını, öğrendiğimiz bilgiler ile OpenGL kullanarak nasıl implement edebileceğimiz gösterilmektedir.

Bölüm 49: Breakout

Bu bölümde genel olarak eski Breakout oyunundan ve onun fonksiyonlarından kısaca bahsedilmekte ve bizim yapacağımız modern Breakout oyununun fonksiyonları ve görselleri özetlenmektedir.

Bölüm 50: Setting Up (Ayarlama)

Bu bölümde genel oyunu kontrol edecek sınıfların arayüzü ve implementasyonu gösterilmektedir. Ayrıca kaynak yönetimi ile ilgili sınıfın yazımı ve genel programın yazımı da kısaca gösterilmekte ve kodların linkleri verilmektedir.

Bölüm 51: Rendering Sprites (Sprite Görselleştirme)

Bu bölümde 2B Sprite’ların render edilmesi için gerekli olan sınıfın yazımı anlatılmaktadır. Uygulamamızda kullanımı ile ilgili bir örnek verilip bölüm sonlandırılmaktadır.

Bölüm 52: Levels (Bölümler)

Bu bölümde Breakout oyunundaki bölümlerin nasıl tasarlanacağı ve bu bölümleri işleyecek olan sınıfların yazımı gösterilmekte ve ana uygulamaya eklenmektedir.

Bölüm 53: Ball (Top)

Bu bölümde oyunda yer alan top nesnesinin görsel ve mantıksal implementasyonu anlatılmaktadır.

Bölüm 54: Collision Detection (Çarpışma Algılama)

Bu bölümde fizik motorlarında sıklıkla karşımıza çıkan basit çarpışma algılama algoritmalarından kısaca bahsedilmektedir. AABB – AABB çarpışmaları ve AABB – Çember çarpışmaları teorik ve uygulama olarak anlatılmaktadır.

Bölüm 55: Collision Resolution (Çarpışma Çözümleme)

Bu bölümde fizik sistemlerinde çarpışma algılama algoritmalarından sonraki adım olan çarpışma çözümleme algoritmaları basit bir şekilde ele alınmaktadır. Nesnelerin birbirleri ile çarpışmasından sonra fiziksel olarak nasıl davranacağını belirleyen bu algoritmalardan AABB – Çember çarpışma çözümleme algoritması basit bir şekilde anlatılmakta ve uygulaması da gösterilmektedir. Bu şekilde Breakout oyunundaki topun fiziği implement edilmektedir.

Bölüm 56: Particles (Parçacıklar)

Bu bölümde oyunlarda sıklıkla karşımıza çıkan parçacık (particle) efekti kavramıdan bahsedilmekte ve bunu nasıl implement edebileceğimiz anlatılmaktadır. İlgili sınıflar yazıldıktan sonra Breakout oyununa bununla ilgili eklemeler yapılmaktadır.

Bölüm 57: Postprocessing (Rötuş)

Bu bölümde daha önce gördüğümüz Postprocessing efektlerini Breakout oyunundaki örnek uygulaması anlatılmakta ve ilgili sınıfların yazımı gösterilmektedir.

Bölüm 58: Powerups (Güçlendiriciler)

Bu bölümde Breakout oyununu oynarken oyuncunun alabileceği güçlendiriciler ve zayıflatıcıların görsel ve mantıksal olarak implementasyonları gösterilmektedir.

Bölüm 59: Audio (Ses)

Bu bölümde "irrKlang" isimli kütüphane ile oyuna nasıl müzik ve ses ekleyebileceğimiz basitçe gösterilmektedir.

Bölüm 60: Render Text (Yazı Görselleştirme)

Bu bölümde daha önce görüğümüz OpenGL ile ekrana yazı yazma olayının Breakout oyununa uygulanması gösterilmektedir.

Bölüm 61: Final Thoughts (Son Düşünceler)

Bu bölümde Breakout oyunu ile ilgili son düşüncelere yer verilmekte ve yapılabilecek optimizasyonlara değinilmektedir.

Değerlendirme

Kitabın hedef kitlesini grafik programlamaya başlamak isteyenler olarak gösterebiliriz. Ancak bu kitaptaki bilgiler sadece bu hedef kitle için değil, zaten OpenGL’i bir nebze de olsa bilen ve kendini geliştirmek isteyen kişiler için de yazılmıştır. Kitaptaki konular OpenGL bazlı olsa da genel olarak grafik programlama alanında kullanılan teknikleri teorik ve matematiksel olarak da ele almaktadır. Bu nedenle bu teknikleri DirectX gibi başka bir grafik API ile de uygulayabilirsiniz. Bu kitabın en önemli özelliği modern OpenGL ile ilgili en geniş bilgilerin bulunduğu kitap olmasıdır. OpenGL’e yönelik diğer kitaplara baktığımızda uygulamadan çok refereans kitap olma özelliği taşımaktadırlar.

Kitapta çok fazla parça bulunmakta ve konular iyi bir şekilde ayrılmaktadır. Her bir konu ile ilgili ayrı ayrı örnekler verilmeye çalışılmıştır. Önce belirli bir örneğin üzerine ekleme mantığı ile ilerlerken, daha sonra gelişmiş teknikleri anlatırken daha farklı örnekler gösterilmektedir. Ayrıca örneklerde kod yazmayı kolaylaştırmak amacıyla kamera işleri ve Shader ile ilgili işler ayrı sınıflara alınmış, bütün örneklerde de bu sınıflar kullanılmaya çalışılmıtır. Burada örnekler C++ dili ile yazılmış olsa da OpenGL’in durum (state) mekaniği, örneklerin biraz C dili ile yazılmış görüntüsü vermektedir. Ancak öğretme amacıyla yazılan örnekler için bu çok bir sorun teşkil etmemektedir. Bazı yerlerde ise kitapta yer alan kodlar biraz eski kalmış olabilir. Bunun için kitabın GitHub reposunu kontrol edebilirsiniz.

Kitapta hem teorik hem de görsel anlatım için kullanılan görseller oldukça fazladır. Bazı görseller düşük kalitede olsalar da hemen hemen hepsi yazarın anlatmak istediği şeyi okuyucuya aktarabilmektedir. Ayrıca örneklerin çıktılarının her biri ayrı ayrı görseller ile gösterilmektedir. Bu da yaptığımız işin sonucunu görmede veya kendi uyguladığımız örneklerdeki sonuçları karşılaştırmada oldukça etkili olmaktadır. Bu nedenle kitabın görsel/diyagram kullanımı yeterliliği oldukça başarılıdır diyebiliriz. Zaten grafik programlamayı anlatan bu tip kitapların görsel konusunda oldukça dikkatli olması gerekir. Piyasada bulunan diğer birçok kitapta bu eksikliği ne yazık ki gördüm.

Kitabın dili oldukça hafif ve anlaşılırdır. Ancak kitabın bazı yerlerinde teorik anlatım yaparken, çok fazla matematiğe ve fiziğe girilmemek istenmemesinden dolayı, bazen buradaki anlatımlar anlaşılmaz kalmaktadır. Ancak bunun için yazar kontrol edebileceğiniz ek web sitelerinin linklerini size vermektedir. Zaten kitabın ana amacının size matematik ve fizik öğretmek olmadığını, sadece ileride yapılan uygulamalar için konuların üzerinden geçmek istediğini varsayarsak, bunun bu şekilde olmasının pek bir problemi yoktur. Kitabın eşsizliğine gelecek olursak, bir bütün olarak ele aldığımızda piyasada modern OpenGL’i anlatan en geniş kitaptır diyebiliriz. Ancak genel olarak OpenGL ve grafik programlama ile ilgili en eşsiz kaynaktır demek diğer kaynaklara haksızlık olacaktır.

Sonuç olarak, bence bu kitap grafik programlamaya başlamak isteyen veya halihazırda grafik programalama ile uğraşanlar için oldukça önemli bir kaynaktır. Örnekleri ve görselleri oldukça yeterlidir. OpenGL ile grafik programlama yapmıyor olsanız bile bazı konularda referans olarak bakabileceğiniz bir kaynaktır. Okunabilirliği ve anlaşılabilirliği de oldukça iyidir. Ancak ben temel matematik ve fizik (genellikle ileri düzey ışıklandırma konularında) bilgilerinizin üzerinden bir geçmenizi tavsiye ediyorum. Kitabın içeriği kaliteli ve konuları zengindir. Hatta son parça tamamen öğrendiğiniz bilgiler ile Breakout oyununun modern halini yapmak üzerine kuruludur. Bu nedenle öğrendiklerinizi pekiştirmek için de idealdir.