nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdopenal.h"
+00027 
+00028 #include "source_al.h"
+00029 
+00030 using namespace NLMISC;
+00031 
+00032 
+00033 namespace NLSOUND {
+00034 
+00035 
+00036 // Currently, the OpenAL headers are different between Windows and Linux versions !
+00037 #ifdef NL_OS_UNIX
+00038 #define alGetSourcei alGetSourceiv
+00039 #define alGetSourcef alGetSourcefv
+00040 #endif
+00041 
+00042 
+00043 /*
+00044  * Constructor
+00045  */
+00046 CSourceAL::CSourceAL( ALuint sourcename ) : ISource(), _SourceName(sourcename)
+00047 {}
+00048 
+00049 
+00050 /*
+00051  * Destructor
+00052  */
+00053 CSourceAL::~CSourceAL()
+00054 {
+00055         CSoundDriverAL *sdal = CSoundDriverAL::instance();
+00056         sdal->removeSource( this );
+00057 }
+00058 
+00059 
+00060 /* Set the buffer that will be played (no streaming)
+00061  * If the buffer is stereo, the source mode becomes stereo and the source relative mode is on,
+00062  * otherwise the source is considered as a 3D source.
+00063  */
+00064 void                                    CSourceAL::setStaticBuffer( IBuffer *buffer )
+00065 {
+00066         ISource::setStaticBuffer( buffer );
+00067 
+00068         // Stop source
+00069         alSourceStop( _SourceName );
+00070         TestALError();
+00071 
+00072         // Set buffer
+00073         if ( buffer == NULL )
+00074         {
+00075                 alSourcei( _SourceName, AL_BUFFER, AL_NONE );
+00076                 TestALError();
+00077         }
+00078         else
+00079         {
+00080                 CBufferAL *bufferAL = dynamic_cast<CBufferAL*>(buffer);
+00081                 alSourcei( _SourceName, AL_BUFFER, bufferAL->bufferName() );
+00082                 TestALError();
+00083 
+00084                 // Set relative mode if the buffer is stereo
+00085                 setSourceRelativeMode( bufferAL->isStereo() );
+00086         }
+00087 }
+00088 
+00089 
+00090 /*
+00091  * Set looping on/off for future playbacks (default: off)
+00092  */
+00093 void                                    CSourceAL::setLooping( bool l )
+00094 {
+00095         alSourcei( _SourceName, AL_LOOPING, l?AL_TRUE:AL_FALSE );
+00096         TestALError();
+00097 }
+00098 
+00099 
+00100 /*
+00101  * Return the looping state
+00102  */
+00103 bool                                    CSourceAL::getLooping() const
+00104 {
+00105         ALint b;
+00106         alGetSourcei( _SourceName, AL_LOOPING, &b );
+00107         TestALError();
+00108         return ( b == AL_TRUE );
+00109 }
+00110 
+00111 
+00112 /*
+00113  * Play the static buffer (or stream in and play)
+00114  */
+00115 bool            CSourceAL::play()
+00116 {
+00117         if ( _Buffer != NULL )
+00118         {
+00119                 // Static playing mode
+00120                 alSourcePlay( _SourceName );
+00121                 TestALError();
+00122         }
+00123         else
+00124         {
+00125                 // Streaming mode
+00126                 nlwarning( "AM: Cannot play null buffer; streaming not implemented" );
+00127                 nlstop;
+00128         }
+00129 
+00130         // TODO : return a correct value, depending on alSourcePlay result.
+00131         return true;
+00132 }
+00133 
+00134 
+00135 /*
+00136  * Stop playing
+00137  */
+00138 void                                    CSourceAL::stop()
+00139 {
+00140         if ( _Buffer != NULL )
+00141         {
+00142                 // Static playing mode
+00143                 alSourceStop( _SourceName );
+00144                 TestALError();
+00145         }
+00146         else
+00147         {
+00148                 // Streaming mode
+00149                 nlwarning( "AM: Cannot stop null buffer; streaming not implemented" );
+00150                 //nlstop;
+00151         }
+00152 }
+00153 
+00154 
+00155 /*
+00156  * Pause. Call play() to resume.
+00157  */
+00158 void                                    CSourceAL::pause()
+00159 {
+00160         if ( _Buffer != NULL )
+00161         {
+00162                 // Static playing mode
+00163                 alSourcePause( _SourceName );
+00164                 TestALError();
+00165         }
+00166         else
+00167         {
+00168                 // Streaming mode
+00169                 nlwarning( "AM: Cannot pause null buffer; streaming not implemented" );
+00170                 nlstop;
+00171         }
+00172 }
+00173 
+00174 
+00175 /*
+00176  * Return the playing state
+00177  */
+00178 bool                                    CSourceAL::isPlaying() const
+00179 {
+00180         ALint srcstate;
+00181         alGetSourcei( _SourceName, AL_SOURCE_STATE, &srcstate );
+00182         TestALError();
+00183         return (srcstate == AL_PLAYING);
+00184 }
+00185 
+00186 
+00187 /*
+00188  * Return true if playing is finished or stop() has been called.
+00189  */
+00190 bool                                    CSourceAL::isStopped() const
+00191 {
+00192         ALint srcstate;
+00193         alGetSourcei( _SourceName, AL_SOURCE_STATE, &srcstate );
+00194         TestALError();
+00195         return (srcstate == AL_STOPPED);
+00196 }
+00197 
+00198 
+00199 /*
+00200  * Update the source (e.g. continue to stream the data in)
+00201  */
+00202 void                                    CSourceAL::update()
+00203 {
+00204         // Streaming not implemented
+00205 }
+00206 
+00207 
+00208 
+00209 /* Set the position vector.
+00210  * 3D mode -> 3D position
+00211  * st mode -> x is the pan value (from left (-1) to right (1)), set y and z to 0
+00212  */
+00213 void                                    CSourceAL::setPos( const NLMISC::CVector& pos )
+00214 {
+00215         _Pos = pos;
+00216         // Coordinate system: conversion from NeL to OpenAL/GL:
+00217         alSource3f( _SourceName, AL_POSITION, pos.x, pos.z, -pos.y );
+00218         TestALError();
+00219 }
+00220 
+00221 
+00222 /* Get the position vector.
+00223  * See setPos() for details.
+00224  */
+00225 const NLMISC::CVector &CSourceAL::getPos() const
+00226 {
+00227         return _Pos;
+00228 /*
+00229         ALfloat v[3];
+00230         alGetSourcefv( _SourceName, AL_POSITION, v );
+00231         TestALError();
+00232         // Coordsys conversion
+00233         pos.set( v[0], -v[2], v[1] );
+00234 */
+00235 }
+00236 
+00237 
+00238 /*
+00239  * Set the velocity vector (3D mode only)
+00240  */
+00241 void                                    CSourceAL::setVelocity( const NLMISC::CVector& vel, bool deferred )
+00242 {
+00243         // Coordsys conversion
+00244         alSource3f( _SourceName, AL_VELOCITY, vel.x, vel.z, -vel.y );
+00245         TestALError();
+00246 }
+00247 
+00248 
+00249 /*
+00250  * Get the velocity vector
+00251  */
+00252 void                                    CSourceAL::getVelocity( NLMISC::CVector& vel ) const
+00253 {
+00254         ALfloat v[3];
+00255         alGetSourcefv( _SourceName, AL_VELOCITY, v );
+00256         TestALError();
+00257         // Coordsys conversion
+00258         vel.set( v[0], -v[2], v[1] );
+00259 }
+00260 
+00261 
+00262 /*
+00263  * Set the direction vector (3D mode only)
+00264  */
+00265 void                                    CSourceAL::setDirection( const NLMISC::CVector& dir )
+00266 {
+00267         // Coordsys conversion
+00268         alSource3f( _SourceName, AL_DIRECTION, dir.x, dir.z, -dir.y );
+00269         TestALError();
+00270 }
+00271 
+00272 
+00273 /*
+00274  * Get the direction vector
+00275  */
+00276 void                                    CSourceAL::getDirection( NLMISC::CVector& dir ) const
+00277 {
+00278         ALfloat v[3];
+00279         alGetSourcefv( _SourceName, AL_DIRECTION, v );
+00280         TestALError();
+00281         // Coordsys conversion
+00282         dir.set( v[0], -v[2], v[1] );
+00283 }
+00284 
+00285 
+00286 /* Set the gain (volume value inside [0 , 1]).
+00287  * 0.0 -> silence
+00288  * 0.5 -> -6dB
+00289  * 1.0 -> no attenuation
+00290  * values > 1 (amplification) not supported by most drivers
+00291  */
+00292 void                                    CSourceAL::setGain( float gain )
+00293 {
+00294         nlassert( (gain >= 0.0f) && (gain <= 1.0f ) );
+00295         alSourcef( _SourceName, AL_GAIN, gain );
+00296         TestALError();
+00297 }
+00298 
+00299 
+00300 /*
+00301  * Get the gain
+00302  */
+00303 float                                   CSourceAL::getGain() const
+00304 {
+00305         ALfloat gain;
+00306         alGetSourcef( _SourceName, AL_GAIN, &gain );
+00307         TestALError();
+00308         return gain;
+00309 }
+00310 
+00311 
+00312 /* Shift the frequency. 1.0f equals identity, each reduction of 50% equals a pitch shift
+00313  * of one octave. 0 is not a legal value.
+00314  */
+00315 void                                    CSourceAL::setPitch( float pitch )
+00316 {
+00317         nlassert( (pitch > 0) && (pitch <= 1.0f ) );
+00318         alSourcef( _SourceName, AL_PITCH, pitch );
+00319         TestALError();
+00320 }
+00321 
+00322 
+00323 /*
+00324  * Get the pitch
+00325  */
+00326 float                                   CSourceAL::getPitch() const
+00327 {
+00328         ALfloat pitch;
+00329         alGetSourcef( _SourceName, AL_PITCH, &pitch );
+00330         TestALError();
+00331         return pitch;
+00332 }
+00333 
+00334 
+00335 /*
+00336  * Set the source relative mode. If true, positions are interpreted relative to the listener position.
+00337  */
+00338 void                                    CSourceAL::setSourceRelativeMode( bool mode )
+00339 {
+00340         alSourcei( _SourceName, AL_SOURCE_RELATIVE, mode?AL_TRUE:AL_FALSE );
+00341         TestALError();
+00342 }
+00343 
+00344 
+00345 /*
+00346  * Get the source relative mode (3D mode only)
+00347  */
+00348 bool                                    CSourceAL::getSourceRelativeMode() const
+00349 {
+00350         ALint b;
+00351         alGetSourcei( _SourceName, AL_SOURCE_RELATIVE, &b );
+00352         TestALError();
+00353         return (b==AL_TRUE);
+00354 }
+00355 
+00356 
+00357 /*
+00358  * Set the min and max distances (3D mode only)
+00359  */
+00360 void                                    CSourceAL::setMinMaxDistances( float mindist, float maxdist, bool deferred )
+00361 {
+00362         nlassert( (mindist >= 0.0f) && (maxdist >= 0.0f) );
+00363         alSourcef( _SourceName, AL_REFERENCE_DISTANCE, mindist );
+00364         alSourcef( _SourceName, AL_MAX_DISTANCE, maxdist );
+00365         TestALError();
+00366 }
+00367 
+00368 
+00369 /*
+00370  * Get the min and max distances
+00371  */
+00372 void                                    CSourceAL::getMinMaxDistances( float& mindist, float& maxdist ) const
+00373 {
+00374         alGetSourcef( _SourceName, AL_REFERENCE_DISTANCE, &mindist );
+00375         alGetSourcef( _SourceName, AL_MAX_DISTANCE, &maxdist );
+00376         TestALError();
+00377 }
+00378 
+00379 
+00380 /*
+00381  * Set the cone angles (in radian) and gain (in [0 , 1]) (3D mode only)
+00382  */
+00383 void                                    CSourceAL::setCone( float innerAngle, float outerAngle, float outerGain )
+00384 {
+00385         nlassert( (outerGain >= 0.0f) && (outerGain <= 1.0f ) );
+00386         alSourcef( _SourceName, AL_CONE_INNER_ANGLE, radToDeg(innerAngle) );
+00387         alSourcef( _SourceName, AL_CONE_OUTER_ANGLE, radToDeg(outerAngle) );
+00388         alSourcef( _SourceName, AL_CONE_OUTER_GAIN, outerGain );
+00389         TestALError();
+00390 }
+00391 
+00392 
+00393 /*
+00394  * Get the cone angles (in radian)
+00395  */
+00396 void                                    CSourceAL::getCone( float& innerAngle, float& outerAngle, float& outerGain ) const
+00397 {
+00398         float ina, outa;
+00399         alGetSourcef( _SourceName, AL_CONE_INNER_ANGLE, &ina );
+00400         innerAngle = degToRad(ina);
+00401         alGetSourcef( _SourceName, AL_CONE_OUTER_ANGLE, &outa );
+00402         outerAngle = degToRad(outa);
+00403         alGetSourcef( _SourceName, AL_CONE_OUTER_GAIN, &outerGain );
+00404         TestALError();
+00405 }
+00406 
+00407 
+00408 /*
+00409  * Set any EAX source property if EAX available
+00410  */
+00411 void                                    CSourceAL::setEAXProperty( uint prop, void *value, uint valuesize )
+00412 {
+00413 #ifdef EAX_AVAILABLE
+00414         if ( EAXSetProp != NULL )
+00415         {
+00416                 EAXSetProp( &DSPROPSETID_EAX_SourceProperties, prop, _SourceName, value, valuesize );
+00417         }
+00418 #endif
+00419 }
+00420 
+00421 
+00422 } // NLSOUND
+
source_al.cpp
