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 "stddsound.h"
00027 
00028 #include "listener_dsound.h"
00029 #include "sound_driver_dsound.h"
00030 
00031 
00032 using namespace NLMISC;
00033 
00034 
00035 namespace NLSOUND {
00036 
00037 
00038 // The instance of the singleton
00039 CListenerDSound *CListenerDSound::_Instance = NULL;
00040 
00041 
00042 /*
00043  * Constructor
00044  */
00045 CListenerDSound::CListenerDSound(LPDIRECTSOUND3DLISTENER dsoundListener) //: IListener()
00046 {
00047         _Pos = CVector::Null;
00048         if ( _Instance == NULL )
00049         {
00050                 _Instance = this;
00051         _Listener = dsoundListener;
00052 
00053                 setRolloffFactor(DS3D_MINROLLOFFFACTOR);
00054         }
00055         else
00056         {
00057                 //nlerror( "Listener singleton instanciated twice" );
00058         }
00059 }
00060 
00061 
00062 CListenerDSound::~CListenerDSound()
00063 {
00064         nldebug("Destroying DirectSound listener");
00065 
00066     release();
00067         _Instance = NULL;
00068 }
00069 
00070 
00071 /*
00072  *      Release all DirectSound resources
00073  */
00074 void CListenerDSound::release()
00075 {
00076     if (_Listener != NULL)
00077     {
00078         _Listener->Release();
00079                 _Listener = NULL;
00080     }
00081 }
00082 
00083 
00084 /*
00085  * Set the position vector (default: (0,0,0)) (3D mode only)
00086  */
00087 void CListenerDSound::setPos( const NLMISC::CVector& pos )
00088 {
00089 
00090         _Pos = pos;
00091         // Coordinate system: conversion from NeL to OpenAL/GL:
00092     if (_Listener != NULL)
00093     {
00094         if (FAILED(_Listener->SetPosition(pos.x, pos.z, pos.y, DS3D_DEFERRED)))
00095                 {
00096                         nlwarning("SetPosition failed");
00097                 }
00098                 else
00099                 {
00100                         //nlwarning ("set listener NEL(p:%.2f/%.2f/%.2f) DS(p:%.2f/%.2f/%.2f)", pos.x, pos.y, pos.z, pos.x, pos.z, pos.y);
00101                 }
00102         }
00103 }
00104 
00105 
00109 const NLMISC::CVector &CListenerDSound::getPos() const
00110 {
00111         return _Pos;
00112 /*      return;
00113         // Coordinate system: conversion from NeL to OpenAL/GL:
00114     if (_Listener != NULL)
00115         {
00116                 D3DVECTOR v;
00117         if (FAILED(_Listener->GetPosition(&v)))
00118                 {
00119                         nlwarning("GetPosition failed");
00120                         pos.set(0.0f, 0.0f, 0.0f);
00121                 }
00122                 else
00123                 {
00124                         pos.set(v.x, v.z, v.y);
00125                 }
00126     }
00127         else
00128         {
00129                 pos.set(0, 0, 0);
00130         }
00131 */
00132 }
00133 
00134 
00135 /*
00136  * Set the velocity vector (3D mode only)
00137  */
00138 void CListenerDSound::setVelocity( const NLMISC::CVector& vel )
00139 {
00140     if (_Listener != NULL)
00141     {
00142         if (FAILED(_Listener->SetVelocity(vel.x, vel.z, vel.y, DS3D_DEFERRED)))
00143                 {
00144                         nlwarning("SetVelocity failed");
00145                 }
00146     }
00147 }
00148 
00149 
00150 /*
00151  * Get the velocity vector
00152  */
00153 void CListenerDSound::getVelocity( NLMISC::CVector& vel ) const
00154 {
00155     if (_Listener != NULL)
00156         {
00157                 D3DVECTOR v;
00158         if (FAILED(_Listener->GetVelocity(&v)))
00159                 {
00160                         nlwarning("GetVelocity failed");
00161                         vel.set(0.0f, 0.0f, 0.0f);
00162                 }
00163                 else
00164                 {
00165                         vel.set(v.x, v.z, v.y);
00166                 }
00167     }
00168         else
00169         {
00170                 vel.set(0, 0, 0);       
00171         }
00172 }
00173 
00174 
00175 /*
00176  * Set the orientation vectors (3D mode only)
00177  */
00178 void CListenerDSound::setOrientation( const NLMISC::CVector& front, const NLMISC::CVector& up )
00179 {
00180     if (_Listener != NULL)
00181     {
00182         if (FAILED(_Listener->SetOrientation(front.x, front.z, front.y, up.x, up.z, up.y, DS3D_DEFERRED)))
00183                 {
00184                         nlwarning("SetOrientation failed");
00185                 }
00186                 else
00187                 {
00188                         //nlwarning ("NLSOUND: set listener orientation NEL(f:%.2f/%.2f/%.2f up:%.2f/%.2f/%.2f) DS(f:%.2f/%.2f/%.2f up:%.2f/%.2f/%.2f)", front.x, front.y, front.z, up.x, up.y, up.z, front.x, front.z, front.y, up.x, up.z, up.y);
00189                 }
00190     }
00191 }
00192 
00193 
00194 /*
00195  * Get the orientation vectors
00196  */
00197 void CListenerDSound::getOrientation( NLMISC::CVector& front, NLMISC::CVector& up ) const
00198 {
00199     if (_Listener != NULL)
00200         {
00201                 D3DVECTOR vfront, vtop;
00202         if (FAILED(_Listener->GetOrientation(&vfront, &vtop)))
00203                 {
00204                         nlwarning("GetOrientation failed");
00205                         front.set(0.0f, 0.0f, 1.0f);
00206                         up.set(0.0f, 1.0f, 0.0f);
00207                 }
00208                 else
00209                 {
00210                         front.set(vfront.x, vfront.z, vfront.y);
00211                         up.set(vtop.x, vtop.z, vtop.y);
00212                 }
00213     }
00214         else
00215         {
00216                 front.set(0, 0, 1);
00217                 up.set(0, 1, 0);
00218         }
00219 }
00220 
00221 
00222 /* Set the gain (volume value inside [0 , 1]). (default: 1)
00223  * 0.0 -> silence
00224  * 0.5 -> -6dB
00225  * 1.0 -> no attenuation
00226  * values > 1 (amplification) not supported by most drivers
00227  */
00228 void CListenerDSound::setGain( float gain )
00229 {
00230         CSoundDriverDSound::instance()->setGain(gain);
00231 }
00232 
00233 
00234 /*
00235  * Get the gain
00236  */
00237 float CListenerDSound::getGain() const
00238 {
00239     return CSoundDriverDSound::instance()->getGain();
00240 }
00241 
00242 
00243 /*
00244  * Set the doppler factor (default: 1) to exaggerate or not the doppler effect
00245  */
00246 void CListenerDSound::setDopplerFactor( float f )
00247 {
00248     if (_Listener != NULL)
00249     {
00250                 if (f > DS3D_MAXDOPPLERFACTOR)
00251                 {
00252                         f = DS3D_MAXDOPPLERFACTOR;
00253                 }
00254                 else if (f < DS3D_MINDOPPLERFACTOR)
00255                 {
00256                         f = DS3D_MINDOPPLERFACTOR;
00257                 }
00258 
00259         if (FAILED(_Listener->SetDopplerFactor(f, DS3D_DEFERRED)))
00260                 {
00261                         nlwarning("SetDopplerFactor failed");
00262                 }
00263     }
00264 }
00265 
00266 
00267 /*
00268  * Set the rolloff factor (default: 1) to scale the distance attenuation effect
00269  */
00270 void CListenerDSound::setRolloffFactor( float f )
00271 {
00272     if (_Listener != NULL)
00273     {
00274                 //clamp(f, DS3D_MINROLLOFFFACTOR, DS3D_MAXROLLOFFFACTOR);
00275 
00276                 // VOLUMETEST: Don't use the rolloff factor. We manage the
00277                 // volumes ourselves
00278                 f = DS3D_MINROLLOFFFACTOR;
00279 
00280         
00281                 if (FAILED(_Listener->SetRolloffFactor(f, DS3D_DEFERRED)))
00282                 {
00283                         nlwarning("SetRolloffFactor failed");
00284                 }
00285     }
00286 }
00287 
00288 
00289 float CListenerDSound::getRolloffFactor()
00290 {   
00291         if (_Listener != NULL)
00292     {
00293                 float f;
00294                 _Listener->GetRolloffFactor(&f);
00295                 return f;
00296     }
00297         else
00298         {
00299                 return 1.0;
00300         }
00301 }
00302 
00303 
00304 void CListenerDSound::commit3DChanges()
00305 {
00306     if (_Listener != NULL)
00307     {
00308                 _Listener->CommitDeferredSettings();
00309         }
00310 }
00311 
00312 
00313 /*
00314  * Set DSPROPERTY_EAXLISTENER_ENVIRONMENT and DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE if EAX available (see EAX listener properties)
00315  */
00316 void CListenerDSound::setEnvironment( uint env, float size )
00317 {
00318 #ifdef EAX_AVAILABLE
00319         if ( EAXSetProp != NULL )
00320         {
00321                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENT, 0, &env, sizeof(unsigned long) );
00322                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE, 0, &size, sizeof(float) );
00323         }
00324 #endif
00325 }
00326 
00327 
00328 /*
00329  * Set any EAX listener property if EAX available
00330  */
00331 void CListenerDSound::setEAXProperty( uint prop, void *value, uint valuesize )
00332 {
00333 #ifdef EAX_AVAILABLE
00334         if ( EAXSetProp != NULL )
00335         {
00336                 EAXSetProp( &DSPROPSETID_EAX_ListenerProperties, prop, 0, value, valuesize );
00337         }
00338 #endif
00339 }
00340 
00341 
00342 } // NLSOUND
listener_dsound.cpp
