#ifndef _SG_SAMPLE_GROUP_OPENAL_HXX
#define _SG_SAMPLE_GROUP_OPENAL_HXX 1
-#ifndef __cplusplus
-# error This library requires C++
-#endif
-
-#if defined(__APPLE__)
-# include <OpenAL/al.h>
-#elif defined(OPENALSDK)
-# include <al.h>
-#else
-# include <AL/al.h>
-#endif
#include <string>
#include <vector>
#include "sample_openal.hxx"
#include "sample_queue.hxx"
-using std::map;
-using std::string;
-typedef map < string, SGSharedPtr<SGSoundSample> > sample_map;
+typedef std::map < std::string, SGSharedPtr<SGSoundSample> > sample_map;
typedef sample_map::iterator sample_map_iterator;
typedef sample_map::const_iterator const_sample_map_iterator;
* @param smgr Pointer to a pre-initialized sound manager class
* @param refname Name of this group for reference purposes.
*/
- SGSampleGroup ( SGSoundMgr *smgr, const string &refname );
+ SGSampleGroup ( SGSoundMgr *smgr, const std::string &refname );
/**
* Destructor
* @param refname Name of this audio sample for reference purposes
* @return return true if successful
*/
- bool add( SGSharedPtr<SGSoundSample> sound, const string& refname );
+ bool add( SGSharedPtr<SGSoundSample> sound, const std::string& refname );
/**
* Remove an audio sample from this group.
* @param refname Reference name of the audio sample to remove
* @return return true if successful
*/
- bool remove( const string& refname );
+ bool remove( const std::string& refname );
/**
* Test if a specified audio sample is registered at this sample group
* @param refname Reference name of the audio sample to test for
* @return true if the specified audio sample exists
*/
- bool exists( const string& refname );
+ bool exists( const std::string& refname );
/**
* Find a specified audio sample in this sample group
* @param refname Reference name of the audio sample to find
* @return A pointer to the SGSoundSample
*/
- SGSoundSample *find( const string& refname );
+ SGSoundSample *find( const std::string& refname );
/**
* Stop all playing samples and set the source id to invalid.
* @param looping Define if the sound should loop continuously
* @return true if the audio sample exsists and is scheduled for playing
*/
- bool play( const string& refname, bool looping );
+ bool play( const std::string& refname, bool looping );
/**
* Request to start playing the referred audio sample looping.
* @param refname Reference name of the audio sample to start playing
* @return true if the audio sample exsists and is scheduled for playing
*/
- inline bool play_looped( const string& refname ) {
+ inline bool play_looped( const std::string& refname ) {
return play( refname, true );
}
* @param refname Reference name of the audio sample to start playing
* @return true if the audio sample exists and is scheduled for playing
*/
- inline bool play_once( const string& refname ) {
+ inline bool play_once( const std::string& refname ) {
return play( refname, false );
}
* @param refname Reference name of the audio sample to test for
* @return True of the specified sound is currently playing
*/
- bool is_playing( const string& refname );
+ bool is_playing( const std::string& refname );
/**
* Request to stop playing the referred audio sample.
* @param refname Reference name of the audio sample to stop
* @return true if the audio sample exists and is scheduled to stop
*/
- bool stop( const string& refname );
+ bool stop( const std::string& refname );
/**
* Set the master volume for this sample group.
protected:
SGSoundMgr *_smgr;
- string _refname;
+ std::string _refname;
bool _active;
private:
sample_map _samples;
std::vector< SGSharedPtr<SGSoundSample> > _removed_samples;
- bool testForALError(string s);
- bool testForError(void *p, string s);
+ bool testForALError(std::string s);
+ bool testForError(void *p, std::string s);
void update_pos_and_orientation();
void update_sample_config( SGSoundSample *sound );
#include <algorithm>
#include <cstring>
+#include <boost/foreach.hpp>
+
#include "soundmgr_openal.hxx"
#include "readwav.hxx"
+#include "soundmgr_openal_private.hxx"
+#include "sample_group.hxx"
+#include <simgear/sg_inlines.h>
#include <simgear/structure/exception.hxx>
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/sg_path.hxx>
using std::string;
using std::vector;
-#if 0
-extern bool isNaN(float *v);
-#endif
#define MAX_SOURCES 128
# define ALC_ALL_DEVICES_SPECIFIER 0x1013
#endif
+class SGSoundMgr::SoundManagerPrivate
+{
+public:
+ SoundManagerPrivate() :
+ _device(NULL),
+ _context(NULL),
+ _absolute_pos(SGVec3d::zeros()),
+ _base_pos(SGVec3d::zeros()),
+ _orientation(SGQuatd::zeros())
+ {
+
+
+ }
+
+ void init()
+ {
+ _at_up_vec[0] = 0.0; _at_up_vec[1] = 0.0; _at_up_vec[2] = -1.0;
+ _at_up_vec[3] = 0.0; _at_up_vec[4] = 1.0; _at_up_vec[5] = 0.0;
+ }
+
+ void update_pos_and_orientation()
+ {
+ /**
+ * Description: ORIENTATION is a pair of 3-tuples representing the
+ * 'at' direction vector and 'up' direction of the Object in
+ * Cartesian space. AL expects two vectors that are orthogonal to
+ * each other. These vectors are not expected to be normalized. If
+ * one or more vectors have zero length, implementation behavior
+ * is undefined. If the two vectors are linearly dependent,
+ * behavior is undefined.
+ *
+ * This is in the same coordinate system as OpenGL; y=up, z=back, x=right.
+ */
+ SGVec3d sgv_at = _orientation.backTransform(-SGVec3d::e3());
+ SGVec3d sgv_up = _orientation.backTransform(SGVec3d::e2());
+ _at_up_vec[0] = sgv_at[0];
+ _at_up_vec[1] = sgv_at[1];
+ _at_up_vec[2] = sgv_at[2];
+ _at_up_vec[3] = sgv_up[0];
+ _at_up_vec[4] = sgv_up[1];
+ _at_up_vec[5] = sgv_up[2];
+
+ _absolute_pos = _base_pos;
+ }
+
+ ALCdevice *_device;
+ ALCcontext *_context;
+
+ std::vector<ALuint> _free_sources;
+ std::vector<ALuint> _sources_in_use;
+
+ SGVec3d _absolute_pos;
+ SGVec3d _base_pos;
+ SGQuatd _orientation;
+ // Orientation of the listener.
+ // first 3 elements are "at" vector, second 3 are "up" vector
+ ALfloat _at_up_vec[6];
+
+ sample_group_map _sample_groups;
+ buffer_map _buffers;
+};
+
+
//
// Sound Manager
//
_active(false),
_changed(true),
_volume(0.0),
- _device(NULL),
- _context(NULL),
- _absolute_pos(SGVec3d::zeros()),
_offset_pos(SGVec3d::zeros()),
- _base_pos(SGVec3d::zeros()),
_geod_pos(SGGeod::fromCart(SGVec3d::zeros())),
_velocity(SGVec3d::zeros()),
- _orientation(SGQuatd::zeros()),
_bad_doppler(false),
_renderer("unknown"),
_vendor("unknown")
{
+ d.reset(new SoundManagerPrivate);
}
// destructor
if (is_working())
stop();
- _sample_groups.clear();
+ d->_sample_groups.clear();
}
// initialize the sound manager
SG_LOG( SG_SOUND, SG_INFO, "Initializing OpenAL sound manager" );
- _free_sources.clear();
- _free_sources.reserve( MAX_SOURCES );
- _sources_in_use.clear();
- _sources_in_use.reserve( MAX_SOURCES );
+ d->_free_sources.clear();
+ d->_free_sources.reserve( MAX_SOURCES );
+ d->_sources_in_use.clear();
+ d->_sources_in_use.reserve( MAX_SOURCES );
ALCdevice *device = NULL;
const char* devname = _device_name.c_str();
return;
}
- if (_context != NULL)
+ if (d->_context != NULL)
{
SG_LOG(SG_SOUND, SG_ALERT, "context is already assigned");
}
- _context = context;
- _device = device;
-
- _at_up_vec[0] = 0.0; _at_up_vec[1] = 0.0; _at_up_vec[2] = -1.0;
- _at_up_vec[3] = 0.0; _at_up_vec[4] = 1.0; _at_up_vec[5] = 0.0;
+
+ d->_context = context;
+ d->_device = device;
+ d->init();
alListenerf( AL_GAIN, 0.0f );
- alListenerfv( AL_ORIENTATION, _at_up_vec );
+ alListenerfv( AL_ORIENTATION, d->_at_up_vec );
alListenerfv( AL_POSITION, SGVec3f::zeros().data() );
alListenerfv( AL_VELOCITY, SGVec3f::zeros().data() );
alGenSources(1, &source);
error = alGetError();
if ( error == AL_NO_ERROR ) {
- _free_sources.push_back( source );
+ d->_free_sources.push_back( source );
+ } else {
+ SG_LOG(SG_SOUND, SG_INFO, "allocating source failed:" << i);
+ break;
}
- else break;
}
_vendor = (const char *)alGetString(AL_VENDOR);
_bad_doppler = true;
}
- if (_free_sources.size() == 0) {
+ if (d->_free_sources.empty()) {
SG_LOG(SG_SOUND, SG_ALERT, "Unable to grab any OpenAL sources!");
}
}
void SGSoundMgr::activate() {
if ( is_working() ) {
_active = true;
- sample_group_map_iterator sample_grp_current = _sample_groups.begin();
- sample_group_map_iterator sample_grp_end = _sample_groups.end();
+
+ sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+ sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
SGSampleGroup *sgrp = sample_grp_current->second;
sgrp->activate();
void SGSoundMgr::stop() {
// first stop all sample groups
- sample_group_map_iterator sample_grp_current = _sample_groups.begin();
- sample_group_map_iterator sample_grp_end = _sample_groups.end();
+ sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+ sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
SGSampleGroup *sgrp = sample_grp_current->second;
sgrp->stop();
}
// clear all OpenAL sources
- for (unsigned int i=0; i<_free_sources.size(); i++) {
- ALuint source = _free_sources[i];
+ BOOST_FOREACH(ALuint source, d->_free_sources) {
alDeleteSources( 1 , &source );
testForALError("SGSoundMgr::stop: delete sources");
}
- _free_sources.clear();
+ d->_free_sources.clear();
// clear any OpenAL buffers before shutting down
- buffer_map_iterator buffers_current = _buffers.begin();
- buffer_map_iterator buffers_end = _buffers.end();
+ buffer_map_iterator buffers_current = d->_buffers.begin();
+ buffer_map_iterator buffers_end = d->_buffers.end();
for ( ; buffers_current != buffers_end; ++buffers_current ) {
refUint ref = buffers_current->second;
ALuint buffer = ref.id;
alDeleteBuffers(1, &buffer);
testForALError("SGSoundMgr::stop: delete buffers");
}
- _buffers.clear();
- _sources_in_use.clear();
+
+ d->_buffers.clear();
+ d->_sources_in_use.clear();
if (is_working()) {
_active = false;
- alcDestroyContext(_context);
- alcCloseDevice(_device);
- _context = NULL;
- _device = NULL;
+ alcDestroyContext(d->_context);
+ alcCloseDevice(d->_device);
+ d->_context = NULL;
+ d->_device = NULL;
_renderer = "unknown";
_vendor = "unknown";
void SGSoundMgr::suspend() {
if (is_working()) {
- sample_group_map_iterator sample_grp_current = _sample_groups.begin();
- sample_group_map_iterator sample_grp_end = _sample_groups.end();
+ sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+ sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
SGSampleGroup *sgrp = sample_grp_current->second;
sgrp->stop();
void SGSoundMgr::resume() {
if (is_working()) {
- sample_group_map_iterator sample_grp_current = _sample_groups.begin();
- sample_group_map_iterator sample_grp_end = _sample_groups.end();
+ sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+ sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
SGSampleGroup *sgrp = sample_grp_current->second;
sgrp->resume();
// run the audio scheduler
void SGSoundMgr::update( double dt ) {
if (_active) {
- alcSuspendContext(_context);
+ alcSuspendContext(d->_context);
if (_changed) {
- update_pos_and_orientation();
+ d->update_pos_and_orientation();
}
- sample_group_map_iterator sample_grp_current = _sample_groups.begin();
- sample_group_map_iterator sample_grp_end = _sample_groups.end();
+ sample_group_map_iterator sample_grp_current = d->_sample_groups.begin();
+ sample_group_map_iterator sample_grp_end = d->_sample_groups.end();
for ( ; sample_grp_current != sample_grp_end; ++sample_grp_current ) {
SGSampleGroup *sgrp = sample_grp_current->second;
sgrp->update(dt);
if (isNaN(_velocity.data())) printf("NaN in listener velocity\n");
#endif
alListenerf( AL_GAIN, _volume );
- alListenerfv( AL_ORIENTATION, _at_up_vec );
+ alListenerfv( AL_ORIENTATION, d->_at_up_vec );
// alListenerfv( AL_POSITION, toVec3f(_absolute_pos).data() );
SGQuatd hlOr = SGQuatd::fromLonLat( _geod_pos );
_changed = false;
}
- alcProcessContext(_context);
+ alcProcessContext(d->_context);
}
}
// add a sample group, return true if successful
bool SGSoundMgr::add( SGSampleGroup *sgrp, const string& refname )
{
- sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
- if ( sample_grp_it != _sample_groups.end() ) {
+ sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+ if ( sample_grp_it != d->_sample_groups.end() ) {
// sample group already exists
return false;
}
if (_active) sgrp->activate();
- _sample_groups[refname] = sgrp;
+ d->_sample_groups[refname] = sgrp;
return true;
}
// remove a sound effect, return true if successful
bool SGSoundMgr::remove( const string &refname )
{
- sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
- if ( sample_grp_it == _sample_groups.end() ) {
+ sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+ if ( sample_grp_it == d->_sample_groups.end() ) {
// sample group was not found.
return false;
}
- _sample_groups.erase( sample_grp_it );
+ d->_sample_groups.erase( sample_grp_it );
return true;
}
// return true of the specified sound exists in the sound manager system
bool SGSoundMgr::exists( const string &refname ) {
- sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
- if ( sample_grp_it == _sample_groups.end() ) {
- // sample group was not found.
- return false;
- }
-
- return true;
+ sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+ return ( sample_grp_it != d->_sample_groups.end() );
}
// return a pointer to the SGSampleGroup if the specified sound exists
// in the sound manager system, otherwise return NULL
SGSampleGroup *SGSoundMgr::find( const string &refname, bool create ) {
- sample_group_map_iterator sample_grp_it = _sample_groups.find( refname );
- if ( sample_grp_it == _sample_groups.end() ) {
+ sample_group_map_iterator sample_grp_it = d->_sample_groups.find( refname );
+ if ( sample_grp_it == d->_sample_groups.end() ) {
// sample group was not found.
if (create) {
SGSampleGroup* sgrp = new SGSampleGroup(this, refname);
void SGSoundMgr::set_volume( float v )
{
_volume = v;
- if (_volume > 1.0) _volume = 1.0;
- if (_volume < 0.0) _volume = 0.0;
+ SG_CLAMP_RANGE(_volume, 0.0f, 1.0f);
_changed = true;
}
{
unsigned int source = NO_SOURCE;
- if (_free_sources.size() > 0) {
- source = _free_sources.back();
- _free_sources.pop_back();
- _sources_in_use.push_back(source);
+ if (!d->_free_sources.empty()) {
+ source = d->_free_sources.back();
+ d->_free_sources.pop_back();
+ d->_sources_in_use.push_back(source);
}
else
SG_LOG( SG_SOUND, SG_BULK, "Sound manager: No more free sources available!\n");
{
vector<ALuint>::iterator it;
- it = std::find(_sources_in_use.begin(), _sources_in_use.end(), source);
- if ( it != _sources_in_use.end() ) {
+ it = std::find(d->_sources_in_use.begin(), d->_sources_in_use.end(), source);
+ if ( it != d->_sources_in_use.end() ) {
ALint result;
alGetSourcei( source, AL_SOURCE_STATE, &result );
alSourcei( source, AL_BUFFER, 0 ); // detach the associated buffer
testForALError("release_source");
- _free_sources.push_back( source );
- _sources_in_use.erase( it );
+ d->_free_sources.push_back( source );
+ d->_sources_in_use.erase( it );
}
}
void *sample_data = NULL;
// see if the sample name is already cached
- buffer_map_iterator buffer_it = _buffers.find( sample_name );
- if ( buffer_it != _buffers.end() ) {
+ buffer_map_iterator buffer_it = d->_buffers.find( sample_name );
+ if ( buffer_it != d->_buffers.end() ) {
buffer_it->second.refctr++;
buffer = buffer_it->second.id;
sample->set_buffer( buffer );
if ( !testForALError("buffer add data") ) {
sample->set_buffer(buffer);
- _buffers[sample_name] = refUint(buffer);
+ d->_buffers[sample_name] = refUint(buffer);
}
}
if ( !sample->is_queue() )
{
string sample_name = sample->get_sample_name();
- buffer_map_iterator buffer_it = _buffers.find( sample_name );
- if ( buffer_it == _buffers.end() ) {
+ buffer_map_iterator buffer_it = d->_buffers.find( sample_name );
+ if ( buffer_it == d->_buffers.end() ) {
// buffer was not found
return;
}
if (buffer_it->second.refctr == 0) {
ALuint buffer = buffer_it->second.id;
alDeleteBuffers(1, &buffer);
- _buffers.erase( buffer_it );
+ d->_buffers.erase( buffer_it );
testForALError("release buffer");
}
}
}
-void SGSoundMgr::update_pos_and_orientation() {
- /**
- * Description: ORIENTATION is a pair of 3-tuples representing the
- * 'at' direction vector and 'up' direction of the Object in
- * Cartesian space. AL expects two vectors that are orthogonal to
- * each other. These vectors are not expected to be normalized. If
- * one or more vectors have zero length, implementation behavior
- * is undefined. If the two vectors are linearly dependent,
- * behavior is undefined.
- *
- * This is in the same coordinate system as OpenGL; y=up, z=back, x=right.
- */
- SGVec3d sgv_at = _orientation.backTransform(-SGVec3d::e3());
- SGVec3d sgv_up = _orientation.backTransform(SGVec3d::e2());
- _at_up_vec[0] = sgv_at[0];
- _at_up_vec[1] = sgv_at[1];
- _at_up_vec[2] = sgv_at[2];
- _at_up_vec[3] = sgv_up[0];
- _at_up_vec[4] = sgv_up[1];
- _at_up_vec[5] = sgv_up[2];
-
- _absolute_pos = _base_pos;
-}
-
bool SGSoundMgr::load(const string &samplepath, void **dbuf, int *fmt,
size_t *sz, int *frq )
{
ALvoid *data;
ALfloat freqf;
- // ignore previous errors to prevent the system from halting on silly errors
- alGetError();
- alcGetError(_device);
+
data = simgear::loadWAVFromFile(samplepath, format, size, freqf );
freq = (ALsizei)freqf;
if (data == NULL) {
bool SGSoundMgr::testForALCError(string s)
{
ALCenum error;
- error = alcGetError(_device);
+ error = alcGetError(d->_device);
if (error != ALC_NO_ERROR) {
SG_LOG( SG_SOUND, SG_ALERT, "ALC Error (sound manager): "
- << alcGetString(_device, error) << " at "
+ << alcGetString(d->_device, error) << " at "
<< s);
return true;
}
return false;
}
+
+bool SGSoundMgr::is_working() const
+{
+ return (d->_device != NULL);
+}
+
+const SGQuatd& SGSoundMgr::get_orientation() const
+{
+ return d->_orientation;
+}
+
+void SGSoundMgr::set_orientation( const SGQuatd& ori )
+{
+ d->_orientation = ori;
+ _changed = true;
+}
+
+const SGVec3d& SGSoundMgr::get_position() const
+{
+ return d->_absolute_pos;
+}
+
+void SGSoundMgr::set_position( const SGVec3d& pos, const SGGeod& pos_geod )
+{
+ d->_base_pos = pos; _geod_pos = pos_geod; _changed = true;
+}
+
+SGVec3f SGSoundMgr::get_direction() const
+{
+ return SGVec3f(d->_at_up_vec[0], d->_at_up_vec[1], d->_at_up_vec[2]);
+}
#include <string>
#include <vector>
#include <map>
-
-#if defined(__APPLE__)
-# include <OpenAL/al.h>
-# include <OpenAL/alc.h>
-#elif defined(OPENALSDK)
-# include <al.h>
-# include <alc.h>
-#else
-# include <AL/al.h>
-# include <AL/alc.h>
-#endif
-
+#include <memory> // for std::auto_ptr
+
#include <simgear/compiler.h>
#include <simgear/structure/subsystem_mgr.hxx>
-#include <simgear/math/SGMathFwd.hxx>
-
-#include "sample_group.hxx"
-
-struct refUint {
- unsigned int refctr;
- ALuint id;
+#include <simgear/math/SGMath.hxx>
- refUint() { refctr = 0; id = (ALuint)-1; };
- refUint(ALuint i) { refctr = 1; id = i; };
- ~refUint() {};
-};
-
-typedef std::map < std::string, refUint > buffer_map;
-typedef buffer_map::iterator buffer_map_iterator;
-typedef buffer_map::const_iterator const_buffer_map_iterator;
-
-typedef std::map < std::string, SGSharedPtr<SGSampleGroup> > sample_group_map;
-typedef sample_group_map::iterator sample_group_map_iterator;
-typedef sample_group_map::const_iterator const_sample_group_map_iterator;
+// forward decls
+class SGSampleGroup;
+class SGSoundSample;
/**
* Manage a collection of SGSampleGroup instances
* Test is the sound manager is in a working condition.
* @return true is the sound manager is working
*/
- inline bool is_working() const { return (_device != NULL); }
+ bool is_working() const;
/**
* Set the sound manager to a working condition.
* @param refname Reference name of the sample group to find
* @return A pointer to the SGSampleGroup
*/
- SGSampleGroup *find( const string& refname, bool create = false );
+ SGSampleGroup *find( const std::string& refname, bool create = false );
/**
* Set the Cartesian position of the sound manager.
* @param pos OpenAL listener position
*/
- void set_position( const SGVec3d& pos, const SGGeod& pos_geod ) {
- _base_pos = pos; _geod_pos = pos_geod; _changed = true;
- }
+ void set_position( const SGVec3d& pos, const SGGeod& pos_geod );
void set_position_offset( const SGVec3d& pos ) {
_offset_pos = pos; _changed = true;
* This is in the same coordinate system as OpenGL; y=up, z=back, x=right
* @return OpenAL listener position
*/
- SGVec3d& get_position() { return _absolute_pos; }
+ const SGVec3d& get_position() const;
/**
* Set the velocity vector (in meters per second) of the sound manager
* Set the orientation of the sound manager
* @param ori Quaternation containing the orientation information
*/
- void set_orientation( const SGQuatd& ori ) {
- _orientation = ori; _changed = true;
- }
+ void set_orientation( const SGQuatd& ori );
/**
* Get the orientation of the sound manager
* @return Quaternation containing the orientation information
*/
- inline const SGQuatd& get_orientation() { return _orientation; }
+ const SGQuatd& get_orientation() const;
/**
* Get the direction vector of the sound manager
* This is in the same coordinate system as OpenGL; y=up, z=back, x=right.
* @return Look-at direction of the OpenAL listener
*/
- SGVec3f get_direction() {
- return SGVec3f(_at_up_vec[0], _at_up_vec[1], _at_up_vec[2]);
- }
+ SGVec3f get_direction() const;
enum {
NO_SOURCE = (unsigned int)-1,
* @param freq Pointer to a vairable that gets the sample frequency in Herz
* @return true if succesful, false on error
*/
- bool load(const string &samplepath, void **data, int *format,
+ bool load(const std::string &samplepath, void **data, int *format,
size_t *size, int *freq );
/**
const std::string& get_renderer() { return _renderer; }
private:
-
+ class SoundManagerPrivate;
+ /// private implementation object
+ std::auto_ptr<SoundManagerPrivate> d;
+
bool _active;
bool _changed;
float _volume;
- ALCdevice *_device;
- ALCcontext *_context;
-
// Position of the listener.
- SGVec3d _absolute_pos;
SGVec3d _offset_pos;
- SGVec3d _base_pos;
SGGeod _geod_pos;
// Velocity of the listener.
SGVec3d _velocity;
- // Orientation of the listener.
- // first 3 elements are "at" vector, second 3 are "up" vector
- SGQuatd _orientation;
- ALfloat _at_up_vec[6];
-
- sample_group_map _sample_groups;
- buffer_map _buffers;
-
- std::vector<ALuint> _free_sources;
- std::vector<ALuint> _sources_in_use;
-
bool _bad_doppler;
std::string _renderer;
std::string _vendor;
bool testForALCError(std::string s);
bool testForError(void *p, std::string s);
- void update_pos_and_orientation();
void update_sample_config( SGSampleGroup *sound );
};
projects / simgear.git / commitdiff