cocos-engine-external/sources/android-gamesdk/GameController/GameController.h

/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <android/input.h>

#include "GameControllerDeviceInfo.h"
#include "GameControllerGameActivityMirror.h"
#include "paddleboat.h"

namespace paddleboat {

// set if axisMultiplier/axisAdjustment should be applied (raw device axis isn't
// -1.0 to 1.0)
inline constexpr uint32_t GAMECONTROLLER_AXIS_FLAG_APPLY_ADJUSTMENTS =
    (1U << 0);
// set if trigger is being faked as an analog axis (device just has a on/off
// button flag)
inline constexpr uint32_t GAMECONTROLLER_AXIS_FLAG_DIGITAL_TRIGGER = (1U << 1);

class GameController {
   public:
    enum GameControllerAxis {
        GAMECONTROLLER_AXIS_LSTICK_X = 0,
        GAMECONTROLLER_AXIS_LSTICK_Y,
        GAMECONTROLLER_AXIS_RSTICK_X,
        GAMECONTROLLER_AXIS_RSTICK_Y,
        GAMECONTROLLER_AXIS_L1,
        GAMECONTROLLER_AXIS_L2,
        GAMECONTROLLER_AXIS_R1,
        GAMECONTROLLER_AXIS_R2,
        GAMECONTROLLER_AXIS_HAT_X,
        GAMECONTROLLER_AXIS_HAT_Y,
        GAMECONTROLLER_AXIS_COUNT
    };

    struct GameControllerAxisInfo {
        // Index into the device axis array, -1 is unmapped
        int32_t axisIndex = -1;
        // See GAMECONTROLLER_AXIS_FLAG constants
        uint32_t axisFlags = 0;
        // Button mask flag, if backed/shadowed by digital button when axis >
        // 0.0
        uint32_t axisButtonMask = 0;
        // Button mask flag, if backed/shadowed by digital button when axis <
        // 0.0
        uint32_t axisButtonNegativeMask = 0;
        // Multiplier to normalize to a 0.0 center -> 1.0 edge
        float axisMultiplier = 1.0f;
        // Adjustment to bring center to 0.0 if necessary
        float axisAdjust = 0.0f;

        void resetInfo() {
            axisIndex = -1;
            axisFlags = 0;
            axisButtonMask = 0;
            axisButtonNegativeMask = 0;
            axisMultiplier = 1.0f;
            axisAdjust = 0.0f;
        }
    };

    GameController();

    void setupController(const Paddleboat_Controller_Mapping_Data *mappingData);

    void initializeDefaultAxisMapping();

    int32_t processGameActivityKeyEvent(
        const Paddleboat_GameActivityKeyEvent *event, const size_t eventSize);

    int32_t processGameActivityMotionEvent(
        const Paddleboat_GameActivityMotionEvent *event,
        const size_t eventSize);

    int32_t processKeyEvent(const AInputEvent *event);

    int32_t processMotionEvent(const AInputEvent *event);

    Paddleboat_ControllerStatus getControllerStatus() const {
        return mControllerStatus;
    }

    void setControllerStatus(
        const Paddleboat_ControllerStatus controllerStatus) {
        mControllerStatus = controllerStatus;
    }

    int32_t getConnectionIndex() const { return mConnectionIndex; }

    void setConnectionIndex(const int32_t connectionIndex) {
        mConnectionIndex = connectionIndex;
    }

    uint64_t getControllerAxisMask() const { return mControllerAxisMask; }

    Paddleboat_Controller_Data &getControllerData() { return mControllerData; }

    const Paddleboat_Controller_Data &getControllerData() const {
        return mControllerData;
    }

    Paddleboat_Controller_Info &getControllerInfo() { return mControllerInfo; }

    const Paddleboat_Controller_Info &getControllerInfo() const {
        return mControllerInfo;
    }

    GameControllerDeviceInfo &getDeviceInfo() { return mDeviceInfo; }

    const GameControllerDeviceInfo &getDeviceInfo() const {
        return mDeviceInfo;
    }

    GameControllerAxisInfo *getAxisInfo() { return mAxisInfo; }

    const GameControllerAxisInfo *getAxisInfo() const { return mAxisInfo; }

    bool getControllerDataDirty() const { return mControllerDataDirty; }

    void setControllerDataDirty(const bool dirty);

    void resetControllerData();

   private:
    int32_t processKeyEventInternal(const int32_t eventKeyCode,
                                    const int32_t eventKeyAction);

    int32_t processMotionEventInternal(const float *axisArray,
                                       const AInputEvent *event);

    void setupAxis(const GameControllerAxis gcAxis,
                   const int32_t preferredNativeAxisId,
                   const int32_t secondaryNativeAxisId,
                   const int32_t buttonMask, const int32_t buttonNegativeMask);

    void adjustAxisConstants();

    uint64_t mControllerAxisMask = 0;
    Paddleboat_ControllerStatus mControllerStatus =
        PADDLEBOAT_CONTROLLER_INACTIVE;
    int32_t mConnectionIndex = -1;
    Paddleboat_Controller_Data mControllerData;
    Paddleboat_Controller_Info mControllerInfo;
    int32_t mButtonKeycodes[PADDLEBOAT_BUTTON_COUNT];
    GameControllerAxisInfo mAxisInfo[GAMECONTROLLER_AXIS_COUNT];
    GameControllerDeviceInfo mDeviceInfo;
    // Controller data has been updated since the last time it was read
    bool mControllerDataDirty;
};
}  // namespace paddleboat