source: GTP/trunk/App/Demos/Vis/FriendlyCulling/Converter/PlyConverter.cpp @ 3359

#include "PlyConverter.h"
#include "SimpleTri.h"
#include "SimpleVec.h"
#include "gzstream.h"
#include <iostream>
#include "rply.h"


using namespace std;

static int sGlobalIndex = 0;


VertexArray sVertices;
VertexArray sNormals;
FaceArray sFaces;



PlyConverter::~PlyConverter()
{
        for (size_t i = 0; i < mGeometry.size(); ++ i) delete mGeometry[i];
        mGeometry.clear();
}


void PlyConverter::LoadShape(const VertexArray &vertices,
                                                         const VertexArray &normals,
                                                         const TexcoordArray &texcoords,
                                                         const FaceArray &faces
                                                         )
{
        Geometry *geom = new Geometry();
        size_t idx = 0;

        for (size_t i = 0; i < faces.size(); ++ i)
        {
                if (i % 1000 == 0)
                        cout << "converted " << i << " lines" << endl;

                Face face = faces[i];

                //cout << "size: " << face.indices.size() << endl;
                for (size_t j = 0; j < face.indices.size(); ++ j)
                {
                        geom->mVertices.push_back(vertices[faces[i].indices[j]]);

                        /*if (!normals.empty())
                        {
                                for (int j = 0; j < 3; ++ j)
                                        faceNormals.push_back(Normalize(normals[nIndices[idx[j]]]));
                        }
                        else
                        {
                                // no face normals? => create normals
                                const SimpleTri tri(vertices[indices[idx[0]]],
                                                        vertices[indices[idx[1]]], 
                                                                        vertices[indices[idx[2]]]);

                                const SimpleVec n = tri.GetNormal();

                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                                faceNormals.push_back(n);
                        }*/
                }

                //cout << "idx: " << idx << " " << geom->mVertices.size() << endl;

                // no face normals? => create normals
                const SimpleTri tri(geom->mVertices[idx],
                                        geom->mVertices[idx + 1], 
                                                        geom->mVertices[idx + 2]);

                const SimpleVec n = tri.GetNormal();

                geom->mNormals.push_back(n);
                geom->mNormals.push_back(n);
                geom->mNormals.push_back(n);

                idx += faces[i].indices.size();
        }

        mGeometry.push_back(geom);
        mNumShapes = 1;
}


bool PlyConverter::Convert(const string &filename, 
                                                   const std::string &outputFilename)
{
        mNumShapes = 0;
        
        for (size_t i = 0; i < mGeometry.size(); ++ i) delete mGeometry[i];
        mGeometry.clear();

        if (!ReadFile(filename))
        {
                cerr << "could not read file" << endl;
                return false;
        }

        if (!WriteFile(outputFilename))
        {
                cerr << "could not write file" << endl;
                return false;
        }

        return true;
}


static int vertex_cb(p_ply_argument argument) 
{
    long eol;
    ply_get_argument_user_data(argument, NULL, &eol);

        static SimpleVec v;
        static int i = 0;

        v[i ++] = (float)ply_get_argument_value(argument);
        //printf("%g", ply_get_argument_value(argument));
    
        if (eol)
        {
                sVertices.push_back(v);
                if (sVertices.size() % 10000 == 0) cout << "read in " << sVertices.size() << " vertices" << endl;
                i = 0;
        }
    
        return 1;
}


static int face_cb(p_ply_argument argument) 
{
    long length, value_index;
    ply_get_argument_property(argument, NULL, &length, &value_index);

        static Face face;
        
        switch (value_index) 
        {
        case 0:
        case 1: 
            //printf("here4 %g ", ply_get_argument_value(argument));
                        face.indices.push_back((int)ply_get_argument_value(argument));
            break;
        case 2:
            //printf("here5 %g\n", ply_get_argument_value(argument));
                        face.indices.push_back((int)ply_get_argument_value(argument));
                        sFaces.push_back(face);
                        if (sFaces.size() % 10000 == 0) cout << "read in " << sFaces.size() << " faces" << endl;

                        face.indices.clear();
            break;
        default: 
            break;
    }


    return 1;
}



bool PlyConverter::ReadFile(const string &filename) 
{
        long nvertices, ntriangles;

        p_ply ply = ply_open(filename.c_str(), NULL);
    
        if (!ply) return 1;
    if (!ply_read_header(ply)) return 1;
    
        nvertices = ply_set_read_cb(ply, "vertex", "x", vertex_cb, NULL, 0);

    ply_set_read_cb(ply, "vertex", "y", vertex_cb, NULL, 0);
    ply_set_read_cb(ply, "vertex", "z", vertex_cb, NULL, 1);

        ntriangles = ply_set_read_cb(ply, "face", "vertex_indices", face_cb, NULL, 0);

        cout << "vertices: " << nvertices << endl;
        cout << "triangles: " << ntriangles << endl;

    if (!ply_read(ply)) return false;
    ply_close(ply);

        TexcoordArray texCoords;
        LoadShape(sVertices, sNormals, texCoords, sFaces);

    return true;
}



void PlyConverter::WriteGeometry(ogzstream &str, Geometry *geom)
{
        size_t vertexCount = (int)geom->mVertices.size();
        str.write(reinterpret_cast<char *>(&vertexCount), sizeof(int));

        cout << "writing geometry" << endl;

        //SimpleVec vertices = new SimpleVec[vertexCount];
        //for (size_t i = 0; i < vertexCount; ++ i) vertices[i] = geom->mVertices[i];
        //for (size_t i = 0; i < vertexCount; ++ i) vertices[i] = geom->mNormals[i];

        for (size_t i = 0; i < vertexCount; ++ i)
                str.write(reinterpret_cast<char *>(&geom->mVertices[i]), sizeof(SimpleVec));

        for (size_t i = 0; i < vertexCount; ++ i)
                str.write(reinterpret_cast<char *>(&geom->mNormals[i]), sizeof(SimpleVec));

        cout << "finished writing geometry" << endl;
        //if (texCoordCount) str.write(reinterpret_cast<char *>(geom->mTexcoords), sizeof(float) * texCoordCount * 2);

        int texCoordCount = 0;
        str.write(reinterpret_cast<char *>(&texCoordCount), sizeof(int));

        //if (texCoordCount) str.write(reinterpret_cast<char *>(geom->mTexcoords), sizeof(float) * texCoordCount * 2);
}


bool PlyConverter::WriteFile(const string &filename)
{
        ogzstream ofile(filename.c_str());
        if (!ofile.is_open()) return false;
        

        mNumShapes = (int)mGeometry.size();

        /////////
        //-- write textures

#ifdef USE_TEXTURE
        int textureCount = 1;
#else
        int textureCount = 0;
#endif
        ofile.write(reinterpret_cast<char *>(&textureCount), sizeof(int));

        if (textureCount > 0)
        {
                // hack
                const string texName("wood.jpg");

                int texnameSize = (int)texName.length() + 1;
                ofile.write(reinterpret_cast<char *>(&texnameSize), sizeof(int));

                ofile.write(texName.c_str(), sizeof(char) * texnameSize);

                int boundS = 1, boundT = 1;

                ofile.write(reinterpret_cast<char *>(&boundS), sizeof(int));
                ofile.write(reinterpret_cast<char *>(&boundT), sizeof(int));
        }


        ///////////
        //-- write shapes

        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int));

        vector<Geometry *>::const_iterator it, it_end = mGeometry.end();

        for (it = mGeometry.begin(); it != it_end; ++ it)
        {
                WriteGeometry(ofile, *it);


                ///////
                //-- texture

                int texId = 0;
                ofile.write(reinterpret_cast<char *>(&texId), sizeof(int));

                bool alphaTestEnabled = false;
                //bool cullFaceEnabled = false;
                bool cullFaceEnabled = true;

                ofile.write(reinterpret_cast<char *>(&alphaTestEnabled), sizeof(bool));
                ofile.write(reinterpret_cast<char *>(&cullFaceEnabled), sizeof(bool));

                // material
                bool hasMaterial = false;
                ofile.write(reinterpret_cast<char *>(&hasMaterial), sizeof(bool));
        }


        int entityCount = 1;
        ofile.write(reinterpret_cast<char *>(&entityCount), sizeof(int));


        //////////
        //-- write single scene entity

        // no transformation
        bool hasTrafo = false;
        ofile.write(reinterpret_cast<char *>(&hasTrafo), sizeof(bool));

        // a dummy lod
        int numLODs = 1;
        ofile.write(reinterpret_cast<char *>(&numLODs), sizeof(int));

        float dist = 0;
        ofile.write(reinterpret_cast<char *>(&dist), sizeof(float));
        ofile.write(reinterpret_cast<char *>(&mNumShapes), sizeof(int));
        

        // all shapes belong to this scene entity
        for (int i = 0; i < mNumShapes; ++ i)
        {
                int shapeId = i;
                ofile.write(reinterpret_cast<char *>(&shapeId), sizeof(int));
        }

        return true;
}