Endpoint.h

//
//  Created by Bradley Austin Davis 2015/10/09
//  Copyright 2015 High Fidelity, Inc.
//  Copyright 2023 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//  SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
#ifndef hifi_Controllers_Endpoint_h
#define hifi_Controllers_Endpoint_h
 
#include <list>
#include <memory>
#include <functional>
 
#include <QtCore/QObject>
 
#include "../AxisValue.h"
#include "../Input.h"
#include "../Pose.h"
 
namespace controller {
    /*
    * Encapsulates a particular input / output,
    * i.e. Hydra.Button0, Standard.X, Action.Yaw
    */
 
// All the derived classes need to have private constructors
class Endpoint : public QObject, public std::enable_shared_from_this<Endpoint> {
        Q_OBJECT;
    public:
        using Pointer = std::shared_ptr<Endpoint>;
        using List = std::list<Pointer>;
        using Pair = std::pair<Pointer, Pointer>;
        using ReadLambda = std::function<float()>;
        using WriteLambda = std::function<void(float)>;
 
        virtual AxisValue value() { return peek(); }
        virtual AxisValue peek() const = 0;
        virtual void apply(AxisValue value, const Pointer& source) = 0;
        virtual Pose peekPose() const { return Pose(); };
        virtual Pose pose() { return peekPose(); }
        virtual void apply(const Pose& value, const Pointer& source) {}
        virtual bool isPose() const { return _input.isPose(); }
        virtual bool writeable() const { return true; }
        virtual bool readable() const { return true; }
        virtual void reset() { }
 
        const Input& getInput() { return _input;  }
 
    protected:
        Endpoint(const Input& input) : _input(input) {}
        Input _input;
    };
 
    class LambdaEndpoint : public Endpoint {
    public:
        using Endpoint::apply;
 
        virtual AxisValue peek() const override { return AxisValue(_readLambda(), 0); }
        virtual void apply(AxisValue value, const Pointer& source) override { _writeLambda(value.value); }
 
    private:
        LambdaEndpoint(ReadLambda readLambda, WriteLambda writeLambda = [](float) {})
            : Endpoint(Input::INVALID_INPUT), _readLambda(readLambda), _writeLambda(writeLambda) { }
 
        ReadLambda _readLambda;
        WriteLambda _writeLambda;
    };
 
    extern Endpoint::WriteLambda DEFAULT_WRITE_LAMBDA;
 
    class LambdaRefEndpoint : public Endpoint {
    public:
        static std::shared_ptr<Endpoint> newEndpoint(const ReadLambda& readLambda, const WriteLambda& writeLambda = DEFAULT_WRITE_LAMBDA) {
            return std::shared_ptr<Endpoint>(new LambdaRefEndpoint(readLambda, writeLambda));
        };
 
        using Endpoint::apply;
 
        virtual AxisValue peek() const override { return AxisValue(_readLambda(), 0); }
        virtual void apply(AxisValue value, const Pointer& source) override { _writeLambda(value.value); }
 
    private:
        LambdaRefEndpoint(const ReadLambda& readLambda, const WriteLambda& writeLambda = DEFAULT_WRITE_LAMBDA)
            : Endpoint(Input::INVALID_INPUT), _readLambda(readLambda), _writeLambda(writeLambda) {
        }
 
        const ReadLambda& _readLambda;
        const WriteLambda& _writeLambda;
    };
 
 
    class VirtualEndpoint : public Endpoint {
    public:
        virtual AxisValue peek() const override { return _currentValue; }
        virtual void apply(AxisValue value, const Pointer& source) override { _currentValue = value; }
 
        virtual Pose peekPose() const override { return _currentPose; }
        virtual void apply(const Pose& value, const Pointer& source) override {
            _currentPose = value;
        }
    protected:
        VirtualEndpoint(const Input& id = Input::INVALID_INPUT)
            : Endpoint(id) {
        }
 
        AxisValue _currentValue { 0.0f, 0, false };
        Pose _currentPose {};
    };
 
}
 
#endif