audio/src/audio.cpp

#include "audio.h"

extern HWND HScol;
extern int AUDIO_END_CB;

SAudioManager::SAudioManager()
{
  // create cAudio manager
  manager = cAudio::createAudioManager(true);
}

SAudioManager::~SAudioManager()
{
  // destroy cAudio manager
  if (manager != 0)
  {
    validSounds.clear();
    manager->releaseAllSources();
    manager->shutDown();
    cAudio::destroyAudioManager(manager);
    manager = 0; 
  }
}

SAudioManager* SAudioManager::GetInstance()
{
  if (NULL == _singleton)
  {
    _singleton =  new SAudioManager;
  }

  return _singleton;
}

void SAudioManager::Kill()
{
  SAFE_DELETE(_singleton);
}

cAudio::IAudioManager* SAudioManager::GetManager()
{
  return manager;
}

void SAudioManager::SetListenerPosition(cAudio::cVector3 pos, cAudio::cVector3 dir)
{
  if (manager != 0)
  {
    cAudio::IListener* listener = manager->getListener();
    listener->setPosition(pos);
    listener->setDirection(dir);
  }
}

void SAudioManager::AddValidSound(SAudioSound* sound)
{
  validSounds.insert(sound);
}

void SAudioManager::RemoveValidSound(SAudioSound* sound)
{
  if (validSounds.find(sound) != validSounds.end())
    validSounds.erase(sound);
}

bool SAudioManager::GetValidSound(SAudioSound* sound)
{
  if (validSounds.find(sound) != validSounds.end())
    return true;
  else
    return false;
}

void SAudioManager::RemoveSound(SAudioSound* sound)
{
  if ((manager != 0) && (GetValidSound(sound)))
  {
    RemoveValidSound(sound);
    SAFE_DELETE(sound);
  }
}

SAudioSound* SAudioManager::AddSound(std::string name, std::string path, bool stream)
{
  if (manager != 0)
  {
    SAudioSound* sound = new SAudioSound(name, path, stream);
    AddValidSound(sound);
    return sound;
  }
  else
    return 0;
}


// Initialize singleton
SAudioManager* SAudioManager::_singleton = NULL;


SAudioSound::SAudioSound(std::string name, std::string path, bool stream)
{
  mName = name;
  mSound = SAudioManager::GetInstance()->GetManager()->create(name.c_str(), path.c_str(), stream);
  if (mSound)
    mSound->registerEventHandler(this);
}

SAudioSound::~SAudioSound()
{
  if (mSound)
  {
    mSound->unRegisterEventHandler(this);
    SAudioManager::GetInstance()->GetManager()->release(mSound);
    mSound = 0;
  }
}

bool SAudioSound::IsValid()
{
  if (mSound)
    return true;
  else
    return false;
}

std::string SAudioSound::GetName()
{
  return mName;
}

bool SAudioSound::Play(bool loop)
{
  if (mSound)
    return mSound->play2d(loop);
  else
    return false;
}

bool SAudioSound::Play3d(float attenuation, bool loop)
{
  if (mSound)
    return mSound->play3d(mSound->getPosition(), attenuation, loop);
  else
    return false;
}

void SAudioSound::Stop()
{
  if (mSound)
    mSound->stop();
}

void SAudioSound::Pause()
{
  if (mSound)
    mSound->pause();
}

void SAudioSound::SetVolume(float volume)
{
  if (mSound)
    mSound->setVolume(volume);
}

float SAudioSound::GetVolume()
{
  if (mSound)
    return mSound->getVolume();
  else
    return 0.0f;
}

bool SAudioSound::IsPlaying()
{
  if (mSound)
    return mSound->isPlaying();
  else
    return false;
}

float SAudioSound::GetTime()
{
  if (mSound)
    return mSound->getCurrentAudioTime();
  else
    return 0.0f;
}

float SAudioSound::GetTotalTime()
{
  if (mSound)
    return mSound->getTotalAudioTime();
  else
    return 0.0f;
}

void SAudioSound::SetPitch(float pitch)
{
  if (mSound)
    mSound->setPitch(pitch);
}

float SAudioSound::GetPitch()
{
  if (mSound)
    return mSound->getPitch();
  else
    return 0.0f;
}

void SAudioSound::Seek(float pos, bool relative)
{
  if (mSound)
    mSound->seek(pos, relative);
}

// 3D
void SAudioSound::SetPositionAndDirection(cAudio::cVector3 pos, cAudio::cVector3 dir)
{
  if (mSound)
  {
    mSound->setPosition(pos);
    mSound->setDirection(dir);
  }
}

cAudio::cVector3 SAudioSound::GetPosition()
{
  if (mSound)
    return mSound->getPosition();
  else
    return cAudio::cVector3(0.0f, 0.0f, 0.0f);
}

cAudio::cVector3 SAudioSound::GetDirection()
{
  if (mSound)
    return mSound->getDirection();
  else
    return cAudio::cVector3(0.0f, 0.0f, 0.0f);
}

void SAudioSound::SetCone(float inner, float outer, float outvol)
{
  if (mSound)
  {
    mSound->setInnerConeAngle(inner);
    mSound->setOuterConeAngle(outer);
    mSound->setOuterConeVolume(outvol);
  }
}

float SAudioSound::GetInnerCone()
{
  if (mSound)
    return mSound->getInnerConeAngle();
  else
    return 0.0f;
}

float SAudioSound::GetOuterCone()
{
  if (mSound)
    return mSound->getOuterConeAngle();
  else
    return 0.0f;
}

float SAudioSound::GetOuterConeVolume()
{
  if (mSound)
    return mSound->getOuterConeVolume();
  else
    return 0.0f;
}

void SAudioSound::SetRolloffFactor(float rolloff)
{
  if (mSound)
    mSound->setRolloffFactor(rolloff);
}

float SAudioSound::GetRolloffFactor()
{
  if (mSound)
    return mSound->getRolloffFactor();
  else
    return 0.0f;
}

// EVENTS
void SAudioSound::onUpdate()
{
}

void SAudioSound::onRelease()
{
}

void SAudioSound::onPlay()
{
}

void SAudioSound::onStop()
{
  PostMessage(HScol, AUDIO_END_CB, (int)this, (LPARAM)0);
}

void SAudioSound::onPause()
{
}