Ignore:
Timestamp:
05/12/07 14:21:03 (17 years ago)
Author:
szirmay
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2355 r2366  
    1818                                                                                                SceneBlendFactor passBlendingSRC, 
    1919                                                                                                SceneBlendFactor passBlendingDEST, 
     20                                                                                                bool createNewPasses, 
     21                                                                                                int startTextureUnitID,                                                  
    2022                                                                                                Pass* pass, 
    2123                                                                                                OgreRenderable* parentRenderable, 
    … …  
    3840        this->WorldParamName = WorldParamName; 
    3941        this->WorldViewProjParamName = WorldViewProjParamName; 
     42        this->createNewPasses = createNewPasses; 
     43        this->startTextureUnitID = startTextureUnitID; 
     44                                                         
     45        if(createNewPasses) 
     46        { 
     47                //insert new passes 
     48                Ogre::Technique* techn = pass->getParent(); 
     49                Technique::PassIterator it = techn->getPassIterator(); 
    4050                 
    41         //insert new passes 
    42         Ogre::Technique* techn = pass->getParent(); 
    43         Technique::PassIterator it = techn->getPassIterator(); 
    44          
    45         int index = 0; 
    46         while(it.hasMoreElements()) 
    47         { 
    48                 if( it.getNext() == pass) 
    49                         break; 
     51                int index = 0; 
     52                while(it.hasMoreElements()) 
     53                { 
     54                        if( it.getNext() == pass) 
     55                                break; 
     56                        index++; 
     57                        it.moveNext(); 
     58                } 
     59                 
    5060                index++; 
    51                 it.moveNext(); 
    52         } 
    53          
    54         index++; 
    55         for(int i = 0; i < maxlights; i++) 
    56         { 
    57                 int lastpass = techn->getNumPasses(); 
    58                 Pass* newpass = techn->createPass(); 
    59                 passes.push_back(newpass); 
    60                  
    61                 TextureUnitState* st = newpass->createTextureUnitState();                
    62                 st->setTextureFiltering(TFO_NONE); 
    63                 st->setTextureAddressingMode(TextureUnitState::TAM_BORDER); 
    64                 st->setTextureBorderColour(ColourValue::White); 
    65  
    66                 newpass->setSceneBlending(passBlendingSRC, passBlendingDEST); 
    67                  
    68                 newpass->setDepthBias(1); 
    69                 techn->movePass(lastpass, index);                        
    70         } 
    71          
     61                for(int i = 0; i < maxlights; i++) 
     62                { 
     63                        int lastpass = techn->getNumPasses(); 
     64                        Pass* newpass = techn->createPass(); 
     65                        passes.push_back(newpass); 
     66                         
     67                        TextureUnitState* st = newpass->createTextureUnitState();                
     68                        st->setTextureFiltering(TFO_NONE); 
     69                        st->setTextureAddressingMode(TextureUnitState::TAM_BORDER); 
     70                        st->setTextureBorderColour(ColourValue::White); 
     71 
     72                        newpass->setSceneBlending(passBlendingSRC, passBlendingDEST); 
     73                         
     74                        newpass->setDepthBias(1); 
     75                        techn->movePass(lastpass, index);                        
     76                } 
     77        }        
    7278} 
    7379 
    … …  
    8793        //fill passes 
    8894        unsigned int l = 0; 
    89         for(unsigned int i = 0; i < passes.size(); i++) 
     95        for(unsigned int i = 0; i < maxlights; i++) 
    9096        { 
    9197                while(lights.size() != l && !lights.at(l)->getCastShadows()) 
    … …  
    108114                                                                                                                .getPerLightRun(lights.at(l)->getName(),  
    109115                                                                                                                ILLUMRUN_DEPTH_SHADOWMAP)->asOgreRenderingRun(); 
    110                                                  
    111                                 passes.at(i)->getTextureUnitState(0)->setTextureName( 
     116                                 
     117                                Pass* passToSet = this->pass; 
     118                                int textureUnit = startTextureUnitID + i; 
     119                                if(createNewPasses) 
     120                                { 
     121                                        passToSet = passes.at(i); 
     122                                        passToSet->setActive(true); 
     123                                        textureUnit = 0; 
     124                                        passes.at(i)->setActive(true); 
     125                                } 
     126                                passToSet->getTextureUnitState(textureUnit)->setTextureName( 
    112127                                        depthRun->getDepthMapTextureName()); 
    113128                         
    114                                 //TODO: ask programs from illummanager 
    115                                 passes.at(i)->setVertexProgram(shadowVertexProgram); 
    116                                 passes.at(i)->setFragmentProgram(shadowFragmentProgram); 
     129                                if(createNewPasses) 
     130                                { 
     131                                        //TODO: ask programs from illummanager 
     132                                        passes.at(i)->setVertexProgram(shadowVertexProgram); 
     133                                        passes.at(i)->setFragmentProgram(shadowFragmentProgram); 
     134                                } 
    117135                 
    118                                 GpuProgramParametersSharedPtr fpParams = passes.at(i)->getFragmentProgramParameters(); 
    119                                 GpuProgramParametersSharedPtr vpParams = passes.at(i)->getVertexProgramParameters(); 
    120  
    121                  
    122                                 vpParams->setNamedAutoConstant(WorldViewProjParamName, 
    123                                                                         GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);         
    124                                 vpParams->setNamedAutoConstant(WorldParamName, 
    125                                                                         GpuProgramParameters::ACT_WORLD_MATRIX); 
     136                                GpuProgramParametersSharedPtr fpParams = passToSet->getFragmentProgramParameters(); 
     137                                GpuProgramParametersSharedPtr vpParams = passToSet->getVertexProgramParameters(); 
     138 
     139                                String LightViewProjParamName = lightViewProjParamName; 
     140                                String LightViewParamName = lightViewParamName; 
     141                                String LightFarPlaneParamName = lightFarPlaneParamName; 
     142                                if(!createNewPasses) 
     143                                { 
     144                                        LightViewProjParamName += String("[") + StringConverter::toString(i) + String("]"); 
     145                                        LightViewParamName += String("[") + StringConverter::toString(i) + String("]"); 
     146                                        LightFarPlaneParamName += String("[") + StringConverter::toString(i) + String("]"); 
     147                                } 
     148                                else 
     149                                { 
     150                                        vpParams->setNamedAutoConstant(WorldViewProjParamName, 
     151                                                                                GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);         
     152                                        vpParams->setNamedAutoConstant(WorldParamName, 
     153                                                                                GpuProgramParameters::ACT_WORLD_MATRIX); 
     154                                } 
    126155                 
    127156                                if(setLightViewProjMatrix) 
    128                                         vpParams->setNamedConstant(lightViewProjParamName, depthRun->getLightViewProjMatrix()); 
     157                                { 
     158                                        if(createNewPasses) 
     159                                        vpParams->setNamedConstant(LightViewProjParamName, depthRun->getLightViewProjMatrix()); 
     160                                        else 
     161                                        fpParams->setNamedConstant(LightViewProjParamName, depthRun->getLightViewProjMatrix()); 
     162                                } 
    129163                                if(setLightViewMatrix) 
    130                                         vpParams->setNamedConstant(lightViewParamName, depthRun->getLightViewMatrix()); 
     164                                { 
     165                                        if(createNewPasses) 
     166                                        vpParams->setNamedConstant(LightViewParamName, depthRun->getLightViewMatrix()); 
     167                                        else 
     168                                        fpParams->setNamedConstant(LightViewParamName, depthRun->getLightViewMatrix()); 
     169                                } 
    131170                                if(setLightProjFarPlane) 
    132                                         fpParams->setNamedConstant(lightFarPlaneParamName, depthRun->getLightFarPlane()); 
    133                                  
    134                                  
    135                                 passes.at(i)->setActive(true); 
    136                          
     171                                { 
     172                                        if(createNewPasses) 
     173                                        fpParams->setNamedConstant(LightFarPlaneParamName, depthRun->getLightFarPlane()); 
     174                                        else 
     175                                        fpParams->setNamedConstant(LightFarPlaneParamName, depthRun->getLightFarPlane()); 
     176                                } 
    137177                }        
    138                 else 
     178                else if(createNewPasses) 
    139179                        passes.at(i)->setActive(false); 
    140180 
    … …  
    282322                  f->passBlendingDEST = convertBlendFactor(vecparams[1]) ; 
    283323                }                
    284         }        
     324        } 
     325 
     326        void parseCreateNewPasses(String& params, RenderTechniqueFactory* factory) 
     327        { 
     328                OgreDepthShadowReceiverRenderTechniqueFactory* f = (OgreDepthShadowReceiverRenderTechniqueFactory*) factory; 
     329                f->createNewPasses =  StringConverter::parseBool(params); 
     330        } 
     331         
     332        void parseStartTexID(String& params, RenderTechniqueFactory* factory) 
     333        { 
     334                OgreDepthShadowReceiverRenderTechniqueFactory* f = (OgreDepthShadowReceiverRenderTechniqueFactory*) factory; 
     335                f->startTextureUnitID =  StringConverter::parseInt(params); 
     336        } 
    285337} 
    286338 
    … …  
    303355        this->attributeParsers.insert(AttribParserList::value_type("light_farplane_param_name", (ILLUM_ATTRIBUTE_PARSER) parseLightFarPlaneParamName)); 
    304356        this->attributeParsers.insert(AttribParserList::value_type("pass_blending", (ILLUM_ATTRIBUTE_PARSER) parsePassBlending)); 
     357        this->attributeParsers.insert(AttribParserList::value_type("new_passes", (ILLUM_ATTRIBUTE_PARSER) parseCreateNewPasses)); 
     358        this->attributeParsers.insert(AttribParserList::value_type("start_tex_id", (ILLUM_ATTRIBUTE_PARSER) parseStartTexID));   
    305359} 
    306360 
    … …  
    325379        passBlendingSRC = SBF_DEST_COLOUR; 
    326380        passBlendingDEST = SBF_ZERO; 
    327  
     381        createNewPasses = true; 
     382        startTextureUnitID = 0; 
     383         
    328384        parseParams(params); 
    329385 
    … …  
    342398                                                                                                passBlendingSRC, 
    343399                                                                                                passBlendingDEST, 
     400                                                                                                createNewPasses, 
     401                                                                                                startTextureUnitID, 
    344402                                                                                                pass, 
    345403                                                                                                parentRenderable, 
Note: See TracChangeset for help on using the changeset viewer.