2002-07-17 04:07:32 +08:00
|
|
|
//C++ header - Open Scene Graph - Copyright (C) 1998-2002 Robert Osfield
|
2001-10-04 23:12:57 +08:00
|
|
|
//Distributed under the terms of the GNU Library General Public License (LGPL)
|
|
|
|
//as published by the Free Software Foundation.
|
|
|
|
|
2001-01-11 00:32:10 +08:00
|
|
|
#ifndef OSG_NODEVISITOR
|
|
|
|
#define OSG_NODEVISITOR 1
|
|
|
|
|
|
|
|
#include <osg/Node>
|
2002-02-06 05:54:46 +08:00
|
|
|
#include <osg/Matrix>
|
2001-09-22 10:42:08 +08:00
|
|
|
#include <osg/FrameStamp>
|
2001-01-11 00:32:10 +08:00
|
|
|
|
|
|
|
namespace osg {
|
|
|
|
|
|
|
|
class Geode;
|
|
|
|
class Billboard;
|
|
|
|
class LightSource;
|
2002-05-02 08:14:40 +08:00
|
|
|
class ClipNode;
|
2001-01-11 00:32:10 +08:00
|
|
|
class Group;
|
2001-09-20 05:08:56 +08:00
|
|
|
class Transform;
|
2002-04-01 00:40:44 +08:00
|
|
|
class Projection;
|
2001-01-11 00:32:10 +08:00
|
|
|
class LOD;
|
|
|
|
class Switch;
|
2001-09-20 05:08:56 +08:00
|
|
|
class Impostor;
|
2001-10-02 19:36:14 +08:00
|
|
|
class EarthSky;
|
2002-06-05 17:39:04 +08:00
|
|
|
class OccluderNode;
|
2001-01-11 00:32:10 +08:00
|
|
|
|
|
|
|
/** Visitor for type safe operations on osg::Node's.
|
2001-10-11 04:20:14 +08:00
|
|
|
Based on GOF's Visitor pattern. The NodeVisitor
|
|
|
|
is useful for developing type safe operations to nodes
|
|
|
|
in the scene graph (as per Visitor pattern), and adds to this
|
|
|
|
support for optional scene graph traversal to allow
|
|
|
|
operations to be applied to whole scenes at once. The Visitor
|
|
|
|
pattern uses a technique of double dispatch as a mechanism to
|
|
|
|
called the appropriate apply(..) method of the NodeVisitor. To
|
|
|
|
use this feature one must use the Node::accept(NodeVisitor) which
|
|
|
|
is extended in each Node subclass, rather than the NodeVisitor
|
|
|
|
apply directly. So use root->accept(myVisitor); instead of
|
|
|
|
myVisitor.apply(*root). The later method will bypass the double
|
|
|
|
dispatch and the appropriate NodeVisitor::apply(..) method will
|
|
|
|
not be called. */
|
2001-01-11 00:32:10 +08:00
|
|
|
class SG_EXPORT NodeVisitor : public Referenced
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
enum TraversalMode {
|
|
|
|
TRAVERSE_NONE,
|
|
|
|
TRAVERSE_PARENTS,
|
|
|
|
TRAVERSE_ALL_CHILDREN,
|
|
|
|
TRAVERSE_ACTIVE_CHILDREN,
|
|
|
|
TRAVERSE_VISITOR
|
|
|
|
};
|
|
|
|
|
|
|
|
NodeVisitor(TraversalMode tm=TRAVERSE_NONE);
|
|
|
|
virtual ~NodeVisitor();
|
|
|
|
|
2001-09-20 05:08:56 +08:00
|
|
|
/** Method to call to reset visitor. Useful for your visitor accumulates
|
2001-10-01 19:15:55 +08:00
|
|
|
state during a traversal, and you plan to reuse the visitor.
|
2001-09-20 05:08:56 +08:00
|
|
|
To flush that state for the next traversal than call reset() prior
|
|
|
|
to each traversal.*/
|
|
|
|
virtual void reset() {}
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2001-09-22 10:42:08 +08:00
|
|
|
|
|
|
|
/** Set the traversal number. Typically used to denote the frame count.*/
|
|
|
|
inline void setTraversalNumber(const int fn) { _traversalNumber = fn; }
|
|
|
|
|
|
|
|
/** Get the traversal number. Typically used to denote the frame count.*/
|
|
|
|
inline const int getTraversalNumber() const { return _traversalNumber; }
|
|
|
|
|
|
|
|
/** Set the FrameStamp that this traversal is assoicated with.*/
|
|
|
|
inline void setFrameStamp(FrameStamp* fs) { _frameStamp = fs; }
|
|
|
|
|
|
|
|
/** Get the FrameStamp that this traversal is assoicated with.*/
|
|
|
|
inline const FrameStamp* getFrameStamp() const { return _frameStamp.get(); }
|
|
|
|
|
|
|
|
|
|
|
|
/** Set the TraversalMask of this NodeVisitor.
|
|
|
|
* The TraversalMask is used by the NodeVisitor::validNodeMask() method
|
|
|
|
* to determine whether to operate on a node and its subgraph.
|
|
|
|
* validNodeMask() is called automaticaly in the Node::accept() method before
|
|
|
|
* any call to NodeVisitor::apply(), apply() is only ever called if validNodeMask
|
|
|
|
* returns true. Note, if NodeVisitor::_traversalMask is 0 then all operations
|
|
|
|
* will be swithced off for all nodes. Whereas setting both _traversalMask and
|
|
|
|
* _nodeMaskOverride to 0xffffffff will allow a visitor to work on all nodes
|
|
|
|
* regardless of their own Node::_nodeMask state.*/
|
|
|
|
inline void setTraversalMask(const Node::NodeMask mask) { _traversalMask = mask; }
|
|
|
|
|
|
|
|
/** Get the TraversalMask.*/
|
|
|
|
inline const Node::NodeMask getTraversalMask() const { return _traversalMask; }
|
|
|
|
|
|
|
|
/** Set the NodeMaskOverride mask.
|
|
|
|
* Used in validNodeMask() to determine whether to operate on a node or its
|
|
|
|
* subgraph, by OR'ing NodeVisitor::_nodeMaskOverride with the Node's own Node::_nodeMask.
|
|
|
|
* Typically used to force on nodes which may have
|
|
|
|
* been switched off by their own Node::_nodeMask.*/
|
|
|
|
inline void setNodeMaskOverride(const Node::NodeMask mask) { _nodeMaskOverride = mask; }
|
|
|
|
|
|
|
|
/** Get the NodeMaskOverride mask.*/
|
|
|
|
inline const Node::NodeMask getNodeMaskOverride() const { return _nodeMaskOverride; }
|
|
|
|
|
|
|
|
/** Method to called by Node and its subclass' Node::accept() method, if the result is true
|
|
|
|
* to be used to cull operations of nodes and their subgraphs.
|
|
|
|
* Return true if the result of a bit wise and of the NodeVisitor::_traversalMask
|
|
|
|
* with the bit or between NodeVistor::_nodeMaskOverride and the Node::_nodeMask.
|
|
|
|
* default values for _traversalMask is 0xffffffff, _nodeMaskOverride is 0x0,
|
|
|
|
* and osg::Node::_nodeMask is 0xffffffff. */
|
|
|
|
inline const bool validNodeMask(const osg::Node& node) const
|
|
|
|
{
|
|
|
|
return (getTraversalMask() & (getNodeMaskOverride() | node.getNodeMask()))!=0;
|
|
|
|
}
|
|
|
|
|
2001-01-11 00:32:10 +08:00
|
|
|
/** Set the traversal mode for Node::traverse() to use when
|
|
|
|
deciding which children of a node to traverse. If a
|
|
|
|
NodeVisitor has been attached via setTraverseVisitor()
|
|
|
|
and the new mode is not TRAVERSE_VISITOR then the attached
|
|
|
|
visitor is detached. Default mode is TRAVERSE_NONE.*/
|
2001-09-20 05:08:56 +08:00
|
|
|
void setTraversalMode(const TraversalMode mode);
|
2001-09-22 10:42:08 +08:00
|
|
|
|
2001-01-11 00:32:10 +08:00
|
|
|
/** Get the traversal mode.*/
|
2001-09-20 05:08:56 +08:00
|
|
|
inline const TraversalMode getTraversalMode() const { return _traversalMode; }
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2001-09-20 05:08:56 +08:00
|
|
|
/** Set a visitor to handle traversal.
|
2001-10-01 19:15:55 +08:00
|
|
|
Overrides the traverse mode setting it to TRAVERSAL_VISITOR.*/
|
2001-09-20 05:08:56 +08:00
|
|
|
void setTraversalVisitor(NodeVisitor* nv);
|
|
|
|
|
|
|
|
/** Get the traversal visitor, returns NULL if none is attached.*/
|
2002-02-06 05:54:46 +08:00
|
|
|
inline NodeVisitor* getTraversalVisitor() { return _traversalVisitor.get(); }
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2002-02-06 05:54:46 +08:00
|
|
|
/** Method for handling traversal of a nodes.
|
2001-01-11 00:32:10 +08:00
|
|
|
If you intend to use the visitor for actively traversing
|
|
|
|
the scene graph then make sure the accept() methods call
|
|
|
|
this method unless they handle traversal directly.*/
|
2002-02-06 05:54:46 +08:00
|
|
|
inline void traverse(Node& node)
|
2001-01-11 00:32:10 +08:00
|
|
|
{
|
2001-09-20 05:08:56 +08:00
|
|
|
if (_traversalVisitor.valid()) node.accept(*_traversalVisitor);
|
|
|
|
else if (_traversalMode==TRAVERSE_PARENTS) node.ascend(*this);
|
|
|
|
else if (_traversalMode!=TRAVERSE_NONE) node.traverse(*this);
|
2001-01-11 00:32:10 +08:00
|
|
|
}
|
2002-02-06 05:54:46 +08:00
|
|
|
|
|
|
|
/** Method called by osg::Node::accept() method before
|
|
|
|
* a call the NodeVisitor::apply(..). The back of the list will,
|
|
|
|
* therefore, be the current node being visited inside the apply(..),
|
|
|
|
* and the rest of the list will be the parental sequence of nodes
|
|
|
|
* from the top most node applied down the graph to the current node.
|
|
|
|
* Note, the user does not typically call pushNodeOnPath() as it
|
|
|
|
* will be called automatically by the Node::accept() method.*/
|
|
|
|
inline void pushOntoNodePath(Node* node) { _nodePath.push_back(node); }
|
|
|
|
|
|
|
|
/** Method callby osg::Node::accept() method after
|
|
|
|
* a call the NodeVisitor::apply(..).
|
|
|
|
* Note, the user does not typically call pushNodeOnPath() as it
|
|
|
|
* will be called automatically by the Node::accept() method.*/
|
|
|
|
inline void popFromNodePath() { _nodePath.pop_back(); }
|
|
|
|
|
|
|
|
/** Get the non const NodePath from the top most node applied down
|
|
|
|
* to the current Node being visited.*/
|
|
|
|
NodePath& getNodePath() { return _nodePath; }
|
|
|
|
|
|
|
|
/** Get the const NodePath from the top most node applied down
|
|
|
|
* to the current Node being visited.*/
|
|
|
|
const NodePath& getNodePath() const { return _nodePath; }
|
|
|
|
|
2002-02-11 06:35:22 +08:00
|
|
|
/** Get the Local To World Matrix from the NodePath for specified Transform::Mode, and u.*/
|
Added DataVariance enum and set/get fields to osg::Object to help identify
which objects have values that vary over the lifetime of the object (DYNAMIC)
and ones that do not vary (STATIC). Removed the equivalent code in
osg::Transform, StateSet and StateAttribute, as these are now encompassed
by the new DataVariance field.
Removed MatrixMode enum from Matrix, and associated fields/parameters from
osg::Transfrom and osg::NodeVisitor, since MatrixMode was not providing
any useful functionality, but made the interface more complex (MatrixMode
was an experimental API)
Added ReferenceFrame field to osg::Transform which allows users to specify
transforms that are relative to their parents (the default, and previous behavior)
or absolute reference frame, which can be used for HUD's, camera relative
light sources etc etc. Note, the view frustum culling for absolute Transform
are disabled, and all their parents up to the root are also automatically
have view frustum culling disabled. However, once passed an absolute Transform
node culling will return to its default state of on, so you can still cull
underneath an absolute transform, its only the culling above which is disabled.
2002-04-12 07:20:23 +08:00
|
|
|
const bool getLocalToWorldMatrix(Matrix& matrix, Node* node);
|
2002-02-06 05:54:46 +08:00
|
|
|
|
|
|
|
/** Get the World To Local Matrix from the NodePath for specified Transform::Mode.*/
|
Added DataVariance enum and set/get fields to osg::Object to help identify
which objects have values that vary over the lifetime of the object (DYNAMIC)
and ones that do not vary (STATIC). Removed the equivalent code in
osg::Transform, StateSet and StateAttribute, as these are now encompassed
by the new DataVariance field.
Removed MatrixMode enum from Matrix, and associated fields/parameters from
osg::Transfrom and osg::NodeVisitor, since MatrixMode was not providing
any useful functionality, but made the interface more complex (MatrixMode
was an experimental API)
Added ReferenceFrame field to osg::Transform which allows users to specify
transforms that are relative to their parents (the default, and previous behavior)
or absolute reference frame, which can be used for HUD's, camera relative
light sources etc etc. Note, the view frustum culling for absolute Transform
are disabled, and all their parents up to the root are also automatically
have view frustum culling disabled. However, once passed an absolute Transform
node culling will return to its default state of on, so you can still cull
underneath an absolute transform, its only the culling above which is disabled.
2002-04-12 07:20:23 +08:00
|
|
|
const bool getWorldToLocalMatrix(Matrix& matrix, Node* node);
|
2002-02-06 05:54:46 +08:00
|
|
|
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2002-05-02 08:14:40 +08:00
|
|
|
virtual void apply(Node& node) { traverse(node);}
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2002-05-02 08:14:40 +08:00
|
|
|
virtual void apply(Geode& node) { apply((Node&)node); }
|
|
|
|
virtual void apply(Billboard& node) { apply((Geode&)node); }
|
|
|
|
virtual void apply(LightSource& node) { apply((Node&)node); }
|
|
|
|
virtual void apply(ClipNode& node) { apply((Node&)node); }
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2002-05-02 08:14:40 +08:00
|
|
|
virtual void apply(Group& node) { apply((Node&)node); }
|
|
|
|
virtual void apply(Projection& node) { apply((Group&)node); }
|
|
|
|
virtual void apply(Transform& node) { apply((Group&)node); }
|
|
|
|
virtual void apply(Switch& node) { apply((Group&)node); }
|
|
|
|
virtual void apply(LOD& node) { apply((Group&)node); }
|
|
|
|
virtual void apply(Impostor& node) { apply((LOD&)node); }
|
|
|
|
virtual void apply(EarthSky& node) { apply((Group&)node); }
|
2002-06-05 17:39:04 +08:00
|
|
|
virtual void apply(OccluderNode& node) { apply((Group&)node); }
|
2001-01-11 00:32:10 +08:00
|
|
|
|
2002-02-06 05:54:46 +08:00
|
|
|
|
2001-01-11 00:32:10 +08:00
|
|
|
protected:
|
|
|
|
|
2001-09-22 10:42:08 +08:00
|
|
|
int _traversalNumber;
|
|
|
|
|
|
|
|
ref_ptr<FrameStamp> _frameStamp;
|
|
|
|
|
2001-09-20 05:08:56 +08:00
|
|
|
ref_ptr<NodeVisitor> _traversalVisitor;
|
2001-09-22 10:42:08 +08:00
|
|
|
|
2001-09-20 05:08:56 +08:00
|
|
|
TraversalMode _traversalMode;
|
2001-09-22 10:42:08 +08:00
|
|
|
Node::NodeMask _traversalMask;
|
|
|
|
Node::NodeMask _nodeMaskOverride;
|
2002-02-06 05:54:46 +08:00
|
|
|
|
|
|
|
NodePath _nodePath;
|
2001-01-11 00:32:10 +08:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2001-10-01 19:15:55 +08:00
|
|
|
/** Convenience functor for assisting visiting of arrays of osg::Node's.*/
|
2001-01-11 00:32:10 +08:00
|
|
|
struct NodeAcceptOp
|
|
|
|
{
|
|
|
|
NodeVisitor& _nv;
|
|
|
|
NodeAcceptOp(NodeVisitor& nv):_nv(nv) {}
|
|
|
|
void operator () (Node* node) { node->accept(_nv); }
|
|
|
|
void operator () (ref_ptr<Node> node) { node->accept(_nv); }
|
|
|
|
};
|
|
|
|
|
2002-02-03 20:33:41 +08:00
|
|
|
}
|
2001-01-11 00:32:10 +08:00
|
|
|
|
|
|
|
#endif
|