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

#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;


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


void PlyConverter::LoadShape(const VertexArray &faceVertices,
                                                         const VertexArray &faceNormals,
                                                         const vector<Texcoord> &faceTexcoords
                                                         )
{
        int numElements = (int)faceVertices.size();
        Geometry *geom = new Geometry();
/*
        // convert the triangles to geometry
        geom->mVertices = new SimpleVec[numElements];
        geom->mNormals = new SimpleVec[numElements];
        geom->mTexcoords = new Texcoord[numElements];

        geom->mVertexCount = numElements;
        geom->mTexcoordCount = (int)faceTexcoords.size();

        cout << "creating new geometry with " << numElements << " vertices" << endl;

        for (int i = 0; i < numElements; ++ i)
        {
                geom->mVertices[i] = faceVertices[i]
                geom->mNormals[i] = faceNormals[i];

                /*if (i < geom->mTexcoordCount)
                {
                        geom->mTexcoords[i].first = faceTexcoords[i].first;
                        geom->mTexcoords[i].second = faceTexcoords[i].second;
                }
        }
*/
        mGeometry.push_back(geom);
}


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 int mainIndex = 0;
        static int i = 0;

        static SimpleVec v;

        v[i] = (float)ply_get_argument_value(argument);
        //printf("here3 %g", ply_get_argument_value(argument));
    
        if (eol) sVertices.push_back(v);
        i = (i + 1) % 3;
        //else printf(" ");
    
        return 1;
}


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

        switch (value_index) 
        {
        case 0:
        case 1: 
            printf("here4 %g ", ply_get_argument_value(argument));
            break;
        case 2:
            printf("here5 %g\n", ply_get_argument_value(argument));
            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);

    printf("%ld\n%ld\n", nvertices, ntriangles);

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

    return 0;
}



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

        for (int i = 0; i < 3; ++ i)
        {
                hvertices[i] = geom->mVertices[i];
                hnormals[i] = geom->mNormals[i];
        }

        int texCoordCount = 0;

        str.write(reinterpret_cast<char *>(hvertices), sizeof(SimpleVec) * vertexCount);
        str.write(reinterpret_cast<char *>(hnormals), sizeof(SimpleVec) * vertexCount);
        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;
        

        /////////
        //-- 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);
        }


        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;
}