source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityPredictor.cpp @ 2558

#include "OgreVisibilityPredictor.h"
#include "OgreBoundingBoxConverter.h"
#include "DistanceQueue.h"


const static int maxInvisibleNodesSize = 50;


namespace Ogre
{
        struct EntityQuery
        {
                GtpVisibility::OcclusionQuery *mQuery;
                vector<Entity *> mEntities;
        };

        typedef std::queue<EntityQuery> EntityQueryQueue;

        VisibilityPredictor::VisibilityPredictor()
        {
        }

        void VisibilityPredictor::HandleProbablyVisibleObjects(GtpVisibilityPreprocessor::ViewCell *vc)
        {
                EntityQueryQueue queryQueue;
                vector<Entity *> invisibleEntities;

                // use multiqueries for the objects that are probably invisible
        GtpVisibilityPreprocessor::ObjectPvsIterator pit = vc->GetPvs().GetIterator();

                while (pit.HasMoreEntries())
                {               
                        GtpVisibilityPreprocessor::Intersectable *obj = pit.Next();
            
                        if (obj->Type() != GtpVisibilityPreprocessor::Intersectable::ENGINE_INTERSECTABLE)
                                continue;
                
                        EngineIntersectable *oi = static_cast<EngineIntersectable *>(obj);

                        EntityContainer *entries = oi->GetItem();
                        
                        EntityContainer::const_iterator eit, eit_end = entries->end();

                        for (eit = entries->begin(); eit != eit_end; ++ eit)
                        {
                                // collect entities for multiqueries
                                invisibleEntities.push_back(*eit);

                                if ((int)invisibleEntities.size() >= maxInvisibleNodesSize)
                                {
                                        // issue the batched queries
                                        IssueMultiQuery(invisibleEntities);
                                        invisibleEntities.clear();
                                }
                        }
                }
        
                while(!queryQueue.empty())
                {
                        unsigned int visiblePixels;

                        // fetch multiquery result
                        queryQueue.front().mQuery->GetQueryResult(visiblePixels, false);

                        size_t n = queryQueue.front().mEntities.size();

                        // tested visible
                        if (visiblePixels > 0)
                        {
                                // render nodes assoziated with current multiquery
                                for (size_t i = 0; i < n; ++ i)
                                {
                                        Entity *ent = queryQueue.front().mEntities[i];
                                        // render entity

                                        // we have to store the entity and test it individually later
                                        mEntityBuffer.push_back(ent);
                                }
                        }

                        queryQueue.pop();
                }       
        }


        void VisibilityPredictor::UpdateVisibility(GtpVisibilityPreprocessor::ViewCell *vc)
        {
                GtpVisibility::HierarchyNodeContainer::const_iterator nit, nit_end = mEntityBuffer.end();

                // test individual nodes
                for (nit = mEntityBuffer.begin(); nit != nit_end; ++ nit)
                {

                }

                // fetch query results, update PVS of view cell
                for (nit = mEntityBuffer.begin(); nit != nit_end; ++ nit)
                {

                }

                mEntityBuffer.clear();
        }

        
        void VisibilityPredictor::IssueMultiQuery(const vector<Entity *> &mEntities)
        {
        }
}