source: GTP/trunk/Lib/Vis/OnlineCullingCHC/ObjReader/src/ObjReader.cpp @ 2115

#include "ObjReader.h"
#include "gzstream.h"
#include "Triangle3.h"
#include "IntersectableWrapper.h"


ObjReader::ObjReader()
{}


ObjReader::~ObjReader()
{}


bool ObjReader::LoadFile(const string &filename,
                                                 GtpVisibilityPreprocessor::ObjectContainer &objects) const
{
        igzstream samplesIn(filename.c_str());
        
        if (!samplesIn.is_open())
                return false;
        
        // read in triangle size
        int numTriangles;

        samplesIn.read(reinterpret_cast<char *>(&numTriangles), sizeof(int));
        objects.reserve(numTriangles);
        
        while (1)
        {
                GtpVisibilityPreprocessor::Triangle3 tri;
                
                samplesIn.read(reinterpret_cast<char *>(tri.mVertices + 0), 
                                           sizeof(GtpVisibilityPreprocessor::Vector3));
                samplesIn.read(reinterpret_cast<char *>(tri.mVertices + 1), 
                                           sizeof(GtpVisibilityPreprocessor::Vector3));
                samplesIn.read(reinterpret_cast<char *>(tri.mVertices + 2), 
                                           sizeof(GtpVisibilityPreprocessor::Vector3));

                // end of file reached
                if (samplesIn.eof())
                        break;

                GtpVisibilityPreprocessor::TriangleIntersectable *obj = 
                        new GtpVisibilityPreprocessor::TriangleIntersectable(tri);
                objects.push_back(obj);
        }
        
        return true;
}


const std::vector<Ogre::Entity *> &ObjReader::GetObjects() const
{
        return mObjects;
}


Ogre::Entity *ObjReader::CreateEntity(const std::string &name)
//                                                                        ObjMeshData *mData, 
//                                                                        Ogre::Vector3 *translation)
{
        using namespace Ogre;
        Entity *entity;

        
        std::string meshName = name.substr(name.find('/',0), name.length()) + "/Mesh";
        std::string entityName = name + "/Entity";

        MeshPtr mesh = MeshManager::getSingleton().createManual(meshName, "ObjGroup");
        SubMesh* submesh = mesh->createSubMesh();
int nbVertices = 99992;
        // We must create the vertex data, indicating how many vertices there will be
        submesh->useSharedVertices = false;
        submesh->vertexData = new VertexData();
        submesh->vertexData->vertexStart = 0;
        submesh->vertexData->vertexCount = nbVertices;

        static const unsigned short source = 0;
        size_t offset = 0;

        VertexDeclaration* declaration = HardwareBufferManager::getSingleton().createVertexDeclaration();

        offset += declaration->addElement(source,offset,VET_FLOAT3,VES_POSITION).getSize();
        //      offset += declaration->addElement(source,offset,VET_FLOAT3,VES_NORMAL).getSize();
        //      offset += declaration->addElement(source,offset,VET_FLOAT2,VES_TEXTURE_COORDINATES).getSize();


        int numVertices = 0;

        HardwareVertexBufferSharedPtr vbuffer = 
                HardwareBufferManager::getSingleton().createVertexBuffer(declaration->getVertexSize(source), // size of one whole vertex
                submesh->vertexData->vertexCount, // number of vertices
                HardwareBuffer::HBU_STATIC_WRITE_ONLY, // usage
                false); // no shadow buffer


        // No we get access to the buffer to fill it.  During so we record the bounding box.
        AxisAlignedBox aabox;

        float* vdata = static_cast<float*>(vbuffer->lock(HardwareBuffer::HBL_DISCARD));

        for (size_t i = 0; i < nbVertices; ++ i)
        {
                // Position
                Vector3 position;// = 20.0f*positions[i];
                *vdata++ = position.x;
                *vdata++ = position.y;
                *vdata++ = position.z;
                aabox.merge(position);
                // Normal
                Vector3 normal = position.normalisedCopy();
                *vdata++ = normal.x;
                *vdata++ = normal.y;
                *vdata++ = normal.z;

                // Texture coordinate
                Vector2 tcoordinate;// = tcoordinates[i];
                *vdata ++ = tcoordinate.x;

                *vdata ++ = tcoordinate.y;

        }

        vbuffer->unlock();

        // We must indicate the bounding box
        //mesh->_setBounds(aabox); 

        //mesh->_setBoundingSphereRadius((aabox.getMaximum()-aabox.getMinimum()).length()/2.0); 

        mesh->load();
        
        // Create an entity with the mesh
        //entity = mSceneManager->createEntity(meshName, entityName);

        return entity;
}