Track.hpp

Go to the documentation of this file.

#pragma once
#include "Profiling/Trackable.hpp"
#include "Mixer.hpp"
#include "Sound.hpp"
 
struct MIX_Track;
 
namespace Cori {
    namespace Audio {
        using TrackStopCallbackFn = std::function<void()>;
        using SoundWithParams = std::pair<std::shared_ptr<Sound>, PlayParams>;
 
        template<typename T>
        concept IsSoundWithParams = std::is_same_v<T, SoundWithParams>;

        class Track : public Profiling::Trackable<Track> {
        public:
            std::expected<void, Core::CoriError<>> SetSound(const std::shared_ptr<Sound>& sound);
 

            std::expected<void, Core::CoriError<>> Start(const PlayParams& params = PlayParams{});
 

            std::expected<void, Core::CoriError<>> Play(const IsSoundWithParams auto&... sequence) {
                if (m_Valid) {
                    if (!m_ActiveSequence) {
                        m_SoundSequence.clear();
                        m_SoundSequence.reserve(sizeof...(sequence));
                        (..., m_SoundSequence.push_back(sequence));
                        m_EraseLastInSequence = false;
                        m_SequenceIntroFinished = false;
 
                        m_CurrentLoopedSequenceIndex = 0;
                        auto& initialPart = m_SoundSequence.back();
 
                        const auto success = PlaySoundWithParams(initialPart);
                        if (!success) {
                            CORI_CORE_ERROR_TAGGED({ Logger::Tags::Audio::Self, Logger::Tags::Audio::Track }, "An error occurred when trying to play a part of sequence. Details: {}", success.error().what());
                        }
 
                        m_ActiveSequence = true;
                        if constexpr (sizeof...(sequence) > 2) {
                            if (!initialPart.second.LoopedInSequence) {
                                m_EraseLastInSequence = true;
                            }
                            else {
                                m_SequenceIntroFinished = true;
                                m_CurrentLoopedSequenceIndex = m_SoundSequence.size() - 2;
                            }
 
                            SetTrackStopCallbackInternal([this] {
                                if (m_EraseLastInSequence) {
                                    m_SoundSequence.pop_back();
                                    m_EraseLastInSequence = false;
                                }
                                if (!m_SoundSequence.empty()) {
                                    SoundWithParams* part;
 
                                    if (m_SequenceIntroFinished) {
                                        part = &m_SoundSequence.at(m_CurrentLoopedSequenceIndex);
                                    }
                                    else {
                                        part = &m_SoundSequence.back();
                                    }
 
                                    m_ActiveSequence = false;
                                    const auto success_ = PlaySoundWithParams(*part);
                                    if (!success_) {
                                        CORI_CORE_ERROR_TAGGED({ Logger::Tags::Audio::Self, Logger::Tags::Audio::Track }, "An error occurred when trying to play a part of sequence. Details: {}", success_.error().what());
                                    }
                                    m_ActiveSequence = true;
 
                                    if (!part->second.LoopedInSequence && !m_SequenceIntroFinished) {
                                        m_EraseLastInSequence = true;
                                    }
                                    else {
                                        if (m_SequenceIntroFinished) {
                                            if (m_CurrentLoopedSequenceIndex == 0) {
                                                m_CurrentLoopedSequenceIndex = m_SoundSequence.size() - 1;
                                            }
                                            else {
                                                --m_CurrentLoopedSequenceIndex;
                                            }
                                        }
                                        else {
                                            m_SequenceIntroFinished = true;
                                            if (m_CurrentLoopedSequenceIndex == 0) {
                                                m_CurrentLoopedSequenceIndex = m_SoundSequence.size() - 2;
                                            }
                                            else {
                                                --m_CurrentLoopedSequenceIndex;
                                            }
                                        }
                                    }
                                }
                                else {
                                    const auto success_ = Stop(false);
                                    if (!success_) {
                                        CORI_CORE_ERROR_TAGGED({ Logger::Tags::Audio::Self, Logger::Tags::Audio::Track }, "An error occurred when trying to stop a sequence inside of Engine side Callback. Details: {}", success_.error().what());
                                    }
                                }
                            });
                            return {};
                        }
                        else {
                            if (initialPart.second.LoopedInSequence) {
                                SetTrackStopCallbackInternal([this] {
                                    SoundWithParams* part = &m_SoundSequence.at(0);
                                    m_ActiveSequence = false;
                                    const auto success_ = PlaySoundWithParams(*part);
                                    if (!success_) {
                                        CORI_CORE_ERROR_TAGGED({ Logger::Tags::Audio::Self, Logger::Tags::Audio::Track }, "An error occurred when trying to play a part of sequence. Details: {}", success_.error().what());
                                    }
                                    m_ActiveSequence = true;
                                });
                                return {};
                            }
 
                            m_ActiveSequence = false;
                            return {};
                        }
                    }
 
                    return std::unexpected(Core::CoriError(std::format("Failed to play sequence on Track '{} (TrackID: {})'. A sequence is already playing on this track.", m_Name, m_ID)));
                }
 
                return std::unexpected(Core::CoriError(std::format("Failed to play sequence on Track '{} (TrackID: {})'. Track object is invalid.", m_Name, m_ID)));
            }

            std::expected<void, Core::CoriError<>> Stop(const bool abruptStop, const int64_t fadeOutMS = 0);
 

            std::expected<void, Core::CoriError<>> Pause();
 

            std::expected<void, Core::CoriError<>> Resume();

            [[nodiscard]] bool IsPaused() const;
 

            [[nodiscard]] bool IsPlaying() const;

            std::expected<void, Core::CoriError<>> SetGain(const float gain);
 

            [[nodiscard]] float GetGain() const;

            std::expected<void, Core::CoriError<>> SetTag(const char* tag);

            void RemoveTag(const char* tag, const bool preserveCachedTag = false);

            [[nodiscard]] std::string_view GetTag() const;

            [[nodiscard]] bool IsValid() const;

            [[nodiscard]] TrackID GetID() const;

            void SetTrackStopCallback(TrackStopCallbackFn callback);

            [[nodiscard]] static std::shared_ptr<Track> Create(std::string name);
 
            ~Track();
 
            const std::string m_Name;

            static void TrackStopCallback(void* userdata, MIX_Track* track);
 
        private:
            explicit Track(std::string name);
 
            std::expected<void, Core::CoriError<>> PlaySoundWithParams(SoundWithParams& object);
 
            std::expected<void, Core::CoriError<>> StopInternal(const int64_t fadeOutMS) const;
 
            TrackStopCallbackFn m_EngineCallBack;
            TrackStopCallbackFn m_ClientCallBack;
 
            std::expected<void, Core::CoriError<>> ProcessSequencePart(const SoundWithParams& part);
 
            void SetTrackStopCallbackInternal(TrackStopCallbackFn callback);
 
            const TrackID m_ID{ 0 };
            bool m_Valid{ false };
            bool m_ActiveSequence{ false };
            bool m_EraseLastInSequence{ false };
            bool m_SequenceIntroFinished{ false };
            uint32_t m_CurrentLoopedSequenceIndex{ 0 };
            std::string m_CurrentTag{};
            std::vector<SoundWithParams> m_SoundSequence;
            inline static std::atomic<TrackID> s_NextIndex{ 1 };
        };
    }
}