Changeset 1055 for GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src

Timestamp:

06/26/06 09:52:08 (19 years ago)

Author:

szirmay

Message:

 

Location:

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src

Files:

• Másolat - OgreRenderingRun.cpp (added)
• OgreIlluminationManager.cpp (modified) (12 diffs)
• OgreRenderable.cpp (modified) (2 diffs)
• OgreRenderingRun.cpp (modified) (2 diffs)
• OgreSharedRuns.cpp (modified) (4 diffs)
• RenderTechniques/OgreCausticCasterRenderTechnique.cpp (modified) (7 diffs)
• RenderTechniques/OgreCausticRecieverRenderTechnique.cpp (modified) (3 diffs)
• RenderTechniques/OgreDepthShadowRecieverRenderTechnique.cpp (modified) (2 diffs)
• RenderTechniques/OgreFireRenderTechnique.cpp (added)
• RenderTechniques/OgreHierarchicalParticleSystemTechnique.cpp (added)
• RenderTechniques/OgreSBBRenderTechnique.cpp (modified) (1 diff)
• RenderingRuns/OgreCausticCubeMapRenderingRun.cpp (modified) (1 diff)
• RenderingRuns/OgreChildParticlesystemRenderingRun.cpp (added)
• RenderingRuns/OgreDepthShadowMapRenderingRun.cpp (modified) (7 diffs)
• RenderingRuns/OgrePhotonMapRenderingRun.cpp (modified) (2 diffs)
• RenderingRuns/OgreReducedCubeMapRenderingRun.cpp (modified) (2 diffs)

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

@@ -79 +79 @@
         visitor = new VisibleFinderVisitor(&visibleObjects);
         maxRad = 400;
+        
+        for(int i = 0; i < RUN_TYPE_COUNT; i++)
+        {
+                maxRads[(RenderingRunType)i] = (float) maxRad;
+        }
 
         //register rendertechnique factories
@@ -95 +100 @@
         OgreSBBRenderTechniqueFactory* sbb = new OgreSBBRenderTechniqueFactory();
                 addRenderTechniqueFactory(sbb);
+        OgreFireRenderTechniqueFactory* fire = new OgreFireRenderTechniqueFactory();
+                addRenderTechniqueFactory(fire);
 }
 
@@ -160 +167 @@
 void OgreIlluminationManager::initTechniques(Entity* e)
 {
+        if( e->getParentSceneNode() == 0 )//Entity not attached
+                return;
+
         OgreSharedRuns* sharedruns = 0;
         
@@ -215 +225 @@
 }
 
+
+void OgreIlluminationManager::initTechniques(BillboardSet* bbs, ParticleSystem* sys)
+{
+        if( bbs->getParentSceneNode() == 0 )//billboardset not attached
+                return;
+
+        OgreSharedRuns* sharedruns = 0; 
+
+        Material* mat = bbs->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(bbs, sys);
+                                        group = new OgreTechniqueGroup();
+                                        bbs->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::initTechniques()
 {
@@ -225 +290 @@
                         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++;
-                                                }
-                                        }
-                                }
-                        }
-
-                */
+                
                         initTechniques(e);
                 }
@@ -290 +302 @@
                         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++)
+                        
+                        try
                         {
-                                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++;
-                                        }
-                                }
+                         BillboardSet* bbset = findRenderableInParticleSystem(psys);
+                         bbset->setMaterialName(psys->getMaterialName());
+                         initTechniques(bbset, psys);
                         }
-                        
-
+                        catch( ... )
+                        {
+                                //unsupported particle renderer, skip init
+                        }
                 }
         }
@@ -371 +342 @@
                 }
 
+                it++;
+        }
+}
+void OgreIlluminationManager::preAllUpdates()
+{
+        std::vector<UpdateListener*>::iterator it = updateListeners.begin();
+        std::vector<UpdateListener*>::iterator itend = updateListeners.end();
+
+        while(it != itend)
+        {
+                UpdateListener* l = *it;
+                l->preAllUpdates();
+                it++;
+        }
+}
+
+void OgreIlluminationManager::postAllUpdates()
+{
+        std::vector<UpdateListener*>::iterator it = updateListeners.begin();
+        std::vector<UpdateListener*>::iterator itend = updateListeners.end();
+
+        while(it != itend)
+        {
+                UpdateListener* l = *it;
+                l->postAllUpdates();
                 it++;
         }
@@ -406 +402 @@
                 std::vector<const Renderable*>::iterator iter = visibleObjects.begin();
                 const std::vector<const Renderable*>::iterator iend = visibleObjects.end();
+
+                preAllUpdates();
 
                 while(iter != iend)
@@ -418 +416 @@
                 }
 
+                postAllUpdates();
+
         }
 }
@@ -448 +448 @@
                 while(it2 != itend)
                 {
-                        if( *it1 != *it2 && OgreSharedRuns::canJoin(*it1, *it2))
+                        if( it1 != it2 && OgreSharedRuns::canJoin(*it1, *it2))
                         {
                                 SharedRuns* newruns = (*it1)->joinRuns(*it2);
@@ -513 +513 @@
 }
 
+
+
 RenderingRun* OgreIlluminationManager::getGlobalRun(RenderingRunType runType)
 {
         return globalSharedRuns.getRun(runType);
+}
+
+GlobalUseRenderTarget* OgreIlluminationManager::getGlobalTarget(GlobalTargetType type)
+{
+        std::map<GlobalTargetType, GlobalUseRenderTarget*>::iterator it = globalTargets.find(type);
+        
+        if( it != globalTargets.end())
+                return (*it).second;
+
+        return 0;
+}
+
+void OgreIlluminationManager::addGlobalTarget(GlobalTargetType type, GlobalUseRenderTarget* target)
+{
+        globalTargets[type] = target;  
 }
 
@@ -545 +562 @@
                                 lightName + "DEPTH_SHADOW_MAP",
                                 sm->getLight(lightName),
-                                2048, //TODO
-                                2048, //TODO
+                                512, //TODO
+                                512, //TODO
                                 "GameTools/ShadowMapDepth" //TODO
                                 );

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

@@ -29 +29 @@
 }
 
-OgreRenderable::OgreRenderable(BillboardSet* billboardset)
+OgreRenderable::OgreRenderable(BillboardSet* billboardset, ParticleSystem* sys)
 {
         renderableType = OGRE_RENDERABLETYPE_BILLBOARDSET;
         billboardSetRenderable = billboardset;
+        parentParticleSystem = sys;
         updateBounds();
         name = billboardset->getName();
@@ -47 +48 @@
         {
          case OGRE_RENDERABLETYPE_SUBENTITY: 
-                 subEntityRenderable->setVisible(visible);
+//               subEntityRenderable->setVisible(visible);
+                 parentEntity->setVisible(visible);
                  break;
          case OGRE_RENDERABLETYPE_BILLBOARDSET:
-                 billboardSetRenderable->setVisible(visible);
+                 if(parentParticleSystem != 0)
+                         parentParticleSystem->setVisible(visible);
+                 else
+                         billboardSetRenderable->setVisible(visible);
                  break;
           default:

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

@@ -214 +214 @@
                 int resolutionX = width;
                 int resolutionY = height;
-                pixelSprites = new SpriteSet(spriteSetName, resolutionX * resolutionY, true);
+                pixelSprites = new BillboardSet(spriteSetName, resolutionX * resolutionY, true);
                 pixelSprites->setBillboardsInWorldSpace(true);
-                pixelSprites->setCullIndividually(false);               
-                pixelSprites->setDefaultDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);
+                pixelSprites->setCullIndividually(false);
+                pixelSprites->setPointRenderingEnabled(true);
+                //pixelSprites->setDefaultDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);
                 pixelSprites->beginBillboards();
                 for(int i = 0; i < resolutionX; i++)
@@ -223 +224 @@
                         for(int j = 0; j < resolutionY; j++)
                         {                               
-                                Billboard bb;
-
-                                bb.setPosition(
-                                                                ( (float)i + 0.5 )/ (float) resolutionX, //position x
-                                                                ( (float)j + 0.5 )/ (float) resolutionY, //position y
-                                                                0);                                                                                                     //position z                                    
+                                Billboard bb( Vector3(
+                                                                                ( (float)i + 0.5 )/ (float) resolutionX, //position x
+                                                                                ( (float)j + 0.5 )/ (float) resolutionY, //position y
+                                                                                0),
+                                                          pixelSprites);
+                                bb.setDimensions(1.0 / (float) resolutionX, 1.0 / resolutionY);                         
                                 pixelSprites->injectBillboard(bb);                              
                         }

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

@@ -1 +1 @@
 #include "..\include\OgreSharedRuns.h"
 #include "OgreIlluminationManager.h"
+
+void OgreSharedRuns::runChanged(RenderingRunType runType, RenderingRun* run)
+{
+        if(child1 != 0) child1->runChanged(runType, run);
+        if(child2 != 0) child2->runChanged(runType, run);
+        
+        std::vector<TechniqueGroup*>::iterator it = childTechniqueGroups.begin();
+        std::vector<TechniqueGroup*>::iterator itend = childTechniqueGroups.end();
+
+        while(it != itend)
+        {
+                (*it)->runChanged(runType, run);
+                it++;
+        }
+}
+
+void OgreSharedRuns::runUpdated(RenderingRunType runType, RenderingRun* run)
+{
+        if(child1 != 0) child1->runUpdated(runType, run);
+        if(child2 != 0) child2->runUpdated(runType, run);
+        
+
+        std::vector<TechniqueGroup*>::iterator it = childTechniqueGroups.begin();
+        std::vector<TechniqueGroup*>::iterator itend = childTechniqueGroups.end();
+
+        while(it != itend)
+        {
+                (*it)->runUpdated(runType, run);
+                it++;
+        }
+}
 
 RenderingRun* OgreSharedRuns::getRun(RenderingRunType runType)
@@ -108 +139 @@
         {
                 runChanged( (*it).first, (*it).second );
-                runChanged( (*it).first, (*it).second );
                 it++;
         }
@@ -135 +165 @@
 }
 
-bool OgreSharedRuns::haveCommonRuns(SharedRuns* r1, SharedRuns* r2)
+bool OgreSharedRuns::haveCommonRuns(SharedRuns* r1, SharedRuns* r2, std::vector<RenderingRunType>& commonruns)
 {
         OgreSharedRuns* run1 = (OgreSharedRuns*) r1;
@@ -143 +173 @@
         std::map<RenderingRunType, RenderingRun*>::iterator itend = run1->sharedRuns.end();
 
+        bool returnvalue = false;
         while(it != itend)
         {
                 if( run2->hasOwnRun((*it).first))
-                        return true;
-                it++;
-        }
-
-        return false;
+                {
+                        if(                      run1->getRun((*it).first)->asOgreRenderingRun()->
+                                canJoin( run2->getRun((*it).first)->asOgreRenderingRun() )
+                           )
+                        {
+                                returnvalue = true;
+                                commonruns.push_back((*it).first);
+                        }
+                }
+                it++;
+        }
+
+        return returnvalue;
 }
 
 bool OgreSharedRuns::canJoin(SharedRuns* r1, SharedRuns* r2)
 {
+        std::vector<RenderingRunType> commonruns;
         //check if they have common resources
-        if(!haveCommonRuns(r1, r2))
+        if(!haveCommonRuns(r1, r2, commonruns))
                 return false;
-
+        
+        float MAXRAD = 0xffffffff;
         //check bounds
-        float MAXRAD = OgreIlluminationManager::getSingleton().getMaxJoinRadius();
+        for(int i = 0; i < commonruns.size(); i++)
+        {
+         
+         RenderingRunType type = commonruns.at(i);
+         float marad = OgreIlluminationManager::getSingleton().getMaxJoinRadius(type);
+         
+         MAXRAD = std::min(MAXRAD, marad);
+        }
 
         Sphere bSphere1 = ((OgreSharedRuns*) r1)->getBoundingSphere();

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreCausticCasterRenderTechnique.cpp

@@ -15 +15 @@
                                                                                                                                 bool updateAllFace,
                                                                                                                                 bool useDistance,
+                                                                                                                                float attenuation,
                                                                                                                                 Pass* pass,
                                                                                                                                 OgreRenderable* parentRenderable,
@@ -22 +23 @@
                                                         RenderTechnique( parentRenderable, parentTechniqueGroup)
 {       
+        this->attenuation = attenuation;
         this->photonMapMaterialName = photonMapMaterialName;
         
@@ -103 +105 @@
                                                                                                 causticMapMaterialName,
                                                                                                 photonMapTexID,
-                                                                                                updateAllFace
+                                                                                                updateAllFace,
+                                                                                                attenuation
                                                                                                 );
 
@@ -185 +188 @@
                 OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
                 f->causticMapMaterialName =  params;
+        }
+
+        void parseAttenuation(String& params, RenderTechniqueFactory* factory)
+        {
+                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory;
+                f->attenuation =  StringConverter::parseReal(params);
         }
 }
@@ -206 +215 @@
         this->attributeParsers.insert(AttribParserList::value_type("distance_impostor", (ILLUM_ATTRIBUTE_PARSER) parseUseDistance));
         this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace));
-
+        this->attributeParsers.insert(AttribParserList::value_type("attenuation", (ILLUM_ATTRIBUTE_PARSER) parseAttenuation));
+        
 }
 
@@ -216 +226 @@
 {       
         //reset parameters
+        attenuation = 1.0;
         startFrame = 1;
         photonMapUpdateInterval = 1;
@@ -237 +248 @@
                                                                                                 photonMapTexID,
                                                                                                 updateAllFace,
-                                                                                                useDistance,                                            
+                                                                                                useDistance,
+                                                                                                attenuation,
                                                                                                 pass,
                                                                                                 parentRenderable,

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreCausticRecieverRenderTechnique.cpp

@@ -106 +106 @@
                         Fparams->setNamedConstant("cubeMapCameraPosition",
                                 causticCasters.at(i)->getRootPosition(ILLUMRUN_CAUSTIC_CUBEMAP));
+                        Fparams->setNamedConstant("attenuation", cauCubeRun->getAttenuation());
                         passes.at(i)->setActive(true);
                 }       
@@ -135 +136 @@
                 f->causticFragmentProgram =  params;
         }
+        
 }
 OgreCausticRecieverRenderTechniqueFactory::OgreCausticRecieverRenderTechniqueFactory()
@@ -145 +147 @@
         this->attributeParsers.insert(AttribParserList::value_type("vertex_program_name", (ILLUM_ATTRIBUTE_PARSER) parseVertexProgram));
         this->attributeParsers.insert(AttribParserList::value_type("fragment_program_name", (ILLUM_ATTRIBUTE_PARSER) parseFragmentProgram));
+        
 }
 

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreDepthShadowRecieverRenderTechnique.cpp

@@ -52 +52 @@
                 TextureUnitState* st = newpass->createTextureUnitState();               
                 st->setTextureFiltering(TFO_BILINEAR);          
+                st = newpass->createTextureUnitState();         
+                st->setTextureFiltering(TFO_BILINEAR);          
 
                 newpass->setSceneBlending(SBT_MODULATE);
-                newpass->setDepthBias(5);
+                newpass->setDepthBias(7);
                 techn->movePass(lastpass, index);                       
         }
@@ -93 +95 @@
                                         
                         passes.at(i)->getTextureUnitState(0)->setTextureName(
-                                depthRun->getDepthMapTextureName());
+                                depthRun->getDepthMapTextureName(0));
+                        passes.at(i)->getTextureUnitState(1)->setTextureName(
+                                depthRun->getDepthMapTextureName(1));
 
                         //TODO: set matrices
                         GpuProgramParametersSharedPtr fpParams = passes.at(i)->getFragmentProgramParameters();
-                        fpParams->setNamedConstant("lightView", depthRun->getLightViewMatrix()); 
-                        fpParams->setNamedConstant("lightViewProj", depthRun->getLightViewProjMatrix()); 
+                        fpParams->setNamedConstant("lightView", depthRun->getLightViewMatrix(0)); 
+                        fpParams->setNamedConstant("lightViewProj", depthRun->getLightViewProjMatrix(0)); 
+                        fpParams->setNamedConstant("lightView2", depthRun->getLightViewMatrix(1)); 
+                        fpParams->setNamedConstant("lightViewProj2", depthRun->getLightViewProjMatrix(1)); 
                         
                         passes.at(i)->setActive(true);

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreSBBRenderTechnique.cpp

@@ -13 +13 @@
 {
         this->depthTexID = depthTexID;
-        OgreIlluminationManager::getSingleton().createGlobalRun(ILLUMRUN_SCENE_CAMERA_DEPTH);
         
+        OgreIlluminationManager::getSingleton().createGlobalRun(ILLUMRUN_SCENE_CAMERA_DEPTH);   
         
         OgreSceneCameraDepthRenderingRun* run = (OgreSceneCameraDepthRenderingRun*)
                 OgreIlluminationManager::getSingleton().getGlobalRun(ILLUMRUN_SCENE_CAMERA_DEPTH)->asOgreRenderingRun();
+
+        Root::getSingleton().addFrameListener(this);
+        OgreIlluminationManager::getSingleton().getMainViewport()
+                                                                ->getTarget()->addListener(this);
+        OgreIlluminationManager::getSingleton().addUpdateListener(this);
         
         pass->getTextureUnitState(depthTexID)->setTextureName(run->getDepthTextureName());
         
+}
+
+void OgreSBBRenderTechnique::preAllUpdates()
+{
+        lastVisibility = parentOgreRenderable->isVisible();
+        parentOgreRenderable->setVisible(false);
+}
+void  OgreSBBRenderTechnique::preRenderTargetUpdate (const RenderTargetEvent &evt)
+{
+        //parentOgreRenderable->setVisible(lastVisibility);     
+}
+void  OgreSBBRenderTechnique::postRenderTargetUpdate (const RenderTargetEvent &evt)
+{
+        //parentOgreRenderable->setVisible(false);
+}
+bool  OgreSBBRenderTechnique::frameEnded (const FrameEvent &evt)
+{
+        
+        return true;
+}
+void  OgreSBBRenderTechnique::postAllUpdates()
+{
+        parentOgreRenderable->setVisible(lastVisibility);       
 }
 

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreCausticCubeMapRenderingRun.cpp

@@ -12 +12 @@
                                                                                                                    String materialName,
                                                                                                                    unsigned char photonMapTexId,
-                                                                                                                   bool updateAllFace)
+                                                                                                                   bool updateAllFace,
+                                                                                                                   float attenuation)
                 :CausticCubeMapRenderingRun(startFrame, updateInterval, resolution, updateAllFace)
                 , OgreRenderingRun(startFrame, updateInterval)
                 , RenderingRun(startFrame, updateInterval)
 {
+        this->attenuation = attenuation;
         this->sharedRuns = sharedRuns;
         this->name = name;

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreDepthShadowMapRenderingRun.cpp

@@ -1 +1 @@
 #include "OgreDepthShadowMapRenderingRun.h"
+#include "OgreIlluminationManager.h"
 
 
@@ -15 +16 @@
         this->light = light;
         this->sharedRuns = sharedRuns;
-        this->name = name;      
+        names[0] = name + "1";  
+        names[1] = name + "2";  
         this->materialName = materialName;
 
@@ -23 +25 @@
 void OgreDepthShadowMapRenderingRun::createDepthMap()
 {
-        TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(name, 
-                                                                                                                                                "default",
-                                                                                                                                                TEX_TYPE_2D,
-                                                                                                                                                resolutionX,
-                                                                                                                                                resolutionY,
-                                                                                                                                                0,
-                                                                                                                                                0,
-                                                                                                                                                PF_FLOAT16_RGBA,
-                                                                                                                                                TU_RENDERTARGET);
-         depthMapTexture = texPtr.getPointer();
-         depthMapCamera = Root::getSingleton()._getCurrentSceneManager()->createCamera(name + "_CAMERA");
-         //add viewport to rendertarget
-         HardwarePixelBuffer* hpb = (depthMapTexture->getBuffer()).getPointer();
-         RenderTarget* rt = hpb->getRenderTarget();
-         Viewport* v = rt->addViewport(depthMapCamera);
-         v->setOverlaysEnabled(false);
-         rt->setAutoUpdated(false);
+        for(int i = 0; i < 2; i++)
+        {
+                TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(names[i], 
+                                                                                                                                                        "default",
+                                                                                                                                                        TEX_TYPE_2D,
+                                                                                                                                                        resolutionX,
+                                                                                                                                                        resolutionY,
+                                                                                                                                                        0,
+                                                                                                                                                        0,
+                                                                                                                                                        PF_FLOAT16_RGBA,
+                                                                                                                                                        TU_RENDERTARGET);
+                depthMapTextures[i] = texPtr.getPointer();
+                depthMapCameras[i] = Root::getSingleton()._getCurrentSceneManager()->createCamera(names[i] + "_CAMERA");
+                //add viewport to rendertarget
+                HardwarePixelBuffer* hpb = (depthMapTextures[i]->getBuffer()).getPointer();
+                RenderTarget* rt = hpb->getRenderTarget();
+                Viewport* v = rt->addViewport(depthMapCameras[i]);
+                v->setOverlaysEnabled(false);
+                rt->setAutoUpdated(false);
+        }
 }
 
@@ -64 +69 @@
 void OgreDepthShadowMapRenderingRun::updateDepthMap()
 {
-        setMaterialForVisibles(materialName, depthMapCamera, true);
-        
-        RenderTarget* rt = depthMapTexture->getBuffer().getPointer()->getRenderTarget();
-        
-        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
-        
-        rt->update();   
-
-        //rt->writeContentsToFile("shadowmap.dds");
-
+        setMaterialForVisibles(materialName, depthMapCameras[0], true); 
+        RenderTarget* rt = depthMapTextures[0]->getBuffer().getPointer()->getRenderTarget();    
+        rt->update();
+        //restoreMaterials();
+        //rt->writeContentsToFile("shadowmap1.dds");
+        
+        //setMaterialForVisibles(materialName, depthMapCameras[1], true);       
+        RenderTarget* rt2 = depthMapTextures[1]->getBuffer().getPointer()->getRenderTarget();
+        rt2->update();
         restoreMaterials();
+        //rt2->writeContentsToFile("shadowmap2.dds");
+
+        
+}
+
+void setnear()
+{
+
 }
 
@@ -84 +96 @@
                 if(light->getType() == Light::LT_DIRECTIONAL)
                 {
-                        Vector3 dir = light->getDirection();
-                        depthMapCamera->setDirection( dir );
+                        //Vector3 dir = light->getDirection();
+                        Vector3 dir = Vector3(0,-1,-1);
+                        Vector3 pos;
+                        float size;
+                        
+                        Camera* viewcam = OgreIlluminationManager::getSingleton().getMainCamera();
+                        
+                        //Matrix4 camView = viewcam->getViewMatrix();
+                        //Matrix4 camViewI = camView.inverse();
+                        //const AxisAlignedBox bt = viewcam->getWorldBoundingBox(true);
+                        //AxisAlignedBox b = bt;
+                        //b.transform(camView);
+                        //SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
+                        //SceneNode* node = sm->getRootSceneNode();
+                        //const AxisAlignedBox bs(-35,-5 ,-75, 35, 15, 75);// = node->_getWorldAABB();
+                        //AxisAlignedBox intersection = b.intersection(bs);
+                        //pos = intersection.getCenter();                       
+                        //size = (intersection.getMaximum() - pos).length();
+                        
                         //TODO: where to put light
-                        depthMapCamera->setPosition( - dir * 100000 );
-                        depthMapCamera->setProjectionType(PT_ORTHOGRAPHIC);             
+                        size = 30;
+                        pos = Vector3(0,0,0);
+                        
+                        depthMapCameras[0]->setDirection( dir );
+                        pos = pos - size * dir;                 
+                        depthMapCameras[0]->setPosition( pos );
+                        depthMapCameras[0]->setProjectionType(PT_ORTHOGRAPHIC);         
+                        Matrix4 fproj;
+                        fproj = depthMapCameras[0]->getProjectionMatrix();
+                        fproj = Matrix4::IDENTITY;
+                        fproj.setScale(Vector3(1.0/20, 1.0/25, -1.0/100));
+                        //fproj.setTrans(Vector3(0,0,-50));
+                        depthMapCameras[0]->setCustomProjectionMatrix(true,fproj);
+
+
+                        //camera2
+                        dir.normalise();
+                        size = abs(dir.crossProduct(Vector3(0,0,1)).length() * 2);
+                        Vector3 viewDir = viewcam->getDirection();
+                        float y = viewDir.y;
+                        viewDir.y = std::min(0.0f, y);
+                        viewDir.normalise();
+                        Vector3 down(0,-1,0);
+                        float cosA = viewDir.dotProduct(down);
+                        Vector3 newDir = viewDir + down * 0.4; 
+                        newDir.normalise();
+                        pos = viewcam->getPosition();
+                        size *= pos.y * 0.5 + 1;
+                        pos += newDir * viewcam->getPosition().y 
+                                                                                        / newDir.dotProduct(down);
+                        //pos.y = 0;
+                        
+                        
+                        
+                        depthMapCameras[1]->setDirection( dir );
+                        pos = pos - 30 * dir;                   
+                        depthMapCameras[1]->setPosition( pos );
+                        depthMapCameras[1]->setProjectionType(PT_ORTHOGRAPHIC);         
+                        Matrix4 fproj2;
+                        fproj2 = depthMapCameras[1]->getProjectionMatrix();
+                        fproj2 = Matrix4::IDENTITY;
+                        fproj2.setScale(Vector3(1.0/size, 1.0/size, -1.0/100));
+                        //fproj.setTrans(Vector3(0,0,-50));
+                        depthMapCameras[1]->setCustomProjectionMatrix(true,fproj2);
+                        
+                        
+/*LISPSM
+                        Vector3 viewdir = viewcam->getDirection();
+                        Vector3 lightdir = dir;
+
+                        float dotProd = viewdir.dotProduct(lightdir);
+                        float sinGamma;
+                        sinGamma = sqrt(1.0-dotProd*dotProd);
+                        g_fsinGamma = sinGamma;
+
+                        Vector3 newVdir = viewdir;
+                        Matrix4 proj;*/
+
                 }
                 else if(light->getType() == Light::LT_SPOTLIGHT)
                 {
-                        Vector3 dir = light->getDirection();
+        /*              Vector3 dir = light->getDirection();
                         depthMapCamera->setDirection( dir );
                         Vector3 pos = light->getParentNode()->getWorldPosition();
                         depthMapCamera->setPosition(pos);
                         depthMapCamera->setProjectionType(PT_PERSPECTIVE);              
-                        depthMapCamera->setFOVy(light->getSpotlightOuterAngle());
+                        depthMapCamera->setFOVy(light->getSpotlightOuterAngle());*/
                 }
                 else//point light
                 {
-                        Vector3 pos = light->getParentNode()->getWorldPosition();
+        /*              Vector3 pos = light->getParentNode()->getWorldPosition();
                         Vector3 dir = -pos;
                         depthMapCamera->setDirection( dir );
@@ -111 +196 @@
         
                         //OGRE_EXCEPT(0, "NOT implemented for Pointlight", "OgreDepthShadowMapRenderingRun::refreshLight");
-                        
+                */      
                         /*Vector3 pos = light->getParentNode()->getWorldPosition();
                         Vector3 dir = -pos;
@@ -123 +208 @@
 }
 
-Matrix4 OgreDepthShadowMapRenderingRun::getLightViewMatrix()
-{
-        return depthMapCamera->getViewMatrix();
-}
-
-Matrix4 OgreDepthShadowMapRenderingRun::getLightViewProjMatrix()
-{
-        return depthMapCamera->getProjectionMatrix() * depthMapCamera->getViewMatrix();
-}
-
+Matrix4 OgreDepthShadowMapRenderingRun::getLightViewMatrix(int i)
+{
+        return depthMapCameras[i]->getViewMatrix();
+}
+
+Matrix4 OgreDepthShadowMapRenderingRun::getLightViewProjMatrix(int i)
+{
+        return depthMapCameras[i]->getProjectionMatrix() * depthMapCameras[i]->getViewMatrix();
+}
+

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgrePhotonMapRenderingRun.cpp

@@ -103 +103 @@
                         Vector3 dir = light->getDirection();
                         photonMapCamera->setDirection( dir );
-                        photonMapCamera->setPosition( sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP) - dir );
-                        photonMapCamera->setProjectionType(PT_ORTHOGRAPHIC);            
+                        Real r = sharedRuns->getRootBoundingSphere(ILLUMRUN_PHOTONMAP).getRadius();
+                        photonMapCamera->setPosition( sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP) - dir * r);
+                        photonMapCamera->setProjectionType(PT_ORTHOGRAPHIC);
+                        Matrix4 proj;
+                        proj = Matrix4::IDENTITY;
+                        proj.setScale(Vector3(1.0/r, 1.0/r, -1.0/r));
+                        proj.setTrans(Vector3(0,0,-1));
+                        photonMapCamera->setCustomProjectionMatrix(true,proj);
                 }
                 else
-                {
-                        photonMapCamera->setFarClipDistance(100000);
-                        photonMapCamera->setNearClipDistance(0.1);
+                {                       
                         Vector3 pos = light->getParentSceneNode()->getPosition();
                         Vector3 dir = sharedRuns->getRootPosition(ILLUMRUN_PHOTONMAP) - pos;
@@ -125 +129 @@
                         photonMapCamera->setFOVy(2*alfa);
                         photonMapCamera->setDirection( dir );
+
+                        photonMapCamera->setNearClipDistance(std::max(0.01f, d - r));
+                        photonMapCamera->setFarClipDistance(r + d);     
                 }
         }

GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreReducedCubeMapRenderingRun.cpp

@@ -27 +27 @@
 {
         reducedCubemapTexture = createCubeRenderTexture(name, 
-                                                                                                sharedRuns->getRootPosition(ILLUMRUN_REDUCED_CUBEMAP),
+                                                                                                sharedRuns->getRootPosition(),
                                                                                                 resolution,
                                                                                                 PF_FLOAT16_RGBA);
@@ -42 +42 @@
 //      mat->getTechnique(0)->getPass(0)->setFragmentProgramParameters(fpParams); 
         
+        renderFullscreenQuad("GameTools/CubeMap/Reduce", rt);
+        
         //rt->writeContentsToFile("cubbereduce" + StringConverter::toString(facenum) + ".dds");
-
-        renderFullscreenQuad("GameTools/CubeMap/Reduce", rt);
 }