source: trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp @ 316

#include "OgrePlatformQueryManager.h"
#include "OcclusionQuery.h"
#include <OgreSceneManager.h>
#include <OgreLogManager.h>
#include <OgreStringConverter.h>
#include <vector>
#include <OgreSubEntity.h>


namespace Ogre {

//----------------------------------------------------------------------- 
PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, 
                                                                                   Viewport *vp, int queryModes):
QueryManager(hierarchyInterface, queryModes), 
mViewport(vp), 
mWasInitialised(false)
{
}
//-----------------------------------------------------------------------
bool PlatformQueryManager::ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine)
{
    // run OGRE ray shooting query
    return false;
}
//-----------------------------------------------------------------------
void PlatformQueryManager::ComputeFromPointVisibility(const Vector3 &point,
                               GtpVisibility::NodeInfoContainer *visibleNodes,
                               GtpVisibility::MeshInfoContainer *visibleGeometry,
                                   GtpVisibility::PatchInfoContainer *visiblePatches,
                               bool relativeVisibility)
{
        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>
                (mHierarchyInterface)->GetSceneManager();

        // create a camera for the point query
        Camera *cam = sm->createCamera("PointQueryCam");        

        //save old camera
        Camera *savedCam = mViewport->getCamera();
        
        // --- initialise new camera
        mViewport->setCamera(cam);
        cam->setPosition(point);

        cam->setNearClipDistance(savedCam->getNearClipDistance());
        cam->setFarClipDistance(savedCam->getFarClipDistance());

        // set frustum to 45 degrees so all the scene can be captured with 6 shots
        cam->setAspectRatio(1.0);
        cam->setFOVy(Radian(Math::HALF_PI));

        int sign = -1;
        
        // ---- capture visibility from all 6 directions
        for (int dir=0; dir < 6; dir++) 
        {
                sign *= -1;
                
                // Print camera details
        std::stringstream d;
                d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) + 
                        " " + "O: " + StringConverter::toString(cam->getDerivedOrientation());
                LogManager::getSingleton().logMessage(d.str());

                // prevent from initialising geometry / node array again
                if (dir > 0)
                {
                        mWasInitialised = true;
                }

                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, visiblePatches, 
                                            relativeVisibility);
                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait");

                // permute directions
                Vector3 direction(0,0,0);
                direction[dir/2] = sign;

                cam->setDirection(direction);
        }
        
        // reset camera
        mViewport->setCamera(savedCam);
}
//-----------------------------------------------------------------------
void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera,
                            GtpVisibility::NodeInfoContainer *visibleNodes,
                            GtpVisibility::MeshInfoContainer *visibleGeometry,
                                GtpVisibility::PatchInfoContainer *visiblePatches,
                            bool relativeVisibility)
{
        // we need access to the scene manager and the rendersystem
        PlatformHierarchyInterface *pfHierarchyInterface = 
                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);

        SceneManager *sm = pfHierarchyInterface->GetSceneManager();


        // const_cast allowed because camera is not changed in renderScene
        Camera *pCam = const_cast<Camera *>(&camera); 

        // disable overlays, reset them later
        bool overlayEnabled = mViewport->getOverlaysEnabled();
        mViewport->setOverlaysEnabled(false);
        
        // clear background with black (i.e., not a valid item id)
        ColourValue bg = mViewport->getBackgroundColour();
        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0));
        //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH);

        // initialise item buffer (if not already initialised)
        InitItemBuffer(visibleGeometry, visiblePatches);

        //-- render scene with item buffer (i.e., objects with their id as color codes)

        // enable item buffer (must be provided by scene manager)
        bool useItemBuffer = true;
        sm->setOption("UseItemBuffer", &useItemBuffer);


        sm->_renderScene(pCam, mViewport, false); // render item buffer
   

        //-- collect results
        CollectItemBufferResults(visibleGeometry, visiblePatches);

        //-- reset options

        useItemBuffer = false; // don't need item buffer anymore
        sm->setOption("UseItemBuffer", &useItemBuffer);

        mWasInitialised = false; // reset initialised - flag
        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status
        mViewport->setBackgroundColour(bg); // reset background color
}
//-----------------------------------------------------------------------
void PlatformQueryManager::CollectItemBufferResults(
                                GtpVisibility::MeshInfoContainer *visibleGeometry,
                                GtpVisibility::PatchInfoContainer *visiblePatches)
{
        int dimx = 0;
        int dimy = 0;

        // copy frame buffer 
        uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy);

        //std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; LogManager::getSingleton().logMessage(d.str());

        // loop through frame buffer and collect visible pixels
        for (int idx = 0; idx < dimy * dimx * 3; idx += 3)
        {
                //-- decode color code to receive id
                int id = buf[idx] << 16;
                id += buf[idx + 1] << 8;
                id += buf[idx + 2];

                //std::stringstream d; d << "myid: " << (int)buf[idx] << " " << (int)buf[idx + 1] << " " << (int)buf[idx + 2]; LogManager::getSingleton().logMessage(d.str());

                // if valid id <= add visibility (id values start at 1)
                if (mQueryModes == PATCH_VISIBILITY)
                {       
                        if ((id > 0) && (id < (int)visiblePatches->size()))
                        {
                                ((*visiblePatches)[id]).AddVisibility(1, 0);
                        }
                }
                else if (mQueryModes == GEOMETRY_VISIBILITY)
                {
                        if ((id > 0) && (id < (int)visibleGeometry->size()))
                        {
                                ((*visibleGeometry)[id]).AddVisibility(1, 0);
                        }
                }
        }

        delete [] buf;
}

//-----------------------------------------------------------------------
void PlatformQueryManager::InitItemBuffer(
                                GtpVisibility::MeshInfoContainer *visibleGeometry,
                                GtpVisibility::PatchInfoContainer *visiblePatches)
{
        if (mWasInitialised)
                return;

        mWasInitialised = true;

        SceneManager *sm = 
                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();

        SceneManager::EntityIterator it = sm->getEntityIterator();

        // TODO: make the function more efficient

        visibleGeometry->clear();
        visiblePatches->clear();

        int id = 0;

        /* We can either use patches or meshes. If patches are used, an unique id must
           be given each patch. Otherwise the same id must be given to all patches belonging
           to the same mesh.
    */
        while (it.hasMoreElements())
        {
                Entity *ent = it.getNext();

                for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
                {
                        SubEntity *subEnt = ent->getSubEntity(i);

                        if (mQueryModes == PATCH_VISIBILITY)
                        {
                                ++ id;
                                visiblePatches->push_back(GtpVisibility::PatchInfo(subEnt, 0, 0));
                        }
                                
                        subEnt->setId(id);
                        //subEnt->setId((41 << 16) + (4 << 8) + 60);
                }
                        
                if (mQueryModes == GEOMETRY_VISIBILITY)
                {
                        visibleGeometry->push_back(GtpVisibility::MeshInfo(ent, 0, 0));
                        ++ id;
                }
        }
}
//-----------------------------------------------------------------------
void PlatformQueryManager::SetViewport(Viewport *vp)
{
        mViewport = vp;
}
} // namespace Ogre