a364875afb
easier to specify which modes and attributes have been modified without the user requiring to know to what value, or to have an equivilant attribute to pass to the have_applied_attribute method. The original have_applied(mode) and have_applied(attribute) methods have been renamed have_applied_mode(), have_applied_attribute() as this was required to prevent the mode and type values colliding during compile (it was causing a compile error when the method names were the same.)
235 lines
8.2 KiB
Plaintext
235 lines
8.2 KiB
Plaintext
//C++ header - Open Scene Graph - Copyright (C) 1998-2001 Robert Osfield
|
|
//Distributed under the terms of the GNU Library General Public License (LGPL)
|
|
//as published by the Free Software Foundation.
|
|
|
|
#ifndef OSG_STATE
|
|
#define OSG_STATE 1
|
|
|
|
#include <osg/Export>
|
|
#include <osg/StateSet>
|
|
#include <osg/Matrix>
|
|
|
|
#include <osg/FrameStamp>
|
|
#include <osg/Camera>
|
|
#include <osg/DisplaySettings>
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
|
|
namespace osg {
|
|
|
|
/** macro for use with osg::StateAttrbiute::apply methods for detected and
|
|
* reporting OpenGL error messages.*/
|
|
#define OSG_GL_DEBUG(message) \
|
|
if (state.getFineGrainedErrorDetection()) \
|
|
{ \
|
|
GLenum errorNo = glGetError(); \
|
|
if (errorNo!=GL_NO_ERROR) \
|
|
{ \
|
|
osg::notify(WARN)<<"Warning: detected OpenGL error '"<<gluErrorString(errorNo)<<" "<<message<<endl; \
|
|
}\
|
|
}
|
|
|
|
/** State class for managing a state stack.
|
|
* Lazy state updating is used to minimize state changes.
|
|
*/
|
|
class SG_EXPORT State : public Referenced
|
|
{
|
|
public :
|
|
|
|
State();
|
|
|
|
virtual ~State();
|
|
|
|
/** push stateset onto state stack.*/
|
|
void pushStateSet(const StateSet* dstate);
|
|
|
|
/** pop drawstate off state stack.*/
|
|
void popStateSet();
|
|
|
|
/** copy the modes and attributes which captures the current state.*/
|
|
void captureCurrentState(StateSet& stateset) const;
|
|
|
|
/** reset the state object to an empty stack.*/
|
|
void reset();
|
|
|
|
|
|
/** apply an OpenGL mode if required. */
|
|
inline const bool apply_mode(const StateAttribute::GLMode mode,const bool enabled)
|
|
{
|
|
return apply_mode(mode,enabled,_modeMap[mode]);
|
|
}
|
|
|
|
|
|
/** apply an attribute if required. */
|
|
inline const bool apply_attribute(const StateAttribute* attribute)
|
|
{
|
|
return apply_attribute(attribute,_attributeMap[attribute->getType()]);
|
|
}
|
|
|
|
|
|
/** apply stateset.*/
|
|
void apply(const StateSet* dstate);
|
|
|
|
/** apply the state.*/
|
|
void apply();
|
|
|
|
/** mode has been set externally, update state to reflect this setting.*/
|
|
void have_applied_mode(const StateAttribute::GLMode mode,const StateAttribute::GLModeValue value);
|
|
|
|
/** mode has been set externally, therefore dirty the associated mode in osg::State
|
|
* so it is applied on next call to osg::State::apply(..)*/
|
|
void have_applied_mode(const StateAttribute::GLMode mode);
|
|
|
|
/** attribute has been applied externally, update state to reflect this setting.*/
|
|
void have_applied_attribute(const StateAttribute* attribute);
|
|
|
|
/** attribute has been applied externally,
|
|
* and therefore this attribute type has been dirtied
|
|
* and will need to be re-appplied on next osg::State.apply(..).
|
|
* note, if you have an osg::StateAttribute which you have applied externally
|
|
* then use the have_applied(attribute) method as this will the osg::State to
|
|
* track the current state more accuratly and enable lazy state updating such
|
|
* that only changed state will be applied.*/
|
|
void have_applied_attribute(const StateAttribute::Type type);
|
|
|
|
|
|
/** Set the current OpenGL context uniqueID.
|
|
Note, it is the application developers responsibility to
|
|
set up unique ID for each OpenGL context. This value is
|
|
then used by osg::StateAttribure's and osg::Drawable's to
|
|
help manage OpenGL display list and texture binds appropriate
|
|
for each context.*/
|
|
inline void setContextID(unsigned int contextID) { _contextID=contextID; }
|
|
|
|
/** Get the current OpenGL context unique ID.*/
|
|
inline const unsigned int getContextID() const { return _contextID; }
|
|
|
|
|
|
/** Set the frame stamp for the current frame.*/
|
|
inline void setFrameStamp(FrameStamp* fs) { _frameStamp = fs; }
|
|
|
|
/** Set the frame stamp for the current frame.*/
|
|
inline const FrameStamp* getFrameStamp() const { return _frameStamp.get(); }
|
|
|
|
|
|
/** Set the camera. Note, nothing is applied, the camera is just used
|
|
* used in the State object to pass the current camera to Drawables
|
|
* during rendering. */
|
|
inline void setCamera(Camera* camera) { _camera = camera; }
|
|
|
|
/** Get the camera */
|
|
inline const Camera* getCamera() const { return _camera.get(); }
|
|
|
|
/** Set the DisplaySettings. Note, nothing is applied, the visual settings are just used
|
|
* used in the State object to pass the current visual settings to Drawables
|
|
* during rendering. */
|
|
inline void setDisplaySettings(DisplaySettings* vs) { _displaySettings = vs; }
|
|
|
|
/** Get the DisplaySettings */
|
|
inline const DisplaySettings* getDisplaySettings() const { return _displaySettings.get(); }
|
|
|
|
typedef std::pair<const StateAttribute*,StateAttribute::OverrideValue> AttributePair;
|
|
typedef std::vector<AttributePair> AttributeVec;
|
|
typedef std::vector<StateAttribute::GLModeValue> ValueVec;
|
|
|
|
private:
|
|
|
|
|
|
unsigned int _contextID;
|
|
ref_ptr<FrameStamp> _frameStamp;
|
|
ref_ptr<Camera> _camera;
|
|
ref_ptr<DisplaySettings> _displaySettings;
|
|
|
|
|
|
struct ModeStack
|
|
{
|
|
ModeStack()
|
|
{
|
|
changed = false;
|
|
last_applied_value = false;
|
|
global_default_value = false;
|
|
}
|
|
|
|
bool changed;
|
|
bool last_applied_value;
|
|
bool global_default_value;
|
|
ValueVec valueVec;
|
|
};
|
|
|
|
|
|
|
|
struct AttributeStack
|
|
{
|
|
AttributeStack()
|
|
{
|
|
changed = false;
|
|
last_applied_attribute = 0L;
|
|
global_default_attribute = 0L;
|
|
}
|
|
|
|
/** apply an attribute if required, passing in attribute and appropriate attribute stack */
|
|
bool changed;
|
|
const StateAttribute* last_applied_attribute;
|
|
ref_ptr<StateAttribute> global_default_attribute;
|
|
AttributeVec attributeVec;
|
|
};
|
|
|
|
/** apply an OpenGL mode if required, passing in mode, enable flag and appropriate mode stack */
|
|
inline const bool apply_mode(const StateAttribute::GLMode mode,const bool enabled,ModeStack& ms)
|
|
{
|
|
if (ms.last_applied_value != enabled)
|
|
{
|
|
ms.last_applied_value = enabled;
|
|
|
|
if (enabled) glEnable(mode);
|
|
else glDisable(mode);
|
|
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/** apply an attribute if required, passing in attribute and appropriate attribute stack */
|
|
inline const bool apply_attribute(const StateAttribute* attribute,AttributeStack& as)
|
|
{
|
|
if (as.last_applied_attribute != attribute)
|
|
{
|
|
if (!as.global_default_attribute.valid()) as.global_default_attribute = dynamic_cast<StateAttribute*>(attribute->cloneType());
|
|
|
|
as.last_applied_attribute = attribute;
|
|
attribute->apply(*this);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
inline const bool apply_global_default_attribute(AttributeStack& as)
|
|
{
|
|
if (as.last_applied_attribute != as.global_default_attribute.get())
|
|
{
|
|
as.last_applied_attribute = as.global_default_attribute.get();
|
|
if (as.global_default_attribute.valid()) as.global_default_attribute->apply(*this);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
typedef std::map<StateAttribute::GLMode,ModeStack> ModeMap;
|
|
typedef std::map<StateAttribute::Type,AttributeStack> AttributeMap;
|
|
typedef std::vector<ref_ptr<const StateSet> > StateSetStack;
|
|
typedef std::vector<ref_ptr<const Matrix> > MatrixStack;
|
|
|
|
ModeMap _modeMap;
|
|
AttributeMap _attributeMap;
|
|
StateSetStack _drawStateStack;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|