early-access version 2853

src/input_common/CMakeLists.txt

@@ -1,6 +1,4 @@
 add_library(input_common STATIC
-    drivers/camera.cpp
-    drivers/camera.h
     drivers/gc_adapter.cpp
     drivers/gc_adapter.h
     drivers/keyboard.cpp

src/input_common/input_engine.cpp

@@ -90,18 +90,6 @@ void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const B
     TriggerOnMotionChange(identifier, motion, value);
 }
 
-void InputEngine::SetCamera(const PadIdentifier& identifier,
-                            const Common::Input::CameraStatus& value) {
-    {
-        std::scoped_lock lock{mutex};
-        ControllerData& controller = controller_list.at(identifier);
-        if (!configuring) {
-            controller.camera = value;
-        }
-    }
-    TriggerOnCameraChange(identifier, value);
-}
-
 bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
     std::scoped_lock lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
@@ -177,18 +165,6 @@ BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion)
     return controller.motions.at(motion);
 }
 
-Common::Input::CameraStatus InputEngine::GetCamera(const PadIdentifier& identifier) const {
-    std::scoped_lock lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
-                  identifier.pad, identifier.port);
-        return {};
-    }
-    const ControllerData& controller = controller_iter->second;
-    return controller.camera;
-}
-
 void InputEngine::ResetButtonState() {
     for (const auto& controller : controller_list) {
         for (const auto& button : controller.second.buttons) {
@@ -341,20 +317,6 @@ void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int mot
     });
 }
 
-void InputEngine::TriggerOnCameraChange(const PadIdentifier& identifier,
-                                        [[maybe_unused]] const Common::Input::CameraStatus& value) {
-    std::scoped_lock lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
-        const InputIdentifier& poller = poller_pair.second;
-        if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Camera, 0)) {
-            continue;
-        }
-        if (poller.callback.on_change) {
-            poller.callback.on_change();
-        }
-    }
-}
-
 bool InputEngine::IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                          const PadIdentifier& identifier, EngineInputType type,
                                          int index) const {

src/input_common/input_engine.h

@@ -36,12 +36,11 @@ struct BasicMotion {
 // Types of input that are stored in the engine
 enum class EngineInputType {
     None,
-    Analog,
-    Battery,
     Button,
-    Camera,
     HatButton,
+    Analog,
     Motion,
+    Battery,
 };
 
 namespace std {
@@ -116,17 +115,10 @@ public:
     // Sets polling mode to a controller
     virtual Common::Input::PollingError SetPollingMode(
         [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] const Common::Input::PollingMode polling_mode) {
+        [[maybe_unused]] const Common::Input::PollingMode vibration) {
         return Common::Input::PollingError::NotSupported;
     }
 
-    // Sets camera format to a controller
-    virtual Common::Input::CameraError SetCameraFormat(
-        [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] Common::Input::CameraFormat camera_format) {
-        return Common::Input::CameraError::NotSupported;
-    }
-
     // Returns the engine name
     [[nodiscard]] const std::string& GetEngineName() const;
 
@@ -182,7 +174,6 @@ public:
     f32 GetAxis(const PadIdentifier& identifier, int axis) const;
     Common::Input::BatteryLevel GetBattery(const PadIdentifier& identifier) const;
     BasicMotion GetMotion(const PadIdentifier& identifier, int motion) const;
-    Common::Input::CameraStatus GetCamera(const PadIdentifier& identifier) const;
 
     int SetCallback(InputIdentifier input_identifier);
     void SetMappingCallback(MappingCallback callback);
@@ -194,7 +185,6 @@ protected:
     void SetAxis(const PadIdentifier& identifier, int axis, f32 value);
     void SetBattery(const PadIdentifier& identifier, Common::Input::BatteryLevel value);
     void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
-    void SetCamera(const PadIdentifier& identifier, const Common::Input::CameraStatus& value);
 
     virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
         return "Unknown";
@@ -207,7 +197,6 @@ private:
         std::unordered_map<int, float> axes;
         std::unordered_map<int, BasicMotion> motions;
         Common::Input::BatteryLevel battery{};
-        Common::Input::CameraStatus camera{};
     };
 
     void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
@@ -216,8 +205,6 @@ private:
     void TriggerOnBatteryChange(const PadIdentifier& identifier, Common::Input::BatteryLevel value);
     void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
                                const BasicMotion& value);
-    void TriggerOnCameraChange(const PadIdentifier& identifier,
-                               const Common::Input::CameraStatus& value);
 
     bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                 const PadIdentifier& identifier, EngineInputType type,

src/input_common/input_poller.cpp

@@ -664,47 +664,6 @@ private:
     InputEngine* input_engine;
 };
 
-class InputFromCamera final : public Common::Input::InputDevice {
-public:
-    explicit InputFromCamera(PadIdentifier identifier_, InputEngine* input_engine_)
-        : identifier(identifier_), input_engine(input_engine_) {
-        UpdateCallback engine_callback{[this]() { OnChange(); }};
-        const InputIdentifier input_identifier{
-            .identifier = identifier,
-            .type = EngineInputType::Camera,
-            .index = 0,
-            .callback = engine_callback,
-        };
-        callback_key = input_engine->SetCallback(input_identifier);
-    }
-
-    ~InputFromCamera() override {
-        input_engine->DeleteCallback(callback_key);
-    }
-
-    Common::Input::CameraStatus GetStatus() const {
-        return input_engine->GetCamera(identifier);
-    }
-
-    void ForceUpdate() override {
-        OnChange();
-    }
-
-    void OnChange() {
-        const Common::Input::CallbackStatus status{
-            .type = Common::Input::InputType::IrSensor,
-            .camera_status = GetStatus(),
-        };
-
-        TriggerOnChange(status);
-    }
-
-private:
-    const PadIdentifier identifier;
-    int callback_key;
-    InputEngine* input_engine;
-};
-
 class OutputFromIdentifier final : public Common::Input::OutputDevice {
 public:
     explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
@@ -723,10 +682,6 @@ public:
         return input_engine->SetPollingMode(identifier, polling_mode);
     }
 
-    Common::Input::CameraError SetCameraFormat(Common::Input::CameraFormat camera_format) override {
-        return input_engine->SetCameraFormat(identifier, camera_format);
-    }
-
 private:
     const PadIdentifier identifier;
     InputEngine* input_engine;
@@ -965,18 +920,6 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
                                                  properties_y, properties_z, input_engine.get());
 }
 
-std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateCameraDevice(
-    const Common::ParamPackage& params) {
-    const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
-        .port = static_cast<std::size_t>(params.Get("port", 0)),
-        .pad = static_cast<std::size_t>(params.Get("pad", 0)),
-    };
-
-    input_engine->PreSetController(identifier);
-    return std::make_unique<InputFromCamera>(identifier, input_engine.get());
-}
-
 InputFactory::InputFactory(std::shared_ptr<InputEngine> input_engine_)
     : input_engine(std::move(input_engine_)) {}
 
@@ -985,9 +928,6 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::Create(
     if (params.Has("battery")) {
         return CreateBatteryDevice(params);
     }
-    if (params.Has("camera")) {
-        return CreateCameraDevice(params);
-    }
     if (params.Has("button") && params.Has("axis")) {
         return CreateTriggerDevice(params);
     }

src/input_common/input_poller.h

@@ -211,17 +211,6 @@ private:
      */
     std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
 
-    /**
-     * Creates a camera device from the parameters given.
-     * @param params contains parameters for creating the device:
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
-     */
-    std::unique_ptr<Common::Input::InputDevice> CreateCameraDevice(
-        const Common::ParamPackage& params);
-
     std::shared_ptr<InputEngine> input_engine;
 };
 } // namespace InputCommon

src/input_common/main.cpp

@@ -5,7 +5,6 @@
 #include <memory>
 #include "common/input.h"
 #include "common/param_package.h"
-#include "input_common/drivers/camera.h"
 #include "input_common/drivers/gc_adapter.h"
 #include "input_common/drivers/keyboard.h"
 #include "input_common/drivers/mouse.h"
@@ -79,15 +78,6 @@ struct InputSubsystem::Impl {
         Common::Input::RegisterFactory<Common::Input::OutputDevice>(tas_input->GetEngineName(),
                                                                     tas_output_factory);
 
-        camera = std::make_shared<Camera>("camera");
-        camera->SetMappingCallback(mapping_callback);
-        camera_input_factory = std::make_shared<InputFactory>(camera);
-        camera_output_factory = std::make_shared<OutputFactory>(camera);
-        Common::Input::RegisterFactory<Common::Input::InputDevice>(camera->GetEngineName(),
-                                                                   camera_input_factory);
-        Common::Input::RegisterFactory<Common::Input::OutputDevice>(camera->GetEngineName(),
-                                                                    camera_output_factory);
-
 #ifdef HAVE_SDL2
         sdl = std::make_shared<SDLDriver>("sdl");
         sdl->SetMappingCallback(mapping_callback);
@@ -327,7 +317,6 @@ struct InputSubsystem::Impl {
     std::shared_ptr<TouchScreen> touch_screen;
     std::shared_ptr<TasInput::Tas> tas_input;
     std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
-    std::shared_ptr<Camera> camera;
 
     std::shared_ptr<InputFactory> keyboard_factory;
     std::shared_ptr<InputFactory> mouse_factory;
@@ -335,14 +324,12 @@ struct InputSubsystem::Impl {
     std::shared_ptr<InputFactory> touch_screen_factory;
     std::shared_ptr<InputFactory> udp_client_input_factory;
     std::shared_ptr<InputFactory> tas_input_factory;
-    std::shared_ptr<InputFactory> camera_input_factory;
 
     std::shared_ptr<OutputFactory> keyboard_output_factory;
     std::shared_ptr<OutputFactory> mouse_output_factory;
     std::shared_ptr<OutputFactory> gcadapter_output_factory;
     std::shared_ptr<OutputFactory> udp_client_output_factory;
     std::shared_ptr<OutputFactory> tas_output_factory;
-    std::shared_ptr<OutputFactory> camera_output_factory;
 
 #ifdef HAVE_SDL2
     std::shared_ptr<SDLDriver> sdl;
@@ -395,14 +382,6 @@ const TasInput::Tas* InputSubsystem::GetTas() const {
     return impl->tas_input.get();
 }
 
-Camera* InputSubsystem::GetCamera() {
-    return impl->camera.get();
-}
-
-const Camera* InputSubsystem::GetCamera() const {
-    return impl->camera.get();
-}
-
 std::vector<Common::ParamPackage> InputSubsystem::GetInputDevices() const {
     return impl->GetInputDevices();
 }

src/input_common/main.h

@@ -30,7 +30,6 @@ enum Values : int;
 }
 
 namespace InputCommon {
-class Camera;
 class Keyboard;
 class Mouse;
 class TouchScreen;
@@ -93,15 +92,9 @@ public:
     /// Retrieves the underlying tas input device.
     [[nodiscard]] TasInput::Tas* GetTas();
 
-    /// Retrieves the underlying tas input device.
+    /// Retrieves the underlying  tas input  device.
     [[nodiscard]] const TasInput::Tas* GetTas() const;
 
-    /// Retrieves the underlying camera input device.
-    [[nodiscard]] Camera* GetCamera();
-
-    /// Retrieves the underlying camera input device.
-    [[nodiscard]] const Camera* GetCamera() const;
-
     /**
      * Returns all available input devices that this Factory can create a new device with.
      * Each returned ParamPackage should have a `display` field used for display, a `engine` field