SceneManager.h

Go to the documentation of this file.

//
// C++ Interface: Audio::SceneManager
//
#ifndef __AUDIO_SCENEMANAGER_H__INCLUDED__
#define __AUDIO_SCENEMANAGER_H__INCLUDED__

#include <string>
#include <map>
#include <set>
#include "Exceptions.h"
#include "Singleton.h"
#include "Types.h"
#include "VirtualIterator.h"


namespace Audio {

    // Some forwards, we don't need to know the details of those classes
    class Renderer;
    class Scene;
    class SourceTemplate;
    class Source;
    class Sound;
    class Listener;
    
    namespace __impl {
        
        // Forward declaration of internal scene manager data
        struct SceneManagerData;
        
    };

    class SceneManager : public Singleton<SceneManager>
    {
    private:
        AutoPtr<__impl::SceneManagerData> data;
        
    public:
        typedef VirtualIterator<SharedPtr<Scene> > SceneIterator;
    
    protected:
        const SharedPtr<Renderer>& internalRenderer() const;
    
    public:
        SceneManager() throw();
        
        virtual ~SceneManager();
        
        virtual SharedPtr<Source> createSource(SharedPtr<Sound> sound, bool looping = false) throw(Exception);
        
        SharedPtr<Source> createSource(SharedPtr<SourceTemplate> tpl) throw(Exception);
        
        SharedPtr<Source> createSource(SharedPtr<SourceTemplate> tpl, const std::string &name) throw(Exception);
        
        virtual void destroySource(SharedPtr<Source> source) throw();
        
        
        
        void playSource(
            SharedPtr<SourceTemplate> tpl, 
            const std::string &sceneName,
            LVector3 position,
            Vector3 direction,
            Vector3 velocity,
            Scalar radius) throw(Exception);
        
        void playSource(
            SharedPtr<SourceTemplate> tpl, 
            const std::string &soundName,
            const std::string &sceneName,
            LVector3 position,
            Vector3 direction,
            Vector3 velocity,
            Scalar radius) throw(Exception);
        
        virtual SharedPtr<Scene> createScene(const std::string &name) throw(DuplicateObjectException);
        
        virtual SharedPtr<Scene> getScene(const std::string &name) const throw(NotFoundException);
        
        virtual void destroyScene(const std::string &name) throw(NotFoundException);
        
        virtual void setSceneActive(const std::string &name, bool active) throw(NotFoundException);
        
        virtual bool getSceneActive(const std::string &name) throw(NotFoundException);
        
        virtual SharedPtr<Listener> getRootListener() const throw();
        
        virtual SharedPtr<SceneIterator> getSceneIterator() const throw();
        
        virtual SharedPtr<SceneIterator> getActiveSceneIterator() const throw();
        
        virtual void setRenderer(SharedPtr<Renderer> renderer) throw(Exception);
        
        SharedPtr<Renderer> getRenderer() const throw();
        
        
        /********* Scene cycle **********/
        
        virtual void commit() throw(Exception);
        
        Duration getPositionUpdateFrequency() const throw();
        
        Duration getListenerUpdateFrequency() const throw();
        
        Duration getAttributeUpdateFrequency() const throw();
        
        Duration getActivationFrequency() const throw();
        
        virtual void setPositionUpdateFrequency(Duration interval) const throw();
        
        virtual void setListenerUpdateFrequency(Duration interval) const throw();
        
        virtual void setAttributeUpdateFrequency(Duration interval) const throw();
        
        virtual void setActivationFrequency(Duration interval) const throw();
        
        
        /********* Culling parameters **********/
        
        
        virtual unsigned int getMaxSources() const throw();
        
        virtual void setMaxSources(unsigned int n) throw(Exception);
        
        virtual float getMinGain() const throw();
    
        virtual void setMinGain(float gain) throw(Exception);
        
        virtual double getMaxDistance() const throw();
    
        virtual void setMaxDistance(double distance) throw(Exception);
        
        
        /*********** Notification events ************/
        
        virtual void notifySourcePlaying(SharedPtr<Source> source, SharedPtr<Scene> scene, bool playing) throw(Exception);
    
    protected:
        void addScene(SharedPtr<Scene> scene) throw(DuplicateObjectException);
        
        virtual void activationPhaseImpl() throw(Exception);
        
        virtual void updateSourcesImpl(bool withAttributes) throw(Exception);
        
        virtual void updateListenerImpl(bool withAttributes) throw(Exception);
    };

};

#endif//__AUDIO_SCENEMANAGER_H__INCLUDED__