OpenGL kütüphanesiyle 3D grafikler nasıl oluşturulur?

Adı : OpenGL kütüphanesiyle 3D grafikler nasıl oluşturulur?

OpenGL, günümüzde en yaygın kullanılan 3D grafik kütüphanelerinden biridir. Bu kütüphane, birçok platformda kullanılabilen donanım hızlandırmalı 3D grafikler oluşturma imkanı sağlar. Bu yazıda, OpenGL ile 3D grafikler nasıl oluşturulacağına yönelik detaylı bilgi ve örnekler sunacağım.
OpenGL, grafik işleme birimleri arasında bir arayüz sağlar. Bu nedenle kullanıcılara hareket edebilen, 3 boyutlu modelleme, simülasyon, gerçek zamanlı grafikler gibi birçok avantaj sağlar. Ancak, OpenGL birçok yönden oldukça karmaşık bir kütüphanedir ve öğrenmesi biraz zahmetli olabilir. Neyse ki, bu yazıda adım adım gideceğiz ve çeşitli örnekler ile kontrolü kolaylaştıracağız.
ONGL İLE PROJE YARATMA
Modern C++ işlerinde ve projelerinde yakından çalıştığımız için, bu yazıda OpenGL'yi kullanarak bir C++ projesi kullanacağız. Visual Studio 2019'un en son sürümünü kullanarak, boş bazda bir C++ projesi oluşturalım. Şimdi OpenGL'in kalitesini kontrol etmek için projemize benzersiz bir identifier adı ekleyelim. Taşları Dizmek oyunu kullanacağız. Örneğimizde, bir kare 9'lu bir tahta üzerine taşları yerleştirir. Bir oyuncu X, diğeri O – bu sık bir örnek olduğu için uygun.
Oyunu tasarlama
Oyun tahtamızı 3D olarak inşa edeceğiz. Bunun için birkaç basit 3D nesne (küp, silindir, küre) oluşturacağız ve bunları tahtamızda yerleştireceğiz. İlk olarak, tahta tasarımını oluşturmaya başlayalım. Bizim tasarımımız için 3D küpü kullanacağız. Küp yalnızca 6 yüzeye ihtiyaç duyar, böylece tahta için kullanışlıdır. Aşağıdaki kod bloğu, küpün nesnesini oluşturmanıza yardımcı olur.
```\nclass Cube {\npublic:\n Cube() { ... }\n void Draw() const { ... }\nprivate:\n ///\n};\n```
Burada öncelikle yapıcı fonksiyonu tanımlanmıştır. Bu fonksiyon, şeklin çizilmesi için gereken liste verilerini (stencil) oluşturur. Bununla beraber, birçok geometrik bilgiler, matrisler ve diğer veri tipini de ekleyebilirsiniz. Bu amaçla `glPolygonMode` fonksiyonu yüzeylere nasıl bakacağını belirleriz.
Bundan sonra, `Draw` fonksiyonu tanımlanır. Bu fonksiyon, `glDrawArrays` fonksiyonu kullanılarak şekil vertex'sını çizer. Sonunda, birkaç yardımcı private fonksiyonu ile küp, yalnızca 3D matrislerin oluşturulması, yüzey verisinin hazırlanması ve benzeri daha birçok işlem yapar.
Pencere Yönetimi
OpenGL projelerinde, pencereyi oluşturmak başlıca zorluklardan biridir. Şimdi pencereyi oluşturma işlemine başlayalım. Ekranı çizmek için bir `GLFWwindow` platformu oluşturacağız. Bu amaçla, `GLFW` kitaplığı kullanarak bir ana pencere yaratılacak.
Aşağıdaki kod bloğu bir `GLFW` pencere oluşturur ve bir `GLAD` benchmark ile beraber yükler.
```\n#include
int main() {\n glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);\n glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);\n glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);\n glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
GLFWmonitor* monitor = nullptr;\n GLFWwindow* window = glfwCreateWindow(800, 800, Create Cube Tutorial, monitor, nullptr);
if (window == nullptr) {\n glfwTerminate();\n throw std::runtime_error(Failed to create window);\n }
glfwMakeContextCurrent(window);\n glfwSwapInterval(1);
if (!gladLoadGL()) {\n glfwTerminate();\n throw std::runtime_error(Failed to initialize GLAD);\n }
…\n}\n```
Burada, `GLFW` pencere fonksiyonları özel bellek yönetimi kullanarak pencere ve disiplinleri yaratır. Bu nedenle, OpenGL (veya diğer grafik ortamları) erişiminden önce bir `glfwCreateWindow` teklifi olmalıdır. Bu fonksiyon, 2. ve 3. parametrelere pencere genişliği ve yüksekliğini alır. Dördüncü parametre, açılır pencere ebeveynini belirtir. Beşinci parametre, dikdörtgen bir görüş paneli oluşturan monitörün indexidir.
`glfwMakeContextCurrent` metodunun çağrılması, spesifik OpenGL uzantılarını kullanmak için mevcut bir OpenGL çalışma belleği (context) oluşturur. Bu metodun çağrılmasıyla bir `GLFWwindow` oluşturursunuz. `GLFW` fonksiyonlarını kullanarak yapabilirsiniz. `gladLoadGL` fonksiyonu, yüklenen OpenGL fonksiyonları kullanıcı tarafından kodlanabilir. Bu fonksiyon olmadan OpenGL fonksiyonlarını kullanmanın bir anlamı yoktur.
İşleme Döngüsü
Pencere oluşturma işi bittikten sonra, sıra şimdilik bir işleme döngüsü oluşturmaya geldi. Şimdi bir döngü oluşturalım ve pencere açıkken, ekranda çizmek için OpenGL kullanalım.
```\nwhile (!glfwWindowShouldClose(window)) {\n glClearColor(0.0f, 0.0f, 0.0f, 1.0f);\n glClear(GL_COLOR_BUFFER_BIT);\n // draw here\n glfwSwapBuffers(window);\n glfwPollEvents();\n}\n```
Bu kodumuzda, `glfwWindowShouldClose` fonksiyonu küçük bir döngüye kaparız. Döngü, pencerenin kapatılmasını kontrol eder. Bu fonksiyon, bir boolean değeri olarak döndürülür. Eğer pencere kapatmak için, x butonunun tıklanılması, kesinti verilmesi veya kapat butonunun tıklanması gerekiyorsa, bu fonksiyon false olacaktır. `glClearColor` fonksiyonu, arka plan rengini kendine özgü (R, G, B, A) değerleri kullanarak belirler. Sonra `glClear` fonksiyonu, çizim bufferlarını temizlemeye yardımcı olur. Bu, eklentinin direkt export edilmesini sağlar ve püskürtme için kullanışlı bir etkiye sahiptir. Aynısını `glClear` için de yapabilirsiniz.
ÇİZİM KODLARI OLUŞTURMAK
OpenGL'yi kullanarak bir tahta nasıl çizebileceğimize yakından bakalım. Basitçe, 9 küp oluşturup sırayla yerleştireceğiz.
```\nCube\nleft (-0.5, 0.0, 0.5);\ndownleft (0.0, 0.0, 0.5);\ndown (0.5, 0.0, 0.5);\ndownright (0.5, 0.0, 0.0);\nright (0.5, 0.0,-0.5);\nupright (0.0, 0.0,-0.5);\nup (-0.5, 0.0,-0.5);\nupleft (-0.5, 0.0, 0.0);\nmiddle (0.0, 0.0, 0.0);\n```
Bu noktalar, küplerimizin yerleştirilecekleri konumlar için görüntü olarak kullanılır. Bu yüzden, DirectX programlamamız için matematiksel kodlar kullanırız. `Cube` sınıfını az bir önceki gibi düzenleyelim:
```\nclass Cube {\npublic:\n Cube() { ... }\n void Draw() const { ... }\n const AABB& GetBoundingBox() const { return boundingBox; }\nprivate:\n AABB boundingBox;\n GLuint vertexBufferObject;\n GLuint indexBufferObject;\n GLuint vertexArrayObject;\n std::vector vertices;\n std::vector indices;\n};\n```
`AABB`, kapsülleyen kutuyu temsil eder. Bounding Box'da tutulan 3D hücrenin sınırları küplerimiz için önemlidir. `vertices` ve `indices` simgeleri, üçgenlerin konularını ve sayılarını içerir. `vertexBufferObject` ve `indexBufferObject`, `vertices` ve` indices` simgeleri tarafından kullanılan belleklerdir.
AABB sınıfımızı OpenGL için yukarıda tanımladığımız açıklayıcı bir şekilde oluşturduktan sonra, `Cube` sınıfımız için bir şekil vertex’ı oluşturalım. Şimdi böyle bir kod bloğuna sahip olmalıyız:
```\nvoid Cube::Create(const vec3f& min, const vec3f& max) {\n indices = { ... };\n vertices = { ... };
// create and bind the VAO\n glGenVertexArrays(1, &vertexArrayObject);\n glBindVertexArray(vertexArrayObject);
// create and bind the VBO\n glGenBuffers(1, &vertexBufferObject);\n glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);\n glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * vertices.size(), vertices.data(), GL_STATIC_DRAW);
// create and bind the IBO\n glGenBuffers(1, &indexBufferObject);\n glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferObject);\n glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(), indices.data(), GL_STATIC_DRAW);
// create the attributes of the VAO\n glEnableVertexAttribArray(0);\n glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(0 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);\n glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);\n glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));\n}\n```
OpenGL'da vertex array object'lerinden (VAO) ve vertex buffer object'lerinden (VBO) bahsetmemiz gerekiyor. VAO, Vertex Attrib Object'in kısaltmasıdır ve OpenGL'ın müthiş bir özelliğidir. Bunlar vertex buffer artışları ve vertex attrib array'lerinin birleştirilmesi gibi bilgileri içerir. VBO, yüksek performans sağlayan bellek kullanımını sağlayan OpenGL'un bir başka müthiş özelliğidir. Bize, sonsuz bir hafıza oluşturma ve performansta çizimler üretme olanağı sağlar. Cube sınıfımızdaki `Create` fonksiyonu, VAO'ları oluşturur ve topladığı geometri için bağlantı noktalarını özelleştirmemize olanak tanır.
Kamera hareketi eklemek
OpenGL'de kamera hareketi oluşturmak için bir projeksiyon-matrix'ine ihtiyacımız var. Kameranın özelliklerine ve perspektifine göre OpenGL kameranın matrisini hesaplar.
```\nclass Camera {\npublic:\n void Update(float deltaTime) { ... }\n void SetPerspectiveMatrix