ControllerInterface.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Battery.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Vector.h>
#include <NDEVR/RGBColor.h>
namespace NDEVR
{
    class Thread;
    class WindowInstance;
    /**--------------------------------------------------------------------------------------------------
    \brief Provides standard logic shared across all hardware controllers to be used with the software.
    **/
    class HARDWARE_API ControllerInterface : public QObject, public SoftwareService
    {
        Q_OBJECT
    public:
        struct ControllerInput
        {
            ControllerInput(UUID id)
                : id(id)
            {}
            TranslatedString name;
            String icon;
            Bounds<2, fltp08> icon_bounds_location = Constant<Bounds<2, fltp08>>::Invalid;
            UUID id;
        };
        struct ControlStick : public ControllerInput
        {
            ControlStick(const UUID& id)
                : ControllerInput(id)
            {}
            ControlStick(const UUID& id, Vector<2, fltp08>& position)
                : ControllerInput(id)
                , position(position)
            {}
            Vector<2, fltp08> position;
            bool pressed = false;
        };
        struct ControlButton : public ControllerInput
        {
            ControlButton(const UUID& id)
                : ControllerInput(id)
            {};
            ControlButton(const UUID& id, bool pressed)
                : ControllerInput(id)
                , pressed(pressed)
            {}
            bool pressed = false;
        };
        struct ControlTrigger : public ControllerInput
        {
            ControlTrigger(const UUID& id)
                : ControllerInput(id)
            {};
            ControlTrigger(const UUID& id, fltp08 percent)
                : ControllerInput(id)
                , percent(percent)
                , pressed(percent > 0.5)
            {}
            fltp08 percent = 0.0;
            bool pressed = false;
        };
        struct HapticFeedback : public ControllerInput
        {
            HapticFeedback(const UUID& id)
                : ControllerInput(id)
            {}
            HapticFeedback(const UUID& id, fltp08 intensity)
                : ControllerInput(id)
                , intensity(intensity)
            {}
            //Referes to another item (for example joystick or trigger) which the feedback applies to. Invalid if just rumbler)
            UUID feedbck_part_id = Constant<UUID>::Invalid;
            fltp08 intensity = 0.0;
        };
        virtual Buffer<ControlStick> rightSticks() const = 0;
        virtual Buffer<ControlStick> leftSticks() const = 0;
        virtual Buffer<ControlButton> centerButtons() const = 0;
        virtual Buffer<ControlButton> rightButtons() const = 0;
        virtual Buffer<ControlButton> leftButtons() const = 0;
        virtual Buffer<ControlTrigger> rightTriggers() const = 0;
        virtual Buffer<ControlTrigger> leftTriggers() const = 0;
        virtual Vector<2, fltp08> vibration() const = 0;
        virtual RGBColor color() const = 0;
        virtual Buffer<Battery*> batteries() const = 0;
        virtual void setWindowInstance(WindowInstance*) {}
        virtual Buffer<HapticFeedback> hapticFeedback() const = 0;
        //0-1, 0 = off, 1 = full vibration
        virtual bool requestVibrating(fltp08 left, fltp08 right) = 0;
        virtual bool requestColor(const RGBColor& color) = 0;
        virtual UUID id() const = 0;
        virtual void updateState() = 0;
    signals:
        void onUpdated();
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores services that allow the software to access physical hardware controllers that can
        be used with the system.
    **/
    class HARDWARE_API ControllerInterfaceManager : public QObject, public SoftwareServiceManager
    {
        Q_OBJECT
    public:
        static ControllerInterfaceManager& Default();
    protected:
        ControllerInterfaceManager();
    public:
        void addController(ControllerInterface* joystick);
        void removeController(UUID id);
        void updateStates();
        void setDefaultWindowInstance(WindowInstance* default_window_instance);
        const Dictionary<UUID, ControllerInterface*>& controllers() const;
    signals:
        void controllerConnectionsChangedSignal();
        void findControllersSignal();
    protected:
        Dictionary<UUID, ControllerInterface*> m_controllers;
        Thread* m_controller_thread = nullptr;
        WindowInstance* m_default_window_instance = nullptr;
    };
}