source: GTP/trunk/App/Demos/Vis/CHC_revisited/BinaryLoader.cpp @ 2747

#include "BinaryLoader.h"
#include "yare.h"
#include "yamath.h"
#include "gzstream.h"
#include "ImageComponent.h"
#include "RenderState.h"
#include "GeometryProcessor.h"


using namespace std;

static STL_MAP<String,Texture *> stlm_textures;


// clear the texture table (called on new file load)
static void clear_textures()
{
        STL_MAP<String,Texture *>::iterator it, it_end = stlm_textures.end();

        for (it = stlm_textures.begin(); it != it_end; ++ it)
        {
                it->second->unref();
                delete [] it->first;

                it ++;
        }

        stlm_textures.clear();
}


static Texture *get_texture(const char *filename, TextureAttributes *&myTextureAttributes)
{
        Texture * myTexture = NULL;

        myTextureAttributes = new TextureAttributes;
        myTextureAttributes->setTextureMode(TextureAttributes::DECAL);

        // Michi: avoid multiple loading of same texture!
        if (stlm_textures.find(filename) != stlm_textures.end())
        {
                myTexture = stlm_textures[filename];
        }
        else
        {
                ImageComponent *image = new ImageComponent(filename);
                //Texture *myTexture = new Texture(Texture::BASE_LEVEL, Texture::RGB, image->getWidth(), image->getHeight());
                myTexture = new Texture(Texture::MULTI_LEVEL_MIPMAP, ImageComponent::FORMAT_RGBP, image->getWidth(), image->getHeight());
                myTexture->setImage(0, image);
                
                myTexture->setMagFilter(Texture::BASE_LEVEL_LINEAR);
                myTexture->setMinFilter(Texture::MULTI_LEVEL_LINEAR_POINT);

                myTexture->setBoundaryModeS(Texture::WRAP);
                myTexture->setBoundaryModeT(Texture::WRAP);
                
                stlm_textures[filename] = myTexture;
                /// HACK!!! (texture not deleted on reload!)
                myTexture->ref();
        }

        return myTexture;
}


Shape3D *BinaryLoader::LoadShape(igzstream &str)
{       
        Geometry *geom = LoadGeometry(str);
        Appearance *app = LoadAppearance(str);

        Shape3D *shape = new Shape3D(geom, app);

        return shape;
}


Appearance *BinaryLoader::LoadAppearance(igzstream &str)
{
        Appearance *app = new Appearance();
        
        // texture
        int texnameSize;

        str.read(reinterpret_cast<char *>(&texnameSize), sizeof(int));

        if (texnameSize)
        {
                TextureAttributes *texAttr;
                char *texname = new char[texnameSize];
                str.read(texname, sizeof(char) * texnameSize);

                Texture *tex = get_texture(texname, texAttr);
                app->setTexture(tex);
                app->setTextureAttributes(texAttr);
        }

        // material
        char hasMaterial;
        str.read(&hasMaterial, sizeof(char));
        
        if (hasMaterial)
        {
                Color3f amb(0.0f, 0.0f, 0.0f);
                Color3f dif(0.5f, 0.5f, 0.5f);
                Color3f spec(0.0f, 0.0f, 0.0f);
                Color3f emi(0.0f, 0.0f, 0.0f);

                float shine = 0;

                //str.read(reinterpret_cast<char *>(&amb), sizeof(Color3f));
                str.read(reinterpret_cast<char *>(&dif), sizeof(Color3f));
                //str.read(reinterpret_cast<char *>(&emi), sizeof(Color3f));
                //str.read(reinterpret_cast<char *>(&spec), sizeof(Color3f));
                //str.read(reinterpret_cast<char *>(&shine), sizeof(float));
#if 1
                Material *mat = new Material();

                mat->setAmbientColor(amb);
                mat->setDiffuseColor(dif);
                mat->setEmissiveColor(emi);
                mat->setSpecularColor(spec);
                mat->setShininess(shine);

                app->setMaterial(mat);
#endif
        }

        return app;
}


Geometry *BinaryLoader::LoadGeometry(igzstream &str)
{
        int vertexCount;
        int stripCount;

        Point3f *vertices;
        Vector3f *normals = NULL;
        Point2f *texCoords = NULL;

        int *stripIndexCounts;
        int *indices;
        int *normalIndices;

        // todo
        int colorCount = 0;
        int normalCount = 0;
        int texCount = 0;

        int format;

        // read in format
        str.read(reinterpret_cast<char *>(&format), sizeof(int));
        
        format = IndexedTriangleStripArray::COORDINATES 
                | IndexedTriangleStripArray::NORMALS
                ;

        //OUT1("new format: " << format);

        // end of file reached
        if (str.eof())
                return NULL;


        //////////////
        // read in vertices
        
        str.read(reinterpret_cast<char *>(&vertexCount), sizeof(int));
        
        vertices = new Point3f[vertexCount];
    str.read(reinterpret_cast<char *>(vertices), sizeof(Point3f) * vertexCount);


        /////////////////
        // read in strip counters
        
        str.read(reinterpret_cast<char *>(&stripCount), sizeof(int));

        stripIndexCounts = new int[stripCount];
    str.read(reinterpret_cast<char *>(stripIndexCounts), sizeof(int) * stripCount);


        //////////
        // read in indices

        int indexCount;
        str.read(reinterpret_cast<char *>(&indexCount), sizeof(int));
        indices = new int[indexCount];
    str.read(reinterpret_cast<char *>(indices), sizeof(int) * indexCount);


        ///////////////
        // read in normals
        
        str.read(reinterpret_cast<char *>(&normalCount), sizeof(int));

        if (normalCount)
        {
                normals = new Vector3f[normalCount];
                str.read(reinterpret_cast<char *>(normals), sizeof(Vector3f) * normalCount);
                normalIndices = new int[indexCount];
                str.read(reinterpret_cast<char *>(normalIndices), sizeof(int) * indexCount);
        }


        //////////////
        // read in texCoords
        
        str.read(reinterpret_cast<char *>(&texCount), sizeof(int));
        if (texCount)
        {
                texCoords = new Point2f[texCount];
                str.read(reinterpret_cast<char *>(texCoords), sizeof(Point2f) * texCount);
        }
        
        IndexedTriangleStripArray *geom = 
                new IndexedTriangleStripArray(vertexCount, 
                                                                          normalCount, 
                                                                          texCount, 
                                                                          colorCount, 
                                                                          format, 
                                                                          indexCount, 
                                                                          stripIndexCounts, 
                                                                          stripCount);

        geom->setCoordinates(0, vertices, vertexCount);
        geom->setCoordinateIndices(0, indices, indexCount);


        if (texCount)
        {
                geom->setTextureCoordinateIndices(0, indices, indexCount);
                geom->setTextureCoordinates(0, texCoords, texCount);
        }

        if (normalCount)
        {
                geom->setNormals(0, normals, normalCount);
                geom->setNormalIndices(0, normalIndices, indexCount);
        }
        

        ///////
        //-- cleanup

        DELAPTR(stripIndexCounts);
        DELAPTR(vertices);
        DELAPTR(normals); 
        DELAPTR(texCoords);
        DELAPTR(indices);
        DELAPTR(normalIndices);

        
        return geom; 
}


BranchGroup *BinaryLoader::Load(const string &filename)
{
        clear_textures(); // clear the texture table

        BranchGroup *root = new BranchGroup();
        //root->setName("start");
        igzstream str(filename.c_str());//, ios::binary);
        
        if (!str.is_open())
                return false;

        // #shapes
        int shapeCount;
        str.read(reinterpret_cast<char *>(&shapeCount), sizeof(int));

        int progress = 0;

        GeometryProcessor geomConv(500000, NULL);

        for (int i = 0; i < shapeCount; ++ i)
        {
                Shape3D *shape = LoadShape(str);

                vector<Shape3D *> newShapes;
                ShapePair shapePair = ShapePair(shape, -1);

                // check, if this node actually contains any geometry
                CalcNumTrianglesVisitor triangleVisitor;
                triangleVisitor.Apply(shape);
                const int numTriangles = triangleVisitor.GetNumTriangles();

                // the shape should be subdivided => replace old shape
                if (geomConv.SubdivideShape(newShapes, shapePair, numTriangles))
                {
                        OUT1("triangleCount: " << numTriangles  << " => subdividing to " << newShapes.size() << " shapes");                     
                        delete shape;//shape->unref();
                }
                else
                {
                        newShapes.push_back(shape);
                }

                VisibilityGroup * visGrp = new VisibilityGroup();
                root->addChild(visGrp);

                for (size_t j = 0; j < newShapes.size(); ++ j)
                {
                        Shape3D *sh = newShapes[j];
                        visGrp->addChild(sh);
                }

                int p = i * 100 / shapeCount;
                
                if (p >= progress)
                {
                        OUT1("% loaded: " << p);
                        progress += 10;
                }
        }

        OUT1("bin loading finished");

        return root;
}


#if 0

collectvertices
{
        int newIndex = 0;

        for (int i = 0; i < numTriangles; ++ i)
        {
                Triangle tri = mTriangles[i];

                for (int j = 0; j < 3; ++ j)
                {
                        const int index = tri.mVertexIndices[j];
                        if (!mHashtable[index])
                        {
                                mHashTable[index] = newIndex;
                                mNewVertices.push_back(mVertices[index];
                        }
        }

        // now loop again, exchange indices;
        for (int i = 0; i < numTriangles; ++ i
        {
                Triangle tri = mTriangles[i];

                for (int j = 0; j < 3; ++ j)
                {
                        const int index = tri.mVertexIndices[j];
                        tri.mVertexIndices[j] = mHashTable[index];
        }
}

#endif