src/rcrt/loaders/ObjectLoader.cpp

Go to the documentation of this file.

#include "ObjectLoader.h"
#include "../objects/DynamicObject.h"
#include "../objects/AffineObject.h"
#include "../materials/DebugMaterial.h"

using namespace std;

namespace rcrt
{

ObjectLoader::ObjectLoader(string path, MaterialLoader* mats):
        XMLLoader(path),materials(mats),material("debug"),initialised(false)
{
}

ObjectLoader::~ObjectLoader()
{
        delete object;
}

void ObjectLoader::init()
{
        initialised = true;
        
        nextStartTag("object");
        name = parser.getAttributeValue("","name");
        string animT = parser.getAttributeValue("","type");
        if(animT == "static")
                aType = STATIC;
        else if (animT == "affine")
                aType = AFFINE;
        else if (animT == "dynamic")
                aType = DYNAMIC;
        else{
                cout << "[ObjectLoader]: Object " << name <<" does not have a valid(static|affine|other) type: " << animT << endl;
                throw exception();
        }
        
        initMaterials();
        
        //sould now be on first frame tag
        switch(aType){
        case STATIC: initAffine(); break;
        case AFFINE: initAffine(); break;
        default://other
                initDynamic();
        }
        
        if(material == "debug" || materials == 0)
                object->setMaterial(new DebugMaterial());
        else{
                Material* mat = materials->getMaterial(material);
                if(mat)
                        object->setMaterial(mat);
                else
                        throw runtime_error(
                                "[ObjectLoader]: Not a valid object file, material does not exist: "
                                        + material);
        }
                
}

void ObjectLoader::initMaterials()
{
        //Assume that we're on the <object> start tag
        //cout << "[ObjectLoader]: Reading materials" << endl;
        string tagName = parser.getName();
        if(tagName != "object"){
                cout << "[ObjectLoader]: Logic error somewhere in ObjectLoader," <<
                                " could not initialize materials: not on <object> tag" << endl;
                throw exception();
        }
        nextStartTag("");
        tagName = parser.getName();
        while(tagName == "mat"){//TODO support material list
                material = parser.getAttributeValue("","name");
                
                nextStartTag("");
                tagName = parser.getName();
        }
}

void ObjectLoader::updateMesh()
{
        //Assume that we're on a <frame> tag
        string tagName = parser.getName();
        if(tagName != "frame"){
                cout << "[ObjectLoader]: Either a logic error somewhere in ObjectLoader," <<
                                " or not a valid object file: could not parse mesh: " <<
                                "not on <frame> tag: " << tagName << endl;
                throw exception();
        }
        
        nextStartTag("mesh");
        string mType = parser.getAttributeValue("","type");
        if(mType == "sphere"){
                nextStartTag("sph");
                float radius = convertTo<float>(parser.getAttributeValue("","r"));
                Point3D loc(convertTo<float>(parser.getAttributeValue("","x")),
                                        convertTo<float>(parser.getAttributeValue("","y")),
                                        convertTo<float>(parser.getAttributeValue("","z")));
                primitives.push_back(new Sphere(loc, radius, object));
                nextStartTag("");//TODO animated spheres and stuff
        } else {        
                nextStartTag("verts");
                nextStartTag("v");
                tagName = parser.getName();
                unsigned int i = 0;
                while(tagName == "v"){
                        Point3D loc(convertTo<float>(parser.getAttributeValue("","x")),
                                        convertTo<float>(parser.getAttributeValue("","y")),
                                        convertTo<float>(parser.getAttributeValue("","z")));
                        if(i < vertices.size())//update vertex
                                vertices.at(i).setPos(loc);
                        else//new vertex
                                vertices.push_back(Vertex(loc));
                        nextStartTag("");
                        tagName = parser.getName();
                        if(tagName == "no"){
                                Vec3D vec(convertTo<float>(parser.getAttributeValue("","x")),
                                                convertTo<float>(parser.getAttributeValue("","y")),
                                                convertTo<float>(parser.getAttributeValue("","z")));
                                vertices.at(i).setNormal(vec);
                                nextStartTag("");
                                tagName = parser.getName();
                        }
                        if(tagName == "uv"){
                                Point2D uv(convertTo<float>(parser.getAttributeValue("","u")),
                                                convertTo<float>(parser.getAttributeValue("","v")));
                                vertices.at(i).setUV(uv);
                                nextStartTag("");
                                tagName = parser.getName();
                        }
                        i++;
                }
                if(tagName != "faces"){
                        cout << "[ObjectLoader]: Either a logic error somewhere in ObjectLoader," <<
                                        " or not a valid object file: could not parse mesh: " <<
                                        "no <faces> tag in frame: "<< currentFrame << endl;
                        throw exception();
                }
                nextStartTag("tri");
                tagName = parser.getName();
                i = 0;
                while(tagName == "tri" && !eof){
                        bool smooth = true;
                        int sm = convertTo<int>(parser.getAttributeValue("","s"));
                        if(sm == 0)
                                smooth = false;
                        
                        //cout << "[ObjectLoader]: Reading triangle" << endl;
                        int verts[3];
                        nextStartTag("");
                        tagName = parser.getName();
                        for(int vertex = 0; vertex < 3; vertex++){
                                if(tagName != "v"){
                                        cout << "[ObjectLoader]: Not a valid object file: could not parse mesh: " <<
                                                        "not enough <v> tags in a tri in frame: "<< currentFrame << endl;
                                        throw exception();
                                }
                                int index = convertTo<int>(parser.getAttributeValue("","i"));
                                if(i < tris.size())
                                        (*tris.at(i))[vertex] = &vertices.at(index);
                                else
                                        verts[vertex] = index;
                                
                                eof = !nextStartTag("");
                                if(!eof) tagName = parser.getName();
                                else break;
                                
                                if(tagName == "uv"){
                                        Point2D uv(convertTo<float>(parser.getAttributeValue("","u")),
                                                        convertTo<float>(parser.getAttributeValue("","v")));
                                        vertices.at(index).setUV(uv);
                                        
                                        eof = !nextStartTag("");
                                        if(!eof) tagName = parser.getName();
                                        else break;
                                        
                                }       
                        }
                        if(i >= tris.size()){
                                tris.push_back(new Triangle(&vertices.at(verts[0]),
                                                &vertices.at(verts[1]),
                                                &vertices.at(verts[2]),object,smooth));
                                primitives.push_back(tris.at(i));
                        }
                        i++;
                }
        }
        
        //set mesh of the object
        object->setPrimitives(&primitives);
}

void ObjectLoader::updateMatrix()
{
        //getting worldmatrix in case of STATIC/AFFINE objects
        string tagName = parser.getName();
        if(tagName != "worldmatrix"){
                throw runtime_error(
                                "[ObjectLoader]: Not a valid object file "+name+" : could not parse mesh: " +
                                ("no <worldmatrix> tag in line: " + toString(parser.getLineNumber()) +
                                                " current tag: " + tagName));
        }
        float matrix[4][4];
        nextStartTag("");
        tagName = parser.getName();
        for(int r = 0; r < 4; r++){
                if(tagName != "matrow"){
                        throw runtime_error(
                                        "[ObjectLoader]: Not a valid object file: could not parse mesh: " +
                                        ("not enough <matrow> tags in line: " + toString(parser.getLineNumber())));
                }
                nextStartTag("");
                tagName = parser.getName();
                for(int c = 0; c < 4; c++){
                        if(tagName != "entry"){
                                throw runtime_error(
                                        "[ObjectLoader]: Not a valid object file: could not parse mesh: " +
                                        ("not enough <entry> tags in line: " + toString(parser.getLineNumber())));
                        }
                        matrix[r][c] = convertTo<float>(parser.getAttributeValue("","val"));
                        
                        eof = !nextStartTag("");
                        if(!eof) tagName = parser.getName();
                        else break;
                }
        }
        Matrix4D m;
        m = matrix;
        object->setWorldMatrix(m);
}

void ObjectLoader::initAffine()
{
        object = new AffineObject(name);
        updateMesh();
        updateMatrix();
}

void ObjectLoader::initDynamic()
{
        object = new DynamicObject(name);
}

bool ObjectLoader::nextFrame()
{
        if(!initialised)
                init();
        
        int eventType = parser.getEventType();
        string tagName = parser.getName();
        if(eventType != XmlPullParser::START_TAG ||
                        tagName != "frame"){
                eof = !nextStartTag("frame");
        }
        if(!eof) {
                currentFrame = convertTo<int>(parser.getAttributeValue("","no"));
                updateMesh();
                return true;
        } else {
                return false;
        }
        
}

bool ObjectLoader::goToFrame(const int& n)
{
        if(!initialised)
                init();
        
        switch(aType){
        case STATIC: currentFrame = n; return true;
        default:        
                if(n < currentFrame)
                        return false;//TODO error handling?
                if(n == currentFrame){
                        return true;
                }
                string tagName = parser.getName();
                if(tagName == "frame")
                        currentFrame = convertTo<int>(parser.getAttributeValue("","no"));
                while(currentFrame < n && !eof){
                        eof = !nextStartTag("frame");
                        currentFrame = convertTo<int>(parser.getAttributeValue("","no"));
                }
                if(!eof) {
                        switch(aType){
                        case DYNAMIC: updateMesh(); break;
                        case AFFINE: nextStartTag("worldmatrix"); updateMatrix(); break;
                        case STATIC: return true;
                        }
                        return true;
                } else {
                        return false;
                }
        }
}

Object* ObjectLoader::getObject()
{
        return object;
}

vector<Triangle*>* ObjectLoader::getTriangles()
{
        return &tris;
}

}

---