sequenceplayerclock.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// external includes
#include <future>
#include <nap/resource.h>
#include <nap/signalslot.h>
#include <nap/timer.h>
#include <rtti/rtti.h>
#include <rtti/factory.h>
 
namespace nap
{
 
    // forward declares
    class SequenceService;
 
    class NAPAPI SequencePlayerClock : public Resource
    {
    RTTI_ENABLE(Resource)
    public:
        // default constructor and deconstructor
        SequencePlayerClock() = default;
        ~SequencePlayerClock() = default;
 
        // make this class explicitly non-copyable
        SequencePlayerClock(const SequencePlayerClock&) = delete;
        SequencePlayerClock& operator=(const SequencePlayerClock&) = delete;
 
        virtual void start(Slot<double>& updateSlot) = 0;
 
        virtual void stop() = 0;
 
    protected:
        // the slot
        Slot<double> mSlot;
    };
 
    class NAPAPI SequencePlayerStandardClock : public SequencePlayerClock
    {
        friend class SequenceService;
 
    RTTI_ENABLE(SequencePlayerClock)
    public:
        SequencePlayerStandardClock(SequenceService& service);
 
        // make this class explicitly non-copyable
        SequencePlayerStandardClock(const SequencePlayerStandardClock&) = delete;
        SequencePlayerStandardClock& operator=(const SequencePlayerStandardClock&) = delete;
 
        void start(Slot<double>& updateSlot) override;
 
        void stop() override;
 
    private:
        void update(double deltaTime);
 
        // reference to service
        SequenceService& mService;
    };
 
    // factory method shortcut
    using SequencePlayerStandClockObjectCreator = rtti::ObjectCreator<SequencePlayerStandardClock, SequenceService>;
 
    class NAPAPI SequencePlayerIndependentClock : public SequencePlayerClock
    {
    RTTI_ENABLE(SequencePlayerClock)
    public:
        SequencePlayerIndependentClock() = default;
 
        ~SequencePlayerIndependentClock() = default;
 
        // make this class explicitly non-copyable
        SequencePlayerIndependentClock(const SequencePlayerIndependentClock&) = delete;
        SequencePlayerIndependentClock& operator=(const SequencePlayerIndependentClock&) = delete;
 
        bool init(utility::ErrorState& errorState) override;
 
        void start(Slot<double>& updateSlot) override;
 
        void stop() override;
 
        // properties
        float mFrequency = 1000.0f; 
    private:
        void onUpdate();
 
        // the task
        std::future<void> mUpdateTask;
 
        // bool indicating if thread is running
        std::atomic_bool mRunning = {false};
 
        // previous timestamp, used to calculate deltaTime
        SteadyTimeStamp mBefore;
    };
}