components/sound/SoundListenerComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SoundListenerComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper of SFML's sf::Listener.
//
// 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 "SoundListenerComponent.h"
#include "../../core/GameManager.h"


// SoundListenerComponent class
// Static variables.
SoundListenerComponent* SoundListenerComponent::mMainListener = 0;

// SoundListener constructor.
SoundListenerComponent::SoundListenerComponent(Entity *parent, bool isMainListener)
: EntityComponent(parent), mPosition(vector3df(0, 0, 0)), mTarget(vector3df(0, 0, 0))
{
    // Get a pointer to sub-systems of the Game Manager.
    EventManager *pEventMgr = GameManager::Instance()->getEventManager();

    // Is this the new main listener?
    if(isMainListener)
    {
        if(mMainListener)
          mMainListener->setIsMainListener(false);

        setIsMainListener(true);
    }

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

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

// SoundListenerComponent deconstructor.
SoundListenerComponent::~SoundListenerComponent()
{
    setIsMainListener(false);
}

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

// Checks if this listener is the main listener.
bool SoundListenerComponent::getIsMainListener() const
{
    return mIsMainListener;
}

// Gets the target direction of this listener.
const vector3df& SoundListenerComponent::getTarget() const
{
    return mTarget;
}

// Sets whether this listener is the main listener.
void SoundListenerComponent::setIsMainListener(bool value)
{
    if(value)
    {
        mMainListener = this;
        mIsMainListener = true;

        sf::Listener::SetPosition(mPosition.X, mPosition.Y, mPosition.Z);
        sf::Listener::SetTarget(mTarget.X, mTarget.Y, mTarget.Z);
    }

    else
    {
        if(mIsMainListener)
          mMainListener = 0;

        mIsMainListener = false;
    }
}

// Sets the target direction of this listener.
void SoundListenerComponent::setTarget(const vector3df &target)
{
    mTarget = target;
    if(mIsMainListener)
      sf::Listener::SetTarget(mTarget.X, mTarget.Y, mTarget.Z);
}

// Events
// Updates the position of the component after its parent has been updated.
void SoundListenerComponent::onPositionChange(void *p)
{
    mPosition += static_cast<vector3df*>(p)[0];
    if(mIsMainListener)
      sf::Listener::SetPosition(mPosition.X, mPosition.Y, mPosition.Z);
}

// Pauses the component if the parent is paused.
void SoundListenerComponent::onPause(void *p)
{
    mWasMainListener = getIsMainListener();
    setIsMainListener(false);
}

// Unpauses the component if the parent is unpaused.
void SoundListenerComponent::onUnPause(void *p)
{
    if(mWasMainListener)
      setIsMainListener(true);
}


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

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

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

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

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

    // Bind SoundListenerComponent class functions.
    r = engine->RegisterObjectMethod("SoundListenerComponent", "bool getIsMainListener()",
                                     asMETHOD(SoundListenerComponent, getIsMainListener), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundListenerComponent", "const vector3df& getTarget()",
                                     asMETHOD(SoundListenerComponent, getTarget), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("SoundListenerComponent", "void setIsMainListener()",
                                     asMETHOD(SoundListenerComponent, setIsMainListener), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundListenerComponent", "void setIsMainListener(bool)",
                                     asMETHOD(SoundListenerComponent, setIsMainListener), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("SoundListenerComponent", "void setTarget(const vector3df &in)",
                                     asMETHOD(SoundListenerComponent, setTarget), asCALL_THISCALL); assert(r >= 0);
}

// End of File

---