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 param, ALfloat value)
  30 {
  31     ALCcontext *Context;
  32
  33     Context = GetContextRef();
  34     if(!Context) return;
  35
  36     al_try
  37     {
  38         switch(param)
  39         {
  40             case AL_GAIN:
  41                 CHECK_VALUE(Context, value >= 0.0f && isfinite(value));
  42
  43                 Context->Listener.Gain = value;
  44                 Context->UpdateSources = AL_TRUE;
  45                 break;
  46
  47             case AL_METERS_PER_UNIT:
  48                 CHECK_VALUE(Context, value >= 0.0f && isfinite(value));
  49
  50                 Context->Listener.MetersPerUnit = value;
  51                 Context->UpdateSources = AL_TRUE;
  52                 break;
  53
  54             default:
  55                 al_throwerr(Context, AL_INVALID_ENUM);
  56         }
  57     }
  58     al_endtry;
  59
  60     ALCcontext_DecRef(Context);
  61 }
  62
  63
  64 AL_API ALvoid AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3)
  65 {
  66     ALCcontext *Context;
  67
  68     Context = GetContextRef();
  69     if(!Context) return;
  70
  71     al_try
  72     {
  73         switch(param)
  74         {
  75             case AL_POSITION:
  76                 CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));
  77
  78                 LockContext(Context);
  79                 Context->Listener.Position[0] = value1;
  80                 Context->Listener.Position[1] = value2;
  81                 Context->Listener.Position[2] = value3;
  82                 Context->UpdateSources = AL_TRUE;
  83                 UnlockContext(Context);
  84                 break;
  85
  86             case AL_VELOCITY:
  87                 CHECK_VALUE(Context, isfinite(value1) && isfinite(value2) && isfinite(value3));
  88
  89                 LockContext(Context);
  90                 Context->Listener.Velocity[0] = value1;
  91                 Context->Listener.Velocity[1] = value2;
  92                 Context->Listener.Velocity[2] = value3;
  93                 Context->UpdateSources = AL_TRUE;
  94                 UnlockContext(Context);
  95                 break;
  96
  97             default:
  98                 al_throwerr(Context, AL_INVALID_ENUM);
  99         }
 100     }
 101     al_endtry;
 102
 103     ALCcontext_DecRef(Context);
 104 }
 105
 106
 107 AL_API ALvoid AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values)
 108 {
 109     ALCcontext *Context;
 110
 111     if(values)
 112     {
 113         switch(param)
 114         {
 115             case AL_GAIN:
 116             case AL_METERS_PER_UNIT:
 117                 alListenerf(param, values[0]);
 118                 return;
 119
 120             case AL_POSITION:
 121             case AL_VELOCITY:
 122                 alListener3f(param, values[0], values[1], values[2]);
 123                 return;
 124         }
 125     }
 126
 127     Context = GetContextRef();
 128     if(!Context) return;
 129
 130     al_try
 131     {
 132         ALfloat U[3], V[3], N[3];
 133         CHECK_VALUE(Context, values);
 134         switch(param)
 135         {
 136             case AL_ORIENTATION:
 137                 CHECK_VALUE(Context, isfinite(values[0]) && isfinite(values[1]) &&
 138                                      isfinite(values[2]) && isfinite(values[3]) &&
 139                                      isfinite(values[4]) && isfinite(values[5]));
 140
 141                 /* AT then UP */
 142                 N[0] = values[0];
 143                 N[1] = values[1];
 144                 N[2] = values[2];
 145                 aluNormalize(N);
 146                 V[0] = values[3];
 147                 V[1] = values[4];
 148                 V[2] = values[5];
 149                 aluNormalize(V);
 150                 /* Build and normalize right-vector */
 151                 aluCrossproduct(N, V, U);
 152                 aluNormalize(U);
 153
 154                 LockContext(Context);
 155                 Context->Listener.Forward[0] = values[0];
 156                 Context->Listener.Forward[1] = values[1];
 157                 Context->Listener.Forward[2] = values[2];
 158                 Context->Listener.Up[0] = values[3];
 159                 Context->Listener.Up[1] = values[4];
 160                 Context->Listener.Up[2] = values[5];
 161                 Context->Listener.Matrix[0][0] =  U[0];
 162                 Context->Listener.Matrix[0][1] =  V[0];
 163                 Context->Listener.Matrix[0][2] = -N[0];
 164                 Context->Listener.Matrix[0][3] =  0.0f;
 165                 Context->Listener.Matrix[1][0] =  U[1];
 166                 Context->Listener.Matrix[1][1] =  V[1];
 167                 Context->Listener.Matrix[1][2] = -N[1];
 168                 Context->Listener.Matrix[1][3] =  0.0f;
 169                 Context->Listener.Matrix[2][0] =  U[2];
 170                 Context->Listener.Matrix[2][1] =  V[2];
 171                 Context->Listener.Matrix[2][2] = -N[2];
 172                 Context->Listener.Matrix[2][3] =  0.0f;
 173                 Context->Listener.Matrix[3][0] =  0.0f;
 174                 Context->Listener.Matrix[3][1] =  0.0f;
 175                 Context->Listener.Matrix[3][2] =  0.0f;
 176                 Context->Listener.Matrix[3][3] =  1.0f;
 177                 Context->UpdateSources = AL_TRUE;
 178                 UnlockContext(Context);
 179                 break;
 180
 181             default:
 182                 al_throwerr(Context, AL_INVALID_ENUM);
 183         }
 184     }
 185     al_endtry;
 186
 187     ALCcontext_DecRef(Context);
 188 }
 189
 190
 191 AL_API ALvoid AL_APIENTRY alListeneri(ALenum param, ALint value)
 192 {
 193     ALCcontext *Context;
 194
 195     (void)value;
 196
 197     Context = GetContextRef();
 198     if(!Context) return;
 199
 200     al_try
 201     {
 202         switch(param)
 203         {
 204             default:
 205                 al_throwerr(Context, AL_INVALID_ENUM);
 206         }
 207     }
 208     al_endtry;
 209
 210     ALCcontext_DecRef(Context);
 211 }
 212
 213
 214 AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3)
 215 {
 216     ALCcontext *Context;
 217
 218     switch(param)
 219     {
 220         case AL_POSITION:
 221         case AL_VELOCITY:
 222             alListener3f(param, (ALfloat)value1, (ALfloat)value2, (ALfloat)value3);
 223             return;
 224     }
 225
 226     Context = GetContextRef();
 227     if(!Context) return;
 228
 229     al_try
 230     {
 231         switch(param)
 232         {
 233             default:
 234                 al_throwerr(Context, AL_INVALID_ENUM);
 235         }
 236     }
 237     al_endtry;
 238
 239     ALCcontext_DecRef(Context);
 240 }
 241
 242
 243 AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values)
 244 {
 245     ALCcontext *Context;
 246
 247     if(values)
 248     {
 249         ALfloat fvals[6];
 250         switch(param)
 251         {
 252             case AL_POSITION:
 253             case AL_VELOCITY:
 254                 alListener3f(param, (ALfloat)values[0], (ALfloat)values[1], (ALfloat)values[2]);
 255                 return;
 256
 257             case AL_ORIENTATION:
 258                 fvals[0] = (ALfloat)values[0];
 259                 fvals[1] = (ALfloat)values[1];
 260                 fvals[2] = (ALfloat)values[2];
 261                 fvals[3] = (ALfloat)values[3];
 262                 fvals[4] = (ALfloat)values[4];
 263                 fvals[5] = (ALfloat)values[5];
 264                 alListenerfv(param, fvals);
 265                 return;
 266         }
 267     }
 268
 269     Context = GetContextRef();
 270     if(!Context) return;
 271
 272     al_try
 273     {
 274         CHECK_VALUE(Context, values);
 275         switch(param)
 276         {
 277             default:
 278                 al_throwerr(Context, AL_INVALID_ENUM);
 279         }
 280     }
 281     al_endtry;
 282
 283     ALCcontext_DecRef(Context);
 284 }
 285
 286
 287 AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value)
 288 {
 289     ALCcontext *Context;
 290
 291     Context = GetContextRef();
 292     if(!Context) return;
 293
 294     al_try
 295     {
 296         CHECK_VALUE(Context, value);
 297         switch(param)
 298         {
 299             case AL_GAIN:
 300                 *value = Context->Listener.Gain;
 301                 break;
 302
 303             case AL_METERS_PER_UNIT:
 304                 *value = Context->Listener.MetersPerUnit;
 305                 break;
 306
 307             default:
 308                 al_throwerr(Context, AL_INVALID_ENUM);
 309         }
 310     }
 311     al_endtry;
 312
 313     ALCcontext_DecRef(Context);
 314 }
 315
 316
 317 AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 318 {
 319     ALCcontext *Context;
 320
 321     Context = GetContextRef();
 322     if(!Context) return;
 323
 324     al_try
 325     {
 326         CHECK_VALUE(Context, value1 && value2 && value3);
 327         switch(param)
 328         {
 329             case AL_POSITION:
 330                 LockContext(Context);
 331                 *value1 = Context->Listener.Position[0];
 332                 *value2 = Context->Listener.Position[1];
 333                 *value3 = Context->Listener.Position[2];
 334                 UnlockContext(Context);
 335                 break;
 336
 337             case AL_VELOCITY:
 338                 LockContext(Context);
 339                 *value1 = Context->Listener.Velocity[0];
 340                 *value2 = Context->Listener.Velocity[1];
 341                 *value3 = Context->Listener.Velocity[2];
 342                 UnlockContext(Context);
 343                 break;
 344
 345             default:
 346                 al_throwerr(Context, AL_INVALID_ENUM);
 347         }
 348     }
 349     al_endtry;
 350
 351     ALCcontext_DecRef(Context);
 352 }
 353
 354
 355 AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values)
 356 {
 357     ALCcontext *Context;
 358
 359     switch(param)
 360     {
 361         case AL_GAIN:
 362         case AL_METERS_PER_UNIT:
 363             alGetListenerf(param, values);
 364             return;
 365
 366         case AL_POSITION:
 367         case AL_VELOCITY:
 368             alGetListener3f(param, values+0, values+1, values+2);
 369             return;
 370     }
 371
 372     Context = GetContextRef();
 373     if(!Context) return;
 374
 375     al_try
 376     {
 377         CHECK_VALUE(Context, values);
 378         switch(param)
 379         {
 380             case AL_ORIENTATION:
 381                 LockContext(Context);
 382                 // AT then UP
 383                 values[0] = Context->Listener.Forward[0];
 384                 values[1] = Context->Listener.Forward[1];
 385                 values[2] = Context->Listener.Forward[2];
 386                 values[3] = Context->Listener.Up[0];
 387                 values[4] = Context->Listener.Up[1];
 388                 values[5] = Context->Listener.Up[2];
 389                 UnlockContext(Context);
 390                 break;
 391
 392             default:
 393                 al_throwerr(Context, AL_INVALID_ENUM);
 394         }
 395     }
 396     al_endtry;
 397
 398     ALCcontext_DecRef(Context);
 399 }
 400
 401
 402 AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum param, ALint *value)
 403 {
 404     ALCcontext *Context;
 405
 406     Context = GetContextRef();
 407     if(!Context) return;
 408
 409     al_try
 410     {
 411         CHECK_VALUE(Context, value);
 412         switch(param)
 413         {
 414             default:
 415                 al_throwerr(Context, AL_INVALID_ENUM);
 416         }
 417     }
 418     al_endtry;
 419
 420     ALCcontext_DecRef(Context);
 421 }
 422
 423
 424 AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3)
 425 {
 426     ALCcontext *Context;
 427
 428     Context = GetContextRef();
 429     if(!Context) return;
 430
 431     al_try
 432     {
 433         CHECK_VALUE(Context, value1 && value2 && value3);
 434         switch (param)
 435         {
 436             case AL_POSITION:
 437                 LockContext(Context);
 438                 *value1 = (ALint)Context->Listener.Position[0];
 439                 *value2 = (ALint)Context->Listener.Position[1];
 440                 *value3 = (ALint)Context->Listener.Position[2];
 441                 UnlockContext(Context);
 442                 break;
 443
 444             case AL_VELOCITY:
 445                 LockContext(Context);
 446                 *value1 = (ALint)Context->Listener.Velocity[0];
 447                 *value2 = (ALint)Context->Listener.Velocity[1];
 448                 *value3 = (ALint)Context->Listener.Velocity[2];
 449                 UnlockContext(Context);
 450                 break;
 451
 452             default:
 453                 al_throwerr(Context, AL_INVALID_ENUM);
 454         }
 455     }
 456     al_endtry;
 457
 458     ALCcontext_DecRef(Context);
 459 }
 460
 461
 462 AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint* values)
 463 {
 464     ALCcontext *Context;
 465
 466     switch(param)
 467     {
 468         case AL_POSITION:
 469         case AL_VELOCITY:
 470             alGetListener3i(param, values+0, values+1, values+2);
 471             return;
 472     }
 473
 474     Context = GetContextRef();
 475     if(!Context) return;
 476
 477     al_try
 478     {
 479         CHECK_VALUE(Context, values);
 480         switch(param)
 481         {
 482             case AL_ORIENTATION:
 483                 LockContext(Context);
 484                 // AT then UP
 485                 values[0] = (ALint)Context->Listener.Forward[0];
 486                 values[1] = (ALint)Context->Listener.Forward[1];
 487                 values[2] = (ALint)Context->Listener.Forward[2];
 488                 values[3] = (ALint)Context->Listener.Up[0];
 489                 values[4] = (ALint)Context->Listener.Up[1];
 490                 values[5] = (ALint)Context->Listener.Up[2];
 491                 UnlockContext(Context);
 492                 break;
 493
 494             default:
 495                 al_throwerr(Context, AL_INVALID_ENUM);
 496         }
 497     }
 498     al_endtry;
 499
 500     ALCcontext_DecRef(Context);
 501 }