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