portalitemvec.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 "portalitem.h"
#include "portalutils.h"
 
// External Includes
#include <apivalue.h>
#include <apievent.h>
#include <parametervec.h>
#include <nap/signalslot.h>
 
namespace nap
{
    template<typename T>
    class PortalItemVec : public PortalItem
    {
        RTTI_ENABLE(PortalItem)
 
    public:
 
        virtual bool init(utility::ErrorState& error) override;
 
        virtual void onDestroy() override;
 
        virtual bool processUpdate(const APIEvent& event, utility::ErrorState& error) override;
 
        virtual APIEventPtr getDescriptor() const override;
 
        virtual APIEventPtr getValue() const override;
 
        virtual void onParameterUpdate(T value);
 
        Slot<T> mParameterUpdateSlot = { this, &PortalItemVec::onParameterUpdate };
 
        ResourcePtr<ParameterVec<T>> mParameter;        
 
    private:
 
        const std::vector<typename T::value_type> getVectorValues() const;
 
        bool setVectorValues(const std::vector<typename T::value_type>& values, utility::ErrorState& error);
    };
 
 
    // Portal Item Numeric Type Definitions
 
    using PortalItemVec2        = PortalItemVec<glm::vec2>;
    using PortalItemVec3        = PortalItemVec<glm::vec3>;
    using PortalItemIVec2       = PortalItemVec<glm::ivec2>;
    using PortalItemIVec3       = PortalItemVec<glm::ivec3>;
 
 
    // Template Definitions
 
    template<typename T>
    bool PortalItemVec<T>::init(utility::ErrorState& error)
    {
        mParameter->valueChanged.connect(mParameterUpdateSlot);
        return true;
    }
 
    template<typename T>
    void PortalItemVec<T>::onDestroy()
    {
        mParameter->valueChanged.disconnect(mParameterUpdateSlot);
    }
 
    template<typename T>
    void PortalItemVec<T>::onParameterUpdate(T value)
    {
        updateSignal(*this);
    }
 
    template<typename T>
    bool PortalItemVec<T>::processUpdate(const APIEvent& event, utility::ErrorState& error)
    {
        // Check for the portal item value argument
        const APIArgument* arg = event.getArgumentByName(nap::portal::itemValueArgName);
        if (!error.check(arg != nullptr, "%s: update event missing argument %s", mID.c_str(), nap::portal::itemValueArgName))
            return false;
 
        // Ensure that the argument is an array
        if (!error.check(arg->isArray(), "%s: expected array for value argument, not %s", mID.c_str(), arg->getValueType().get_name().data()))
            return false;
 
        // Cast the argument to an array of the basic data type
        const std::vector<typename T::value_type>* values = arg->asArray<typename T::value_type>();
        if (!error.check(values != nullptr, "%s: expected array of %s for value argument, not %s", mID.c_str(), RTTI_OF(typename T::value_type).get_name().data(), arg->getValueType().get_name().data()))
            return false;
 
        return setVectorValues(*values, error);
    }
 
    template<typename T>
    APIEventPtr PortalItemVec<T>::getDescriptor() const
    {
        APIEventPtr event = std::make_unique<APIEvent>(mParameter->getDisplayName(), mID);
        event->addArgument<APIString>(nap::portal::itemTypeArgName, get_type().get_name().data());
        event->addArgument<APIValue<std::vector<typename T::value_type>>>(nap::portal::itemValueArgName, getVectorValues());
        event->addArgument<APIValue<typename T::value_type>>(nap::portal::itemMinArgName, mParameter->mMinimum);
        event->addArgument<APIValue<typename T::value_type>>(nap::portal::itemMaxArgName, mParameter->mMaximum);
        event->addArgument<APIBool>(nap::portal::itemClampArgName, mParameter->mClamp);
        return event;
    }
 
    template<typename T>
    APIEventPtr PortalItemVec<T>::getValue() const
    {
        APIEventPtr event = std::make_unique<APIEvent>(mParameter->getDisplayName(), mID);
        event->addArgument<APIValue<std::vector<typename T::value_type>>>(nap::portal::itemValueArgName, getVectorValues());
        return event;
    }
 
    template<typename T>
    const std::vector<typename T::value_type> PortalItemVec<T>::getVectorValues() const
    {
        size_t length = mParameter->mValue.length();
        std::vector<typename T::value_type> values(length);
        std::memcpy(values.data(), &mParameter->mValue, sizeof(typename T::value_type) * length);
        return values;
    }
 
    template<typename T>
    bool PortalItemVec<T>::setVectorValues(const std::vector<typename T::value_type>& values, utility::ErrorState& error)
    {
        // Ensure we have enough data
        size_t length = mParameter->mValue.length();
        if (!error.check(values.size() == length, "%s: expected a vector of size %i, received %i", mID.c_str(), length, values.size()))
            return false;
 
        // Update the vector trough setValue so the parameter will trigger an update signal
        T new_value;
        std::memcpy(&new_value, values.data(), sizeof(typename T::value_type) * length);
        mParameter->valueChanged.disconnect(mParameterUpdateSlot);
        mParameter->setValue(new_value);
        mParameter->valueChanged.connect(mParameterUpdateSlot);
        return true;
    }
}
 
#define DEFINE_PORTAL_ITEM_VEC(Type)                                                                                    \
    RTTI_BEGIN_CLASS(Type, "Portal vector item")                                                                        \
        RTTI_PROPERTY("Parameter",  &Type::mParameter,  nap::rtti::EPropertyMetaData::Required, "Vector parameter")     \
    RTTI_END_CLASS