Source.h

Go to the documentation of this file.

//
// C++ Interface: Audio::Source
//
#ifndef __AUDIO_SOURCE_H__INCLUDED__
#define __AUDIO_SOURCE_H__INCLUDED__

#include "Exceptions.h"
#include "Types.h"
#include "Format.h"
#include "RenderableSource.h"

namespace Audio {

    // Forward declarations
    
    class Sound;
    class Listener;
    class SourceListener;
    

    class Source
    {
    private:
        SharedPtr<Sound> soundPtr;
        SharedPtr<RenderableSource> rendererDataPtr;
        SharedPtr<UserData> userDataPtr;
        long userDataLong;
        SharedPtr<SourceListener> sourceListenerPtr;
        
    protected:
        LVector3 position;
        Vector3 direction;
        Vector3 velocity;
        
        Range<Scalar> cosAngleRange;
        
        Scalar radius;
        PerFrequency<Scalar> pfRadiusRatios;
        PerFrequency<Scalar> referenceFreqs;
        
        Scalar gain;
        
        struct {
            int looping : 1;
            int attenuated : 1;
            int relative : 1;
        } flags;
        
        Timestamp lastKnownPlayingTime;
        Timestamp lastKnownPlayingTimeTime;
        
        struct {
            int location : 1;
            
            int attributes : 1;
            
            int gain : 1;
            
            int soundPtr : 1;
            
            int soundAttributes : 1;
            
            void reset()
            {
                location = 0;
                attributes = 0;
                gain = 0;
                soundPtr = 0;
                soundAttributes = 0;
            }
            
            void setAll()
            {
                location = 1;
                attributes = 1;
                gain = 1;
                soundAttributes = 1;
            }
        } dirty;
        
    protected:
        Source(SharedPtr<Sound> sound, bool looping = false) throw();
        
    public:
        virtual ~Source();
        
        LVector3 getPosition() const throw() { return position; }
        
        void setPosition(LVector3 x) throw() { position = x; dirty.location = 1; }
        
        Vector3 getDirection() const throw() { return direction; }
        
        void setDirection(Vector3 x) throw() { direction = x; dirty.location = 1; }
        
        Vector3 getVelocity() const throw() { return velocity; }
        
        void setVelocity(Vector3 x) throw() { velocity = x; dirty.location = 1; }
        
        Range<Scalar> getAngleRange() const throw();
        
        void setAngleRange(Range<Scalar> r) throw();
        
        Range<Scalar> getCosAngleRange() const throw() { return cosAngleRange; }
        
        void setCosAngleRange(Range<Scalar> r) throw() { cosAngleRange = r; dirty.attributes = 1; }
        
        Scalar getRadius() const throw() { return radius; }
        
        void setRadius(Scalar r) throw() { radius = r; dirty.attributes = 1; }
        
        PerFrequency<Scalar> getPerFrequencyRadiusRatios() const throw() { return pfRadiusRatios; }
        
        void setPerFrequencyRadiusRatios(PerFrequency<Scalar> val) throw() { pfRadiusRatios = val; dirty.attributes = 1; }
        
        PerFrequency<Scalar> getReferenceFreqs() const throw() { return referenceFreqs; }
        
        void setReferenceFreqs(PerFrequency<Scalar> val) throw() { referenceFreqs = val; dirty.attributes = 1; }
        
        Scalar getGain() const throw() { return gain; }
        
        void setGain(Scalar g) throw() { gain = g; dirty.gain = 1; }
        
        bool isLooping() const throw() { return flags.looping != 0; }
        
        void setLooping(bool loop) throw() { flags.looping = loop ? 1 : 0; dirty.soundAttributes = 1; }
        
        bool isAttenuated() const throw() { return flags.attenuated != 0; }
        
        void setAttenuated(bool attenuated) throw() { flags.attenuated = attenuated ? 1 : 0; dirty.attributes = 1; }
        
        bool isRelative() const throw() { return flags.relative != 0; }
        
        void setRelative(bool relative) throw() { flags.relative = relative ? 1 : 0; dirty.attributes = 1; }
        
        void startPlaying(Timestamp start = 0) throw(Exception);
        
        void stopPlaying() throw();
        
        void pausePlaying() throw();
        
        void continuePlaying() throw(Exception);
        
        bool isPlaying() const throw();
        
        bool isActive() const throw();
        
        Timestamp getPlayingTime() const throw();
        
        Timestamp getWouldbePlayingTime() const throw();
        
        SharedPtr<RenderableSource> getRenderable() const throw() { return rendererDataPtr; }
        
        void setRenderable(SharedPtr<RenderableSource> ptr) throw();
        
        SharedPtr<UserData> getUserDataPtr() const throw() { return userDataPtr; }
        
        void setUserDataLong(SharedPtr<UserData> ptr) throw() { userDataPtr = ptr; }
        
        long getUserDataLong() const throw() { return userDataLong; }
        
        void setUserDataLong(long data) throw() { userDataLong = data; }
        
        SharedPtr<SourceListener> getSourceListener() const throw() { return sourceListenerPtr; }
        
        void setSourceListener(SharedPtr<SourceListener> ptr) throw() { sourceListenerPtr = ptr; }
        
        SharedPtr<Sound> getSound() const throw() { return soundPtr; }
        
        void setSound(SharedPtr<Sound> ptr) throw() { soundPtr = ptr; dirty.soundPtr = 1; }
        
        void updateRenderable(int flags, const Listener& sceneListener) throw();
        
        void seek(Timestamp time) throw(Exception);
        
    protected:
        Timestamp setLastKnownPlayingTime(Timestamp timestamp) throw();
        
        // The following section contains all the virtual functions that need be implemented
        // by a concrete Sound class. All are protected, so the stream interface is independent
        // of implementations.
    protected:
        
        virtual void startPlayingImpl(Timestamp start) throw(Exception) = 0;
        
        virtual void stopPlayingImpl() throw(Exception) = 0;
        
        virtual bool isPlayingImpl() const throw(Exception) = 0;
    
        // The following section contains package-private stuff
        // They're intended for plugin developers, and not end users
    public:
        
        void _notifyPlaying() throw();
    };

};

#endif//__AUDIO_SOURCE_H__INCLUDED__