ControllerInterface.h

#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;
    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)
            {}
            UUID feedback_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;
        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();
    };

    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;   
    };
}