sequenceservice.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
 
// Local Includes
#include "sequenceplayer.h"
 
// External Includes
#include <nap/service.h>
#include <entity.h>
#include <nap/datetime.h>
#include <rtti/factory.h>
 
namespace nap
{
 
    // forward declares
    class SequenceController;
    class SequenceEditor;
    class SequencePlayerAdapter;
    class SequencePlayerStandardClock;
 
    // shortcuts
    using SequenceControllerFactoryFunc = std::function<std::unique_ptr<SequenceController>(SequencePlayer&, SequenceEditor &)>;
    using SequenceControllerFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceControllerFactoryFunc>;
    using DefaultSequenceTrackFactoryMap = std::unordered_map<rtti::TypeInfo, std::function<std::unique_ptr<SequenceTrack>(const SequencePlayerOutput*)>>;
    using SequencePlayerAdapterFactoryFunc = std::function<std::unique_ptr<SequencePlayerAdapter>(const SequenceTrack&,
                                                                                                  SequencePlayerOutput&,
                                                                                                  const SequencePlayer&)>;
    using SequencePlayerAdapterFactoryMap = std::unordered_map<rtti::TypeInfo, SequencePlayerAdapterFactoryFunc>;
 
    class NAPAPI SequenceService final : public Service
    {
        friend class SequencePlayerOutput;
 
    RTTI_ENABLE(Service)
    public:
        SequenceService(ServiceConfiguration *configuration);
 
        ~SequenceService() override;
 
        bool registerDefaultTrackCreatorForOutput(rtti::TypeInfo outputType,
                                                  std::function<std::unique_ptr<SequenceTrack>(const SequencePlayerOutput*)> func);
 
        Sequence *createDefaultSequence(std::vector<std::unique_ptr<rtti::Object>>& createdObjects,
                                        std::unordered_set<std::string>& objectIDs,
                                        const std::vector<ResourcePtr<SequencePlayerOutput>>& outputs);
 
        bool registerControllerTypeForTrackType(rtti::TypeInfo trackType, rtti::TypeInfo controllerType);
 
        rtti::TypeInfo getControllerTypeForTrackType(rtti::TypeInfo trackType);
 
        bool registerControllerFactoryFunc(rtti::TypeInfo controllerType, SequenceControllerFactoryFunc factory);
 
        bool registerAdapterFactoryFunc(rtti::TypeInfo typeInfo, SequencePlayerAdapterFactoryFunc factory);
 
        std::unique_ptr<SequencePlayerAdapter> invokeAdapterFactory(rtti::TypeInfo type, const SequenceTrack& track,
                                                                    SequencePlayerOutput& output,
                                                                    const SequencePlayer& player);
 
        std::unique_ptr<SequenceController> invokeControllerFactory(rtti::TypeInfo controllerType,
                                                                    SequencePlayer& player, SequenceEditor& editor);
 
        std::vector<rtti::TypeInfo> getRegisteredControllerTypes() const;
 
        std::string generateUniqueID(std::unordered_set<std::string>& objectIDs,
                                     const std::string& baseID = "Generated");
 
        void registerStandardClock(SequencePlayerStandardClock* standardClock);
 
        void unregisterStandardClock(SequencePlayerStandardClock* standardClock);
 
    protected:
        void registerObjectCreators(rtti::Factory& factory) override;
 
        bool init(nap::utility::ErrorState& errorState) override;
 
        void update(double deltaTime) override;
 
    private:
        void registerOutput(SequencePlayerOutput& output);
 
        void removeOutput(SequencePlayerOutput& output);
 
        // vector holding raw pointers to outputs
        std::vector<SequencePlayerOutput*> mOutputs;
 
        // factory map for default creation of tracks
        DefaultSequenceTrackFactoryMap mDefaultTrackCreatorMap;
 
        // map of controller type information for each track type
        std::unordered_map<rtti::TypeInfo, rtti::TypeInfo> mControllerTypesTrackTypeMap;
 
        // map of controller factory functions
        SequenceControllerFactoryMap mControllerFactory;
 
        // map of sequence player adapter factory functions
        SequencePlayerAdapterFactoryMap mAdapterFactory;
 
        // clocks that need updating
        std::vector<SequencePlayerStandardClock*> mClocks;
    };
}