Changeset 13041 for OpenSceneGraph/trunk/src/osgShadow/LightSpacePerspectiveShadowMap.cpp

Timestamp:

03/21/12 18:36:20 (14 months ago)

Author:

robert

Message:

Ran script to remove trailing spaces and tabs

Files:

• OpenSceneGraph/trunk/src/osgShadow/LightSpacePerspectiveShadowMap.cpp (modified) (47 diffs)

OpenSceneGraph/trunk/src/osgShadow/LightSpacePerspectiveShadowMap.cpp

@@ -1 @@
-/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
  *
- * This library is open source and may be redistributed and/or modified under  
- * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
  * (at your option) any later version.  The full license is in LICENSE file
  * included with this distribution, and on the openscenegraph.org website.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * OpenSceneGraph Public License for more details.
  *
@@ -36 +36 @@
 
 ////////////////////////////////////////////////////////////////////////////////
-// There are two slightly differing implemetations available on 
+// There are two slightly differing implemetations available on
 // "Light Space Perspective Shadow Maps" page. One from 2004 and other from 2006.
 // Our implementation is written in two versions based on these solutions.
@@ -48 +48 @@
 // This code is copyright Vienna University of Technology, 2004.
 //
-// Please feel FREE to COPY and USE the code to include it in your own work, 
+// Please feel FREE to COPY and USE the code to include it in your own work,
 // provided you include this copyright notice.
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
-// 
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//
 // Authors Code:
 // Daniel Scherzer (scherzer@cg.tuwien.ac.at)
-// 
-// Authors Paper: 
+//
+// Authors Paper:
 // Michael Wimmer (wimmer@cg.tuwien.ac.at)
 // Daniel Scherzer (scherzer@cg.tuwien.ac.at)
@@ -88 +88 @@
     //temporal light View
     //look from position(eyePos)
-    //into direction(lightDir) 
+    //into direction(lightDir)
     //with up vector(up)
     look(lightView,eyePos,lightDir,up);
@@ -95 +95 @@
     transformVecPoint(B,lightView);
 
-    //calculate the cubic hull (an AABB) 
+    //calculate the cubic hull (an AABB)
     //of the light space extents of the intersection body B
     //and save the two extreme points min and max
@@ -103 +103 @@
         //use the formulas of the paper to get n (and f)
         const double factor = 1.0/sinGamma;
-        const double z_n = factor*nearDist; //often 1 
+        const double z_n = factor*nearDist; //often 1
         const double d = absDouble(max[1]-min[1]); //perspective transform depth //light space y extents
         const double z_f = z_n + d*sinGamma;
@@ -119 +119 @@
         //with the two parameters n(near) and f(far) in y direction
         copyMatrix(lispMtx,IDENTITY);    // a = (f+n)/(f-n); b = -2*f*n/(f-n);
-        lispMtx[ 5] = (f+n)/(f-n);        // [ 1 0 0 0] 
+        lispMtx[ 5] = (f+n)/(f-n);        // [ 1 0 0 0]
         lispMtx[13] = -2*f*n/(f-n);        // [ 0 a 0 b]
         lispMtx[ 7] = 1;                // [ 0 0 1 0]
@@ -126 +126 @@
         //temporal arrangement for the transformation of the points to post-perspective space
         mult(lightProjection,lispMtx,lightView); // ligthProjection = lispMtx*lightView
-        
+
         //transform the light volume points from world into the distorted light space
         transformVecPoint(&Bcopy,lightProjection);
 
-        //calculate the cubic hull (an AABB) 
+        //calculate the cubic hull (an AABB)
         //of the light space extents of the intersection body B
         //and save the two extreme points min and max
@@ -184 +184 @@
     const double sinGamma = sqrt(1.0- dotProd*dotProd);
     const double factor = 1.0/sinGamma;
-    const double z_n = factor*nearDist; //often 1 
+    const double z_n = factor*nearDist; //often 1
     //use the formulas of the paper to get n (and f)
     const double d = fabs( bb._max[1]-bb._min[1]); //perspective transform depth //light space y extents
@@ -194 +194 @@
 #if PRINT_COMPUTED_N_OPT
     std::cout
-       << " N=" << std::setw(8) << n 
+       << " N=" << std::setw(8) << n
        << " n=" << std::setw(8) << z_n
        << " f=" << std::setw(8) << z_f
-       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" 
+       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
        << std::flush;
 #endif
@@ -216 +216 @@
 #if 0
     {
-        osg::Matrix mvp = _camera->getViewMatrix() * 
+        osg::Matrix mvp = _camera->getViewMatrix() *
                       _camera->getProjectionMatrix();
 
@@ -232 +232 @@
     cameraShadow->setProjectionMatrix
         ( lightViewToWorld * lightView * lispProjection * fitToUnitFrustum );
-    
+
 
 #if 0 // DOUBLE CHECK!
     bb = computeScenePolytopeBounds
         ( cameraShadow->getViewMatrix() * cameraShadow->getProjectionMatrix() );
-    
+
     if( !osg::equivalent( 0.f, (bb._min - osg::Vec3d(-1,-1,-1)).length2() ) ||
         !osg::equivalent( 0.f, (bb._max - osg::Vec3d( 1, 1, 1)).length2() ) )
@@ -263 +263 @@
 
 void LightSpacePerspectiveShadowMapAlgorithm::operator()
-    ( const osgShadow::ConvexPolyhedron* hullShadowedView, 
-      const osg::Camera* cameraMain, 
+    ( const osgShadow::ConvexPolyhedron* hullShadowedView,
+      const osg::Camera* cameraMain,
       osg::Camera* cameraShadow ) const
 {
 
     // all computations are done in post projection light space
-    // which means we are in left handed coordinate system 
-    osg::Matrix mvpLight = 
+    // which means we are in left handed coordinate system
+    osg::Matrix mvpLight =
         cameraShadow->getViewMatrix() * cameraShadow->getProjectionMatrix();
 
@@ -298 +298 @@
     // as all computations are performed in post projection light space.
     // Frankly, I have my doubts if their error analysis and methodology still works
-    // in non directional lights post projective space. But since I can't prove it doesn't, 
-    // I assume it does ;-). So I made an effort to modify their original directional algo 
+    // in non directional lights post projective space. But since I can't prove it doesn't,
+    // I assume it does ;-). So I made an effort to modify their original directional algo
     // to work in true light post perspective space and compute all params in this space.
-    // And here is a snag. Although shadowed hull fits completely into light space, 
-    // camera position may not, and after projective transform it may land outside 
-    // light frustum and even on/or below infinity plane. I need camera pos to compute 
+    // And here is a snag. Although shadowed hull fits completely into light space,
+    // camera position may not, and after projective transform it may land outside
+    // light frustum and even on/or below infinity plane. I need camera pos to compute
     // minimal distance to shadowed hull. If its not right rest of the computation may
-    // be completely off. So in the end this approach is not singulartity free. 
-    // I guess this problem is solvable in other way but "this other 
-    // way" looks like a topic for other scientific paper and I am definitely not that 
-    // ambitious ;-). So for the time being I simply try to discover when this happens and 
-    // apply workaround, I found works. This workaround may mean that adjusted projection 
-    // may not be optimal in original LisPSM Lmax norm sense. But as I wrote above, 
-    // I doubt they are optimal when Light is not directional, anyway. 
-
-    // Seems that most nasty case when algorithm fails is when cam pos is 
-    // below light frustum near plane but above infinity plane - when this occurs 
-    // shadows simply disappear. My workaround is to find this case by 
+    // be completely off. So in the end this approach is not singulartity free.
+    // I guess this problem is solvable in other way but "this other
+    // way" looks like a topic for other scientific paper and I am definitely not that
+    // ambitious ;-). So for the time being I simply try to discover when this happens and
+    // apply workaround, I found works. This workaround may mean that adjusted projection
+    // may not be optimal in original LisPSM Lmax norm sense. But as I wrote above,
+    // I doubt they are optimal when Light is not directional, anyway.
+
+    // Seems that most nasty case when algorithm fails is when cam pos is
+    // below light frustum near plane but above infinity plane - when this occurs
+    // shadows simply disappear. My workaround is to find this case by
     // checking light postperspective transform camera z ( negative value means this )
     // and make sure min distance to shadow hull is clamped to positive value.
@@ -327 +327 @@
         // OSG_NOTICE<<"LightSpacePerspectiveShadowMapAlgorithm::operator() adjusting eye"<<std::endl;
 #endif
-        
+
     }
 #endif
@@ -341 +341 @@
 
     // Beware!!! Dirty Tricks:
-    // Light direction in light post proj space is actually (0,0,1) 
-    // But since we want to pass it to std OpenGL right handed coordinate 
-    // makeLookAt function we compensate the effects by also using right 
-    // handed view forward vector (ie 0,0,-1) instead. 
-    // So in the end we get left handed makeLookAt behaviour (D3D like)...    
-    // I agree this method is bizarre. But it works so I left it as is.  
-    // It sort of came out by itself through trial and error. 
-    // I later understoood why it works. 
+    // Light direction in light post proj space is actually (0,0,1)
+    // But since we want to pass it to std OpenGL right handed coordinate
+    // makeLookAt function we compensate the effects by also using right
+    // handed view forward vector (ie 0,0,-1) instead.
+    // So in the end we get left handed makeLookAt behaviour (D3D like)...
+    // I agree this method is bizarre. But it works so I left it as is.
+    // It sort of came out by itself through trial and error.
+    // I later understoood why it works.
 
     osg::Vec3 lightDir(0,0,-1);
@@ -368 +368 @@
     const double z_n = factor*nearDist;
     //perspective transform depth light space y extents
-    const double d = fabs( bb._max[1]-bb._min[1]); 
+    const double d = fabs( bb._max[1]-bb._min[1]);
     const double z_f = z_n + d*sinGamma;
     double n = (z_n+sqrt(z_f*z_n))/sinGamma;
@@ -383 +383 @@
     const double f = n+d;
     osg::Vec3d pos = eye-up*(n-nearDist);
-    //pos = eye;  
+    //pos = eye;
     lightView.makeLookAt( pos, pos + lightDir, up );
 
@@ -409 +409 @@
 
 // Adapted Modified version of LispSM authors implementation from 2006
-// Nopt formula differs from the paper. I adopted original authors class to 
+// Nopt formula differs from the paper. I adopted original authors class to
 // use with OSG
 
@@ -424 +424 @@
     typedef std::vector<osg::Vec3d> Vertices;
 
-    void setProjectionMatrix( const osg::Matrix & projectionMatrix ) 
+    void setProjectionMatrix( const osg::Matrix & projectionMatrix )
         { _projectionMatrix = projectionMatrix; }
 
-    void setViewMatrix( const osg::Matrix & viewMatrix ) 
+    void setViewMatrix( const osg::Matrix & viewMatrix )
         { _viewMatrix = viewMatrix; }
 
@@ -436 +436 @@
         { return _hull; }
 
-    const osg::Matrix & getProjectionMatrix( void ) const 
+    const osg::Matrix & getProjectionMatrix( void ) const
         { return _projectionMatrix; }
 
-    const osg::Matrix & getViewMatrix( void ) const 
+    const osg::Matrix & getViewMatrix( void ) const
         { return _viewMatrix; }
-    
-    bool getUseLiSPSM() const    
+
+    bool getUseLiSPSM() const
         { return _useLiSPSM; }
 
-    void setUseLiSPSM( bool use ) 
+    void setUseLiSPSM( bool use )
         { _useLiSPSM = use; }
 
@@ -451 +451 @@
         { return _useFormula; }
 
-    void setUseFormula( bool use ) 
+    void setUseFormula( bool use )
         { _useFormula = use; }
 
@@ -457 +457 @@
         { return _useOldFormula; }
 
-    void setUseOldFormula( bool use ) 
+    void setUseOldFormula( bool use )
         { _useOldFormula = use; }
 
-    void setN(const double& n )    
+    void setN(const double& n )
         { _N = n; }
 
-    const double getN() const    
-        { return _N; } 
+    const double getN() const
+        { return _N; }
 
     //for old LispSM formula from paper
@@ -470 +470 @@
         { return _nearDist; }
 
-    void setNearDist( const double & nearDist ) 
+    void setNearDist( const double & nearDist )
         { _nearDist = nearDist; }
 
@@ -476 +476 @@
         { return _farDist; }
 
-    void setFarDist( const double & farDist ) 
+    void setFarDist( const double & farDist )
         { _farDist = farDist; }
 
-    const osg::Vec3d & getEyeDir() const 
+    const osg::Vec3d & getEyeDir() const
         { return _eyeDir; }
 
-    const osg::Vec3d & getLightDir() const 
+    const osg::Vec3d & getLightDir() const
         { return _lightDir; }
 
-    void setEyeDir( const osg::Vec3d eyeDir ) 
+    void setEyeDir( const osg::Vec3d eyeDir )
         { _eyeDir = eyeDir; }
 
-    void setLightDir( const osg::Vec3d lightDir ) 
+    void setLightDir( const osg::Vec3d lightDir )
         { _lightDir = lightDir; }
 
@@ -512 +512 @@
 
     osg::Vec3d  getNearCameraPointE() const;
-    
+
     osg::Vec3d  getZ0_ls
                     (const osg::Matrix& lightSpace, const osg::Vec3d& e, const double& b_lsZmax, const osg::Vec3d& eyeDir) const;
@@ -539 +539 @@
 }
 
-osg::Vec3d LispSM::getNearCameraPointE( ) const 
+osg::Vec3d LispSM::getNearCameraPointE( ) const
 {
     const osg::Matrix& eyeView = getViewMatrix();
@@ -566 +566 @@
 //and on the near plane of the C frustum (the plane z = bZmax) and on the line x = e.x
 osg::Vec3d LispSM::getZ0_ls
-    (const osg::Matrix& lightSpace, const osg::Vec3d& e, const double& b_lsZmax, const osg::Vec3d& eyeDir) const 
-{
-    //to calculate the parallel plane to the near plane through e we 
+    (const osg::Matrix& lightSpace, const osg::Vec3d& e, const double& b_lsZmax, const osg::Vec3d& eyeDir) const
+{
+    //to calculate the parallel plane to the near plane through e we
     //calculate the plane A with the three points
     osg::Plane A(eyeDir,e);
@@ -576 +576 @@
     const osg::Vec3d e_ls = e * lightSpace;
 
-    //z_0 has the x coordinate of e, the z coord of B_lsZmax 
+    //z_0 has the x coordinate of e, the z coord of B_lsZmax
     //and the y coord of the plane A and plane (z==B_lsZmax) intersection
 #if 1
     osg::Vec3d v = osg::Vec3d(e_ls.x(),0,b_lsZmax);
 
-    // x & z are given. We compute y from equations: 
+    // x & z are given. We compute y from equations:
     // A.distance( x,y,z ) == 0
     // A.distance( x,y,z ) == A.distance( x,0,z ) + A.normal.y * y
@@ -598 +598 @@
 }
 
-double LispSM::calcNoptGeneral(const osg::Matrix lightSpace, const osg::BoundingBox& B_ls) const 
+double LispSM::calcNoptGeneral(const osg::Matrix lightSpace, const osg::BoundingBox& B_ls) const
 {
     const osg::Matrix& eyeView = getViewMatrix();
@@ -605 +605 @@
     const osg::Vec3d z0_ls = getZ0_ls(lightSpace, _E,B_ls.zMax(),getEyeDir());
     const osg::Vec3d z1_ls = osg::Vec3d(z0_ls.x(),z0_ls.y(),B_ls.zMin());
-    
+
     //to world
     const osg::Vec4d z0_ws = osg::Vec4d( z0_ls, 1 ) * invLightSpace;
@@ -620 +620 @@
 
         // solve camera pos singularity in light space problem brutally:
-        // if extreme points of B projected to Light space extend beyond 
+        // if extreme points of B projected to Light space extend beyond
         // camera frustum simply use B extents in camera frustum
 
-        // Its not optimal selection but ceratainly better than negative N       
+        // Its not optimal selection but ceratainly better than negative N
         osg::BoundingBox bb = _hull.computeBoundingBox( eyeView );
         z0 = -bb.zMax();
-        if( z0 <= 0 ) 
+        if( z0 <= 0 )
             z0 = 0.1;
 
         z1 = -bb.zMin();
-        if( z1 <= z0 ) 
+        if( z1 <= z0 )
             z1 = z0 + 0.1;
     }
@@ -639 +639 @@
 #if PRINT_COMPUTED_N_OPT
     std::cout
-       << " N=" << std::setw(8) << N 
+       << " N=" << std::setw(8) << N
        << " n=" << std::setw(8) << z0
        << " f=" << std::setw(8) << z1
-       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" 
+       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
        << std::flush;
 #endif
@@ -648 +648 @@
 }
 
-double LispSM::calcNoptOld( const double gamma_ ) const 
+double LispSM::calcNoptOld( const double gamma_ ) const
 {
     const double& n = getNearDist();
@@ -665 +665 @@
 #if PRINT_COMPUTED_N_OPT
     std::cout
-       << " N=" << std::setw(8) << N 
+       << " N=" << std::setw(8) << N
        << " n=" << std::setw(8) << n
        << " f=" << std::setw(8) << f
-       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" 
+       << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
        << std::flush;
 #endif
@@ -674 +674 @@
 }
 
-double LispSM::getN(const osg::Matrix lightSpace, const osg::BoundingBox& B_ls) const 
+double LispSM::getN(const osg::Matrix lightSpace, const osg::BoundingBox& B_ls) const
 {
     if( getUseFormula()) {
@@ -687 +687 @@
 }
 //this is the algorithm discussed in the article
-osg::Matrix LispSM::getLispSmMtx( const osg::Matrix& lightSpace ) const 
+osg::Matrix LispSM::getLispSmMtx( const osg::Matrix& lightSpace ) const
 {
     const osg::BoundingBox B_ls = _hull.computeBoundingBox( lightSpace );
@@ -695 +695 @@
     //get the coordinates of the near camera point in light space
     const osg::Vec3d e_ls = _E * lightSpace;
-    //c start has the x and y coordinate of e, the z coord of B.min() 
+    //c start has the x and y coordinate of e, the z coord of B.min()
     const osg::Vec3d Cstart_lp(e_ls.x(),e_ls.y(),B_ls.zMax());
 
@@ -713 +713 @@
 
     //the lispsm perspective transformation
-    
+
     //here done with a standard frustum call that maps P onto the unit cube with
     //corner points [-1,-1,-1] and [1,1,1].
@@ -751 +751 @@
     }
 
-    osg::Vec3d projDir( osg::Vec3( b_lp[0], b_lp[1], b_lp[2] ) / b_lp[3] - 
+    osg::Vec3d projDir( osg::Vec3( b_lp[0], b_lp[1], b_lp[2] ) / b_lp[3] -
                         osg::Vec3( e_lp[0], e_lp[1], e_lp[2] ) / e_lp[3] );
 
@@ -762 +762 @@
 
 void LispSM::updateLightMtx
-    ( osg::Matrix& lightView, osg::Matrix& lightProj ) const 
+    ( osg::Matrix& lightView, osg::Matrix& lightProj ) const
 {
     //calculate standard light space for spot or directional lights
-    //this routine returns two matrices: 
+    //this routine returns two matrices:
     //lightview contains the rotated translated frame
     //lightproj contains in the case of a spot light the spot light perspective transformation
@@ -791 +791 @@
     osg::Matrix L = lightView * lightProj;
 
-    osg::Vec3d projViewDir = getProjViewDir_ls(L); 
+    osg::Vec3d projViewDir = getProjViewDir_ls(L);
 
     if( getUseLiSPSM() /* && projViewDir.z() < 0*/ ) {
@@ -798 +798 @@
         //calculate a frame matrix that uses the projViewDir[light-space] as up vector
         //look(from position, into the direction of the projected direction, with unchanged up-vector)
-        lightProj = lightProj * 
+        lightProj = lightProj *
             osg::Matrix::lookAt( osg::Vec3d(0,0,0), projViewDir, osg::Vec3d(0,1,0) );
 
@@ -832 +832 @@
 void LightSpacePerspectiveShadowMapAlgorithm::operator()
     ( const osgShadow::ConvexPolyhedron* hullShadowedView,
-      const osg::Camera* cameraMain, 
+      const osg::Camera* cameraMain,
       osg::Camera* cameraShadow ) const
 {
@@ -844 +844 @@
 
 #else
-    
+
     osg::Vec3d lightDir = osg::Matrix::transform3x3( cameraShadow->getViewMatrix(), osg::Vec3d( 0.0, 0.0, -1.0 ) );
     osg::Vec3d eyeDir = osg::Matrix::transform3x3( cameraMain->getViewMatrix(), osg::Vec3d( 0.0, 0.0, -1.0 ) );
@@ -860 +860 @@
     if( proj.getOrtho( l,r,b,t,n,f ) )
     {
-        osg::Vec3d camPosInLightSpace = 
-            osg::Vec3d( 0, 0, 0 ) * 
-            osg::Matrix::inverse( cameraMain->getViewMatrix() ) * 
+        osg::Vec3d camPosInLightSpace =
+            osg::Vec3d( 0, 0, 0 ) *
+            osg::Matrix::inverse( cameraMain->getViewMatrix() ) *
             cameraShadow->getViewMatrix() *
             cameraShadow->getProjectionMatrix();
@@ -871 +871 @@
     lispsm->setEyeDir( eyeDir );
 
-    osg::BoundingBox bb = 
+    osg::BoundingBox bb =
         hullShadowedView->computeBoundingBox( cameraMain->getViewMatrix() );