222 lines
8.5 KiB
Plaintext
222 lines
8.5 KiB
Plaintext
#ifndef OSG_NODE
|
|
#define OSG_NODE 1
|
|
|
|
#include <osg/Object>
|
|
#include <osg/StateSet>
|
|
#include <osg/BoundingSphere>
|
|
#include <osg/MemoryAdapter>
|
|
#include <osg/NodeCallback>
|
|
#include <osg/ref_ptr>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace osg {
|
|
|
|
class NodeVisitor;
|
|
class Group;
|
|
|
|
/** META_Node macro define the standard clone, isSameKindAs, className
|
|
* and accept methods. Use when subclassing from Node to make it
|
|
* more convinient to define the required pure virtual methods.*/
|
|
#define META_Node(name) \
|
|
virtual Object* clone() const { return new name (); } \
|
|
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const name *>(obj)!=NULL; } \
|
|
virtual const char* className() const { return #name; } \
|
|
virtual void accept(NodeVisitor& nv) { if (nv.validNodeMask(*this)) nv.apply(*this); } \
|
|
|
|
|
|
/** Base class for all internal nodes in the scene graph.
|
|
Provides interface for most common node operations (Composite Pattern).
|
|
*/
|
|
class SG_EXPORT Node : public Object
|
|
{
|
|
public:
|
|
|
|
/** Construct a node.
|
|
Initialize the parent list to empty, node name to "" and
|
|
bounding sphere dirty flag to true.*/
|
|
Node();
|
|
|
|
/** return a shallow copy of a node, with Object* return type.*/
|
|
virtual Object* clone() const { return new Node(); }
|
|
|
|
/** return true if this and obj are of the same kind of object.*/
|
|
virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const Node*>(obj)!=NULL; }
|
|
|
|
/** return the name of the node's class type.*/
|
|
virtual const char* className() const { return "Node"; }
|
|
|
|
/** Visitor Pattern : calls the apply method of a NodeVisitor with this node's type.*/
|
|
virtual void accept(NodeVisitor& nv);
|
|
/** Traverse upwards : calls parents' accept method with NodeVisitor.*/
|
|
virtual void ascend(NodeVisitor& nv);
|
|
/** Traverse downwards : calls children's accept method with NodeVisitor.*/
|
|
virtual void traverse(NodeVisitor& /*nv*/) {}
|
|
|
|
|
|
/** Set the name of node using C++ style string.*/
|
|
inline void setName( const std::string& name ) { _name = name; }
|
|
/** Set the name of node using a C style string.*/
|
|
inline void setName( const char* name ) { _name = name; }
|
|
/** Get the name of node.*/
|
|
inline const std::string& getName() const { return _name; }
|
|
|
|
|
|
/** A vector of osg::Group pointers which is used to store the parent(s) of node.*/
|
|
typedef std::vector<Group*> ParentList;
|
|
|
|
/** Get the parent list of node. */
|
|
inline const ParentList& getParents() const { return _parents; }
|
|
|
|
/** Get the a copy of parent list of node. A copy is returned to
|
|
* prevent modification of the parent list.*/
|
|
// inline ParentList getParents() { return _parents; }
|
|
|
|
inline Group* getParent(const int i) { return _parents[i]; }
|
|
/**
|
|
* Get a single const parent of node.
|
|
* @param i index of the parent to get.
|
|
* @return the parent i.
|
|
*/
|
|
inline const Group* getParent(const int i) const { return _parents[i]; }
|
|
|
|
/**
|
|
* Get the number of parents of node.
|
|
* @return the number of parents of this node.
|
|
*/
|
|
inline const int getNumParents() const { return _parents.size(); }
|
|
|
|
|
|
/** Set app node callback, called during app traversal. */
|
|
void setAppCallback(NodeCallback* nc);
|
|
|
|
/** Get app node callback, called during app traversal. */
|
|
inline NodeCallback* getAppCallback() { return _appCallback.get(); }
|
|
|
|
/** Get const app node callback, called during app traversal. */
|
|
inline const NodeCallback* getAppCallback() const { return _appCallback.get(); }
|
|
|
|
/** Get the number of Children of this node which require App traversal,
|
|
* since they have an AppCallback attached to them or their children.*/
|
|
inline const int getNumChildrenRequiringAppTraversal() const { return _numChildrenRequiringAppTraversal; }
|
|
|
|
/**
|
|
* Set user data. See MemoryAdapter documentation for details
|
|
* of how to specify memory management of _userData.
|
|
*/
|
|
inline void setUserData(void* data,MemoryAdapter* ma=0L)
|
|
{
|
|
if (_userData && _memoryAdapter.valid()) _memoryAdapter->unref_data(_userData);
|
|
_userData = data;
|
|
_memoryAdapter = ma;
|
|
if (_userData && _memoryAdapter.valid()) _memoryAdapter->ref_data(_userData);
|
|
}
|
|
/** Get user data.*/
|
|
inline void* getUserData() { return _userData; }
|
|
|
|
/** Get const user data.*/
|
|
inline const void* getUserData() const { return _userData; }
|
|
|
|
/** Get the memory adapter associated with _userData.*/
|
|
inline MemoryAdapter* getMemoryAdapter() { return _memoryAdapter.get(); }
|
|
|
|
/** Get the const memory adapter associated with _userData.*/
|
|
inline const MemoryAdapter* getMemoryAdapter() const { return _memoryAdapter.get(); }
|
|
|
|
typedef unsigned int NodeMask;
|
|
/** Set the node mask. Note, node mask is will be replaced by TraversalMask.*/
|
|
inline void setNodeMask(const NodeMask nm) { _nodeMask = nm; }
|
|
/** Get the node Mask. Note, node mask is will be replaced by TraversalMask.*/
|
|
inline const NodeMask getNodeMask() const { return _nodeMask; }
|
|
|
|
|
|
|
|
/** A vector of std::string's which are used to describe the object.*/
|
|
typedef std::vector<std::string> DescriptionList;
|
|
|
|
/** Get the description list of the const node.*/
|
|
inline const DescriptionList& getDescriptions() const { return _descriptions; }
|
|
/** Get the description list of the const node.*/
|
|
inline DescriptionList& getDescriptions() { return _descriptions; }
|
|
/** Get a single const description of the const node.*/
|
|
inline const std::string& getDescription(const int i) const { return _descriptions[i]; }
|
|
/** Get a single description of the node.*/
|
|
inline std::string& getDescription(const int i) { return _descriptions[i]; }
|
|
/** Get the number of descriptions of the node.*/
|
|
inline const int getNumDescriptions() const { return _descriptions.size(); }
|
|
/** Add a description string to the node.*/
|
|
void addDescription(const std::string& desc) { _descriptions.push_back(desc); }
|
|
|
|
|
|
/** set the node's StateSet.*/
|
|
inline void setStateSet(osg::StateSet* dstate) { _dstate = dstate; }
|
|
|
|
/** return the node's StateSet.*/
|
|
inline osg::StateSet* getStateSet() { return _dstate.get(); }
|
|
|
|
/** return the node's const StateSet.*/
|
|
inline const osg::StateSet* getStateSet() const { return _dstate.get(); }
|
|
|
|
/** get the bounding sphere of node.
|
|
Using lazy evaluation computes the bounding sphere if it is 'dirty'.*/
|
|
inline const BoundingSphere& getBound() const
|
|
{
|
|
if(!_bsphere_computed) computeBound();
|
|
return _bsphere;
|
|
}
|
|
|
|
|
|
/** Mark this node's bounding sphere dirty.
|
|
Forcing it to be computed on the next call to getBound().*/
|
|
void dirtyBound();
|
|
|
|
|
|
protected:
|
|
|
|
/** Node destructor. Note, is protected so that Nodes cannot
|
|
be deleted other than by being dereferenced and the reference
|
|
count being zero (see osg::Referenced), preventing the deletion
|
|
of nodes which are still in use. This also means that
|
|
Node's cannot be created on stack i.e Node node will not compile,
|
|
forcing all nodes to be created on the heap i.e Node* node
|
|
= new Node().*/
|
|
virtual ~Node();
|
|
|
|
|
|
/** Compute the bounding sphere around Node's geometry or children.
|
|
This method is automatically called by getBound() when the bounding
|
|
sphere has been marked dirty via dirtyBound().*/
|
|
virtual const bool computeBound() const;
|
|
|
|
mutable BoundingSphere _bsphere;
|
|
mutable bool _bsphere_computed;
|
|
|
|
std::string _name;
|
|
|
|
ParentList _parents;
|
|
friend Group;
|
|
|
|
ref_ptr<NodeCallback> _appCallback;
|
|
int _numChildrenRequiringAppTraversal;
|
|
|
|
void setNumChildrenRequiringAppTraversal(const int num);
|
|
|
|
void* _userData;
|
|
ref_ptr<MemoryAdapter> _memoryAdapter;
|
|
|
|
NodeMask _nodeMask;
|
|
|
|
DescriptionList _descriptions;
|
|
|
|
ref_ptr<StateSet> _dstate;
|
|
|
|
};
|
|
|
|
/** A vector of Nodes pointers which is used to describe the path from a root node to a descendant.*/
|
|
typedef std::vector<Node*> NodePath;
|
|
|
|
};
|
|
|
|
#endif
|