Model Yükleme

Assimp ile çalışma ve gerçek yükleme kodunu yazma zamanı geldi. Bu bölümün amacı, bir modeli bütünüyle temsil eden yeni bir sınıf oluşturmaktır: birden fazla mesh içerebilen, muhtemelen birden fazla dokuya sahip bir model. Ahshap balkonu, kuleleri ve hatta bir havuzu olan bir ev, tek bir model olarak yüklenebilir. Modeli Assimp aracılığıyla yükleyecek ve bir önceki bölümde tanımladığımız Mesh nesnelerine çevireceğiz.

Lafı fazla uzatmadan, Model sınıfının yapısını sunuyoruz:

class Model 
{
    public:
        Model(char *path)
        {
            loadModel(path);
        }
        void Draw(Shader &shader);	
    private:
        // model verileri
        vector<Mesh> meshes;
        string directory;

        void loadModel(string path);
        void processNode(aiNode *node, const aiScene *scene);
        Mesh processMesh(aiMesh *mesh, const aiScene *scene);
        vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type, 
                                             string typeName);
};

Model sınıfı, Mesh nesnelerinden oluşan bir vector içerir ve constructor'ında bir dosya yolu alarak modeli anında yükler. Private fonksiyonların her biri Assimp'in içe aktarma sürecinin farklı bir aşamasını işler; kısa süre içinde bunları ele alacağız. Ayrıca dosya yolunun dizinini sakladığımıza dikkat edin; dokuları yüklerken buna ihtiyacımız olacak.

Draw fonksiyonu özel bir fonksiyon değildir; temelde her mesh üzerinde döngü kurarak ilgili Draw fonksiyonunu çağırır:

void Draw(Shader &shader)
{
    for(unsigned int i = 0; i < meshes.size(); i++)
        meshes[i].Draw(shader);
}  

---

OpenGL'e 3D Model İçe Aktarmak

Bir modeli içe aktarıp kendi yapımıza çevirmek için önce Assimp'in uygun başlıklarını eklememiz gerekiyor:

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

Constructor'ın doğrudan çağırdığı loadModel işlevi içinde, modeli Assimp'in scene nesnesi adı verilen bir yapıya yükleme için Assimp'i kullanıyoruz. Model yükleme serisinin ilk bölümünden hatırlayabileceğiniz gibi bu, Assimp veri arayüzünün kök nesnesidir. Scene nesnesine sahip olduğumuzda yüklenen modele ait tüm verilere erişebiliriz.

Assimp'in harika yanı, farklı dosya formatlarını yüklemenin tüm teknik ayrıntılarını güzel bir şekilde soyutlaması ve bunu tek bir satırla yapmasıdır:

Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); 

Assimp'in namespace'inden bir Importer nesnesi tanımlıyor, ardından ReadFile fonksiyonunu çağırıyoruz. Fonksiyon, ikinci argüman olarak bir dosya yolu ve birkaç post-processing seçeneği bekler. aiProcess_Triangulate ayarıyla modelin (tamamen) üçgenlerden oluşmadığı durumlarda Assimp'e önce tüm model ilkel şekillerini üçgene dönüştürmesini söylüyoruz. aiProcess_FlipUVs ise işleme sırasında y ekseninde doku koordinatlarını çeviriyor (Dokular bölümünden hatırlayabileceğiniz gibi OpenGL'deki görüntülerin büyük çoğunluğu y ekseninde tersine çevrilmiştir). Diğer bazı kullanışlı seçenekler:

• aiProcess_GenNormals: Model normal vektörler içermiyorsa her vertex için normal vektörler oluşturur.

• aiProcess_SplitLargeMeshes: Büyük mesh'leri daha küçük alt mesh'lere böler; rendering'inizde izin verilen maksimum vertex sayısı varsa ve yalnızca daha küçük mesh'leri işleyebiliyorsa kullanışlıdır.

• aiProcess_OptimizeMeshes: Optimizasyon için çizim çağrılarını azaltarak birkaç mesh'i daha büyük bir mesh'e birleştirmeye çalışır.

Assimp harika bir post-processing seçenekleri seti sunar ve tümünü burada bulabilirsiniz. Bir modeli Assimp aracılığıyla yüklemek (gördüğünüz gibi) şaşırtıcı derecede kolaydır. Zor kısım, döndürülen scene nesnesini kullanarak yüklenen verileri bir Mesh nesneleri dizisine çevirmektir.

Tam loadModel fonksiyonu şuradan listelenmiştir:

void loadModel(string path)
{
    Assimp::Importer import;
    const aiScene *scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);	
	
    if(!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) 
    {
        cout << "ERROR::ASSIMP::" << import.GetErrorString() << endl;
        return;
    }
    directory = path.substr(0, path.find_last_of('/'));

    processNode(scene->mRootNode, scene);
}  

Modeli yükledikten sonra scene'nin ve kök node'unun null olup olmadığını kontrol ediyoruz; ayrıca verilerin eksik olup olmadığını gösteren bir flag'i de kontrol ediyoruz. Bu hata koşullarından biri karşılanırsa importer'ın GetErrorString fonksiyonundan alınan hata mesajını yazdırıp çıkıyoruz. Bıyık hata yoksa dosya yolunun dizinini elde ediyoruz.

Hiçbir şey yanlış gitmezse sahnenin tüm node'larını işlemek istiyoruz. İlk node'u (kök node) özyinelemeli processNode fonksiyonuna geçiriyoruz. Her node muhtemelen bir dizi çocuk içerdiğinden, önce söz konusu node'u işlemek, sonra tüm node çocuklarını işlemek ve böyle devam etmek istiyoruz.

Assimp yapısından hatırlayabileceğiniz gibi her node, belirli bir mesh'e işaret eden bir dizi mesh indeksi içerir. Amacımız bu indeksleri alıp ilgili mesh'leri işlemek, ardından her node'un çocuk node'ları için aynı işlemi tekrarlamaktır. processNode işlevinin içeriği aşağıda gösterilmektedir:

void processNode(aiNode *node, const aiScene *scene)
{
    // node'un mesh'lerini işle (varsa)
    for(unsigned int i = 0; i < node->mNumMeshes; i++)
    {
        aiMesh *mesh = scene->mMeshes[node->mMeshes[i]]; 
        meshes.push_back(processMesh(mesh, scene));			
    }
    // ardından her çocuğu için aynısını yap
    for(unsigned int i = 0; i < node->mNumChildren; i++)
    {
        processNode(node->mChildren[i], scene);
    }
}  

Node'un mesh indekslerini tek tek kontrol ediyor ve sahnenin mMeshes dizisini indeksleyerek ilgili mesh'i alıyoruz. Döndürülen mesh, Mesh nesnesi üreten processMesh fonksiyonuna geçirilir; sonuç meshes vektörüne eklenir.

Tüm mesh'ler işlendikten sonra node'un çocuklarını yineliyoruz ve her biri için processNode özyinelemeli olarak çağrılır; hiç çocuğu kalmayan node'a ulaşıldığında özyineleme durur.

Dikkatli bir okuyucu, node'lardan herhangi birini işlemeyi unutup sahnenin tüm mesh'lerini doğrudan indeksler üzerindeki tüm bu karmaşık çalışma olmadan döngüye alabileceğimizi fark etmiş olabilir. Bunu yapma nedenimiz, bu şekilde node'ları kullanmanın başlangıç fikrinin mesh'ler arasında bir üst-alt ilişkisi tanımlamasıdır. Bu ilişkileri özyinelemeli olarak yineleyerek, belirli mesh'leri diğer mesh'lerin ebeveyni olarak tanımlayabiliriz.

Bu tür bir sistemin örnek kullanım durumu, bir araba mesh'ini ötelemek ve tüm çocuklarının (motor mesh, direksiyon mesh'i ve lastik mesh'leri gibi) birlikte ötelenmesini sağlamak istediğinizde ortaya çıkar; böyle bir sistem üst-alt ilişkileri kullanılarak kolaylıkla oluşturulabilir.

Şu an böyle bir sistem kullanmıyoruz; ancak mesh verileriniz üzerinde daha fazla kontrol istediğinizde genel olarak bu yaklaşımda kalmak önerilir. Bu node benzeri ilişkiler sonuçta modelleri oluşturan sanatçılar tarafından tanımlanır.

---

Assimp'ten Mesh'e

Bir aiMesh nesnesini kendi mesh nesnemize çevirmek çok zor değildir. Yapmamız gereken tek şey, mesh'in ilgili özelliklerinin her birine erişmek ve bunları kendi nesnemizde saklamaktır. processMesh fonksiyonunun genel yapısı şöyle olur:

Mesh processMesh(aiMesh *mesh, const aiScene *scene)
{
    vector<Vertex> vertices;
    vector<unsigned int> indices;
    vector<Texture> textures;

    for(unsigned int i = 0; i < mesh->mNumVertices; i++)
    {
        Vertex vertex;
        // vertex konumları, normal'lar ve doku koordinatlarını işle
        [...]
        vertices.push_back(vertex);
    }
    // indeksleri işle
    [...]
    // materyali işle
    if(mesh->mMaterialIndex >= 0)
    {
        [...]
    }

    return Mesh(vertices, indices, textures);
}  

Bir mesh'i işlemek 3 aşamalıdır: tüm vertex verilerini al, indeksleri al, ilgili materyal verilerini al. İşlenen veriler 3 vektörde saklanır; bunlardan bir Mesh oluşturulup çağrıcıya döndürülür.

Vertex verilerini almak oldukça basittir: Her döngü yinelemesinin ardından vertices dizisine eklediğimiz bir Vertex struct'ı tanımlıyoruz. Mesh (yani mesh->mNumVertices aracılığıyla alınan) içinde ne kadar vertex varsa o kadar döngü kuruyoruz. Yineleme içinde bu struct'ı tüm ilgili verilerle doldurmak istiyoruz. Vertex konumları için şöyle yapılır:

glm::vec3 vector; 
vector.x = mesh->mVertices[i].x;
vector.y = mesh->mVertices[i].y;
vector.z = mesh->mVertices[i].z; 
vertex.Position = vector;

Assimp'in verilerini geçici bir vec3'e aktardığımıza dikkat edin. Bu gereklidir çünkü Assimp, vektör, matris, string vb. için kendi veri türlerini korur ve glm'nin veri türlerine iyi dönüşüm yapmazlar.

Assimp, vertex konum dizisini mVertices olarak adlandırmaktadır — en sezgisel isim sayılmaz.

Normal'lerin düzeni tamamen aynıdır:

vector.x = mesh->mNormals[i].x;
vector.y = mesh->mNormals[i].y;
vector.z = mesh->mNormals[i].z;
vertex.Normal = vector;  

Doku koordinatları kabaca aynıdır; ancak Assimp, vertex başına 8 farklı doku koordinatına izin verir. 8'ini kullanmayacağız; yalnızca ilk doku koordinatları seti ile ilgileniyoruz. Ayrıca mesh'in gerçekten doku koordinatları içerip içermediğini kontrol etmek isteyeceğiz:

if(mesh->mTextureCoords[0]) // mesh doku koordinatları içeriyor mu?
{
    glm::vec2 vec;
    vec.x = mesh->mTextureCoords[0][i].x; 
    vec.y = mesh->mTextureCoords[0][i].y;
    vertex.TexCoords = vec;
}
else
    vertex.TexCoords = glm::vec2(0.0f, 0.0f);  

vertex struct'i gerekli attribute'larla doldu. Yineleme sonunda bunu vertices vektörüne ekliyoruz. Bu işlem mesh'in her vertex'i için tekrarlanır.

---

İndeksler

Assimp'in arayüzü, her mesh'i bir yüzler dizisi olarak tanımlar; her yüz bizim durumumuzda (yani aiProcess_Triangulate seçeneği nedeniyle) her zaman üçgen olan bir ilkeli temsil eder. Bir yüz, çizilmesi gereken vertex indekslerini hangi sırada içerir. Dolayısıyla tüm yüzleri yineleyip yüzün tüm indekslerini indices vektörüne saklarsak hazır oluruz:

for(unsigned int i = 0; i < mesh->mNumFaces; i++)
{
    aiFace face = mesh->mFaces[i];
    for(unsigned int j = 0; j < face.mNumIndices; j++)
        indices.push_back(face.mIndices[j]);
}  

Dış döngü bittikten sonra glDrawElements aracılığıyla mesh'ü çizmek için eksiksiz bir vertex ve indeks veri kümesine sahip oluruz. Tartışmayı tamamlamak için materyalü de işleyeceğiz.

---

Materyal

Node'lara benzer şekilde, bir mesh yalnızca bir materyal nesnesine indeks içerir. Bir mesh'in materyalini almak için scene'in mMaterials dizisini indekslemeliyiz. Mesh'in materyal indeksi, mMaterialIndex özelliğinde ayarlanmıştır:

if(mesh->mMaterialIndex >= 0)
{
    aiMaterial *material = scene->mMaterials[mesh->mMaterialIndex];
    vector<Texture> diffuseMaps = loadMaterialTextures(material, 
                                        aiTextureType_DIFFUSE, "texture_diffuse");
    textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
    vector<Texture> specularMaps = loadMaterialTextures(material, 
                                        aiTextureType_SPECULAR, "texture_specular");
    textures.insert(textures.end(), specularMaps.begin(), specularMaps.end());
}  

Scene'in mMaterials dizisinden aiMaterial nesnesini alıyoruz. Ardından mesh'in diffuse ve/veya specular dokularını yüklemek istiyoruz. loadMaterialTextures yardımcı fonksiyonu dokuları materyalden alır, yükler ve başlatır; Texture struct'larından oluşan bir vektör döndürür.

loadMaterialTextures fonksiyonu, verilen doku türünün tüm doku konumları üzerinde yineleme yapar, dokunun dosya konumunu alır, ardından dokuyu yükler ve oluşturur, bilgileri bir Vertex struct'ında saklar. Şuna benzer görünür:

vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type, string typeName)
{
    vector<Texture> textures;
    for(unsigned int i = 0; i < mat->GetTextureCount(type); i++)
    {
        aiString str;
        mat->GetTexture(type, i, &str);
        Texture texture;
        texture.id = TextureFromFile(str.C_Str(), directory);
        texture.type = typeName;
        texture.path = str;
        textures.push_back(texture);
    }
    return textures;
}  

GetTextureCount fonksiyonu aracılığıyla materyalde saklanan doku miktarını kontrol ediyoruz. GetTexture fonksiyonu aracılığıyla dokunun dosya konumlarının her birini alıyoruz; bu sonucu bir aiString'e saklar. Ardından, bizim için bir doku yükleyen (stb_image.h ile) ve dokunun ID'sini döndüren TextureFromFile helper fonksiyonunu kullanıyoruz.

Model dosyalarındaki doku dosyası yollarının modelin gerçek nesnesinin lokal yollarında olduğunu varsayıyoruz; yani modelin konumuyla aynı dizinde. Daha sonra (yani loadModel fonksiyonunda) aldığımız dizin dizesini doku konumu dizesiyle birleştirerek tam doku yolunu elde edebiliriz.

İnternette bulunan bazı modeller, dokularının yerleri için mutlak yollar kullanır ki bu her makinede çalışmaz. Bu durumda muhtemelen dosyayı manuel olarak düzenlemek ve dokular için yerel yollar kullanmak isteyeceksiniz (mümkünse).

---

Optimizasyon

Henüz tamamen bitmedi; yapmak istediğimiz büyük (ancak tamamen gerekli olmayan) bir optimizasyon var. Çoğu sahne, çeşitli mesh'lerde birkaç dokusunu yeniden kullanır. Birden fazla mesh üzerinde granit dokusu kullanan bir ev hayal edin. Bu doku zemine, tavanlara, merdivene, belki bir masaya ve belki de yakınlardaki küçük bir kuyuya da uygulanabilir. Dokuları yüklemek ucuz bir işlem değildir ve mevcut implementasyonumuzda tam olarak aynı doku daha önce birkaç kez yüklenmiş olsa bile her mesh için yeni bir doku yüklenir ve oluşturulur. Bu, model yükleme implementasyonunuzun darboğazı haline gelebilir.

Bu nedenle yüklenen tüm dokuları global olarak saklayıp model koduna küçük bir düzeltme yapıyoruz. Bir doku yüklemek istediğimizde önce daha önce yüklenip yüklenmediğini kontrol ederiz; yüklendiyse yükleme rutinini atlayarak işlem gücu tasarrufu sağlarız. Karşılaştırma yapabilmek için yollarını da saklamamiz gerekir:

struct Texture {
    unsigned int id;
    string type;
    string path;  // diğer dokularla karşılaştırma için doku yolunu saklıyoruz
};

Ardından yüklenen tüm dokuları model sınıf dosyasının başında private değişken olarak tanımlanan başka bir vektörde saklıyoruz:

vector<Texture> textures_loaded; 

loadMaterialTextures fonksiyonunda, doku yolunu mevcut doku yolunun textures_loaded vektöründeki tüm dokularla karşılaştırmak istiyoruz. Eşleşirse, bu doku yolunun daha önce yüklendiğini biliyoruz ve mesh'in dokusu olarak bulunan doku struct'ını kullanıp doku yükleme/oluşturma bölümünü atlıyoruz. Güncellenmiş fonksiyon şöyle gösterilir:

vector<Texture> loadMaterialTextures(aiMaterial *mat, aiTextureType type, string typeName)
{
    vector<Texture> textures;
    for(unsigned int i = 0; i < mat->GetTextureCount(type); i++)
    {
        aiString str;
        mat->GetTexture(type, i, &str);
        bool skip = false;
        for(unsigned int j = 0; j < textures_loaded.size(); j++)
        {
            if(std::strcmp(textures_loaded[j].path.data(), str.C_Str()) == 0)
            {
                textures.push_back(textures_loaded[j]);
                skip = true; 
                break;
            }
        }
        if(!skip)
        {   // doku daha önce yüklenmediyse yükle
            Texture texture;
            texture.id = TextureFromFile(str.C_Str(), directory);
            texture.type = typeName;
            texture.path = str.C_Str();
            textures.push_back(texture);
            textures_loaded.push_back(texture); // yüklenen dokular listesine ekle
        }
    }
    return textures;
}  

Assimp'in bazı sürümleri, IDE'nizin debug modunda ve/veya debug sürümünü kullanırken modelleri oldukça yavaş yükleyebilir. Yavaş yükleme süreleriyle karşılaşırsanız release sürümleriyle de test ettiğinizden emin olun.

Model sınıfının tam kaynak kodunu buradan bulabilirsiniz.

---

Artık Konteynerler Yok!

Haydi implementasyonumuzu gerçek bir sanatçı tarafından yaratılmış bir modeli içe aktararak deneyelim. Berk Gedik'in bu muhteşem Hayatta Kalma Gitar Sırt Çantasını yükleyeceğiz. Model, bir .obj dosyası olarak ve ilgili .mtl dosyasıyla birlikte dışa aktarılmıştır. Düzeltilmiş modeli buradan indirebilirsiniz. Tüm dokuların ve model dosyalarının aynı dizinde bulunması gerektiğini unutmayın.

Sırt çantasının değiştirilmiş versiyonu, yerel göreli doku yolları kullanır ve albedo ve metallic dokularını sırasıyla diffuse ve specular olarak yeniden adlandırdı.

Şimdi bir Model nesnesi tanımlayın ve model dosyasının konumunu iletin. Model otomatik yüklenecek ve hata yoksa render döngüsünde Draw fonksiyonuyla çizilecektir. Artık buffer tahsisi, attribute pointer veya draw command yok — yalnızca tek satır. Fragment shader yalnızca diffuse dokuyu çıkarıyorsa sonuç şuna benzer:

Model diffuse doku

Tam kaynak kodu buradan bulabilirsiniz. Modeli yüklemeden önce stb_image.h'ye dokuları dikey olarak çevirmesini söylediğinizden emin olun; aksi takdirde dokular çok karmaşık görünecektir.

Işıklandırma bölümlerinden öğrendiğimiz gibi render denklemine nokta ışıklar ekleyerek ve specular map'lerle birlikte harika sonuçlar elde edebiliriz:

Model ışıklandırma

Bunu şimdiye kadar kullandığımız konteyner sahnelerinden çok daha etkileyici bulmak gerekir. Assimp ile internette bulduğunuz pek çok modeli yükleyebilirsiniz; ancak bazı modeller hâlâ sorunlu olabilir: çalışmayan doku yolları ya da Assimp'in desteklemediği formatlar bu sorunların başında gelir.

---

İlave Okuma

• OpenGL için Wavefront (.obj) Modellerini Doku Eklemek: Matthew Early tarafından hazırlanmış harika bir video rehberi; Blender'da 3D modelleri mevcut model yükleyiciyle doğrudan çalışacak şekilde nasıl ayarlayacağınızı gösteriyor.

---

Orijinal kaynak: LearnOpenGL – Model-Loading/Model Türkçe çeviri: OpenGL Öğrenin projesi