PadPS5.hpp

[詳解]

//
//    PS5コントローラー受信クラス
//
//    Copyright (c) 2022 udonrobo
//
//    Controller --> Sender --> Master
//                              ^^^^^^
//
 
#pragma once
 
#include <Udon/Types/Position.hpp>
#include <Udon/Algorithm/Input.hpp>
#include <Udon/Com/Message.hpp>
#include <Udon/Com/Message/PadPS5.hpp>
#include <Udon/Traits/ReaderWriterTraits.hpp>
 
namespace Udon
{

    template <template <typename> class Reader>
    class PadPS5
        : public Reader<Message::PadPS5>
    {
        static_assert(Traits::IsReader<Reader>::value, "Reader type must meet recipient requirements.");
 
    public:
        using MessageType = Message::PadPS5;

        using ReaderType = Reader<MessageType>;

        using ReaderType::ReaderType;

        explicit operator bool() const noexcept { return isConnected; }

        bool isEmergencyStop() const noexcept
        {
            // パッドが接続されていない場合は非常停止
            if (not *this)
            {
                return true;
            }
 
            if (getCross().toggle)
            {
                return false;
            }
            else
            {
                // 起動時は非常停止
                return true;
            }
        }

        bool isOperable() const noexcept
        {
            return not isEmergencyStop();
        }

        Input getTriangle() const noexcept { return triangle; }

        Input getCircle() const noexcept { return circle; }

        Input getCross() const noexcept { return cross; }

        Input getSquare() const noexcept { return square; }

        Input getUp() const noexcept { return up; }

        Input getRight() const noexcept { return right; }

        Input getDown() const noexcept { return down; }

        Input getLeft() const noexcept { return left; }

        Input getL1() const noexcept { return l1; }

        Input getR1() const noexcept { return r1; }

        Input getL2() const noexcept { return l2; }

        Input getR2() const noexcept { return r2; }

        Input getL3() const noexcept { return l3; }

        Input getR3() const noexcept { return r3; }

        Input getCreate() const noexcept { return create; }

        Input getOption() const noexcept { return option; }

        Input getTouch() const noexcept { return touch; }

        Input getMic() const noexcept { return mic; }

        Input getPs() const noexcept { return ps; }

        Vec2 getLeftStick() const noexcept { return leftStick; }

        Vec2 getRightStick() const noexcept { return rightStick; }

        Stick getMoveInfo() const noexcept { return { leftStick, rightStick.x }; }

        void update(int deadZone = 20) noexcept
        {
            Traits::MaybeInvokeUpdate<ReaderType>(*this);
            const auto message = ReaderType::getMessage();
 
            if (message && message->isConnected)
            {
                isConnected = true;
 
                triangle.update(message->triangle);
                circle.update(message->circle);
                cross.update(message->cross);
                square.update(message->square);
 
                up.update(message->up);
                right.update(message->right);
                down.update(message->down);
                left.update(message->left);
 
                l1.update(message->l1);
                r1.update(message->r1);
                l2.update(message->l2);
                r2.update(message->r2);
                l3.update(message->l3);
                r3.update(message->r3);
 
                create.update(message->create);
                option.update(message->option);
                touch.update(message->touch);
                mic.update(message->mic);
                ps.update(message->ps);
 
                // -128 ~ 127(int8_t) -> -255 ~ 255(int16_t)
                const auto decodeStick = [](int8_t raw) -> int16_t
                {
                    return raw * 2 + 1;    // (raw + 128) * 2 - 255
                };
 
                leftStick = {
                    CutDeadZone(decodeStick(message->analogLeftX), deadZone),
                    CutDeadZone(decodeStick(message->analogLeftY), deadZone),
                };
                rightStick = {
                    CutDeadZone(decodeStick(message->analogRightX), deadZone),
                    CutDeadZone(decodeStick(message->analogRightY), deadZone),
                };
            }
            else
            {
                isConnected = false;
 
                triangle.update(false);
                circle.update(false);
                cross.update(false);
                square.update(false);
 
                up.update(false);
                right.update(false);
                down.update(false);
                left.update(false);
 
                l1.update(false);
                r1.update(false);
                l2.update(false);
                r2.update(false);
                l3.update(false);
                r3.update(false);
 
                create.update(false);
                option.update(false);
                touch.update(false);
                mic.update(false);
 
                leftStick.clear();
                rightStick.clear();
            }
        }

        MessageType getMessage() const
        {
            return {
                isConnected,
                triangle.press,
                circle.press,
                cross.press,
                square.press,
 
                up.press,
                right.press,
                down.press,
                left.press,
 
                l1.press,
                r1.press,
                l2.press,
                r2.press,
                l3.press,
                r3.press,
 
                create.press,
                option.press,
                touch.press,
                mic.press,
                ps.press,
 
                static_cast<int8_t>(rightStick.x / 2),
                static_cast<int8_t>(rightStick.y / 2),
                static_cast<int8_t>(leftStick.x / 2),
                static_cast<int8_t>(leftStick.y / 2),
            };
        }
 
    private:
        // 接続状態
        bool isConnected = false;
 
        // ボタン
        Input triangle;
        Input circle;
        Input cross;
        Input square;
        Input up;
        Input right;
        Input down;
        Input left;
        Input l1;
        Input r1;
        Input l2;
        Input r2;
        Input l3;
        Input r3;
        Input create;
        Input option;
        Input touch;
        Input mic;
        Input ps;
 
        // アナログスティック [-255~255]
        Vec2 rightStick;
        Vec2 leftStick;

        static double CutDeadZone(double value, uint8_t deadZone)
        {
            if (value > deadZone)
                return 255 * (value - deadZone) / (255 - deadZone);
            else if (value < -deadZone)
                return 255 * (value + deadZone) / (255 - deadZone);
            else
                return 0.0;
        };
    };
 
}    // namespace Udon