Ignore:
Timestamp:
04/27/06 09:24:44 (18 years ago)
Author:
szirmay
Message:
 
Location:
GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r790 r836  
    22#include "OgreParticleSystemRenderer.h" 
    33#include "OgreBillboardParticleRenderer.h" 
     4#include "SpriteParticleRenderer.h" 
    45  
    56 
    … …  
    7879        visitor = new VisibleFinderVisitor(&visibleObjects); 
    7980        maxRad = 400; 
     81 
     82        //register rendertechnique factories 
     83        OgreColorCubeMapRenderTechniqueFactory* colorcube = new OgreColorCubeMapRenderTechniqueFactory(); 
     84                addRenderTechniqueFactory(colorcube); 
     85        OgreDistanceCubeMapRenderTechniqueFactory* distcube = new OgreDistanceCubeMapRenderTechniqueFactory(); 
     86                addRenderTechniqueFactory(distcube); 
     87        OgreConvoledCubeMapRenderTechniqueFactory* convcube = new OgreConvoledCubeMapRenderTechniqueFactory(); 
     88                addRenderTechniqueFactory(convcube); 
     89        OgreCausticCasterRenderTechniqueFactory* caucast = new OgreCausticCasterRenderTechniqueFactory(); 
     90                addRenderTechniqueFactory(caucast); 
     91        OgreCausticRecieverRenderTechniqueFactory* caurec = new OgreCausticRecieverRenderTechniqueFactory(); 
     92                addRenderTechniqueFactory(caurec); 
     93        OgreDepthShadowRecieverRenderTechniqueFactory* dsrec = new OgreDepthShadowRecieverRenderTechniqueFactory(); 
     94                addRenderTechniqueFactory(dsrec); 
     95        OgreSBBRenderTechniqueFactory* sbb = new OgreSBBRenderTechniqueFactory(); 
     96                addRenderTechniqueFactory(sbb); 
    8097} 
    8198 
    … …  
    119136} 
    120137 
     138BillboardSet* OgreIlluminationManager::findRenderableInParticleSystem(ParticleSystem* system) 
     139{ 
     140        ParticleSystemRenderer* renderer = system->getRenderer(); 
     141         
     142        const String rendererType = renderer->getType(); 
     143        if(rendererType == "billboard") 
     144        { 
     145                BillboardSet* bbSet = ((BillboardParticleRenderer*) renderer)->getBillboardSet(); 
     146                return bbSet; 
     147        } 
     148 
     149        if(rendererType == "sprite") 
     150        { 
     151                BillboardSet* bbSet = ((SpriteParticleRenderer*) renderer)->getSpriteSet(); 
     152                return bbSet; 
     153        } 
     154         
     155        OGRE_EXCEPT(0, "Unsupported particle renderable type", "OgreIlluminationManager::findRenderableInParticleSystem"); 
     156 
     157        return NULL; 
     158} 
     159 
     160 
     161void OgreIlluminationManager::initTechniques() 
     162{ 
     163        { 
     164                //Entities 
     165                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager() 
     166                                                                                                        ->getMovableObjectIterator("Entity"); 
     167                while(it.hasMoreElements()) 
     168                { 
     169                        MovableObject* o = it.getNext(); 
     170                        Entity* e = (Entity*) o; 
     171 
     172                        OgreSharedRuns* sharedruns = 0; 
     173                         
     174                        for(unsigned int s = 0; s < e->getNumSubEntities(); s++) 
     175                        { 
     176                                SubEntity* sube = e->getSubEntity(s); 
     177 
     178                                Material* mat = sube->getMaterial().getPointer(); 
     179                                 
     180                                OgreRenderable* rend = 0;        
     181                                OgreTechniqueGroup* group = 0; 
     182                         
     183                                for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++) 
     184                                { 
     185                                        Technique* tech = mat->getTechnique(t); 
     186 
     187                                        for(unsigned int p = 0; p< tech->getNumPasses(); p++) 
     188                                        { 
     189                                                Pass* pass = tech->getPass(p); 
     190 
     191                                                std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques(); 
     192                                                std::vector<IllumTechniqueParams*>::iterator i = techniques.begin();  
     193                                                std::vector<IllumTechniqueParams*>::iterator iend = techniques.end(); 
     194                                                 
     195                                                while( i != iend) 
     196                                                { 
     197                                                        IllumTechniqueParams* params = *i; 
     198                                                         
     199                                                        if(rend == 0) 
     200                                                        { 
     201                                                                rend = new OgreRenderable(e, s); 
     202                                                                group = new OgreTechniqueGroup(); 
     203                                                                sube->setRenderTechniqueGroup(group);                                                    
     204                                                                 
     205                                                                if( sharedruns == 0) 
     206                                                                {                                                                        
     207                                                                        sharedruns  = new OgreSharedRuns(); 
     208                                                                        addSharedRuns(sharedruns); 
     209                                                                } 
     210 
     211                                                                group->addSharedRun(sharedruns); 
     212                                                                sharedruns->addRenderable(rend); 
     213                                                                sharedruns->updateBounds(); 
     214                                                        } 
     215                                                         
     216                                                        createTechnique(params, pass, rend, sharedruns);  
     217 
     218                                                        i++; 
     219                                                } 
     220                                        } 
     221                                } 
     222                        } 
     223 
     224                } 
     225        } 
     226        { 
     227                //ParticleSystems 
     228                SceneManager::MovableObjectIterator it = Root::getSingleton()._getCurrentSceneManager() 
     229                                                                                                        ->getMovableObjectIterator("ParticleSystem"); 
     230                while(it.hasMoreElements()) 
     231                { 
     232                        MovableObject* o = it.getNext(); 
     233                        ParticleSystem* psys = (ParticleSystem*) o; 
     234 
     235                        BillboardSet* bbset = findRenderableInParticleSystem(psys); 
     236                         
     237                        OgreTechniqueGroup* group = 0;                   
     238                        OgreSharedRuns* sharedruns = 0; 
     239                        OgreRenderable* rend = 0;        
     240                                                 
     241                        String matName = psys->getMaterialName(); 
     242                        Material* mat = (Material*) MaterialManager::getSingleton().getByName(matName).getPointer(); 
     243 
     244                        for(unsigned int t = 0 ; t < mat->getNumTechniques() ; t++) 
     245                        { 
     246                                Technique* tech = mat->getTechnique(t); 
     247 
     248                                for(unsigned int p = 0; p< tech->getNumPasses(); p++) 
     249                                { 
     250                                        Pass* pass = tech->getPass(p); 
     251 
     252                                        std::vector<IllumTechniqueParams*>& techniques = pass->getIllumTechniques(); 
     253                                        std::vector<IllumTechniqueParams*>::iterator i = techniques.begin();  
     254                                        std::vector<IllumTechniqueParams*>::iterator iend = techniques.end(); 
     255 
     256                                         
     257                                        while( i != iend) 
     258                                        { 
     259                                                IllumTechniqueParams* params = *i; 
     260                                                 
     261                                                if(rend == 0) 
     262                                                { 
     263                                                        rend = new OgreRenderable(bbset); 
     264                                                        group = new OgreTechniqueGroup(); 
     265                                                        bbset->setRenderTechniqueGroup(group);                                                   
     266                                                         
     267                                                        if( sharedruns == 0) 
     268                                                        {                                                                        
     269                                                                sharedruns  = new OgreSharedRuns(); 
     270                                                                addSharedRuns(sharedruns); 
     271                                                        } 
     272 
     273                                                        group->addSharedRun(sharedruns); 
     274                                                        sharedruns->addRenderable(rend); 
     275                                                        sharedruns->updateBounds(); 
     276                                                } 
     277 
     278                                                createTechnique(params, pass, rend, sharedruns);  
     279 
     280                                                i++; 
     281                                        } 
     282                                } 
     283                        } 
     284                         
     285 
     286                } 
     287        } 
     288} 
     289 
     290void OgreIlluminationManager::createTechnique(IllumTechniqueParams* params, Pass* pass, OgreRenderable* rend, OgreSharedRuns* sRuns) 
     291{ 
     292        std::list<RenderTechniqueFactory*>::iterator it = techniqueFactories.begin(); 
     293        std::list<RenderTechniqueFactory*>::iterator itend = techniqueFactories.end(); 
     294 
     295        OgreTechniqueGroup* group = (OgreTechniqueGroup*) rend->getRenderable()->getRenderTechniqueGroup();      
     296         
     297                         
     298        while(it != itend) 
     299        { 
     300                RenderTechniqueFactory* factory = *it; 
     301                 
     302                 
     303                if(factory->isType(params->getTypeName())) 
     304                { 
     305                         
     306                        RenderTechnique* newTechnique = factory->createInstance(params, 
     307                                                                                                                                        pass, 
     308                                                                                                                                        rend, 
     309                                                                                                                                        group ); 
     310 
     311                        group->addRenderTechnique(newTechnique); 
     312                         
     313                } 
     314 
     315                it++; 
     316        } 
     317} 
     318 
    121319void OgreIlluminationManager::update(unsigned long frameNumber, RenderTarget* rt) 
    122320{ 
    … …  
    141339                fillVisibleList(rq);     
    142340 
    143                 //int l = visibleObjects.size(); //debug 
     341                int l = visibleObjects.size(); //debug 
    144342                 
    145343                joinSharedRuns(); 
    146344 
    147                 //int ll = sharedRunRoots.size(); //debug 
     345                int ll = sharedRunRoots.size(); //debug 
    148346 
    149347                //update precomputings                           

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/OgreRenderTechnique.cpp

    r790 r836  
    11#include "OgreRenderTechnique.h" 
    22#include "OgreTechniqueGroup.h" 
     3#include "OgrePass.h" 
     4 
     5using namespace Ogre; 
    36 
    47OgreRenderTechnique::OgreRenderTechnique( 
    … …  
    1922} 
    2023 
     24void RenderTechniqueFactory::parseParams(IllumTechniqueParams* params) 
     25{ 
     26        NameValuePairList parameters = params->getParams(); 
     27 
     28        NameValuePairList::iterator it = parameters.begin(); 
     29        NameValuePairList::iterator itend = parameters.end(); 
     30 
     31        while(it != itend) 
     32        { 
     33                AttribParserList::iterator i = attributeParsers.find(it->first); 
     34 
     35                if(i == attributeParsers.end()) 
     36                { 
     37                         LogManager::getSingleton().logMessage("Unknown parameter type found while parsing illummodule technique params!"); 
     38                } 
     39                else 
     40                { 
     41                        i->second(it->second, this); 
     42                } 
     43 
     44                it++; 
     45        } 
     46} 
     47 

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

    r790 r836  
    115115                getCausticCubeMapTextureName(); 
    116116} 
     117 
     118 
     119///Technique Parsers 
     120namespace CausticCasterParsers 
     121{ 
     122        void parseStartFrame(String& params, RenderTechniqueFactory* factory) 
     123        { 
     124                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     125                f->startFrame =  StringConverter::parseUnsignedLong(params); 
     126        } 
     127        void parsePhotonMapUpdateInterval(String& params, RenderTechniqueFactory* factory) 
     128        { 
     129                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     130                f->photonMapUpdateInterval =  StringConverter::parseUnsignedLong(params); 
     131        } 
     132 
     133        void parsePhotonMapResolution(String& params, RenderTechniqueFactory* factory) 
     134        { 
     135                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     136                f->photonMapResolution =  StringConverter::parseUnsignedInt(params); 
     137        } 
     138 
     139        void parseCausticCubeMapResolution(String& params, RenderTechniqueFactory* factory) 
     140        { 
     141                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     142                f->causticCubeMapResolution =  StringConverter::parseUnsignedInt(params); 
     143        } 
     144 
     145        void parseTexID(String& params, RenderTechniqueFactory* factory) 
     146        { 
     147                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     148                f->photonMapTexID =  StringConverter::parseUnsignedInt(params); 
     149        } 
     150 
     151        void parseUseDistance(String& params, RenderTechniqueFactory* factory) 
     152        { 
     153                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     154                f->useDistance = StringConverter::parseBool(params); 
     155        } 
     156 
     157        void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory) 
     158        { 
     159                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     160                f->updateAllFace =  StringConverter::parseBool(params); 
     161        } 
     162 
     163        void parsePhotonMapMaterial(String& params, RenderTechniqueFactory* factory) 
     164        { 
     165                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     166                f->photonMapMaterialName =  params; 
     167        } 
     168 
     169        void parseCauMapMaterial(String& params, RenderTechniqueFactory* factory) 
     170        { 
     171                OgreCausticCasterRenderTechniqueFactory* f = (OgreCausticCasterRenderTechniqueFactory*) factory; 
     172                f->causticMapMaterialName =  params; 
     173        } 
     174} 
     175 
     176 
     177///Technique factory 
     178OgreCausticCasterRenderTechniqueFactory::OgreCausticCasterRenderTechniqueFactory() 
     179{ 
     180        typeName = "CausticCaster"; 
     181         
     182        using namespace CausticCasterParsers; 
     183 
     184        //register parsers 
     185        this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame)); 
     186        this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapUpdateInterval)); 
     187        this->attributeParsers.insert(AttribParserList::value_type("photonmap_resolution", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapResolution)); 
     188        this->attributeParsers.insert(AttribParserList::value_type("caustic_cubemap_resolution", (ILLUM_ATTRIBUTE_PARSER) parseCausticCubeMapResolution)); 
     189        this->attributeParsers.insert(AttribParserList::value_type("photon_map_material", (ILLUM_ATTRIBUTE_PARSER) parsePhotonMapMaterial)); 
     190        this->attributeParsers.insert(AttribParserList::value_type("caustic_map_material", (ILLUM_ATTRIBUTE_PARSER) parseCauMapMaterial)); 
     191        this->attributeParsers.insert(AttribParserList::value_type("photon_map_tex_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID)); 
     192        this->attributeParsers.insert(AttribParserList::value_type("distance_impostor", (ILLUM_ATTRIBUTE_PARSER) parseUseDistance)); 
     193        this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace)); 
     194 
     195} 
     196 
     197OgreRenderTechnique* OgreCausticCasterRenderTechniqueFactory::createInstance(  
     198                                                                                IllumTechniqueParams* params, 
     199                                                                                Pass* pass, 
     200                                                                                OgreRenderable* parentRenderable, 
     201                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     202{        
     203        //reset parameters 
     204        startFrame = 0; 
     205        photonMapUpdateInterval = 1; 
     206        photonMapResolution = 64; 
     207        causticCubeMapResolution = 128;  
     208        photonMapMaterialName = "GameTools/PhotonMapCaustic"; 
     209        causticMapMaterialName = "GameTools/Cau"; 
     210        photonMapTexID = 0; 
     211        useDistance = true; 
     212        updateAllFace = false; 
     213 
     214        parseParams(params); 
     215 
     216        OgreCausticCasterRenderTechnique* result = new OgreCausticCasterRenderTechnique( 
     217                                                                                                startFrame, 
     218                                                                                                photonMapUpdateInterval, 
     219                                                                                                photonMapResolution, 
     220                                                                                                causticCubeMapResolution, 
     221                                                                                                photonMapMaterialName, 
     222                                                                                                causticMapMaterialName, 
     223                                                                                                photonMapTexID, 
     224                                                                                                updateAllFace, 
     225                                                                                                useDistance,                                             
     226                                                                                                pass, 
     227                                                                                                parentRenderable, 
     228                                                                                                parentTechniqueGroup); 
     229         
     230        return result; 
     231} 

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

    r808 r836  
    113113} 
    114114 
     115 
     116namespace CausticRecieverParsers 
     117{ 
     118        ///Technique parsers 
     119        void parseMaxCasters(String& params, RenderTechniqueFactory* factory) 
     120        { 
     121                OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory; 
     122                f->maxcasters =  StringConverter::parseInt(params); 
     123        } 
     124 
     125        void parseVertexProgram(String& params, RenderTechniqueFactory* factory) 
     126        { 
     127                OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory; 
     128                f->causticVertexProgram =  params; 
     129        } 
     130 
     131        void parseFragmentProgram(String& params, RenderTechniqueFactory* factory) 
     132        { 
     133                OgreCausticRecieverRenderTechniqueFactory* f = (OgreCausticRecieverRenderTechniqueFactory*) factory; 
     134                f->causticFragmentProgram =  params; 
     135        } 
     136} 
     137OgreCausticRecieverRenderTechniqueFactory::OgreCausticRecieverRenderTechniqueFactory() 
     138{ 
     139        typeName = "CausticReciever"; 
     140 
     141        using namespace CausticRecieverParsers; 
     142        //register parsers 
     143        this->attributeParsers.insert(AttribParserList::value_type("max_caster_count", (ILLUM_ATTRIBUTE_PARSER) parseMaxCasters)); 
     144        this->attributeParsers.insert(AttribParserList::value_type("vertex_program_name", (ILLUM_ATTRIBUTE_PARSER) parseVertexProgram)); 
     145        this->attributeParsers.insert(AttribParserList::value_type("fragment_program_name", (ILLUM_ATTRIBUTE_PARSER) parseFragmentProgram)); 
     146} 
     147 
     148OgreRenderTechnique* OgreCausticRecieverRenderTechniqueFactory::createInstance(  
     149                                                                                IllumTechniqueParams* params, 
     150                                                                                Pass* pass, 
     151                                                                                OgreRenderable* parentRenderable, 
     152                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     153{        
     154        //reset parameters 
     155        maxcasters = 1; 
     156        causticVertexProgram = "GameTools/Caustic/DefaultVS"; 
     157        causticFragmentProgram = "GameTools/Caustic/DefaultPS"; 
     158 
     159        parseParams(params); 
     160 
     161        OgreCausticRecieverRenderTechnique* result = new OgreCausticRecieverRenderTechnique( 
     162                                                                                                maxcasters, 
     163                                                                                                causticVertexProgram, 
     164                                                                                                causticFragmentProgram, 
     165                                                                                                pass, 
     166                                                                                                parentRenderable, 
     167                                                                                                parentTechniqueGroup); 
     168 
     169        return result; 
     170} 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreConvolvedCubeMapRenderTechnique.cpp

    r790 r836  
    9191} 
    9292 
    93  
     93///Technique Parsers 
     94namespace ConvolvedCubemapParsers 
     95{ 
     96        void parseStartFrame(String& params, RenderTechniqueFactory* factory) 
     97        { 
     98                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     99                f->startFrame =  StringConverter::parseUnsignedLong(params); 
     100        } 
     101        void parseCubeMapUpdateInterval(String& params, RenderTechniqueFactory* factory) 
     102        { 
     103                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     104                f->cubeMapUpdateInterval =  StringConverter::parseUnsignedLong(params); 
     105        } 
     106 
     107        void parseCubeMapResolution(String& params, RenderTechniqueFactory* factory) 
     108        { 
     109                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     110                f->cubeMapResolution =  StringConverter::parseUnsignedInt(params); 
     111        } 
     112 
     113        void parseReducedCubeMapResolution(String& params, RenderTechniqueFactory* factory) 
     114        { 
     115                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     116                f->reducedCubeMapResolution =  StringConverter::parseUnsignedInt(params); 
     117        } 
     118 
     119        void parseTexID(String& params, RenderTechniqueFactory* factory) 
     120        { 
     121                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     122                f->texID =  StringConverter::parseUnsignedInt(params); 
     123        } 
     124 
     125        void parseUseDistCalc(String& params, RenderTechniqueFactory* factory) 
     126        { 
     127                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     128                // format: on/off tolerance(float) 
     129                StringVector vecparams = StringUtil::split(params, " \t"); 
     130 
     131                if(StringConverter::parseBool(vecparams[0]))//on 
     132                { 
     133                        f->useDistCalc = true; 
     134 
     135                        if(vecparams.size()>1) 
     136                        {                        
     137                                f->distTolerance = StringConverter::parseReal(vecparams[1]); 
     138                        } 
     139                } 
     140                else 
     141                { 
     142                        f->useDistCalc = false; 
     143                } 
     144        } 
     145 
     146        void parseUseFaceAngleCalc(String& params, RenderTechniqueFactory* factory) 
     147        { 
     148                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     149                // format: on/off tolerance(float) 
     150                StringVector vecparams = StringUtil::split(params, " \t"); 
     151 
     152                if(StringConverter::parseBool(vecparams[0]))//on 
     153                { 
     154                        f->useFaceAngleCalc = true; 
     155 
     156                        if(vecparams.size()>1) 
     157                        {                        
     158                                f->angleTolerance = StringConverter::parseReal(vecparams[1]); 
     159                        } 
     160                } 
     161                else 
     162                { 
     163                        f->useFaceAngleCalc = false; 
     164                } 
     165        } 
     166 
     167        void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory) 
     168        { 
     169                OgreConvoledCubeMapRenderTechniqueFactory* f = (OgreConvoledCubeMapRenderTechniqueFactory*) factory; 
     170                f->updateAllFace =  StringConverter::parseBool(params); 
     171        } 
     172} 
     173///Technique factory 
     174OgreConvoledCubeMapRenderTechniqueFactory::OgreConvoledCubeMapRenderTechniqueFactory() 
     175{ 
     176        typeName = "ReducedColorCubeMap"; 
     177 
     178        using namespace ConvolvedCubemapParsers; 
     179        //register parsers 
     180        this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame)); 
     181        this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapUpdateInterval)); 
     182        this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapResolution)); 
     183        this->attributeParsers.insert(AttribParserList::value_type("reduced_resolution", (ILLUM_ATTRIBUTE_PARSER) parseReducedCubeMapResolution)); 
     184        this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID)); 
     185        this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc)); 
     186        this->attributeParsers.insert(AttribParserList::value_type("face_angle_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseFaceAngleCalc)); 
     187        this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace)); 
     188 
     189} 
     190 
     191OgreRenderTechnique* OgreConvoledCubeMapRenderTechniqueFactory::createInstance(  
     192                                                                                IllumTechniqueParams* params, 
     193                                                                                Pass* pass, 
     194                                                                                OgreRenderable* parentRenderable, 
     195                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     196{        
     197        //reset parameters 
     198        startFrame = 0; 
     199        cubeMapUpdateInterval = 1; 
     200        cubeMapResolution = 256; 
     201        reducedCubeMapResolution = 8;    
     202        texID = 0; 
     203        useDistCalc = 1; 
     204        useFaceAngleCalc = false; 
     205        distTolerance = 2.0; 
     206        angleTolerance = 2.0; 
     207        updateAllFace = false; 
     208 
     209        parseParams(params); 
     210 
     211        OgreConvolvedCubeMapRenderTechnique* result = new OgreConvolvedCubeMapRenderTechnique( 
     212                                                                                                startFrame, 
     213                                                                                                cubeMapUpdateInterval, 
     214                                                                                                cubeMapResolution, 
     215                                                                                                reducedCubeMapResolution, 
     216                                                                                                texID, 
     217                                                                                                useDistCalc, 
     218                                                                                                useFaceAngleCalc, 
     219                                                                                                distTolerance, 
     220                                                                                                angleTolerance, 
     221                                                                                                updateAllFace, 
     222                                                                                                pass, 
     223                                                                                                parentRenderable, 
     224                                                                                                parentTechniqueGroup); 
     225 
     226        return result; 
     227} 
     228 
     229 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreCubeMapRenderTechnique.cpp

    r790 r836  
    6666} 
    6767 
     68///Technique Parsers 
     69namespace ColorCubemapParsers 
     70{ 
     71        void parseStartFrame(String& params, RenderTechniqueFactory* factory) 
     72        { 
     73                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     74                f->startFrame =  StringConverter::parseUnsignedLong(params); 
     75        } 
     76        void parseCubeMapUpdateInterval(String& params, RenderTechniqueFactory* factory) 
     77        { 
     78                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     79                f->cubeMapUpdateInterval =  StringConverter::parseUnsignedLong(params); 
     80        } 
    6881 
     82        void parseCubeMapResolution(String& params, RenderTechniqueFactory* factory) 
     83        { 
     84                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     85                f->cubeMapResolution =  StringConverter::parseUnsignedInt(params); 
     86        } 
     87 
     88        void parseTexID(String& params, RenderTechniqueFactory* factory) 
     89        { 
     90                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     91                f->texID =  StringConverter::parseUnsignedInt(params); 
     92        } 
     93 
     94        void parseUseDistCalc(String& params, RenderTechniqueFactory* factory) 
     95        { 
     96                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     97                // format: on/off tolerance(float) 
     98                StringVector vecparams = StringUtil::split(params, " \t"); 
     99 
     100                if(StringConverter::parseBool(vecparams[0]))//on 
     101                { 
     102                        f->useDistCalc = true; 
     103 
     104                        if(vecparams.size()>1) 
     105                        {                        
     106                                f->distTolerance = StringConverter::parseReal(vecparams[1]); 
     107                        } 
     108                } 
     109                else 
     110                { 
     111                        f->useDistCalc = false; 
     112                } 
     113        } 
     114 
     115        void parseUseFaceAngleCalc(String& params, RenderTechniqueFactory* factory) 
     116        { 
     117                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     118                // format: on/off tolerance(float) 
     119                StringVector vecparams = StringUtil::split(params, " \t"); 
     120 
     121                if(StringConverter::parseBool(vecparams[0]))//on 
     122                { 
     123                        f->useFaceAngleCalc = true; 
     124 
     125                        if(vecparams.size()>1) 
     126                        {                        
     127                                f->angleTolerance = StringConverter::parseReal(vecparams[1]); 
     128                        } 
     129                } 
     130                else 
     131                { 
     132                        f->useFaceAngleCalc = false; 
     133                } 
     134        } 
     135 
     136        void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory) 
     137        { 
     138                OgreColorCubeMapRenderTechniqueFactory* f = (OgreColorCubeMapRenderTechniqueFactory*) factory; 
     139                f->updateAllFace =  StringConverter::parseBool(params); 
     140        } 
     141} 
     142///Technique factory 
     143OgreColorCubeMapRenderTechniqueFactory::OgreColorCubeMapRenderTechniqueFactory() 
     144{ 
     145        typeName = "ColorCubeMap"; 
     146 
     147        using namespace ColorCubemapParsers; 
     148 
     149        //register parsers 
     150        this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame)); 
     151        this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapUpdateInterval)); 
     152        this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapResolution)); 
     153        this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID)); 
     154        this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc)); 
     155        this->attributeParsers.insert(AttribParserList::value_type("face_angle_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseFaceAngleCalc)); 
     156        this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace)); 
     157 
     158} 
     159 
     160OgreRenderTechnique* OgreColorCubeMapRenderTechniqueFactory::createInstance(  
     161                                                                                IllumTechniqueParams* params, 
     162                                                                                Pass* pass, 
     163                                                                                OgreRenderable* parentRenderable, 
     164                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     165{        
     166        //reset parameters 
     167        startFrame = 0; 
     168        cubeMapUpdateInterval = 1; 
     169        cubeMapResolution = 256;                                                                                                 
     170        texID = 0; 
     171        useDistCalc = 1; 
     172        useFaceAngleCalc = false; 
     173        distTolerance = 2.0; 
     174        angleTolerance = 2.0; 
     175        updateAllFace = false; 
     176 
     177        parseParams(params); 
     178 
     179        OgreCubeMapRenderTechnique* result = new OgreCubeMapRenderTechnique( 
     180                                                                                                startFrame, 
     181                                                                                                cubeMapUpdateInterval, 
     182                                                                                                cubeMapResolution, 
     183                                                                                                texID, 
     184                                                                                                useDistCalc, 
     185                                                                                                useFaceAngleCalc, 
     186                                                                                                distTolerance, 
     187                                                                                                angleTolerance, 
     188                                                                                                updateAllFace, 
     189                                                                                                pass, 
     190                                                                                                parentRenderable, 
     191                                                                                                parentTechniqueGroup); 
     192         
     193        return result; 
     194} 
     195 

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

    r790 r836  
    108108} 
    109109 
     110 
     111///Technique parsers 
     112namespace DepthShadowRecieverParsers 
     113{ 
     114        void parseMaxLights(String& params, RenderTechniqueFactory* factory) 
     115        { 
     116                OgreDepthShadowRecieverRenderTechniqueFactory* f = (OgreDepthShadowRecieverRenderTechniqueFactory*) factory; 
     117                f->maxlights =  StringConverter::parseInt(params); 
     118        } 
     119 
     120        void parseVertexProgram(String& params, RenderTechniqueFactory* factory) 
     121        { 
     122                OgreDepthShadowRecieverRenderTechniqueFactory* f = (OgreDepthShadowRecieverRenderTechniqueFactory*) factory; 
     123                f->shadowVertexProgram =  params; 
     124        } 
     125 
     126        void parseFragmentProgram(String& params, RenderTechniqueFactory* factory) 
     127        { 
     128                OgreDepthShadowRecieverRenderTechniqueFactory* f = (OgreDepthShadowRecieverRenderTechniqueFactory*) factory; 
     129                f->shadowFragmentProgram =  params; 
     130        } 
     131} 
     132 
     133OgreDepthShadowRecieverRenderTechniqueFactory::OgreDepthShadowRecieverRenderTechniqueFactory() 
     134{ 
     135        typeName = "DepthShadowReciever"; 
     136 
     137        using namespace DepthShadowRecieverParsers; 
     138        //register parsers 
     139        this->attributeParsers.insert(AttribParserList::value_type("max_light_count", (ILLUM_ATTRIBUTE_PARSER) parseMaxLights)); 
     140        this->attributeParsers.insert(AttribParserList::value_type("vertex_program_name", (ILLUM_ATTRIBUTE_PARSER) parseVertexProgram)); 
     141        this->attributeParsers.insert(AttribParserList::value_type("fragment_program_name", (ILLUM_ATTRIBUTE_PARSER) parseFragmentProgram)); 
     142} 
     143 
     144OgreRenderTechnique* OgreDepthShadowRecieverRenderTechniqueFactory::createInstance(  
     145                                                                                IllumTechniqueParams* params, 
     146                                                                                Pass* pass, 
     147                                                                                OgreRenderable* parentRenderable, 
     148                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     149{        
     150        //reset parameters 
     151        maxlights = 1; 
     152        shadowVertexProgram = "GameTools/ShadowMap/ShadowVS"; 
     153        shadowFragmentProgram = "GameTools/ShadowMap/ShadowPS"; 
     154 
     155        parseParams(params); 
     156 
     157        OgreDepthShadowRecieverRenderTechnique* result = new OgreDepthShadowRecieverRenderTechnique( 
     158                                                                                                maxlights, 
     159                                                                                                shadowVertexProgram, 
     160                                                                                                shadowFragmentProgram, 
     161                                                                                                pass, 
     162                                                                                                parentRenderable, 
     163                                                                                                parentTechniqueGroup);   
     164 
     165        return result; 
     166} 
     167 

  • GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreDistanceCubeMapRenderTechnique.cpp

    r790 r836  
    6868 
    6969 
     70///Technique Parsers 
     71namespace CausticCubemapParsers 
     72{ 
     73        void parseStartFrame(String& params, RenderTechniqueFactory* factory) 
     74        { 
     75                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     76                f->startFrame =  StringConverter::parseUnsignedLong(params); 
     77        } 
     78        void parseCubeMapUpdateInterval(String& params, RenderTechniqueFactory* factory) 
     79        { 
     80                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     81                f->cubeMapUpdateInterval =  StringConverter::parseUnsignedLong(params); 
     82        } 
     83 
     84        void parseCubeMapResolution(String& params, RenderTechniqueFactory* factory) 
     85        { 
     86                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     87                f->cubeMapResolution =  StringConverter::parseUnsignedInt(params); 
     88        } 
     89 
     90        void parseTexID(String& params, RenderTechniqueFactory* factory) 
     91        { 
     92                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     93                f->texID =  StringConverter::parseUnsignedInt(params); 
     94        } 
     95 
     96        void parseUseDistCalc(String& params, RenderTechniqueFactory* factory) 
     97        { 
     98                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     99                // format: on/off tolerance(float) 
     100                StringVector vecparams = StringUtil::split(params, " \t"); 
     101 
     102                if(StringConverter::parseBool(vecparams[0]))//on 
     103                { 
     104                        f->useDistCalc = true; 
     105 
     106                        if(vecparams.size()>1) 
     107                        {                        
     108                                f->distTolerance = StringConverter::parseReal(vecparams[1]); 
     109                        } 
     110                } 
     111                else 
     112                { 
     113                        f->useDistCalc = false; 
     114                } 
     115        } 
     116 
     117        void parseUseFaceAngleCalc(String& params, RenderTechniqueFactory* factory) 
     118        { 
     119                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     120                // format: on/off tolerance(float) 
     121                StringVector vecparams = StringUtil::split(params, " \t"); 
     122 
     123                if(StringConverter::parseBool(vecparams[0]))//on 
     124                { 
     125                        f->useFaceAngleCalc = true; 
     126 
     127                        if(vecparams.size()>1) 
     128                        {                        
     129                                f->angleTolerance = StringConverter::parseReal(vecparams[1]); 
     130                        } 
     131                } 
     132                else 
     133                { 
     134                        f->useFaceAngleCalc = false; 
     135                } 
     136        } 
     137 
     138        void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory) 
     139        { 
     140                OgreDistanceCubeMapRenderTechniqueFactory* f = (OgreDistanceCubeMapRenderTechniqueFactory*) factory; 
     141                f->updateAllFace =  StringConverter::parseBool(params); 
     142        } 
     143} 
     144///Technique factory 
     145OgreDistanceCubeMapRenderTechniqueFactory::OgreDistanceCubeMapRenderTechniqueFactory() 
     146{ 
     147        typeName = "DistanceCubeMap"; 
     148 
     149        using namespace CausticCubemapParsers; 
     150        //register parsers 
     151        this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame)); 
     152        this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapUpdateInterval)); 
     153        this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapResolution)); 
     154        this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID)); 
     155        this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc)); 
     156        this->attributeParsers.insert(AttribParserList::value_type("face_angle_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseFaceAngleCalc)); 
     157        this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace)); 
     158 
     159} 
     160 
     161OgreRenderTechnique* OgreDistanceCubeMapRenderTechniqueFactory::createInstance(  
     162                                                                                IllumTechniqueParams* params, 
     163                                                                                Pass* pass, 
     164                                                                                OgreRenderable* parentRenderable, 
     165                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     166{        
     167        //reset parameters 
     168        startFrame = 0; 
     169        cubeMapUpdateInterval = 1; 
     170        cubeMapResolution = 256;                                                                                                 
     171        texID = 1; 
     172        useDistCalc = 1; 
     173        useFaceAngleCalc = false; 
     174        distTolerance = 2.0; 
     175        angleTolerance = 2.0; 
     176        updateAllFace = false; 
     177 
     178        parseParams(params); 
     179 
     180        OgreDistanceCubeMapRenderTechnique* result = new OgreDistanceCubeMapRenderTechnique( 
     181                                                                                                startFrame, 
     182                                                                                                cubeMapUpdateInterval, 
     183                                                                                                cubeMapResolution, 
     184                                                                                                texID, 
     185                                                                                                useDistCalc, 
     186                                                                                                useFaceAngleCalc, 
     187                                                                                                distTolerance, 
     188                                                                                                angleTolerance, 
     189                                                                                                updateAllFace, 
     190                                                                                                pass, 
     191                                                                                                parentRenderable, 
     192                                                                                                parentTechniqueGroup); 
     193 
     194        return result; 
     195} 
     196 

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

    r790 r836  
    3333} 
    3434 
     35namespace SBBParsers 
     36{ 
     37///Technique parsers 
     38        void parseDepthTexID(String& params, RenderTechniqueFactory* factory) 
     39        { 
     40                OgreSBBRenderTechniqueFactory* f = (OgreSBBRenderTechniqueFactory*) factory; 
     41                f->depthTexID =  StringConverter::parseUnsignedInt(params); 
     42        } 
     43} 
     44 
     45OgreSBBRenderTechniqueFactory::OgreSBBRenderTechniqueFactory() 
     46{ 
     47        typeName = "SphericalBillboard"; 
     48         
     49        using namespace SBBParsers; 
     50         
     51        //register parsers 
     52        this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseDepthTexID)); 
     53} 
     54 
     55OgreRenderTechnique* OgreSBBRenderTechniqueFactory::createInstance(  
     56                                                                                IllumTechniqueParams* params, 
     57                                                                                Pass* pass, 
     58                                                                                OgreRenderable* parentRenderable, 
     59                                                                                OgreTechniqueGroup* parentTechniqueGroup) 
     60{        
     61        //reset parameters 
     62        depthTexID = 0; 
     63         
     64        parseParams(params); 
     65 
     66        OgreSBBRenderTechnique* result = new OgreSBBRenderTechnique( 
     67                                                                                                depthTexID, 
     68                                                                                                pass, 
     69                                                                                                parentRenderable, 
     70                                                                                                parentTechniqueGroup); 
     71        return result; 
     72} 
     73 
     74 
     75 
Note: See TracChangeset for help on using the changeset viewer.