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

#include "BinaryLoader.h"
#include "Matrix4x4.h"
#include "Geometry.h"
#include "SceneEntity.h"
#include "Material.h"
#include "Texture.h"
//#include "gzstream.h"


using namespace std;


namespace CHCDemo
{

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


//SceneEntity *BinaryLoader::LoadSceneEntity(igzstream &str)
SceneEntity *BinaryLoader::LoadSceneEntity(ifstream &str)
{       
        Geometry *geom = LoadGeometry(str);
        Material *mat = LoadMaterial(str);
        Matrix4x4 *trafo = NULL;//IdentityMatrix();

        SceneEntity *sceneGeom = new SceneEntity(geom, mat, trafo);

        return sceneGeom;
}


void BinaryLoader::LoadTextures(ifstream &str)
{
        int numTextures;
        str.read(reinterpret_cast<char *>(&numTextures), sizeof(int));

        for (int i = 0; i < numTextures; ++ i)
        {
                // texture
                int texnameSize;
                int id;

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

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

                cout << "loading texture " << texname << " with len " << texnameSize << " id: " << id << endl;

                Texture *tex = new Texture(texname);

                mTextureTable[id] = tex;
        }
}


//Appearance *BinaryLoader::LoadMaterial(igzstream &str)
Material *BinaryLoader::LoadMaterial(ifstream &str)
{
        // default material
        Material *mat = new Material();
        
        // texture
        int texId;

        str.read(reinterpret_cast<char *>(&texId), sizeof(int));
        //cout << "texid: " << texId << endl;

        if (texId >= 0)
        {
                mat->SetTexture(mTextureTable[texId]);
        }

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

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

                app->setMaterial(mat);
        }

        return app;*/

        return mat;
}


//Geometry *BinaryLoader::LoadGeometry(igzstream &str)
Geometry *BinaryLoader::LoadGeometry(ifstream &str)
{
        Vector3 *vertices;
        Vector3 *normals;
        float *texcoords;


        //////////////
        //-- read in vertices

        int vertexCount;
        str.read(reinterpret_cast<char *>(&vertexCount), sizeof(int));
        
        // end of file reached
        if (str.eof())
                return NULL;

        //cout << "vertexcount: " << vertexCount << endl;

        vertices = new Vector3[vertexCount];
    str.read(reinterpret_cast<char *>(vertices), sizeof(Vector3) * vertexCount);
        
        normals = new Vector3[vertexCount];
        str.read(reinterpret_cast<char *>(normals), sizeof(Vector3) * vertexCount);

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

        if (texCoordCount)
        {
                //cout << "loading texcoords of size " << texCoordCount << endl;
                texcoords = new float[texCoordCount * 2];
                str.read(reinterpret_cast<char *>(texcoords), sizeof(float) * vertexCount * 2);
        }
        else
                texcoords = NULL;

        for (int i = 0; i < vertexCount; i += 3)
        {
                Triangle3 tri(vertices[i], vertices[i + 1], vertices[i + 2]);
                Vector3 n = tri.GetNormal();

                normals[i + 0] = n;
                normals[i + 1] = n;
                normals[i + 2] = n;
        }

        return new Geometry(vertices, normals, texcoords, vertexCount);
}


bool BinaryLoader::Load(const std::string &filename, SceneEntityContainer &geometry)
{
        //clear_textures(); // clear the texture table

        //igzstream str(filename.c_str());//, ios::binary);
        ifstream istr(filename.c_str(), ios::binary);
        
        if (!istr.is_open())
                return false;

        // load the texture table
        LoadTextures(istr);

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

        int progress = 0;

        for (int i = 0; i < shapeCount; ++ i)
        {
                SceneEntity *ent = LoadSceneEntity(istr);
                geometry.push_back(ent);
                
                int p = (i + 1) * 100 / shapeCount;
                
                if (p >= progress)
                {
                        cout << "% loaded: " << p << endl;
                        progress += 10;
                }
        }

        cout << "bin loading finished" << endl;

        return true;
}

}