StateAttribute.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.
*/

#ifndef OSG_STATEATTRIBUTE
#define OSG_STATEATTRIBUTE 1

#include <osg/Export>
#include <osg/Object>
#include <osg/Callback>
#include <osg/Shader>
#include <osg/GL>

#include <typeinfo>
#include <utility>
#include <vector>

// define for the GL_EXT_secondary_color extension, GL_COLOR_SUM is OpenGL
// mode to be used to enable and disable the second color.
#ifndef GL_COLOR_SUM
#define GL_COLOR_SUM    0x8458
#endif

namespace osg {


// forward declare NodeVisitor, State & StateSet
class NodeVisitor;
class State;
class ShaderComposer;
class StateSet;
class Texture;

#define META_StateAttribute(library,name,type) \
        virtual osg::Object* cloneType() const { return new name(); } \
        virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new name (*this,copyop); } \
        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const name *>(obj)!=NULL; } \
        virtual const char* libraryName() const { return #library; } \
        virtual const char* className() const { return #name; } \
        virtual Type getType() const { return type; }

#define COMPARE_StateAttribute_Types(TYPE,rhs_attribute) \
            if (this==&rhs_attribute) return 0;\
            const std::type_info* type_lhs = &typeid(*this);\
            const std::type_info* type_rhs = &typeid(rhs_attribute);\
            if (type_lhs->before(*type_rhs)) return -1;\
            if (*type_lhs != *type_rhs) return 1;\
            const TYPE& rhs = static_cast<const TYPE&>(rhs_attribute);


#define COMPARE_StateAttribute_Parameter(parameter) \
        if (parameter<rhs.parameter) return -1; \
        if (rhs.parameter<parameter) return 1;


class OSG_EXPORT StateAttribute : public Object
{
    public :

        typedef GLenum          GLMode;
        typedef unsigned int    GLModeValue;
        typedef unsigned int    OverrideValue;

        enum Values
        {
            OFF          = 0x0,
            ON           = 0x1,
            OVERRIDE     = 0x2,
            PROTECTED    = 0x4,
            INHERIT      = 0x8
        };

        // typedef unsigned int Type;

        enum Type
        {
            TEXTURE,

            POLYGONMODE,
            POLYGONOFFSET,
            MATERIAL,
            ALPHAFUNC,
            ANTIALIAS,
            COLORTABLE,
            CULLFACE,
            FOG,
            FRONTFACE,

            LIGHT,

            POINT,
            LINEWIDTH,
            LINESTIPPLE,
            POLYGONSTIPPLE,
            SHADEMODEL,
            TEXENV,
            TEXENVFILTER,
            TEXGEN,
            TEXMAT,
            LIGHTMODEL,
            BLENDFUNC,
            BLENDEQUATION,
            LOGICOP,
            STENCIL,
            COLORMASK,
            DEPTH,
            VIEWPORT,
            SCISSOR,
            BLENDCOLOR,
            MULTISAMPLE,
            CLIPPLANE,
            COLORMATRIX,
            VERTEXPROGRAM,
            FRAGMENTPROGRAM,
            POINTSPRITE,
            PROGRAM,
            CLAMPCOLOR,
            HINT,
            SAMPLEMASKI,
            PRIMITIVERESTARTINDEX,
            CLIPCONTROL,

            VALIDATOR,
            VIEWMATRIXEXTRACTOR,

            OSGNV_PARAMETER_BLOCK,

            // osgNVExt namespace
            OSGNVEXT_TEXTURE_SHADER,
            OSGNVEXT_VERTEX_PROGRAM,
            OSGNVEXT_REGISTER_COMBINERS,

            OSGNVCG_PROGRAM,

            // osgNVSlang namespace
            OSGNVSLANG_PROGRAM,

            // osgNVParse
            OSGNVPARSE_PROGRAM_PARSER,

            UNIFORMBUFFERBINDING,
            TRANSFORMFEEDBACKBUFFERBINDING,

            ATOMICCOUNTERBUFFERBINDING,

            PATCH_PARAMETER,

            FRAME_BUFFER_OBJECT,

            VERTEX_ATTRIB_DIVISOR,

            SHADERSTORAGEBUFFERBINDING,

            CAPABILITY = 100
        };

        typedef std::pair<Type,unsigned int> TypeMemberPair;

        StateAttribute();

        StateAttribute(const StateAttribute& sa,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
            Object(sa,copyop),
            _shaderComponent(sa._shaderComponent),
            _updateCallback(copyop(sa._updateCallback.get())),
            _eventCallback(copyop(sa._eventCallback.get()))
            {}


        virtual Object* cloneType() const = 0;

        virtual Object* clone(const CopyOp&) const = 0;

        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const StateAttribute*>(obj)!=NULL; }

        virtual const char* libraryName() const { return "osg"; }

        virtual const char* className() const { return "StateAttribute"; }


        virtual StateAttribute* asStateAttribute() { return this; }

        virtual const StateAttribute* asStateAttribute() const { return this; }

        virtual Texture* asTexture() { return 0; }

        virtual const Texture* asTexture() const { return 0; }


        virtual Type getType() const = 0;

        virtual unsigned int getMember() const { return 0; }

        inline TypeMemberPair getTypeMemberPair() const { return TypeMemberPair(getType(),getMember()); }

        virtual bool isTextureAttribute() const { return false; }

        virtual int compare(const StateAttribute& sa) const = 0;

        bool operator <  (const StateAttribute& rhs) const { return compare(rhs)<0; }
        bool operator == (const StateAttribute& rhs) const { return compare(rhs)==0; }
        bool operator != (const StateAttribute& rhs) const { return compare(rhs)!=0; }


        typedef std::vector<StateSet*> ParentList;

        inline const ParentList& getParents() const { return _parents; }

        inline StateSet* getParent(unsigned int i)  { return _parents[i]; }
        inline const StateSet* getParent(unsigned int i) const  { return _parents[i]; }

        inline unsigned int getNumParents() const { return static_cast<unsigned int>(_parents.size()); }

        void setShaderComponent(ShaderComponent* sc) { _shaderComponent = sc; }
        ShaderComponent* getShaderComponent() { return _shaderComponent.get(); }
        const ShaderComponent* getShaderComponent() const { return _shaderComponent.get(); }

        struct ModeUsage
        {
            virtual ~ModeUsage() {}
            virtual void usesMode(GLMode mode) = 0;
            virtual void usesTextureMode(GLMode mode) = 0;
        };

        virtual bool getModeUsage(ModeUsage&) const
        {
            // default to no GLMode's associated with use of the StateAttribute.
            return false;
        }

        virtual bool checkValidityOfAssociatedModes(osg::State&) const
        {
            // default to no black listed GLMode's associated with use of the StateAttribute.
            return true;
        }

        // provide callback for backwards compatibility.
        typedef osg::StateAttributeCallback Callback;

        void setUpdateCallback(StateAttributeCallback* uc);

        StateAttributeCallback* getUpdateCallback() { return _updateCallback.get(); }

        const StateAttributeCallback* getUpdateCallback() const { return _updateCallback.get(); }


        void setEventCallback(StateAttributeCallback* ec);

        StateAttributeCallback* getEventCallback() { return _eventCallback.get(); }

        const StateAttributeCallback* getEventCallback() const { return _eventCallback.get(); }


        virtual void apply(State&) const {}

        virtual void compileGLObjects(State&) const {}

        virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/) {}

        virtual void releaseGLObjects(State* =0) const {}


    protected:

        virtual ~StateAttribute() {}

        void addParent(osg::StateSet* object);
        void removeParent(osg::StateSet* object);

        ParentList _parents;
        friend class osg::StateSet;

        ref_ptr<ShaderComponent>          _shaderComponent;

        ref_ptr<StateAttributeCallback>   _updateCallback;
        ref_ptr<StateAttributeCallback>   _eventCallback;
};

}

#endif