source: OGRE/trunk/ogrenew/Tools/VRMLConverter/src/VRML2mesh.cpp @ 692

#include "stdafx.h"

struct vertex {
        int pos, tc, normal, colour;

        bool operator<(const vertex &v) const {
                if (pos < v.pos) return true;
                if (pos > v.pos) return false;
                if (normal < v.normal) return true;
                if (normal > v.normal) return false;
                if (tc < v.tc) return true;
                if (tc > v.tc) return false;
                return colour < v.colour;
        }
};

// VRML face
struct face {
        std::vector<int> indices;
};

// OGRE face
struct triangle {
        int vertices[3];
};

typedef std::vector<Vector3> Vec3Vec;
typedef std::vector<vertex> VertVec;
typedef std::vector<face> FaceVec;
typedef std::vector<triangle> TriVec;
typedef std::vector<int> IntVec;
typedef std::map<vertex, int> VertMap;

// traverse the scene graph looking for Shapes
void parseFile(Mesh *, const vrmllib::file &);
void parseNode(Mesh *, const vrmllib::node *, Matrix4 = Matrix4::IDENTITY);

// generate a SubMesh from a Shape
void parseShape(Mesh *, const Shape *, Matrix4);

        // helpers:
        Ogre::MaterialPtr parseMaterial(const Appearance *, const String &name);
        void parseFaces(FaceVec &, const IndexedFaceSet *);
        void triangulateAndExpand(TriVec &, VertVec &, const FaceVec &, const Shape *);
        void copyToSubMesh(SubMesh *, const TriVec &, const VertVec &, const Shape *, const Matrix4 &);

// get the array index for a VRML vertex property
int getIndex(const IntVec &coordIndex, const IntVec &, bool perVertex, int facenr, int vertnr);

// used by findName*
typedef std::map<const vrmllib::node *, String> NameMap;
NameMap gNameMap;

// find name of DEFined node
const String *findName(const vrmllib::node *n);
const String *findNameRecursive(const vrmllib::node *n);

String gBaseName; // base name of the input file (no path or extension)

// conversion functions:
inline Vector3 vec(const vrmllib::vec3 &v) { return Vector3(v.x, v.y, v.z); }
inline ColourValue col(const vrmllib::col3 &c) { return ColourValue(c.r, c.g, c.b); }
inline void copyVec(Real *d, const Vector3 &s) { d[0] = s.x; d[1] = s.y; d[2] = s.z; }
inline void copyVec(Real *d, const vec2 &s) { d[0] = s.x; d[1] = s.y; }

Matrix4 transMat(vrmllib::vec3, bool inverse = false);
Matrix4 scaleMat(vrmllib::vec3, bool inverse = false);
Matrix4 rotMat(vrmllib::rot, bool inverse = false);

int main(int argc, char **argv)
{
try
{
        String inname, outname, path;

        if (argc != 2 && argc != 3)
                throw
                        "Wrong number of arguments.\n"
                        "       Usage: VRML2mesh <input vrml file> [output mesh file]";

        inname = argv[1];

        // get base name
        gBaseName = inname;
        size_t p = gBaseName.find_last_of("/\\");
        if (p != gBaseName.npos) {
                path.assign(gBaseName, 0, p+1);
                gBaseName.erase(0, p+1);
        }
        p = gBaseName.rfind('.');
        if (p != gBaseName.npos)
                gBaseName.erase(p);

        if (argc == 3)
                outname = argv[2];
        else
                outname = path + gBaseName + ".mesh";

        LogManager log;
        log.createLog(path + "VRML2mesh.log");

        Math math;
    ResourceGroupManager resGrpMgr;
        MaterialManager materialMgr;
        MeshSerializer meshSer;

        Mesh mesh("conversionTarget");

        try {
                log.logMessage("Reading " + inname);

                // read VRML file
                std::ifstream infile(inname.c_str());
                if (!infile.is_open())
                        throw "failed to open input file";

                vrmllib::file vfile(infile);
                log.logMessage("Finished parsing VRML file");

                // populate name map
                for (vrmllib::file::defs_t::iterator i=vfile.defs.begin(), e=vfile.defs.end(); i!=e; ++i)
                        gNameMap[i->second] = i->first;

                // search from SubMeshes
                parseFile(&mesh, vfile);

                if (mesh.getNumSubMeshes() == 0)
                        throw "No SubMeshes were generated, aborting.";

                log.logMessage("Exporting Mesh");
                meshSer.exportMesh(&mesh, outname, true);

                log.logMessage("Done.");
        }
        catch (const char *e) {
                log.logMessage(LML_NORMAL, "Error: %s", e);
                return 1;
        }
        catch (std::exception &e) {
                log.logMessage(LML_NORMAL, "Exception: %s", e.what());
                return 1;
        }
        catch (Exception &e) {
                log.logMessage("Exception: " + e.getFullDescription());
                return 1;
        }
}
catch (Exception &e) {
        std::cerr << "Exception: " << e.getFullDescription() << std::endl;
        return 1;
}
catch (const char *e) {
        std::cerr << e << std::endl;
        return 1;
}
}

void parseFile(Mesh *mesh, const vrmllib::file &file)
{
        for (vrmllib::file::roots_t::const_iterator i=file.roots.begin(), e=file.roots.end(); i!=e; ++i)
                parseNode(mesh, *i);
}

void parseNode(Mesh *mesh, const vrmllib::node *n, Matrix4 m)
{
        if (const Transform *tr = dynamic_cast<const Transform *>(n)) {
                // TODO: handle center, scaleOrientation

                Matrix4 trans;
                trans.makeTrans(vec(tr->translation));

                Matrix4 scale = Matrix4::IDENTITY;
                scale[0][0] = tr->scale.x;
                scale[1][1] = tr->scale.y;
                scale[2][2] = tr->scale.z;

                Matrix3 rot3;
                rot3.FromAxisAngle(vec(tr->rotation.vector), tr->rotation.radians);
                Matrix4 rot = Matrix4::IDENTITY;
                rot = rot3;

                m = m * transMat(tr->translation) * transMat(tr->center)
                        * rotMat(tr->rotation) * rotMat(tr->scaleOrientation) * scaleMat(tr->scale)
                        * rotMat(tr->scaleOrientation, true) * transMat(tr->center, true);
        }

        if (const grouping_node *gn = dynamic_cast<const grouping_node *>(n)) {
                for (std::vector<vrmllib::node *>::const_iterator
                        i=gn->children.begin(), e=gn->children.end(); i!=e; ++i)
                                parseNode(mesh, *i, m);

        } else if (const Shape *sh = dynamic_cast<const Shape *>(n))
                parseShape(mesh, sh, m);
}

void parseShape(Mesh *mesh, const Shape *sh, Matrix4 mat)
{
try
{
        LogManager &log = LogManager::getSingleton();
        log.logMessage("Found a Shape...");

        IndexedFaceSet *ifs = dynamic_cast<IndexedFaceSet *>(sh->geometry);
        if (!ifs)
                throw "Geometry was not an IndexedFaceSet, keep looking";

        Coordinate *coord = dynamic_cast<Coordinate *>(ifs->coord);
        if (!coord)
                throw "Invalid Coordinate node";
        if (coord->point.empty())
                throw "No coordinates found, ignoring this Shape";

        SubMesh *sub;
        if (const String *name = findNameRecursive(sh)) {
                log.logMessage("Creating SubMesh: " + *name);
                sub = mesh->createSubMesh(*name);
        } else {
                log.logMessage("Creating unnamed SubMesh");
                sub = mesh->createSubMesh();
        }

        Appearance *app = dynamic_cast<Appearance *>(sh->appearance);
        TextureCoordinate *tcs = dynamic_cast<TextureCoordinate *>(ifs->texCoord);
        Normal *norm = dynamic_cast<Normal *>(ifs->normal);
        Color *color = dynamic_cast<Color *>(ifs->color);

        String message = "Found: geometry";
        if (tcs)
                message += ", texcoords";
        if (norm)
                message += ", normals";
        if (color)
                message += ", colours";
        log.logMessage(message);

        if (!tcs && !norm && !color)
                log.logMessage("Warning: OGRE will refuse to render SubMeshes that have neither\n"
                        "\ttexture coordinates, normals or vertex colours.");

        if (!norm) {
                log.logMessage("Warning: No normals found.\n"
                        "\tVRML dictates that normals should be generated, but this program\n"
                        "\tdoes not do so. If you want the resulting mesh to contain normals,\n"
                        "\tmake sure they are exported.");
        }

        // process material
        static std::map<Appearance *, Ogre::MaterialPtr> matMap;

        Ogre::MaterialPtr material = matMap[app];
        if (!material->isNull() && app) {
                log.logMessage("Using material " + material->getName());
                sub->setMaterialName(material->getName());
        } else {
                String matName;
                const String *mn;
                if (mn = findName(app))
                        matName = *mn;
                else if (app && (mn = findName(app->material))) {
                        static std::map<String, int> postfix;
                        std::stringstream ss;
                        int &num = postfix[*mn];
                        ss << *mn << '/' << num++;
                        matName = ss.str();
                } else {
                        static int matNum;
                        std::stringstream ss;
                        ss << gBaseName << '/' << matNum++;
                        matName = ss.str();
                        log.logMessage("No material name found, using " + matName);
                }
                log.logMessage("Reading material " + matName);

                material = parseMaterial(app, matName);

                sub->setMaterialName(matName);
        }

        FaceVec faces;
        parseFaces(faces, ifs);

        VertVec vertices;
        TriVec triangles;

        log.logMessage("Processing geometry...");
        triangulateAndExpand(triangles, vertices, faces, sh);

        copyToSubMesh(sub, triangles, vertices, sh, mat);

        log.logMessage("Done with this SubMesh.");
}
catch (const char *e) {
        LogManager::getSingleton().logMessage(e);
}
}

void copyToSubMesh(SubMesh *sub, const TriVec &triangles, const VertVec &vertices,
        const Shape *sh, const Matrix4 &mat)
{
        IndexedFaceSet *ifs = dynamic_cast<IndexedFaceSet *>(sh->geometry);
        Coordinate *coord = dynamic_cast<Coordinate *>(ifs->coord);
        TextureCoordinate *tcs = dynamic_cast<TextureCoordinate *>(ifs->texCoord);
        Normal *norm = dynamic_cast<Normal *>(ifs->normal);
        Color *color = dynamic_cast<Color *>(ifs->color);

        int nvertices = vertices.size();
        int nfaces = triangles.size();

        GeometryData &geom = sub->geometry;
        sub->useSharedVertices = false;
        sub->numFaces = nfaces;
        sub->faceVertexIndices = new unsigned short[nfaces*3];

        geom.hasColours = color;
        geom.hasNormals = norm;
        geom.numTexCoords = tcs ? 1 : 0;
        geom.numTexCoordDimensions[0] = 2;
        geom.numVertices = nvertices;

        geom.pVertices = new Real[nvertices*3];
        if (tcs)
                geom.pTexCoords[0] = new Real[nvertices*2];
        if (norm)
                geom.pNormals = new Real[nvertices*3];
        if (color)
                geom.pColours = new unsigned long[nvertices];

        Matrix3 normMat;
        mat.extract3x3Matrix(normMat);
        normMat = normMat.Inverse().Transpose();

        // populate face list
        for (int i=0; i!=nfaces; ++i) {
                unsigned short *f = sub->faceVertexIndices + i*3;
                f[0] = triangles[i].vertices[0];
                f[1] = triangles[i].vertices[1];
                f[2] = triangles[i].vertices[2];
        }

        // populate vertex arrays
        for (int i=0; i!=nvertices; ++i) {
                const vertex &v = vertices[i];

                Real *pos = geom.pVertices + i*3;
                Real *tc = geom.pTexCoords[0] + i*2;
                Real *n = geom.pNormals + i*3;
                unsigned long *col = geom.pColours + i;

                copyVec(pos, mat * vec(coord->point[v.pos]));
                if (norm) {
                        Vector3 t = normMat * vec(norm->vector[v.normal]);
                        t.normalise();
                        copyVec(n, t);
                }
                if (tcs)
                        copyVec(tc, tcs->point[v.tc]);
                if (color) {
                        col3 c = color->color[v.colour];
                        ColourValue cv(c.r, c.g, c.b);
                        *col = cv.getAsLongRGBA();
                }
        }
}

void triangulateAndExpand(TriVec &triangles, VertVec &vertices, const FaceVec &faces, const Shape *sh)
{
        IndexedFaceSet *ifs = dynamic_cast<IndexedFaceSet *>(sh->geometry);
        Coordinate *coord = dynamic_cast<Coordinate *>(ifs->coord);
        TextureCoordinate *tcs = dynamic_cast<TextureCoordinate *>(ifs->texCoord);
        Normal *norm = dynamic_cast<Normal *>(ifs->normal);
        Color *color = dynamic_cast<Color *>(ifs->color);

        VertMap vertexMap;

        // triangulate and expand vertices
        for (FaceVec::const_iterator f=faces.begin(), e=faces.end(); f!=e; ++f) {
                int faceNr = f - faces.begin();
                int triVertNr = 0;
                int triVerts[2] = { -1, -1 };
                for (IntVec::const_iterator i = f->indices.begin(), e=f->indices.end(); i!=e; ++i, ++triVertNr) {
                        int triVertNr = i - f->indices.begin();
                        int index = *i;

                        vertex vert;

                        // get full indices for vertex data
                        vert.pos = ifs->coordIndex[index];
                        vert.normal = norm ? getIndex(ifs->coordIndex, ifs->normalIndex,
                                ifs->normalPerVertex, faceNr, index) : 0;
                        vert.colour = color ? getIndex(ifs->coordIndex, ifs->colorIndex,
                                ifs->colorPerVertex, faceNr, index) : 0;
                        vert.tc = tcs ? getIndex(ifs->coordIndex, ifs->texCoordIndex,
                                true, faceNr, index) : 0;

                        // avoid duplication
                        int nvert = vertexMap.size();
                        int &vpos = vertexMap[vert];
                        if (nvert != vertexMap.size()) {
                                vpos = vertices.size();
                                vertices.push_back(vert);
                        }

                        // emit triangle (maybe)
                        if (triVertNr == 0)
                                triVerts[0] = vpos;
                        else if (triVertNr == 1)
                                triVerts[1] = vpos;
                        else {
                                triangle t;
                                t.vertices[0] = triVerts[0];
                                t.vertices[1] = triVerts[1];
                                t.vertices[2] = vpos;

                                if (!ifs->ccw)
                                        std::swap(t.vertices[1], t.vertices[2]);

                                triangles.push_back(t);

                                triVerts[1] = vpos;
                        }
                }
        }
}

int getIndex(const IntVec &coordIndex, const IntVec &vec, bool perVertex, int facenr, int index)
{
        if (!perVertex) {
                if (!vec.empty())
                        return vec[facenr];
                else
                        return facenr;
        } else {
                if (!vec.empty())
                        return vec[index];
                else
                        return coordIndex[index];
        }
}

const String *findName(const vrmllib::node *n)
{
        NameMap::const_iterator i = gNameMap.find(n);
        if (i == gNameMap.end())
                return 0;
        else
                return &i->second;
}

const String *findNameRecursive(const vrmllib::node *n)
{
        if (const String *name = findName(n))
                return name;
        else if (n->parent)
                return findNameRecursive(n->parent);
        else
                return 0;
}

void parseFaces(FaceVec &faces, const IndexedFaceSet *ifs)
{
        face f;
        for (IntVec::const_iterator i=ifs->coordIndex.begin(), e=ifs->coordIndex.end(); i!=e; ++i) {
                if (*i == -1) {
                        faces.resize(faces.size()+1);
                        faces.back().indices.swap(f.indices);
                } else
                        f.indices.push_back(i - ifs->coordIndex.begin());
        }
        if (!f.indices.empty()) {
                faces.resize(faces.size()+1);
                faces.back().indices.swap(f.indices);
        }
}

Ogre::MaterialPtr parseMaterial(const Appearance *app, const String &name)
{
        vrmllib::Material *vm = app ? dynamic_cast<vrmllib::Material *>(app->material) : 0;
        vrmllib::ImageTexture *texture = app ? dynamic_cast<vrmllib::ImageTexture *>(app->texture) : 0;

        Ogre::MaterialPtr m = MaterialManager::getSingleton().create(name, 
        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

        ColourValue diffuse = texture ? ColourValue::White : col(vm->diffuseColor);
                // diffuse colour is unused by VRML when a texture is avaliable,
                // set to white to give the same effect in OGRE

        ColourValue a = diffuse;
        a.r *= vm->ambientIntensity;
        a.g *= vm->ambientIntensity;
        a.b *= vm->ambientIntensity;
        m->setAmbient(a);
        m->setDiffuse(diffuse);
        m->setSelfIllumination(col(vm->emissiveColor));
        m->setShininess(vm->shininess);
        m->setSpecular(col(vm->specularColor));

        m->setLightingEnabled(app);

        if (texture && !texture->url.empty()) {
                String texName = texture->url.front();
                size_t p = texName.find_last_of("/\\");
                if (p != texName.npos) {
                        LogManager::getSingleton().logMessage("Stripping path from texture " + texName);
                        texName.erase(0, p+1);
                }

                LogManager::getSingleton().logMessage("Adding texture layer for " + texName);

                Ogre::TextureUnitState *l = m->addTextureLayer(texName);
                l->setTextureAddressingMode(texture->repeatS ?
                        Ogre::TextureUnitState::TAM_WRAP : Ogre::TextureUnitState::TAM_CLAMP);
        }

        return m;
}

Matrix4 transMat(vrmllib::vec3 v, bool inverse)
{
        if (inverse)
                return Matrix4::getTrans(-v.x, -v.y, -v.z);
        else
                return Matrix4::getTrans(v.x, v.y, v.z);
}

Matrix4 scaleMat(vrmllib::vec3 v, bool inverse)
{
        if (inverse)
                return Matrix4::getScale(1/v.x, 1/v.y, 1/v.z);
        else
                return Matrix4::getScale(v.x, v.y, v.z);
}

Matrix4 rotMat(vrmllib::rot r, bool inverse)
{
        Matrix3 rot3;
        rot3.FromAxisAngle(vec(r.vector), inverse ? -r.radians : r.radians);
        Matrix4 rot = Matrix4::IDENTITY;
        rot = rot3;
        return rot;
}