Node.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_NODE
#define OSG_NODE 1

#include <osg/Object>
#include <osg/StateSet>
#include <osg/BoundingSphere>
#include <osg/BoundingBox>
#include <osg/Callback>

#include <string>
#include <vector>


// forward declare osgTerrrain::Terrain to enable declaration of asTerrain() method.
namespace osgTerrain {
class Terrain;
}

namespace osg {

// forcing declare classes to enable declaration of as*() methods.
class NodeVisitor;
class Drawable;
class Geometry;
class Group;
class Transform;
class Node;
class Switch;
class Geode;
class Camera;

typedef std::vector< Node* > NodePath;

typedef std::vector< NodePath > NodePathList;

typedef std::vector< Matrix > MatrixList;


#define META_Node(library,name) \
        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* className() const { return #name; } \
        virtual const char* libraryName() const { return #library; } \
        virtual void accept(osg::NodeVisitor& nv) { if (nv.validNodeMask(*this)) { nv.pushOntoNodePath(this); nv.apply(*this); nv.popFromNodePath(); } } \


class OSG_EXPORT Node : public Object
{
    public:

        Node();

        Node(const Node&,const CopyOp& copyop=CopyOp::SHALLOW_COPY);

        virtual Object* cloneType() const { return new Node(); }

        virtual Object* clone(const CopyOp& copyop) const { return new Node(*this,copyop); }

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

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

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

        virtual Node* asNode() { return this; }

        virtual const Node* asNode() const { return this; }

        virtual Drawable* asDrawable() { return 0; }
        virtual const Drawable* asDrawable() const { return 0; }

        virtual Geometry* asGeometry() { return 0; }
        virtual const Geometry* asGeometry() const { return 0; }

        virtual Group* asGroup() { return 0; }
        virtual const Group* asGroup() const { return 0; }

        virtual Transform* asTransform() { return 0; }

        virtual const Transform* asTransform() const { return 0; }


        virtual Camera* asCamera() { return 0; }
        virtual const Camera* asCamera() const { return 0; }


        virtual Switch* asSwitch() { return 0; }

        virtual const Switch* asSwitch() const { return 0; }

        virtual Geode* asGeode() { return 0; }

        virtual const Geode* asGeode() const { return 0; }

        virtual osgTerrain::Terrain* asTerrain() { return 0; }

        virtual const osgTerrain::Terrain* asTerrain() const { return 0; }


        virtual void accept(NodeVisitor& nv);
        virtual void ascend(NodeVisitor& nv);
        virtual void traverse(NodeVisitor& /*nv*/) {}

        typedef std::vector<Group*> ParentList;

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

        inline ParentList getParents() { return _parents; }

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

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

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



        NodePathList getParentalNodePaths(osg::Node* haltTraversalAtNode=0) const;

        MatrixList getWorldMatrices(const osg::Node* haltTraversalAtNode=0) const;


        void setUpdateCallback(Callback* nc);

        inline Callback* getUpdateCallback() { return _updateCallback.get(); }

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

        inline void addUpdateCallback(Callback* nc) {
            if (nc != NULL) {
                if (_updateCallback.valid()) _updateCallback->addNestedCallback(nc);
                else setUpdateCallback(nc);
            }
        }

        inline void removeUpdateCallback(Callback* nc) {
            if (nc != NULL && _updateCallback.valid()) {
                if (_updateCallback == nc)
                {
                    ref_ptr<osg::Callback> new_nested_callback = nc->getNestedCallback();
                    nc->setNestedCallback(0);
                    setUpdateCallback(new_nested_callback.get());
                }
                else _updateCallback->removeNestedCallback(nc);
            }
        }

        inline unsigned int getNumChildrenRequiringUpdateTraversal() const { return _numChildrenRequiringUpdateTraversal; }


        void setEventCallback(Callback* nc);

        inline Callback* getEventCallback() { return _eventCallback.get(); }

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

        inline void addEventCallback(Callback* nc) {
            if (nc != NULL) {
                if (_eventCallback.valid()) _eventCallback->addNestedCallback(nc);
                else setEventCallback(nc);
            }
        }

        inline void removeEventCallback(Callback* nc) {
            if (nc != NULL && _eventCallback.valid()) {
                if (_eventCallback == nc)
                {
                    ref_ptr<osg::Callback> new_nested_callback = nc->getNestedCallback();
                    nc->setNestedCallback(0);
                    setEventCallback(new_nested_callback.get()); // replace the callback by the nested one
                }
                else _eventCallback->removeNestedCallback(nc);
            }
        }

        inline unsigned int getNumChildrenRequiringEventTraversal() const { return _numChildrenRequiringEventTraversal; }


        void setCullCallback(Callback* nc) { _cullCallback = nc; }

        inline Callback* getCullCallback() { return _cullCallback.get(); }

        inline const Callback* getCullCallback() const { return _cullCallback.get(); }

        inline void addCullCallback(Callback* nc) {
            if (nc != NULL) {
                if (_cullCallback.valid()) _cullCallback->addNestedCallback(nc);
                else setCullCallback(nc);
            }
        }

        inline void removeCullCallback(Callback* nc) {
            if (nc != NULL && _cullCallback.valid()) {
                if (_cullCallback == nc)
                {
                    ref_ptr<osg::Callback> new_nested_callback = nc->getNestedCallback();
                    nc->setNestedCallback(0);
                    setCullCallback(new_nested_callback.get()); // replace the callback by the nested one
                }
                else _cullCallback->removeNestedCallback(nc);
            }
        }

        void setCullingActive(bool active);

        inline bool getCullingActive() const { return _cullingActive; }

        inline unsigned int getNumChildrenWithCullingDisabled() const { return _numChildrenWithCullingDisabled; }

        inline bool isCullingActive() const { return _numChildrenWithCullingDisabled==0 && _cullingActive && getBound().valid(); }

        inline unsigned int getNumChildrenWithOccluderNodes() const { return _numChildrenWithOccluderNodes; }


        bool containsOccluderNodes() const;


        typedef unsigned int NodeMask;
        inline void setNodeMask(NodeMask nm) { _nodeMask = nm; }
        inline NodeMask getNodeMask() const { return _nodeMask; }



        void setStateSet(osg::StateSet* stateset);

        osg::StateSet* getOrCreateStateSet();

        inline osg::StateSet* getStateSet() { return _stateset.get(); }

        inline const osg::StateSet* getStateSet() const { return _stateset.get(); }


        typedef std::vector<std::string> DescriptionList;

        void setDescriptions(const DescriptionList& descriptions);

        DescriptionList& getDescriptions();

        const DescriptionList& getDescriptions() const;


        const std::string& getDescription(unsigned int i) const;

        std::string& getDescription(unsigned int i);

        unsigned int getNumDescriptions() const;

        void addDescription(const std::string& desc);


        void setInitialBound(const osg::BoundingSphere& bsphere) { _initialBound = bsphere; dirtyBound(); }

        const BoundingSphere& getInitialBound() const { return _initialBound; }

        void dirtyBound();


        inline const BoundingSphere& getBound() const
        {
            if(!_boundingSphereComputed)
            {
                _boundingSphere = _initialBound;
                if (_computeBoundCallback.valid())
                    _boundingSphere.expandBy(_computeBoundCallback->computeBound(*this));
                else
                    _boundingSphere.expandBy(computeBound());

                _boundingSphereComputed = true;
            }
            return _boundingSphere;
        }

        virtual BoundingSphere computeBound() const;

        struct ComputeBoundingSphereCallback : public osg::Object
        {
            ComputeBoundingSphereCallback() {}

            ComputeBoundingSphereCallback(const ComputeBoundingSphereCallback&,const CopyOp&) {}

            META_Object(osg,ComputeBoundingSphereCallback);

           virtual BoundingSphere computeBound(const osg::Node&) const { return BoundingSphere(); }
        };

        void setComputeBoundingSphereCallback(ComputeBoundingSphereCallback* callback) { _computeBoundCallback = callback; }

        ComputeBoundingSphereCallback* getComputeBoundingSphereCallback() { return _computeBoundCallback.get(); }

        const ComputeBoundingSphereCallback* getComputeBoundingSphereCallback() const { return _computeBoundCallback.get(); }

        virtual void setThreadSafeRefUnref(bool threadSafe);

        virtual void resizeGLObjectBuffers(unsigned int /*maxSize*/);

        virtual void releaseGLObjects(osg::State* = 0) const;


    protected:

        virtual ~Node();



        BoundingSphere                          _initialBound;
        ref_ptr<ComputeBoundingSphereCallback>  _computeBoundCallback;
        mutable BoundingSphere                  _boundingSphere;
        mutable bool                            _boundingSphereComputed;

        void addParent(osg::Group* parent);
        void removeParent(osg::Group* parent);

        ParentList _parents;
        friend class osg::Group;
        friend class osg::Drawable;
        friend class osg::StateSet;

        ref_ptr<Callback> _updateCallback;
        unsigned int _numChildrenRequiringUpdateTraversal;
        void setNumChildrenRequiringUpdateTraversal(unsigned int num);

        ref_ptr<Callback> _eventCallback;
        unsigned int _numChildrenRequiringEventTraversal;
        void setNumChildrenRequiringEventTraversal(unsigned int num);

        ref_ptr<Callback> _cullCallback;

        bool _cullingActive;
        unsigned int _numChildrenWithCullingDisabled;
        void setNumChildrenWithCullingDisabled(unsigned int num);

        unsigned int _numChildrenWithOccluderNodes;
        void setNumChildrenWithOccluderNodes(unsigned int num);

        NodeMask _nodeMask;

        ref_ptr<StateSet> _stateset;

};

}

#endif