/* -*-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.

*/

#include <osg/Node>

#include <osg/Group>

#include <osg/NodeVisitor>

#include <osg/Notify>

#include <osg/OccluderNode>

#include <osg/Transform>

#include <osg/UserDataContainer>

#include <algorithm>

using namespace osg;

namespace osg

{

    /// Helper class for generating NodePathList.

    class CollectParentPaths : public NodeVisitor

    {

    public:

        CollectParentPaths(const osg::Node* haltTraversalAtNode=) :

            osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_PARENTS),

            _haltTraversalAtNode(haltTraversalAtNode)

        {

            setNodeMaskOverride(0xffffffff);

        }

        virtual void apply(osg::Node& node)

        {

            if (node.getNumParents()== || &node==_haltTraversalAtNode)

            {

                _nodePaths.push_back(getNodePath());

            }

            else

            {

                traverse(node);

            }

       }

        const Node*     _haltTraversalAtNode;

        NodePath        _nodePath;

        NodePathList    _nodePaths;

    };

}

Node::Node()

    :Object(true)

{

    _boundingSphereComputed = false;

    _nodeMask = 0xffffffff;

    _numChildrenRequiringUpdateTraversal = ;

    _numChildrenRequiringEventTraversal = ;

    _cullingActive = true;

    _numChildrenWithCullingDisabled = ;

    _numChildrenWithOccluderNodes = ;

}

Node::Node(const Node& node,const CopyOp& copyop):

        Object(node,copyop),

        _initialBound(node._initialBound),

        _boundingSphere(node._boundingSphere),

        _boundingSphereComputed(node._boundingSphereComputed),

        _parents(), // leave empty as parentList is managed by Group.

        _updateCallback(copyop(node._updateCallback.get())),

        _numChildrenRequiringUpdateTraversal(), // assume no children yet.

        _numChildrenRequiringEventTraversal(), // assume no children yet.

        _cullCallback(copyop(node._cullCallback.get())),

        _cullingActive(node._cullingActive),

        _numChildrenWithCullingDisabled(), // assume no children yet.

        _numChildrenWithOccluderNodes(),

        _nodeMask(node._nodeMask)

{

    setStateSet(copyop(node._stateset.get()));

}

Node::~Node()

{

    // cleanly detach any associated stateset (include remove parent links)

    setStateSet();

}

void Node::addParent(osg::Group* parent)

{

    OpenThreads::ScopedPointerLock<OpenThreads::Mutex> lock(getRefMutex());

    _parents.push_back(parent);

}

void Node::removeParent(osg::Group* parent)

{

    OpenThreads::ScopedPointerLock<OpenThreads::Mutex> lock(getRefMutex());

    ParentList::iterator pitr = std::find(_parents.begin(), _parents.end(), parent);

    if (pitr!=_parents.end()) _parents.erase(pitr);

}

void Node::accept(NodeVisitor& nv)

{

    if (nv.validNodeMask(*this))

    {

        nv.pushOntoNodePath(this);

        nv.apply(*this);

        nv.popFromNodePath();

    }

}

void Node::ascend(NodeVisitor& nv)

{

    std::for_each(_parents.begin(),_parents.end(),NodeAcceptOp(nv));

}

void Node::setStateSet(osg::StateSet* stateset)

{

    // do nothing if nothing changed.

    if (_stateset==stateset) return;

    // track whether we need to account for the need to do a update or event traversal.

    int delta_update = ;

    int delta_event = ;

    // remove this node from the current statesets parent list

    if (_stateset.valid())

    {

        _stateset->removeParent(this);

        if (_stateset->requiresUpdateTraversal()) --delta_update;

        if (_stateset->requiresEventTraversal()) --delta_event;

    }

    // set the stateset.

    _stateset = stateset;

    // add this node to the new stateset to the parent list.

    if (_stateset.valid())

    {

        _stateset->addParent(this);

        if (_stateset->requiresUpdateTraversal()) ++delta_update;

        if (_stateset->requiresEventTraversal()) ++delta_event;

    }

    if (delta_update!=)

    {

        setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()+delta_update);

    }

    if (delta_event!=)

    {

        setNumChildrenRequiringEventTraversal(getNumChildrenRequiringEventTraversal()+delta_event);

    }

}

osg::StateSet* Node::getOrCreateStateSet()

{

    if (!_stateset) setStateSet(new StateSet);

    return _stateset.get();

}

NodePathList Node::getParentalNodePaths(osg::Node* haltTraversalAtNode) const

{

    CollectParentPaths cpp(haltTraversalAtNode);

    const_cast<Node*>(this)->accept(cpp);

    return cpp._nodePaths;

}

MatrixList Node::getWorldMatrices(const osg::Node* haltTraversalAtNode) const

{

    CollectParentPaths cpp(haltTraversalAtNode);

    const_cast<Node*>(this)->accept(cpp);

    MatrixList matrices;

    for(NodePathList::iterator itr = cpp._nodePaths.begin();

        itr != cpp._nodePaths.end();

        ++itr)

    {

        NodePath& nodePath = *itr;

        if (nodePath.empty())

        {

            matrices.push_back(osg::Matrix::identity());

        }

        else

        {

            matrices.push_back(osg::computeLocalToWorld(nodePath));

        }

    }

    return matrices;

}

void Node::setUpdateCallback(Callback* nc)

{

    // if no changes just return.

    if (_updateCallback==nc) return;

    // updated callback has been changed, will need to update

    // both _updateCallback and possibly the numChildrenRequiringAppTraversal

    // if the number of callbacks changes.

    // update the parents numChildrenRequiringAppTraversal

    // note, if _numChildrenRequiringUpdateTraversal!=0 then the

    // parents won't be affected by any app callback change,

    // so no need to inform them.

    if (_numChildrenRequiringUpdateTraversal== && !_parents.empty())

    {

        int delta = ;

        if (_updateCallback.valid()) --delta;

        if (nc) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenRequiringUpdateTraversal(

                        (*itr)->getNumChildrenRequiringUpdateTraversal()+delta );

            }

        }

    }

    // set the app callback itself.

    _updateCallback = nc;

}

void Node::setNumChildrenRequiringUpdateTraversal(unsigned int num)

{

    // if no changes just return.

    if (_numChildrenRequiringUpdateTraversal==num) return;

    // note, if _updateCallback is set then the

    // parents won't be affected by any changes to

    // _numChildrenRequiringUpdateTraversal so no need to inform them.

    if (!_updateCallback && !_parents.empty())

    {

        // need to pass on changes to parents.

        int delta = ;

        if (_numChildrenRequiringUpdateTraversal>) --delta;

        if (num>) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenRequiringUpdateTraversal(

                    (*itr)->getNumChildrenRequiringUpdateTraversal()+delta

                    );

            }

        }

    }

    // finally update this objects value.

    _numChildrenRequiringUpdateTraversal=num;

}

void Node::setEventCallback(Callback* nc)

{

    // if no changes just return.

    if (_eventCallback==nc) return;

    // event callback has been changed, will need to Event

    // both _EventCallback and possibly the numChildrenRequiringAppTraversal

    // if the number of callbacks changes.

    // Event the parents numChildrenRequiringAppTraversal

    // note, if _numChildrenRequiringEventTraversal!=0 then the

    // parents won't be affected by any app callback change,

    // so no need to inform them.

    if (_numChildrenRequiringEventTraversal== && !_parents.empty())

    {

        int delta = ;

        if (_eventCallback.valid()) --delta;

        if (nc) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenRequiringEventTraversal(

                        (*itr)->getNumChildrenRequiringEventTraversal()+delta );

            }

        }

    }

    // set the app callback itself.

    _eventCallback = nc;

}

void Node::setNumChildrenRequiringEventTraversal(unsigned int num)

{

    // if no changes just return.

    if (_numChildrenRequiringEventTraversal==num) return;

    // note, if _EventCallback is set then the

    // parents won't be affected by any changes to

    // _numChildrenRequiringEventTraversal so no need to inform them.

    if (!_eventCallback && !_parents.empty())

    {

        // need to pass on changes to parents.

        int delta = ;

        if (_numChildrenRequiringEventTraversal>) --delta;

        if (num>) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenRequiringEventTraversal(

                    (*itr)->getNumChildrenRequiringEventTraversal()+delta

                    );

            }

        }

    }

    // finally Event this objects value.

    _numChildrenRequiringEventTraversal=num;

}

void Node::setCullingActive(bool active)

{

    // if no changes just return.

    if (_cullingActive == active) return;

    // culling active has been changed, will need to update

    // both _cullActive and possibly the parents numChildrenWithCullingDisabled

    // if culling disabled changes.

    // update the parents _numChildrenWithCullingDisabled

    // note, if _numChildrenWithCullingDisabled!=0 then the

    // parents won't be affected by any app callback change,

    // so no need to inform them.

    if (_numChildrenWithCullingDisabled== && !_parents.empty())

    {

        int delta = ;

        if (!_cullingActive) --delta;

        if (!active) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenWithCullingDisabled(

                        (*itr)->getNumChildrenWithCullingDisabled()+delta );

            }

        }

    }

    // set the cullingActive itself.

    _cullingActive = active;

}

void Node::setNumChildrenWithCullingDisabled(unsigned int num)

{

    // if no changes just return.

    if (_numChildrenWithCullingDisabled==num) return;

    // note, if _cullingActive is false then the

    // parents won't be affected by any changes to

    // _numChildrenWithCullingDisabled so no need to inform them.

    if (_cullingActive && !_parents.empty())

    {

        // need to pass on changes to parents.

        int delta = ;

        if (_numChildrenWithCullingDisabled>) --delta;

        if (num>) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenWithCullingDisabled(

                    (*itr)->getNumChildrenWithCullingDisabled()+delta

                    );

            }

        }

    }

    // finally update this objects value.

    _numChildrenWithCullingDisabled=num;

}

void Node::setNumChildrenWithOccluderNodes(unsigned int num)

{

    // if no changes just return.

    if (_numChildrenWithOccluderNodes==num) return;

    // note, if this node is a OccluderNode then the

    // parents won't be affected by any changes to

    // _numChildrenWithOccluderNodes so no need to inform them.

    if (!dynamic_cast<OccluderNode*>(this) && !_parents.empty())

    {

        // need to pass on changes to parents.

        int delta = ;

        if (_numChildrenWithOccluderNodes>) --delta;

        if (num>) ++delta;

        if (delta!=)

        {

            // the number of callbacks has changed, need to pass this

            // on to parents so they know whether app traversal is

            // required on this subgraph.

            for(ParentList::iterator itr =_parents.begin();

                itr != _parents.end();

                ++itr)

            {

                (*itr)->setNumChildrenWithOccluderNodes(

                    (*itr)->getNumChildrenWithOccluderNodes()+delta

                    );

            }

        }

    }

    // finally update this objects value.

    _numChildrenWithOccluderNodes=num;

}

bool Node::containsOccluderNodes() const

{

    return _numChildrenWithOccluderNodes> || dynamic_cast<const OccluderNode*>(this);

}

void Node::setDescriptions(const DescriptionList& descriptions)

{

    // only assign a description list (and associated UseDataContainer) if we need to.

    if (!descriptions.empty() || getUserDataContainer())

    {

        getOrCreateUserDataContainer()->setDescriptions(descriptions);

    }

}

Node::DescriptionList& Node::getDescriptions()

{

    return getOrCreateUserDataContainer()->getDescriptions();

}

static OpenThreads::Mutex s_mutex_StaticDescriptionList;

static const Node::DescriptionList& getStaticDescriptionList()

{

    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_mutex_StaticDescriptionList);

    static Node::DescriptionList s_descriptionList;

    return s_descriptionList;

}

const Node::DescriptionList& Node::getDescriptions() const

{

    if (_userDataContainer) return _userDataContainer->getDescriptions();

    else return getStaticDescriptionList();

}

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

{

    return getOrCreateUserDataContainer()->getDescriptions()[i];

}

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

{

    if (_userDataContainer) return _userDataContainer->getDescriptions()[i];

    else return getStaticDescriptionList()[i];

}

unsigned int Node::getNumDescriptions() const

{

    return _userDataContainer ? _userDataContainer->getDescriptions().size() : ;

}

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

{

    getOrCreateUserDataContainer()->getDescriptions().push_back(desc);

}

BoundingSphere Node::computeBound() const

{

    return BoundingSphere();

}

void Node::dirtyBound()

{

    if (_boundingSphereComputed)

    {

        _boundingSphereComputed = false;

        // dirty parent bounding sphere's to ensure that all are valid.

        for(ParentList::iterator itr=_parents.begin();

            itr!=_parents.end();

            ++itr)

        {

            (*itr)->dirtyBound();

        }

    }

}

void Node::setThreadSafeRefUnref(bool threadSafe)

{

    Object::setThreadSafeRefUnref(threadSafe);

    if (_stateset.valid()) _stateset->setThreadSafeRefUnref(threadSafe);

    if (_updateCallback.valid()) _updateCallback->setThreadSafeRefUnref(threadSafe);

    if (_eventCallback.valid()) _eventCallback->setThreadSafeRefUnref(threadSafe);

    if (_cullCallback.valid()) _cullCallback->setThreadSafeRefUnref(threadSafe);

}

void Node::resizeGLObjectBuffers(unsigned int maxSize)

{

    if (_stateset.valid()) _stateset->resizeGLObjectBuffers(maxSize);

    if (_updateCallback.valid()) _updateCallback->resizeGLObjectBuffers(maxSize);

    if (_eventCallback.valid()) _eventCallback->resizeGLObjectBuffers(maxSize);

    if (_cullCallback.valid()) _cullCallback->resizeGLObjectBuffers(maxSize);

}

void Node::releaseGLObjects(osg::State* state) const

{

    if (_stateset.valid()) _stateset->releaseGLObjects(state);

    if (_updateCallback.valid()) _updateCallback->releaseGLObjects(state);

    if (_eventCallback.valid()) _eventCallback->releaseGLObjects(state);

    if (_cullCallback.valid()) _cullCallback->releaseGLObjects(state);

}