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

Revision 2379, 22.8 KB checked in by szirmay, 17 years ago (diff)
Line 
1#include "OgreIlluminationManager.h"
2#include "OgreParticleSystemRenderer.h"
3#include "OgreBillboardParticleRenderer.h"
4#include "SpriteParticleRenderer.h"
5#include "OgrePMEntryPointMapRenderingRun.h"
6#include "OgrePMWeightComputeRenderingRun.h"
7#include "OgreTriggersRenderTechnique.h"
8#include "OgreColorCubeMapRenderTechnique.h"
9#include "OgreDistanceCubeMapRenderTechnique.h"
10#include "OgreConvolvedCubeMapRenderTechnique.h"
11#include "OgreCausticCasterRenderTechnique.h"
12#include "OgreCausticReceiverRenderTechnique.h"
13#include "OgreSceneCameraDepthRenderingRun.h"
14#include "OgreSBBRenderTechnique.h"
15#include "OgreDepthShadowMapRenderingRun.h"
16#include "OgreDepthShadowReceiverRenderTechnique.h"
17#include "OgreFireRenderTechnique.h"
18#include "OgreHierarchicalParticleSystemTechnique.h"
19#include "OgreIllumVolumeRenderTechnique.h"
20#include "OgrePhaseTextureRenderingRun.h"
21#include "OgrePathMapRenderTechnique.h"
22
23
24OgreIlluminationManager* OgreIlluminationManager::instance = NULL;
25
26Vector3 sortfrom;
27RenderingRunType sortType;
28
29class sortFromVector
30{
31public:
32   bool operator()(OgreSharedRuns* a, OgreSharedRuns* b)
33   {
34           float dist1 = (a->getRootPosition() - sortfrom).length();
35           float dist2 = (b->getRootPosition() - sortfrom).length();
36
37           return dist1 > dist2;
38   }
39};
40
41class sortFromVectorWithRunType
42{
43public:
44   bool operator()(OgreSharedRuns* a, OgreSharedRuns* b)
45   {
46           float dist1 = (a->getRootPosition(sortType) - sortfrom).length();
47           float dist2 = (b->getRootPosition(sortType) - sortfrom).length();
48
49           return dist1 > dist2;
50   }
51};
52
53
54class VisibleFinderVisitor : public QueuedRenderableVisitor
55{
56private:
57        std::vector<const Renderable*>* visibleObjects;
58public:
59   
60        VisibleFinderVisitor(std::vector<const Renderable*>* visibleObjectsVector)
61        {
62                this->visibleObjects = visibleObjectsVector;
63        }
64
65        void visit(const Renderable* r)
66        {               
67                OgreTechniqueGroup* tg = (OgreTechniqueGroup*) r->getRenderTechniqueGroup();
68               
69                if(tg != 0)
70                {
71                        tg->validateSharedRuns();
72                        visibleObjects->push_back(r);
73                }
74        }
75        bool visit(const Pass* p)       
76        {
77                return true;
78        }
79        void visit(const RenderablePass* rp)
80        {
81                Renderable* r = rp->renderable;
82
83                OgreTechniqueGroup* tg = (OgreTechniqueGroup*) r->getRenderTechniqueGroup();
84               
85                if(tg != 0)
86                {
87                        tg->validateSharedRuns();
88                        visibleObjects->push_back(r);
89                }       
90        }
91
92};
93
94OgreIlluminationManager::OgreIlluminationManager()
95{
96        visitor = new VisibleFinderVisitor(&visibleObjects);
97        joinRuns = true;
98        maxRad = 400;
99        focusingMapSize = 32;
100        phaseTextureSize = 256;
101        shadowMapSizeDirectional = shadowMapSizePoint = shadowMapSizeSpot = 512;
102        useLISPSMDirectional = useLISPSMPoint = useLISPSMSpot = false;
103        blurSMDirectional = blurSMPoint = blurSMSpot = false;
104        focusingSMDirectional = focusingSMPoint = focusingSMSpot = true;
105        shadowMapMaterialNameDirectional = "GTP/Basic/Depth or GTP/Basic/DepthCCW";
106        shadowMapMaterialNamePoint = "GTP/Basic/Distance_NormalizedCCW";
107        shadowMapMaterialNameSpot = "GTP/Basic/Distance_NormalizedCCW";
108        areaLightRadius = 0.1;
109
110        for(int i = 0; i < RUN_TYPE_COUNT; i++)
111        {
112                maxRads[(RenderingRunType)i] = (float) maxRad;
113        }
114
115        //register rendertechnique factories
116        OgreColorCubeMapRenderTechniqueFactory* colorcube = new OgreColorCubeMapRenderTechniqueFactory();
117                addRenderTechniqueFactory(colorcube);
118        OgreDistanceCubeMapRenderTechniqueFactory* distcube = new OgreDistanceCubeMapRenderTechniqueFactory();
119                addRenderTechniqueFactory(distcube);
120        OgreConvoledCubeMapRenderTechniqueFactory* convcube = new OgreConvoledCubeMapRenderTechniqueFactory();
121                addRenderTechniqueFactory(convcube);
122        OgreCausticCasterRenderTechniqueFactory* caucast = new OgreCausticCasterRenderTechniqueFactory();
123                addRenderTechniqueFactory(caucast);
124        OgreCausticReceiverRenderTechniqueFactory* caurec = new OgreCausticReceiverRenderTechniqueFactory();
125                addRenderTechniqueFactory(caurec);
126        OgreDepthShadowReceiverRenderTechniqueFactory* dsrec = new OgreDepthShadowReceiverRenderTechniqueFactory();
127                addRenderTechniqueFactory(dsrec);
128        OgreSBBRenderTechniqueFactory* sbb = new OgreSBBRenderTechniqueFactory();
129                addRenderTechniqueFactory(sbb);
130        OgreFireRenderTechniqueFactory* fire = new OgreFireRenderTechniqueFactory();
131                addRenderTechniqueFactory(fire);
132        OgreHierarchicalParticleSystemTechniqueFactory* HPSF = new OgreHierarchicalParticleSystemTechniqueFactory();
133                addRenderTechniqueFactory(HPSF);
134        OgreIllumVolumeRenderTechniqueFactory* illumVolume = new OgreIllumVolumeRenderTechniqueFactory();
135                addRenderTechniqueFactory(illumVolume);
136        OgrePathMapRenderTechniqueFactory* pathmap = new OgrePathMapRenderTechniqueFactory();
137        addRenderTechniqueFactory(pathmap);
138        OgreTriggersRenderTechniqueFactory* triggers = new OgreTriggersRenderTechniqueFactory();
139        addRenderTechniqueFactory(triggers);
140}
141
142OgreIlluminationManager::~OgreIlluminationManager()
143{
144       
145}
146
147OgreIlluminationManager& OgreIlluminationManager::getSingleton()
148{
149        if(instance == NULL)
150                instance= new OgreIlluminationManager();
151
152        return *instance;
153}
154
155void OgreIlluminationManager::fillVisibleList(  RenderQueue * rq )
156{
157        visibleObjects.clear();
158
159        RenderQueue::QueueGroupIterator queueIt = rq->_getQueueGroupIterator();
160   
161    while (queueIt.hasMoreElements())
162    {
163        RenderQueueGroup* pGroup = queueIt.getNext();
164               
165        RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
166
167                while (groupIt.hasMoreElements())
168                {
169                        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
170                        const QueuedRenderableCollection& solids = pPriorityGrp->getSolidsBasic();
171                        const QueuedRenderableCollection& transparents = pPriorityGrp->getTransparents();
172                                                                       
173                        solids.acceptVisitor(visitor, QueuedRenderableCollection::OM_PASS_GROUP);
174                        transparents.acceptVisitor(visitor, QueuedRenderableCollection::OM_SORT_ASCENDING);             
175                }                       
176    }
177
178        rq->clear();   
179}
180
181BillboardSet* OgreIlluminationManager::findRenderableInParticleSystem(ParticleSystem* system)
182{
183        ParticleSystemRenderer* renderer = system->getRenderer();
184       
185        const String rendererType = renderer->getType();
186        if(rendererType == "billboard")
187        {
188                BillboardSet* bbSet = ((BillboardParticleRenderer*) renderer)->getBillboardSet();
189                return bbSet;
190        }
191
192        if(rendererType == "sprite")
193        {
194                BillboardSet* bbSet = ((SpriteParticleRenderer*) renderer)->getSpriteSet();
195                return bbSet;
196        }
197       
198        OGRE_EXCEPT(0, "Unsupported particle renderable type", "OgreIlluminationManager::findRenderableInParticleSystem");
199
200        return NULL;
201}
202
203void OgreIlluminationManager::freeAllResources()
204{
205        std::list<SharedRuns*>::iterator srit = this->sharedRunRoots.begin();
206        std::list<SharedRuns*>::iterator sritend = this->sharedRunRoots.end();
207        while(srit != sritend)
208        {
209                (*srit)->freeAllResources();
210                srit++;
211        }
212        sharedRunRoots.clear();
213
214        this->sharedRunRoots.clear();
215
216        this->globalSharedRuns.freeAllResources();
217               
218        std::map<String, OgreSharedRuns*>::iterator lrit = this->perLightRuns.begin();
219        std::map<String, OgreSharedRuns*>::iterator lritend = this->perLightRuns.end();
220
221        while(lrit != lritend)
222        {
223                OgreSharedRuns* lightRuns = ((*lrit).second);
224                perLightRuns.erase(lrit);
225                lightRuns->freeAllResources();
226                delete lightRuns;
227                lrit++;
228        }
229        perLightRuns.clear();
230
231        std::map<enum GlobalTargetType, GlobalUseRenderTarget*>::iterator grtit = this->globalTargets.begin();
232        std::map<enum GlobalTargetType, GlobalUseRenderTarget*>::iterator grtitend = this->globalTargets.end();
233        while(grtit != grtitend)
234        {
235                GlobalUseRenderTarget* rt = (*grtit).second;
236                globalTargets.erase(grtit);
237                delete rt;
238                grtit++;
239        }
240
241        this->pathMapClusters.clear();
242        this->pathMapEntryPoints.clear();
243
244        //delete rendertechniquegroups and cloned materials
245        SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager()
246                                                                                                        ->getMovableObjectIterator("Entity");
247        while(it.hasMoreElements())
248        {
249                MovableObject* o = it.getNext();
250                Entity* e = (Entity*) o;
251               
252                if( e->getParentSceneNode() == 0 )//Entity not attached
253                break;
254
255                for(unsigned int s = 0; s < e->getNumSubEntities(); s++)
256                {
257                        SubEntity* sube = e->getSubEntity(s);
258
259                        Material* mat = sube->getMaterial().getPointer();
260
261                        for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
262                        {
263                                Technique* tech = mat->getTechnique(t);
264
265                                for(unsigned int p = 0; p< tech->getNumPasses(); p++)
266                                {
267                                        Pass* pass = tech->getPass(p);
268
269                                        std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
270                                        if( techniques.size() > 0)
271                                        {
272                                                OgreTechniqueGroup* tg =  (OgreTechniqueGroup*) sube->getRenderTechniqueGroup();
273                                                delete tg;
274                                                sube->setRenderTechniqueGroup(0);
275                                        }
276                                }
277                        }
278
279                        MaterialManager::getSingleton().remove(mat->getName());
280                }
281        }
282       
283        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
284        if(OgreRenderingRun::fullScreenQuad)
285                MeshManager::getSingleton().remove("PASS_FULLSCREENQUAD_MESH");
286                OgreRenderingRun::fullScreenQuad = 0;
287        if(OgreRenderingRun::fullScreenQuadEntity)
288                sm->destroyEntity(OgreRenderingRun::fullScreenQuadEntity);
289                OgreRenderingRun::fullScreenQuadEntity = 0;
290        if(OgreRenderingRun::pixelSprites)
291                sm->destroyBillboardSet(OgreRenderingRun::pixelSprites);
292                OgreRenderingRun::pixelSprites = 0;
293        if(OgreRenderingRun::fullscreenGrid)
294                sm->destroyEntity(OgreRenderingRun::fullscreenGrid);
295                OgreRenderingRun::fullscreenGrid = 0;   
296}
297
298void OgreIlluminationManager::initTechniques(Entity* e)
299{
300        if( e->getParentSceneNode() == 0 )//Entity not attached
301                return;
302
303        OgreSharedRuns* sharedruns = 0;
304       
305        for(unsigned int s = 0; s < e->getNumSubEntities(); s++)
306        {
307                SubEntity* sube = e->getSubEntity(s);
308
309                Material* mat = sube->getMaterial().getPointer();
310               
311                OgreRenderable* rend = 0;       
312                OgreTechniqueGroup* group = 0;
313
314                for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
315                {
316                        Technique* tech = mat->getTechnique(t);
317
318                        for(unsigned int p = 0; p< tech->getNumPasses(); p++)
319                        {
320                                Pass* pass = tech->getPass(p);
321
322                                std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
323                                if( techniques.size() > 0)
324                                {
325                                        if(rend == 0)
326                                        {
327                                                rend = new OgreRenderable(e, s);
328                                                group = new OgreTechniqueGroup();
329                                                sube->setRenderTechniqueGroup(group);                                                   
330                                               
331                                                if( sharedruns == 0)
332                                                {                                                                       
333                                                        sharedruns  = new OgreSharedRuns();
334                                                        addSharedRuns(sharedruns);
335                                                }
336
337                                                group->addSharedRun(sharedruns);
338                                                sharedruns->addRenderable(rend);
339                                                sharedruns->updateBounds();
340                                        }
341                                        String newMaterialName = mat->getName() + "_clone_" + rend->getName();
342                                        Material* newMat = mat->clone(newMaterialName).getPointer();
343                                        rend->setMaterialName(newMaterialName);
344                                        mat = sube->getMaterial().getPointer();
345                                        break;
346                                }
347                        }
348                }
349
350       
351                for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
352                {
353                        Technique* tech = mat->getTechnique(t);
354
355                        for(unsigned int p = 0; p< tech->getNumPasses(); p++)
356                        {
357                                Pass* pass = tech->getPass(p);
358
359                                std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
360                                std::vector<IllumTechniqueParams*>::iterator i = techniques.begin();
361                                std::vector<IllumTechniqueParams*>::iterator iend = techniques.end();
362                               
363                                while( i != iend)
364                                {
365                                        IllumTechniqueParams* params = *i;
366                                        createTechnique(params, pass, rend, sharedruns);
367
368                                        i++;
369                                }
370                        }
371                }
372        }
373
374               
375}
376
377
378void OgreIlluminationManager::initTechniques(BillboardSet* bbs, ParticleSystem* sys)
379{
380        if( bbs->getParentSceneNode() == 0 )//billboardset not attached
381                return;
382
383        OgreSharedRuns* sharedruns = 0;
384
385        Material* mat = bbs->getMaterial().getPointer();
386       
387        OgreRenderable* rend = 0;       
388        OgreTechniqueGroup* group = 0;
389
390        for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
391        {
392                Technique* tech = mat->getTechnique(t);
393
394                for(unsigned int p = 0; p< tech->getNumPasses(); p++)
395                {
396                        Pass* pass = tech->getPass(p);
397
398                        std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
399                        std::vector<IllumTechniqueParams*>::iterator i = techniques.begin();
400                        std::vector<IllumTechniqueParams*>::iterator iend = techniques.end();
401                       
402                        while( i != iend)
403                        {
404                                IllumTechniqueParams* params = *i;
405                               
406                                if(rend == 0)
407                                {
408                                        rend = new OgreRenderable(bbs, sys);
409                                        group = new OgreTechniqueGroup();
410                                        bbs->setRenderTechniqueGroup(group);                                                   
411                                       
412                                        if( sharedruns == 0)
413                                        {                                                                       
414                                                sharedruns  = new OgreSharedRuns();
415                                                addSharedRuns(sharedruns);
416                                        }
417
418                                        group->addSharedRun(sharedruns);
419                                        sharedruns->addRenderable(rend);
420                                        sharedruns->updateBounds();
421                                }
422                               
423                                createTechnique(params, pass, rend, sharedruns);
424
425                                i++;
426                        }
427                }
428        }
429                       
430}
431
432void OgreIlluminationManager::initTechniques()
433{
434        {
435                //Entities
436                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager()
437                                                                                                        ->getMovableObjectIterator("Entity");
438                while(it.hasMoreElements())
439                {
440                        MovableObject* o = it.getNext();
441                        Entity* e = (Entity*) o;
442               
443                        initTechniques(e);
444                }
445        }
446        {
447                //ParticleSystems
448                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager()
449                                                                                                        ->getMovableObjectIterator("ParticleSystem");
450                while(it.hasMoreElements())
451                {
452                        MovableObject* o = it.getNext();
453                        ParticleSystem* psys = (ParticleSystem*) o;
454                       
455                        try
456                        {
457                         BillboardSet* bbset = findRenderableInParticleSystem(psys);
458                         bbset->setMaterialName(psys->getMaterialName());
459                         initTechniques(bbset, psys);
460                        }
461                        catch( ... )
462                        {
463                                //unsupported particle renderer, skip init
464                        }
465                }
466        }
467}
468
469void OgreIlluminationManager::createTechnique(IllumTechniqueParams* params, Pass* pass, OgreRenderable* rend, OgreSharedRuns* sRuns)
470{
471        std::list<RenderTechniqueFactory*>::iterator it = techniqueFactories.begin();
472        std::list<RenderTechniqueFactory*>::iterator itend = techniqueFactories.end();
473
474        OgreTechniqueGroup* group = (OgreTechniqueGroup*) rend->getRenderable()->getRenderTechniqueGroup();     
475       
476                       
477        while(it != itend)
478        {
479                RenderTechniqueFactory* factory = *it;
480               
481               
482                if(factory->isType(params->getTypeName()))
483                {
484                       
485                        RenderTechnique* newTechnique = factory->createInstance(params,
486                                                                                                                                        pass,
487                                                                                                                                        rend,
488                                                                                                                                        group );
489
490                        group->addRenderTechnique(newTechnique);
491                       
492                }
493
494                it++;
495        }
496}
497void OgreIlluminationManager::preAllUpdates()
498{
499        std::vector<UpdateListener*>::iterator it = updateListeners.begin();
500        std::vector<UpdateListener*>::iterator itend = updateListeners.end();
501
502        while(it != itend)
503        {
504                UpdateListener* l = *it;
505                l->preAllUpdates();
506                it++;
507        }
508}
509
510void OgreIlluminationManager::postAllUpdates()
511{
512        std::vector<UpdateListener*>::iterator it = updateListeners.begin();
513        std::vector<UpdateListener*>::iterator itend = updateListeners.end();
514
515        while(it != itend)
516        {
517                UpdateListener* l = *it;
518                l->postAllUpdates();
519                it++;
520        }
521}
522
523void OgreIlluminationManager::update(unsigned long frameNumber, RenderTarget* rt)
524{
525
526        RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
527        SceneManager* sceneManager = Root::getSingleton()._getCurrentSceneManager();
528       
529        for(unsigned short i = 0; i<rt->getNumViewports();i++)
530        {
531                //find visible objects from the camera
532                RenderQueue* rq = sceneManager->getRenderQueue();
533                rq->clear();
534                RenderQueue::QueueGroupIterator groupIter = rq->_getQueueGroupIterator();
535                while (groupIter.hasMoreElements())
536                {
537                        RenderQueueGroup* g = groupIter.getNext();
538                        //g->addOrganisationMode(QueuedRenderableCollection::OM_SORT_ASCENDING);
539                        g->defaultOrganisationMode();
540                }
541               
542                //sceneManager->_findVisibleObjectsOC(rt->getViewport(i)->getCamera(), rt->getViewport(i), false, false, false);
543                sceneManager->_findVisibleObjects(rt->getViewport(i)->getCamera(), false);
544               
545                fillVisibleList(rq);   
546
547                if(joinRuns)
548                {
549                        int l = visibleObjects.size(); //debug         
550                        joinSharedRuns();
551                        int ll = sharedRunRoots.size(); //debug
552                }
553
554                //update precomputings                         
555                std::vector<const Renderable*>::iterator iter = visibleObjects.begin();
556                const std::vector<const Renderable*>::iterator iend = visibleObjects.end();
557
558                preAllUpdates();
559
560                while(iter != iend)
561                {
562                        const Renderable* rend = *iter;
563                        OgreTechniqueGroup* techniqueGroup = (OgreTechniqueGroup*) rend->getRenderTechniqueGroup();
564                        if(techniqueGroup != 0)
565                        {
566                                techniqueGroup->update(frameNumber);
567                        }
568                        iter++;
569                }
570
571                postAllUpdates();
572        }
573}
574
575void OgreIlluminationManager::sharedRunSplit(SharedRuns* old, SharedRuns* new1, SharedRuns* new2)
576{
577        sharedRunRoots.remove(old);
578        sharedRunRoots.push_back(new1);
579        sharedRunRoots.push_back(new2);
580}
581
582void OgreIlluminationManager::sharedRunJoin(SharedRuns* old1, SharedRuns* old2, SharedRuns* newsr)
583{
584        sharedRunRoots.remove(old1);
585        sharedRunRoots.remove(old2);
586        sharedRunRoots.push_back(newsr);
587}
588
589void OgreIlluminationManager::joinSharedRuns()
590{
591        std::list<SharedRuns*>::iterator it1 = sharedRunRoots.begin();
592        std::list<SharedRuns*>::iterator itend = sharedRunRoots.end();
593
594        bool again = false;
595
596        while(it1 != itend)
597        {
598                std::list<SharedRuns*>::iterator it2 = sharedRunRoots.begin();         
599               
600                while(it2 != itend)
601                {
602                        if( it1 != it2 && OgreSharedRuns::canJoin(*it1, *it2))
603                        {
604                                SharedRuns* newruns = (*it1)->joinRuns(*it2);
605                                sharedRunJoin(*it1, *it2, newruns);
606                                again = true;
607                                break;
608                        }
609                        it2++;
610                }
611
612                if(again)
613                        break;         
614
615                it1++;
616        }
617        if(again)
618        joinSharedRuns();
619
620}
621
622void OgreIlluminationManager::addSharedRuns(SharedRuns* runs)
623{
624        sharedRunRoots.push_back(runs);
625}
626
627void OgreIlluminationManager::getNearestCausticCasters(Vector3 position, std::vector<OgreSharedRuns*>* nearestcasters, unsigned int maxCount)
628{
629        sortfrom = position;
630        std::vector<OgreSharedRuns*> allcasters;
631        //fill casters
632        std::list<SharedRuns*>::iterator it = sharedRunRoots.begin();
633        std::list<SharedRuns*>::iterator itend = sharedRunRoots.end();
634        while(it != itend)
635        {
636                OgreSharedRuns* sr = (OgreSharedRuns*) (*it);
637               
638                sr->findSharedRootsForType(ILLUMRUN_CAUSTIC_CUBEMAP, allcasters);
639               
640                it++;
641        }
642
643        //sort
644        std::stable_sort(allcasters.begin(), allcasters.end(), sortFromVector());
645
646        for(unsigned int i = 0; i < maxCount && i < allcasters.size(); i++)
647        {
648                nearestcasters->push_back(allcasters.at(i));
649        }
650}
651
652void OgreIlluminationManager::createGlobalRun(RenderingRunType runType)
653{
654        switch(runType)
655        {
656                case ILLUMRUN_SCENE_CAMERA_DEPTH:
657                if(globalSharedRuns.getRun(ILLUMRUN_SCENE_CAMERA_DEPTH) == 0)
658                {
659                        OgreSceneCameraDepthRenderingRun* run = new OgreSceneCameraDepthRenderingRun
660                                (&globalSharedRuns, "ILLUMMODULE_SCENE_CAMERA_DEPTH", mainViewport);
661                        globalSharedRuns.addRun(ILLUMRUN_SCENE_CAMERA_DEPTH, run);
662                }
663                case ILLUMRUN_FOCUSING_MAP:
664                if(globalSharedRuns.getRun(ILLUMRUN_FOCUSING_MAP) == 0)
665                {
666                        OgreFocusingMapRenderingRun* run  = new OgreFocusingMapRenderingRun(
667                                "LIGHT_FOCUSING_MAP",                           
668                                Matrix4::IDENTITY,
669                                focusingMapSize
670                                );
671                        globalSharedRuns.addRun(ILLUMRUN_FOCUSING_MAP, run);
672                       
673                }
674                case ILLUMRUN_PHASE_TEXTURE:
675                if(globalSharedRuns.getRun(ILLUMRUN_PHASE_TEXTURE) == 0)
676                {
677                        OgrePhaseTextureRenderingRun* run  = new OgrePhaseTextureRenderingRun(
678                                "PHASE_TEXTURE",                               
679                                phaseTextureSize,
680                                phaseTextureSize,
681                                "Phase_HenyeyGreenStein");
682                        globalSharedRuns.addRun(ILLUMRUN_PHASE_TEXTURE, run);                   
683                }
684                break;
685                case ILLUMRUN_PM_ENTRYPOINTMAP:
686                if(globalSharedRuns.getRun(ILLUMRUN_PM_ENTRYPOINTMAP) == 0)
687                {
688                        OgrePMEntryPointMapRenderingRun* run  = new OgrePMEntryPointMapRenderingRun(
689                                "PM_ENTRYPOINT_MAP");
690                        globalSharedRuns.addRun(ILLUMRUN_PM_ENTRYPOINTMAP, run);                       
691                }
692                break;
693        }
694}
695
696void OgreIlluminationManager::savePhaseTextureToFile(String filename)
697{
698        OgrePhaseTextureRenderingRun* r = (OgrePhaseTextureRenderingRun*)
699                globalSharedRuns.getRun(ILLUMRUN_PHASE_TEXTURE)->asOgreRenderingRun();
700        Texture* t = (Texture*) TextureManager::getSingleton().getByName(r->getPhaseTextureName()).getPointer();
701       
702        t->getBuffer()->getRenderTarget()->writeContentsToFile(filename);       
703}
704
705RenderingRun* OgreIlluminationManager::getGlobalRun(RenderingRunType runType)
706{
707        if(globalSharedRuns.getRun(runType) == 0)
708                createGlobalRun(runType);
709        return globalSharedRuns.getRun(runType);
710}
711
712GlobalUseRenderTarget* OgreIlluminationManager::getGlobalTarget(GlobalTargetType type)
713{
714        std::map<GlobalTargetType, GlobalUseRenderTarget*>::iterator it = globalTargets.find(type);
715       
716        if( it != globalTargets.end())
717                return (*it).second;
718
719        return 0;
720}
721
722void OgreIlluminationManager::addGlobalTarget(GlobalTargetType type, GlobalUseRenderTarget* target)
723{
724        globalTargets[type] = target; 
725}
726
727void OgreIlluminationManager::updateGlobalRun(RenderingRunType runType, unsigned long frameNum)
728{
729        globalSharedRuns.updateRun(runType, frameNum);
730}
731
732void OgreIlluminationManager::createPerLightRun(String lightName, RenderingRunType runType)
733{
734        OgreSharedRuns* runs = 0;
735       
736        if(perLightRuns.find(lightName) == perLightRuns.end())
737        {///create sharedruns
738                OgreSharedRuns* newruns = new OgreSharedRuns();
739                perLightRuns[lightName] = newruns;
740        }
741
742        runs = perLightRuns[lightName];
743
744    switch(runType)
745        {
746                case ILLUMRUN_DEPTH_SHADOWMAP:
747                if(runs->getRun(ILLUMRUN_DEPTH_SHADOWMAP) == 0)
748                {
749                        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
750                        Light* light = sm->getLight(lightName);
751                        unsigned int res;
752                        String MaterialName;
753                        switch(light->getType())
754                        {
755                        case Light::LT_DIRECTIONAL:
756                                res = shadowMapSizeDirectional;
757                                MaterialName = shadowMapMaterialNameDirectional;
758                                break;
759                        case Light::LT_POINT:
760                                res = shadowMapSizePoint;
761                                MaterialName = shadowMapMaterialNamePoint;
762                                break;
763                        case Light::LT_SPOTLIGHT:
764                                res = shadowMapSizeSpot;
765                                MaterialName = shadowMapMaterialNameSpot;
766                                break;
767                        }
768
769                        OgreDepthShadowMapRenderingRun* run  = new OgreDepthShadowMapRenderingRun(
770                                runs,
771                                lightName + "DEPTH_SHADOW_MAP",
772                                light,
773                                res,
774                                res,
775                                MaterialName
776                                );
777                        runs->addRun(ILLUMRUN_DEPTH_SHADOWMAP, run);
778                       
779                }               
780                break;
781                case ILLUMRUN_PM_WEIGHTMAP:
782                if(runs->getRun(ILLUMRUN_PM_WEIGHTMAP) == 0)
783                {
784                        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
785                        OgrePMWeightComputeRenderingRun* run  = new OgrePMWeightComputeRenderingRun(                           
786                                lightName + "PM_WEIGHT_MAP",
787                                lightName);
788                        runs->addRun(ILLUMRUN_PM_WEIGHTMAP, run);                       
789                }               
790                break;
791        }       
792}
793
794RenderingRun* OgreIlluminationManager::getPerLightRun(String lightName, RenderingRunType runType)
795{
796        return perLightRuns[lightName]->getRun(runType);
797}
798
799void OgreIlluminationManager::updatePerLightRun(String lightName, RenderingRunType runType, unsigned long frameNum)
800{
801        perLightRuns[lightName]->updateRun(runType, frameNum);
802}
803
804void OgreIlluminationManager::setFireRenderTargetSize(int size)
805{
806        FireRenderTarget::targetsize = size;
807}
808
Note: See TracBrowser for help on using the repository browser.