osg轮廓特效

墨蓝 2022-08-05 15:13 214阅读 0赞

// -\*-c++-\*-

/\*  
 \* OpenSceneGraph - Copyright (C) 1998-2003 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.  
 \*/

/\*  
 \* osgFX::Outline - Copyright (C) 2004,2009 Ulrich Hertlein  
 \*/

\#ifndef OSGFX\_OUTLINE\_  
\#define OSGFX\_OUTLINE\_

\#include <osgFX/Export>  
\#include <osgFX/Effect>

namespace osgFX  
\{  
    /\*\*  
     \* Outline effect.  
     \*/  
    class Outline : public Effect  
    \{  
    public:  
        /// Constructor.  
        Outline();  
        Outline(const Outline& copy,  
                const osg::CopyOp& op = osg::CopyOp::SHALLOW\_COPY)  
            : Effect(copy, op) \{  
            \_width = copy.\_width;  
            \_color = copy.\_color;  
        \}

// Effect class info  
        META\_Effect(osgFX, Outline, "Outline",  
                    "Stencil buffer based object outlining.",  
                    "Ulrich Hertlein <[u.hertlein@sandbox.de][u.hertlein_sandbox.de]>");

/// Set outline width.  
        void setWidth(float w) \{  
            \_width = w;  
        \}

/// Get outline width.  
        float getWidth() const \{  
            return \_width;  
        \}

/// Set outline color.  
        void setColor(const osg::Vec4& col) \{  
            \_color = col;  
        \}

/// Get outline color.  
        const osg::Vec4& getColor() const \{  
            return \_color;  
        \}

protected:  
        /// Destructor.  
        virtual ~Outline() \{  
        \}

/// Define available techniques.  
        bool define\_techniques();

private:  
        /// Outline width.  
        float \_width;

/// Outline color.  
        osg::Vec4 \_color;  
    \};  
\};

\#endif

// -\*-c++-\*-

/\*  
 \* OpenSceneGraph - Copyright (C) 1998-2009 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.  
 \*/

/\*  
 \* osgFX::Outline - Copyright (C) 2004,2009 Ulrich Hertlein  
 \*/

\#include <osgFX/Outline>  
\#include <osgFX/Registry>

\#include <osg/Group>  
\#include <osg/Stencil>  
\#include <osg/CullFace>  
\#include <osg/PolygonMode>  
\#include <osg/LineWidth>  
\#include <osg/Material>

\#include <osg/NodeCallback>  
\#include <osgUtil/CullVisitor>

\#include <iostream>

const unsigned int Override\_On = osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE;  
const unsigned int Override\_Off = osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE;

namespace osgFX  
\{  
    /// Register prototype.  
    Registry::Proxy proxy(new Outline);

/\*\*  
     \* Outline technique.  
     \*/  
    class OutlineTechnique : public Technique  
    \{  
    public:  
        /// Constructor.  
        OutlineTechnique(const Outline& outline) : Technique() \{  
            \_outline = &outline;  
        \}

/// Validate.  
        bool validate(osg::State&) const \{  
            return true;  
        \}

protected:  
        /// Define render passes.  
        void define\_passes() \{

/\*  
             \* draw  
             \* - set stencil buffer to ref=1 where draw occurs  
             \* - clear stencil buffer to 0 where test fails  
             \*/  
            \{  
                osg::StateSet\* state = new osg::StateSet;

// stencil op  
                osg::Stencil\* stencil  = new osg::Stencil;  
                stencil->setFunction(osg::Stencil::ALWAYS, 1, ~0);  
                stencil->setOperation(osg::Stencil::KEEP,  
                                      osg::Stencil::KEEP,  
                                      osg::Stencil::REPLACE);  
                state->setAttributeAndModes(stencil, Override\_On);

addPass(state);  
            \}

/\*  
             \* post-draw  
             \* - only draw where draw didn't set the stencil buffer  
             \* - draw only back-facing polygons  
             \* - draw back-facing polys as lines  
             \* - disable depth-test, lighting & texture  
             \*/  
            \{  
                osg::StateSet\* state = new osg::StateSet;

// stencil op  
                osg::Stencil\* stencil  = new osg::Stencil;  
                stencil->setFunction(osg::Stencil::NOTEQUAL, 1, ~0);  
                stencil->setOperation(osg::Stencil::KEEP,  
                                      osg::Stencil::KEEP,  
                                      osg::Stencil::REPLACE);  
                state->setAttributeAndModes(stencil, Override\_On);

// cull front-facing polys  
                osg::CullFace\* cf = new osg::CullFace;  
                cf->setMode(osg::CullFace::FRONT);  
                state->setAttributeAndModes(cf, Override\_On);

// poly mode for back-facing polys  
                osg::PolygonMode\* pm = new osg::PolygonMode;  
                pm->setMode(osg::PolygonMode::BACK, osg::PolygonMode::LINE);  
                state->setAttributeAndModes(pm, Override\_On);

// outline width  
                osg::LineWidth\* lw = new osg::LineWidth;  
                lw->setWidth(\_outline->getWidth());  
                state->setAttributeAndModes(lw, Override\_On);

// outline color/material  
                const osg::Material::Face face = osg::Material::FRONT\_AND\_BACK;  
                osg::Material\* mtl = new osg::Material;  
                mtl->setColorMode(osg::Material::AMBIENT\_AND\_DIFFUSE);  
                mtl->setAmbient(face, \_outline->getColor());  
                mtl->setDiffuse(face, \_outline->getColor());  
                mtl->setEmission(face, \_outline->getColor());  
                state->setAttributeAndModes(mtl, Override\_On);

// disable modes  
                state->setMode(GL\_BLEND, Override\_Off);  
                state->setMode(GL\_DEPTH\_TEST, Override\_Off);  
                state->setTextureMode(0, GL\_TEXTURE\_1D, Override\_Off);  
                state->setTextureMode(0, GL\_TEXTURE\_2D, Override\_Off);  
                state->setTextureMode(0, GL\_TEXTURE\_3D, Override\_Off);

addPass(state);  
            \}  
        \}

private:  
        /// Outline effect.  
        osg::ref\_ptr<const Outline> \_outline;  
    \};

/\*\*  
     \* Enable stencil clear callback.  
     \*/  
    class EnableStencilCallback : public osg::NodeCallback  
    \{  
    public:  
        EnableStencilCallback() \{\}

virtual void operator()(osg::Node\* node, osg::NodeVisitor\* nv) \{

osgUtil::CullVisitor\* cv = dynamic\_cast<osgUtil::CullVisitor\*>(nv);  
            if (cv) \{  
                // enable stencil clear on render stage  
                osgUtil::RenderStage\* render = cv->getRenderStage();  
                unsigned int mask = render->getClearMask();  
                if ((mask & GL\_STENCIL\_BUFFER\_BIT) == 0) \{  
                    render->setClearMask(mask | GL\_STENCIL\_BUFFER\_BIT);  
                    render->setClearStencil(0);  
                    //std::cerr << "osgFX::Outline activated stencil/n";  
                \}  
            \}

traverse(node, nv);  
        \}

private:  
    \};

/// Constructor.  
    Outline::Outline() : Effect()  
    \{  
        \_width = 3.0f;  
        \_color.set(1.0f,1.0f,1.0f,1.0f);  
        addCullCallback(new EnableStencilCallback);  
    \}

/// Define available techniques.  
    bool Outline::define\_techniques()  
    \{  
        addTechnique(new OutlineTechnique(\*this));  
        return true;  
    \}  
\};

[u.hertlein_sandbox.de]: mailto:u.hertlein@sandbox.de