components/sound/SoundSourceComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SoundSourceComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper of SFML's sf::Sound and sf::Music.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "SoundSourceComponent.h"
#include "../../core/GameManager.h"


// SoundSourceComponent class
// SoundSource constructor.
SoundSourceComponent::SoundSourceComponent(Entity *parent)
: EntityComponent(parent), mSound(NULL), mMusic(NULL), mBuffer(NULL), mAttenuation(1.0f),
  mLoop(false), mMinDistance(1.0f), mPitch(1.0f), mPosition(vector3df(0, 0, 0)), mVolume(100)
{
    // Get a pointer to sub-systems of the Game Manager.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();

    // Set misc. variables.
    mName = "SoundSourceComponent";

    // Register events.
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onPositionChange",
                                  this, &SoundSourceComponent::onPositionChange);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onPause",
                                  this, &SoundSourceComponent::onPause);
    pEventMgr->connectEventSignal(std::string("ent#") + parent->getName(), "onUnPause",
                                  this, &SoundSourceComponent::onUnPause);
}

// SoundSourceComponent deconstructor.
SoundSourceComponent::~SoundSourceComponent()
{
    if(mSound != NULL)
      delete mSound;

    if(mMusic != NULL)
      delete mMusic;

    if(mBuffer != NULL)
      delete[] mBuffer;
}

// AngelScript: Will be used to instanciate objects of this class.
SoundSourceComponent* SoundSourceComponent::refFactory(Entity *parent)
{
    return new SoundSourceComponent(parent);
}

// Returns a direct pointer to the sf::Sound object in this component.
sf::Sound* SoundSourceComponent::getSound()
{
    return mSound;
}

// Returns a direct pointer to the sf::Music object in this component.
sf::Music* SoundSourceComponent::getMusic()
{
    return mMusic;
}

// Loads the sound data as a music (streaming) object.
bool SoundSourceComponent::loadMusic(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Delete the previous data.
    unloadData();

    // Does the file exist?
    if(!fileSystem->existFile(fileName.c_str()))
      return false;

    // Open the given file and load the contents to the buffer.
    IReadFile *file = fileSystem->createAndOpenFile(fileName.c_str());

    mBufferSize = file->getSize();
    mBuffer = new c8[mBufferSize+1];
    file->read(mBuffer, mBufferSize);
    file->drop();

    // Create SFML's music object.
    mMusic = new sf::Music();
    mMusic->OpenFromMemory(mBuffer, mBufferSize);

    // Initialize variables.
    mMusic->SetAttenuation(mAttenuation);
    mMusic->SetLoop(mLoop);
    mMusic->SetMinDistance(mMinDistance);
    mMusic->SetPitch(mPitch);
    mMusic->SetPosition(mPosition.X, mPosition.Y, mPosition.Z);
    mMusic->SetVolume(mVolume);

    return true;
}

// Loads the sound data from a sound buffer.
bool SoundSourceComponent::loadSoundBuffer(const std::string &bufferName)
{
    // Delete the previous data.
    unloadData();

    // Set new data.
    mSound = new sf::Sound();

    sf::SoundBuffer *soundBuffer = GameManager::Instance()->getSoundManager()->getSoundBuffer(bufferName);
    if(soundBuffer == NULL)
    {
       delete mSound;
       mSound = NULL;
       return false;
    }

    mSound->SetBuffer(*soundBuffer);
    std::cout << mSound->GetBuffer()->GetDuration() << "\n";

    mSound->SetAttenuation(mAttenuation);
    mSound->SetLoop(mLoop);
    mSound->SetMinDistance(mMinDistance);
    mSound->SetPitch(mPitch);
    mSound->SetPosition(mPosition.X, mPosition.Y, mPosition.Z);
    mSound->SetVolume(mVolume);

    return true;
}

// Unloads previously loaded data.
void SoundSourceComponent::unloadData()
{
    if(mSound != NULL)
    {
       delete mSound;
       mSound = NULL;
    }

    if(mMusic != NULL)
    {
       delete mMusic;
       mMusic = NULL;
    }

    if(mBuffer != NULL)
    {
        delete[] mBuffer;
        mBuffer = NULL;
        mBufferSize = 0;
    }
}

// Plays the associated sound.
void SoundSourceComponent::play()
{
    if(mSound != NULL)
      mSound->Play();

    else if(mMusic != NULL)
      mMusic->Play();
}

// Pauses the associated sound.
void SoundSourceComponent::pause()
{
    if(mSound != NULL)
      mSound->Pause();

    else if(mMusic != NULL)
      mMusic->Pause();
}

// Stops the associated sound.
void SoundSourceComponent::stop()
{
    if(mSound != NULL)
      mSound->Stop();

    else if(mMusic != NULL)
      mMusic->Stop();
}

// Gets the attenuation of the sound.
f32 SoundSourceComponent::getAttenuation() const
{
    return mAttenuation;
}

// Returns whether the sound is paused.
bool SoundSourceComponent::getIsPaused() const
{
    if(mSound != NULL)
    {
       if(mSound->GetStatus() == sf::Sound::Paused)
         return true;
    }

    else if(mMusic != NULL)
    {
        if(mMusic->GetStatus() == sf::Sound::Paused)
          return true;
    }

    return false;
}

// Returns whether the sound is playing.
bool SoundSourceComponent::getIsPlaying() const
{
    if(mSound != NULL)
    {
       if(mSound->GetStatus() == sf::Sound::Playing)
         return true;
    }

    else if(mMusic != NULL)
    {
        if(mMusic->GetStatus() == sf::Sound::Playing)
          return true;
    }

    return false;
}

// Returns whether the sound has been stopped.
bool SoundSourceComponent::getIsStopped() const
{
    if(mSound != NULL)
    {
        if(mSound->GetStatus() == sf::Sound::Stopped)
          return true;
    }

    else if(mMusic != NULL)
    {
        if(mMusic->GetStatus() == sf::Sound::Stopped)
          return true;
    }

    return false;
}

// Gets the loop state of the sound.
bool SoundSourceComponent::getLoop() const
{
    return mLoop;
}

// Gets the minimum distance.
f32 SoundSourceComponent::getMinDistance() const
{
    return mMinDistance;
}

// Gets the current playing position of the sound.
// NOTE: Only works for sound!
f32 SoundSourceComponent::getOffset() const
{
    if(mSound != NULL)
      return mSound->GetPlayingOffset();

    return 0.0f;
}

// Gets the pitch of the sound.
f32 SoundSourceComponent::getPitch() const
{
    return mPitch;
}

// Gets the volume of the sound.
f32 SoundSourceComponent::getVolume() const
{
    return mVolume;
}

// Sets the attenuation factor - the higher the attenuation, the more the sound
// will be attenuated with distance from listener.
void SoundSourceComponent::setAttenuation(f32 attenuation)
{
    if(mSound != NULL)
      mSound->SetAttenuation(attenuation);

    else if(mMusic != NULL)
      mMusic->SetAttenuation(attenuation);

    mAttenuation = attenuation;
}

// Sets the sound loop state.
void SoundSourceComponent::setLoop(bool value)
{
    if(mSound != NULL)
      mSound->SetLoop(value);

    else if(mMusic != NULL)
      mMusic->SetLoop(value);

    mLoop = value;
}

// Sets the minimum distance - closer than this distance, the listener will hear
// the sound at its maximum volume.
void SoundSourceComponent::setMinDistance(f32 minDistance)
{
    if(mSound != NULL)
      mSound->SetMinDistance(minDistance);

    else if(mMusic != NULL)
      mMusic->SetMinDistance(minDistance);

    mMinDistance = minDistance;
}

// Sets the current playing position of the sound.
// NOTE: Only works for sound!
void SoundSourceComponent::setOffset(f32 offset)
{
    if(mSound != NULL)
      mSound->SetPlayingOffset(offset);
}

// Sets the sound pitch.
void SoundSourceComponent::setPitch(f32 pitch)
{
    if(mSound != NULL)
      mSound->SetPitch(pitch);

    else if(mMusic != NULL)
      mMusic->SetPitch(pitch);

    mPitch = pitch;
}

// Sets the sound volume.
void SoundSourceComponent::setVolume(f32 volume)
{
    if(mSound != NULL)
      mSound->SetVolume(volume);

    else if(mMusic != NULL)
      mMusic->SetVolume(volume);

    mVolume = volume;
}

// Events
// Updates the position of the component after its parent has been updated.
void SoundSourceComponent::onPositionChange(void *p)
{
    mPosition += static_cast<vector3df*>(p)[0];

    if(mSound != NULL)
      mSound->SetPosition(mPosition.X, mPosition.Y, mPosition.Z);

    else if(mMusic != NULL)
      mMusic->SetPosition(mPosition.X, mPosition.Y, mPosition.Z);
}

// Pauses the component if the parent is paused.
void SoundSourceComponent::onPause(void *p)
{
    mWasPaused = getIsPaused();
    pause();
}

// Unpauses the component if the parent is unpaused.
void SoundSourceComponent::onUnPause(void *p)
{
    if(!mWasPaused)
      play();
}


// SoundSourceComponent Angelscript binding.
void bindSoundSourceComponent(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind SoundSourceComponent class.
    r = engine->RegisterObjectType("SoundSourceComponent", sizeof(SoundSourceComponent), asOBJ_REF); assert(r >= 0);

    // Bind inherited functions.
    bindEntityComponentBase<SoundSourceComponent>(engine, "SoundSourceComponent");

    // Set SoundSourceComponent behaviour.
    r = engine->RegisterGlobalBehaviour(asBEHAVE_REF_CAST, "SoundSourceComponent@ f(EntityComponent @)",
                                        asFUNCTION((asRefCast<EntityComponent,SoundSourceComponent>)), asCALL_CDECL); assert( r >= 0 );
    r = engine->RegisterGlobalBehaviour(asBEHAVE_IMPLICIT_REF_CAST, "EntityComponent@ f(SoundSourceComponent @)",
                                        asFUNCTION((asRefCast<SoundSourceComponent,EntityComponent>)), asCALL_CDECL); assert( r >= 0 );

    r = engine->RegisterObjectBehaviour("SoundSourceComponent", asBEHAVE_FACTORY, "SoundSourceComponent@ f(Entity @)",
                                        asFUNCTION(SoundSourceComponent::refFactory), asCALL_CDECL); assert(r >= 0);

    // Bind SoundSourceComponent class functions.
    r = engine->RegisterObjectMethod("SoundSourceComponent", "bool loadMusic(const string &)",
                                     asMETHOD(SoundSourceComponent, loadMusic), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "bool loadSoundBuffer(const string &)",
                                     asMETHOD(SoundSourceComponent, loadSoundBuffer), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("SoundSourceComponent", "void play()",
                                     asMETHOD(SoundSourceComponent, play), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void pause()",
                                     asMETHOD(SoundSourceComponent, play), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void stop()",
                                     asMETHOD(SoundSourceComponent, play), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("SoundSourceComponent", "f32 getAttenuation()",
                                     asMETHOD(SoundSourceComponent, getAttenuation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "bool getIsPlaying()",
                                     asMETHOD(SoundSourceComponent, getIsPlaying), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "bool getIsPaused()",
                                     asMETHOD(SoundSourceComponent, getIsPaused), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "bool getIsStopped()",
                                     asMETHOD(SoundSourceComponent, getIsStopped), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "f32 getMinDistance()",
                                     asMETHOD(SoundSourceComponent, getMinDistance), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "f32 getOffset()",
                                     asMETHOD(SoundSourceComponent, getOffset), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "f32 getPitch()",
                                     asMETHOD(SoundSourceComponent, getPitch), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "f32 getVolume()",
                                     asMETHOD(SoundSourceComponent, getVolume), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setAttenuation(f32)",
                                     asMETHOD(SoundSourceComponent, setAttenuation), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setLoop(bool)",
                                     asMETHOD(SoundSourceComponent, setLoop), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setMinDistance(f32)",
                                     asMETHOD(SoundSourceComponent, setMinDistance), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setOffset(f32)",
                                     asMETHOD(SoundSourceComponent, setOffset), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setPitch(f32)",
                                     asMETHOD(SoundSourceComponent, setPitch), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundSourceComponent", "void setVolume(f32)",
                                     asMETHOD(SoundSourceComponent, setVolume), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---