OpenAL32/alListener.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2000 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "alMain.h"
  24 #include "AL/alc.h"
  25 #include "alError.h"
  26 #include "alListener.h"
  27 #include "alSource.h"
  28
  29 AL_API ALvoid AL_APIENTRY alListenerf(ALenum eParam, ALfloat flValue)
  30 {
  31     ALCcontext *pContext;
  32
  33     pContext = GetLockedContext();
  34     if(!pContext) return;
  35
  36     switch(eParam)
  37     {
  38         case AL_GAIN:
  39             if(flValue >= 0.0f)
  40             {
  41                 pContext->Listener.Gain = flValue;
  42                 pContext->UpdateSources = AL_TRUE;
  43             }
  44             else
  45                 alSetError(pContext, AL_INVALID_VALUE);
  46             break;
  47
  48         case AL_METERS_PER_UNIT:
  49             if(flValue > 0.0f)
  50             {
  51                 pContext->Listener.MetersPerUnit = flValue;
  52                 pContext->UpdateSources = AL_TRUE;
  53             }
  54             else
  55                 alSetError(pContext, AL_INVALID_VALUE);
  56             break;
  57
  58         default:
  59             alSetError(pContext, AL_INVALID_ENUM);
  60             break;
  61     }
  62
  63     UnlockContext(pContext);
  64 }
  65
  66
  67 AL_API ALvoid AL_APIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
  68 {
  69     ALCcontext *pContext;
  70
  71     pContext = GetLockedContext();
  72     if(!pContext) return;
  73
  74     switch(eParam)
  75     {
  76         case AL_POSITION:
  77             pContext->Listener.Position[0] = flValue1;
  78             pContext->Listener.Position[1] = flValue2;
  79             pContext->Listener.Position[2] = flValue3;
  80             pContext->UpdateSources = AL_TRUE;
  81             break;
  82
  83         case AL_VELOCITY:
  84             pContext->Listener.Velocity[0] = flValue1;
  85             pContext->Listener.Velocity[1] = flValue2;
  86             pContext->Listener.Velocity[2] = flValue3;
  87             pContext->UpdateSources = AL_TRUE;
  88             break;
  89
  90         default:
  91             alSetError(pContext, AL_INVALID_ENUM);
  92             break;
  93     }
  94
  95     UnlockContext(pContext);
  96 }
  97
  98
  99 AL_API ALvoid AL_APIENTRY alListenerfv(ALenum eParam, const ALfloat *pflValues)
 100 {
 101     ALCcontext *pContext;
 102
 103     if(pflValues)
 104     {
 105         switch(eParam)
 106         {
 107             case AL_GAIN:
 108             case AL_METERS_PER_UNIT:
 109                 alListenerf(eParam, pflValues[0]);
 110                 return;
 111
 112             case AL_POSITION:
 113             case AL_VELOCITY:
 114                 alListener3f(eParam, pflValues[0], pflValues[1], pflValues[2]);
 115                 return;
 116         }
 117     }
 118
 119     pContext = GetLockedContext();
 120     if(!pContext) return;
 121
 122     if(pflValues)
 123     {
 124         switch(eParam)
 125         {
 126             case AL_ORIENTATION:
 127                 // AT then UP
 128                 pContext->Listener.Forward[0] = pflValues[0];
 129                 pContext->Listener.Forward[1] = pflValues[1];
 130                 pContext->Listener.Forward[2] = pflValues[2];
 131                 pContext->Listener.Up[0] = pflValues[3];
 132                 pContext->Listener.Up[1] = pflValues[4];
 133                 pContext->Listener.Up[2] = pflValues[5];
 134                 pContext->UpdateSources = AL_TRUE;
 135                 break;
 136
 137             default:
 138                 alSetError(pContext, AL_INVALID_ENUM);
 139                 break;
 140         }
 141     }
 142     else
 143         alSetError(pContext, AL_INVALID_VALUE);
 144
 145     UnlockContext(pContext);
 146 }
 147
 148
 149 AL_API ALvoid AL_APIENTRY alListeneri(ALenum eParam, ALint lValue)
 150 {
 151     ALCcontext *pContext;
 152
 153     (void)lValue;
 154
 155     pContext = GetLockedContext();
 156     if(!pContext) return;
 157
 158     switch(eParam)
 159     {
 160         default:
 161             alSetError(pContext, AL_INVALID_ENUM);
 162             break;
 163     }
 164
 165     UnlockContext(pContext);
 166 }
 167
 168
 169 AL_API void AL_APIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 170 {
 171     ALCcontext *pContext;
 172
 173     switch(eParam)
 174     {
 175         case AL_POSITION:
 176         case AL_VELOCITY:
 177             alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
 178             return;
 179     }
 180
 181     pContext = GetLockedContext();
 182     if(!pContext) return;
 183
 184     switch(eParam)
 185     {
 186         default:
 187             alSetError(pContext, AL_INVALID_ENUM);
 188             break;
 189     }
 190
 191     UnlockContext(pContext);
 192 }
 193
 194
 195 AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
 196 {
 197     ALCcontext *pContext;
 198     ALfloat flValues[6];
 199
 200     pContext = GetLockedContext();
 201     if(!pContext) return;
 202
 203     if(plValues)
 204     {
 205         switch(eParam)
 206         {
 207             case AL_POSITION:
 208             case AL_VELOCITY:
 209                 flValues[0] = (ALfloat)plValues[0];
 210                 flValues[1] = (ALfloat)plValues[1];
 211                 flValues[2] = (ALfloat)plValues[2];
 212                 alListenerfv(eParam, flValues);
 213                 break;
 214
 215             case AL_ORIENTATION:
 216                 flValues[0] = (ALfloat)plValues[0];
 217                 flValues[1] = (ALfloat)plValues[1];
 218                 flValues[2] = (ALfloat)plValues[2];
 219                 flValues[3] = (ALfloat)plValues[3];
 220                 flValues[4] = (ALfloat)plValues[4];
 221                 flValues[5] = (ALfloat)plValues[5];
 222                 alListenerfv(eParam, flValues);
 223                 break;
 224
 225             default:
 226                 alSetError(pContext, AL_INVALID_ENUM);
 227                 break;
 228         }
 229     }
 230     else
 231         alSetError(pContext, AL_INVALID_VALUE);
 232
 233     UnlockContext(pContext);
 234 }
 235
 236
 237 AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
 238 {
 239     ALCcontext *pContext;
 240
 241     pContext = GetLockedContext();
 242     if(!pContext) return;
 243
 244     if(pflValue)
 245     {
 246         switch(eParam)
 247         {
 248             case AL_GAIN:
 249                 *pflValue = pContext->Listener.Gain;
 250                 break;
 251
 252             case AL_METERS_PER_UNIT:
 253                 *pflValue = pContext->Listener.MetersPerUnit;
 254                 break;
 255
 256             default:
 257                 alSetError(pContext, AL_INVALID_ENUM);
 258                 break;
 259         }
 260     }
 261     else
 262         alSetError(pContext, AL_INVALID_VALUE);
 263
 264     UnlockContext(pContext);
 265 }
 266
 267
 268 AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
 269 {
 270     ALCcontext *pContext;
 271
 272     pContext = GetLockedContext();
 273     if(!pContext) return;
 274
 275     if(pflValue1 && pflValue2 && pflValue3)
 276     {
 277         switch(eParam)
 278         {
 279             case AL_POSITION:
 280                 *pflValue1 = pContext->Listener.Position[0];
 281                 *pflValue2 = pContext->Listener.Position[1];
 282                 *pflValue3 = pContext->Listener.Position[2];
 283                 break;
 284
 285             case AL_VELOCITY:
 286                 *pflValue1 = pContext->Listener.Velocity[0];
 287                 *pflValue2 = pContext->Listener.Velocity[1];
 288                 *pflValue3 = pContext->Listener.Velocity[2];
 289                 break;
 290
 291             default:
 292                 alSetError(pContext, AL_INVALID_ENUM);
 293                 break;
 294         }
 295     }
 296     else
 297         alSetError(pContext, AL_INVALID_VALUE);
 298
 299     UnlockContext(pContext);
 300 }
 301
 302
 303 AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
 304 {
 305     ALCcontext *pContext;
 306
 307     switch(eParam)
 308     {
 309         case AL_GAIN:
 310         case AL_METERS_PER_UNIT:
 311             alGetListenerf(eParam, pflValues);
 312             return;
 313
 314         case AL_POSITION:
 315         case AL_VELOCITY:
 316             alGetListener3f(eParam, pflValues+0, pflValues+1, pflValues+2);
 317             return;
 318     }
 319
 320     pContext = GetLockedContext();
 321     if(!pContext) return;
 322
 323     if(pflValues)
 324     {
 325         switch(eParam)
 326         {
 327             case AL_ORIENTATION:
 328                 // AT then UP
 329                 pflValues[0] = pContext->Listener.Forward[0];
 330                 pflValues[1] = pContext->Listener.Forward[1];
 331                 pflValues[2] = pContext->Listener.Forward[2];
 332                 pflValues[3] = pContext->Listener.Up[0];
 333                 pflValues[4] = pContext->Listener.Up[1];
 334                 pflValues[5] = pContext->Listener.Up[2];
 335                 break;
 336
 337             default:
 338                 alSetError(pContext, AL_INVALID_ENUM);
 339                 break;
 340         }
 341     }
 342     else
 343         alSetError(pContext, AL_INVALID_VALUE);
 344
 345     UnlockContext(pContext);
 346 }
 347
 348
 349 AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
 350 {
 351     ALCcontext *pContext;
 352
 353     pContext = GetLockedContext();
 354     if(!pContext) return;
 355
 356     if(plValue)
 357     {
 358         switch(eParam)
 359         {
 360             default:
 361                 alSetError(pContext, AL_INVALID_ENUM);
 362                 break;
 363         }
 364     }
 365     else
 366         alSetError(pContext, AL_INVALID_VALUE);
 367
 368     UnlockContext(pContext);
 369 }
 370
 371
 372 AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
 373 {
 374     ALCcontext *pContext;
 375
 376     pContext = GetLockedContext();
 377     if(!pContext) return;
 378
 379     if(plValue1 && plValue2 && plValue3)
 380     {
 381         switch (eParam)
 382         {
 383             case AL_POSITION:
 384                 *plValue1 = (ALint)pContext->Listener.Position[0];
 385                 *plValue2 = (ALint)pContext->Listener.Position[1];
 386                 *plValue3 = (ALint)pContext->Listener.Position[2];
 387                 break;
 388
 389             case AL_VELOCITY:
 390                 *plValue1 = (ALint)pContext->Listener.Velocity[0];
 391                 *plValue2 = (ALint)pContext->Listener.Velocity[1];
 392                 *plValue3 = (ALint)pContext->Listener.Velocity[2];
 393                 break;
 394
 395             default:
 396                 alSetError(pContext, AL_INVALID_ENUM);
 397                 break;
 398         }
 399     }
 400     else
 401         alSetError(pContext, AL_INVALID_VALUE);
 402
 403     UnlockContext(pContext);
 404 }
 405
 406
 407 AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
 408 {
 409     ALCcontext *pContext;
 410
 411     switch(eParam)
 412     {
 413         case AL_POSITION:
 414         case AL_VELOCITY:
 415             alGetListener3i(eParam, plValues+0, plValues+1, plValues+2);
 416             return;
 417     }
 418
 419     pContext = GetLockedContext();
 420     if(!pContext) return;
 421
 422     if(plValues)
 423     {
 424         switch(eParam)
 425         {
 426             case AL_ORIENTATION:
 427                 // AT then UP
 428                 plValues[0] = (ALint)pContext->Listener.Forward[0];
 429                 plValues[1] = (ALint)pContext->Listener.Forward[1];
 430                 plValues[2] = (ALint)pContext->Listener.Forward[2];
 431                 plValues[3] = (ALint)pContext->Listener.Up[0];
 432                 plValues[4] = (ALint)pContext->Listener.Up[1];
 433                 plValues[5] = (ALint)pContext->Listener.Up[2];
 434                 break;
 435
 436             default:
 437                 alSetError(pContext, AL_INVALID_ENUM);
 438                 break;
 439         }
 440     }
 441     else
 442         alSetError(pContext, AL_INVALID_VALUE);
 443
 444     UnlockContext(pContext);
 445 }