ShadowVolumeOccluder

Go to the documentation of this file.

/* -*-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
 * (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
 * OpenSceneGraph Public License for more details.
*/
 
#ifndef OSG_SHADOWVOLUMEOCCLUDER
#define OSG_SHADOWVOLUMEOCCLUDER 1
 
#include <osg/Polytope>
#include <osg/ConvexPlanarOccluder>
#include <osg/Node>
 
namespace osg {
 
class CullStack;

class OSG_EXPORT ShadowVolumeOccluder
{
 
    public:
 
 
        typedef std::vector<Polytope> HoleList;
 
        ShadowVolumeOccluder(const ShadowVolumeOccluder& svo):
            _volume(svo._volume),
            _nodePath(svo._nodePath),
            _projectionMatrix(svo._projectionMatrix),
            _occluderVolume(svo._occluderVolume),
            _holeList(svo._holeList) {}
 
        ShadowVolumeOccluder():
            _volume(0.0f) {}
 
 
        bool operator < (const ShadowVolumeOccluder& svo) const { return getVolume()>svo.getVolume(); } // not greater volume first.

        bool computeOccluder(const NodePath& nodePath,const ConvexPlanarOccluder& occluder,CullStack& cullStack,bool createDrawables=false);
 
 
        inline void disableResultMasks();
 
        inline void pushCurrentMask();
        inline void popCurrentMask();
 

        bool matchProjectionMatrix(const osg::Matrix& matrix) const
        {
            if (_projectionMatrix.valid()) return matrix==*_projectionMatrix;
            else return false;
        }
 

        inline void setNodePath(NodePath& nodePath) { _nodePath = nodePath; }
        inline NodePath& getNodePath() { return _nodePath; }
        inline const NodePath& getNodePath() const { return _nodePath; }
 

        float getVolume() const { return _volume; }

        Polytope& getOccluder() { return _occluderVolume; }

        const Polytope& getOccluder() const { return _occluderVolume; }

        HoleList& getHoleList() { return _holeList; }

        const HoleList& getHoleList() const { return _holeList; }
 

        bool contains(const std::vector<Vec3>& vertices);

        bool contains(const BoundingSphere& bound);

        bool contains(const BoundingBox& bound);
 
        inline void transformProvidingInverse(const osg::Matrix& matrix)
        {
            _occluderVolume.transformProvidingInverse(matrix);
            for(HoleList::iterator itr=_holeList.begin();
                itr!=_holeList.end();
                ++itr)
            {
                itr->transformProvidingInverse(matrix);
            }
        }
 
 
    protected:
 
        float                       _volume;
        NodePath                    _nodePath;
        ref_ptr<const RefMatrix>    _projectionMatrix;
        Polytope                    _occluderVolume;
        HoleList                    _holeList;
};
 

typedef std::vector<ShadowVolumeOccluder> ShadowVolumeOccluderList;
 
 
inline void ShadowVolumeOccluder::disableResultMasks()
{
    //std::cout<<"ShadowVolumeOccluder::disableResultMasks() - _occluderVolume.getMaskStack().size()="<<_occluderVolume.getMaskStack().size()<<"  "<<_occluderVolume.getCurrentMask()<<std::endl;
    _occluderVolume.setResultMask(0);
    for(HoleList::iterator itr=_holeList.begin();
        itr!=_holeList.end();
        ++itr)
    {
        itr->setResultMask(0);
    }
}
 
inline void ShadowVolumeOccluder::pushCurrentMask()
{
    //std::cout<<"ShadowVolumeOccluder::pushCurrentMasks() - _occluderVolume.getMaskStack().size()="<<_occluderVolume.getMaskStack().size()<<"  "<<_occluderVolume.getCurrentMask()<<std::endl;
    _occluderVolume.pushCurrentMask();
    if (!_holeList.empty())
    {
        for(HoleList::iterator itr=_holeList.begin();
            itr!=_holeList.end();
            ++itr)
        {
            itr->pushCurrentMask();
        }
    }
}
 
inline void ShadowVolumeOccluder::popCurrentMask()
{
    _occluderVolume.popCurrentMask();
    if (!_holeList.empty())
    {
        for(HoleList::iterator itr=_holeList.begin();
            itr!=_holeList.end();
            ++itr)
        {
            itr->popCurrentMask();
        }
    }
    //std::cout<<"ShadowVolumeOccluder::popCurrentMasks() - _occluderVolume.getMaskStack().size()="<<_occluderVolume.getMaskStack().size()<<"  "<<_occluderVolume.getCurrentMask()<<std::endl;
}
 
}    // end of namespace
 
#endif