Пример #1
0
static int lua_alDistanceModel(lua_State* lua_state)
{
	ALenum enum_parameter;
	enum_parameter = lua_tointeger(lua_state, 1);
	alDistanceModel(enum_parameter);
	return 0;
}
Пример #2
0
bool ALSound::Create()
{
    CleanUp();

    if (m_enabled)
        return true;

    GetLogger()->Info("Opening audio device...\n");
    m_device = alcOpenDevice(nullptr);
    if (!m_device)
    {
        GetLogger()->Error("Could not open audio device!\n");
        return false;
    }

    m_context = alcCreateContext(m_device, nullptr);
    if (!m_context)
    {
        GetLogger()->Error("Could not create audio context!\n");
        return false;
    }
    alcMakeContextCurrent(m_context);
    alListenerf(AL_GAIN, m_audioVolume);
    alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);

    GetLogger()->Info("Done.\n");
    m_enabled = true;
    return true;
}
Пример #3
0
COpenALSound::COpenALSound()
{
	maxSounds = configHandler.GetInt("MaxSounds",16);
	noSound = false;
	cur = 0;
	if (!noSound) {
		ALCdevice *device = alcOpenDevice(NULL);
		if (device != NULL) {
			ALCcontext *context = alcCreateContext(device, NULL);
			if (context != NULL)
				alcMakeContextCurrent(context);
			else {
				handleerror(0, "Could not create audio context","OpenAL error",MBF_OK);
				noSound = true;
				alcCloseDevice(device);
				return;
			}
		} else {
			handleerror(0,"Could not create audio device","OpenAL error",MBF_OK);
			noSound = true;
			return;
		}
	}

	// Generate sound sources
	Sources = new ALuint[maxSounds];
	for (int a=0;a<maxSounds;a++) Sources[a]=0;

	// Set distance model (sound attenuation)
	alDistanceModel (AL_INVERSE_DISTANCE);

	posScale.x = 0.02f;
	posScale.y = 0.02f;
	posScale.z = 0.0005f;
}
Пример #4
0
void
sound_init ()
{
    if (have_al)
	return;
    if ((dev = alcOpenDevice (NULL)) == NULL)
	return;
    if ((context_id = alcCreateContext (dev, NULL)) == NULL)
    {
	alcCloseDevice (dev);
	have_al = 0;
	return;
    }
    alcMakeContextCurrent (context_id);

    alGenSources (1, &source);

    alGenBuffers (2, wave);
    sound_load (wave[SOUND_BOINK], "/boink.wav");
    sound_load (wave[SOUND_NNGNGNG], "/lose.wav");

    alDistanceModel (AL_DISTANCE_MODEL);
    alSourcef (source, AL_REFERENCE_DISTANCE, 22.0);

    have_al = 1;
    return;
}
Пример #5
0
GAudio::GAudio() : mDevice(NULL), mContext(NULL), mChannels(NULL)
{
  // open the device
  mDevice = alcOpenDevice(NULL);
  if(mDevice==NULL) GAssert("GAudio: could not open the al device!.");

  // create a context
  ALCint caps[] = 
  { 
    ALC_FREQUENCY, 44100,
    ALC_STEREO_SOURCES, 4, 
    0, 0
  };
  mContext = alcCreateContext(mDevice, caps);
  if(mContext==NULL) GAssert("GAudio: could not create a al context.");
  CHECK(alcMakeContextCurrent(mContext));

  // initialize channels.
  mChannels = GNEW(GAudioSource[MAX_AUDIO_CHANNELS]);
  CHECK(mChannels);
  for(U32 i = 0; i < MAX_AUDIO_CHANNELS; i++)
  {
    mFrees.push_back(&mChannels[i]);
  }

  // use our own distance model.
  alDistanceModel(AL_NONE);
}
Пример #6
0
void cOAL_Device::SetDistanceModel(eOAL_DistanceModel aModel)
{
	DEF_FUNC_NAME("OAL_SetDistanceModel");
	FUNC_USES_AL;

	ALenum distModel;
	switch(aModel)
	{
	case eOAL_DistanceModel_Inverse:
		distModel = AL_INVERSE_DISTANCE;
		break;
	case eOAL_DistanceModel_Inverse_Clamped:
		distModel = AL_INVERSE_DISTANCE_CLAMPED;
		break;
	case eOAL_DistanceModel_Linear:
		distModel = AL_LINEAR_DISTANCE;
		break;
	case eOAL_DistanceModel_Linear_Clamped:
		distModel = AL_LINEAR_DISTANCE_CLAMPED;
		break;
	case eOAL_DistanceModel_Exponent:
		distModel = AL_EXPONENT_DISTANCE;
		break;
	case eOAL_DistanceModel_Exponent_Clamped:
		distModel = AL_EXPONENT_DISTANCE_CLAMPED;
		break;
	case eOAL_DistanceModel_None:
		distModel = AL_NONE;
	default:
		break;
	}

	RUN_AL_FUNC(alDistanceModel(distModel));
}
// Thread: Any. Must be locked: AudioMutex.
bool CreatePlaybackDevice() {
	if (AudioDevice) return true;

	AudioDevice = alcOpenDevice(nullptr);
	if (!AudioDevice) {
		LOG(("Audio Error: Could not create default playback device, enumerating.."));
		EnumeratePlaybackDevices();
		return false;
	}

	ALCint attributes[] = {
		ALC_STEREO_SOURCES, 128,
		ALC_FREQUENCY, Media::Player::kDefaultFrequency,
		0
	};
	AudioContext = alcCreateContext(AudioDevice, attributes);
	alcMakeContextCurrent(AudioContext);
	if (ContextErrorHappened()) {
		DestroyPlaybackDevice();
		return false;
	}

	ALfloat v[] = { 0.f, 0.f, -1.f, 0.f, 1.f, 0.f };
	alListener3f(AL_POSITION, 0.f, 0.f, 0.f);
	alListener3f(AL_VELOCITY, 0.f, 0.f, 0.f);
	alListenerfv(AL_ORIENTATION, v);

	alDistanceModel(AL_NONE);

	return true;
}
Пример #8
0
int DS_Init(void)
{
    // Already initialized?
    if(initOk) return true;

    // Open the default playback device.
    device = alcOpenDevice(NULL);
    if(!device)
    {
        Con_Message("OpenAL init failed (default playback device).");
        return false;
    }

    // Create and make current a new context.
    alcMakeContextCurrent(context = alcCreateContext(device, NULL));
    DSOPENAL_ERRCHECK(alGetError());

    // Attempt to load and configure the EAX extensions.
    loadExtensions();

    // Configure the listener and global OpenAL properties/state.
    alListenerf(AL_GAIN, 1);
    alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
    headYaw = headPitch = 0;
    unitsPerMeter = 36;

    // Everything is OK.
    DSOPENAL_TRACE("DS_Init: OpenAL initialized%s." << (hasEAX? " (EAX 2.0 available)" : ""));
    initOk = true;
    return true;
}
Пример #9
0
    AudioWorld::AudioWorld(Engine::BaseEngine& engine, AudioEngine& audio_engine, const VDFS::FileIndex& vdfidx)
        : m_Engine(engine)
        , m_VDFSIndex(vdfidx)
        , m_exiting(false)
    {
#ifdef RE_USE_SOUND
        if (!audio_engine.getDevice())
            return;

        m_Context = alcCreateContext(audio_engine.getDevice(), nullptr);
        if (!m_Context)
        {
            LogWarn() << "Could not create OpenAL context: "
                      << AudioEngine::getErrorString(alcGetError(audio_engine.getDevice()));
            return;
        }

        alcMakeContextCurrent(m_Context);

        alListener3f(AL_POSITION, 0, 0, 0.0f);
        // check for errors
        alListener3f(AL_VELOCITY, 0, 0, 0);
        // check for errors
        ALfloat listenerOri[] = {0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f};
        alListenerfv(AL_ORIENTATION, listenerOri);

        // Need this for AL_MAX_DISTANCE to work
        alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);

        createSounds();

        initializeMusic();
#endif
    }
Пример #10
0
	OpenALSoundManager(OnDemandSoundFetcher *fetcher):
		m_fetcher(fetcher),
		m_device(NULL),
		m_context(NULL),
		m_can_vorbis(false),
		m_next_id(1),
		m_is_initialized(false)
	{
		ALCenum error = ALC_NO_ERROR;
		
		infostream<<"Audio: Initializing..."<<std::endl;

		m_device = alcOpenDevice(NULL);
		if(!m_device){
			infostream<<"Audio: No audio device available, audio system "
				<<"not initialized"<<std::endl;
			return;
		}

		if(alcIsExtensionPresent(m_device, "EXT_vorbis")){
			infostream<<"Audio: Vorbis extension present"<<std::endl;
			m_can_vorbis = true;
		} else{
			infostream<<"Audio: Vorbis extension NOT present"<<std::endl;
			m_can_vorbis = false;
		}

		m_context = alcCreateContext(m_device, NULL);
		if(!m_context){
			error = alcGetError(m_device);
			infostream<<"Audio: Unable to initialize audio context, "
					<<"aborting audio initialization ("<<alcErrorString(error)
					<<")"<<std::endl;
			alcCloseDevice(m_device);
			m_device = NULL;
			return;
		}

		if(!alcMakeContextCurrent(m_context) ||
				(error = alcGetError(m_device) != ALC_NO_ERROR))
		{
			infostream<<"Audio: Error setting audio context, aborting audio "
					<<"initialization ("<<alcErrorString(error)<<")"<<std::endl;
			alcDestroyContext(m_context);
			m_context = NULL;
			alcCloseDevice(m_device);
			m_device = NULL;
			return;
		}

		alDistanceModel(AL_EXPONENT_DISTANCE);

		infostream<<"Audio: Initialized: OpenAL "<<alGetString(AL_VERSION)
				<<", using "<<alcGetString(m_device, ALC_DEVICE_SPECIFIER)
				<<std::endl;

		m_is_initialized = true;
	}
Пример #11
0
void OpenALDevice::setDistanceModel(DistanceModel model)
{
	std::lock_guard<std::recursive_mutex> lock(m_mutex);

	switch(model)
	{
	case DISTANCE_MODEL_INVERSE:
		alDistanceModel(AL_INVERSE_DISTANCE);
		break;
	case DISTANCE_MODEL_INVERSE_CLAMPED:
		alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
		break;
	case DISTANCE_MODEL_LINEAR:
		alDistanceModel(AL_LINEAR_DISTANCE);
		break;
	case DISTANCE_MODEL_LINEAR_CLAMPED:
		alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
		break;
	case DISTANCE_MODEL_EXPONENT:
		alDistanceModel(AL_EXPONENT_DISTANCE);
		break;
	case DISTANCE_MODEL_EXPONENT_CLAMPED:
		alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED);
		break;
	default:
		alDistanceModel(AL_NONE);
	}
}
Пример #12
0
void AUD_OpenALDevice::setDistanceModel(AUD_DistanceModel model)
{
	switch(model)
	{
	case AUD_DISTANCE_MODEL_INVERSE:
		alDistanceModel(AL_INVERSE_DISTANCE);
		break;
	case AUD_DISTANCE_MODEL_INVERSE_CLAMPED:
		alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
		break;
	case AUD_DISTANCE_MODEL_LINEAR:
		alDistanceModel(AL_LINEAR_DISTANCE);
		break;
	case AUD_DISTANCE_MODEL_LINEAR_CLAMPED:
		alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
		break;
	case AUD_DISTANCE_MODEL_EXPONENT:
		alDistanceModel(AL_EXPONENT_DISTANCE);
		break;
	case AUD_DISTANCE_MODEL_EXPONENT_CLAMPED:
		alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED);
		break;
	default:
		alDistanceModel(AL_NONE);
	}
}
Пример #13
0
Audio::Audio(){
	dev = alcOpenDevice(NULL);
	ctx = alcCreateContext(dev, NULL);
	alcMakeContextCurrent(ctx);

//	alDistanceModel(AL_INVERSE_DISTANCE);
	alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
	//alListenerf(AL_GAIN, 0.0f);
}
Пример #14
0
optional<string> AudioDevice::initialize() {
  if ((device = alcOpenDevice(nullptr))) {
    if ((context = alcCreateContext((ALCdevice*)device, nullptr))) {
      alcMakeContextCurrent((ALCcontext*)context);
      alDistanceModel(AL_NONE);
      initialized = true;
      return none;
    }
  }
  return "Error code: " + toString(alGetError());
}
Пример #15
0
void CSoundManager::InitListener()
{
	ALfloat listenerPos[] = {0.0, 0.0, 0.0};
	ALfloat listenerVel[] = {0.0, 0.0, 0.0};
	ALfloat	listenerOri[] = {0.0, 0.0, -1.0, 0.0, 1.0, 0.0};

	alListenerfv(AL_POSITION, listenerPos);
	alListenerfv(AL_VELOCITY, listenerVel);
	alListenerfv(AL_ORIENTATION, listenerOri);

	alDistanceModel(AL_LINEAR_DISTANCE);
}
Пример #16
0
void CSound::StartThread(int maxSounds)
{
#if BOOST_VERSION >= 103500
	try
	{
#endif
		{
			boost::mutex::scoped_lock lck(soundMutex);

			// Generate sound sources
			for (int i = 0; i < maxSounds; i++)
			{
				SoundSource* thenewone = new SoundSource();
				if (thenewone->IsValid())
				{
					sources.push_back(thenewone);
				}
				else
				{
					maxSounds = std::max(i-1,0);
					LogObject(LOG_SOUND) << "Your hardware/driver can not handle more than " << maxSounds << " soundsources";
					delete thenewone;
					break;
				}
			}

			// Set distance model (sound attenuation)
			alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
			//alDopplerFactor(1.0);

			alListenerf(AL_GAIN, masterVolume);
		}
		configHandler->Set("MaxSounds", maxSounds);

		soundThreadRunning = true;
		while (soundThreadRunning) {
#if BOOST_VERSION >= 103500
			boost::this_thread::sleep(boost::posix_time::millisec(50)); // sleep
#else
			SDL_Delay(50);
#endif
			boost::mutex::scoped_lock lck(soundMutex); // lock
			Update(); // call update
		}
#if BOOST_VERSION >= 103500
	}
	catch(boost::thread_interrupted const&)
	{
		// do cleanup here
	}
#endif
}
Пример #17
0
Handle<Value> ALDistanceModelCallback(const Arguments& args) {
	//if less that nbr of formal parameters then do nothing
	if (args.Length() < 1)
		return v8::Undefined();
	
	//get arguments
	int arg0 = args[0]->IntegerValue();

	//make call
	alDistanceModel((ALenum)arg0);
	
	return v8::Undefined();
}
Пример #18
0
// Thread: Any. Must be locked: AudioMutex.
bool CreatePlaybackDevice() {
	if (AudioDevice) return true;

	AudioDevice = alcOpenDevice(nullptr);
	if (!AudioDevice) {
		LOG(("Audio Error: Could not create default playback device, enumerating.."));
		EnumeratePlaybackDevices();
		return false;
	}

	ALCint attributes[] = {
		ALC_STEREO_SOURCES, 128,
		ALC_FREQUENCY, Media::Player::kDefaultFrequency,
		0
	};
	AudioContext = alcCreateContext(AudioDevice, attributes);
	alcMakeContextCurrent(AudioContext);
	if (ContextErrorHappened()) {
		DestroyPlaybackDevice();
		return false;
	}

	ALfloat v[] = { 0.f, 0.f, -1.f, 0.f, 1.f, 0.f };
	alListener3f(AL_POSITION, 0.f, 0.f, 0.f);
	alListener3f(AL_VELOCITY, 0.f, 0.f, 0.f);
	alListenerfv(AL_ORIENTATION, v);

#ifndef TDESKTOP_DISABLE_OPENAL_EFFECTS
	// playback speed related init
	// generate an effect slot and an effect
	alGenAuxiliaryEffectSlots(1, &_playbackSpeedData.uiEffectSlot);
	alGenEffects(1, &_playbackSpeedData.uiEffect);
	// initialize the pitch shifter effect
	alEffecti(_playbackSpeedData.uiEffect, AL_EFFECT_TYPE, AL_EFFECT_PITCH_SHIFTER);
	// 12 semitones = 1 octave
	alEffecti(_playbackSpeedData.uiEffect, AL_PITCH_SHIFTER_COARSE_TUNE, kPlaybackSpeedTune);
	// connect the effect with the effect slot
	alAuxiliaryEffectSloti(_playbackSpeedData.uiEffectSlot, AL_EFFECTSLOT_EFFECT, _playbackSpeedData.uiEffect);
	// initialize a filter to disable the direct (dry) path
	alGenFilters(1, &_playbackSpeedData.uiFilter);
	alFilteri(_playbackSpeedData.uiFilter, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
	// disable all frequencies
	alFilterf(_playbackSpeedData.uiFilter, AL_LOWPASS_GAIN, 0.f);
	// to use the modified playback speed:
	// connect both the effect slot and filter with the stream source and set AL_PITCH
#endif // TDESKTOP_DISABLE_OPENAL_EFFECTS

	alDistanceModel(AL_NONE);

	return true;
}
Пример #19
0
/* The open method starts up the driver and should lock the device, using the
   previously set paramters, or defaults. It shouldn't need to start sending
   audio data to the device yet, however. */
static int _openal_open(void)
{
   ALenum openal_err;
   ALCenum alc_err;

   ALLEGRO_INFO("Starting OpenAL\n");

   /* clear the error state */
   openal_err = alGetError();

   /* pick default device. always a good choice */
   openal_dev = alcOpenDevice(NULL);

   alc_err = ALC_NO_ERROR;
   if (!openal_dev || (alc_err = alcGetError(openal_dev)) != ALC_NO_ERROR) {
      ALLEGRO_ERROR("Could not open audio device: %s\n",
         alc_get_err_str(alc_err));
      return 1;
   }

   openal_context = alcCreateContext(openal_dev, NULL);
   alc_err = ALC_NO_ERROR;
   if (!openal_context || (alc_err = alcGetError(openal_dev)) != ALC_NO_ERROR) {
      ALLEGRO_ERROR("Could not create current device context: %s\n",
         alc_get_err_str(alc_err));
      return 1;
   }

   alcMakeContextCurrent(openal_context);
#if !defined ALLEGRO_IPHONE
   if ((alc_err = alcGetError(openal_dev)) != ALC_NO_ERROR) {
      ALLEGRO_ERROR("Could not make context current: %s\n",
         alc_get_err_str(alc_err));
      return 1;
   }

   alDistanceModel(AL_NONE);
   if ((openal_err = alGetError()) != AL_NO_ERROR) {
      ALLEGRO_ERROR("Could not set distance model: %s\n",
         openal_get_err_str(openal_err));
      return 1;
   }
#endif

   ALLEGRO_DEBUG("Vendor: %s\n", alGetString(AL_VENDOR));
   ALLEGRO_DEBUG("Version: %s\n", alGetString(AL_VERSION));
   ALLEGRO_DEBUG("Renderer: %s\n", alGetString(AL_RENDERER));
   ALLEGRO_DEBUG("Extensions: %s\n", alGetString(AL_EXTENSIONS));

   return 0;
}
Пример #20
0
void ConfigurarEntorno ( ALsizei identificador, ALenum modelo,
                         ALfloat doppler_factor, ALfloat doppler_vel,
                         ALint room, ALint room_high_frequency,
                         ALfloat rolloff_factor, ALfloat decay_time,
                         ALfloat decay_high_frequency_ratio, ALint reflections,
                         ALfloat reflections_delay, ALint reverb,
                         ALfloat reverb_delay, ALfloat diffusion,
                         ALfloat density, ALfloat high_frequency_reference ){



	/* Configuramos la atenuacion y el efecto doppler */
	alEnable ( AL_DISTANCE_MODEL );
	alDistanceModel ( modelo );
	alDopplerFactor ( doppler_factor );
	alDopplerVelocity ( doppler_vel ); /* Recordad que en metros la velocidad del sonido es 343 */

#ifdef _LINUX
	/* Generamos el entorno y comprobamos errores */
	alGenEnvironmentIASIG ( identificador, &entornos[identificador] );
	if ( !alIsEnvironmentIASIG ( entornos[identificador] )){
		fprintf ( logs, "No se puede configurar parte del entorno\n");
	}

	/* Configuramos las propiedades del entorno */
	alEnvironmentiIASIG ( entornos[identificador], AL_ENV_ROOM_IASIG, room );
	alEnvironmentiIASIG ( entornos[identificador], AL_ENV_ROOM_HIGH_FREQUENCY_IASIG,
	                      room_high_frequency);

	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_ROOM_ROLLOFF_FACTOR_IASIG, rolloff_factor );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_DECAY_TIME_IASIG, decay_time );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_DECAY_HIGH_FREQUENCY_RATIO_IASIG,
	                      decay_high_frequency_ratio );
	alEnvironmentiIASIG ( entornos[identificador], AL_ENV_REFLECTIONS_IASIG, reflections );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_REFLECTIONS_DELAY_IASIG, reflections_delay );
	alEnvironmentiIASIG ( entornos[identificador], AL_ENV_REVERB_IASIG, reverb );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_REVERB_DELAY_IASIG, reverb_delay );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_DIFFUSION_IASIG, diffusion );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_DENSITY_IASIG, density );
	alEnvironmentfIASIG ( entornos[identificador], AL_ENV_HIGH_FREQUENCY_REFERENCE_IASIG,
	                      high_frequency_reference );
#endif
#ifdef _WIN32
	/* Para windows se pueden crear y configurar entornos utilizando las extensiones EAX
	que admiten algunas tarjetas Soundblaster. Pero como no sé si es gratuito la utilizacion
	de dichas extensiones, de momento para windows no se generaran entornos
	*/
#endif
}
Пример #21
0
void Contexte::setDistanceModel(ALenum modele)
{
	alGetError();

	alDistanceModel(modele);

	ALenum error = alCheckError();

	if (error == AL_INVALID_VALUE)
	{
		std::cerr << "The specified distance model is not valid." << std::endl;
	} else if (error == AL_INVALID_OPERATION) {
		std::cerr << "There is no current context." << std::endl;
	}
}
Пример #22
0
static int
_context_setdistancemodel (PyObject* self, PyObject *value, void *closure)
{
    int model;
    
    ASSERT_CONTEXT_IS_CURRENT (self, -1);
    
    if (!IntFromObj (value, &model))
        return -1;
    CLEAR_ALERROR_STATE ();
    alDistanceModel ((ALenum)model);
    if (SetALErrorException (alGetError (), 0))
        return -1;
    return 0;
}
Пример #23
0
	OALAudioEngine::OALAudioEngine()
	{
		ALCdevice* device = alcOpenDevice(nullptr);
		ALCcontext* context = alcCreateContext(device, 0);

		alcMakeContextCurrent(context);

		this->SetListenerPos(float3(0, 0, 0));
		this->SetListenerVel(float3(0, 0, 0));
		this->SetListenerOri(float3(0, 0, 1), float3(0, 1, 0));

		alDistanceModel(AL_INVERSE_DISTANCE);

		alDopplerFactor(1);
		alDopplerVelocity(343); // m/s
	}
Пример #24
0
Engine::Audio::AudioRenderer::AudioRenderer(void)
{
	_device = alcOpenDevice(NULL);
	if (!_device)
	{
		throw std::exception("Error init OpenAL device");
	}

	_context = alcCreateContext(_device, NULL);
	if (!alcMakeContextCurrent(_context))
	{
		throw std::exception("Error init OpenAL context");
	}

	alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
}
Пример #25
0
	void init()
	{
		s_al_device = alcOpenDevice(NULL);
		CE_ASSERT(s_al_device, "Cannot open OpenAL audio device");

		s_al_context = alcCreateContext(s_al_device, NULL);
		CE_ASSERT(s_al_context, "Cannot create OpenAL context");

		AL_CHECK(alcMakeContextCurrent(s_al_context));

		CE_LOGD("OpenAL Vendor   : %s", alGetString(AL_VENDOR));
		CE_LOGD("OpenAL Version  : %s", alGetString(AL_VERSION));
		CE_LOGD("OpenAL Renderer : %s", alGetString(AL_RENDERER));

		AL_CHECK(alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED));
		AL_CHECK(alDopplerFactor(1.0f));
		AL_CHECK(alDopplerVelocity(343.0f));
	}
Пример #26
0
static int Initialize(void *hnd)
{
  ALCdevice *dev;
  ALCcontext *ctxt;
  ALCint attrs[3];
  // TODO: Check for failures (generally, not just in this file).
  dev = alcOpenDevice(NULL);
  attrs[0] = ALC_FREQUENCY;
  attrs[1] = RLX.Audio.SR_to_Khz[RLX.Audio.SamplingRate];
  attrs[2] = 0;
  ctxt = alcCreateContext(dev, (ALCint *)&attrs);
  alcMakeContextCurrent(ctxt);
  alDistanceModel(AL_INVERSE_DISTANCE);
  alDopplerFactor(0.f); // No doppler
  alDopplerVelocity(0.f); // No velocity

  RLX.Audio.Config|=RLXAUDIO_Use3D;
  return 0;
}
Пример #27
0
COpenALSound::COpenALSound()
{
	Sources = NULL;

	maxSounds = configHandler.GetInt("MaxSounds", 16);
	if (maxSounds <= 0) {
		throw content_error("Internal error, (maxSounds <= 0) in COpenALSound");
	}

	globalVolume = 1.0f;

	cur = 0;

	ALCdevice *device = alcOpenDevice(NULL);
	if (device == NULL) {
		throw content_error("Could not create OpenAL audio device");
	} else {
		ALCcontext *context = alcCreateContext(device, NULL);
		if (context != NULL) {
			alcMakeContextCurrent(context);
		} else {
			alcCloseDevice(device);
			throw content_error("Could not create OpenAL audio context");
		}
	}

	logOutput.Print("OpenAL: %s\n", (const char*)alGetString(AL_VERSION));
	logOutput.Print("OpenAL: %s",   (const char*)alGetString(AL_EXTENSIONS));

	// Generate sound sources
	Sources = SAFE_NEW ALuint[maxSounds];
	for (int a=0;a<maxSounds;a++) {
		Sources[a]=0;
	}

	// Set distance model (sound attenuation)
	alDistanceModel (AL_INVERSE_DISTANCE);

	posScale.x = 0.02f;
	posScale.y = 0.0005f;
	posScale.z = 0.02f;
}
Пример #28
0
void SetupAndPlayAudio() {
  g_MyState.source_pos[0] = 1.0f;
  g_MyState.source_pos[1] = 1.0f;
  g_MyState.source_pos[2] = 1.0f;

  g_MyState.source_vel[0] = 0.0f;
  g_MyState.source_vel[1] = 0.0f;
  g_MyState.source_vel[2] = 0.0f;

  g_MyState.listener_pos[0] = 0.0f;
  g_MyState.listener_pos[1] = 0.0f;
  g_MyState.listener_pos[2] = 0.0f;

  g_MyState.listener_vel[0] = 0.0f;
  g_MyState.listener_vel[1] = 0.0f;
  g_MyState.listener_vel[2] = 0.0f;

  g_MyState.pitch = 1.0f;
  g_MyState.gain = 1.0f;

  alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
  assert(alGetError() == AL_NO_ERROR);
  alSourcei(g_MyState.source, AL_LOOPING, AL_TRUE);
  assert(alGetError() == AL_NO_ERROR);
  alSourcefv(g_MyState.source, AL_POSITION, g_MyState.source_pos);
  assert(alGetError() == AL_NO_ERROR);
  alSourcef(g_MyState.source, AL_REFERENCE_DISTANCE, 1.0f);
  assert(alGetError() == AL_NO_ERROR);
  alSourcef(g_MyState.source, AL_MAX_DISTANCE, 70.0f);
  assert(alGetError() == AL_NO_ERROR);
  alSourcef(g_MyState.source, AL_GAIN, 1.0f);
  assert(alGetError() == AL_NO_ERROR);
  alSourcei(g_MyState.source, AL_BUFFER, g_MyState.buffer);
  assert(alGetError() == AL_NO_ERROR);
  alSourcef(g_MyState.source, AL_PITCH, g_MyState.pitch);
  assert(alGetError() == AL_NO_ERROR);
  alSourcef(g_MyState.source, AL_GAIN, g_MyState.gain);
  assert(alGetError() == AL_NO_ERROR);
  alSourcePlay(g_MyState.source);
  assert(alGetError() == AL_NO_ERROR);
}
Пример #29
0
void sound_init() {

    ALCdevice* pDevice;
    ALCcontext* pContext;

    // Get handle to device.
    pDevice = alcOpenDevice(NULL);

    // Create audio context.
    pContext = alcCreateContext(pDevice, NULL);

    // Set active context.
    alcMakeContextCurrent(pContext);

    // Check for an error.
    if (alcGetError(pDevice) != ALC_NO_ERROR)
        fprintf(stderr, "Warning: cannot initialize sound environment.");

    alDistanceModel(AL_LINEAR_DISTANCE);

}
Пример #30
0
void Init(int frequency, int resolution, int sources)
{
	(void)resolution;
	--sources; // one spare source for music
	ALCint attribs[] = {
		ALC_FREQUENCY, frequency,
		/*ALC_MONO_SOURCES, sources,
		ALC_STEREO_SOURCES, 1,*/
		0
	};
	alureInitDevice(NULL, attribs);
	soundSources = new ALuint[sources];
	alGenSources(sources, soundSources);
	alGenSources(1, &musicSource);
	//alGenBuffers(2, musicBufs);
	soundSourceCount = sources;
	alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED);
	alSpeedOfSound(1400.0);
	alDopplerFactor(0.7);
	alureUpdateInterval(0.03333f);
}