source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp @ 790

#include "OgreIlluminationManager.h"
#include "OgreParticleSystemRenderer.h"
#include "OgreBillboardParticleRenderer.h"
 

OgreIlluminationManager* OgreIlluminationManager::instance = NULL;

Vector3 sortfrom;
RenderingRunType sortType;

class sortFromVector
{
public:
   bool operator()(OgreSharedRuns* a, OgreSharedRuns* b)
   {
           float dist1 = (a->getRootPosition() - sortfrom).length();
           float dist2 = (b->getRootPosition() - sortfrom).length();

           return dist1 > dist2;
   }
};

class sortFromVectorWithRunType
{
public:
   bool operator()(OgreSharedRuns* a, OgreSharedRuns* b)
   {
           float dist1 = (a->getRootPosition(sortType) - sortfrom).length();
           float dist2 = (b->getRootPosition(sortType) - sortfrom).length();

           return dist1 > dist2;
   }
};


class VisibleFinderVisitor : public QueuedRenderableVisitor
{
private:
        std::vector<const Renderable*>* visibleObjects;
public:
    
        VisibleFinderVisitor(std::vector<const Renderable*>* visibleObjectsVector)
        {
                this->visibleObjects = visibleObjectsVector;
        }

        void visit(const Renderable* r)
        {               
                OgreTechniqueGroup* tg = (OgreTechniqueGroup*) r->getRenderTechniqueGroup();
                
                if(tg != 0)
                {
                        tg->validateSharedRuns();
                        visibleObjects->push_back(r);
                }
        }
        bool visit(const Pass* p)       
        {
                return true;
        }
        void visit(const RenderablePass* rp)
        {
                Renderable* r = rp->renderable;

                OgreTechniqueGroup* tg = (OgreTechniqueGroup*) r->getRenderTechniqueGroup();
                
                if(tg != 0)
                {
                        tg->validateSharedRuns();
                        visibleObjects->push_back(r);
                }       
        }

};

OgreIlluminationManager::OgreIlluminationManager()
{
        visitor = new VisibleFinderVisitor(&visibleObjects);
        maxRad = 400;
}

OgreIlluminationManager::~OgreIlluminationManager()
{
        
}

OgreIlluminationManager& OgreIlluminationManager::getSingleton()
{
        if(instance == NULL)
                instance= new OgreIlluminationManager();

        return *instance;
}

void OgreIlluminationManager::fillVisibleList(  RenderQueue * rq )
{
        visibleObjects.clear();

        RenderQueue::QueueGroupIterator queueIt = rq->_getQueueGroupIterator();
   
    while (queueIt.hasMoreElements())
    {
        RenderQueueGroup* pGroup = queueIt.getNext();
                
        RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();

                while (groupIt.hasMoreElements())
                {
                        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
                        const QueuedRenderableCollection& solids = pPriorityGrp->getSolidsBasic();
                        const QueuedRenderableCollection& transparents = pPriorityGrp->getTransparents();
                                                                        
                        solids.acceptVisitor(visitor, QueuedRenderableCollection::OM_PASS_GROUP);
                        transparents.acceptVisitor(visitor, QueuedRenderableCollection::OM_SORT_ASCENDING);             
                }                       
    }

        rq->clear();    
}

void OgreIlluminationManager::update(unsigned long frameNumber, RenderTarget* rt)
{

        RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
        SceneManager* sceneManager = Root::getSingleton()._getCurrentSceneManager();
        
        for(unsigned short i = 0; i<rt->getNumViewports();i++)
        {
                //find visible objects from the camera
                RenderQueue* rq = sceneManager->getRenderQueue();
                rq->clear();
                RenderQueue::QueueGroupIterator groupIter = rq->_getQueueGroupIterator();
                while (groupIter.hasMoreElements())
                {
                        RenderQueueGroup* g = groupIter.getNext();
                        //g->addOrganisationMode(QueuedRenderableCollection::OM_SORT_ASCENDING);
                        g->defaultOrganisationMode();
                }
                
                sceneManager->_findVisibleObjects(rt->getViewport(i)->getCamera(),false);
                fillVisibleList(rq);    

                //int l = visibleObjects.size(); //debug
                
                joinSharedRuns();

                //int ll = sharedRunRoots.size(); //debug

                //update precomputings                          
                std::vector<const Renderable*>::iterator iter = visibleObjects.begin();
                const std::vector<const Renderable*>::iterator iend = visibleObjects.end();

                while(iter != iend)
                {
                        const Renderable* rend = *iter;
                        OgreTechniqueGroup* techniqueGroup = (OgreTechniqueGroup*) rend->getRenderTechniqueGroup();
                        if(techniqueGroup != 0)
                        {
                                techniqueGroup->update(frameNumber);
                        }
                        iter++;
                }

        }

        Root::getSingleton().renderOneFrame();
        //Root::getSingleton()._updateAllRenderTargets();


}

void OgreIlluminationManager::sharedRunSplit(SharedRuns* old, SharedRuns* new1, SharedRuns* new2)
{
        sharedRunRoots.remove(old);
        sharedRunRoots.push_back(new1);
        sharedRunRoots.push_back(new2);
}

void OgreIlluminationManager::sharedRunJoin(SharedRuns* old1, SharedRuns* old2, SharedRuns* newsr)
{
        sharedRunRoots.remove(old1);
        sharedRunRoots.remove(old2);
        sharedRunRoots.push_back(newsr);
}

void OgreIlluminationManager::joinSharedRuns()
{
        std::list<SharedRuns*>::iterator it1 = sharedRunRoots.begin();
        std::list<SharedRuns*>::iterator itend = sharedRunRoots.end();

        bool again = false;

        while(it1 != itend)
        {
                std::list<SharedRuns*>::iterator it2 = sharedRunRoots.begin();          
                
                while(it2 != itend)
                {
                        if( *it1 != *it2 && OgreSharedRuns::canJoin(*it1, *it2))
                        {
                                SharedRuns* newruns = (*it1)->joinRuns(*it2);
                                sharedRunJoin(*it1, *it2, newruns);
                                again = true;
                                break;
                        }
                        it2++;
                }

                if(again)
                        break;          

                it1++;
        }
        if(again)
        joinSharedRuns();

}

void OgreIlluminationManager::addSharedRuns(SharedRuns* runs)
{
        sharedRunRoots.push_back(runs);
}

void OgreIlluminationManager::getNearestCausticCasters(Vector3 position, std::vector<OgreSharedRuns*>* nearestcasters, unsigned int maxCount)
{
        sortfrom = position;
        std::vector<OgreSharedRuns*> allcasters;
        //fill casters
        std::list<SharedRuns*>::iterator it = sharedRunRoots.begin();
        std::list<SharedRuns*>::iterator itend = sharedRunRoots.end();
        while(it != itend)
        {
                OgreSharedRuns* sr = (OgreSharedRuns*) (*it);
                
                sr->findSharedRootsForType(ILLUMRUN_CAUSTIC_CUBEMAP, allcasters);
                
                it++;
        }

        //sort
        std::stable_sort(allcasters.begin(), allcasters.end(), sortFromVector());

        for(unsigned int i = 0; i < maxCount && i < allcasters.size(); i++)
        {
                nearestcasters->push_back(allcasters.at(i));
        }
}

void OgreIlluminationManager::createGlobalRun(RenderingRunType runType)
{
        switch(runType)
        {
                case ILLUMRUN_SCENE_CAMERA_DEPTH:
                if(globalSharedRuns.getRun(ILLUMRUN_SCENE_CAMERA_DEPTH) == 0)
                {
                        OgreSceneCameraDepthRenderingRun* run = new OgreSceneCameraDepthRenderingRun
                                (&globalSharedRuns, "ILLUMMODULE_SCENE_CAMERA_DEPTH", mainViewport);
                        globalSharedRuns.addRun(ILLUMRUN_SCENE_CAMERA_DEPTH, run);
                }
                break;
        }
}

RenderingRun* OgreIlluminationManager::getGlobalRun(RenderingRunType runType)
{
        return globalSharedRuns.getRun(runType);
}

void OgreIlluminationManager::updateGlobalRun(RenderingRunType runType, unsigned long frameNum)
{
        globalSharedRuns.updateRun(runType, frameNum);
}

void OgreIlluminationManager::createPerLightRun(String lightName, RenderingRunType runType)
{
        OgreSharedRuns* runs = 0;
        
        if(perLightRuns.find(lightName) == perLightRuns.end()) 
        {///create sharedruns
                OgreSharedRuns* newruns = new OgreSharedRuns();
                perLightRuns[lightName] = newruns;
        }

        runs = perLightRuns[lightName];

    switch(runType)
        {
                case ILLUMRUN_DEPTH_SHADOWMAP:
                if(runs->getRun(ILLUMRUN_DEPTH_SHADOWMAP) == 0)
                {
                        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
                        OgreDepthShadowMapRenderingRun* run  = new OgreDepthShadowMapRenderingRun(
                                runs,
                                lightName + "DEPTH_SHADOW_MAP",
                                sm->getLight(lightName),
                                2048, //TODO
                                2048, //TODO
                                "GameTools/ShadowMapDepth" //TODO
                                );
                        runs->addRun(ILLUMRUN_DEPTH_SHADOWMAP, run);
                        
                }
                break;
        }       
}

RenderingRun* OgreIlluminationManager::getPerLightRun(String lightName, RenderingRunType runType)
{
        return perLightRuns[lightName]->getRun(runType);
}

void OgreIlluminationManager::updatePerLightRun(String lightName, RenderingRunType runType, unsigned long frameNum)
{
        perLightRuns[lightName]->updateRun(runType, frameNum);
}