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

#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"
#include "ObjManualMeshLoader.h"



ObjReader::ObjReader(Ogre::SceneManager *sceneManager):
mSceneManager(sceneManager), mPreprocessor(NULL)
{
}


ObjReader::~ObjReader()
{
        CLEAR_CONTAINER(mPvsObjects);
        
        DEL_PTR(mPreprocessor);
}


bool ObjReader::LoadFile(const string &sceneName, 
                                                 const string &visibilitySolution,
                                                 Ogre::SceneNode *root)
{
        GtpVisibilityPreprocessor::Debug.open("debug.log");

        // HACK: get any preprocessor to load file
        // note should be preserved to allow manual mesh reloading,
        // but then geometry has to be stored two times
        mPreprocessor = 
                GtpVisibilityPreprocessor::PreprocessorFactory::CreatePreprocessor("vss");

        // hack
        mPreprocessor->mLoadMeshes = false;

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

        if (mPreprocessor->LoadScene(sceneName))
        {
                Ogre::LogManager::getSingleton().logMessage("scene loaded, loading objects");
                // form objects from the scene triangles
                if (!mPreprocessor->LoadObjects(visibilitySolution, mPvsObjects, mPreprocessor->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 " << (int)mPvsObjects.size() 
          << " objects from " << (int)mPreprocessor->mObjects.size() << " preprocessor objects";

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

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

        int i = 0;
        for (oit = mPvsObjects.begin(); oit != oit_end; ++ oit, ++ i)
        {
                if (i % 5000 == 4999)
                {
                        d << i << " objects created";
                        Ogre::LogManager::getSingleton().logMessage(d.str());
                }
        
                const Ogre::String entname = "Object" + Ogre::StringConverter::toString(i);

#if 0
                Ogre::ManualObject *ent = CreateManualObject(entname, *oit);
#else
                Ogre::Entity *ent = CreateEntity(entname, *oit);
#endif

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

                // problems for too many objects (= vbo)?
                //if (i > 30000)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("BaseWhite", RenderOperation::OT_TRIANGLE_LIST);
        
        const float red = GtpVisibilityPreprocessor::Random(1.0f);
        const float green = GtpVisibilityPreprocessor::Random(1.0f);
        const float blue = GtpVisibilityPreprocessor::Random(1.0f);

        // 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];
                        const GtpVisibilityPreprocessor::Vector3 n = tri.GetNormal();

                        manual->position(vtx.x, vtx.y, vtx.z);
                        manual->normal(n.x, n.y, n.z);
                        //manual->colour(red, green, blue);
                }
        }

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

        manual->end();

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

        ObjManualMeshLoader *loader = new ObjManualMeshLoader(bvhObj);

        Mesh* pMesh = MeshManager::getSingleton().createManual(meshName, "ObjGroup", loader).getPointer(); 
        pMesh->load(); 

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

        return entity;
}