AutoSoundNodeCallback.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program 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
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Sound/AutoSoundNodeCallback.h>

#ifdef PVLE_AUDIO

#include <boost/cast.hpp>
//#include <boost/foreach.hpp>

#include <osg/NodeVisitor>
#include <osg/Group>
#include <osgAL/SoundNode>
#include <PVLE/Util/Assert.h>


class /*PVLE_EXPORT*/ DeleteNonPlayingSubgraphsVisitor : public osg::NodeVisitor {
public:
    DeleteNonPlayingSubgraphsVisitor(bool deleteAllSubgraphs = true)
        : NodeVisitor(TRAVERSE_ALL_CHILDREN), foundSoundNode(false), foundSoundNodePlaying(false), deleteAllSubgraphs(deleteAllSubgraphs)
    {
    }

    virtual void apply(osg::Group & node);

    /*virtual*/ void apply(osgAL::SoundNode & node);        // TEMP - Cannot be directly applied since not supported by NodeVisitor (OSG 2.7.6)
    virtual void apply(osg::Node & node) {
        if (std::string(node.className()) == "SoundNode") {
            ASSERT(dynamic_cast<osgAL::SoundNode *>(&node));
            apply(static_cast<osgAL::SoundNode &>(node));
        }
        traverse(node);
    }

    inline bool soundNodeFound() const { return foundSoundNode; }
    inline bool playingSoundNodeFound() const { return foundSoundNodePlaying; }

protected:
    bool foundSoundNode;
    bool foundSoundNodePlaying;
    const bool deleteAllSubgraphs;
};


void DeleteNonPlayingSubgraphsVisitor::apply(osg::Group & node) {
    // For a group, we check all children and kill them if needed.
    for(int i=static_cast<int>(node.getNumChildren())-1; i>=0; --i) {       // Cast to signed int to avoid underflow
        DeleteNonPlayingSubgraphsVisitor v;
        node.getChild(i)->accept(v);

        // Propagates the "found" value to the parents.
        foundSoundNodePlaying |= v.playingSoundNodeFound();
        foundSoundNode |= v.soundNodeFound();

        // Dev note:
        // Only takes into account subgraphs having at least one SoundNode: if (v.soundNodeFound() && !v.playingSoundNodeFound())
        // Takes into account all subgraphs: if (!v.playingSoundNodeFound())

        if ((deleteAllSubgraphs || v.soundNodeFound()) && !v.playingSoundNodeFound()) {
            // No problem about loop variable 'i' while removing a child since we go from N-1 to 0.
            node.removeChildren(i, 1);
        }
    }
    //traverse(node);       // Manual traversal - don't call this!
}

void DeleteNonPlayingSubgraphsVisitor::apply(osgAL::SoundNode & node) {
    foundSoundNode = true;
    ASSERT(node.getSoundState());
    if (node.getSoundState()->isPlaying()) {
        foundSoundNodePlaying = true;
        setTraversalMode(osg::NodeVisitor::TRAVERSE_NONE);      // Stop traversal
    }
    traverse(node);
}



void AutoSoundNodeCallback::operator()(osg::Node* node, osg::NodeVisitor* nv) {
    osg::Group * pGroup = boost::polymorphic_downcast<osg::Group *>(node);      // Can't apply this callback to a non-group node.
    for(int i=static_cast<int>(pGroup->getNumChildren())-1; i>=0; --i) {        // Cast to signed int to avoid underflow
        osg::Node* pChild = pGroup->getChild(i);
        if (std::string(pChild->className()) == "SoundNode" && !boost::polymorphic_downcast<osgAL::SoundNode *>(pChild)->getSoundState()->isPlaying()) {
            pGroup->removeChildren(i, 1);
        }
    }
    traverse(node, nv);
}


void AutoSoundNodeGraphCallback::operator()(osg::Node* node, osg::NodeVisitor* nv) {
    ASSERT(dynamic_cast<osg::Group *>(node));       // Can't apply this callback to a non-group node.
    DeleteNonPlayingSubgraphsVisitor nv2;
    node->accept(nv2);
    traverse(node, nv);
}

#endif  // PVLE_AUDIO

---