Changeset 12887

Show
Ignore:
Timestamp:
11/22/11 22:55:30 (3 years ago)
Author:
robert
Message:

Added prelimanary support for parallel split shadow maps into ViewDependentShadowMap?.

Location:
OpenSceneGraph/trunk
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osgShadow/ShadowSettings

    r12832 r12887  
    7373        double getPerspectiveShadowMapCutOffAngle() const { return _perspectiveShadowMapCutOffAngle; } 
    7474 
     75         
     76        void setNumShadowMapsPerLight(unsigned int numShadowMaps) { _numShadowMapsPerLight = numShadowMaps; } 
     77        unsigned int getNumShadowMapsPerLight() const { return _numShadowMapsPerLight; } 
     78 
     79        enum MultipleShadowMapHint 
     80        { 
     81            PARALLEL_SPLIT, 
     82            CASCADED 
     83        }; 
     84 
     85        void setMultipleShadowMapHint(MultipleShadowMapHint hint) { _multipleShadowMapHint = hint; } 
     86        MultipleShadowMapHint getMultipleShadowMapHint() const { return _multipleShadowMapHint; } 
     87         
     88 
    7589        enum ShaderHint 
    7690        { 
     
    98112        ShadowMapProjectionHint                 _shadowMapProjectionHint; 
    99113        double                                  _perspectiveShadowMapCutOffAngle; 
     114 
     115        unsigned int                            _numShadowMapsPerLight; 
     116        MultipleShadowMapHint                   _multipleShadowMapHint; 
     117         
    100118        ShaderHint                              _shaderHint; 
    101119        bool                                    _debugDraw; 
  • OpenSceneGraph/trunk/include/osgShadow/ViewDependentShadowMap

    r12782 r12887  
    160160        virtual osg::Polytope computeLightViewFrustumPolytope(Frustum& frustum, LightData& positionedLight); 
    161161 
    162         virtual bool computeShadowCameraSettings(Frustum& frustum, LightData& positionedLight, osg::Camera* camera); 
     162        virtual bool computeShadowCameraSettings(Frustum& frustum, LightData& positionedLight, osg::Matrixd& projectionMatrix, osg::Matrixd& viewMatrix); 
    163163 
    164164        virtual bool adjustPerspectiveShadowMapCameraSettings(osgUtil::RenderStage* renderStage, Frustum& frustum, LightData& positionedLight, osg::Camera* camera); 
  • OpenSceneGraph/trunk/src/osgShadow/ShadowSettings.cpp

    r12832 r12887  
    2424    _shadowMapProjectionHint(PERSPECTIVE_SHADOW_MAP), 
    2525    _perspectiveShadowMapCutOffAngle(2.0), 
    26     _shaderHint(NO_SHADERS), 
     26    _numShadowMapsPerLight(1), 
     27    _multipleShadowMapHint(PARALLEL_SPLIT), 
     28   _shaderHint(NO_SHADERS), 
    2729//    _shaderHint(PROVIDE_FRAGMENT_SHADER), 
    2830    _debugDraw(false) 
     
    3941    _shadowMapProjectionHint(ss._shadowMapProjectionHint), 
    4042    _perspectiveShadowMapCutOffAngle(ss._perspectiveShadowMapCutOffAngle), 
     43    _numShadowMapsPerLight(ss._numShadowMapsPerLight), 
     44    _multipleShadowMapHint(ss._multipleShadowMapHint), 
    4145    _shaderHint(ss._shaderHint), 
    4246    _debugDraw(ss._debugDraw) 
  • OpenSceneGraph/trunk/src/osgShadow/ViewDependentShadowMap.cpp

    r12834 r12887  
    1515#include <osgShadow/ShadowedScene> 
    1616#include <osg/CullFace> 
     17#include <osg/Geode> 
    1718#include <osg/io_utils> 
     19 
     20#include <sstream> 
    1821 
    1922using namespace osgShadow; 
     
    3841        "uniform sampler2D baseTexture;                                          \n" 
    3942        "uniform int baseTextureUnit;                                            \n" 
    40         "uniform sampler2DShadow shadowTexture;                                  \n" 
    41         "uniform int shadowTextureUnit;                                          \n" 
     43        "uniform sampler2DShadow shadowTexture0;                                 \n" 
     44        "uniform int shadowTextureUnit0;                                         \n" 
    4245        "                                                                        \n" 
    4346        "void main(void)                                                         \n" 
     
    4548        "  vec4 colorAmbientEmissive = gl_FrontLightModelProduct.sceneColor;     \n" 
    4649        "  vec4 color = texture2D( baseTexture, gl_TexCoord[baseTextureUnit].xy );                                              \n" 
    47         "  color *= mix( colorAmbientEmissive, gl_Color, shadow2DProj( shadowTexture, gl_TexCoord[shadowTextureUnit] ).r );     \n" 
     50        "  color *= mix( colorAmbientEmissive, gl_Color, shadow2DProj( shadowTexture0, gl_TexCoord[shadowTextureUnit0] ).r );     \n" 
    4851        "  gl_FragColor = color;                                                                                                \n" 
     52        "} \n"; 
     53 
     54static const char fragmentShaderSource_withBaseTexture_twoShadowMaps[] = 
     55        "uniform sampler2D baseTexture;                                          \n" 
     56        "uniform int baseTextureUnit;                                            \n" 
     57        "uniform sampler2DShadow shadowTexture0;                                 \n" 
     58        "uniform int shadowTextureUnit0;                                         \n" 
     59        "uniform sampler2DShadow shadowTexture1;                                 \n" 
     60        "uniform int shadowTextureUnit1;                                         \n" 
     61        "                                                                        \n" 
     62        "void main(void)                                                         \n" 
     63        "{                                                                       \n" 
     64        "  vec4 colorAmbientEmissive = gl_FrontLightModelProduct.sceneColor;     \n" 
     65        "  vec4 color = texture2D( baseTexture, gl_TexCoord[baseTextureUnit].xy );              \n" 
     66        "  float shadow0 = shadow2DProj( shadowTexture0, gl_TexCoord[shadowTextureUnit0] ).r;   \n" 
     67        "  float shadow1 = shadow2DProj( shadowTexture1, gl_TexCoord[shadowTextureUnit1] ).r;   \n" 
     68        "  color *= mix( colorAmbientEmissive, gl_Color, shadow0*shadow1 );                     \n" 
     69        "  gl_FragColor = color;                                                                \n" 
    4970        "} \n"; 
    5071#endif 
     
    227248} 
    228249 
     250 
     251class ComputeLightSpaceBounds : public osg::NodeVisitor, public osg::CullStack 
     252{ 
     253public: 
     254    ComputeLightSpaceBounds(osg::Viewport* viewport, const osg::Matrixd& projectionMatrix, osg::Matrixd& viewMatrix): 
     255        osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN) 
     256    { 
     257        pushViewport(viewport); 
     258        pushProjectionMatrix(new osg::RefMatrix(projectionMatrix)); 
     259        pushModelViewMatrix(new osg::RefMatrix(viewMatrix),osg::Transform::ABSOLUTE_RF); 
     260    } 
     261     
     262    void apply(osg::Node& node) 
     263    { 
     264        if (isCulled(node)) return; 
     265 
     266        traverse(node);         
     267    } 
     268 
     269    void apply(osg::Geode& node) 
     270    { 
     271        if (isCulled(node)) return; 
     272 
     273        for(unsigned int i=0; i<node.getNumDrawables();++i) 
     274        { 
     275            if (node.getDrawable(i)) 
     276            { 
     277                updateBound(node.getDrawable(i)->getBound()); 
     278            } 
     279        } 
     280    } 
     281 
     282    void apply(osg::Billboard&) 
     283    { 
     284        OSG_INFO<<"Warning Billboards not yet supported"<<std::endl; 
     285        return; 
     286    } 
     287 
     288    void apply(osg::Projection&) 
     289    { 
     290        // projection nodes won't affect a shadow map so their subgraphs should be ignored 
     291        return; 
     292    } 
     293     
     294    void apply(osg::Transform& transform) 
     295    { 
     296        if (isCulled(transform)) return; 
     297 
     298        // absolute transforms won't affect a shadow map so their subgraphs should be ignored. 
     299        if (transform.getReferenceFrame()==osg::Transform::ABSOLUTE_RF) return; 
     300 
     301        osg::ref_ptr<osg::RefMatrix> matrix = new osg::RefMatrix(*getModelViewMatrix()); 
     302        transform.computeLocalToWorldMatrix(*matrix,this); 
     303        pushModelViewMatrix(matrix.get(), transform.getReferenceFrame()); 
     304 
     305        traverse(transform); 
     306 
     307        popModelViewMatrix(); 
     308    } 
     309 
     310    void apply(osg::Camera&) 
     311    { 
     312        // camera nodes won't affect a shadow map so their subgraphs should be ignored 
     313        return; 
     314    } 
     315 
     316    void updateBound(const osg::BoundingBox& bb) 
     317    { 
     318        if (!bb.valid()) return; 
     319         
     320        const osg::Matrix& matrix = *getModelViewMatrix() * *getProjectionMatrix(); 
     321 
     322        update(bb.corner(0) * matrix); 
     323        update(bb.corner(1) * matrix); 
     324        update(bb.corner(2) * matrix); 
     325        update(bb.corner(3) * matrix); 
     326        update(bb.corner(4) * matrix); 
     327        update(bb.corner(5) * matrix); 
     328        update(bb.corner(6) * matrix); 
     329        update(bb.corner(7) * matrix); 
     330    } 
     331 
     332    void update(const osg::Vec3& v) 
     333    { 
     334        if (v.z()<0.0f) 
     335        { 
     336            //OSG_NOTICE<<"discarding("<<v<<")"<<std::endl; 
     337            return; 
     338        } 
     339         
     340        float x = v.x(); 
     341        if (x<-1.0f) x=-1.0f; 
     342        if (x>1.0f) x=1.0f; 
     343        float y = v.y(); 
     344        if (y<-1.0f) y=-1.0f; 
     345        if (y>1.0f) y=1.0f; 
     346 
     347        _bb.expandBy(osg::Vec3(x,y,v.z())); 
     348    } 
     349 
     350    osg::BoundingBox _bb; 
     351}; 
     352     
    229353/////////////////////////////////////////////////////////////////////////////////////////////// 
    230354// 
     
    673797    ShadowDataList previous_sdl; 
    674798    previous_sdl.swap(sdl); 
    675      
     799 
     800    unsigned int numShadowMapsPerLight = settings->getNumShadowMapsPerLight(); 
     801    if (numShadowMapsPerLight>2) 
     802    { 
     803        OSG_NOTICE<<"numShadowMapsPerLight of "<<numShadowMapsPerLight<<" is greater than maximum supported, falling back to 2."<<std::endl; 
     804        numShadowMapsPerLight = 2; 
     805    } 
     806 
    676807    LightDataList& pll = vdd->getLightDataList(); 
    677808    for(LightDataList::iterator itr = pll.begin(); 
     
    684815        LightData& pl = **itr; 
    685816 
     817        // 3.1 compute light space polytope 
     818        // 
     819        osg::Polytope polytope = computeLightViewFrustumPolytope(frustum, pl); 
     820 
     821        // if polytope is empty then no rendering. 
     822        if (polytope.empty()) 
     823        { 
     824            OSG_NOTICE<<"Polytope empty no shadow to render"<<std::endl; 
     825            continue; 
     826        } 
     827 
     828        // 3.2 compute RTT camera view+projection matrix settings 
     829        // 
     830        osg::Matrixd projectionMatrix; 
     831        osg::Matrixd viewMatrix; 
     832        if (!computeShadowCameraSettings(frustum, pl, projectionMatrix, viewMatrix)) 
     833        { 
     834            OSG_NOTICE<<"No valid Camera settings, no shadow to render"<<std::endl; 
     835            continue; 
     836        } 
     837 
     838        // if we are using multiple shadow maps and CastShadowTraversalMask is being used 
     839        // traverse the scene to compute the extents of the objects 
     840        if (numShadowMapsPerLight>1 && _shadowedScene->getCastsShadowTraversalMask()!=0xffffffff) 
     841        { 
     842            // osg::ElapsedTime timer; 
     843             
     844            osg::ref_ptr<osg::Viewport> viewport = new osg::Viewport(0,0,2048,2048); 
     845            ComputeLightSpaceBounds clsb(viewport.get(), projectionMatrix, viewMatrix); 
     846            clsb.setTraversalMask(_shadowedScene->getCastsShadowTraversalMask()); 
     847 
     848            osg::Matrixd invertModelView; 
     849            invertModelView.invert(viewMatrix); 
     850            osg::Polytope local_polytope(polytope); 
     851            local_polytope.transformProvidingInverse(invertModelView); 
     852 
     853            osg::CullingSet& cs = clsb.getProjectionCullingStack().back(); 
     854            cs.setFrustum(local_polytope); 
     855 
     856            clsb.pushCullingSet(); 
     857 
     858            _shadowedScene->accept(clsb); 
     859 
     860            // OSG_NOTICE<<"Extents of LightSpace "<<clsb._bb.xMin()<<", "<<clsb._bb.xMax()<<", "<<clsb._bb.yMin()<<", "<<clsb._bb.yMax()<<", "<<clsb._bb.zMin()<<", "<<clsb._bb.zMax()<<std::endl; 
     861            // OSG_NOTICE<<"  time "<<timer.elapsedTime_m()<<"ms, mask = "<<std::hex<<_shadowedScene->getCastsShadowTraversalMask()<<std::endl; 
     862 
     863            if (clsb._bb.xMin()>-1.0f || clsb._bb.xMax()<1.0f || clsb._bb.yMin()>-1.0f || clsb._bb.yMax()<1.0f) 
     864            { 
     865                // OSG_NOTICE<<"Need to clamp projection matrix"<<std::endl; 
     866 
     867#if 0 
     868                double xMid = (clsb._bb.xMin()+clsb._bb.xMax())*0.5f; 
     869                double xRange = clsb._bb.xMax()-clsb._bb.xMin(); 
     870#else 
     871                double xMid = 0.0; 
     872                double xRange = 2.0; 
     873#endif 
     874                double yMid = (clsb._bb.yMin()+clsb._bb.yMax())*0.5f; 
     875                double yRange = (clsb._bb.yMax()-clsb._bb.yMin()); 
     876 
     877                // OSG_NOTICE<<"  xMid="<<xMid<<", yMid="<<yMid<<", xRange="<<xRange<<", yRange="<<yRange<<std::endl; 
     878 
     879                projectionMatrix =  
     880                    projectionMatrix * 
     881                    osg::Matrixd::translate(osg::Vec3d(-xMid,-yMid,0.0)) * 
     882                    osg::Matrixd::scale(osg::Vec3d(2.0/xRange, 2.0/yRange,1.0)); 
     883                 
     884            } 
     885 
     886        } 
     887 
     888        double splitPoint = 0.0; 
     889         
     890        if (numShadowMapsPerLight>1) 
     891        { 
     892            osg::Vec3d eye_v = frustum.eye * viewMatrix; 
     893            osg::Vec3d center_v = frustum.center * viewMatrix; 
     894            osg::Vec3d viewdir_v = center_v-eye_v; viewdir_v.normalize(); 
     895            osg::Vec3d lightdir(0.0,0.0,-1.0); 
     896             
     897            double dotProduct_v = lightdir * viewdir_v; 
     898            double angle = acosf(dotProduct_v); 
     899 
     900            osg::Vec3d eye_ls = eye_v * projectionMatrix; 
     901             
     902            OSG_INFO<<"Angle between view vector and eye "<<osg::RadiansToDegrees(angle)<<std::endl; 
     903            OSG_INFO<<"eye_ls="<<eye_ls<<std::endl; 
     904 
     905            if (eye_ls.y()>=-1.0 && eye_ls.y()<=1.0) 
     906            { 
     907                OSG_INFO<<"Eye point inside light space clip region   "<<std::endl; 
     908                splitPoint = 0.0; 
     909            } 
     910            else 
     911            { 
     912                double n = -1.0-eye_ls.y(); 
     913                double f = 1.0-eye_ls.y(); 
     914                double sqrt_nf = sqrt(n*f); 
     915                double mid = eye_ls.y()+sqrt_nf; 
     916                double ratioOfMidToUseForSplit = 0.8; 
     917                splitPoint = mid * ratioOfMidToUseForSplit; 
     918 
     919                OSG_INFO<<"  n="<<n<<", f="<<f<<", sqrt_nf="<<sqrt_nf<<" mid="<<mid<<std::endl; 
     920            } 
     921        } 
     922 
    686923        // 4. For each light/shadow map 
     924        for (unsigned int sm_i=0; sm_i<numShadowMapsPerLight; ++sm_i) 
    687925        { 
    688926            osg::ref_ptr<ShadowData> sd; 
     
    702940            osg::ref_ptr<osg::Camera> camera = sd->_camera; 
    703941 
     942            camera->setProjectionMatrix(projectionMatrix); 
     943            camera->setViewMatrix(viewMatrix); 
     944 
    704945            if (settings->getDebugDraw()) 
    705946            { 
    706947                camera->getViewport()->x() = pos_x; 
    707948                pos_x += camera->getViewport()->width() + 40; 
    708             } 
    709  
    710             osg::ref_ptr<osg::TexGen> texgen = sd->_texgen; 
    711  
    712             // 4.1 compute light space polytope 
    713             // 
    714  
    715             osg::Polytope polytope = computeLightViewFrustumPolytope(frustum, pl); 
    716  
    717             // if polytope is empty then no rendering. 
    718             if (polytope.empty()) 
    719             { 
    720                 OSG_NOTICE<<"Polytope empty no shadow to render"<<std::endl; 
    721                 continue; 
    722             } 
    723  
    724             // 4.2 compute RTT camera view+projection matrix settings 
    725             // 
    726             if (!computeShadowCameraSettings(frustum, pl, camera.get())) 
    727             { 
    728                 OSG_NOTICE<<"No valid Camera settings, no shadow to render"<<std::endl; 
    729                 continue; 
    730949            } 
    731950 
     
    734953            invertModelView.invert(camera->getViewMatrix()); 
    735954 
    736             polytope.transformProvidingInverse(invertModelView); 
    737  
    738             osg::ref_ptr<VDSMCameraCullCallback> vdsmCallback = new VDSMCameraCullCallback(this, polytope); 
     955            osg::Polytope local_polytope(polytope); 
     956            local_polytope.transformProvidingInverse(invertModelView); 
     957 
     958 
     959            if (numShadowMapsPerLight>1) 
     960            { 
     961                // compute the start and end range in non-dimensional coords 
     962#if 0                 
     963                double r_start = (sm_i==0) ? -1.0 : (double(sm_i)/double(numShadowMapsPerLight)*2.0-1.0); 
     964                double r_end = (sm_i+1==numShadowMapsPerLight) ? 1.0 : (double(sm_i+1)/double(numShadowMapsPerLight)*2.0-1.0); 
     965#endif 
     966 
     967                // hardwired for 2 splits 
     968                double r_start = (sm_i==0) ? -1.0 : splitPoint; 
     969                double r_end = (sm_i+1==numShadowMapsPerLight) ? 1.0 : splitPoint; 
     970 
     971                // for all by the last shadowmap shift the r_end so that it overlaps slightly with the next shadowmap 
     972                // to prevent a seam showing through between the shadowmaps 
     973                if (sm_i+1<numShadowMapsPerLight) r_end+=0.01; 
     974 
     975 
     976                if (sm_i>0) 
     977                { 
     978                    // not the first shadowmap so insert a polytope to clip the scene from before r_start 
     979 
     980                    // plane in clip space coords 
     981                    osg::Plane plane(0.0,1.0,0.0,-r_start); 
     982 
     983                    // transform into eye coords 
     984                    plane.transformProvidingInverse(projectionMatrix); 
     985                    local_polytope.getPlaneList().push_back(plane); 
     986 
     987                    //OSG_NOTICE<<"Adding r_start plane "<<plane<<std::endl; 
     988 
     989                } 
     990 
     991                if (sm_i+1<numShadowMapsPerLight) 
     992                { 
     993                    // not the last shadowmap so insert a polytope to clip the scene from beyond r_end 
     994 
     995                    // plane in clip space coords 
     996                    osg::Plane plane(0.0,-1.0,0.0,r_end); 
     997 
     998                    // transform into eye coords 
     999                    plane.transformProvidingInverse(projectionMatrix); 
     1000                    local_polytope.getPlaneList().push_back(plane); 
     1001 
     1002                    //OSG_NOTICE<<"Adding r_end plane "<<plane<<std::endl; 
     1003                } 
     1004 
     1005                local_polytope.setupMask(); 
     1006 
     1007                 
     1008                // OSG_NOTICE<<"Need to adjust RTT camera projection and view matrix here, r_start="<<r_start<<", r_end="<<r_end<<std::endl; 
     1009                // OSG_NOTICE<<"  textureUnit = "<<textureUnit<<std::endl; 
     1010 
     1011                double mid_r = (r_start+r_end)*0.5; 
     1012                double range_r = (r_end-r_start); 
     1013 
     1014                // OSG_NOTICE<<"  mid_r = "<<mid_r<<", range_r = "<<range_r<<std::endl; 
     1015 
     1016                camera->setProjectionMatrix( 
     1017                    camera->getProjectionMatrix() * 
     1018                    osg::Matrixd::translate(osg::Vec3d(0.0,-mid_r,0.0)) * 
     1019                    osg::Matrixd::scale(osg::Vec3d(1.0,2.0/range_r,1.0))); 
     1020                 
     1021            } 
     1022 
     1023 
     1024            osg::ref_ptr<VDSMCameraCullCallback> vdsmCallback = new VDSMCameraCullCallback(this, local_polytope); 
    7391025            camera->setCullCallback(vdsmCallback.get()); 
    7401026 
     
    7591045            // 4.4 compute main scene graph TexGen + uniform settings + setup state 
    7601046            // 
    761  
    762             assignTexGenSettings(&cv, camera.get(), textureUnit, texgen.get()); 
    763  
     1047            assignTexGenSettings(&cv, camera.get(), textureUnit, sd->_texgen.get()); 
    7641048 
    7651049            // mark the light as one that has active shadows and requires shaders 
     
    8881172    _uniforms.push_back(baseTextureUnit.get()); 
    8891173 
    890     osg::ref_ptr<osg::Uniform> shadowTextureSampler = new osg::Uniform("shadowTexture",(int)(settings->getBaseShadowTextureUnit())); 
    891     _uniforms.push_back(shadowTextureSampler.get()); 
    892  
    893     osg::ref_ptr<osg::Uniform> shadowTextureUnit = new osg::Uniform("shadowTextureUnit",(int)(settings->getBaseShadowTextureUnit())); 
    894     _uniforms.push_back(shadowTextureUnit.get()); 
     1174    for(unsigned int sm_i=0; sm_i<settings->getNumShadowMapsPerLight(); ++sm_i) 
     1175    { 
     1176        { 
     1177            std::stringstream sstr; 
     1178            sstr<<"shadowTexture"<<sm_i; 
     1179            osg::ref_ptr<osg::Uniform> shadowTextureSampler = new osg::Uniform(sstr.str().c_str(),(int)(settings->getBaseShadowTextureUnit()+sm_i)); 
     1180            _uniforms.push_back(shadowTextureSampler.get()); 
     1181        } 
     1182 
     1183        { 
     1184            std::stringstream sstr; 
     1185            sstr<<"shadowTextureUnit"<<sm_i; 
     1186            osg::ref_ptr<osg::Uniform> shadowTextureUnit = new osg::Uniform(sstr.str().c_str(),(int)(settings->getBaseShadowTextureUnit()+sm_i)); 
     1187            _uniforms.push_back(shadowTextureUnit.get()); 
     1188        } 
     1189    } 
    8951190 
    8961191    switch(settings->getShaderHint()) 
     
    9041199        case(ShadowSettings::PROVIDE_FRAGMENT_SHADER): 
    9051200        { 
     1201            _program = new osg::Program; 
     1202 
    9061203            //osg::ref_ptr<osg::Shader> fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_noBaseTexture); 
    907             osg::ref_ptr<osg::Shader> fragment_shader = new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_withBaseTexture); 
    908             _program = new osg::Program; 
    909             _program->addShader(fragment_shader.get()); 
     1204            if (settings->getNumShadowMapsPerLight()==2) 
     1205            { 
     1206                _program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_withBaseTexture_twoShadowMaps)); 
     1207            } 
     1208            else 
     1209            { 
     1210                _program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_withBaseTexture)); 
     1211            } 
     1212             
    9101213            break; 
    9111214        } 
     
    10511354} 
    10521355 
    1053 bool ViewDependentShadowMap::computeShadowCameraSettings(Frustum& frustum, LightData& positionedLight, osg::Camera* camera) 
     1356bool ViewDependentShadowMap::computeShadowCameraSettings(Frustum& frustum, LightData& positionedLight, osg::Matrixd& projectionMatrix, osg::Matrixd& viewMatrix) 
    10541357{ 
    10551358    OSG_INFO<<"standardShadowMapCameraSettings()"<<std::endl; 
     
    11351438        else 
    11361439        { 
    1137             camera->setProjectionMatrixAsOrtho(xMin,xMax, yMin, yMax,0.0,zMax-zMin); 
    1138             camera->setViewMatrixAsLookAt(frustum.center+positionedLight.lightDir*zMin, frustum.center, lightUp); 
     1440            projectionMatrix.makeOrtho(xMin,xMax, yMin, yMax,0.0,zMax-zMin); 
     1441            viewMatrix.makeLookAt(frustum.center+positionedLight.lightDir*zMin, frustum.center, lightUp); 
    11391442        } 
    11401443    } 
     
    11731476        if(fov < 180.0)   // spotlight 
    11741477        { 
    1175             camera->setProjectionMatrixAsPerspective(fov, 1.0, zMin, zMax); 
    1176             camera->setViewMatrixAsLookAt(positionedLight.lightPos3, 
     1478            projectionMatrix.makePerspective(fov, 1.0, zMin, zMax); 
     1479            viewMatrix.makeLookAt(positionedLight.lightPos3, 
    11771480                                          positionedLight.lightPos3+positionedLight.lightDir, lightUp); 
    11781481        } 
     
    12071510            } 
    12081511 
    1209             camera->setProjectionMatrixAsPerspective(fov, 1.0, zMin, zMax); 
    1210             camera->setViewMatrixAsLookAt(positionedLight.lightPos3, 
    1211                                           positionedLight.lightPos3+positionedLight.lightDir, lightUp); 
     1512            projectionMatrix.makePerspective(fov, 1.0, zMin, zMax); 
     1513            viewMatrix.makeLookAt(positionedLight.lightPos3, 
     1514                                  positionedLight.lightPos3+positionedLight.lightDir, lightUp); 
    12121515 
    12131516        } 
     
    17982101     
    17992102    osg::Vec3d eye_v = frustum.eye * light_v; 
    1800     osg::Vec3d centerNearPlane_v = frustum.centerNearPlane * light_v; 
     2103    //osg::Vec3d centerNearPlane_v = frustum.centerNearPlane * light_v; 
    18012104    osg::Vec3d center_v = frustum.center * light_v; 
    18022105    osg::Vec3d viewdir_v = center_v-eye_v; viewdir_v.normalize(); 
     
    18232126#endif 
    18242127     
    1825     osg::Vec3d centerNearPlane_ls = frustum.centerNearPlane * light_vp; 
    1826     osg::Vec3d centerFarPlane_ls = frustum.centerFarPlane * light_vp; 
     2128    //osg::Vec3d centerNearPlane_ls = frustum.centerNearPlane * light_vp; 
     2129    //osg::Vec3d centerFarPlane_ls = frustum.centerFarPlane * light_vp; 
    18272130    osg::Vec3d center_ls = frustum.center * light_vp; 
    18282131    osg::Vec3d viewdir_ls = center_ls-eye_ls; viewdir_ls.normalize(); 
     
    19492252bool ViewDependentShadowMap::assignTexGenSettings(osgUtil::CullVisitor* cv, osg::Camera* camera, unsigned int textureUnit, osg::TexGen* texgen) 
    19502253{ 
    1951     OSG_INFO<<"assignTexGenSettings()"<<std::endl; 
     2254    OSG_INFO<<"assignTexGenSettings() textureUnit="<<textureUnit<<" texgen="<<texgen<<std::endl; 
    19522255 
    19532256    texgen->setMode(osg::TexGen::EYE_LINEAR); 
     
    19582261    texgen->setPlanesFromMatrix( camera->getProjectionMatrix() * 
    19592262                                 osg::Matrix::translate(1.0,1.0,1.0) * 
    1960                                  osg::Matrix::scale(0.5f,0.5f,0.5f) ); 
     2263                                 osg::Matrix::scale(0.5,0.5,0.5) ); 
    19612264 
    19622265    // Place texgen with modelview which removes big offsets (making it float friendly) 
     
    20202323        ++itr) 
    20212324    { 
     2325        OSG_INFO<<"addUniform("<<(*itr)->getName()<<")"<<std::endl; 
    20222326        stateset->addUniform(itr->get()); 
    20232327    }