OBJLoader.h

Go to the documentation of this file.

#ifndef ULT_OBJ_LOADER_H_INCLUDED
#define ULT_OBJ_LOADER_H_INCLUDED
 
#include <cstring>
#include <fstream>
#include <sstream>
#include <string>
 
#include "ModelData.h"
 
namespace Ult
{
 
struct stOBJMeshVertex
{
    float x, y, z;
    float tu1, tv1;
    float nx, ny, nz;
};
struct stObjModel
{
    float* vertices;
    float* normals;
    float* texCoords;
    int numFaces;
};

inline stObjModel* LoadOBJ(const char* fileName)
{
    std::ifstream fileInput(fileName);
    if (!fileInput || !fileInput.is_open()) {
        return nullptr;
    }
 
    std::string tmpLine, token;
    int totalVertices = 0, totalNormals = 0,
        totalTexC = 0, totalFaces = 0;
    
    while (std::getline(fileInput, tmpLine))
    {
        if (tmpLine.empty()) {
            continue;
        }
        
        std::stringstream ss(tmpLine);
        ss >> token;
        if (token == "v") { totalVertices++; }
        else if (token == "vn") { totalNormals++; }
        else if (token == "vt") { totalTexC++; }
        else if (token == "f") { totalFaces++; }
    }
    fileInput.clear();
    fileInput.seekg(0, fileInput.beg);
    
    float* verts = new float[totalVertices*3];
    float* norms = new float[totalNormals*3];
    float* texC = new float[totalTexC*2];
    int* faces = new int[totalFaces*9];
    int vIndex = 0, nIndex = 0, tIndex = 0, fIndex = 0, index = 0;
    
    while (std::getline(fileInput, tmpLine))
    {
        if (tmpLine.empty()) {
            continue;
        }
        
        std::stringstream ss(tmpLine);
        ss >> token;
        if (token == "v") {
            ss >> token;
            verts[vIndex++] = (float)std::atof(token.c_str());
            
            ss >> token;
            verts[vIndex++] = (float)std::atof(token.c_str());
            
            ss >> token;
            verts[vIndex++] = (float)std::atof(token.c_str());
        }
        
        else if (token == "vn") {
            ss >> token;
            norms[nIndex++] = (float)std::atof(token.c_str());
            
            ss >> token;
            norms[nIndex++] = (float)std::atof(token.c_str());
            
            ss >> token;
            norms[nIndex++] = (float)std::atof(token.c_str());
        }
        
        else if (token == "vt") {
            ss >> token;
            texC[tIndex++] = (float)std::atof(token.c_str());
            
            ss >> token;
            texC[tIndex++] = (float)std::atof(token.c_str());
        }
        
        else if (token == "f") {
            for (int i=0; i<3; i++) {
                ss >> token;
                int len = (int)token.size();
                for (int s=0; s<len+1; s++) {
                    char buff[64];
                    if (token[s] != '/' && s < len) {
                        buff[index++] = token[s];
                    } else {
                        buff[index] = '\0';
                        faces[fIndex++] = (int)atoi(buff);
                        index = 0;
                    }
                }
            }
        }
    }
    
    stObjModel* model = new stObjModel;
    if (!model) {
        return nullptr;
    }
    memset(model, 0, sizeof(stObjModel));
    
    model->numFaces = totalFaces;
    vIndex = 0, nIndex = 0, tIndex = 0, fIndex = 0, index = 0;
    
    model->vertices = new float[totalFaces * 3 * 3];
    if (totalNormals) { model->normals = new float[totalFaces * 3 * 3]; }
    if (totalTexC) { model->texCoords = new float[totalFaces * 3 * 2]; }
    
    for (int f=0; f<totalFaces*9; f+=3) {
        model->vertices[vIndex+0] = verts[(faces[f+0]-1)*3 + 0];
        model->vertices[vIndex+1] = verts[(faces[f+0]-1)*3 + 1];
        model->vertices[vIndex+2] = verts[(faces[f+0]-1)*3 + 2];
        vIndex += 3;
        
        if (model->texCoords) {
            model->texCoords[tIndex+0] = texC[(faces[f+1]-1)*2 + 0];
            model->texCoords[tIndex+1] = texC[(faces[f+1]-1)*2 + 1];
            tIndex += 2;
        }
        
        if (model->normals) {
            model->normals[nIndex + 0] = norms[(faces[f+2]-1)*3 + 0];
            model->normals[nIndex + 1] = norms[(faces[f+2]-1)*3 + 1];
            model->normals[nIndex + 2] = norms[(faces[f+2]-1)*3 + 2];
            nIndex += 3;
        }
    }
    
    delete[] verts;
    delete[] norms;
    delete[] texC;
    delete[] faces;
    
    return model;
}

inline bool CreateOBJMesh(const char* fileName, ModelData* model)
{
    if (!model) {
        return false;
    }
    
    stObjModel* loadedModel = LoadOBJ(fileName);
    if (!loadedModel) {
        return false;
    }
    
    int totalVertices = loadedModel->numFaces * 3;
    stOBJMeshVertex* objMesh = new stOBJMeshVertex[totalVertices];
    if (!objMesh) {
        return false;
    }
    
    int i = 0, v = 0, n = 0, t = 0;
    for (i=0; i<totalVertices; i++) {
        objMesh[i].x = loadedModel->vertices[v++];
        objMesh[i].y = loadedModel->vertices[v++];
        objMesh[i].z = loadedModel->vertices[v++];
        
        objMesh[i].nx = loadedModel->normals[n++];
        objMesh[i].ny = loadedModel->normals[n++];
        objMesh[i].nz = loadedModel->normals[n++];
        
        objMesh[i].tu1 = loadedModel->texCoords[t++];
        objMesh[i].tv1 = loadedModel->texCoords[t++];
    }
    
    model->Clear();
    model->AddDescriptorElement(ULT_VERTEX_3F);
    model->AddDescriptorElement(ULT_TEX1_2F);
    model->AddDescriptorElement(ULT_NORMAL_3F);
    if (!model->SetVertices(
            ULT_TRI_LIST,
            totalVertices,
            sizeof(stOBJMeshVertex),
            (char*)objMesh)) {
        return false;
    }
    model->SetIndices(0, nullptr);
    
    delete[] loadedModel;
    delete[] objMesh;
    
    return true;
}
 
} // namespace Ult
 
#endif // ULT_OBJ_LOADER_H_INCLUDED