parameterblendcomponent.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 "parameterblendgroup.h"
#include "parameterblender.h"
 
// External Includes
#include <component.h>
#include <parameternumeric.h>
#include <parameterservice.h>
#include <rtti/deserializeresult.h>
#include <nap/signalslot.h>
 
namespace nap
{
    // Forward Declares
    class ParameterBlendComponentInstance;
 
    class NAPAPI ParameterBlendComponent : public Component
    {
        RTTI_ENABLE(Component)
        DECLARE_COMPONENT(ParameterBlendComponent, ParameterBlendComponentInstance)
    public:
 
        nap::ResourcePtr<ParameterBlendGroup> mBlendGroup = nullptr;            
        nap::ResourcePtr<ParameterInt> mPresetIndex = nullptr;                  
        nap::ResourcePtr<ParameterFloat> mPresetBlendTime = nullptr;            
        bool mEnableBlending = false;                                           
        bool mBlendOnInit = false;                                              
        bool mIgnoreNonBlendableParameters = true;                              
    };
 
 
    class NAPAPI ParameterBlendComponentInstance : public ComponentInstance
    {
        RTTI_ENABLE(ComponentInstance)
    public:
        ParameterBlendComponentInstance(EntityInstance& entity, Component& resource) :
            ComponentInstance(entity, resource)                                 { }
 
        // Destructor
        ~ParameterBlendComponentInstance();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void update(double deltaTime) override;
 
        bool enabled() const                                                    { return mEnableBlending; }
 
        void enable(bool value);
 
        bool isBlending() const;
 
        float getBlendValue();
 
        int getIndex() const                                                    { return mPresetIndex->mValue; }
 
        const std::vector<std::string>& getPresets() const                      { return mPresets; }
 
        bool reload(nap::utility::ErrorState& error);
 
        bool hasPresets() const                                                 { return !(mPresets.empty()); }
 
    private:
        ParameterBlendGroup* mBlendParameters = nullptr;                        
        ParameterInt* mPresetIndex = nullptr;                                   
        ParameterFloat* mPresetBlendTime = nullptr;                             
        bool mEnableBlending = false;                                           
        ParameterService* mParameterService = nullptr;                          
        std::vector<std::string> mPresets;                                      
        std::vector<std::unique_ptr<rtti::DeserializeResult>> mPresetData;      
        std::vector<ParameterGroup*> mPresetGroups;                             
        std::vector<std::unique_ptr<BaseParameterBlender>> mBlenders;           
        double mElapsedTime = 0.0;                                              
        bool mBlending = false;                                                 
        bool mIgnoreNonBlendableParameters = true;                              
 
        bool sourcePresets(nap::utility::ErrorState& error);
 
        bool createBlenders(nap::utility::ErrorState& error);
 
        void changePreset(int index);
 
        nap::Slot<int> mIndexChangedSlot = { this, &ParameterBlendComponentInstance::changePreset };
    };
}