Subversion Repositories Games.Chess Giants

   // this function disposes of sound buffers and sources that have finished playing

   // this function enqueues sounds, plays them and disposes of sound buffers and sources that have finished playing

   ALfloat camera_position[3];

   float pitch;

   // cycle through all used sources and see if one is no longer playing

   // is one sound enqueued for playing ?

   for (source_index = 0; source_index < source_count; source_index++)

   if (enqueued_sound.type != 0)

      if (!sources[source_index].is_used)

      memcpy (&processed_sound, &enqueued_sound, sizeof (enqueued_sound_t));

         continue; // skip unused slots

      enqueued_sound.type = 0; // have a copy of it quickly and reset it (helps preserve thread safety)

      alGetSourcei (sources[source_index].openal_source, AL_SOURCE_STATE, &status); // get this source's playing state

      else if (processed_sound.type == SOUNDTYPE_CHECK)       swprintf_s (soundfile_path, WCHAR_SIZEOF (soundfile_path), L"%s/themes/%s/sounds/check.wav", app_path, theme->name);

      if (status == AL_PLAYING)

      else if (processed_sound.type == SOUNDTYPE_MOVE)

         continue; // skip sources that are still playing

      else if (processed_sound.type == SOUNDTYPE_SLIDE)

      alSourcei (sources[source_index].openal_source, AL_BUFFER, NULL); // untie the buffer from this source

      // now cycle through our known OpenAL buffers and see if we already know this one

      alDeleteSources (1, &sources[source_index].openal_source); // and tell OpenAL to dispose of it

      for (soundbuffer = soundbuffers; soundbuffer != NULL; soundbuffer = soundbuffer->next)

      sources[source_index].is_used = false; // mark this source as unused now

            break; // break as soon as we find it

   return; // finished, audio has been handled

      // have we NOT found it ? if so, we must create it

}

      {

void Audio_PlaySound (int sound_type, float pos_x, float pos_y, float pos_z)

               temp32 = READ_DATA (uint32_t); // skip the "chunk size" field

{

            {

   // helper function to play a sound

                  current_pos += blksiz - 16;

   uint32_t blksiz;

#undef READ_DATA

   int sample_size;

         }

   int channel_count;

         if ((sample_count == 0) || (channel_count == 0) || (sample_size == 0) || (channel_size == 0))

   int source_index;

            return; // FIXME: not a wav file

   if (!options.want_sounds)

         // compute the total number of samples (number of channels * number of frames)

      return; // if we want no sound, don't play anything

         sample_count /= sample_size;

   // now cycle through our known OpenAL buffers and see if we already know this one

         // allocate space for one more sound buffer, and tie it to the linked list

   if (soundbuffer == NULL)

         if (soundbuffers == NULL)

            temp32 = READ_DATA (uint32_t); // skip the "chunk size" field

            soundbuffers = (openal_buffer_t *) SAFE_malloc (1, sizeof (openal_buffer_t), false); // allocate a new slot to initialize the linked list

            temp32 = READ_DATA (uint32_t); // skip the "riff style" field (typically "WAVE")

            soundbuffer = soundbuffers; // and set the pointer to the beginning of the list

         else if (chunk_id == *((uint32_t *) "fmt "))

         else

            temp16 = READ_DATA (uint16_t); if (temp16 != 1) break; // compressed WAVs are unsupported

            for (soundbuffer = soundbuffers; soundbuffer->next != NULL; soundbuffer = soundbuffer->next); // locate the last slot in the linked list

            temp16 = READ_DATA (uint16_t); channel_size = (int) temp16 / 8;

            soundbuffer->next = (openal_buffer_t *) SAFE_malloc (1, sizeof (openal_buffer_t), false); // allocate a new slot and tie it there at the same time

               break; // don't go beyond the end of the file

            soundbuffer = soundbuffer->next; // and update the pointer to it

         else if (chunk_id == *((uint32_t *) "data"))

         soundbuffer->next = NULL; // this is the last sound buffer in the linked list, do remember it.

         {

            temp32 = READ_DATA (uint32_t); sample_count = (int) temp32;

         temp32 = wcslen (soundfile_path) + 1; // compute pathname buffer length (including null terminator)

            break; // current_pos is now at the beginning of data, and data measures sample_count bytes long

         soundbuffer->pathname = (wchar_t *) SAFE_malloc (temp32, sizeof (wchar_t), false); // allocate space for it

         }

         else

         for (sample_index = 0; sample_index < sample_count; sample_index++)

            blksiz = READ_DATA (uint32_t); // skip the "chunk size" field

               for (channel_index = 0; channel_index < channel_count; channel_index++)

            current_pos += blksiz; // useless chunk, skip it

            else if (channel_size == 2)

            if (current_pos >= soundfile.size)

            sample_value /= channel_count;

               break; // don't go beyond the end of the file

            soundbuffer->openal_samples[sample_index] = (ALshort) sample_value;

         #undef READ_DATA

         if (alGetError () != AL_NO_ERROR)

      sample_count /= sample_size;

      // now we have a buffer to play

      // allocate space for one more sound buffer, and tie it to the linked list

      // have we NOT found any ? if so, reallocate so as to have one more

      if (soundbuffers == NULL)

      if (source_index == source_count)

         soundbuffers = (openal_buffer_t *) SAFE_malloc (1, sizeof (openal_buffer_t), false); // allocate a new slot to initialize the linked list

         sources = (openal_source_t *) SAFE_realloc (sources, source_count, source_count + 1, sizeof (openal_source_t), false);

         soundbuffer = soundbuffers; // and set the pointer to the beginning of the list

         source_count++; // one more source has been created

      temp32 = wcslen (soundfile_path) + 1; // compute pathname buffer length (including null terminator)

      // now we have a source to play our buffer

      for (sample_index = 0; sample_index < sample_count; sample_index++)

      sources[source_index].is_used = true; // immediately mark it as used

         soundbuffer->openal_samples[sample_index] = (ALshort) sample_value;

      alGenSources (1, &sources[source_index].openal_source); // (re)create an OpenAL source

      Buffer_Forget (&soundfile); // we can now forget this sound file

      alSource3f (sources[source_index].openal_source, AL_POSITION, (ALfloat) processed_sound.emitterlocation_x * ATTENUATION_FACTOR, (ALfloat) processed_sound.emitterlocation_y * ATTENUATION_FACTOR, (ALfloat) processed_sound.emitterlocation_z * ATTENUATION_FACTOR);

      alGenBuffers (1, &soundbuffer->openal_buffer); // create an OpenAL sound buffer and fill it with our samples

      // play the source! Audio_Think() will dispose of it when it's finished

         return; // FIXME: couldn't fill OpenAL buffer

      alSourcePlay (sources[source_index].openal_source);

   // cycle through our known OpenAL sources and find a free one

   // cycle through all used sources and see if one is no longer playing

         break; // break as soon as we find it

         continue; // skip unused slots

   // have we NOT found any ? if so, reallocate so as to have one more

      alGetSourcei (sources[source_index].openal_source, AL_SOURCE_STATE, &status); // get this source's playing state

   if (source_index == source_count)

      if (status == AL_PLAYING)

   {

      sources = (openal_source_t *) SAFE_realloc (sources, source_count, source_count + 1, sizeof (openal_source_t), false);

      alSourcei (sources[source_index].openal_source, AL_BUFFER, NULL); // untie the buffer from this source

      source_count++; // one more source has been created

      sources[source_index].is_used = false; // mark this source as unused now

   // now we have a source to play our buffer

   return; // finished, audio has been handled

   alSourcef (sources[source_index].openal_source, AL_PITCH, (ALfloat) pitch); // set the source's pitch

void Audio_PlaySound (int sound_type, float pos_x, float pos_y, float pos_z)

   alSourcef (sources[source_index].openal_source, AL_GAIN, 1.0f); // set the source's volume (full)

   // helper function to play a sound (WARNING: it is NOT thread-safe!)

   alSource3f (sources[source_index].openal_source, AL_VELOCITY, 0, 0, 0); // set the source's velocity (static)

   if (!options.want_sounds)

   alSourcei (sources[source_index].openal_source, AL_LOOPING, AL_FALSE); // set it as non-looping

      return; // if we want no sound, don't play anything

   // play the source! Audio_Think() will dispose of it when it's finished

   enqueued_sound.type = sound_type; // enqueue this sound for playing. Audio_Think() will take care of it.

   alSourcePlay (sources[source_index].openal_source);

   enqueued_sound.emitterlocation_x = pos_x;