Technique.h

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.
*/
//osgFX - Copyright (C) 2003 Marco Jez

#ifndef OSGFX_TECHNIQUE_
#define OSGFX_TECHNIQUE_

#include <osgFX/Export>

#include <osg/Referenced>
#include <osg/State>
#include <osg/Group>
#include <osg/NodeVisitor>

#include <vector>
#include <string>

#define META_Technique(name, description) \
    inline virtual const char *techniqueName() { return name; } \
    inline virtual const char *techniqueDescription() { return description; }


namespace osgFX
{

    class Effect;

    class OSGFX_EXPORT Technique: public osg::Referenced {
    public:
        Technique();

        virtual const char *techniqueName()        { return "Default"; }

        virtual const char *techniqueDescription() { return "This is the default technique"; }

        virtual void getRequiredExtensions(std::vector<std::string>&  /*extensions*/) const {};

        virtual bool validate(osg::State& ) const;

        inline int getNumPasses() const;

        inline osg::StateSet* getPassStateSet(int i);

        inline const osg::StateSet* getPassStateSet(int i) const;

        inline virtual void traverse(osg::NodeVisitor& nv, Effect* fx);

    protected:
        Technique(const Technique &): osg::Referenced() {}    // copying is nonsense ;)
        virtual ~Technique() {}
        Technique &operator=(const Technique &)  { return *this; }

        inline void dirtyPasses();

        void addPass(osg::StateSet* ss = 0);

        inline virtual osg::Node* getOverrideChild(int)  { return 0; }

        virtual void define_passes() = 0;

        void traverse_implementation(osg::NodeVisitor& nv, Effect* fx);

    private:
        typedef std::vector<osg::ref_ptr<osg::StateSet> > Pass_list;
        Pass_list _passes;
    };

    // INLINE METHODS

    inline int Technique::getNumPasses() const
    {
        return static_cast<int>(_passes.size());
    }

    inline osg::StateSet* Technique::getPassStateSet(int i)
    {
        return _passes[i].get();
    }

    inline const osg::StateSet* Technique::getPassStateSet(int i) const
    {
        return _passes[i].get();
    }

    inline void Technique::dirtyPasses()
    {
        _passes.clear();
    }

    inline void Technique::traverse(osg::NodeVisitor& nv, Effect* fx)
    {
        traverse_implementation(nv, fx);
    }

}

#endif