MayaParser.cc

Go to the documentation of this file.

#include <esg/parser/MayaParser.h>
#include <esg/Shape.h>
#include <esg/Group.h>
#include <esg/spacesorting/BVH.h>

#include <assert.h>
#include <time.h>

using namespace esg;

void MayaParser::_set_material(const GLMmaterial& glmMat)
{
    Vector3  ambient(glmMat.ambient[0] * glmMat.ambient[3],
                     glmMat.ambient[1] * glmMat.ambient[3],
                     glmMat.ambient[2] * glmMat.ambient[3]);
    Vector3  diffuse(glmMat.diffuse[0] * glmMat.diffuse[3],
                     glmMat.diffuse[1] * glmMat.diffuse[3],
                     glmMat.diffuse[2] * glmMat.diffuse[3]);
    Vector3  specular(glmMat.specular[0] * glmMat.specular[3],
                      glmMat.specular[1] * glmMat.specular[3],
                      glmMat.specular[2] * glmMat.specular[3]);
    float shininess = glmMat.shininess; // in the range of [0,128] !

#ifndef WIN32
#warning "TODO: Shared material insted of privite"
#else
//#pragma warning "TODO: Shared material insted of privite"
#endif
    _pParsedObject->appendPrivateMaterial(new Specular(specular));
    _pParsedObject->appendPrivateMaterial(new Diffuse(diffuse));
    _pParsedObject->appendPrivateMaterial(new Ambient(ambient));
    _pParsedObject->appendPrivateMaterial(new Roughness((int)shininess));
}

bool MayaParser::_parse_triangle(Surface* pSurface, GLMtriangle* pGLMTri)
{
    pSurface->normal(Vector3(_pGLMModel->facetnorms[3 * pGLMTri->findex + 0],
                             _pGLMModel->facetnorms[3 * pGLMTri->findex + 1],
                             _pGLMModel->facetnorms[3 * pGLMTri->findex + 2]));

    // The reason of index decrementaion is explained in
    // attention comment in constructor's source code.
    if (!pSurface->vertex(pGLMTri->vindices[0]-1,
                          pGLMTri->nindices[0]-1,
                          pGLMTri->tindices[0]-1)) return false;
    if (!pSurface->vertex(pGLMTri->vindices[1]-1,
                          pGLMTri->nindices[1]-1,
                          pGLMTri->tindices[1]-1)) return false;
    if (!pSurface->vertex(pGLMTri->vindices[2]-1,
                          pGLMTri->nindices[2]-1,
                          pGLMTri->tindices[2]-1)) return false;

    if (_pStat) _pStat->primitives++; // increment counter

    return true;
}

void MayaParser::_init_model(bool unitize) const
{
    glmFacetNormals(_pGLMModel);
    glmVertexNormals(_pGLMModel, VERT_NORMAL_DEGREE_TRESHOLD);
    if (unitize) glmUnitize(_pGLMModel);
    if (!_pGLMModel->texcoords) glmSpheremapTexture(_pGLMModel);
    assert(_pGLMModel);
    assert(_pGLMModel->vertices);
}

MayaParser::MayaParser(const char*           path,
                       const SDS&            proto,
                       SceneGraphObject::OID firstOID,
                       Parser::Statistics*   pStat,
                       bool                  unitize,
                       bool                  fastMesh)
    : Parser(path, proto, firstOID, pStat)
{
    _pGLMModel = glmReadOBJ(path);
    _pGLMGroup = _pGLMModel->groups;
    _fastMesh  = fastMesh;

    if (_pGLMModel) _init_model(unitize);

    // set global arrays
    // ATTENTION: glm stores vertices and normals absolutely unreaseonably.
    //            It stores them in the range
    //            [3, 3*numvertices+1] and the first coordinates
    //            (that is index 0,1 and 2) are not used!!!
    //            Therefore such a strange indexing here.
    Vertex3* vertArray = new Vertex3 [_pGLMModel->numvertices];
    Vector3* normArray = new Vector3 [_pGLMModel->numnormals];
    Vector2* texArray  = new Vector2 [_pGLMModel->numtexcoords];
    for (unsigned i = 1; i <= _pGLMModel->numvertices; i++) {
        vertArray[i-1].x = _pGLMModel->vertices[3*i+0];
        vertArray[i-1].y = _pGLMModel->vertices[3*i+1];
        vertArray[i-1].z = _pGLMModel->vertices[3*i+2];
        //fprintf(stderr,"%i: %f %f %f\n",i,vertArray[i].x,vertArray[i].y,vertArray[i].z);
    }
    for (unsigned i = 1; i <= _pGLMModel->numnormals; i++) {
        normArray[i-1].x = _pGLMModel->normals[3*i+0];
        normArray[i-1].y = _pGLMModel->normals[3*i+1];
        normArray[i-1].z = _pGLMModel->normals[3*i+2];
    }
    for (unsigned i = 1; i <= _pGLMModel->numtexcoords; i++) {
        texArray[i-1].x = _pGLMModel->texcoords[2*i+0];
        texArray[i-1].y = _pGLMModel->texcoords[2*i+1];
    }
    _pAutoVertices  = new AutoArray<Vertex3>(vertArray);
    _pAutoNormals   = new AutoArray<Vector3>(normArray);
    _pAutoTexCoords = new AutoArray<Vector2>(texArray);
    _pAutoVertices->registerReferer(this);
    _pAutoNormals->registerReferer(this);
    _pAutoTexCoords->registerReferer(this);

    if (_pStat) {
        _pStat->vertices    = _pGLMModel->numvertices;
        _pStat->vertNormals = _pGLMModel->numnormals;
    }
}

MayaParser::~MayaParser()
{
    if (_pGLMModel) delete _pGLMModel;
    AutoArray<Vertex3>::destroy(_pAutoVertices, this);
    AutoArray<Vector3>::destroy(_pAutoNormals, this);
    AutoArray<Vector2>::destroy(_pAutoTexCoords, this);
}

bool MayaParser::parseObject(void)
{
    if (!_pGLMModel || !_pGLMGroup || !_pSSProto) {
        _pParsedObject = NULL;
        return false;
    }

    if (_pGLMGroup->numtriangles) {
        GLMtriangle* pGLMTri;

        if (_pGLMGroup->name)
            _pParsedObject = new Shape(_oid++, _pGLMGroup->name);
        else
            _pParsedObject = new Shape(_oid++, "Polygonal Surface");

        // set materials of _pParsedObject
        _set_material(_pGLMModel->materials[_pGLMGroup->material]);

        // set geometry
        Surface * pS = new Surface(*_pSSProto,
                                   _pAutoVertices,
                                   _pGLMModel->numvertices,
                                   _pAutoNormals,
                                   _pGLMModel->numnormals,
                                   _pAutoTexCoords,
                                   _pGLMModel->numtexcoords,
                                   Surface::TRIANGLES,
                                   new AutoPtr<Intersector>(new Intersector),
                                   _fastMesh);
        
        for (register unsigned i = 0; i < _pGLMGroup->numtriangles; i++) {
            // get actual triangle in group
            pGLMTri = &(_pGLMModel->triangles[_pGLMGroup->triangles[i]]);
            if (!_parse_triangle(pS, pGLMTri)) {
                fprintf(stderr,"MayaParser Error: Wrong data format\n");
                delete pS;
                return false;
            }
        }

        pS->done();
        _pParsedObject->setPrivateGeometry(pS);
        _pGLMGroup = _pGLMGroup->next;
        return true;
    } else {
        _pParsedObject = NULL;
        _pGLMGroup = _pGLMGroup->next;
        return false;
    }
}

---