src/OBJObject.cpp

Go to the documentation of this file.

#include <stdexcept>
#include <fstream>
#include <sstream>

#include "OBJObject.h"
#include "Triangle.h"
//#include "SimpleKDTree.h"
#include "SAHKDTree.h"
#include "defines.h"


struct FaceIdcs
{
    int v[4];
    int vn[4];
    int vt[4];

    FaceIdcs()
    {
        for (int i=0; i<4; i++)
            v[i] = vn[i] = vt[i] = 0;
    }

    FaceIdcs(std::istream & aStream)
    {
        for (int i=0; i<4; i++)
            v[i] = vn[i] = vt[i] = 0;

        char c;
        for(int i = 0; i < 3; i++)
        {
            aStream >> std::ws >> v[i] >> std::ws;
            if (aStream.peek() != '/')
                continue;
            aStream >> c >> std::ws;
            if (aStream.peek() == '/')
            {
                aStream >> c >> std::ws >> vn[i];
                continue;
            }
            else
                aStream >> vt[i];
            if (aStream.peek() != '/')
                continue;
            aStream >> c >> vn[i];
        }
    }
};


static Vec3f vec3fFromStream(std::istream & aStream)
{
    float x, y, z;
    aStream >> x >> std::ws >> y >> std::ws >> z;
    return Vec3f(x, y, z);
}


static TexCoordinate texCoordinateFromStream(std::istream & aStream)
{
    float x, y;
    aStream >> x >> std::ws >> y;
    return TexCoordinate(x, y);
}


/* ************************************************************************** */


OBJObject::OBJObject(const std::string & fileName)
    : Object(false),
        mPrimitives(NULL),
        mKdTree(NULL)
{
    LOG("Creating OBJ Object");
    mPrimitives = new std::vector<Primitive *>;
    read(fileName);
}


OBJObject::OBJObject(const OBJObject & other)
    : Object(other),
        mPrimitives(other.mPrimitives),
        mKdTree(other.mKdTree)
{
}


OBJObject::~OBJObject()
{
    if (*mRefCounter <= 1)
    {
        // cleanup primitives
        std::vector<Primitive *>::iterator it = mPrimitives->begin();
        for (; it != mPrimitives->end(); ++it)
            delete *it;
        delete mPrimitives;

        // delete tree
        delete mKdTree;
    }
}


void OBJObject::setShader(Shader * sh)
{
    std::vector<Primitive *>::iterator it = mPrimitives->begin();
    for (; it != mPrimitives->end(); ++it)
        (*it)->setShader(sh);
}


void OBJObject::setCastShadows(bool b)
{
    Object::setCastShadows(b);

    // set to each primitive
    std::vector<Primitive *>::iterator it = mPrimitives->begin();
    for (; it != mPrimitives->end(); ++it)
        (*it)->setCastShadows(b);
}


void OBJObject::read(const std::string & fileName, const PrimitiveFactory & factory)
{
    LOG("Parsing OBJFile : " << fileName);

    std::ifstream               ifile(fileName.c_str());
    std::vector<FaceIdcs>       faces;
    std::vector<Vec3f>          vert;
    std::vector<Vec3f>          norm;
    std::vector<TexCoordinate>  text;

    if (!ifile)
    {
        LOG("Could not open file");
        throw ObjectFileOpenException(fileName);
    }
    
    // while not end of file
    while (!ifile.eof())
    {
        // get line
        std::string curLine;
        std::getline(ifile, curLine);

        // read type of the line
        std::istringstream issLine(curLine);
        std::string lineType;
        issLine >> std::ws >> lineType;

        // based on the type parse data
        if (lineType == "v")
            vert.push_back(vec3fFromStream(issLine));
        else if (lineType == "vn")
            norm.push_back(vec3fFromStream(issLine).normal());
        else if (lineType == "vt")
            text.push_back(texCoordinateFromStream(issLine));
        else if (lineType == "f")
            faces.push_back(issLine);
        else if (lineType == "#" || lineType == "")
        {
            // comment / empty line
        }
        else if (lineType == "o")
        {
            std::string data;
            issLine >> std::ws >> data;
            LOG("Reading object \"" << data << "\"");
        }
        else if (lineType == "g")
        {
            std::string data;
            issLine >> std::ws >> data;
            LOG("Found type \"" << lineType << "\" : sub-object group \"" << data << "\" : NOT USED YET");
        }
        else if (lineType == "usemtl")
        {
            std::string data;
            issLine >> std::ws >> data;
            LOG("Found type \"" << lineType << "\" : use material \"" << data << "\" : NOT USED YET");
        }
        else if (lineType == "mtllib")
        {
            std::string data;
            issLine >> std::ws >> data;
            LOG("Found type \"" << lineType << "\" : material file \"" << data << "\" : NOT USED YET");
        }
        else
        {
            LOG("Found unknown line Type \"" << lineType << "\"");
        }
    }

    // iterate through all stored faces and create triangles
    for (std::vector<FaceIdcs>::iterator it = faces.begin(); it != faces.end(); ++it)
    {
        Vec3f           v[3];
        Vec3f           vn[3];
        TexCoordinate   vt[3];
        for (int i = 0; i < 3; i++)
        {
            v[i] = vert[it->v[i] - 1];
            if (it->vn[i] >= 1 && it->vn[i] <= static_cast<int>(norm.size()))
                vn[i] = norm[it->vn[i] - 1];
            else if (it->vn[i] == 0)
                vn[i] = Vec3f();
            else
            {
                LOG("FUCK normal: it->vn[" << i << "] = " << it->vn[i] << " , norm.size() = " << norm.size());
            }
            if (it->vt[i] >= 1 && it->vt[i] <= static_cast<int>(text.size()))
                vt[i] = text[it->vt[i] - 1];
            else if (it->vt[i] == 0)
                vt[i] = TexCoordinate();
            else
            {
                LOG("FUCK texture: it->vt[" << i << "] = " << it->vt[i] << " , text.size() = " << text.size());
            }
        }

        // create primitive by the factory
        mPrimitives->push_back(factory.create(  Triangle(v[0], v[1], v[2]),
                                                vn[0], vn[1], vn[2],
                                                vt[0], vt[1], vt[2] ));
    }

    buildAccelStructure();

    LOG("Number of Vertices:       " << (vert.size()) );
    LOG("Number of Triangles:      " << mPrimitives->size() );
    LOG("Number of Faces:          " << faces.size() );
    LOG("Number of Normals:        " << norm.size() );
    LOG("Number of TexCoordinates: " << text.size() );
    LOG("Finished Parsing");
}


void OBJObject::calcBounds()
{
    mBoundingBox.clear();

    std::vector<Primitive *>::const_iterator it = mPrimitives->begin();
    for (; it != mPrimitives->end(); ++it)
        mBoundingBox.extend((*it)->bounds());

    LOG("bb.min: " << mBoundingBox.minVertex() << " , bb.max: " << mBoundingBox.maxVertex());
}


void OBJObject::buildAccelStructure()
{
    // compute the bounding box
    calcBounds();

    // recreate the tree
    delete mKdTree;
//    mKdTree = new SimpleKDTree();
    mKdTree = new SAHKDTree();

    // build acceleration data structure
    mKdTree->buildTree(*mPrimitives, mBoundingBox);
}

---