root/OpenSceneGraph/trunk/include/osg/StateAttribute @ 10671

Revision 10671, 13.3 kB (checked in by robert, 4 years ago)

From Cedric Pinson, "Here a patch to be able to clone stateattribute, in order to do that i
moved the StateAttribute::Callback structure to a file
StateAttributeCallback? with the same behavior as NodeCallback?.
"

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
RevLine 
[5328]1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
[1529]2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
[51]13
[10]14#ifndef OSG_STATEATTRIBUTE
15#define OSG_STATEATTRIBUTE 1
16
[585]17#include <osg/Export>
[10]18#include <osg/Object>
[10671]19#include <osg/StateAttributeCallback>
[10]20#include <osg/GL>
21
[26]22#include <typeinfo>
[3488]23#include <utility>
[4091]24#include <vector>
[26]25
[3766]26// define for the GL_EXT_secondary_color extension, GL_COLOR_SUM is OpenGL
27// mode to be used to enable and disable the second color.
28#ifndef GL_COLOR_SUM
29#define GL_COLOR_SUM    0x8458
30#endif
31
[10]32namespace osg {
33
[3222]34
[4084]35// forward declare NodeVisitor, State & StateSet
36class NodeVisitor;
[10]37class State;
38class StateSet;
[8655]39class Texture;
[10]40
[26]41/** META_StateAttribute macro define the standard clone, isSameKindAs,
42  * className and getType methods.
[3375]43  * Use when subclassing from Object to make it more convenient to define
[26]44  * the standard pure virtual methods which are required for all Object
45  * subclasses.*/
[740]46#define META_StateAttribute(library,name,type) \
[1418]47        virtual osg::Object* cloneType() const { return new name(); } \
48        virtual osg::Object* clone(const osg::CopyOp& copyop) const { return new name (*this,copyop); } \
[327]49        virtual bool isSameKindAs(const osg::Object* obj) const { return dynamic_cast<const name *>(obj)!=NULL; } \
[740]50        virtual const char* libraryName() const { return #library; } \
[26]51        virtual const char* className() const { return #name; } \
[1133]52        virtual Type getType() const { return type; }
[26]53
[3375]54/** COMPARE_StateAttribute_Types macro is a helper for implementing the StateAtribute::compare(..) method.*/
[26]55#define COMPARE_StateAttribute_Types(TYPE,rhs_attribute) \
56            if (this==&rhs_attribute) return 0;\
57            const std::type_info* type_lhs = &typeid(*this);\
58            const std::type_info* type_rhs = &typeid(rhs_attribute);\
59            if (type_lhs->before(*type_rhs)) return -1;\
60            if (*type_lhs != *type_rhs) return 1;\
61            const TYPE& rhs = static_cast<const TYPE&>(rhs_attribute);
62
63
64/** COMPARE_StateAttribute_Parameter macro is a helper for implementing the StatateAtribute::compare(..) method.
[3375]65  * Macro assumes that variable rhs has been correctly defined by preceding code
[26]66  * macro.*/
67#define COMPARE_StateAttribute_Parameter(parameter) \
68        if (parameter<rhs.parameter) return -1; \
69        if (rhs.parameter<parameter) return 1;
70
[1115]71
[3375]72/** Base class for state attributes.
[10]73*/     
[4021]74class OSG_EXPORT StateAttribute : public Object
[10]75{
76    public :
77   
78        /** GLMode is the value used in glEnable/glDisable(mode) */
79        typedef GLenum          GLMode;
[3375]80        /** GLModeValue is used to specify whether a mode is enabled (ON) or disabled (OFF).
[39]81          * GLMoveValue is also used to specify the override behavior of modes from parent to children.
[10]82          * See enum Value description for more details.*/
83        typedef unsigned int    GLModeValue;
[3375]84        /** Override is used to specify the override behavior of StateAttributes
85          * from parent to children.
[10]86          * See enum Value description for more details.*/
[2306]87        typedef unsigned int    OverrideValue;
[10]88
[3375]89        /** list values which can be used to set either GLModeValues or OverrideValues.
90          * When using in conjunction with GLModeValues, all Values have meaning.
[7648]91          * When using in conjunction with StateAttribute OverrideValue only
[3375]92          * OFF,OVERRIDE and INHERIT are meaningful.
93          * However, they are useful when using GLModeValue
[10]94          * and OverrideValue in conjunction with each other as when using
95          * StateSet::setAttributeAndModes(..).*/
96        enum Values
97        {
98            /** means that associated GLMode and Override is disabled.*/
99            OFF          = 0x0,
100            /** means that associated GLMode is enabled and Override is disabled.*/
101            ON           = 0x1,
[3375]102            /** Overriding of GLMode's or StateAttributes is enabled, so that state below it is overridden.*/
[10]103            OVERRIDE     = 0x2,
[3375]104            /** Protecting of GLMode's or StateAttributes is enabled, so that state from above cannot override this and below state.*/
[1008]105            PROTECTED    = 0x4,           
[3375]106            /** means that GLMode or StateAttribute should be inherited from above.*/
[1008]107            INHERIT      = 0x8
[10]108        };
[248]109       
[26]110        /** Type identifier to differentiate between different state types. */
[3482]111        // typedef unsigned int Type;
[26]112
[10]113        /** Values of StateAttribute::Type used to aid identification
[39]114          * of different StateAttribute subclasses. Each subclass defines
[3375]115          * its own value in the virtual Type getType() method.  When
[10]116          * extending the osg's StateAttribute's simply define your
117          * own Type value which is unique, using the StateAttribute::Type
118          * enum as a guide of what values to use.  If your new subclass
[3375]119          * needs to override a standard StateAttriubte then simply use
120          * that type's value. */
[3482]121        enum Type
[10]122        {
[299]123            TEXTURE,
[225]124           
[489]125            POLYGONMODE,
126            POLYGONOFFSET,
[299]127            MATERIAL,
128            ALPHAFUNC,
129            ANTIALIAS,
130            COLORTABLE,
131            CULLFACE,
132            FOG,
133            FRONTFACE,
[225]134           
[299]135            LIGHT,
[233]136
[299]137            POINT,
138            LINEWIDTH,
[422]139            LINESTIPPLE,
[1164]140            POLYGONSTIPPLE,
[299]141            SHADEMODEL,
142            TEXENV,
[3494]143            TEXENVFILTER,
[299]144            TEXGEN,
145            TEXMAT,
[426]146            LIGHTMODEL,
[867]147            BLENDFUNC,
[3922]148            BLENDEQUATION,
149            LOGICOP,
[299]150            STENCIL,
151            COLORMASK,
152            DEPTH,
153            VIEWPORT,
[4407]154            SCISSOR,
[2306]155            BLENDCOLOR,
156            MULTISAMPLE,
[299]157            CLIPPLANE,
[1448]158            COLORMATRIX,
159            VERTEXPROGRAM,
[2032]160            FRAGMENTPROGRAM,
[3482]161            POINTSPRITE,
[4039]162            PROGRAM,
[5169]163            CLAMPCOLOR,
[6824]164            HINT,
[4039]165
[3482]166            /// osgFX namespace
167            VALIDATOR,
168            VIEWMATRIXEXTRACTOR,
[3500]169           
[4039]170            /// osgNV namespace
[3922]171            OSGNV_PARAMETER_BLOCK,
172
[3500]173            // osgNVExt namespace
[3922]174            OSGNVEXT_TEXTURE_SHADER,
175            OSGNVEXT_VERTEX_PROGRAM,
176            OSGNVEXT_REGISTER_COMBINERS,
177
[4039]178            /// osgNVCg namespace
[3922]179            OSGNVCG_PROGRAM,
180
181            // osgNVSlang namespace
182            OSGNVSLANG_PROGRAM,
183
[3500]184            // osgNVParse
[6842]185            OSGNVPARSE_PROGRAM_PARSER
[10]186        };
[3488]187       
188        /** Simple pairing between an attribute type and the member within that attribute type group.*/
189        typedef std::pair<Type,unsigned int> TypeMemberPair;
[10]190
[7263]191        StateAttribute();
[327]192       
[331]193        StateAttribute(const StateAttribute& sa,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
[10671]194            Object(sa,copyop),
195            _updateCallback(copyop(sa._updateCallback.get()))
196            {}
[327]197       
[10]198
[327]199        /** Clone the type of an attribute, with Object* return type.
200            Must be defined by derived classes.*/
201        virtual Object* cloneType() const = 0;
[10]202
[327]203        /** Clone an attribute, with Object* return type.
204            Must be defined by derived classes.*/
[331]205        virtual Object* clone(const CopyOp&) const = 0;
[327]206
[3488]207        /** Return true if this and obj are of the same kind of object.*/
[10]208        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const StateAttribute*>(obj)!=NULL; }
209
[3488]210        /** Return the name of the attribute's library.*/
[740]211        virtual const char* libraryName() const { return "osg"; }
212
[3488]213        /** Return the name of the attribute's class type.*/
[10]214        virtual const char* className() const { return "StateAttribute"; }
215       
[8655]216       
217        /** Fast alternative to dynamic_cast<> for determining if state attribute is a Texture.*/
218        virtual Texture* asTexture() { return 0; }
219       
220        /** Fast alternative to dynamic_cast<> for determining if state attribute is a Texture.*/
221        virtual const Texture* asTexture() const { return 0; }
222
223       
[3488]224        /** Return the Type identifier of the attribute's class type.*/
[1133]225        virtual Type getType() const = 0;
[26]226
[3488]227        /** Return the member identifier within the attribute's class type. Used for light number/clip plane number etc.*/
228        virtual unsigned int getMember() const { return 0; }
229
230        /** Return the TypeMemberPair that uniquely identifies this type member.*/
231        inline TypeMemberPair getTypeMemberPair() const { return TypeMemberPair(getType(),getMember()); }
232
233        /** Return true if StateAttribute is a type which controls texturing and needs to be issued w.r.t to specific texture unit.*/
[836]234        virtual bool isTextureAttribute() const { return false; }
[451]235
[3488]236        /** Return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/
[26]237        virtual int compare(const StateAttribute& sa) const = 0;
[10]238       
[26]239        bool operator <  (const StateAttribute& rhs) const { return compare(rhs)<0; }
240        bool operator == (const StateAttribute& rhs) const { return compare(rhs)==0; }
241        bool operator != (const StateAttribute& rhs) const { return compare(rhs)!=0; }
[4091]242
[836]243       
[4091]244        /** A vector of osg::StateSet pointers which is used to store the parent(s) of this StateAttribute.*/
245        typedef std::vector<StateSet*> ParentList;
[26]246
[4091]247        /** Get the parent list of this StateAttribute. */
248        inline const ParentList& getParents() const { return _parents; }
249
250        inline StateSet* getParent(unsigned int i)  { return _parents[i]; }
251        /**
252         * Get a single const parent of this StateAttribute.
253         * @param i index of the parent to get.
254         * @return the parent i.
255         */
256        inline const StateSet* getParent(unsigned int i) const  { return _parents[i]; }
257
258        /**
259         * Get the number of parents of this StateAttribute.
260         * @return the number of parents of this StateAttribute.
261         */
[9599]262        inline unsigned int getNumParents() const { return static_cast<unsigned int>(_parents.size()); }
[4091]263
264
[2773]265        struct ModeUsage
[10]266        {
[4461]267            virtual ~ModeUsage() {}
[2773]268            virtual void usesMode(GLMode mode) = 0;
269            virtual void usesTextureMode(GLMode mode) = 0;
270        };
271
[3488]272        /** Return the modes associated with this StateAttribute.*/       
[2773]273        virtual bool getModeUsage(ModeUsage&) const
274        {
[39]275            // default to no GLMode's associated with use of the StateAttribute.
[2773]276            return false;
[10]277        }
[4084]278       
[5001]279        /** Check the modes associated with this StateAttribute are supported by current OpenGL drivers,
280          * and if not set the associated mode in osg::State to be black listed/invalid.
281          * Return true if all associated modes are valid.*/
[5004]282        virtual bool checkValidityOfAssociatedModes(osg::State&) const
[5001]283        {
284            // default to no black listed GLMode's associated with use of the StateAttribute.
285            return true;
286        }
[4084]287
[10671]288        // provide callback for backwards compatibility.
289        typedef osg::StateAttributeCallback Callback;
[4084]290
291        /** Set the UpdateCallback which allows users to attach customize the updating of an object during the update traversal.*/
[10671]292        void setUpdateCallback(StateAttributeCallback* uc);
[4084]293
294        /** Get the non const UpdateCallback.*/
[10671]295        StateAttributeCallback* getUpdateCallback() { return _updateCallback.get(); }
[4084]296
297        /** Get the const UpdateCallback.*/
[10671]298        const StateAttributeCallback* getUpdateCallback() const { return _updateCallback.get(); }
[4084]299
300
301        /** Set the EventCallback which allows users to attach customize the updating of an object during the Event traversal.*/
[10671]302        void setEventCallback(StateAttributeCallback* ec);
[4084]303
304        /** Get the non const EventCallback.*/
[10671]305        StateAttributeCallback* getEventCallback() { return _eventCallback.get(); }
[4084]306
307        /** Get the const EventCallback.*/
[10671]308        const StateAttributeCallback* getEventCallback() const { return _eventCallback.get(); }
[4084]309
[10]310   
311        /** apply the OpenGL state attributes.
[5573]312          * The render info for the current OpenGL context is passed
[10]313          * in to allow the StateAttribute to obtain details on the
314          * the current context and state.
315          */
[5573]316        virtual void apply(State&) const {}
317
[5882]318        /** Default to nothing to compile - all state is applied immediately. */
[3159]319        virtual void compileGLObjects(State&) const {}
[10]320
[5882]321        /** Resize any per context GLObject buffers to specified size. */
322        virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/) {}
323
324        /** Release OpenGL objects in specified graphics context if State
[7648]325            object is passed, otherwise release OpenGL objects for all graphics context if
[3159]326            State object pointer NULL.*/
327        virtual void releaseGLObjects(State* =0) const {}
328
329
[10]330    protected:
331   
332        virtual ~StateAttribute() {}
333
[4091]334        void addParent(osg::StateSet* object);
335        void removeParent(osg::StateSet* object);
336
337        ParentList _parents;
338        friend class osg::StateSet;
339
[10671]340        ref_ptr<StateAttributeCallback>   _updateCallback;
341        ref_ptr<StateAttributeCallback>   _eventCallback;
[10]342};
343
[349]344}
[10]345
346#endif
Note: See TracBrowser for help on using the browser.