soundemitter.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2019 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_SOUNDEMITTER_H_
#define FIFE_SOUNDEMITTER_H_

// Standard C++ library includes

// Platform specific includes

// 3rd party library includes

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "model/metamodel/modelcoords.h"

#include "soundclip.h"

namespace FIFE {

    enum SoundStateType {
        SD_UNKNOWN_STATE,
        SD_INITIAL_STATE,
        SD_PLAYING_STATE,
        SD_PAUSED_STATE,
        SD_STOPPED_STATE
    };

    class SoundEmitterListener {
    public:
        virtual ~SoundEmitterListener() {};
        
        virtual void onSoundFinished(uint32_t emitterId, uint32_t soundClipId) = 0;
    };

    class SoundEffect;
    class SoundFilter;
    class SoundManager;

    class SoundEmitter {
    public:

        SoundEmitter(SoundManager* manager, uint32_t uid);
        ~SoundEmitter();

        void setSource(ALuint source);

        ALuint getSource() const;

        bool isActive() const;

        void update();

        uint32_t getId() const;

        void setRelativePositioning(bool relative);

        bool isRelativePositioning() const;

        void setReferenceDistance(float distance);

        float getReferenceDistance() const;

        void setMaxDistance(float distance);

        float getMaxDistance() const;

        void setRolloff(float rolloff);

        float getRolloff() const;

        void setSoundClip(SoundClipPtr soundClip);

        SoundClipPtr getSoundClip();

        void setSoundClip(const std::string& name);

        void reset(bool defaultall = false);

        void release();

        void setLooping(bool loop);

        bool isLooping() const;

        void play();

        void play(float inTime, float outTime);

        void stop();

        void stop(float time);

        void pause();

        void rewind();

        void setGain(float gain);

        float getGain() const;

        void setMaxGain(float gain);

        float getMaxGain() const;

        void setMinGain(float gain);

        float getMinGain() const;

        bool isStereo();

        int16_t getBitResolution();

        uint64_t getSampleRate();

        uint64_t getDecodedLength();

        uint64_t getDuration();

        uint32_t getPlayTimestamp();

        bool isFinished();

        void setCursor(SoundPositionType type, float value);

        float getCursor(SoundPositionType type);

        void setPosition(const AudioSpaceCoordinate& position);

        AudioSpaceCoordinate getPosition() const;

        bool isPosition() const;

        void setDirection(const AudioSpaceCoordinate& direction);

        AudioSpaceCoordinate getDirection() const;

        void setPitch(float pitch);

        float getPitch() const;

        void setVelocity(const AudioSpaceCoordinate& velocity);

        AudioSpaceCoordinate getVelocity() const;

        void setConeInnerAngle(float inner);

        float getConeInnerAngle() const;

        void setConeOuterAngle(float outer);

        float getConeOuterAngle() const;

        void setConeOuterGain(float gain);

        float getConeOuterGain() const;

        SoundStateType getState();

        void setGroup(const std::string& group);

        const std::string& getGroup();

        void addEffect(SoundEffect* effect);

        void removeEffect(SoundEffect* effect);

        uint8_t getEffectCount();

        uint8_t getEffectNumber(SoundEffect* effect);

        void setDirectFilter(SoundFilter* filter);

        SoundFilter* getDirectFilter();

        void activateEffects();

        void deactivateEffects();

        void setCheckDifference();

        void addListener(SoundEmitterListener* listener);

        void removeListener(SoundEmitterListener* listener);

    private:
        void attachSoundClip();

        void detachSoundClip();

        void syncData();

        void checkFade();

        void resetInternData();

        void callOnSoundFinished();

        SoundManager* m_manager;
        ALuint m_source;
        SoundFilter* m_directFilter;
        SoundClipPtr m_soundClip;
        uint32_t m_soundClipId;
        uint32_t m_streamId;
        uint32_t m_emitterId;

        struct internData {
            float volume;
            float maxVolume;
            float minVolume;
            float refDistance;
            float maxDistance;
            float rolloff;
            float pitch;
            float coneInnerAngle;
            float coneOuterAngle;
            float coneOuterGain;
            AudioSpaceCoordinate position;
            AudioSpaceCoordinate direction;
            AudioSpaceCoordinate velocity;
            uint32_t playTimestamp;
            SoundStateType soundState;
            bool loop;
            bool relative;
        } m_internData;

        std::string m_group;
        float m_samplesOffset;
        bool m_active;
        bool m_fadeIn;
        bool m_fadeOut;
        float m_origGain;
        uint32_t m_fadeInStartTimestamp;
        uint32_t m_fadeInEndTimestamp;
        uint32_t m_fadeOutStartTimestamp;
        uint32_t m_fadeOutEndTimestamp;
        uint32_t m_playCheckDifference;
        std::vector<SoundEffect*> m_effects;
        std::vector<SoundEmitterListener*> m_listeners;
    };
}

#endif