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

#include "ObjReader.h"
#include "gzstream.h"
#include "Triangle3.h"
#include "IntersectableWrapper.h"
#include "BvHierarchy.h"
#include "Preprocessor.h"
#include "OgreEntity.h"
#include "PreprocessorFactory.h"
#include "OgreLogManager.h"



ObjReader::ObjReader(Ogre::SceneManager *sceneManager):
mSceneManager(sceneManager)
{}


ObjReader::~ObjReader()
{}


bool ObjReader::LoadFile(const string &sceneName, 
                                                 const string &visibilitySolution,
                                                 Ogre::SceneNode *root)
{
        GtpVisibilityPreprocessor::Debug.open("debug.log");
        // HACK: get any preprocessor to load file
        GtpVisibilityPreprocessor::Preprocessor *preprocessor = 
                GtpVisibilityPreprocessor::PreprocessorFactory::CreatePreprocessor("vss");

        // hack
        preprocessor->mLoadMeshes = false;
        GtpVisibilityPreprocessor::ObjectContainer pvsObjects;

        Ogre::LogManager::getSingleton().logMessage("loading obj scene!!");

        if (preprocessor->LoadScene(sceneName))
        {
                Ogre::LogManager::getSingleton().logMessage("scene loaded, loading objects");
                // form objects from the scene triangles
                if (!preprocessor->LoadObjects(visibilitySolution, pvsObjects, preprocessor->mObjects))
                {
                        Ogre::LogManager::getSingleton().logMessage("objects cannot be loaded");
                        return false;
                }
        }
        else
        {
                Ogre::LogManager::getSingleton().logMessage("scene cannot be loaded");
                return false;
        }

        std::stringstream d; 
        d << "successfully loaded " << pvsObjects.size() << " objects from " << preprocessor->mObjects.size() << " preprocessor objects";

        Ogre::LogManager::getSingleton().logMessage(d.str());

        GtpVisibilityPreprocessor::ObjectContainer::const_iterator oit, oit_end = pvsObjects.end();

        int i = 0;
        for (oit = pvsObjects.begin(); oit != oit_end; ++ oit, ++ i)
        {
                Ogre::LogManager::getSingleton().logMessage("r");
                const Ogre::String entname = "Object" + Ogre::StringConverter::toString(i);

                Ogre::ManualObject *ent = CreateEntity(entname, *oit);

                const Ogre::String nodeName = entname + "Node";
                Ogre::SceneNode* node = root->createChildSceneNode(nodeName);
                node->attachObject(ent);

                if (i > 100)
                        break;
        }

        delete preprocessor;

        return true;
}


Ogre::ManualObject *ObjReader::CreateManualObject(const std::string &name,
                                                                                                  GtpVisibilityPreprocessor::Intersectable *object)
{
        using namespace Ogre;
        //using namespace GtpVisibilityPreprocessor;

        std::string meshName = name + ".mesh";
        std::string entityName = name + "Entity";

GtpVisibilityPreprocessor::BvhLeaf *bvhObj = 
                static_cast<GtpVisibilityPreprocessor::BvhLeaf *>(object);
        const int vertexCount = (int)bvhObj->mObjects.size() * 3;

        ManualObject* manual = mSceneManager->createManualObject(entityName);
        manual->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_STRIP);
        
        // create vertices
        
        GtpVisibilityPreprocessor::ObjectContainer::const_iterator oit, oit_end = bvhObj->mObjects.end();
        
        for (oit = bvhObj->mObjects.begin(); oit != oit_end; ++ oit)
        {
                GtpVisibilityPreprocessor::TriangleIntersectable *tObj = 
                        static_cast<GtpVisibilityPreprocessor::TriangleIntersectable *>(*oit);
                
                GtpVisibilityPreprocessor::Triangle3 tri = tObj->GetItem();

                for (int i = 0; i < 3; ++ i)
                {
                        const GtpVisibilityPreprocessor::Vector3 vtx = tri.mVertices[i];
                        manual->position(vtx.x, vtx.y, vtx.z);
                        manual->colour(1.0f, 0.0f, 0.0f);
                }
        }

        for (int i = 0; i < vertexCount; ++ i)
        {
                manual->index(i);
        }

        return manual;
}


Ogre::Entity *ObjReader::CreateEntity(const std::string &name,
                                                                          GtpVisibilityPreprocessor::Intersectable *object)
{
        using namespace Ogre;

        Entity *entity;

        GtpVisibilityPreprocessor::BvhLeaf *bvhObj = 
                static_cast<GtpVisibilityPreprocessor::BvhLeaf *>(object);

        std::string meshName = name + ".mesh";
        std::string entityName = name + "Entity";

        MeshPtr mesh = MeshManager::getSingleton().createManual(meshName, "Custom");
        SubMesh* submesh = mesh->createSubMesh();

        const int vertexCount = (int)bvhObj->mObjects.size() * 3;

        // 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 = vertexCount;

        std::stringstream d; d << "objects: " << bvhObj->mObjects.size() << " vtx: " << submesh->vertexData->vertexCount << endl;
        Ogre::LogManager::getSingleton().logMessage(d.str());

        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),
                                                   submesh->vertexData->vertexCount,
                                                   HardwareBuffer::HBU_STATIC_WRITE_ONLY);

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

        GtpVisibilityPreprocessor::ObjectContainer::const_iterator oit, oit_end = bvhObj->mObjects.end();

        for (oit = bvhObj->mObjects.begin(); oit != oit_end; ++ oit)
        {
                GtpVisibilityPreprocessor::TriangleIntersectable *tObj = 
                        static_cast<GtpVisibilityPreprocessor::TriangleIntersectable *>(*oit);
                
                GtpVisibilityPreprocessor::Triangle3 tri = tObj->GetItem();

                for (int i = 0; i < 3; ++ i)
                {
                        Vector3 vtx = Vector3(tri.mVertices[i]);

                        *vdata ++ = vtx.x;
                        *vdata ++ = vtx.y;
                        *vdata ++ = vtx.z;

                        //std::stringstream d; d << vtx;
                        //Ogre::LogManager::getSingleton().logMessage(d.str());
                        aabox.merge(vtx);
                }
        }
        //Ogre::LogManager::getSingleton().logMessage("***");
        vbuffer->unlock();
        
        /*Ogre::RenderOperation rop;
        submesh->_getRenderOperation(rop);
        rop.useIndexes = false;
*/
        //////
        //-- Creates the index data

    submesh->vertexData->vertexBufferBinding->setBinding(source, vbuffer);

        submesh->indexData->indexStart = 0;
        // we use an index for every vertex
        submesh->indexData->indexCount = vertexCount;
        submesh->indexData->indexBuffer =
            HardwareBufferManager::getSingleton().
                        createIndexBuffer(HardwareIndexBuffer::IT_16BIT,
                                                          submesh->indexData->indexCount,
                                                          HardwareBuffer::HBU_STATIC_WRITE_ONLY);
        submesh->operationType = RenderOperation::OT_LINE_STRIP;
        //uint16* idata = static_cast<uint16*>(submesh->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
    unsigned short* idata = static_cast<unsigned short*>(submesh->indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));

        for (int j = 0; j < vertexCount; ++ j)
    {
                *idata = j;
                ++ idata;
    }
    
        submesh->indexData->indexBuffer->unlock();

        submesh->setMaterialName("BaseWhiteNoLighting"); 

        // We must indicate the bounding box
        mesh->_setBounds(aabox); 
        mesh->_setBoundingSphereRadius((aabox.getMaximum() - aabox.getMinimum()).length() / 2.0); 
        mesh->load();
        mesh->touch();

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

        //entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_MAIN);

        return entity;
#endif
}