Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgShadow/ViewDependentShadowMap.cpp

    r13032 r13041  
    177177    { 
    178178        OSG_INFO<<"Pushing custom Polytope"<<std::endl; 
    179          
     179 
    180180        osg::CullingSet& cs = cv->getProjectionCullingStack().back(); 
    181181 
     
    200200 
    201201    OSG_INFO<<"VDSM second : _renderStage = "<<_renderStage<<std::endl; 
    202      
     202 
    203203    if (cv->getComputeNearFarMode() != osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR) 
    204204    { 
     
    256256    { 
    257257        setCullingMode(osg::CullSettings::VIEW_FRUSTUM_CULLING); 
    258          
     258 
    259259        pushViewport(viewport); 
    260260        pushProjectionMatrix(new osg::RefMatrix(projectionMatrix)); 
    261261        pushModelViewMatrix(new osg::RefMatrix(viewMatrix),osg::Transform::ABSOLUTE_RF); 
    262262    } 
    263      
     263 
    264264    void apply(osg::Node& node) 
    265265    { 
    266266        if (isCulled(node)) return; 
    267          
     267 
    268268        // push the culling mode. 
    269269        pushCurrentMask(); 
     
    305305        return; 
    306306    } 
    307      
     307 
    308308    void apply(osg::Transform& transform) 
    309309    { 
     
    324324            popModelViewMatrix(); 
    325325        } 
    326          
     326 
    327327        // pop the culling mode. 
    328328        popCurrentMask(); 
    329          
     329 
    330330    } 
    331331 
     
    339339    { 
    340340        if (!bb.valid()) return; 
    341          
     341 
    342342        const osg::Matrix& matrix = *getModelViewMatrix() * *getProjectionMatrix(); 
    343343 
     
    370370    osg::BoundingBox _bb; 
    371371}; 
    372      
     372 
    373373/////////////////////////////////////////////////////////////////////////////////////////////// 
    374374// 
     
    432432 
    433433    const ShadowSettings* settings = vdd->getViewDependentShadowMap()->getShadowedScene()->getShadowSettings(); 
    434      
     434 
    435435    bool debug = settings->getDebugDraw(); 
    436436 
     
    443443    osg::Vec2s textureSize = debug ? osg::Vec2s(512,512) : settings->getTextureSize(); 
    444444    _texture->setTextureSize(textureSize.x(), textureSize.y()); 
    445      
     445 
    446446    if (debug) 
    447447    { 
     
    454454        _texture->setShadowTextureMode(osg::Texture2D::LUMINANCE); 
    455455    } 
    456      
     456 
    457457    _texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR); 
    458458    _texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR); 
     
    463463    _texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,1.0f)); 
    464464    //_texture->setBorderColor(osg::Vec4(0.0f,0.0f,0.0f,0.0f)); 
    465      
     465 
    466466    // set up the camera 
    467467    _camera = new osg::Camera; 
     
    477477    // switch off small feature culling as this can cull out geometry that will still be large enough once perspective correction takes effect. 
    478478    _camera->setCullingMode(_camera->getCullingMode() & ~osg::CullSettings::SMALL_FEATURE_CULLING); 
    479      
     479 
    480480    // set viewport 
    481481    _camera->setViewport(0,0,textureSize.x(),textureSize.y()); 
     
    498498        // clear the depth and colour bufferson each clear. 
    499499        _camera->setClearMask(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); 
    500          
     500 
    501501        // set the camera to render before the main camera. 
    502502        _camera->setRenderOrder(osg::Camera::PRE_RENDER); 
    503          
     503 
    504504        // tell the camera to use OpenGL frame buffer object where supported. 
    505505        _camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT); 
     
    508508        _camera->attach(osg::Camera::DEPTH_BUFFER, _texture.get()); 
    509509        //_camera->attach(osg::Camera::COLOR_BUFFER, _texture.get()); 
    510     }    
     510    } 
    511511} 
    512512 
     
    542542        OSG_INFO<<"Projection matrix after clamping "<<projectionMatrix<<std::endl; 
    543543    } 
    544      
     544 
    545545    corners[0].set(-1.0,-1.0,-1.0); 
    546546    corners[1].set(1.0,-1.0,-1.0); 
     
    696696 
    697697    createShaders(); 
    698      
     698 
    699699    _dirty = false; 
    700700} 
     
    752752 
    753753    osg::RefMatrix& viewProjectionMatrix = *cv.getProjectionMatrix(); 
    754      
     754 
    755755    // check whether this main views projection is perspective or orthographic 
    756756    bool orthographicViewFrustum = viewProjectionMatrix(0,3)==0.0 && 
     
    795795        cv.computeNearPlane(); 
    796796    } 
    797      
     797 
    798798    Frustum frustum(&cv, minZNear, maxZFar); 
    799799 
     
    809809 
    810810    ShadowSettings* settings = getShadowedScene()->getShadowSettings(); 
    811      
     811 
    812812    unsigned int pos_x = 0; 
    813813    unsigned int textureUnit = settings->getBaseShadowTextureUnit(); 
     
    861861        { 
    862862            // osg::ElapsedTime timer; 
    863              
     863 
    864864            osg::ref_ptr<osg::Viewport> viewport = new osg::Viewport(0,0,2048,2048); 
    865865            ComputeLightSpaceBounds clsb(viewport.get(), projectionMatrix, viewMatrix); 
     
    896896                // OSG_NOTICE<<"  xMid="<<xMid<<", yMid="<<yMid<<", xRange="<<xRange<<", yRange="<<yRange<<std::endl; 
    897897 
    898                 projectionMatrix =  
     898                projectionMatrix = 
    899899                    projectionMatrix * 
    900900                    osg::Matrixd::translate(osg::Vec3d(-xMid,-yMid,0.0)) * 
    901901                    osg::Matrixd::scale(osg::Vec3d(2.0/xRange, 2.0/yRange,1.0)); 
    902                  
     902 
    903903            } 
    904904 
     
    906906 
    907907        double splitPoint = 0.0; 
    908          
     908 
    909909        if (numShadowMapsPerLight>1) 
    910910        { 
     
    913913            osg::Vec3d viewdir_v = center_v-eye_v; viewdir_v.normalize(); 
    914914            osg::Vec3d lightdir(0.0,0.0,-1.0); 
    915              
     915 
    916916            double dotProduct_v = lightdir * viewdir_v; 
    917917            double angle = acosf(dotProduct_v); 
    918918 
    919919            osg::Vec3d eye_ls = eye_v * projectionMatrix; 
    920              
     920 
    921921            OSG_INFO<<"Angle between view vector and eye "<<osg::RadiansToDegrees(angle)<<std::endl; 
    922922            OSG_INFO<<"eye_ls="<<eye_ls<<std::endl; 
     
    979979            { 
    980980                // compute the start and end range in non-dimensional coords 
    981 #if 0                 
     981#if 0 
    982982                double r_start = (sm_i==0) ? -1.0 : (double(sm_i)/double(numShadowMapsPerLight)*2.0-1.0); 
    983983                double r_end = (sm_i+1==numShadowMapsPerLight) ? 1.0 : (double(sm_i+1)/double(numShadowMapsPerLight)*2.0-1.0); 
     
    10241024                local_polytope.setupMask(); 
    10251025 
    1026                  
     1026 
    10271027                // OSG_NOTICE<<"Need to adjust RTT camera projection and view matrix here, r_start="<<r_start<<", r_end="<<r_end<<std::endl; 
    10281028                // OSG_NOTICE<<"  textureUnit = "<<textureUnit<<std::endl; 
     
    10371037                    osg::Matrixd::translate(osg::Vec3d(0.0,-mid_r,0.0)) * 
    10381038                    osg::Matrixd::scale(osg::Vec3d(1.0,2.0/range_r,1.0))); 
    1039                  
     1039 
    10401040            } 
    10411041 
     
    10711071            // pass on shadow data to ShadowDataList 
    10721072            sd->_textureUnit = textureUnit; 
    1073              
     1073 
    10741074            if (textureUnit >= 8) 
    10751075            { 
     
    10801080                sdl.push_back(sd); 
    10811081            } 
    1082              
     1082 
    10831083            // increment counters. 
    10841084            ++textureUnit; 
     
    10891089    if (numValidShadows>0) 
    10901090    { 
    1091         decoratorStateGraph->setStateSet(selectStateSetForRenderingShadow(*vdd));         
    1092     } 
    1093     
     1091        decoratorStateGraph->setStateSet(selectStateSetForRenderingShadow(*vdd)); 
     1092    } 
     1093 
    10941094    // OSG_NOTICE<<"End of shadow setup Projection matrix "<<*cv.getProjectionMatrix()<<std::endl; 
    10951095} 
     
    11001100 
    11011101    LightDataList& pll = vdd->getLightDataList(); 
    1102      
     1102 
    11031103    LightDataList previous_ldl; 
    11041104    previous_ldl.swap(pll); 
     
    11101110 
    11111111    osg::Matrixd modelViewMatrix = *(cv->getModelViewMatrix()); 
    1112      
     1112 
    11131113    osgUtil::PositionalStateContainer::AttrMatrixList& aml = 
    11141114        rs->getPositionalStateContainer()->getAttrMatrixList(); 
     
    11161116 
    11171117    const ShadowSettings* settings = getShadowedScene()->getShadowSettings(); 
    1118          
     1118 
    11191119    for(osgUtil::PositionalStateContainer::AttrMatrixList::reverse_iterator itr = aml.rbegin(); 
    11201120        itr != aml.rend(); 
     
    11261126            // is LightNum matched to that defined in settings 
    11271127            if (settings && settings->getLightNum()>=0 && light->getLightNum()!=settings->getLightNum()) continue; 
    1128              
     1128 
    11291129            LightDataList::iterator pll_itr = pll.begin(); 
    11301130            for(; pll_itr != pll.end(); ++pll_itr) 
     
    11431143            { 
    11441144                OSG_INFO<<"Light num "<<light->getLightNum()<<" already used, ignore light"<<std::endl; 
    1145             }             
    1146         } 
    1147     } 
    1148      
     1145            } 
     1146        } 
     1147    } 
     1148 
    11491149    return !pll.empty(); 
    11501150} 
     
    11591159 
    11601160    ShadowSettings* settings = getShadowedScene()->getShadowSettings(); 
    1161      
     1161 
    11621162    if (!settings->getDebugDraw()) 
    11631163    { 
     
    11781178        _shadowCastingStateSet->setMode( GL_CULL_FACE, osg::StateAttribute::OFF ); 
    11791179    } 
    1180      
     1180 
    11811181#if 1 
    11821182    float factor = 1.1; 
     
    11901190    _shadowCastingStateSet->setMode(GL_POLYGON_OFFSET_FILL, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE); 
    11911191 
    1192      
     1192 
    11931193    _uniforms.clear(); 
    11941194    osg::ref_ptr<osg::Uniform> baseTextureSampler = new osg::Uniform("baseTexture",(int)_baseTextureUnit); 
     
    12361236                _program->addShader(new osg::Shader(osg::Shader::FRAGMENT, fragmentShaderSource_withBaseTexture)); 
    12371237            } 
    1238              
     1238 
    12391239            break; 
    12401240        } 
     
    13871387 
    13881388    const ShadowSettings* settings = getShadowedScene()->getShadowSettings(); 
    1389      
     1389 
    13901390    double dotProduct_v = positionedLight.lightDir * frustum.frustumCenterLine; 
    13911391    double gamma_v = acos(dotProduct_v); 
     
    14111411#endif 
    14121412 
    1413      
     1413 
    14141414    if (positionedLight.directionalLight) 
    14151415    { 
     
    14841484 
    14851485            OSG_INFO<<"   cornerInLightCoords= "<<cornerInLightCoords<<std::endl; 
    1486              
     1486 
    14871487            zMax = osg::maximum( zMax, cornerInLightCoords.z()); 
    14881488        } 
     
    15721572        _edges.push_back( Edge(frustum.corners[3],frustum.corners[7]) ); 
    15731573    } 
    1574      
     1574 
    15751575    void transform(const osg::Matrixd& m) 
    15761576    { 
     
    15831583        } 
    15841584    } 
    1585      
    1586     void clip(const osg::Plane& plane)     
     1585 
     1586    void clip(const osg::Plane& plane) 
    15871587    { 
    15881588        Vertices intersections; 
    1589          
     1589 
    15901590        // OSG_NOTICE<<"clip("<<plane<<") edges.size()="<<_edges.size()<<std::endl; 
    15911591        for(Edges::iterator itr = _edges.begin(); 
     
    16241624                    v1 = intersection; 
    16251625                } 
    1626                  
     1626 
    16271627                ++itr; 
    16281628            } 
     
    16401640            return; 
    16411641        } 
    1642          
     1642 
    16431643        if (intersections.size() == 3) 
    16441644        { 
     
    16581658        osg::Vec3d side = (side_x.length2()>=side_y.length2()) ? side_x : side_y; 
    16591659        side.normalize(); 
    1660          
     1660 
    16611661        osg::Vec3d up = side ^ normal; 
    16621662        up.normalize(); 
     
    16711671 
    16721672        center /= double(intersections.size()); 
    1673                  
     1673 
    16741674        typedef std::map<double, osg::Vec3d> VertexMap; 
    16751675        VertexMap vertexMap; 
     
    16941694            previous_v = itr->second; 
    16951695        } 
    1696          
     1696 
    16971697        // OSG_NOTICE<<"  after clip("<<plane<<") edges.size()="<<_edges.size()<<std::endl; 
    16981698    } 
    1699      
     1699 
    17001700    void clip(const osg::Polytope& polytope) 
    17011701    { 
     
    17221722        return m; 
    17231723    } 
    1724      
     1724 
    17251725    double max(unsigned int index) const 
    17261726    { 
     
    18351835        n = nr; 
    18361836    } 
    1837      
     1837 
    18381838    void operator() (const osgUtil::RenderLeaf* renderLeaf) 
    18391839    { 
    18401840        ++numRenderLeaf; 
    1841          
     1841 
    18421842        if (renderLeaf->_modelview.get()!=previous_modelview) 
    18431843        { 
     
    19061906            if (z_ratio>max_z_ratio) max_z_ratio = z_ratio; 
    19071907        } 
    1908          
     1908 
    19091909        // clip to the light space 
    19101910        if (ls.x()<clip_min_x) ls.x()=clip_min_x; 
     
    19341934    osg::Vec3d          eye_ls; 
    19351935    double              n; 
    1936      
     1936 
    19371937    osg::Matrixd        light_mvp; 
    19381938    osg::RefMatrix*     previous_modelview; 
     
    19451945    double clip_min_x_ratio, clip_max_x_ratio; 
    19461946    double clip_min_z_ratio, clip_max_z_ratio; 
    1947      
     1947 
    19481948    double min_x_ratio, max_x_ratio; 
    19491949    double min_z_ratio, max_z_ratio; 
     
    19771977    //OSG_NOTICE<<"light_v="<<light_v<<std::endl; 
    19781978    //OSG_NOTICE<<"light_p="<<light_p<<std::endl; 
    1979      
     1979 
    19801980    ConvexHull convexHull; 
    19811981    convexHull.setToFrustum(frustum); 
    1982      
     1982 
    19831983#if 0 
    19841984    OSG_NOTICE<<"ws ConvexHull xMin="<<convexHull.min(0)<<", xMax="<<convexHull.max(0)<<std::endl; 
    19851985    OSG_NOTICE<<"ws ConvexHull yMin="<<convexHull.min(1)<<", yMax="<<convexHull.max(1)<<std::endl; 
    19861986    OSG_NOTICE<<"ws ConvexHull zMin="<<convexHull.min(2)<<", zMax="<<convexHull.max(2)<<std::endl; 
    1987      
     1987 
    19881988    convexHull.output(osg::notify(osg::NOTICE)); 
    19891989#endif 
    1990      
     1990 
    19911991    convexHull.transform(light_vp); 
    19921992 
     
    20422042        convexHull.clip(osg::Plane(1.0,0.0,0.0,widest_x)); 
    20432043        convexHull.clip(osg::Plane(-1.0,0.0,0.0,widest_x)); 
    2044 #endif         
     2044#endif 
    20452045#if 1 
    20462046        convexHull.clip(osg::Plane(0.0,1.0,0.0,-rli.min_y)); 
     
    20572057#endif 
    20582058 
    2059 #if 0         
     2059#if 0 
    20602060        OSG_NOTICE<<"widest_x = "<<widest_x<<std::endl; 
    20612061        OSG_NOTICE<<"widest_y = "<<widest_y<<std::endl; 
     
    20972097    OSG_NOTICE<<"zMin = "<<zMin<<", \tzMax = "<<zMax<<std::endl; 
    20982098#endif 
    2099      
     2099 
    21002100#if 1 
    21012101    // we always want the lightspace to include the computed near plane. 
     
    21082108                                    -0.5*(yMax+yMin), 
    21092109                                    -0.5*(zMax+zMin))); 
    2110          
     2110 
    21112111        m.postMultScale(osg::Vec3d(2.0/(xMax-xMin), 
    21122112                                   2.0/(yMax-yMin), 
     
    21252125 
    21262126#endif 
    2127      
     2127 
    21282128    osg::Vec3d eye_v = frustum.eye * light_v; 
    21292129    //osg::Vec3d centerNearPlane_v = frustum.centerNearPlane * light_v; 
     
    21422142    //OSG_NOTICE<<"eye_v="<<eye_v<<std::endl; 
    21432143    //OSG_NOTICE<<"viewdir_v="<<viewdir_v<<std::endl; 
    2144      
     2144 
    21452145    osg::Vec3d eye_ls = frustum.eye * light_vp; 
    21462146#if 0 
     
    21512151    } 
    21522152#endif 
    2153      
     2153 
    21542154    //osg::Vec3d centerNearPlane_ls = frustum.centerNearPlane * light_vp; 
    21552155    //osg::Vec3d centerFarPlane_ls = frustum.centerFarPlane * light_vp; 
     
    21592159    osg::Vec3d side = lightdir ^ viewdir_ls; side.normalize(); 
    21602160    osg::Vec3d up = side ^ lightdir; 
    2161      
     2161 
    21622162    double d = 2.0; 
    21632163 
     
    21792179 
    21802180    //n = z_n; 
    2181      
     2181 
    21822182    double f = n+d; 
    21832183 
     
    22122212    OSG_NOTICE<<"convexHull max_z_ratio = "<<max_z_ratio<<std::endl; 
    22132213#endif 
    2214      
     2214 
    22152215    #if 1 
    22162216    if (renderStage) 
     
    22282228            return false; 
    22292229        } 
    2230          
     2230 
    22312231#if 0 
    22322232        OSG_NOTICE<<"Time for RenderLeafTraverser "<<timer.elapsedTime_m()<<"ms, number of render leaves "<<rli.numRenderLeaf<<std::endl; 
     
    22582258 
    22592259    //best_z_ratio *= 10.0; 
    2260      
     2260 
    22612261    osg::Matrixd lightPerspective( 1.0/best_x_ratio,  0.0, 0.0,  0.0, 
    22622262                                   0.0,  a,   0.0,  1.0, 
     
    23032303    OSG_INFO<<"cullShadowReceivingScene()"<<std::endl; 
    23042304 
    2305 #if 0     
     2305#if 0 
    23062306    // record the traversal mask on entry so we can reapply it later. 
    23072307    unsigned int traversalMask = cv->getTraversalMask(); 
     
    23222322{ 
    23232323    OSG_INFO<<"cullShadowCastingScene()"<<std::endl; 
    2324      
     2324 
    23252325    // record the traversal mask on entry so we can reapply it later. 
    23262326    unsigned int traversalMask = cv->getTraversalMask(); 
     
    23402340 
    23412341    osg::ref_ptr<osg::StateSet> stateset = vdd.getStateSet(); 
    2342      
     2342 
    23432343    vdd.getStateSet()->clear(); 
    2344      
     2344 
    23452345    vdd.getStateSet()->setTextureAttributeAndModes(0, _fallbackBaseTexture.get(), osg::StateAttribute::ON); 
    23462346 
     
    24032403        stateset->setTextureMode(sd._textureUnit,GL_TEXTURE_GEN_T,osg::StateAttribute::ON); 
    24042404        stateset->setTextureMode(sd._textureUnit,GL_TEXTURE_GEN_R,osg::StateAttribute::ON); 
    2405         stateset->setTextureMode(sd._textureUnit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON);        
     2405        stateset->setTextureMode(sd._textureUnit,GL_TEXTURE_GEN_Q,osg::StateAttribute::ON); 
    24062406    } 
    24072407 
     
    24112411void ViewDependentShadowMap::resizeGLObjectBuffers(unsigned int maxSize) 
    24122412{ 
    2413     // the way that ViewDependentData is mapped shouldn't  
     2413    // the way that ViewDependentData is mapped shouldn't 
    24142414} 
    24152415