sequencecontrollercurve.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 "sequencecontroller.h"
#include "sequencecurveenums.h"
#include "sequencetrackcurve.h"
 
// External Includes
#include <mathutils.h>
 
namespace nap {
 
    // forward declares
    class SequenceService;
 
    class NAPAPI SequenceControllerCurve : public SequenceController
    {
        RTTI_ENABLE(SequenceController)
    public:
        SequenceControllerCurve(SequenceService& service, SequencePlayer& player, SequenceEditor& editor);
 
        double segmentDurationChange(const std::string& trackID, const std::string& segmentID, float duration);
 
        template<typename T>
        void addNewCurveTrack();
 
        void changeCurveSegmentValue(const std::string& trackID, const std::string& segmentID, float newValue,
                                     int curveIndex, sequencecurveenums::ESegmentValueTypes valueType);
 
        void insertCurvePoint(const std::string& trackID, const std::string& segmentID, float pos, int curveIndex);
 
        void deleteCurvePoint(const std::string& trackID, const std::string& segmentID, int index, int curveIndex);
 
        void changeCurvePoint(const std::string& trackID, const std::string& segmentID, int pointIndex, int curveIndex,
                              float time, float value);
 
        bool changeTanPoint(const std::string& trackID, const std::string& segmentID, int pointIndex, int curveIndex,
                            sequencecurveenums::ETanPointTypes tanType, float time, float value);
 
        template<typename T>
        void changeMinMaxCurveTrack(const std::string& trackID, T minimum, T maximum);
 
        template<typename T>
        void changeCurveType(SequenceTrackSegment& segment, math::ECurveInterp type, int curveIndex);
 
        const SequenceTrackSegment* insertSegment(const std::string& trackID, double time) override;
 
        void deleteSegment(const std::string& trackID, const std::string& segmentID) override;
 
        void insertTrack(rtti::TypeInfo type) override;
 
        void updateCurveSegments(const std::string& trackID);
 
        void changeCurveType(const std::string& trackID, const std::string& segmentID, math::ECurveInterp type,
                             int curveIndex);
 
    protected:
        template<typename T>
        void updateCurveSegments(SequenceTrack& track);
 
        template<typename T>
        const SequenceTrackSegment* insertCurveSegment(const std::string& trackID, double time);
 
        template<typename T>
        bool changeTanPoint(SequenceTrackSegment& segment, const std::string& trackID, int pointIndex, int curveIndex,
                            sequencecurveenums::ETanPointTypes tanType, float time, float value);
 
        template<typename T>
        void changeCurvePoint(SequenceTrackSegment& segment, int pointIndex, int curveIndex, float time, float value);
 
        template<typename T>
        void changeLastCurvePoint(SequenceTrackSegment& segment, int curveIndex, float time, float value);
 
        template<typename T>
        void deleteCurvePoint(SequenceTrackSegment& segment, int index, int curveIndex);
 
        template<typename T>
        void insertCurvePoint(SequenceTrackSegment& segment, float pos, int curveIndex);
 
        template<typename T>
        void changeCurveSegmentValue(SequenceTrack& track, SequenceTrackSegment& segment, float newValue, int curveIndex, sequencecurveenums::ESegmentValueTypes valueType);
 
        // map for updating segments
        std::unordered_map<rttr::type, std::function<void(SequenceTrack&)>> mUpdateSegmentFunctionMap;
 
        // map for inserting segments
        std::unordered_map<rttr::type, std::function<const SequenceTrackSegment*(const std::string&,double)>> mInsertSegmentFunctionMap;
 
        // maps containing function pointers to templated functions
        // the reason for this is that actions are not templated and when handled by the gui contain rtti type information
        // in order to call the right templated controller function, function calls are stored in a map with type information as key value
        // this makes it also possible to add other curved tracks when extending the controller
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceControllerCurve*)>> mInsertTrackFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<bool(SequenceTrackSegment&, const std::string&, const int, const int, sequencecurveenums::ETanPointTypes, float, float)>> mChangeTanPointFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrackSegment&, const int, const int, float, float)>> mChangeCurvePointFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrackSegment&, const int, float, float)>> mChangeLastCurvePointFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrackSegment&, const int, int)>> mDeleteCurvePointFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrackSegment&, float, int)>> mInsertCurvePointFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrack&, SequenceTrackSegment& segment, float, int, sequencecurveenums::ESegmentValueTypes)>> mChangeSegmentValueFunctionMap;
        std::unordered_map<rtti::TypeInfo, std::function<void(SequenceTrackSegment&, math::ECurveInterp type, int curveIndex)>> mChangeCurveTypeFunctionMap;
    };
 
    // Forward declarations
 
    template<>
    void NAPAPI SequenceControllerCurve::changeMinMaxCurveTrack<float>(const std::string& trackID, float minimum, float maximum);
}
 
#include "sequencecontrollercurve_template.h"