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

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