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 "listener_al.h"
+00029 
+00030 
+00031 using namespace NLMISC;
+00032 
+00033 
+00034 namespace NLSOUND {
+00035 
+00036 
+00037 // The instance of the singleton
+00038 CListenerAL     *CListenerAL::_Instance = NULL;
+00039 
+00040 
+00041 /*
+00042  * Constructor
+00043  */
+00044 CListenerAL::CListenerAL() : IListener()
+00045 {
+00046         if ( _Instance == NULL )
+00047         {
+00048                 _Instance = this;
+00049         }
+00050         else
+00051         {
+00052                 nlerror( "Listener singleton instanciated twice" );
+00053         }
+00054 }
+00055 
+00056 
+00057 /*
+00058  * Set the position vector (default: (0,0,0)) (3D mode only)
+00059  */
+00060 void                                    CListenerAL::setPos( const NLMISC::CVector& pos )
+00061 {
+00062         _Pos = pos;
+00063         // Coordinate system: conversion from NeL to OpenAL/GL:
+00064         alListener3f( AL_POSITION, pos.x, pos.z, -pos.y );
+00065         TestALError();
+00066 }
+00067 
+00068 
+00072 const NLMISC::CVector &CListenerAL::getPos() const
+00073 {
+00074         return _Pos;
+00075 
+00076 // Currently, the OpenAL headers are different between Windows and Linux versions !
+00077 // alGetListener3f() is part of the spec, though.
+00078 /*
+00079 #ifdef NL_OS_WINDOWS
+00080         // Coordsys conversion
+00081         float glposz;
+00082         alGetListener3f( AL_POSITION, &pos.x, &pos.z, &glposz );
+00083         pos.y = -glposz;
+00084 #else
+00085         float posarray [3];
+00086         alGetListenerfv( AL_POSITION, posarray );
+00087         // Coordsys conversion
+00088         pos.set( posarray[0], -posarray[2], posarray[1] );
+00089 #endif
+00090         TestALError();
+00091 */
+00092 }
+00093 
+00094 
+00095 /*
+00096  * Set the velocity vector (3D mode only)
+00097  */
+00098 void                                    CListenerAL::setVelocity( const NLMISC::CVector& vel )
+00099 {
+00100         // Coordsys conversion
+00101         alListener3f( AL_VELOCITY, vel.x, vel.z, -vel.y );
+00102         TestALError();
+00103 }
+00104 
+00105 
+00106 /*
+00107  * Get the velocity vector
+00108  */
+00109 void                                    CListenerAL::getVelocity( NLMISC::CVector& vel ) const
+00110 {
+00111 #ifdef NL_OS_WINDOWS
+00112         // Coordsys conversion
+00113         float glposz;
+00114         alGetListener3f( AL_VELOCITY, &vel.x, &vel.z, &glposz );
+00115         vel.y = - glposz;
+00116 #else
+00117         float velarray [3];
+00118         alGetListenerfv( AL_VELOCITY, velarray );
+00119         // Coordsys conversion
+00120         vel.set( velarray[0], -velarray[2], velarray[1] );
+00121 #endif
+00122         TestALError();
+00123 }
+00124 
+00125 
+00126 /*
+00127  * Set the orientation vectors (3D mode only)
+00128  */
+00129 void                                    CListenerAL::setOrientation( const NLMISC::CVector& front, const NLMISC::CVector& up )
+00130 {
+00131         // Forward then up
+00132         ALfloat v[6];
+00133         // Coordsys conversion
+00134         v[0] = front.x;
+00135         v[1] = front.z;
+00136         v[2] = -front.y;
+00137         v[3] = up.x;
+00138         v[4] = up.z;
+00139         v[5] = -up.y;
+00140         alListenerfv( AL_ORIENTATION, v );
+00141         TestALError();
+00142 }
+00143 
+00144 
+00145 /*
+00146  * Get the orientation vectors
+00147  */
+00148 void                                    CListenerAL::getOrientation( NLMISC::CVector& front, NLMISC::CVector& up ) const
+00149 {
+00150         // Forward then up
+00151         ALfloat v[6];
+00152         alGetListenerfv( AL_ORIENTATION, v );
+00153         TestALError();
+00154         // Coordsys conversion
+00155         front.set( v[0], -v[2], v[1] );
+00156         up.set( v[3], -v[5], v[4] );
+00157 }
+00158 
+00159 
+00160 /* Set the gain (volume value inside [0 , 1]). (default: 1)
+00161  * 0.0 -> silence
+00162  * 0.5 -> -6dB
+00163  * 1.0 -> no attenuation
+00164  * values > 1 (amplification) not supported by most drivers
+00165  */
+00166 void                                    CListenerAL::setGain( float gain )
+00167 {
+00168         alListenerf( AL_GAIN, gain );
+00169         TestALError();
+00170 }
+00171 
+00172 
+00173 /*
+00174  * Get the gain
+00175  */
+00176 float                                   CListenerAL::getGain() const
+00177 {
+00178         ALfloat gain;
+00179 #ifdef NL_OS_WINDOWS
+00180         alGetListenerf( AL_GAIN, &gain );
+00181 #else
+00182         alGetListenerfv( AL_GAIN, &gain );
+00183 #endif
+00184         TestALError();
+00185         return gain;
+00186 }
+00187 
+00188 
+00189 /*
+00190  * Set the doppler factor (default: 1) to exaggerate or not the doppler effect
+00191  */
+00192 void                                    CListenerAL::setDopplerFactor( float f )
+00193 {
+00194         alDopplerFactor( f );
+00195         TestALError();
+00196 }
+00197 
+00198 
+00199 /*
+00200  * Set the rolloff factor (default: 1) to scale the distance attenuation effect
+00201  */
+00202 void                                    CListenerAL::setRolloffFactor( float f )
+00203 {
+00204         nlassert( CSoundDriverAL::instance() != NULL );
+00205         CSoundDriverAL::instance()->applyRolloffFactor( f );
+00206 }
+00207 
+00208 
+00209 /*
+00210  * Set DSPROPERTY_EAXLISTENER_ENVIRONMENT and DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE if EAX available (see EAX listener properties)
+00211  */
+00212 void                                    CListenerAL::setEnvironment( uint env, float size )
+00213 {
+00214 #ifdef EAX_AVAILABLE
+00215         if ( EAXSetProp != NULL )
+00216         {
+00217                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENT, 0, &env, sizeof(unsigned long) );
+00218                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE, 0, &size, sizeof(float) );
+00219         }
+00220 #endif
+00221 }
+00222 
+00223 
+00224 /*
+00225  * Set any EAX listener property if EAX available
+00226  */
+00227 void                                    CListenerAL::setEAXProperty( uint prop, void *value, uint valuesize )
+00228 {
+00229 #ifdef EAX_AVAILABLE
+00230         if ( EAXSetProp != NULL )
+00231         {
+00232                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, prop, 0, value, valuesize );
+00233         }
+00234 #endif
+00235 }
+00236 
+00237 
+00238 } // NLSOUND
+
listener_al.cpp
