source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgrePlatformQueryManager.cpp @ 2505

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



namespace Ogre {

//-----------------------------------------------------------------------
void PlatformQueryManager::SetViewport(Viewport *vp)
{
        mViewport = vp;
}
//-----------------------------------------------------------------------
void PlatformQueryManager::ComputeFromPointVisibility(
                                                                                        const Vector3 &point,
                                                                                        NodeInfoContainer *visibleNodes,
                                                                                        MeshInfoContainer *visibleGeometry,
                                                                                        PatchInfoContainer *visiblePatches,
                                                                                        const bool relativeVisibility,
                                                                                        const bool approximateVisibility)
{
        SceneManager *sm = static_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
        if (0)
                {
                        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,
                                                                approximateVisibility);

                // 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,
                                                                        NodeInfoContainer *visibleNodes,
                                                                        MeshInfoContainer *visibleGeometry,
                                                                        PatchInfoContainer *visiblePatches,
                                                                        const bool relativeVisibility,
                                                                        const bool approximateVisibility)
{
        // we need access to the scene manager and the rendersystem
        PlatformHierarchyInterface *pfHierarchyInterface = 
                static_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);

        // render scene once to fill depth buffer
        sm->_renderScene(pCam, mViewport, false); 
   
        mWasInitialised = false; // reset flag
        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status
        mViewport->setBackgroundColour(bg); // reset background color
}

} // namespace Ogre