Changeset 836 for GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp

Timestamp:

04/27/06 09:24:44 (18 years ago)

Author:

szirmay

Message:

 

File:

• GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp (modified) (4 diffs)

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreIlluminationManager.cpp

@@ -2 +2 @@
 #include "OgreParticleSystemRenderer.h"
 #include "OgreBillboardParticleRenderer.h"
+#include "SpriteParticleRenderer.h"
  
 
@@ -78 +79 @@
         visitor = new VisibleFinderVisitor(&visibleObjects);
         maxRad = 400;
+
+        //register rendertechnique factories
+        OgreColorCubeMapRenderTechniqueFactory* colorcube = new OgreColorCubeMapRenderTechniqueFactory();
+                addRenderTechniqueFactory(colorcube);
+        OgreDistanceCubeMapRenderTechniqueFactory* distcube = new OgreDistanceCubeMapRenderTechniqueFactory();
+                addRenderTechniqueFactory(distcube);
+        OgreConvoledCubeMapRenderTechniqueFactory* convcube = new OgreConvoledCubeMapRenderTechniqueFactory();
+                addRenderTechniqueFactory(convcube);
+        OgreCausticCasterRenderTechniqueFactory* caucast = new OgreCausticCasterRenderTechniqueFactory();
+                addRenderTechniqueFactory(caucast);
+        OgreCausticRecieverRenderTechniqueFactory* caurec = new OgreCausticRecieverRenderTechniqueFactory();
+                addRenderTechniqueFactory(caurec);
+        OgreDepthShadowRecieverRenderTechniqueFactory* dsrec = new OgreDepthShadowRecieverRenderTechniqueFactory();
+                addRenderTechniqueFactory(dsrec);
+        OgreSBBRenderTechniqueFactory* sbb = new OgreSBBRenderTechniqueFactory();
+                addRenderTechniqueFactory(sbb);
 }
 
@@ -119 +136 @@
 }
 
+BillboardSet* OgreIlluminationManager::findRenderableInParticleSystem(ParticleSystem* system)
+{
+        ParticleSystemRenderer* renderer = system->getRenderer();
+        
+        const String rendererType = renderer->getType();
+        if(rendererType == "billboard")
+        {
+                BillboardSet* bbSet = ((BillboardParticleRenderer*) renderer)->getBillboardSet();
+                return bbSet;
+        }
+
+        if(rendererType == "sprite")
+        {
+                BillboardSet* bbSet = ((SpriteParticleRenderer*) renderer)->getSpriteSet();
+                return bbSet;
+        }
+        
+        OGRE_EXCEPT(0, "Unsupported particle renderable type", "OgreIlluminationManager::findRenderableInParticleSystem");
+
+        return NULL;
+}
+
+
+void OgreIlluminationManager::initTechniques()
+{
+        {
+                //Entities
+                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager()
+                                                                                                        ->getMovableObjectIterator("Entity");
+                while(it.hasMoreElements())
+                {
+                        MovableObject* o = it.getNext();
+                        Entity* e = (Entity*) o;
+
+                        OgreSharedRuns* sharedruns = 0;
+                        
+                        for(unsigned int s = 0; s < e->getNumSubEntities(); s++)
+                        {
+                                SubEntity* sube = e->getSubEntity(s);
+
+                                Material* mat = sube->getMaterial().getPointer();
+                                
+                                OgreRenderable* rend = 0;       
+                                OgreTechniqueGroup* group = 0;
+                        
+                                for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
+                                {
+                                        Technique* tech = mat->getTechnique(t);
+
+                                        for(unsigned int p = 0; p< tech->getNumPasses(); p++)
+                                        {
+                                                Pass* pass = tech->getPass(p);
+
+                                                std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
+                                                std::vector<IllumTechniqueParams*>::iterator i = techniques.begin(); 
+                                                std::vector<IllumTechniqueParams*>::iterator iend = techniques.end();
+                                                
+                                                while( i != iend)
+                                                {
+                                                        IllumTechniqueParams* params = *i;
+                                                        
+                                                        if(rend == 0)
+                                                        {
+                                                                rend = new OgreRenderable(e, s);
+                                                                group = new OgreTechniqueGroup();
+                                                                sube->setRenderTechniqueGroup(group);                                                   
+                                                                
+                                                                if( sharedruns == 0)
+                                                                {                                                                       
+                                                                        sharedruns  = new OgreSharedRuns();
+                                                                        addSharedRuns(sharedruns);
+                                                                }
+
+                                                                group->addSharedRun(sharedruns);
+                                                                sharedruns->addRenderable(rend);
+                                                                sharedruns->updateBounds();
+                                                        }
+                                                        
+                                                        createTechnique(params, pass, rend, sharedruns); 
+
+                                                        i++;
+                                                }
+                                        }
+                                }
+                        }
+
+                }
+        }
+        {
+                //ParticleSystems
+                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager()
+                                                                                                        ->getMovableObjectIterator("ParticleSystem");
+                while(it.hasMoreElements())
+                {
+                        MovableObject* o = it.getNext();
+                        ParticleSystem* psys = (ParticleSystem*) o;
+
+                        BillboardSet* bbset = findRenderableInParticleSystem(psys);
+                        
+                        OgreTechniqueGroup* group = 0;                  
+                        OgreSharedRuns* sharedruns = 0;
+                        OgreRenderable* rend = 0;       
+                                                
+                        String matName = psys->getMaterialName();
+                        Material* mat = (Material*) MaterialManager::getSingleton().getByName(matName).getPointer();
+
+                        for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++)
+                        {
+                                Technique* tech = mat->getTechnique(t);
+
+                                for(unsigned int p = 0; p< tech->getNumPasses(); p++)
+                                {
+                                        Pass* pass = tech->getPass(p);
+
+                                        std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques();
+                                        std::vector<IllumTechniqueParams*>::iterator i = techniques.begin(); 
+                                        std::vector<IllumTechniqueParams*>::iterator iend = techniques.end();
+
+                                        
+                                        while( i != iend)
+                                        {
+                                                IllumTechniqueParams* params = *i;
+                                                
+                                                if(rend == 0)
+                                                {
+                                                        rend = new OgreRenderable(bbset);
+                                                        group = new OgreTechniqueGroup();
+                                                        bbset->setRenderTechniqueGroup(group);                                                  
+                                                        
+                                                        if( sharedruns == 0)
+                                                        {                                                                       
+                                                                sharedruns  = new OgreSharedRuns();
+                                                                addSharedRuns(sharedruns);
+                                                        }
+
+                                                        group->addSharedRun(sharedruns);
+                                                        sharedruns->addRenderable(rend);
+                                                        sharedruns->updateBounds();
+                                                }
+
+                                                createTechnique(params, pass, rend, sharedruns); 
+
+                                                i++;
+                                        }
+                                }
+                        }
+                        
+
+                }
+        }
+}
+
+void OgreIlluminationManager::createTechnique(IllumTechniqueParams* params, Pass* pass, OgreRenderable* rend, OgreSharedRuns* sRuns)
+{
+        std::list<RenderTechniqueFactory*>::iterator it = techniqueFactories.begin();
+        std::list<RenderTechniqueFactory*>::iterator itend = techniqueFactories.end();
+
+        OgreTechniqueGroup* group = (OgreTechniqueGroup*) rend->getRenderable()->getRenderTechniqueGroup();     
+        
+                        
+        while(it != itend)
+        {
+                RenderTechniqueFactory* factory = *it;
+                
+                
+                if(factory->isType(params->getTypeName()))
+                {
+                        
+                        RenderTechnique* newTechnique = factory->createInstance(params,
+                                                                                                                                        pass,
+                                                                                                                                        rend,
+                                                                                                                                        group );
+
+                        group->addRenderTechnique(newTechnique);
+                        
+                }
+
+                it++;
+        }
+}
+
 void OgreIlluminationManager::update(unsigned long frameNumber, RenderTarget* rt)
 {
@@ -141 +339 @@
                 fillVisibleList(rq);    
 
-                //int l = visibleObjects.size(); //debug
+                int l = visibleObjects.size(); //debug
                 
                 joinSharedRuns();
 
-                //int ll = sharedRunRoots.size(); //debug
+                int ll = sharedRunRoots.size(); //debug
 
                 //update precomputings