VRS - The Virtual Rendering System

version 3.3

sourceal.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. 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
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

#ifndef VRS_SOUND_SOURCEAL_H
#define VRS_SOUND_SOURCEAL_H

//
// VRS
//
#include <vrs/vector.h>
#include <vrs/polyattribute.h>
#include <vrs/container/iterator.h>
#include <vrs/container/array.h>
#include <vrs/sg/scenething.h>

//
// SOUND
//
#include <vrs/openal/bufferal.h>

//
// STL
//
#include <limits>


namespace VRS
{
    namespace SOUND
    {
        class VRS_OPENAL_API SourceAL : public PolyAttribute
        {
        public:

            enum SourceType
            {
                UNDETERMINED = AL_UNDETERMINED,
                STATIC       = AL_STATIC,
                STREAMING    = AL_STREAMING

            };//endenum SourceType
            VRS_SERIALIZABLE_CLASS_ENUM(SourceType);


            enum SourceState
            {
                INITIAL  = AL_INITIAL,
                PLAYING  = AL_PLAYING,
                PAUSED   = AL_PAUSED,
                STOPPED  = AL_STOPPED

            };//endenum SourceState
            VRS_SERIALIZABLE_CLASS_ENUM(SourceState);

            SourceAL(const Vector& position = Vector::origin,
                     const Vector& velocity = Vector::origin,
                     const Vector& direction = Vector::origin,
                     bool  relativeMode = false,
                     bool  loopMode = false,
                     float gain = 1.0f,
                     float gainMax = 1.0f,
                     float gainMin = 0.0f,
                     float innerConeAngle = 360.0f,
                     float outerConeAngle = 360.0f,
                     float coneOuterGain = 0.0f,
                     float pitch = 1.0f,
                     float referenceDistance = 1.0f,
                     float maxDistance = std::numeric_limits<float>::max(),
                     float rollOffFactor = 1.0f,
                     bool enabled = true);

            SourceAL(const SO<BufferAL>& buffer,
                     const Vector& position = Vector::origin,
                     const Vector& velocity = Vector::origin,
                     const Vector& direction = Vector::origin,
                     bool  relativeMode = false,
                     bool  loopMode = false,
                     float gain = 1.0f,
                     float gainMax = 1.0f,
                     float gainMin = 0.0f,
                     float innerConeAngle = 360.0f,
                     float outerConeAngle = 360.0f,
                     float coneOuterGain = 0.0f,
                     float pitch = 1.0f,
                     float referenceDistance = 1.0f,
                     float maxDistance = std::numeric_limits<float>::max(),
                     float rollOffFactor = 1.0f,
                     bool enabled = true);

            SourceAL(const SO<Iterator<SO<BufferAL> > >& buffers,
                     const Vector& position = Vector::origin,
                     const Vector& velocity = Vector::origin,
                     const Vector& direction = Vector::origin,
                     bool  relativeMode = false,
                     bool  loopMode = false,
                     float gain = 1.0f,
                     float gainMax = 1.0f,
                     float gainMin = 0.0f,
                     float innerConeAngle = 360.0f,
                     float outerConeAngle = 360.0f,
                     float coneOuterGain = 0.0f,
                     float pitch = 1.0f,
                     float referenceDistance = 1.0f,
                     float maxDistance = std::numeric_limits<float>::max(),
                     float rollOffFactor = 1.0f,
                     bool enabled = true);

            SourceAL(const SO<BufferAL>& buffer,
                     const SO<SceneThing>& sceneThing,
                     const Vector& velocity = Vector::origin,
                     const Vector& direction = Vector::origin,
                     bool  relativeMode = false,
                     bool  loopMode = false,
                     float gain = 1.0f,
                     float gainMax = 1.0f,
                     float gainMin = 0.0f,
                     float innerConeAngle = 360.0f,
                     float outerConeAngle = 360.0f,
                     float coneOuterGain = 0.0f,
                     float pitch = 1.0f,
                     float referenceDistance = 1.0f,
                     float maxDistance = std::numeric_limits<float>::max(),
                     float rollOffFactor = 1.0f,
                     bool enabled = true);

            SourceAL(const SO<Iterator<SO<BufferAL> > >& buffers,
                     const SO<SceneThing>& sceneThing,
                     const Vector& velocity = Vector::origin,
                     const Vector& direction = Vector::origin,
                     bool  relativeMode = false,
                     bool  loopMode = false,
                     float gain = 1.0f,
                     float gainMax = 1.0f,
                     float gainMin = 0.0f,
                     float innerConeAngle = 360.0f,
                     float outerConeAngle = 360.0f,
                     float coneOuterGain = 0.0f,
                     float pitch = 1.0f,
                     float referenceDistance = 1.0f,
                     float maxDistance = std::numeric_limits<float>::max(),
                     float rollOffFactor = 1.0f,
                     bool enabled = true);

            ~SourceAL(void);

            void setSceneThing(const SO<SceneThing>& sceneThing);
            inline SO<SceneThing> getSceneThing(void) const
            {
                return this->sceneThing_;
            }

            void attachBuffer(const SO<BufferAL>& buffer);

            void queueBuffer(const SO<BufferAL>& buffer);
            SO<BufferAL> unqueueBuffer(void);

            void queueBuffers(const SO<Iterator<SO<BufferAL> > >& buffers);


            SO<Iterator<SO<BufferAL> > > unqueueBuffers(void);
            void unqueueAllBuffers(void);

            unsigned int getQueuedBuffers(void) const;
            unsigned int getProcessedBuffers(void) const;

            void play(void);
            bool isPlaying(void) const;

            void stop(void);
            bool isStopped(void) const;

            void pause(void);
            bool isPaused(void) const;

            void rewind(void);
            bool isInitial(void) const;

            void setPosition(const VRS::Vector& position);
            inline const Vector& getPosition(void) const
            {
                return this->position_;
            }

            void setVelocity(const VRS::Vector& velocity);
            inline const Vector& getVelocity(void) const
            {
                return this->velocity_;
            }

            void setDirection(const VRS::Vector& direction);
            inline const Vector& getDirection(void) const
            {
                return this->direction_;
            }


            void setGain(float gain);
            inline float getGain(void) const
            {
                return this->gain_;
            }

            void setGainMin(float gainMin);
            inline float getGainMin(void) const
            {
                return this->gainMin_;
            }

            void setGainMax(float gainMax);
            inline float getGainMax(void) const
            {
                return this->gainMax_;
            }

            void setConeOuterGain(float coneOuterGain);
            inline float getConeOuterGain(void) const
            {
                return this->coneOuterGain_;
            }

            void setReferenceDistance(float referenceDistance);
            inline float getReferenceDistance(void) const
            {
                return this->referenceDistance_;
            }

            void setMaxDistance(float maxDistance);
            inline float getMaxDistance(void) const
            {
                return this->maxDistance_;
            }

            void setRollOffFactor(float rollOffFactor);
            inline float getRollOffFactor(void) const
            {
                return this->rollOffFactor_;
            }

            void setPitch(float pitch);
            inline float getPitch(void) const
            {
                return this->pitch_;
            }

            void setInnerConeAngle(float innerConeAngle);
            inline float getInnerConeAngle(void) const
            {
                return this->innerConeAngle_;
            }

            void setOuterConeAngle(float outerConeAngle);
            inline float getOuterConeAngle(void) const
            {
                return this->outerConeAngle_;
            }

            void setRelativeMode(bool relativeMode);
            inline bool getRelativeMode(void) const
            {
                return this->relativeMode_;
            }

            void setLoopMode(bool loopMode);
            inline bool getLoopMode(void) const
            {
                return this->loopMode_;
            }

            void setSecondOffset(float secondOffset);
            inline float getSecondOffset(void) const
            {
                return this->secondOffset_;
            }

            void setSampleOffset(float sampleOffset);
            inline float getSampleOffset(void) const
            {
                return this->sampleOffset_;
            }

            void setByteOffset(float byteOffset);
            inline float getByteOffset(void) const
            {
                return this->byteOffset_;
            }

            SourceType getSourceType(void) const;

            SourceState getSourceState(void) const;

            bool isValid(void) const;

            inline unsigned int getName(void) const
            {
                return this->name_;
            }

            VRS_TYPEINFO(SourceAL, PolyAttribute);
            VRS_SERIALIZABLE(SourceAL);

        private:

            SO<BufferAL> findAndUnqueueBuffer(unsigned int name);

            SO<SceneThing>                          sceneThing_;
            SO<BufferAL>                            buffer_;
            SO<NonPersistentArray<SO<BufferAL> > >  queuedBuffers_;

            Vector position_;
            Vector velocity_;
            Vector direction_;

            bool  relativeMode_;
            bool  loopMode_;

            float innerConeAngle_;
            float outerConeAngle_;
            float coneOuterGain_;

            float gain_;
            float gainMax_;
            float gainMin_;

            float pitch_;

            float referenceDistance_;
            float maxDistance_;
            float rollOffFactor_;

            float secondOffset_;
            float sampleOffset_;
            float byteOffset_;

            unsigned int name_;

        };//endclass SourceAL

    };//endnamespace SOUND

};//endnamespace VRS

#endif //VRS_SOUND_SOURCEAL_H

---

Generated on Thu May 24 06:00:15 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact