├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── ci.yml
├── third-party
    ├── CMakeLists.txt
    ├── catch.cmake
    ├── vigemclient.cmake
    ├── favhidclient.cmake
    ├── cppwinrt.cmake
    └── vjoy.cmake
├── utilities
    ├── CMakeLists.txt
    ├── list-devices.cpp
    └── render.cpp
├── .gitignore
├── lib
    ├── AxisInformation.cpp
    ├── EventSink.cpp
    ├── Source.cpp
    ├── manifest.xml
    ├── EventSource.cpp
    ├── include
    │   └── cpp-remapper
    │   │   ├── OutputDevice.h
    │   │   ├── EventSink.h
    │   │   ├── EventSource.h
    │   │   ├── MappableOutput.h
    │   │   ├── Percent.h
    │   │   ├── ViGEmClient.h
    │   │   ├── InputDeviceCollection.h
    │   │   ├── Clock.h
    │   │   ├── ButtonToAxis.h
    │   │   ├── MomentaryToLatchedButton.h
    │   │   ├── ClosedPipeline.h
    │   │   ├── FAVHIDDevice.h
    │   │   ├── FunctionTransform.h
    │   │   ├── AxisInformation.h
    │   │   ├── ShortPressLongPress.h
    │   │   ├── easymode.h
    │   │   ├── AxisCurve.h
    │   │   ├── EventLoop.h
    │   │   ├── VJoyDevice.h
    │   │   ├── FunctionSink.h
    │   │   ├── MappableX360Output.h
    │   │   ├── LatchedToMomentaryButton.h
    │   │   ├── AnyOfButton.h
    │   │   ├── Sink.h
    │   │   ├── AxisToHat.h
    │   │   ├── CompositeSink.h
    │   │   ├── SourcePipeline.h
    │   │   ├── SinkPipeline.h
    │   │   ├── render_axis.h
    │   │   ├── MappableDS4Output.h
    │   │   ├── Shift.h
    │   │   ├── Controls.h
    │   │   ├── ViGEmTarget.h
    │   │   ├── function_traits.h
    │   │   ├── SquareDeadzone.h
    │   │   ├── AxisTrimmer.h
    │   │   ├── TransformPipeline.h
    │   │   ├── devicedb.h
    │   │   ├── Source.h
    │   │   ├── X360Device.h
    │   │   ├── AxisToButtons.h
    │   │   ├── maybe_shared_ptr.h
    │   │   ├── InputDevice.h
    │   │   ├── HidHide.h
    │   │   ├── SourcePtr.h
    │   │   ├── DS4Device.h
    │   │   ├── MappableVJoyOutput.h
    │   │   ├── MappableFAVHIDOutput.h
    │   │   ├── DeviceSpecifier.h
    │   │   ├── MappableInput.h
    │   │   ├── SinkPtr.h
    │   │   ├── HatToButtons.h
    │   │   ├── TransformPtr.h
    │   │   ├── connections.h
    │   │   └── Profile.h
    ├── MappableOutput.cpp
    ├── ButtonToAxis.cpp
    ├── Percent.cpp
    ├── AnyOfButton.cpp
    ├── MomentaryToLatchedButton.cpp
    ├── LatchedToMomentaryButton.cpp
    ├── AxisToButtons.cpp
    ├── Clock.cpp
    ├── AxisTrimmer.cpp
    ├── AxisToHat.cpp
    ├── connections.cpp
    ├── SquareDeadzone.cpp
    ├── AxisCurve.cpp
    ├── ShortPressLongPress.cpp
    ├── ViGEmClient.cpp
    ├── CMakeLists.txt
    ├── FAVHIDDevice.cpp
    ├── MappableX360Output.cpp
    ├── InputDeviceCollection.cpp
    ├── X360Device.cpp
    ├── MappableDS4Output.cpp
    ├── DeviceSpecifier.cpp
    ├── HatToButtons.cpp
    ├── Profile.cpp
    ├── DS4Device.cpp
    ├── render_axis.cpp
    ├── MappableVJoyOutput.cpp
    ├── EventLoop.cpp
    ├── VJoyDevice.cpp
    ├── MappableFAVHIDOutput.cpp
    └── MappableInput.cpp
├── tests
    ├── test.cpp
    ├── FunctionSink_test.cpp
    ├── FunctionTransform_test.cpp
    ├── CMakeLists.txt
    ├── tests.h
    ├── AnyOfButton_test.cpp
    ├── Shift_test.cpp
    ├── ButtonToAxis_test.cpp
    ├── MomentaryToLatchedButton_test.cpp
    ├── FakeClock.h
    ├── LatchedToMomentaryButton_test.cpp
    ├── FakeClock.cpp
    ├── ShortPressLongPress_test.cpp
    ├── AxisToHat_test.cpp
    ├── AxisCurve_test.cpp
    ├── CompositeSink_test.cpp
    ├── SquareDeadzone_test.cpp
    ├── AxisToButtons_test.cpp
    ├── Profile_test.cpp
    ├── AxisTrimmer_test.cpp
    ├── connections_test.cpp
    └── HatToButtons_test.cpp
├── legacy_profiles.cmake
├── LICENSE
├── example.cpp
├── .clang-format
├── CMakeLists.txt
└── .vscode
    └── settings.json


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [fredemmott]
2 | 


--------------------------------------------------------------------------------
/third-party/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | include(catch.cmake)
2 | include(cppwinrt.cmake)
3 | include(favhidclient.cmake)
4 | include(vjoy.cmake)
5 | include(vigemclient.cmake)
6 | 


--------------------------------------------------------------------------------
/utilities/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | add_cppremapper_executable(
2 |   list-devices
3 |   list-devices.cpp
4 | )
5 | add_cppremapper_executable(
6 |   render
7 |   render.cpp
8 | )
9 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.ilk
 2 | *.pdb
 3 | .vs/
 4 | *.exe
 5 | *.obj
 6 | *.lib
 7 | 
 8 | /profiles/
 9 | vJoyInterface.dll
10 | /bin/
11 | *~
12 | *.bmp
13 | *.exp
14 | /build/
15 | /out/
16 | 


--------------------------------------------------------------------------------
/third-party/catch.cmake:
--------------------------------------------------------------------------------
 1 | add_library(
 2 |   ThirdParty-Catch2
 3 |   INTERFACE
 4 | )
 5 | 
 6 | target_include_directories(
 7 |   ThirdParty-Catch2
 8 |   INTERFACE
 9 |   "${CMAKE_CURRENT_SOURCE_DIR}/catch2"
10 | )
11 | 


--------------------------------------------------------------------------------
/lib/AxisInformation.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | // This file exists just to give clear compile errors
10 | #include <cpp-remapper/AxisInformation.h>
11 | 


--------------------------------------------------------------------------------
/third-party/vigemclient.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | FetchContent_Declare(
 4 |   FC_ViGEmClient
 5 |   URL "https://github.com/ViGEm/ViGEmClient/archive/refs/tags/v1.21.222.0.zip"
 6 |   URL_HASH "SHA256=4c61f0a82ea1153e271fe760712a97f4edaf64ad5f4244aca78eead74a3749b9"
 7 | )
 8 | FetchContent_MakeAvailable(FC_ViGEmClient)
 9 | 
10 | add_library(ThirdParty-ViGEmClient ALIAS ViGEmClient)
11 | 


--------------------------------------------------------------------------------
/tests/test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #define CATCH_CONFIG_MAIN
10 | 
11 | // Don't intercept ASAN or standard library exceptions
12 | #define CATCH_CONFIG_NO_WINDOWS_SEH
13 | 
14 | #include <catch.hpp>
15 | 


--------------------------------------------------------------------------------
/lib/EventSink.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/EventSink.h>
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | EventSink::~EventSink() {
13 | }
14 | 
15 | }// namespace fredemmott::inputmapping
16 | 


--------------------------------------------------------------------------------
/lib/Source.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/Source.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | AnySource::~AnySource() {
14 | }
15 | 
16 | }// namespace fredemmott::inputmapping
17 | 


--------------------------------------------------------------------------------
/lib/manifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 2 | <assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
 3 |   <assemblyIdentity name="com.fredemmott.openxr-layers-ui" version="6.0.0.0"/>
 4 |   <application>
 5 |     <windowsSettings>
 6 |       <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
 7 |     </windowsSettings>
 8 |   </application>
 9 | </assembly>
10 | 


--------------------------------------------------------------------------------
/lib/EventSource.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/EventSource.h>
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | EventSource::EventSource() {
13 | }
14 | 
15 | EventSource::~EventSource() {
16 | }
17 | 
18 | }// namespace fredemmott::inputmapping
19 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/OutputDevice.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/EventSink.h>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | class OutputDevice : public EventSink {};
15 | 
16 | }// namespace fredemmott::inputmapping
17 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/EventSink.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | class EventSink {
13 |  public:
14 |   virtual ~EventSink();
15 |   virtual void flush() = 0;
16 | };
17 | 
18 | }// namespace fredemmott::inputmapping
19 | 


--------------------------------------------------------------------------------
/lib/MappableOutput.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/MappableOutput.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | MappableOutput::MappableOutput() {
14 | }
15 | 
16 | MappableOutput::~MappableOutput() {
17 | }
18 | 
19 | }// namespace fredemmott::inputmapping
20 | 


--------------------------------------------------------------------------------
/tests/FunctionSink_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/FunctionSink.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("FunctionSink") {
16 |   Axis::Value value = -1;
17 | 
18 |   TestAxis axis;
19 |   axis >> [&value](Axis::Value newValue) { value = newValue; };
20 |   axis.emit(1337);
21 |   REQUIRE(value == 1337);
22 | }
23 | 


--------------------------------------------------------------------------------
/lib/ButtonToAxis.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/ButtonToAxis.h>
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | ButtonToAxis::ButtonToAxis(Axis::Value falseValue, Axis::Value trueValue)
13 |   : mFalse(falseValue), mTrue(trueValue) {
14 | }
15 | 
16 | void ButtonToAxis::map(bool value) {
17 |   emit(value ? mTrue : mFalse);
18 | }
19 | 
20 | }// namespace fredemmott::inputmapping
21 | 


--------------------------------------------------------------------------------
/lib/Percent.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/Percent.h>
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | Percent::Percent(uint8_t value) : mValue(value) {
13 | }
14 | 
15 | uint8_t Percent::value() const noexcept {
16 |   return mValue;
17 | }
18 | 
19 | Percent operator"" _percent(unsigned long long value) {
20 |   return Percent(value);
21 | }
22 | 
23 | }// namespace fredemmott::inputmapping
24 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/EventSource.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #define _WIN32_LEAN_AND_MEAN
11 | #include <Windows.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | class EventSource {
16 |  protected:
17 |   EventSource();
18 | 
19 |  public:
20 |   virtual ~EventSource();
21 |   virtual HANDLE getHandle() = 0;
22 |   virtual void poll() = 0;
23 | };
24 | }// namespace fredemmott::inputmapping
25 | 


--------------------------------------------------------------------------------
/tests/FunctionTransform_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/FunctionTransform.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("FunctionTransform") {
16 |   Axis::Value value = -1;
17 | 
18 |   TestAxis axis;
19 |   axis >> [](Axis::Value value) { return Axis::MAX - value; } >> &value;
20 |   axis.emit(Axis::MAX);
21 |   REQUIRE(value == 0);
22 | }
23 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableOutput.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <memory>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | class OutputDevice;
15 | 
16 | class MappableOutput {
17 |  protected:
18 |   MappableOutput();
19 | 
20 |  public:
21 |   virtual ~MappableOutput();
22 |   virtual std::shared_ptr<OutputDevice> getDevice() const = 0;
23 | };
24 | 
25 | }// namespace fredemmott::inputmapping
26 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Percent.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cstdint>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | class Percent final {
15 |  private:
16 |   uint8_t mValue;
17 | 
18 |  public:
19 |   explicit Percent(uint8_t value);
20 |   uint8_t value() const noexcept;
21 | };
22 | 
23 | Percent operator"" _percent(unsigned long long value);
24 | 
25 | }// namespace fredemmott::inputmapping
26 | 


--------------------------------------------------------------------------------
/lib/AnyOfButton.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AnyOfButton.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | void AnyOfButton::map(bool pressed) {
14 |   if (pressed) {
15 |     mPressed++;
16 |     if (mPressed == 1) {
17 |       emit(true);
18 |     }
19 |     return;
20 |   }
21 | 
22 |   mPressed--;
23 |   if (mPressed == 0) {
24 |     emit(false);
25 |   }
26 | }
27 | 
28 | }// namespace fredemmott::inputmapping
29 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_cppremapper_executable(
 2 |   test
 3 |   AnyOfButton_test.cpp
 4 |   AxisCurve_test.cpp
 5 |   AxisToButtons_test.cpp
 6 |   AxisToHat_test.cpp
 7 |   AxisTrimmer_test.cpp
 8 |   ButtonToAxis_test.cpp
 9 |   CompositeSink_test.cpp
10 |   FakeClock.cpp
11 |   FunctionSink_test.cpp
12 |   FunctionTransform_test.cpp
13 |   HatToButtons_test.cpp
14 |   LatchedToMomentaryButton_test.cpp
15 |   MomentaryToLatchedButton_test.cpp
16 |   Profile_test.cpp
17 |   Shift_test.cpp
18 |   ShortPressLongPress_test.cpp
19 |   SquareDeadzone_test.cpp
20 |   connections_test.cpp
21 |   test.cpp
22 | )
23 | 
24 | target_link_libraries(
25 |   test
26 |   PRIVATE
27 |   ThirdParty-Catch2
28 |   LibCppRemapper
29 | )
30 | 


--------------------------------------------------------------------------------
/third-party/favhidclient.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | find_package(Git)
 3 | 
 4 | set(FAVHID_REVISION "88f3f8f874b5587f473dd9ae78cb7abb7076d669")
 5 | FetchContent_Declare(
 6 |     favhidclient
 7 |     GIT_REPOSITORY https://github.com/fredemmott/favhid-client.git
 8 |     GIT_TAG main
 9 |     PATCH_COMMAND "${GIT_EXECUTABLE}" reset --hard "${FAVHID_REVISION}"
10 |     EXCLUDE_FROM_ALL
11 | )
12 | 
13 | FetchContent_MakeAvailable(favhidclient)
14 | 
15 | # Build against the same version. Generally a good idea, but especially needed
16 | # for /await compat with the obsolete toolchain on github actions
17 | target_link_libraries(favhid PUBLIC ThirdParty-CppWinRT)
18 | 
19 | add_library(ThirdParty-FAVHIDClient ALIAS favhid)


--------------------------------------------------------------------------------
/tests/tests.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <catch.hpp>
11 | 
12 | #include <cpp-remapper/Source.h>
13 | #include <cpp-remapper/connections.h>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | template <typename TControl>
18 | class TestInput final : public Source<TControl> {
19 |  public:
20 |   using Source<TControl>::emit;
21 | };
22 | using TestAxis = TestInput<Axis>;
23 | using TestButton = TestInput<Button>;
24 | using TestHat = TestInput<Hat>;
25 | 
26 | }// namespace fredemmott::inputmapping
27 | 


--------------------------------------------------------------------------------
/lib/MomentaryToLatchedButton.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/MomentaryToLatchedButton.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | MomentaryToLatchedButton::MomentaryToLatchedButton(bool pressed)
14 |   : mPressed(pressed) {
15 | }
16 | 
17 | MomentaryToLatchedButton::~MomentaryToLatchedButton() {
18 | }
19 | 
20 | void MomentaryToLatchedButton::map(Button::Value value) {
21 |   if (!value) {
22 |     return;
23 |   }
24 |   mPressed = !mPressed;
25 |   emit(mPressed);
26 | }
27 | 
28 | }// namespace fredemmott::inputmapping
29 | 


--------------------------------------------------------------------------------
/tests/AnyOfButton_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AnyOfButton.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("AnyOfButton") {
16 |   AnyOfButton foo;
17 |   bool pressed = false;
18 | 
19 |   foo >> &pressed;
20 | 
21 |   foo.map(true); // 0 -> 1
22 |   REQUIRE(pressed == true);
23 |   foo.map(true); // 1 -> 2
24 |   REQUIRE(pressed == true);
25 |   foo.map(false); // 2 -> 1
26 |   REQUIRE(pressed == true);
27 |   foo.map(false); // 1 -> 0
28 |   REQUIRE(pressed == false);
29 | }
30 | 


--------------------------------------------------------------------------------
/legacy_profiles.cmake:
--------------------------------------------------------------------------------
 1 | option(
 2 |   BUILD_LEGACY_PROFILES
 3 |   "build profiles/ subdirectory"
 4 |   OFF
 5 | )
 6 | 
 7 | if(NOT BUILD_LEGACY_PROFILES)
 8 |   return()
 9 | endif()
10 | 
11 | file(GLOB LEGACY_PROFILES CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/profiles/*.cpp")
12 | 
13 | foreach(PROFILE_SOURCE IN LISTS LEGACY_PROFILES)
14 |   get_filename_component(PROFILE_NAME "${PROFILE_SOURCE}" NAME_WLE)
15 |   message(STATUS "Found legacy profile '${PROFILE_NAME}'")
16 |   set(TARGET "Legacy-Profile-${PROFILE_NAME}")
17 |   add_cppremapper_executable(
18 |     "${TARGET}"
19 |     "${PROFILE_SOURCE}"
20 |   )
21 |   set_target_properties(
22 |     "${TARGET}"
23 |     PROPERTIES
24 |     OUTPUT_NAME "${PROFILE_NAME}"
25 |   )
26 |   target_link_libraries("${TARGET}" PRIVATE LibCppRemapper-compat)
27 | endforeach()
28 | 


--------------------------------------------------------------------------------
/tests/Shift_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/Shift.h>
10 | 
11 | #include <cpp-remapper/MappableVJoyOutput.h>
12 | #include "tests.h"
13 | 
14 | using namespace fredemmott::inputmapping;
15 | 
16 | TEST_CASE("Shift") {
17 |   bool shifted = false;
18 |   TestButton button;
19 |   bool a = false, b = false;
20 | 
21 |   button >> Shift(&shifted, &a, &b);
22 | 
23 |   button.emit(true);
24 |   REQUIRE(a);
25 |   REQUIRE(!b);
26 | 
27 |   button.emit(false);
28 |   REQUIRE(!a);
29 |   REQUIRE(!b);
30 | 
31 |   shifted = true;
32 |   button.emit(true);
33 |   REQUIRE(!a);
34 |   REQUIRE(b);
35 | }
36 | 


--------------------------------------------------------------------------------
/lib/LatchedToMomentaryButton.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/LatchedToMomentaryButton.h>
10 | 
11 | #include <cpp-remapper/Clock.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | LatchedToMomentaryButton::LatchedToMomentaryButton(
16 |   const std::chrono::steady_clock::duration& pressDuration)
17 |   : mPressDuration(pressDuration) {
18 | }
19 | 
20 | LatchedToMomentaryButton::~LatchedToMomentaryButton() {
21 | }
22 | 
23 | void LatchedToMomentaryButton::map(Button::Value value) {
24 |   emit(true);
25 |   Clock::get()->setTimer(mPressDuration, [this]() { emit(false); });
26 | }
27 | 
28 | }// namespace fredemmott::inputmapping
29 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/ViGEmClient.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | // clang-format off
11 | #define WIN32_LEAN_AND_MEAN
12 | #include <windows.h>
13 | #include <ViGEm/Client.h>
14 | // clang-format on
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class ViGEmClient final {
19 |  public:
20 |   ViGEmClient();
21 |   ~ViGEmClient();
22 | 
23 |   operator PVIGEM_CLIENT();
24 |   operator bool();
25 | 
26 |   static ViGEmClient& get();
27 | 
28 |   ViGEmClient(const ViGEmClient&) = delete;
29 |   ViGEmClient& operator=(const ViGEmClient&) = delete;
30 | 
31 |  private:
32 |   PVIGEM_CLIENT p = nullptr;
33 | };
34 | 
35 | }// namespace fredemmott::inputmapping


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/InputDeviceCollection.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/DeviceSpecifier.h>
11 | #include <dinput.h>
12 | 
13 | #include <memory>
14 | #include <vector>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class InputDevice;
19 | 
20 | class InputDeviceCollection {
21 |  public:
22 |   InputDeviceCollection();
23 |   ~InputDeviceCollection();
24 | 
25 |   std::shared_ptr<InputDevice> get(const DeviceSpecifier& device);
26 |   std::vector<std::shared_ptr<InputDevice>> getAllDevices();
27 | 
28 |  private:
29 |   std::vector<std::shared_ptr<InputDevice>> mDevices;
30 | };
31 | 
32 | }// namespace fredemmott::inputmapping
33 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Clock.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <chrono>
11 | #include <functional>
12 | #include <memory>
13 | 
14 | namespace fredemmott::inputmapping {
15 | 
16 | class Clock {
17 |  public:
18 |   virtual ~Clock() = default;
19 |   static std::shared_ptr<Clock> get();
20 |   static void set(const std::shared_ptr<Clock>&);
21 | 
22 |   virtual std::chrono::steady_clock::time_point now() noexcept;
23 | 
24 |   virtual void setTimer(
25 |     const std::chrono::steady_clock::duration& delay,
26 |     const std::function<void()>& handler) noexcept;
27 | 
28 |  protected:
29 |   Clock() = default;
30 | };
31 | 
32 | }// namespace fredemmott::inputmapping
33 | 


--------------------------------------------------------------------------------
/tests/ButtonToAxis_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/ButtonToAxis.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("ButtonToAxis") {
16 |   TestButton button;
17 |   Axis::Value out = -1;
18 |   SECTION("Defaults") {
19 |     button >> ButtonToAxis() >> &out;
20 |     button.emit(false);
21 |     REQUIRE(out == Axis::MIN);
22 |     button.emit(true);
23 |     REQUIRE(out == Axis::MAX);
24 |   }
25 | 
26 |   SECTION("Custom values") {
27 |     button >> ButtonToAxis(42, 1337) >> &out;
28 |     button.emit(false);
29 |     REQUIRE(out == 42);
30 |     button.emit(true);
31 |     REQUIRE(out == 1337);
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/MomentaryToLatchedButton_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/MomentaryToLatchedButton.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("MomentaryToLatchedButton") {
16 | 
17 |   TestButton button;
18 |   Button::Value pressed(false);
19 | 
20 |   button >> MomentaryToLatchedButton() >> &pressed;
21 |   button.emit(true);
22 |   REQUIRE(pressed);
23 |   button.emit(false);
24 |   REQUIRE(pressed);
25 | 
26 |   button.emit(true);
27 |   REQUIRE(!pressed);
28 |   button.emit(false);
29 |   REQUIRE(!pressed);
30 | 
31 |   button.emit(true);
32 |   REQUIRE(pressed);
33 |   button.emit(false);
34 |   REQUIRE(pressed);
35 | }
36 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/ButtonToAxis.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/Source.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | /** Convert a button to an axis.
16 |  *
17 |  * This is useful when binding a button to a virtual X360 trigger.
18 |  */
19 | class ButtonToAxis final : public ButtonSink, public AxisSource {
20 |  private:
21 |   Axis::Value mFalse;
22 |   Axis::Value mTrue;
23 | 
24 |  public:
25 |   ButtonToAxis(
26 |     Axis::Value falseValue = Axis::MIN,
27 |     Axis::Value trueValue = Axis::MAX);
28 |   virtual void map(Button::Value value) override;
29 | };
30 | 
31 | }// namespace fredemmott::inputmapping
32 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MomentaryToLatchedButton.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/Source.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | /** Turn a momentary button into a latched/toggle button.
16 |  */
17 | class MomentaryToLatchedButton final : public Sink<Button>,
18 |                                        public Source<Button> {
19 |  private:
20 |   bool mPressed = false;
21 | 
22 |  public:
23 |   MomentaryToLatchedButton() = default;
24 |   explicit MomentaryToLatchedButton(bool initiallyPressed);
25 |   ~MomentaryToLatchedButton();
26 | 
27 |   virtual void map(Button::Value value) override;
28 | };
29 | 
30 | }// namespace fredemmott::inputmapping
31 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/ClosedPipeline.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Controls.h>
11 | #include <cpp-remapper/maybe_shared_ptr.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | class AnySource;
16 | 
17 | /** A pipeline that takes no input and produces no output.
18 |  *
19 |  * This pipeline starts with a source, ends with a sink, and may
20 |  * contain compatible transformations in between the source and the sink.
21 |  */
22 | class ClosedPipeline final {
23 |  public:
24 |   ClosedPipeline() = delete;
25 |   ClosedPipeline(const maybe_shared_ptr<AnySource>& source) : mSource(source) {
26 |   }
27 | 
28 |  private:
29 |   maybe_shared_ptr<AnySource> mSource;
30 | };
31 | }// namespace fredemmott::inputmapping
32 | 


--------------------------------------------------------------------------------
/tests/FakeClock.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Clock.h>
11 | #include <map>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | class FakeClock : public Clock {
16 |  private:
17 |   std::chrono::steady_clock::time_point mNow;
18 |   std::map<std::chrono::steady_clock::time_point, std::function<void()>> mTimers;
19 | 
20 |  public:
21 |   FakeClock();
22 | 
23 |   void advance(const std::chrono::steady_clock::duration& amount);
24 | 
25 |   virtual std::chrono::steady_clock::time_point now() noexcept override;
26 | 
27 |   virtual void setTimer(
28 |     const std::chrono::steady_clock::duration& delay,
29 |     const std::function<void()>& handler) noexcept override;
30 | };
31 | 
32 | }// namespace fredemmott::inputmapping
33 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/FAVHIDDevice.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/OutputDevice.h>
11 | 
12 | #include <cstdint>
13 | #include <favhid/FAVJoyState2.hpp>
14 | #include <memory>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | /** This is an alternative to VJoy using an
19 |  * Arduino Micro.
20 |  *
21 |  * See https://github.com/fredemmott/favhid
22 |  */
23 | class FAVHIDDevice final : public OutputDevice {
24 |  public:
25 |   FAVHIDDevice() = delete;
26 | 
27 |   FAVHIDDevice(uint8_t id);
28 |   virtual ~FAVHIDDevice();
29 | 
30 |   void set(const FAVHID::FAVJoyState2::Report&);
31 | 
32 |   virtual void flush() override;
33 | 
34 |  private:
35 |   struct Impl;
36 |   std::unique_ptr<Impl> p;
37 | };
38 | 
39 | }// namespace fredemmott::inputmapping


--------------------------------------------------------------------------------
/third-party/cppwinrt.cmake:
--------------------------------------------------------------------------------
 1 | include(ExternalProject)
 2 | 
 3 | ExternalProject_Add(
 4 |   EP_CppWinRT
 5 |   URL "https://github.com/microsoft/cppwinrt/releases/download/2.0.220912.1/Microsoft.Windows.CppWinRT.2.0.220912.1.nupkg"
 6 |   URL_HASH "SHA256=d57e487b4e35d33ac7e808d4b63a664b99802047a8044eadf130e8048668252a"
 7 | 
 8 |   CONFIGURE_COMMAND ""
 9 |   BUILD_COMMAND
10 |   "<SOURCE_DIR>/bin/cppwinrt.exe"
11 |   -in "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}"
12 |   -output "<BINARY_DIR>/include"
13 |   INSTALL_COMMAND ""
14 | 
15 |   EXCLUDE_FROM_ALL
16 | )
17 | message(STATUS "Windows target version: ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}")
18 | 
19 | ExternalProject_Get_property(EP_CppWinRT SOURCE_DIR)
20 | ExternalProject_Get_property(EP_CppWinRT BINARY_DIR)
21 | 
22 | add_library(ThirdParty-CppWinRT INTERFACE)
23 | add_dependencies(ThirdParty-CppWinRT EP_CppWinRT)
24 | target_link_libraries(ThirdParty-CppWinRT INTERFACE "WindowsApp")
25 | target_include_directories(ThirdParty-CppWinRT INTERFACE "${BINARY_DIR}/include")
26 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/FunctionTransform.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <functional>
11 | #include <type_traits>
12 | 
13 | #include <cpp-remapper/Sink.h>
14 | #include <cpp-remapper/Source.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | template <std::derived_from<Control> TIn, std::derived_from<Control> TOut>
19 | class FunctionTransform final : public Sink<TIn>, public Source<TOut> {
20 |  public:
21 |   using Impl = std::function<typename TOut::Value(typename TIn::Value)>;
22 | 
23 |   FunctionTransform() = delete;
24 |   FunctionTransform(const Impl& impl) : impl(impl) {};
25 |   void map(typename TIn::Value value) final override {
26 |     this->emit(impl(value));
27 |   };
28 | 
29 |  private:
30 |   Impl impl;
31 | };
32 | 
33 | }// namespace fredemmott::inputmapping
34 | 


--------------------------------------------------------------------------------
/tests/LatchedToMomentaryButton_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/LatchedToMomentaryButton.h>
10 | 
11 | #include "FakeClock.h"
12 | #include "tests.h"
13 | 
14 | using namespace fredemmott::inputmapping;
15 | 
16 | TEST_CASE("LatchedToMomentaryButton") {
17 |   auto clock = std::make_shared<FakeClock>();
18 |   Clock::set(clock);
19 | 
20 |   TestButton button;
21 |   Button::Value pressed(false);
22 | 
23 |   button >> LatchedToMomentaryButton() >> &pressed;
24 |   button.emit(true);
25 |   REQUIRE(pressed);
26 |   clock->advance(std::chrono::milliseconds(1));
27 |   REQUIRE(pressed);
28 |   clock->advance(std::chrono::seconds(1));
29 |   REQUIRE(!pressed);
30 | 
31 |   button.emit(false);
32 |   REQUIRE(pressed);
33 |   clock->advance(std::chrono::seconds(1));
34 |   REQUIRE(!pressed);
35 | }
36 | 


--------------------------------------------------------------------------------
/third-party/vjoy.cmake:
--------------------------------------------------------------------------------
 1 | include(FetchContent)
 2 | 
 3 | FetchContent_Declare(
 4 |   fcvjoysdk
 5 |   URL "https://github.com/njz3/vJoy/releases/download/v2.2.1.1/vJoy-2.2.1.1-SDK.zip"
 6 |   URL_HASH "SHA256=49afe972e4ecddde86736ccb17463095fb10faea484d40349b88d5e4f416398f"
 7 |   CONFIGURE_COMMAND ""
 8 |   BUILD_COMMAND ""
 9 |   INSTALL_COMMAND ""
10 | )
11 | FetchContent_MakeAvailable(fcvjoysdk)
12 | 
13 | set(VJoy_LIBDIR "${fcvjoysdk_SOURCE_DIR}/lib")
14 | 
15 | if(CMAKE_SIZEOF_VOID_P EQUAL 8)
16 |   set(VJoy_LIBDIR "${VJoy_LIBDIR}/amd64")
17 | else()
18 |   message(WARNING "Use 64-bit builds, it's 2022")
19 | endif()
20 | 
21 | add_library(ThirdParty-VJoy SHARED IMPORTED GLOBAL)
22 | 
23 | set_target_properties(
24 |   ThirdParty-VJoy
25 |   PROPERTIES
26 |   IMPORTED_LOCATION "${VJoy_LIBDIR}/vjoyInterface.dll"
27 |   IMPORTED_IMPLIB "${VJoy_LIBDIR}/vjoyInterface.lib"
28 | )
29 | 
30 | target_include_directories(
31 |   ThirdParty-VJoy
32 |   INTERFACE
33 |   "${fcvjoysdk_SOURCE_DIR}/inc"
34 | )
35 | 
36 | install(IMPORTED_RUNTIME_ARTIFACTS ThirdParty-VJoy)
37 | 


--------------------------------------------------------------------------------
/lib/AxisToButtons.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/AxisToButtons.h>
 9 | 
10 | #include <limits>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | AxisToButtons::AxisToButtons(std::initializer_list<AxisToButtons::Range> ranges)
15 |   : AxisToButtons(std::vector(ranges)) {
16 | }
17 | 
18 | AxisToButtons::AxisToButtons(const std::vector<Range>& ranges) {
19 |   const long max = Axis::MAX;
20 |   for (const auto& range: ranges) {
21 |     mRanges.push_back(
22 |       {(range.min.value() * max) / 100,
23 |        (range.max.value() * max) / 100,
24 |        range.next});
25 |   }
26 | }
27 | 
28 | void AxisToButtons::map(long value) {
29 |   for (auto& range: mRanges) {
30 |     bool active = range.min <= value && range.max >= value;
31 |     range.next->map(active);
32 |   }
33 | }
34 | 
35 | }// namespace fredemmott::inputmapping
36 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AxisInformation.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <string>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | #define AXIS_TYPES AT(X) AT(Y) AT(Z) AT(RX) AT(RY) AT(RZ) AT(SLIDER)
15 | enum class AxisType {
16 | #define AT(x) x,
17 |   AXIS_TYPES
18 | #undef AT
19 | };
20 | 
21 | struct AxisInformation {
22 |   AxisType type;
23 |   std::string name = "Invalid axis type";
24 | 
25 |   AxisInformation() = delete;
26 |   AxisInformation(AxisType type, std::string name) : type(type), name(name) {
27 |   }
28 | 
29 |   AxisInformation(AxisType type) : type(type) {
30 |     switch (type) {
31 | #define AT(x) \
32 |   case AxisType::x: \
33 |     name = #x; \
34 |     break;
35 |       AXIS_TYPES
36 | #undef AT
37 |     }
38 |   }
39 | };
40 | #undef AXIS_TYPES
41 | 
42 | }// namespace fredemmott::inputmapping
43 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright 2020 Fred Emmott
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | 
 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | 


--------------------------------------------------------------------------------
/lib/Clock.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/Clock.h>
 9 | 
10 | #include <cpp-remapper/EventLoop.h>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | namespace {
15 | std::shared_ptr<Clock> g_clock;
16 | }
17 | 
18 | std::shared_ptr<Clock> Clock::get() {
19 |   if (g_clock) {
20 |     return g_clock;
21 |   }
22 |   g_clock.reset(new Clock());
23 |   return g_clock;
24 | }
25 | 
26 | void Clock::set(const std::shared_ptr<Clock>& clock) {
27 |   g_clock = clock;
28 | }
29 | 
30 | std::chrono::steady_clock::time_point Clock::now() noexcept {
31 |   return std::chrono::steady_clock::now();
32 | };
33 | 
34 | void Clock::setTimer(
35 |   const std::chrono::steady_clock::duration& duration,
36 |   const std::function<void()>& handler) noexcept {
37 |   EventLoop::inject(duration, handler);
38 | }
39 | 
40 | }// namespace fredemmott::inputmapping
41 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/ShortPressLongPress.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <chrono>
11 | 
12 | #include <cpp-remapper/SinkPtr.h>
13 | 
14 | namespace fredemmott::inputmapping {
15 | 
16 | /// Different actions for if a button is short-pressed or long-pressed
17 | class ShortPressLongPress : public ButtonSink {
18 |  public:
19 |   ShortPressLongPress(
20 |     ButtonSinkPtr short_handler,
21 |     ButtonSinkPtr long_handle,
22 |     const std::chrono::steady_clock::duration duration
23 |     = std::chrono::milliseconds(300));
24 |   virtual void map(Button::Value state) override;
25 | 
26 |  private:
27 |   ButtonSinkPtr mShortPress;
28 |   ButtonSinkPtr mLongPress;
29 |   std::chrono::steady_clock::duration mLongDuration;
30 | 
31 |   std::chrono::time_point<std::chrono::steady_clock> mStart;
32 | };
33 | 
34 | }// namespace fredemmott::inputmapping
35 | 


--------------------------------------------------------------------------------
/example.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include "easymode.h"
 9 | 
10 | int main() {
11 |   auto [p, throttle, stick, vj1, vj2, x360, ds4] = create_profile(
12 |     VPC_MT50CM3_THROTTLE,
13 |     VPC_RIGHT_WARBRD,
14 |     VJOY_1,
15 |     VJOY_2,
16 |     VIGEM_X360_PAD,
17 |     VIGEM_DS4_PAD);
18 | 
19 |   // Copy all inputs to outputs
20 |   throttle >> vj1;
21 |   stick >> vj2;
22 | 
23 |   // Copy axis to virtual gamepads: throttle and twist on left stick, stick xy
24 |   // on right stick
25 |   throttle.RXAxis >> all(vj1.RXAxis, x360.LYAxis, ds4.LYAxis);
26 |   stick.ZAxis >> all(vj2.ZAxis, x360.LXAxis, ds4.LXAxis);
27 | 
28 |   stick.XAxis >> all(vj2.XAxis, x360.RXAxis, ds4.RXAxis);
29 |   stick.YAxis >> all(vj2.YAxis, x360.RYAxis, ds4.RYAxis);
30 | 
31 |   // Test at least one button works :)
32 |   stick.Button3 >> all(vj1.Button1, x360.ButtonA, ds4.ButtonCross);
33 |   p.run();
34 |   return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | BasedOnStyle: Google
 2 | AlignAfterOpenBracket: AlwaysBreak
 3 | AlignConsecutiveDeclarations: 'false'
 4 | AlignEscapedNewlinesLeft: DontAlign
 5 | AlignOperands: 'false'
 6 | AlignTrailingComments: 'false'
 7 | AllowAllParametersOfDeclarationOnNextLine: 'false'
 8 | AllowShortBlocksOnASingleLine: 'false'
 9 | AllowShortFunctionsOnASingleLine: false
10 | AllowShortIfStatementsOnASingleLine: 'false'
11 | AllowShortLoopsOnASingleLine: 'false'
12 | BinPackArguments: 'false'
13 | BinPackParameters: 'false'
14 | BreakBeforeBinaryOperators: 'true'
15 | ColumnLimit: '80'
16 | ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
17 | ConstructorInitializerIndentWidth: '2'
18 | ContinuationIndentWidth: '2'
19 | DeriveLineEnding: false
20 | DerivePointerAlignment: false
21 | IndentRequires: true
22 | IndentWidth: '2'
23 | MaxEmptyLinesToKeep: '1'
24 | PointerAlignment: Left
25 | ReflowComments: true
26 | SpaceBeforeCpp11BracedList: 'true'
27 | SpaceBeforeAssignmentOperators: 'true'
28 | SpaceBeforeRangeBasedForLoopColon: 'false'
29 | SpacesBeforeTrailingComments: '0'
30 | Standard: c++20
31 | TabWidth: '2'
32 | UseCRLF: false
33 | UseTab: Never
34 | 


--------------------------------------------------------------------------------
/tests/FakeClock.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include "FakeClock.h"
 9 | 
10 | namespace fredemmott::inputmapping {
11 | 
12 | FakeClock::FakeClock() {
13 |   mNow = std::chrono::steady_clock::now();
14 | }
15 | 
16 | void FakeClock::advance(const std::chrono::steady_clock::duration& amount) {
17 |   mNow += amount;
18 |   for (auto it = mTimers.begin(); it != mTimers.end(); /* nothing */) {
19 |     auto [when, handler] = *it;
20 |     if (when > mNow) {
21 |       ++it;
22 |       continue;
23 |     }
24 |     handler();
25 |     it = mTimers.erase(it);
26 |   }
27 | }
28 | 
29 | std::chrono::steady_clock::time_point FakeClock::now() noexcept {
30 |   return mNow;
31 | }
32 | 
33 | void FakeClock::setTimer(
34 |   const std::chrono::steady_clock::duration& delay,
35 |   const std::function<void()>& handler) noexcept {
36 |   mTimers.emplace(mNow + delay, handler);
37 | }
38 | 
39 | }// namespace fredemmott::inputmapping
40 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/easymode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/AnyOfButton.h>
11 | #include <cpp-remapper/AxisCurve.h>
12 | #include <cpp-remapper/AxisToButtons.h>
13 | #include <cpp-remapper/AxisToHat.h>
14 | #include <cpp-remapper/AxisTrimmer.h>
15 | #include <cpp-remapper/ButtonToAxis.h>
16 | #include <cpp-remapper/CompositeSink.h>
17 | #include <cpp-remapper/EventLoop.h>
18 | #include <cpp-remapper/HatToButtons.h>
19 | #include <cpp-remapper/LatchedToMomentaryButton.h>
20 | #include <cpp-remapper/MomentaryToLatchedButton.h>
21 | #include <cpp-remapper/Profile.h>
22 | #include <cpp-remapper/Shift.h>
23 | #include <cpp-remapper/ShortPressLongPress.h>
24 | #include <cpp-remapper/SquareDeadzone.h>
25 | #include <cpp-remapper/connections.h>
26 | #include <cpp-remapper/devicedb.h>
27 | 
28 | using namespace fredemmott::inputmapping::devicedb;
29 | using namespace fredemmott::inputmapping;
30 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AxisCurve.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/Source.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | /** A simple curve with tuneable 'curviness'.
16 |  *
17 |  * - Curviness is >= -1 and < 1
18 |  * - Curviness of 0 no curve, i.e. a straight line
19 |  * - Curviness of 0.9999999 is a very slightly rounded right angle corner
20 |  * - You probably want curvature between 0 and 1; 0.5 is a good starting point.
21 |  *   This makes the axis less sensitive near center, more sensitive when fully
22 |  *   deflective. A negative curviness gives you the opposite.
23 |  */
24 | class AxisCurve final : public AxisSource, public AxisSink {
25 |  public:
26 |   AxisCurve(double curviness);
27 |   virtual ~AxisCurve();
28 |   void map(long value);
29 | 
30 |  private:
31 |   double mCurviness;
32 | };
33 | 
34 | }// namespace fredemmott::inputmapping
35 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/EventLoop.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <chrono>
11 | #include <functional>
12 | #include <map>
13 | #include <memory>
14 | #include <vector>
15 | 
16 | namespace fredemmott::inputmapping {
17 | class EventSink;
18 | class EventSource;
19 | 
20 | class EventLoop final {
21 |  public:
22 |   void setEventSinks(const std::vector<std::shared_ptr<EventSink>>& sinks);
23 |   void setEventSources(
24 |     const std::vector<std::shared_ptr<EventSource>>& sources);
25 | 
26 |   void run();
27 | 
28 |   static void inject(
29 |     const std::chrono::steady_clock::duration& delay,
30 |     const std::function<void()>& handler);
31 | 
32 |  private:
33 |   std::vector<std::shared_ptr<EventSource>> mEventSources;
34 |   std::vector<std::shared_ptr<EventSink>> mEventSinks;
35 |   std::map<void*, std::function<void()>> mInjected;
36 | 
37 |   void flush();
38 | };
39 | }// namespace fredemmott::inputmapping
40 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/VJoyDevice.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/OutputDevice.h>
11 | 
12 | #include <cstdint>
13 | #include <memory>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | class VJoyDevice final : public OutputDevice {
18 |  public:
19 |   VJoyDevice(uint8_t id);
20 |   ~VJoyDevice();
21 | 
22 |   virtual void flush() override;
23 | 
24 |   VJoyDevice* setXAxis(long value);
25 |   VJoyDevice* setYAxis(long value);
26 |   VJoyDevice* setZAxis(long value);
27 |   VJoyDevice* setRXAxis(long value);
28 |   VJoyDevice* setRYAxis(long value);
29 |   VJoyDevice* setRZAxis(long value);
30 |   VJoyDevice* setSlider(long value);
31 |   VJoyDevice* setDial(long value);
32 | 
33 |   VJoyDevice* setButton(uint8_t button, bool value);
34 |   VJoyDevice* setHat(uint8_t hat, uint16_t value);
35 | 
36 |  private:
37 |   struct Impl;
38 |   std::unique_ptr<Impl> p;
39 | };
40 | 
41 | }// namespace fredemmott::inputmapping
42 | 


--------------------------------------------------------------------------------
/lib/AxisTrimmer.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/AxisTrimmer.h>
 9 | 
10 | #include <algorithm>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | void AxisTrimmer::map(Axis::Value v) {
15 |   mValue = v;
16 |   update();
17 | }
18 | 
19 | void AxisTrimmer::update() {
20 |   if (mTrimming) {
21 |     return;
22 |   }
23 |   emit(std::clamp(mValue + mOffset, Axis::MIN, Axis::MAX));
24 | }
25 | 
26 | void AxisTrimmer::trim(bool pressed) {
27 |   if (pressed) {
28 |     mTrimming = true;
29 |     mStartValue = mValue;
30 |     return;
31 |   }
32 | 
33 |   if (!mTrimming) {
34 |     return;
35 |   }
36 | 
37 |   mTrimming = false;
38 | 
39 |   mOffset += mStartValue - mValue;
40 | 
41 |   constexpr auto max_offset = Axis::MID + 1;
42 |   mOffset = std::clamp(mOffset, -max_offset, max_offset);
43 | 
44 |   update();
45 | }
46 | 
47 | void AxisTrimmer::reset() {
48 |   mOffset = 0;
49 |   update();
50 | }
51 | 
52 | }// namespace fredemmott::inputmapping
53 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/FunctionSink.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <functional>
11 | 
12 | #include <cpp-remapper/Sink.h>
13 | #include <cpp-remapper/function_traits.h>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | template <typename TControl>
18 | class FunctionSink : public Sink<TControl> {
19 |  public:
20 |   using Impl = std::function<void(typename TControl::Value)>;
21 |   FunctionSink() = delete;
22 |   FunctionSink(const Impl& impl) : impl(impl) {};
23 |   virtual void map(typename TControl::Value value) override {
24 |     impl(value);
25 |   }
26 | 
27 |  private:
28 |   Impl impl;
29 | };
30 | 
31 | // clang-format off
32 | template<typename T, typename TControl>
33 | concept sink_invocable =
34 |   std::is_base_of_v<Control, TControl>
35 |   && std::invocable<T, typename TControl::Value>
36 |   && detail::exact_signature<T, void(typename TControl::Value)>;
37 | // clang-format on
38 | 
39 | }// namespace fredemmott::inputmapping
40 | 


--------------------------------------------------------------------------------
/utilities/list-devices.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/InputDevice.h>
 9 | #include <cpp-remapper/InputDeviceCollection.h>
10 | 
11 | #include <cstdio>
12 | 
13 | int main() {
14 |   fredemmott::inputmapping::InputDeviceCollection idc;
15 |   for (const auto& device: idc.getAllDevices()) {
16 |     auto name = device->getProductName();
17 |     printf("\"%s\"\n", name.data());
18 | 
19 |     printf(
20 |       "  Axes: %d\n  Buttons: %d\n  Hats: %d\n",
21 |       device->getAxisCount(),
22 |       device->getButtonCount(),
23 |       device->getHatCount());
24 | 
25 |     auto vidpid = device->getVIDPID();
26 |     if (vidpid) {
27 |       auto buf = vidpid->getHumanReadable();
28 |       printf("  %s\n", buf.c_str());
29 |     }
30 | 
31 |     auto iid = device->getInstanceID().getHumanReadable();
32 |     printf("  %s\n", iid.c_str());
33 | 
34 |     auto hid = device->getHardwareID().getHumanReadable();
35 |     printf("  %s\n", hid.c_str());
36 |   }
37 |   return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableX360Output.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/MappableOutput.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | 
13 | #include <cstdint>
14 | #include <memory>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class X360Device;
19 | 
20 | class MappableX360Output final : public MappableOutput {
21 |  public:
22 |   explicit MappableX360Output();
23 |   MappableX360Output(std::shared_ptr<X360Device> dev);
24 |   ~MappableX360Output();
25 | 
26 |   std::shared_ptr<OutputDevice> getDevice() const override;
27 | 
28 |   const AxisSinkPtr LXAxis, LYAxis, LTrigger, RXAxis, RYAxis, RTrigger;
29 | 
30 |   const ButtonSinkPtr ButtonA, ButtonB, ButtonX, ButtonY, ButtonBack,
31 |     ButtonStart, ButtonGuide, DPadUp, DPadDown, DPadLeft, DPadRight,
32 |     ButtonLStick, ButtonRStick, ButtonLShoulder, ButtonRShoulder;
33 | 
34 |  private:
35 |   std::shared_ptr<X360Device> mDevice;
36 | };
37 | 
38 | }// namespace fredemmott::inputmapping
39 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/LatchedToMomentaryButton.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <chrono>
11 | 
12 | #include <cpp-remapper/Sink.h>
13 | #include <cpp-remapper/Source.h>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | /** Turn a button that is maintained/latched on or off into a button that
18 |  * triggers whenever the state changes.
19 |  *
20 |  * This is useful if a game has a binding for 'toggle on/off', but your
21 |  * device has a latching on switch.
22 |  */
23 | class LatchedToMomentaryButton final : public Sink<Button>,
24 |                                        public Source<Button> {
25 |  public:
26 |   LatchedToMomentaryButton(
27 |     const std::chrono::steady_clock::duration& pressDuration
28 |     = std::chrono::milliseconds(50));
29 |   ~LatchedToMomentaryButton();
30 |   virtual void map(Button::Value value) override;
31 | 
32 |  private:
33 |   const std::chrono::steady_clock::duration mPressDuration;
34 | };
35 | 
36 | }// namespace fredemmott::inputmapping
37 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AnyOfButton.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | #include <cpp-remapper/Source.h>
13 | #include <cpp-remapper/SourcePtr.h>
14 | #include <cpp-remapper/connections.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class AnyOfButton final : public Sink<Button>, public Source<Button> {
19 |  private:
20 |   uint16_t mPressed = 0;
21 | 
22 |  public:
23 |   virtual void map(bool pressed) override;
24 | };
25 | 
26 | template <typename First, typename... Rest>
27 | auto any(First&& first, Rest&&... rest) {
28 |   std::vector<ButtonSourcePtr> inners {
29 |     std::forward<First>(first), std::forward<Rest>(rest)...};
30 |   auto impl = std::make_shared<AnyOfButton>();
31 |   auto as_sink = std::static_pointer_cast<ButtonSink>(impl);
32 |   for (auto& inner: inners) {
33 |     inner >> as_sink;
34 |   }
35 |   return std::static_pointer_cast<ButtonSource>(impl);
36 | }
37 | 
38 | }// namespace fredemmott::inputmapping
39 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | on: [push, pull_request]
 3 | jobs:
 4 |   build:
 5 |     name: Build
 6 |     runs-on: windows-latest
 7 |     strategy:
 8 |       fail-fast: false
 9 |       matrix:
10 |         mode: [ RelWithDebInfo, Debug ]
11 |         compiler: [ cl, clang]
12 |         platform: [ x86, x64 ]
13 |     steps:
14 |       - name: Checkout
15 |         uses: actions/checkout@v3
16 |       - name: Configure
17 |         run: |
18 |           $CMakeArgs = @()
19 | 
20 |           if ("${{matrix.compiler}}" -eq "clang") {
21 |             $CMakeArgs += @("-T","ClangCL")
22 |           }
23 |           if ("${{matrix.platform}}" -eq "x86") {
24 |             $CMakeArgs += @("-A","Win32")
25 |           }
26 |           mkdir build
27 |           cd build
28 |           Write-Output("Running: cmake .. @CMakeArgs")
29 |           cmake .. @CMakeArgs
30 |       - name: Build
31 |         working-directory: build
32 |         run: cmake --build . --config ${{matrix.mode}} --parallel
33 |       - name: Install
34 |         working-directory: build
35 |         run: cmake --install . --config ${{matrix.mode}} --prefix ${{runner.temp}}/install
36 |       - name: Run tests
37 |         working-directory: ${{runner.temp}}/install
38 |         run: bin/test.exe
39 | 


--------------------------------------------------------------------------------
/lib/AxisToHat.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #define _USE_MATH_DEFINES
10 | #include <cpp-remapper/AxisToHat.h>
11 | 
12 | #include <cmath>
13 | 
14 | namespace fredemmott::inputmapping {
15 | 
16 | const Percent AxisToHat::DEFAULT_DEADZONE = 90_percent;
17 | 
18 | AxisToHat::AxisToHat(Percent deadzone) : mDeadzone(deadzone) {
19 | }
20 | 
21 | AxisToHat::~AxisToHat() {
22 | }
23 | 
24 | void AxisToHat::update() {
25 |   // Recenter around (0, 0)
26 |   const auto x = mX - Axis::MID;
27 |   const auto y = mY - Axis::MID;
28 | 
29 |   // Treat deadzone as combined distance to center - same amount of
30 |   // needed for corners.
31 |   const auto distance = sqrt((x * x) + (y * y));
32 |   if ((distance * 100) / Hat::CENTER < mDeadzone.value() / 2) {
33 |     emit(Hat::CENTER);
34 |     return;
35 |   }
36 | 
37 |   const auto radians = atan2(y, x);
38 |   const auto centidegrees = std::lround((18000 * radians) / M_PI) + 9000;
39 |   emit(centidegrees < 0 ? centidegrees + 36000 : centidegrees);
40 | }
41 | 
42 | }// namespace fredemmott::inputmapping
43 | 


--------------------------------------------------------------------------------
/utilities/render.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | // This file is an executable, intended to generate illustrative diagrams
10 | // of some basic axis mapping operations
11 | 
12 | #include <cpp-remapper/AxisCurve.h>
13 | #include <cpp-remapper/easymode.h>
14 | #include <cpp-remapper/render_axis.h>
15 | 
16 | using fredemmott::inputmapping::maybe_shared_ptr;
17 | using fredemmott::inputmapping::render_axis;
18 | using fredemmott::inputmapping::Sink;
19 | using fredemmott::inputmapping::Source;
20 | 
21 | int main() {
22 |   render_axis("linear.bmp", [](Axis::Value next) { return next; });
23 |   render_axis("curve_0.bmp", AxisCurve(0));
24 |   render_axis("curve_0.5.bmp", AxisCurve(0.5));
25 |   render_axis("curve_neg0.5.bmp", AxisCurve(-0.5));
26 |   render_axis("curve_0.99.bmp", AxisCurve(0.99));
27 |   render_axis("dead_10.bmp", SquareDeadzone(10_percent));
28 | 
29 |   render_axis("dead_curve.bmp", SquareDeadzone(50_percent) >> AxisCurve(0.5));
30 |   render_axis("curve_dead.bmp", AxisCurve(0.5) >> SquareDeadzone(50_percent));
31 |   return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Sink.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Controls.h>
11 | 
12 | #include <concepts>
13 | #include <functional>
14 | #include <type_traits>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class AnySource;
19 | class AnySink {};
20 | 
21 | template <std::derived_from<Control> TControl>
22 | class Sink : public AnySink {
23 |  protected:
24 |   Sink() = default;
25 | 
26 |  public:
27 |   virtual ~Sink() = default;
28 |   using InControl = TControl;
29 |   using In = typename TControl::Value;
30 |   virtual void map(In value) = 0;
31 | };
32 | using AxisSink = Sink<Axis>;
33 | using ButtonSink = Sink<Button>;
34 | using HatSink = Sink<Hat>;
35 | 
36 | // clang-format off
37 | template<typename T>
38 | concept any_sink =
39 |   (!std::derived_from<T, AnySource>)
40 |   && std::derived_from<T, AnySink>;
41 | 
42 | template<typename T, typename TControl>
43 | concept sink =
44 |   any_sink<T>
45 |   && std::derived_from<T, Sink<TControl>>;
46 | // clang-format on
47 | 
48 | }// namespace fredemmott::inputmapping
49 | 


--------------------------------------------------------------------------------
/tests/ShortPressLongPress_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/ShortPressLongPress.h>
10 | 
11 | #include "FakeClock.h"
12 | #include "tests.h"
13 | 
14 | using namespace fredemmott::inputmapping;
15 | 
16 | TEST_CASE("ShortPressLongPress") {
17 |   auto clock = std::make_shared<FakeClock>();
18 |   Clock::set(clock);
19 | 
20 |   TestButton button;
21 |   Button::Value b1(false), b2(false);
22 | 
23 |   button >> ShortPressLongPress(&b1, &b2);
24 |   SECTION("Short Press") {
25 |     button.emit(true);
26 |     clock->advance(std::chrono::milliseconds(1));
27 |     REQUIRE(!b1);
28 |     REQUIRE(!b2);
29 |     button.emit(false);
30 |     REQUIRE(b1);
31 |     REQUIRE(!b2);
32 |     clock->advance(std::chrono::seconds(1));
33 |     REQUIRE(!b1);
34 |   }
35 | 
36 |   SECTION("Long Press") {
37 |     button.emit(true);
38 |     clock->advance(std::chrono::seconds(10));
39 |     button.emit(false);
40 |     REQUIRE(!b1);
41 |     REQUIRE(b2);
42 |     clock->advance(std::chrono::seconds(1));
43 |     REQUIRE(!b1);
44 |     REQUIRE(!b2);
45 |   }
46 | }
47 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AxisToHat.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cstdint>
11 | 
12 | #include <cpp-remapper/Percent.h>
13 | #include <cpp-remapper/SinkPtr.h>
14 | #include <cpp-remapper/Source.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | /** Converts two axis to a continuous (360-degree) hat.
19 |  *
20 |  * Deflections > 327.67 degrees will not be shown correctly in the Windows
21 |  * test app - use "Monitor vJoy" instead.
22 |  */
23 | class AxisToHat final : public HatSource {
24 |  public:
25 |   static const Percent DEFAULT_DEADZONE;
26 | 
27 |   AxisSinkPtr XAxis = [this](Axis::Value x) {
28 |     mX = x;
29 |     update();
30 |   };
31 |   AxisSinkPtr YAxis = [this](Axis::Value y) {
32 |     mY = y;
33 |     update();
34 |   };
35 | 
36 |   AxisToHat(Percent deadzone_percent = DEFAULT_DEADZONE);
37 |   ~AxisToHat();
38 | 
39 |  private:
40 |   Percent mDeadzone = DEFAULT_DEADZONE;
41 |   Axis::Value mX = Axis::MID;
42 |   Axis::Value mY = Axis::MID;
43 | 
44 |   void update();
45 | };
46 | 
47 | }// namespace fredemmott::inputmapping
48 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/CompositeSink.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | 
13 | #include <concepts>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | template <typename TControl>
18 | class CompositeSink final : public Sink<TControl> {
19 |  public:
20 |   CompositeSink(std::vector<SinkPtr<TControl>> sinks) : mSinks(sinks) {
21 |   }
22 | 
23 |   virtual void map(typename TControl::Value value) override {
24 |     for (auto& inner: mSinks) {
25 |       inner->map(value);
26 |     }
27 |   };
28 | 
29 |  private:
30 |   std::vector<SinkPtr<TControl>> mSinks;
31 | };
32 | 
33 | template <convertible_to_any_sink_ptr TFirst, typename... TRest>
34 | auto all(TFirst&& first, TRest&&... rest) {
35 |   auto first_ptr = convert_to_any_sink_ptr(std::forward<TFirst>(first));
36 |   using TControl = typename decltype(first_ptr)::element_type::InControl;
37 |   return CompositeSink<TControl>(
38 |     {first_ptr, convert_to_any_sink_ptr(std::forward<TRest>(rest))...});
39 | }
40 | 
41 | }// namespace fredemmott::inputmapping
42 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/SourcePipeline.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | 
12 | #include <cpp-remapper/Controls.h>
13 | #include <cpp-remapper/Sink.h>
14 | #include <cpp-remapper/Source.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | /** A pipeline that takes no input, but produces output.
19 |  *
20 |  * This starts with a source, and may also contain transformations that are
21 |  * applied to the pipeline's output.
22 |  */
23 | template <std::derived_from<Control> TControl>
24 | class SourcePipeline final : public Source<TControl> {
25 |  public:
26 |   SourcePipeline() = delete;
27 | 
28 |   SourcePipeline(
29 |     const maybe_shared_ptr<AnySource>& first,
30 |     const maybe_shared_ptr<Source<TControl>>& last)
31 |     : mFirst(first), mLast(last) {};
32 | 
33 |   virtual void setNext(const maybe_shared_ptr<Sink<TControl>>& next) override {
34 |     mLast->setNext(next);
35 |   }
36 | 
37 |  private:
38 |   maybe_shared_ptr<AnySource> mFirst;
39 |   maybe_shared_ptr<Source<TControl>> mLast;
40 | };
41 | 
42 | }// namespace fredemmott::inputmapping
43 | 


--------------------------------------------------------------------------------
/lib/connections.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/MappableFAVHIDOutput.h>
 9 | #include <cpp-remapper/MappableInput.h>
10 | #include <cpp-remapper/MappableVJoyOutput.h>
11 | #include <cpp-remapper/connections.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | namespace detail {
16 | template <class T>
17 | void AssignVJoyLike(MappableInput& s, const T& t) {
18 |   s.XAxis >> t.XAxis;
19 |   s.YAxis >> t.YAxis;
20 |   s.ZAxis >> t.ZAxis;
21 |   s.RXAxis >> t.RXAxis;
22 |   s.RYAxis >> t.RYAxis;
23 |   s.RZAxis >> t.RZAxis;
24 |   s.Slider >> t.Slider;
25 |   s.Dial >> t.Dial;
26 |   for (int i = 1; i <= s.getButtonCount(); ++i) {
27 |     s.button(i) >> t.button(i);
28 |   }
29 |   for (int i = 1; i <= s.getHatCount(); ++i) {
30 |     s.hat(i) >> t.hat(i);
31 |   }
32 | }
33 | }// namespace detail
34 | 
35 | void operator>>(MappableInput& s, const MappableFAVHIDOutput& t) {
36 |   detail::AssignVJoyLike(s, t);
37 | }
38 | 
39 | void operator>>(MappableInput& s, const MappableVJoyOutput& t) {
40 |   detail::AssignVJoyLike(s, t);
41 | }
42 | 
43 | }// namespace fredemmott::inputmapping
44 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/SinkPipeline.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <type_traits>
12 | 
13 | #include <cpp-remapper/Controls.h>
14 | #include <cpp-remapper/Sink.h>
15 | #include <cpp-remapper/SinkPtr.h>
16 | #include <cpp-remapper/maybe_shared_ptr.h>
17 | 
18 | namespace fredemmott::inputmapping {
19 | 
20 | /** A pipeline that receives input, but produces no output.
21 |  *
22 |  * This is the tail end of a pipeline; it ends with a sink,
23 |  * but may also contain transformations that are applied
24 |  * to values before they reach that sink.
25 |  */
26 | template <std::derived_from<Control> TControl>
27 | class SinkPipeline final : public Sink<TControl> {
28 |   static_assert(std::is_base_of_v<Control, TControl>);
29 | 
30 |  public:
31 |   SinkPipeline() = delete;
32 |   SinkPipeline(const SinkPtr<TControl>& first) : mFirst(first) {
33 |   }
34 | 
35 |   void map(typename TControl::Value value) override {
36 |     mFirst->map(value);
37 |   };
38 | 
39 |  private:
40 |   maybe_shared_ptr<Sink<TControl>> mFirst;
41 | };
42 | 
43 | }// namespace fredemmott::inputmapping
44 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/render_axis.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/FunctionTransform.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | #include <cpp-remapper/SourcePtr.h>
13 | #include <cpp-remapper/TransformPtr.h>
14 | 
15 | #include <functional>
16 | #include <string>
17 | #include <type_traits>
18 | 
19 | namespace fredemmott::inputmapping {
20 | 
21 | void render_axis(
22 |   const std::string& bmp_filename,
23 |   AxisSinkPtr transform_in,
24 |   AxisSourcePtr transform_out);
25 | 
26 | template <transform_ptr<Axis, Axis> T>
27 | void render_axis(const std::string& bmp_filename, const T& transform) {
28 |   render_axis(bmp_filename, transform, transform);
29 | }
30 | 
31 | template <transform<Axis, Axis> T>
32 | void render_axis(const std::string& bmp_filename, T&& transform) {
33 |   render_axis(bmp_filename, transform, transform);
34 | }
35 | 
36 | template <transform_invocable<Axis, Axis> T>
37 | void render_axis(const std::string& bmp_filename, const T& func) {
38 |   auto t = std::make_shared<FunctionTransform<Axis, Axis>>(func);
39 |   render_axis(bmp_filename, t, t);
40 | }
41 | 
42 | }// namespace fredemmott::inputmapping
43 | 


--------------------------------------------------------------------------------
/lib/SquareDeadzone.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #define _NO_MIN_MAX
 9 | #include <cpp-remapper/SquareDeadzone.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | SquareDeadzone::SquareDeadzone(const Percent& percent)
14 |   : mPercent(percent.value()) {
15 | }
16 | 
17 | SquareDeadzone::~SquareDeadzone() {
18 | }
19 | 
20 | void SquareDeadzone::map(long value) {
21 |   // Re-scale to 100x to avoid dividing by 100 all over the place when dealing
22 |   // with percentages
23 |   value *= 100;
24 |   const uint32_t MAX = 0xffff * 100;
25 |   const uint32_t MID = MAX / 2;
26 |   const uint32_t DEAD = (mPercent * MID) / 100;
27 |   if (value > (MID - DEAD) && value < (MID + DEAD)) {
28 |     emit(MID / 100);
29 |     return;
30 |   }
31 |   const uint32_t NEW_MAX = MAX - (2 * DEAD);
32 |   const uint32_t without_deadzone = (value < MID) ? value : value - (2 * DEAD);
33 |   // We end up with a temporary where the value is multiplied by 100 * MAX
34 |   // * NEW_MAX; if the percentage is large, this overflows the uint32
35 |   const uint32_t scaled = (without_deadzone * (uint64_t)MAX) / NEW_MAX;
36 |   emit(scaled / 100);
37 | }
38 | 
39 | }// namespace fredemmott::inputmapping
40 | 


--------------------------------------------------------------------------------
/lib/AxisCurve.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/AxisCurve.h>
 9 | 
10 | #include <cmath>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | AxisCurve::AxisCurve(double curviness) : mCurviness(curviness) {
15 | }
16 | 
17 | AxisCurve::~AxisCurve() {
18 | }
19 | 
20 | void AxisCurve::map(long value) {
21 |   // Normalize between -1 to 1
22 |   //
23 |   // the raw range is 0-0xffff with 0x7fff as 'neutral', which means
24 |   // there (0xffff - 0x7fff = 0x8000) possible positive values, but
25 |   // (0x7fff - 0 = 0x7fff) negative values.
26 |   //
27 |   // This level of accuracy doesn't usually matter, but some games care
28 |   // about actually reaching min and max values
29 |   const auto scale = value > 0x7fff ? 0x8000 : 0x7fff;
30 | 
31 |   const double x = (value - 0x7fff) / (double)scale;
32 |   const double k = mCurviness;
33 |   // This is based on
34 |   // https://dinodini.wordpress.com/2010/04/05/normalized-tunable-sigmoid-functions/
35 |   const auto fx = (x - (x * k)) / (k - (abs(x) * 2 * k) + 1);
36 | 
37 |   const auto clamped = fx > 1.0 ? 1.0 : (fx < -1.0 ? -1.0 : fx);
38 | 
39 |   emit((clamped * scale) + 0x7fff);
40 | }
41 | 
42 | }// namespace fredemmott::inputmapping
43 | 


--------------------------------------------------------------------------------
/tests/AxisToHat_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AxisToHat.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("AxisToHat") {
16 |   TestAxis x, y;
17 |   Hat::Value hat;
18 |   AxisToHat ath;
19 |   // TODO: tuple assignments?
20 |   x >> ath.XAxis;
21 |   y >> ath.YAxis;
22 |   ath >> &hat;
23 | 
24 |   // verify that both axis default to cente
25 |   x.emit(Axis::MID);
26 |   REQUIRE(hat == Hat::CENTER);
27 |   ath = AxisToHat();
28 |   ath >> &hat;
29 |   x.emit(Axis::MID);
30 |   REQUIRE(hat == Hat::CENTER);
31 | 
32 |   y.emit(Axis::MIN);
33 |   REQUIRE(hat == Hat::NORTH);
34 | 
35 |   x.emit(Axis::MIN);
36 |   REQUIRE(hat == Hat::NORTH_WEST);
37 | 
38 |   x.emit(Axis::MAX);
39 |   REQUIRE(hat == Hat::NORTH_EAST);
40 | 
41 |   y.emit(Axis::MID);
42 |   REQUIRE(hat == Hat::EAST);
43 | 
44 |   x.emit(Axis::MID);
45 |   REQUIRE(hat == Hat::CENTER);
46 | 
47 |   x.emit(Axis::MIN);
48 |   REQUIRE(hat == Hat::WEST);
49 | 
50 |   y.emit(Axis::MAX);
51 |   REQUIRE(hat == Hat::SOUTH_WEST);
52 | 
53 |   x.emit(Axis::MID);
54 |   REQUIRE(hat == Hat::SOUTH);
55 | 
56 |   x.emit(Axis::MAX);
57 |   REQUIRE(hat == Hat::SOUTH_EAST);
58 | }
59 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableDS4Output.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cstdint>
11 | #include <memory>
12 | 
13 | #include <cpp-remapper/MappableOutput.h>
14 | #include <cpp-remapper/SinkPtr.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class DS4Device;
19 | 
20 | class MappableDS4Output final : public MappableOutput {
21 |  public:
22 |   explicit MappableDS4Output();
23 |   MappableDS4Output(std::shared_ptr<DS4Device> dev);
24 |   ~MappableDS4Output();
25 | 
26 |   std::shared_ptr<OutputDevice> getDevice() const override;
27 | 
28 |   const AxisSinkPtr LXAxis, LYAxis, LTrigger, RXAxis, RYAxis, RTrigger;
29 | 
30 |   const ButtonSinkPtr ButtonTriangle, ButtonCircle, ButtonCross, ButtonSquare,
31 |     ButtonLTrigger, ButtonRTrigger, ButtonLShoulder, ButtonRShoulder,
32 |     ButtonOptions, ButtonShare;
33 | 
34 |   const ButtonSinkPtr ButtonPS, ButtonTouchPad;
35 | 
36 |   const ButtonSinkPtr ButtonDPadNorth, ButtonDPadNorthEast, ButtonDPadEast,
37 |     ButtonDPadSouthEast, ButtonDPadSouth, ButtonDPadSouthWest, ButtonDPadWest,
38 |     ButtonDPadNorthWest;
39 | 
40 |  private:
41 |   std::shared_ptr<DS4Device> mDevice;
42 | };
43 | 
44 | }// namespace fredemmott::inputmapping
45 | 


--------------------------------------------------------------------------------
/lib/ShortPressLongPress.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/ShortPressLongPress.h>
 9 | 
10 | #include <cpp-remapper/Clock.h>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | namespace {
15 | const std::chrono::milliseconds INJECTED_PRESS_DURATION(100);
16 | }
17 | 
18 | ShortPressLongPress::ShortPressLongPress(
19 |   ButtonSinkPtr s,
20 |   ButtonSinkPtr l,
21 |   std::chrono::steady_clock::duration long_duration)
22 |   : mShortPress(s), mLongPress(l), mLongDuration(long_duration) {
23 | }
24 | 
25 | void ShortPressLongPress::map(bool pressed) {
26 |   const auto clock = Clock::get();
27 |   const auto now = clock->now();
28 |   if (pressed) {
29 |     mStart = now;
30 |     return;
31 |   }
32 | 
33 |   // Check for default-constructed invalid value
34 |   if (mStart == std::chrono::steady_clock::time_point()) {
35 |     return;
36 |   }
37 | 
38 |   if (now - mStart < mLongDuration) {
39 |     mShortPress->map(true);
40 |     clock->setTimer(
41 |       INJECTED_PRESS_DURATION, [=]() { mShortPress->map(false); });
42 |   } else {
43 |     mLongPress->map(true);
44 |     clock->setTimer(INJECTED_PRESS_DURATION, [=]() { mLongPress->map(false); });
45 |   }
46 | }
47 | 
48 | }// namespace fredemmott::inputmapping
49 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Shift.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | template <control T>
16 | class Shift : public Sink<T> {
17 |  private:
18 |   bool* mShifted = nullptr;
19 |   SinkPtr<T> mA, mB;
20 | 
21 |  public:
22 |   template <convertible_to_sink_ptr<T> A, convertible_to_sink_ptr<T> B>
23 |   Shift(bool* shifted, A&& a, B&& b)
24 |     : mShifted(shifted),
25 |       mA(convert_to_any_sink_ptr(std::forward<A>(a))),
26 |       mB(convert_to_any_sink_ptr(std::forward<B>(b))) {
27 |   }
28 | 
29 |   virtual void map(typename T::Value value) override {
30 |     auto next = *mShifted ? mB : mA;
31 |     next->map(value);
32 |   }
33 | };
34 | 
35 | // Help template inference along a bit...
36 | 
37 | template <convertible_to_sink_ptr<Axis> A, convertible_to_sink_ptr<Axis> B>
38 | Shift(bool*, A, B) -> Shift<Axis>;
39 | 
40 | template <convertible_to_sink_ptr<Button> A, convertible_to_sink_ptr<Button> B>
41 | Shift(bool*, A, B) -> Shift<Button>;
42 | 
43 | template <convertible_to_sink_ptr<Hat> A, convertible_to_sink_ptr<Hat> B>
44 | Shift(bool*, A, B) -> Shift<Hat>;
45 | 
46 | }// namespace fredemmott::inputmapping
47 | 


--------------------------------------------------------------------------------
/lib/ViGEmClient.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/ViGEmClient.h>
 9 | 
10 | #include <iostream>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | namespace {
15 | ViGEmClient g_client;
16 | }
17 | 
18 | ViGEmClient::ViGEmClient() {
19 | }
20 | ViGEmClient::~ViGEmClient() {
21 |   if (!p) {
22 |     return;
23 |   }
24 |   std::cout << "Disconnecting from ViGEm bus..." << std::endl;
25 |   vigem_disconnect(p);
26 |   vigem_free(p);
27 |   std::cout << "...disconnected." << std::endl;
28 | }
29 | 
30 | ViGEmClient::operator PVIGEM_CLIENT() {
31 |   if (p) {
32 |     return p;
33 |   }
34 |   p = vigem_alloc();
35 | 
36 |   if (!p) {
37 |     std::cerr << "Failed to allocate ViGEmClient" << std::endl;
38 |     return nullptr;
39 |   }
40 | 
41 |   auto ret = vigem_connect(p);
42 |   if (!VIGEM_SUCCESS(ret)) {
43 |     std::cerr << "ViGEm Bus connection failed with error code: 0x" << std::hex
44 |               << ret << std::endl;
45 |     vigem_free(p);
46 |     p = nullptr;
47 |     return nullptr;
48 |   }
49 | 
50 |   return p;
51 | }
52 | 
53 | ViGEmClient::operator bool() {
54 |   return this->operator PVIGEM_CLIENT();
55 | }
56 | 
57 | ViGEmClient& ViGEmClient::get() {
58 |   return g_client;
59 | };
60 | 
61 | }// namespace fredemmott::inputmapping
62 | 


--------------------------------------------------------------------------------
/tests/AxisCurve_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AxisCurve.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("AxisCurve") {
16 |   long out = -1;
17 | 
18 |   TestAxis linear;
19 |   linear >> AxisCurve {0} >> &out;
20 | 
21 |   linear.emit(0);
22 |   REQUIRE(out == 0);
23 |   linear.emit(0xffff);
24 |   REQUIRE(out == 0xffff);
25 |   linear.emit(0x7fff);
26 |   REQUIRE(out == 0x7fff);
27 |   linear.emit(0x1234);
28 |   REQUIRE(out == 0x1234);
29 | 
30 |   TestAxis extreme;
31 |   extreme >> AxisCurve {0.99} >> &out;
32 | 
33 |   extreme.emit(0);
34 |   REQUIRE(out == 0);
35 |   extreme.emit(0xffff);
36 |   REQUIRE(out == 0xffff);
37 |   extreme.emit(0x7fff);
38 |   REQUIRE(out == 0x7fff);
39 |   extreme.emit(0x4000);
40 |   REQUIRE((out > 0x4000 && out < 0x7fff));
41 |   extreme.emit(0x7fff + 0x4000);
42 |   REQUIRE((out > 0x7fff && out < (0x7ffff + 0x4000)));
43 | 
44 |   TestAxis gentle;
45 |   gentle >> AxisCurve {0.5} >> &out;
46 |   extreme.emit(0x4000);
47 |   const auto extreme_out = out;
48 |   gentle.emit(0x4000);
49 |   REQUIRE((out > 0x4000 && out < 0x7fff));
50 |   // As 0x4000 is less than the midpoint, the smaller number has the most
51 |   // deflection
52 |   REQUIRE(out < extreme_out);
53 | }
54 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Controls.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <cstdint>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | class Control {};
16 | 
17 | class Axis final : public Control {
18 |  public:
19 |   using Value = long;
20 |   static const Value MAX = 0xffff;
21 |   static const Value MIN = 0;
22 |   // Not called 'center' because that's misleading for sliders.
23 |   static const Value MID = MAX / 2;
24 | };
25 | 
26 | class Button final : public Control {
27 |  public:
28 |   using Value = bool;
29 | };
30 | 
31 | class Hat final : public Control {
32 |  public:
33 |   using Value = uint16_t;
34 |   static const Value MAX = 35999;
35 |   static const Value MIN = 0;
36 |   static const Value CENTER = 0xffff;
37 | 
38 |   static const Value NORTH = 0;
39 |   static const Value NORTH_EAST = 4500;
40 |   static const Value EAST = 9000;
41 |   static const Value SOUTH_EAST = 13500;
42 |   static const Value SOUTH = 18000;
43 |   static const Value SOUTH_WEST = 22500;
44 |   static const Value WEST = 27000;
45 |   static const Value NORTH_WEST = 31500;
46 | };
47 | 
48 | template <class T>
49 | concept control
50 |   = std::same_as<Axis, T> || std::same_as<Button, T> || std::same_as<Hat, T>;
51 | 
52 | }// namespace fredemmott::inputmapping
53 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/ViGEmTarget.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/ViGEmClient.h>
 9 | 
10 | #include <concepts>
11 | #include <iostream>
12 | 
13 | #include <cpp-remapper/DS4Device.h>
14 | 
15 | namespace fredemmott::inputmapping::detail {
16 | 
17 | template <typename TState, typename TDerived>
18 | class ViGEmTarget {
19 |  public:
20 |   TState state;
21 |   PVIGEM_TARGET pad = nullptr;
22 | 
23 |   ViGEmTarget() {
24 |     TDerived::initState(&state);
25 |     auto& client = ViGEmClient::get();
26 |     if (!client) {
27 |       return;
28 |     }
29 |     pad = TDerived::allocTarget();
30 |     auto ret = vigem_target_add(client, pad);
31 |     if (!VIGEM_SUCCESS(ret)) {
32 |       vigem_target_free(pad);
33 |       pad = nullptr;
34 |       std::cerr << "Failed to plug ViGEm " << TDerived::productShortName()
35 |                 << ": 0x" << std::hex << ret << std::endl;
36 |     }
37 |   }
38 | 
39 |   ~ViGEmTarget() {
40 |     if (!pad) {
41 |       return;
42 |     }
43 |     std::cout << "Unplugging ViGEm " << TDerived::productShortName() << "..."
44 |               << std::endl;
45 |     vigem_target_remove(ViGEmClient::get(), pad);
46 |     vigem_target_free(pad);
47 |     std::cout << "...unplugged." << std::endl;
48 |   }
49 | };
50 | 
51 | }// namespace fredemmott::inputmapping::detail
52 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/function_traits.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <tuple>
12 | 
13 | namespace fredemmott::inputmapping::detail {
14 | 
15 | template <typename T>
16 | struct function_traits : public function_traits<decltype(&T::operator())> {};
17 | 
18 | template <typename TClass, typename TRet, typename... TArgs>
19 | struct function_traits<TRet (TClass::*)(TArgs...) const>
20 |   : public function_traits<TRet(TArgs...)> {};
21 | 
22 | template <typename TRet, typename... TArgs>
23 | struct function_traits<TRet(TArgs...)> {
24 |   using ReturnType = TRet;
25 |   using Signature = TRet(TArgs...);
26 |   using ArgTypes = std::tuple<TArgs...>;
27 |   template <std::size_t N>
28 |   using ArgType = std::tuple_element_t<N, ArgTypes>;
29 |   using FirstArg = ArgType<0>;
30 | };
31 | 
32 | template <typename T, typename TSignature>
33 | concept exact_signature
34 |   = std::same_as<TSignature, typename function_traits<T>::Signature>;
35 | 
36 | template <typename T, typename... TArgs>
37 | concept exact_arguments = std::same_as < std::tuple<TArgs...>,
38 | typename function_traits<T>::ArgTypes > ;
39 | 
40 | template <typename T, typename TRet>
41 | concept exact_return_type
42 |   = std::same_as<TRet, typename function_traits<T>::ReturnType>;
43 | 
44 | }// namespace fredemmott::inputmapping::detail
45 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/SquareDeadzone.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cstdint>
11 | 
12 | #include <cpp-remapper/Percent.h>
13 | #include <cpp-remapper/Sink.h>
14 | #include <cpp-remapper/Source.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | /** A simple deadzone for a single axis.
19 |  *
20 |  * Values less than x% are ignored. Larger values are scaled to still report as
21 |  * 0-100%; this leads to a loss of precision.
22 |  *
23 |  * For example, if you set a 50% dead zone, 50% deflection will be reported as
24 |  * 0%, 75% as 50%, and 100% as 100%. This means that once you reach 50%, each
25 |  * 1% change is reported as 2%, so the precision is half.
26 |  *
27 |  * As the original precision is reported out of 32767, this is unlikely to be a
28 |  * practical concern, but you probably don't want to chain a bunch of deadzones
29 |  * as this effect compounds.
30 |  *
31 |  * While this deadzone action only operates on a single axis at a time, if you
32 |  * apply to both the X and Y axis, you end up with a square dead zone :)
33 |  */
34 | class SquareDeadzone : public AxisSink, public AxisSource {
35 |  public:
36 |   SquareDeadzone(const Percent& percent);
37 |   virtual ~SquareDeadzone();
38 |   virtual void map(Axis::Value value) override;
39 | 
40 |  private:
41 |   uint8_t mPercent;
42 | };
43 | 
44 | }// namespace fredemmott::inputmapping
45 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AxisTrimmer.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/Sink.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | #include <cpp-remapper/Source.h>
13 | 
14 | namespace fredemmott::inputmapping {
15 | 
16 | /** Recenter an axis by pressing and holding a button.
17 |  *
18 |  * Any movement is ignored while the button is pressed; trim is adjusted by the
19 |  * position difference between where the button was pressed and where it was
20 |  * released.
21 |  *
22 |  * For example, if you move the joystick to (100, 100), press the button, center
23 |  * the stick, then release the button, when centered, the joystick will report
24 |  * (100, 100); if you then move to (100, 100), it will report (200, 200).
25 |  *
26 |  * Trim is limited to half of the axis range.
27 |  */
28 | class AxisTrimmer final : public Source<Axis>, public Sink<Axis> {
29 |  private:
30 |  public:
31 |   const ButtonSinkPtr ResetButton = [this](bool _) { reset(); };
32 |   const ButtonSinkPtr TrimButton = [this](bool pressed) { trim(pressed); };
33 | 
34 |   void map(Axis::Value v) override;
35 | 
36 |  private:
37 |   void update();
38 |   void trim(bool pressed);
39 |   void reset();
40 | 
41 |   Axis::Value mValue = Axis::MID;
42 |   Axis::Value mOffset = 0;
43 | 
44 |   bool mTrimming = false;
45 |   Axis::Value mStartValue = 0;
46 | };
47 | 
48 | }// namespace fredemmott::inputmapping
49 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/TransformPipeline.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <type_traits>
12 | 
13 | #include <cpp-remapper/Controls.h>
14 | #include <cpp-remapper/Sink.h>
15 | #include <cpp-remapper/SinkPtr.h>
16 | #include <cpp-remapper/Source.h>
17 | #include <cpp-remapper/SourcePtr.h>
18 | #include <cpp-remapper/maybe_shared_ptr.h>
19 | 
20 | namespace fredemmott::inputmapping {
21 | 
22 | /** A pipeline that is open at both ends.
23 |  *
24 |  * It receives an input, and produces an output (potentially of a different
25 |  * type).
26 |  *
27 |  * It starts with a sink, ends with a source, and may contain additional
28 |  * transformations.
29 |  */
30 | template <std::derived_from<Control> TIn, std::derived_from<Control> TOut>
31 | class TransformPipeline final : public Sink<TIn>, public Source<TOut> {
32 |  public:
33 |   TransformPipeline() = delete;
34 |   TransformPipeline(const SinkPtr<TIn>& first, const SourcePtr<TOut>& last)
35 |     : mFirst(first), mLast(last) {
36 |   }
37 | 
38 |   virtual void setNext(const maybe_shared_ptr<Sink<TIn>>& next) override {
39 |     mLast->setNext(next);
40 |   }
41 | 
42 |   virtual void map(typename TIn::Value value) override {
43 |     mFirst->map(value);
44 |   }
45 | 
46 |  private:
47 |   maybe_shared_ptr<Sink<TIn>> mFirst;
48 |   maybe_shared_ptr<Source<TOut>> mLast;
49 | };
50 | 
51 | }// namespace fredemmott::inputmapping
52 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/devicedb.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/InputDevice.h>
11 | 
12 | namespace fredemmott::inputmapping::devicedb {
13 | const VIDPID TM_WARTHOG_THROTTLE {0x044f, 0x0404};
14 | const VIDPID TM_TPR {0x044f, 0xb68f};
15 | const HardwareID VPC_LEFT_WARBRD {"HID\\VID_3344&PID_80CC&Col01"};
16 | const HardwareID VPC_RIGHT_WARBRD {"HID\\VID_3344&PID_40CC&Col01"};
17 | const HardwareID VPC_MT50CM3_THROTTLE {"HID\\VID_3344&PID_0194&Col01"};
18 | const HardwareID VPC_MT50CM2_SHARKA_CYCLIC {"HID\\VID_3344&PID_012E&Col01"};
19 | const HardwareID VPC_MT50CM2_TM_STICK {"HID\\VID_03EB&PID_2045"};
20 | const HardwareID VPC_ROTOR_TCS_PLUS {"HID\\VID_3344&PID_02C3&Col01"};
21 | 
22 | // Useful either for interacting with other software, or for hiding unused VJoy
23 | // devices
24 | const HardwareID VJOY_1_IN {"HID\\HIDCLASS&Col01"},
25 |   VJOY_2_IN {"HID\\HIDCLASS&Col02"}, VJOY_3_IN {"HID\\HIDCLASS&Col03"},
26 |   VJOY_4_IN {"HID\\HIDCLASS&Col04"}, VJOY_5_IN {"HID\\HIDCLASS&Col05"},
27 |   VJOY_6_IN {"HID\\HIDCLASS&Col06"}, VJOY_7_IN {"HID\\HIDCLASS&Col07"},
28 |   VJOY_8_IN {"HID\\HIDCLASS&Col08"}, VJOY_9_IN {"HID\\HIDCLASS&Col09"},
29 |   VJOY_10_IN {"HID\\HIDCLASS&Col10"}, VJOY_11_IN {"HID\\HIDCLASS&Col11"},
30 |   VJOY_12_IN {"HID\\HIDCLASS&Col12"}, VJOY_13_IN {"HID\\HIDCLASS&Col13"},
31 |   VJOY_14_IN {"HID\\HIDCLASS&Col14"}, VJOY_15_IN {"HID\\HIDCLASS&Col15"},
32 |   VJOY_16_IN {"HID\\HIDCLASS&Col16"};
33 | }// namespace fredemmott::inputmapping::devicedb
34 | 


--------------------------------------------------------------------------------
/lib/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | add_library(
 2 |   LibCppRemapper
 3 |   STATIC
 4 |   AnyOfButton.cpp
 5 |   AxisCurve.cpp
 6 |   AxisInformation.cpp
 7 |   AxisToButtons.cpp
 8 |   AxisToHat.cpp
 9 |   AxisTrimmer.cpp
10 |   ButtonToAxis.cpp
11 |   Clock.cpp
12 |   DS4Device.cpp
13 |   DeviceSpecifier.cpp
14 |   EventLoop.cpp
15 |   EventSink.cpp
16 |   EventSource.cpp
17 |   FAVHIDDevice.cpp
18 |   HatToButtons.cpp
19 |   HidHide.cpp
20 |   InputDevice.cpp
21 |   InputDeviceCollection.cpp
22 |   LatchedToMomentaryButton.cpp
23 |   MappableDS4Output.cpp
24 |   MappableFAVHIDOutput.cpp
25 |   MappableInput.cpp
26 |   MappableOutput.cpp
27 |   MappableVJoyOutput.cpp
28 |   MappableX360Output.cpp
29 |   MomentaryToLatchedButton.cpp
30 |   Percent.cpp
31 |   Profile.cpp
32 |   ShortPressLongPress.cpp
33 |   Source.cpp
34 |   SquareDeadzone.cpp
35 |   VJoyDevice.cpp
36 |   ViGEmClient.cpp
37 |   X360Device.cpp
38 |   connections.cpp
39 |   render_axis.cpp
40 | )
41 | target_link_libraries(
42 |   LibCppRemapper
43 |   PRIVATE
44 |   ThirdParty-FAVHIDClient
45 |   ThirdParty-ViGEmClient
46 |   ThirdParty-VJoy
47 | )
48 | target_link_libraries(
49 |   LibCppRemapper
50 |   PUBLIC
51 |   ThirdParty-CppWinRT
52 | )
53 | target_include_directories(
54 |   LibCppRemapper
55 |   PUBLIC
56 |   "${CMAKE_CURRENT_SOURCE_DIR}/include"
57 | )
58 | target_compile_definitions(
59 |   LibCppRemapper
60 |   PUBLIC
61 |   "DIRECTINPUT_VERSION=0x0800"
62 | )
63 | 
64 | install(TARGETS LibCppRemapper LIBRARY)
65 | install(DIRECTORY include/cpp-remapper TYPE INCLUDE)
66 | add_library(LibCppRemapper-compat INTERFACE)
67 | target_link_libraries(LibCppRemapper-compat INTERFACE LibCppRemapper)
68 | target_include_directories(
69 |   LibCppRemapper-compat
70 |   INTERFACE
71 |   "${CMAKE_CURRENT_SOURCE_DIR}/include/cpp-remapper"
72 | )
73 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 2 | cmake_policy(SET CMP0135 NEW)
 3 | 
 4 | option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 5 | 
 6 | # Enable CMAKE_MSVC_RUNTIME_LIBRARY variable
 7 | cmake_policy(SET CMP0091 NEW)
 8 | 
 9 | set(
10 |   CMAKE_MSVC_RUNTIME_LIBRARY
11 |   "MultiThreaded$<$<CONFIG:Debug>:Debug>"
12 | )
13 | add_link_options(
14 |   "/DEFAULTLIB:ucrt$<$<CONFIG:Debug>:d>.lib" # include the dynamic UCRT
15 |   "/NODEFAULTLIB:libucrt$<$<CONFIG:Debug>:d>.lib" # remove the static UCRT 
16 | )
17 | 
18 | set(VERSION_BUILD 0 CACHE STRING "Build component of the version number")
19 | project(cpp-remapper VERSION 0.4.0.${VERSION_BUILD} LANGUAGES CXX)
20 | 
21 | set(CMAKE_CXX_STANDARD 20)
22 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
23 | set(CMAKE_CXX_EXTENSIONS OFF)
24 | 
25 | # - Use ASAN for debug builds
26 | # - statically link to statically link the ASAN runtime
27 | if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" AND NOT $ENV{GITHUB_RUN_NUMBER})
28 |   add_compile_options(
29 |     "$<$<CONFIG:Debug>:/fsanitize=address>"
30 |     "$<$<CONFIG:Debug>:/MTd>"
31 |   )
32 | endif()
33 | 
34 | function(add_cppremapper_executable TARGET)
35 |   add_executable(${TARGET} ${ARGN} "${CMAKE_SOURCE_DIR}/lib/manifest.xml")
36 |   target_link_libraries(
37 |     "${TARGET}"
38 |     PRIVATE
39 |     LibCppRemapper
40 |   )
41 |   add_custom_command(
42 |     TARGET "${TARGET}"
43 |     POST_BUILD
44 |     COMMAND
45 |     "${CMAKE_COMMAND}"
46 |     -E copy
47 |     "$<TARGET_RUNTIME_DLLS:${TARGET}>"
48 |     "$<TARGET_FILE_DIR:${TARGET}>"
49 |   )
50 |   install(TARGETS "${TARGET}")
51 | endfunction()
52 | 
53 | add_subdirectory(third-party)
54 | add_subdirectory(lib)
55 | add_subdirectory(utilities)
56 | add_subdirectory(tests)
57 | 
58 | include(legacy_profiles.cmake)
59 | 


--------------------------------------------------------------------------------
/lib/FAVHIDDevice.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/FAVHIDDevice.h>
 9 | 
10 | #include <format>
11 | #include <iostream>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | namespace {
16 | uint8_t gDeviceCount {};
17 | std::optional<FAVHID::FAVJoyState2> gArduino;
18 | 
19 | void InitializeFAVHID() {
20 |   if (gArduino) {
21 |     return;
22 |   }
23 | 
24 |   gArduino = FAVHID::FAVJoyState2::Open(gDeviceCount);
25 |   if (!gArduino) {
26 |     std::cerr << "Failed to initalize FAVHID Arduino" << std::endl;
27 |   }
28 | }
29 | 
30 | }// namespace
31 | 
32 | struct FAVHIDDevice::Impl final {
33 |   uint8_t mID {};
34 |   FAVHID::FAVJoyState2::Report mReport;
35 | };
36 | 
37 | FAVHIDDevice::FAVHIDDevice(uint8_t id) {
38 |   if (id >= FAVHID::FAVJoyState2::MAX_DEVICES) {
39 |     std::cerr << std::format(
40 |       "Ignoring FAVHIDDevice because requested ID {} >= MAX_DEVICES {}",
41 |       id,
42 |       FAVHID::FAVJoyState2::MAX_DEVICES)
43 |               << std::endl;
44 |     return;
45 |   }
46 | 
47 |   p.reset(new Impl {.mID = id, .mReport = {}});
48 |   gDeviceCount = std::max<uint8_t>(gDeviceCount, id + 1);
49 | }
50 | FAVHIDDevice::~FAVHIDDevice() = default;
51 | 
52 | void FAVHIDDevice::set(const FAVHID::FAVJoyState2::Report& report) {
53 |   if (!p) {
54 |     return;
55 |   }
56 |   p->mReport = report;
57 | }
58 | 
59 | void FAVHIDDevice::flush() {
60 |   if (!p) {
61 |     return;
62 |   }
63 |   InitializeFAVHID();
64 |   if (!gArduino) {
65 |     return;
66 |   }
67 |   gArduino->WriteReport(p->mReport, p->mID);
68 | }
69 | 
70 | }// namespace fredemmott::inputmapping
71 | 


--------------------------------------------------------------------------------
/lib/MappableX360Output.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/AxisInformation.h>
 9 | #include <cpp-remapper/InputDevice.h>
10 | #include <cpp-remapper/MappableX360Output.h>
11 | #include <cpp-remapper/X360Device.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | MappableX360Output::MappableX360Output()
16 |   : MappableX360Output(std::make_shared<X360Device>()) {
17 | }
18 | 
19 | MappableX360Output::MappableX360Output(std::shared_ptr<X360Device> dev)
20 |   :
21 | #define A(a) a([dev](long value) { dev->set##a(value); })
22 | #define AA(a) A(a##Axis)
23 |     AA(LX),
24 |     AA(LY),
25 |     A(LTrigger),
26 |     AA(RX),
27 |     AA(RY),
28 |     A(RTrigger),
29 | #undef AA
30 | #undef A
31 | #define B(name, enum) \
32 |   name([dev](bool value) { dev->setButton(X360Device::Button::enum, value); })
33 | #define BB(x) B(Button##x, x)
34 |     BB(A),
35 |     BB(B),
36 |     BB(X),
37 |     BB(Y),
38 | #undef BB
39 | #define BB(name, enum) B(Button##name, enum)
40 |     BB(Back, BACK),
41 |     BB(Start, START),
42 |     BB(Guide, GUIDE),
43 |     B(DPadUp, DPAD_UP),
44 |     B(DPadDown, DPAD_DOWN),
45 |     B(DPadLeft, DPAD_LEFT),
46 |     B(DPadRight, DPAD_RIGHT),
47 |     BB(LStick, LEFT_STICK),
48 |     BB(RStick, RIGHT_STICK),
49 |     BB(LShoulder, LEFT_SHOULDER),
50 |     BB(RShoulder, RIGHT_SHOULDER),
51 | #undef BB
52 | #undef B
53 |     mDevice(dev) {
54 | }
55 | 
56 | MappableX360Output::~MappableX360Output() {
57 | }
58 | 
59 | std::shared_ptr<OutputDevice> MappableX360Output::getDevice() const {
60 |   return mDevice;
61 | }
62 | 
63 | }// namespace fredemmott::inputmapping
64 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Source.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | 
12 | #include <cpp-remapper/Controls.h>
13 | #include <cpp-remapper/Sink.h>
14 | #include <cpp-remapper/maybe_shared_ptr.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | // Just so we can store a shared_ptr without worrying about the inner generics
19 | class AnySource {
20 |  protected:
21 |   AnySource() = default;
22 | 
23 |  public:
24 |   virtual ~AnySource();
25 | };
26 | 
27 | template <std::derived_from<Control> TControl>
28 | class Source : public AnySource {
29 |  public:
30 |   using OutControl = TControl;
31 |   using Out = typename TControl::Value;
32 | 
33 |   virtual void setNext(const maybe_shared_ptr<Sink<TControl>>& next) {
34 |     mNext = next;
35 |   }
36 | 
37 |   Out value() const {
38 |     return mValue;
39 |   }
40 | 
41 |  protected:
42 |   void emit(Out value) {
43 |     if (!mNext.isValid()) {
44 |       return;
45 |     }
46 |     mValue = value;
47 |     mNext->map(value);
48 |   }
49 | 
50 |  private:
51 |   maybe_shared_ptr<Sink<TControl>> mNext;
52 |   Out mValue;
53 | };
54 | 
55 | using AxisSource = Source<Axis>;
56 | using ButtonSource = Source<Button>;
57 | using HatSource = Source<Hat>;
58 | 
59 | // clang-format off
60 | template<typename T>
61 | concept any_source =
62 |   std::derived_from<T, AnySource>
63 |   && (!std::derived_from<T, AnySink>);
64 | 
65 | template<typename T, typename TControl>
66 | concept source =
67 |   any_source<T>
68 |   && std::derived_from<T, Source<TControl>>;
69 | // clang-format on
70 | 
71 | }// namespace fredemmott::inputmapping
72 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/X360Device.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/OutputDevice.h>
11 | 
12 | #include <cstdint>
13 | #include <memory>
14 | 
15 | // clang-format off
16 | #define WIN32_LEAN_AND_MEAN
17 | #include <windows.h>
18 | #include <ViGEm/Client.h>
19 | // clang-format on
20 | 
21 | namespace fredemmott::inputmapping {
22 | 
23 | class X360Device final : public OutputDevice {
24 |  public:
25 |   X360Device();
26 |   ~X360Device();
27 | 
28 |   X360Device(const X360Device&) = delete;
29 |   X360Device& operator=(const X360Device&) = delete;
30 | 
31 |   virtual void flush() override;
32 | 
33 |   enum class Button {
34 |     DPAD_UP = XUSB_GAMEPAD_DPAD_UP,
35 |     DPAD_DOWN = XUSB_GAMEPAD_DPAD_DOWN,
36 |     DPAD_LEFT = XUSB_GAMEPAD_DPAD_LEFT,
37 |     DPAD_RIGHT = XUSB_GAMEPAD_DPAD_RIGHT,
38 |     START = XUSB_GAMEPAD_START,
39 |     BACK = XUSB_GAMEPAD_BACK,
40 |     LEFT_STICK = XUSB_GAMEPAD_LEFT_THUMB,
41 |     RIGHT_STICK = XUSB_GAMEPAD_RIGHT_THUMB,
42 |     LEFT_SHOULDER = XUSB_GAMEPAD_LEFT_SHOULDER,
43 |     RIGHT_SHOULDER = XUSB_GAMEPAD_RIGHT_SHOULDER,
44 |     GUIDE = XUSB_GAMEPAD_GUIDE,
45 |     A = XUSB_GAMEPAD_A,
46 |     B = XUSB_GAMEPAD_B,
47 |     X = XUSB_GAMEPAD_X,
48 |     Y = XUSB_GAMEPAD_Y
49 |   };
50 | 
51 |   X360Device* setButton(Button button, bool value);
52 |   X360Device* setLXAxis(long value);
53 |   X360Device* setLYAxis(long value);
54 |   X360Device* setRXAxis(long value);
55 |   X360Device* setRYAxis(long value);
56 |   X360Device* setLTrigger(long value);
57 |   X360Device* setRTrigger(long value);
58 | 
59 |  private:
60 |   class Impl;
61 |   std::unique_ptr<Impl> p;
62 | };
63 | 
64 | }// namespace fredemmott::inputmapping
65 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/AxisToButtons.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cstdint>
11 | #include <vector>
12 | 
13 | #include <cpp-remapper/Percent.h>
14 | #include <cpp-remapper/SinkPtr.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class AxisToButtons final : public AxisSink {
19 |  public:
20 |   struct Range {
21 |     Percent min;
22 |     Percent max;
23 |     ButtonSinkPtr next;
24 |   };
25 | 
26 |   AxisToButtons(const std::vector<Range>& ranges);
27 |   AxisToButtons(std::initializer_list<Range> ranges);
28 | 
29 |   // clang-format off
30 |   template <typename First, convertible_to_sink_ptr<Button>... Rest>
31 |   requires
32 |     // clang needs this as the first constraint on First to avoid a
33 |     // template/concept recursion bug
34 |     (!std::same_as<AxisToButtons, std::decay_t<First>>)
35 |     && convertible_to_sink_ptr<First, Button>
36 |   // clang-format on
37 |   AxisToButtons(First&& first, Rest... rest) {
38 |     std::vector<ButtonSinkPtr> buttons {
39 |       convert_to_any_sink_ptr(std::forward<First>(first)),
40 |       convert_to_any_sink_ptr(std::forward<Rest>(rest))...};
41 |     const auto step = ((long double)Axis::MAX) / buttons.size();
42 |     for (auto i = 0; i < buttons.size(); ++i) {
43 |       mRanges.push_back(
44 |         {std::lround(i * step) + (i == 0 ? 0 : 1),
45 |          std::lround((i + 1) * step),
46 |          buttons[i]});
47 |     }
48 |   }
49 | 
50 |   virtual void map(long value) override;
51 | 
52 |  private:
53 |   struct RawRange {
54 |     Axis::Value min;
55 |     Axis::Value max;
56 |     ButtonSinkPtr next;
57 |   };
58 |   std::vector<RawRange> mRanges;
59 | };
60 | 
61 | }// namespace fredemmott::inputmapping
62 | 


--------------------------------------------------------------------------------
/lib/InputDeviceCollection.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/InputDeviceCollection.h>
 9 | 
10 | #include <cpp-remapper/AxisInformation.h>
11 | #include <cpp-remapper/InputDevice.h>
12 | #pragma comment(lib, "Ole32.lib")// GUID
13 | 
14 | namespace fredemmott::inputmapping {
15 | 
16 | namespace {
17 | struct DeviceEnumeratorState {
18 |   IDirectInput8* di8;
19 |   std::vector<std::shared_ptr<InputDevice>> devices;
20 | };
21 | 
22 | BOOL CALLBACK
23 | enum_device_callback(LPCDIDEVICEINSTANCE didevinst, LPVOID vpRef) {
24 |   auto state = reinterpret_cast<DeviceEnumeratorState*>(vpRef);
25 |   auto device = std::make_shared<InputDevice>(state->di8, didevinst);
26 |   state->devices.push_back(device);
27 | 
28 |   return DIENUM_CONTINUE;
29 | }
30 | 
31 | IDirectInput8* gDI8 = nullptr;
32 | }// namespace
33 | 
34 | InputDeviceCollection::InputDeviceCollection() {
35 |   if (!gDI8) {
36 |     DirectInput8Create(
37 |       GetModuleHandle(nullptr),
38 |       DIRECTINPUT_VERSION,
39 |       IID_IDirectInput8,
40 |       (LPVOID*)&gDI8,
41 |       nullptr);
42 |   }
43 |   auto di8 = gDI8;
44 |   DeviceEnumeratorState state {di8, {}};
45 |   di8->EnumDevices(
46 |     DI8DEVCLASS_GAMECTRL, &enum_device_callback, &state, DIEDFL_ATTACHEDONLY);
47 |   mDevices = state.devices;
48 | }
49 | 
50 | std::shared_ptr<InputDevice> InputDeviceCollection::get(
51 |   const DeviceSpecifier& id) {
52 |   for (auto device: mDevices) {
53 |     if (id.matches(*device)) {
54 |       return device;
55 |     }
56 |   }
57 |   return nullptr;
58 | }
59 | 
60 | std::vector<std::shared_ptr<InputDevice>>
61 | InputDeviceCollection::getAllDevices() {
62 |   return mDevices;
63 | }
64 | 
65 | InputDeviceCollection::~InputDeviceCollection() {
66 | }
67 | 
68 | }// namespace fredemmott::inputmapping
69 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/maybe_shared_ptr.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <memory>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | namespace detail {
16 | template <typename T>
17 | concept decay_equiv = std::same_as<T, std::decay_t<T>>;
18 | 
19 | template <typename T>
20 | concept container = requires(T) {
21 |   typename T::element_type;
22 | };
23 | 
24 | template <typename T>
25 | concept maybe_shared_ptr_target
26 |   = std::same_as<T, std::decay_t<T>> && !container<T>;
27 | }// namespace detail
28 | 
29 | template <detail::maybe_shared_ptr_target T>
30 | class maybe_shared_ptr {
31 |   template <detail::maybe_shared_ptr_target U>
32 |   friend class maybe_shared_ptr;
33 | 
34 |   T* p {nullptr};
35 |   std::shared_ptr<T> refcounted;
36 | 
37 |  public:
38 |   using element_type = T;
39 | 
40 |   maybe_shared_ptr() {
41 |   }
42 | 
43 |   explicit maybe_shared_ptr(T* impl) : p(impl) {
44 |   }
45 | 
46 |   template <std::derived_from<T> TSubtype>
47 |   maybe_shared_ptr(const std::shared_ptr<TSubtype>& impl)
48 |     : p(impl.get()), refcounted(impl) {
49 |   }
50 | 
51 |   template <std::derived_from<T> TSubtype>
52 |   maybe_shared_ptr(const maybe_shared_ptr<TSubtype>& impl)
53 |     : p(impl.p), refcounted(impl.refcounted) {
54 |   }
55 | 
56 |   template <std::derived_from<T> TSubtype>
57 |   maybe_shared_ptr(TSubtype& local) : p(&local) {
58 |   }
59 | 
60 |   template <std::derived_from<T> TSubtype>
61 |   explicit maybe_shared_ptr(TSubtype&& temporary) {
62 |     refcounted = std::make_shared<TSubtype>(std::move(temporary));
63 |     p = refcounted.get();
64 |   }
65 | 
66 |   bool isValid() const {
67 |     return p;
68 |   }
69 |   T& operator*() const {
70 |     return *p;
71 |   }
72 |   T* operator->() const {
73 |     return p;
74 |   }
75 | };
76 | }// namespace fredemmott::inputmapping
77 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/InputDevice.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/DeviceSpecifier.h>
11 | #include <dinput.h>
12 | 
13 | #include <cstddef>
14 | #include <memory>
15 | #include <optional>
16 | #include <string>
17 | #include <vector>
18 | 
19 | namespace fredemmott::inputmapping {
20 | 
21 | struct AxisInformation;
22 | 
23 | class InputDevice final {
24 |  public:
25 |   InputDevice(IDirectInput8A* di, LPCDIDEVICEINSTANCEA device);
26 |   InputDevice() = delete;
27 |   InputDevice(const InputDevice&) = delete;
28 |   void operator=(const InputDevice&) = delete;
29 |   ~InputDevice();
30 | 
31 |   std::string getInstanceName() const;
32 |   std::string getProductName() const;
33 |   std::optional<VIDPID> getVIDPID() const;
34 |   InstanceID getInstanceID() const;
35 |   HardwareID getHardwareID() const;
36 | 
37 |   uint32_t getAxisCount();
38 |   std::vector<AxisInformation> getAxisInformation();
39 |   uint32_t getButtonCount();
40 |   uint32_t getHatCount();
41 | 
42 |   HANDLE getEvent();
43 | 
44 |   // TODO move to Stateclass
45 |   struct StateOffsets {
46 |     off_t firstAxis;
47 |     off_t firstButton;
48 |     off_t firstHat;
49 |   };
50 | 
51 |   class State final {
52 |    private:
53 |     StateOffsets offsets;
54 |     std::vector<std::byte> buffer;
55 | 
56 |    public:
57 |     State(const StateOffsets& offsets, const std::vector<std::byte>& buffer);
58 |     ~State();
59 | 
60 |     long getAxis(uint8_t i) const;
61 |     bool getButton(uint8_t i) const;
62 |     uint16_t getHat(uint8_t i) const;
63 |     void dump() const;
64 |   };
65 |   State getState();
66 | 
67 |  private:
68 |   struct Impl;
69 |   std::unique_ptr<Impl> p;
70 |   HANDLE mEventHandle = nullptr;
71 |   bool mActivated = false;
72 |   size_t mDataSize = 0;
73 |   StateOffsets mOffsets {};
74 |   void activate();
75 | };
76 | }// namespace fredemmott::inputmapping
77 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/HidHide.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <filesystem>
11 | #include <memory>
12 | #include <set>
13 | #include <vector>
14 | 
15 | #include <cpp-remapper/DeviceSpecifier.h>
16 | 
17 | // clang-format off
18 | #include <Unknwn.h>
19 | #include <winrt/base.h>
20 | // clang-format on
21 | 
22 | namespace fredemmott::inputmapping {
23 | class InputDevice;
24 | 
25 | class HidHide {
26 |  public:
27 |   using ControlDevice = winrt::file_handle;
28 |   using AbsoluteDosDevicePath = std::wstring;
29 | 
30 |   HidHide(const std::vector<DeviceSpecifier>& devices);
31 | 
32 |   ~HidHide();
33 | 
34 |  private:
35 |   bool mInitialized = false;
36 | 
37 |   void init(const std::vector<DeviceSpecifier>& devices);
38 | 
39 |   static ControlDevice getControlDevice();
40 | 
41 |   static std::set<std::wstring> getDeviceBlacklist(const ControlDevice&);
42 |   static void setDeviceBlacklist(
43 |     const ControlDevice&,
44 |     const std::set<std::wstring>&);
45 | 
46 |   static std::set<AbsoluteDosDevicePath> getApplicationWhitelist(
47 |     const ControlDevice&);
48 |   static void setApplicationWhitelist(
49 |     const ControlDevice&,
50 |     const std::set<AbsoluteDosDevicePath>&);
51 |   static void ensureApplicationIsWhitelisted();
52 |   static void ensureApplicationIsWhitelisted(const std::filesystem::path&);
53 | 
54 |   class DeviceBlacklistEntry {
55 |    public:
56 |     DeviceBlacklistEntry(const std::wstring&);
57 |     DeviceBlacklistEntry(DeviceBlacklistEntry&&);
58 |     ~DeviceBlacklistEntry();
59 | 
60 |     DeviceBlacklistEntry& operator=(DeviceBlacklistEntry&&);
61 | 
62 |     DeviceBlacklistEntry(const DeviceBlacklistEntry&) = delete;
63 |     auto operator=(const DeviceBlacklistEntry&) = delete;
64 | 
65 |    private:
66 |     std::wstring mDevice;
67 |   };
68 | 
69 |   std::vector<DeviceBlacklistEntry> mEntries;
70 | };
71 | 
72 | }// namespace fredemmott::inputmapping
73 | 


--------------------------------------------------------------------------------
/tests/CompositeSink_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/CompositeSink.h>
10 | 
11 | #include <cpp-remapper/MappableVJoyOutput.h>
12 | #include <cpp-remapper/SquareDeadzone.h>
13 | #include <cpp-remapper/connections.h>
14 | #include "tests.h"
15 | 
16 | using namespace fredemmott::inputmapping;
17 | 
18 | TEST_CASE("CompositeSink") {
19 |   TestAxis axis;
20 | 
21 |   SECTION("Lambdas") {
22 |     Axis::Value out1(-1), out2(-1), out3(-1);
23 |     // 1, 2, n are special
24 |     axis >> all([&](Axis::Value v) { out1 = v; });
25 |     axis.emit(Axis::MAX);
26 |     REQUIRE(out1 == Axis::MAX);
27 |     axis >> all(
28 |       [&](Axis::Value v) { out1 = v; }, [&](Axis::Value v) { out2 = v; });
29 |     axis.emit(Axis::MIN);
30 |     REQUIRE(out1 == Axis::MIN);
31 |     REQUIRE(out2 == Axis::MIN);
32 |     axis >> all(
33 |       [&](Axis::Value v) { out1 = v; },
34 |       [&](Axis::Value v) { out2 = v; },
35 |       [&](Axis::Value v) { out3 = v; });
36 |     axis.emit(Axis::MAX);
37 |     REQUIRE(out1 == Axis::MAX);
38 |     REQUIRE(out2 == Axis::MAX);
39 |     REQUIRE(out3 == Axis::MAX);
40 |   }
41 | 
42 |   SECTION("Pipelines") {
43 |     Axis::Value out1(-1), out2(-1);
44 |     axis >> all(
45 |       SquareDeadzone(10_percent) >> &out1, SquareDeadzone(20_percent) >> &out2);
46 |     axis.emit(Axis::MID + 1);
47 |     REQUIRE(out1 == Axis::MID);
48 |     REQUIRE(out2 == Axis::MID);
49 |     axis.emit(Axis::MID + (Axis::MAX / 10) + 1);
50 |     REQUIRE(out1 > Axis::MID);
51 |     REQUIRE(out2 == Axis::MID);
52 |     axis.emit(Axis::MID + (Axis::MAX / 5) + 1);
53 |     REQUIRE(out1 > Axis::MID);
54 |     REQUIRE(out2 > Axis::MID);
55 |   }
56 | }
57 | 
58 | namespace {
59 | void static_test_ptrs() {
60 |   MappableVJoyOutput vj(nullptr);
61 |   TestAxis axis;
62 |   static_assert(any_sink_ptr<decltype(vj.XAxis)>);
63 |   static_assert(any_sink_ptr<decltype(vj.YAxis)>);
64 |   static_assert(any_sink_ptr<decltype(vj.ZAxis)>);
65 |   axis >> all(vj.XAxis, vj.YAxis, vj.ZAxis);
66 | }
67 | }// namespace
68 | 


--------------------------------------------------------------------------------
/tests/SquareDeadzone_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/SquareDeadzone.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("SquareDeadzone") {
16 |   const auto percent = GENERATE(10_percent, 90_percent);
17 | 
18 |   long out = -1;
19 |   TestAxis axis;
20 |   axis >> SquareDeadzone(percent) >> &out;
21 | 
22 |   axis.emit(0x7fff);// mid point
23 |   // In deadzone
24 |   REQUIRE(out == 0x7fff);
25 |   axis.emit(0x8000);
26 |   REQUIRE(out == 0x7fff);
27 |   axis.emit(0x7ffe);
28 |   REQUIRE(out == 0x7fff);
29 |   // Out of deadzone: extremes
30 |   axis.emit(0);
31 |   REQUIRE(out == 0);
32 |   axis.emit(0xffff);
33 |   REQUIRE(out == 0xffff);
34 |   // Return to deadzone
35 |   axis.emit(0x80ff);
36 |   REQUIRE(out == 0x7fff);
37 | 
38 |   const long dz_size = round(0x8000 * percent.value() / 100.0);
39 |   // 1 change in input produces this size change in output...
40 |   const double out_delta = 0x8000 * 1.0 / (0x8000 - dz_size);
41 |   // ... but as we're using < and > constraints with a input of 1, we always
42 |   // want the ceil
43 |   const long delta_ceil = ceil(out_delta);
44 | 
45 |   // Just above center
46 |   axis.emit(0x7fff + dz_size);
47 |   REQUIRE(out == 0x7fff);
48 |   axis.emit(0x7fff + dz_size + 1);
49 |   REQUIRE(out > 0x7fff);
50 |   REQUIRE(out <= 0x7fff + delta_ceil);
51 |   // Near max
52 |   axis.emit(0xfffe);
53 |   REQUIRE(out == 0xffff - delta_ceil);
54 |   // Just below center
55 |   axis.emit(0x7fff - dz_size + 1);
56 |   REQUIRE(out == 0x7fff);
57 |   axis.emit(0x7fff - dz_size);
58 |   REQUIRE(out < 0x7fff);
59 |   REQUIRE(out >= 0x7fff - delta_ceil);
60 |   // Near min
61 |   axis.emit(1);
62 |   REQUIRE(out >= 1);
63 |   REQUIRE(out <= delta_ceil);
64 | 
65 |   // Half way points
66 |   axis.emit(0x7fff + 0x4000 + (dz_size / 2) + 1);
67 |   REQUIRE(out >= 0x7fff + 0x4000);
68 |   REQUIRE(out <= 0x7fff + 0x4000 + delta_ceil);
69 |   axis.emit(0x7fff - 0x4000 - (dz_size / 2));
70 |   REQUIRE(out <= 0x7fff - 0x4000);
71 |   REQUIRE(out >= 0x7fff - 0x4000 - delta_ceil);
72 | }
73 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/SourcePtr.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <memory>
12 | 
13 | #include <cpp-remapper/Source.h>
14 | #include <cpp-remapper/maybe_shared_ptr.h>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | template <std::derived_from<Control> TControl>
19 | using SourcePtr = maybe_shared_ptr<Source<TControl>>;
20 | using AxisSourcePtr = SourcePtr<Axis>;
21 | using ButtonSourcePtr = SourcePtr<Button>;
22 | using HatSourcePtr = SourcePtr<Hat>;
23 | 
24 | // clang-format off
25 | template<typename T>
26 | concept any_source_ptr =
27 |   any_source<typename T::element_type>
28 |   && std::convertible_to<T, maybe_shared_ptr<typename T::element_type>>;
29 | 
30 | template<typename T, typename TControl>
31 | concept source_ptr =
32 |   any_source_ptr<T>
33 |   && source<typename T::element_type, TControl>;
34 | // clang-format on
35 | 
36 | template <typename T>
37 | auto convert_to_any_source_ptr(T&& in) {
38 |   using DT = std::decay_t<T>;
39 |   if constexpr (any_source_ptr<DT>) {
40 |     return in;
41 |   }
42 | 
43 |   if constexpr (any_source<DT>) {
44 |     return maybe_shared_ptr<std::decay_t<T>>(std::forward<T>(in));
45 |   }
46 | 
47 |   if constexpr (any_source<std::remove_pointer_t<DT>>) {
48 |     return maybe_shared_ptr<std::remove_pointer_t<DT>>(in);
49 |   }
50 | }
51 | 
52 | // clang-format off
53 | template <typename T>
54 | concept convertible_to_any_source_ptr = requires(T x) {
55 | 	{ convert_to_any_source_ptr(x) } -> any_source_ptr;
56 | };
57 | 
58 | template <typename T>
59 | concept non_id_convertible_to_any_source_ptr =
60 |   !any_source_ptr<std::decay_t<T>>
61 |   && convertible_to_any_source_ptr<T>;
62 | 
63 | template <typename T, typename TControl>
64 | concept convertible_to_source_ptr = requires(T x) {
65 | 	{ convert_to_any_source_ptr(x) } -> source_ptr<TControl>;
66 | };
67 | 
68 | template <typename T, typename TControl>
69 | concept non_id_convertible_to_source_ptr =
70 |   !source_ptr<std::decay_t<T>, TControl>
71 |   && convertible_to_source_ptr<T, TControl>;
72 | // clang-format on
73 | 
74 | }// namespace fredemmott::inputmapping
75 | 


--------------------------------------------------------------------------------
/tests/AxisToButtons_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AxisToButtons.h>
10 | 
11 | #include <cpp-remapper/CompositeSink.h>
12 | #include <cpp-remapper/MappableVJoyOutput.h>
13 | #include "tests.h"
14 | 
15 | using namespace fredemmott::inputmapping;
16 | 
17 | TEST_CASE("AxisToButtons") {
18 |   TestAxis axis;
19 |   SECTION("Implicit Equal Spacing") {
20 |     Button::Value b1, b2, b3;
21 |     axis >> AxisToButtons(&b1, &b2, &b3);
22 | 
23 |     axis.emit(0);
24 |     REQUIRE(b1);
25 |     REQUIRE(!b2);
26 |     REQUIRE(!b3);
27 |     axis.emit(Axis::MAX / 3);
28 |     REQUIRE(b1);
29 |     REQUIRE(!b2);
30 |     REQUIRE(!b3);
31 |     axis.emit((Axis::MAX / 3) + 1);
32 |     REQUIRE(!b1);
33 |     REQUIRE(b2);
34 |     REQUIRE(!b3);
35 |     axis.emit(2 * Axis::MAX / 3);
36 |     REQUIRE(!b1);
37 |     REQUIRE(b2);
38 |     REQUIRE(!b3);
39 |     axis.emit((2 * Axis::MAX / 3) + 1);
40 |     REQUIRE(!b1);
41 |     REQUIRE(!b2);
42 |     REQUIRE(b3);
43 |     axis.emit(Axis::MAX);
44 |     REQUIRE(!b1);
45 |     REQUIRE(!b2);
46 |     REQUIRE(b3);
47 |   }
48 | 
49 |   SECTION("Explicit ranges") {
50 |     Button::Value b1, b2;
51 |     axis >> AxisToButtons {
52 |       {0_percent, 0_percent, &b1}, {100_percent, 100_percent, &b2}};
53 |     axis.emit(0);
54 |     REQUIRE(b1);
55 |     REQUIRE(!b2);
56 |     axis.emit(1);
57 |     REQUIRE(!b1);
58 |     REQUIRE(!b2);
59 |     axis.emit(Axis::MAX - 1);
60 |     REQUIRE(!b1);
61 |     REQUIRE(!b2);
62 |     axis.emit(Axis::MAX);
63 |     REQUIRE(!b1);
64 |     REQUIRE(b2);
65 |   }
66 | }
67 | 
68 | namespace {
69 | 
70 | // Check that the compiler lets us call it as intended
71 | void static_test_real_buttons() {
72 |   MappableVJoyOutput o(nullptr);
73 |   AxisToButtons::Range range1 {0_percent, 0_percent, o.Button1};
74 | 
75 |   AxisToButtons::Range range2 {0_percent, 0_percent, all(o.Button1, o.Button2)};
76 |   AxisToButtons foo {
77 |     {0_percent, 0_percent, o.Button1},
78 |     {0_percent, 0_percent, all(o.Button1, o.Button2)},
79 |     {100_percent, 100_percent, [](bool) {}}};
80 |   AxisToButtons implicit_equal_spacing(o.Button1, o.Button2, o.Button3);
81 | }
82 | 
83 | }// namespace
84 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "files.associations": {
 3 |     "functional": "cpp",
 4 |     "memory": "cpp",
 5 |     "tuple": "cpp",
 6 |     "xtr1common": "cpp",
 7 |     "charconv": "cpp",
 8 |     "map": "cpp",
 9 |     "type_traits": "cpp",
10 |     "unordered_map": "cpp",
11 |     "variant": "cpp",
12 |     "xlocmon": "cpp",
13 |     "xmemory": "cpp",
14 |     "xtree": "cpp",
15 |     "algorithm": "cpp",
16 |     "array": "cpp",
17 |     "atomic": "cpp",
18 |     "bit": "cpp",
19 |     "cctype": "cpp",
20 |     "chrono": "cpp",
21 |     "clocale": "cpp",
22 |     "cmath": "cpp",
23 |     "compare": "cpp",
24 |     "concepts": "cpp",
25 |     "cstddef": "cpp",
26 |     "cstdint": "cpp",
27 |     "cstdio": "cpp",
28 |     "cstdlib": "cpp",
29 |     "cstring": "cpp",
30 |     "ctime": "cpp",
31 |     "cwchar": "cpp",
32 |     "exception": "cpp",
33 |     "filesystem": "cpp",
34 |     "format": "cpp",
35 |     "forward_list": "cpp",
36 |     "fstream": "cpp",
37 |     "initializer_list": "cpp",
38 |     "iomanip": "cpp",
39 |     "ios": "cpp",
40 |     "iosfwd": "cpp",
41 |     "iostream": "cpp",
42 |     "istream": "cpp",
43 |     "iterator": "cpp",
44 |     "limits": "cpp",
45 |     "list": "cpp",
46 |     "locale": "cpp",
47 |     "new": "cpp",
48 |     "optional": "cpp",
49 |     "ostream": "cpp",
50 |     "ratio": "cpp",
51 |     "set": "cpp",
52 |     "sstream": "cpp",
53 |     "stdexcept": "cpp",
54 |     "stop_token": "cpp",
55 |     "streambuf": "cpp",
56 |     "string": "cpp",
57 |     "system_error": "cpp",
58 |     "thread": "cpp",
59 |     "typeinfo": "cpp",
60 |     "utility": "cpp",
61 |     "vector": "cpp",
62 |     "xfacet": "cpp",
63 |     "xhash": "cpp",
64 |     "xiosbase": "cpp",
65 |     "xlocale": "cpp",
66 |     "xlocbuf": "cpp",
67 |     "xlocinfo": "cpp",
68 |     "xlocmes": "cpp",
69 |     "xlocnum": "cpp",
70 |     "xloctime": "cpp",
71 |     "xstddef": "cpp",
72 |     "xstring": "cpp",
73 |     "xutility": "cpp",
74 |     "any": "cpp",
75 |     "*.rh": "cpp",
76 |     "codecvt": "cpp",
77 |     "condition_variable": "cpp",
78 |     "coroutine": "cpp",
79 |     "deque": "cpp",
80 |     "resumable": "cpp",
81 |     "future": "cpp",
82 |     "mutex": "cpp",
83 |     "numeric": "cpp",
84 |     "random": "cpp",
85 |     "regex": "cpp",
86 |     "stack": "cpp"
87 |   },
88 |   "C_Cpp.default.cppStandard": "c++20",
89 |   "editor.formatOnSave": true,
90 |   "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools"
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/Profile_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/OutputDevice.h>
10 | #include <cpp-remapper/Profile.h>
11 | #include <cpp-remapper/connections.h>
12 | #include <cpp-remapper/devicedb.h>
13 | 
14 | #include "tests.h"
15 | 
16 | using namespace fredemmott::inputmapping;
17 | using namespace fredemmott::inputmapping::devicedb;
18 | 
19 | static void static_test_vjoy() {
20 |   auto [p, stick, vj1] = create_profile(VPC_RIGHT_WARBRD, VJOY_1);
21 |   stick.Button1 >> vj1.Button1;
22 |   stick >> vj1;
23 | }
24 | 
25 | static void static_test_favhid() {
26 |   auto [p, stick, fh1] = create_profile(VPC_RIGHT_WARBRD, FAVHID_1);
27 |   stick.Button1 >> fh1.Button1;
28 |   stick >> fh1;
29 | }
30 | 
31 | static void static_test_vigem() {
32 |   auto [p, stick, xpad, ds4]
33 |     = create_profile(VPC_RIGHT_WARBRD, VIGEM_X360_PAD, VIGEM_DS4_PAD);
34 |   // Device-specific IDs
35 |   stick.Button1 >> xpad.ButtonA;
36 |   stick.Button2 >> ds4.ButtonTriangle;
37 | }
38 | 
39 | static void static_test_unhiddendevice() {
40 |   auto [p, stick, vj1]
41 |     = create_profile(UnhiddenDevice(VPC_RIGHT_WARBRD), VJOY_1);
42 |   stick.Button1 >> vj1.Button1;
43 | }
44 | 
45 | TEST_CASE("TestFillHiddenIDs") {
46 |   static_assert(std::convertible_to<decltype(VIDPID(0, 0)), DeviceSpecifier>);
47 |   static_assert(!std::convertible_to<decltype(VIDPID(0, 0)), HiddenDevice>);
48 |   static_assert(!std::convertible_to<decltype(VIDPID(0, 0)), UnhiddenDevice>);
49 |   static_assert(std::is_constructible_v<HiddenDevice, VIDPID>);
50 |   static_assert(!std::is_constructible_v<HiddenDevice, UnhiddenDevice>);
51 | 
52 |   std::vector<HiddenDevice> hidden;
53 |   detail::fill_hidden_ids(
54 |     hidden,
55 |     VIDPID {0x1234, 0x0001},
56 |     HiddenDevice(VIDPID {0x1234, 0x0002}),
57 |     VJOY_1,
58 |     VJOY_2,
59 |     VIGEM_X360_PAD,
60 |     VIGEM_DS4_PAD);
61 |   REQUIRE(hidden.size() == 2);
62 | 
63 |   hidden.clear();
64 |   detail::fill_hidden_ids(
65 |     hidden,
66 |     VIDPID {0x1234, 0x0001},
67 |     UnhiddenDevice(VIDPID {0x1234, 0x0002}),
68 |     HiddenDevice(VIDPID {0x1234, 0x0003}),
69 |     VJOY_1,
70 |     VJOY_2,
71 |     VIGEM_X360_PAD,
72 |     VIGEM_DS4_PAD);
73 |   REQUIRE(hidden.size() == 2);
74 | }
75 | 


--------------------------------------------------------------------------------
/lib/X360Device.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/X360Device.h>
 9 | 
10 | #include <iostream>
11 | 
12 | #include <cpp-remapper/ViGEmClient.h>
13 | #include <cpp-remapper/ViGEmTarget.h>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | class X360Device::Impl final
18 |   : public detail::ViGEmTarget<XUSB_REPORT, X360Device::Impl> {
19 |  public:
20 |   static void initState(XUSB_REPORT* state) {
21 |     XUSB_REPORT_INIT(state);
22 |   }
23 | 
24 |   static PVIGEM_TARGET allocTarget() {
25 |     return vigem_target_x360_alloc();
26 |   }
27 | 
28 |   static const char* productShortName() {
29 |     return "X360 pad";
30 |   }
31 | };
32 | 
33 | X360Device::X360Device() : p(new Impl()) {
34 |   if (p) {
35 |     std::cout << "Attached ViGEm X360 pad." << std::endl;
36 |     return;
37 |   }
38 | 
39 |   std::cerr << "---\nERROR\n---\nFailed to initialize ViGEm X360 pad."
40 |             << std::endl;
41 |   exit(1);
42 | }
43 | 
44 | X360Device::~X360Device() {
45 | }
46 | 
47 | void X360Device::flush() {
48 |   auto& client = ViGEmClient::get();
49 |   if (!client) {
50 |     return;
51 |   }
52 |   vigem_target_x360_update(client, p->pad, p->state);
53 | }
54 | 
55 | X360Device* X360Device::setButton(Button button, bool value) {
56 |   if (value) {
57 |     p->state.wButtons |= static_cast<USHORT>(button);
58 |   } else {
59 |     p->state.wButtons &= ~static_cast<USHORT>(button);
60 |   }
61 |   return this;
62 | }
63 | 
64 | X360Device* X360Device::setLXAxis(long value) {
65 |   p->state.sThumbLX = value - 32768;
66 |   return this;
67 | }
68 | X360Device* X360Device::setLYAxis(long value) {
69 |   p->state.sThumbLY = 32767 - value;
70 |   return this;
71 | }
72 | X360Device* X360Device::setRXAxis(long value) {
73 |   p->state.sThumbRX = value - 32768;
74 |   return this;
75 | }
76 | X360Device* X360Device::setRYAxis(long value) {
77 |   p->state.sThumbRY = 32767 - value;
78 |   return this;
79 | }
80 | 
81 | X360Device* X360Device::setLTrigger(long value) {
82 |   p->state.bLeftTrigger = (value * 255) / 65535;
83 |   return this;
84 | }
85 | X360Device* X360Device::setRTrigger(long value) {
86 |   p->state.bRightTrigger = (value * 255) / 65535;
87 |   return this;
88 | }
89 | 
90 | }// namespace fredemmott::inputmapping
91 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/DS4Device.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/OutputDevice.h>
11 | 
12 | #include <cstdint>
13 | #include <memory>
14 | 
15 | // clang-format off
16 | #define WIN32_LEAN_AND_MEAN
17 | #include <windows.h>
18 | #include <ViGEm/Client.h>
19 | // clang-format on
20 | 
21 | namespace fredemmott::inputmapping {
22 | 
23 | class DS4Device final : public OutputDevice {
24 |  public:
25 |   DS4Device();
26 |   ~DS4Device();
27 | 
28 |   DS4Device(const DS4Device&) = delete;
29 |   DS4Device& operator=(const DS4Device&) = delete;
30 | 
31 |   virtual void flush() override;
32 | 
33 |   enum class Button {
34 |     LEFT_THUMB = DS4_BUTTON_THUMB_LEFT,
35 |     RIGHT_THUMB = DS4_BUTTON_THUMB_RIGHT,
36 |     OPTIONS = DS4_BUTTON_OPTIONS,
37 |     SHARE = DS4_BUTTON_SHARE,
38 |     LEFT_TRIGGER = DS4_BUTTON_TRIGGER_LEFT,
39 |     RIGHT_TRIGGER = DS4_BUTTON_TRIGGER_RIGHT,
40 |     LEFT_SHOULDER = DS4_BUTTON_SHOULDER_LEFT,
41 |     RIGHT_SHOULDER = DS4_BUTTON_SHOULDER_LEFT,
42 |     TRIANGLE = DS4_BUTTON_TRIANGLE,
43 |     CIRCLE = DS4_BUTTON_CIRCLE,
44 |     CROSS = DS4_BUTTON_CROSS,
45 |     SQUARE = DS4_BUTTON_SQUARE,
46 |   };
47 | 
48 |   enum class SpecialButton {
49 |     PS = DS4_SPECIAL_BUTTON_PS,
50 |     TOUCHPAD = DS4_SPECIAL_BUTTON_TOUCHPAD,
51 |   };
52 | 
53 |   enum class DPadDirection {
54 |     NONE = DS4_BUTTON_DPAD_NONE,
55 |     NORTHWEST = DS4_BUTTON_DPAD_NORTHWEST,
56 |     WEST = DS4_BUTTON_DPAD_WEST,
57 |     SOUTHWEST = DS4_BUTTON_DPAD_SOUTHWEST,
58 |     SOUTH = DS4_BUTTON_DPAD_SOUTH,
59 |     SOUTHEAST = DS4_BUTTON_DPAD_SOUTHEAST,
60 |     EAST = DS4_BUTTON_DPAD_EAST,
61 |     NORTHEAST = DS4_BUTTON_DPAD_NORTHEAST,
62 |     NORTH = DS4_BUTTON_DPAD_NORTH,
63 |   };
64 | 
65 |   DS4Device* setButton(Button button, bool value);
66 |   DS4Device* setButton(SpecialButton button, bool value);
67 |   DS4Device* setDPad(DPadDirection direction);
68 | 
69 |   DS4Device* setLXAxis(long value);
70 |   DS4Device* setLYAxis(long value);
71 |   DS4Device* setRXAxis(long value);
72 |   DS4Device* setRYAxis(long value);
73 |   DS4Device* setLTrigger(long value);
74 |   DS4Device* setRTrigger(long value);
75 | 
76 |  private:
77 |   class Impl;
78 |   std::unique_ptr<Impl> p;
79 | };
80 | 
81 | }// namespace fredemmott::inputmapping
82 | 


--------------------------------------------------------------------------------
/lib/MappableDS4Output.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/AxisInformation.h>
 9 | #include <cpp-remapper/DS4Device.h>
10 | #include <cpp-remapper/InputDevice.h>
11 | #include <cpp-remapper/MappableDS4Output.h>
12 | 
13 | namespace fredemmott::inputmapping {
14 | 
15 | MappableDS4Output::MappableDS4Output()
16 |   : MappableDS4Output(std::make_shared<DS4Device>()) {
17 | }
18 | 
19 | namespace {
20 | void button_to_dpad(
21 |   const std::shared_ptr<DS4Device>& device,
22 |   DS4Device::DPadDirection direction,
23 |   bool value) {
24 |   if (!value) {
25 |     device->setDPad(DS4Device::DPadDirection::NONE);
26 |     return;
27 |   }
28 |   device->setDPad(direction);
29 | }
30 | }// namespace
31 | 
32 | MappableDS4Output::MappableDS4Output(std::shared_ptr<DS4Device> dev)
33 |   :
34 | #define A(a) a([dev](long value) { dev->set##a(value); })
35 | #define AA(a) A(a##Axis)
36 |     AA(LX),
37 |     AA(LY),
38 |     A(LTrigger),
39 |     AA(RX),
40 |     AA(RY),
41 |     A(RTrigger),
42 | #undef AA
43 | #undef A
44 | #define B(name, enum) \
45 |   Button##name( \
46 |     [dev](bool value) { dev->setButton(DS4Device::Button::enum, value); })
47 |     B(Triangle, TRIANGLE),
48 |     B(Circle, CIRCLE),
49 |     B(Cross, CROSS),
50 |     B(Square, SQUARE),
51 |     B(LTrigger, LEFT_TRIGGER),
52 |     B(RTrigger, RIGHT_TRIGGER),
53 |     B(LShoulder, LEFT_SHOULDER),
54 |     B(RShoulder, RIGHT_SHOULDER),
55 |     B(Options, OPTIONS),
56 |     B(Share, SHARE),
57 | #undef B
58 | #define SB(name, enum) \
59 |   Button##name([dev](bool value) { \
60 |     dev->setButton(DS4Device::SpecialButton::enum, value); \
61 |   })
62 |     SB(PS, PS),
63 |     SB(TouchPad, TOUCHPAD),
64 | #undef SB
65 | #define DP(name, enum) \
66 |   ButtonDPad##name([dev](bool value) { \
67 |     button_to_dpad(dev, DS4Device::DPadDirection::enum, value); \
68 |   })
69 |     DP(North, NORTH),
70 |     DP(NorthEast, NORTHEAST),
71 |     DP(East, EAST),
72 |     DP(SouthEast, SOUTHEAST),
73 |     DP(South, SOUTH),
74 |     DP(SouthWest, SOUTHWEST),
75 |     DP(West, WEST),
76 |     DP(NorthWest, NORTHWEST),
77 | #undef DP
78 |     mDevice(dev) {
79 | }
80 | 
81 | MappableDS4Output::~MappableDS4Output() {
82 | }
83 | 
84 | std::shared_ptr<OutputDevice> MappableDS4Output::getDevice() const {
85 |   return mDevice;
86 | }
87 | 
88 | }// namespace fredemmott::inputmapping
89 | 


--------------------------------------------------------------------------------
/lib/DeviceSpecifier.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #include <cpp-remapper/DeviceSpecifier.h>
 9 | #include <cpp-remapper/InputDevice.h>
10 | 
11 | namespace fredemmott::inputmapping {
12 | 
13 | DeviceSpecifierBase::DeviceSpecifierBase() {
14 | }
15 | 
16 | DeviceSpecifierBase::~DeviceSpecifierBase() {
17 | }
18 | 
19 | VIDPID::~VIDPID() {
20 | }
21 | 
22 | bool VIDPID::matches(const InputDevice& device) const {
23 |   auto dev_vidpid = device.getVIDPID();
24 |   if (!dev_vidpid) {
25 |     return false;
26 |   }
27 |   return mVID == dev_vidpid->mVID && mPID == dev_vidpid->mPID;
28 | }
29 | 
30 | std::string VIDPID::getHumanReadable() const {
31 |   char buf[sizeof("VID: 0x1234, PID: 0x5678")];
32 |   snprintf(buf, sizeof(buf), "VID: 0x%04hX, PID: 0x%04hX", mVID, mPID);
33 |   return buf;
34 | }
35 | 
36 | StringBasedID::StringBasedID(const std::string& impl) : mID(impl) {
37 | }
38 | 
39 | StringBasedID::~StringBasedID() {
40 | }
41 | 
42 | std::string StringBasedID::toString() const {
43 |   return mID;
44 | }
45 | 
46 | std::wstring StringBasedID::toWString() const {
47 |   wchar_t buf[UNICODE_STRING_MAX_CHARS];
48 |   const auto wchar_count
49 |     = ::MultiByteToWideChar(1252, 0, mID.data(), mID.size(), buf, sizeof(buf));
50 |   return std::wstring(buf, wchar_count);
51 | }
52 | 
53 | bool HardwareID::matches(const InputDevice& device) const {
54 |   return mID == device.getHardwareID().mID;
55 | }
56 | 
57 | std::string HardwareID::getHumanReadable() const {
58 |   return "HardwareID: " + mID;
59 | }
60 | 
61 | bool InstanceID::matches(const InputDevice& device) const {
62 |   return mID == device.getInstanceID().mID;
63 | }
64 | 
65 | std::string InstanceID::getHumanReadable() const {
66 |   return "InstanceID: " + mID;
67 | }
68 | 
69 | namespace {
70 | const DeviceSpecifierBase& unwrap_impl(const DeviceSpecifier::Impl& impl) {
71 |   return std::visit(
72 |     [&](const DeviceSpecifierBase& base) -> const DeviceSpecifierBase& {
73 |       return base;
74 |     },
75 |     impl);
76 | }
77 | }// namespace
78 | 
79 | DeviceSpecifier::~DeviceSpecifier() {
80 | }
81 | bool DeviceSpecifier::matches(const InputDevice& device) const {
82 |   return unwrap_impl(p).matches(device);
83 | }
84 | std::string DeviceSpecifier::getHumanReadable() const {
85 |   return unwrap_impl(p).getHumanReadable();
86 | }
87 | 
88 | }// namespace fredemmott::inputmapping
89 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableVJoyOutput.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/MappableOutput.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | 
13 | #include <cstdint>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | class VJoyDevice;
18 | 
19 | class MappableVJoyOutput final : public MappableOutput {
20 |  private:
21 |   std::shared_ptr<VJoyDevice> mDevice;
22 | 
23 |  public:
24 |   MappableVJoyOutput() = delete;
25 |   explicit MappableVJoyOutput(uint8_t vjoy_id);
26 |   MappableVJoyOutput(std::shared_ptr<VJoyDevice> dev);
27 |   ~MappableVJoyOutput();
28 |   std::shared_ptr<OutputDevice> getDevice() const override;
29 | 
30 |   ButtonSinkPtr button(uint8_t id) const;
31 |   HatSinkPtr hat(uint8_t id) const;
32 | 
33 |   const AxisSinkPtr XAxis, YAxis, ZAxis, RXAxis, RYAxis, RZAxis, Slider, Dial;
34 | 
35 |   const ButtonSinkPtr Button1, Button2, Button3, Button4, Button5, Button6,
36 |     Button7, Button8, Button9, Button10, Button11, Button12, Button13, Button14,
37 |     Button15, Button16, Button17, Button18, Button19, Button20, Button21,
38 |     Button22, Button23, Button24, Button25, Button26, Button27, Button28,
39 |     Button29, Button30, Button31, Button32, Button33, Button34, Button35,
40 |     Button36, Button37, Button38, Button39, Button40, Button41, Button42,
41 |     Button43, Button44, Button45, Button46, Button47, Button48, Button49,
42 |     Button50, Button51, Button52, Button53, Button54, Button55, Button56,
43 |     Button57, Button58, Button59, Button60, Button61, Button62, Button63,
44 |     Button64, Button65, Button66, Button67, Button68, Button69, Button70,
45 |     Button71, Button72, Button73, Button74, Button75, Button76, Button77,
46 |     Button78, Button79, Button80, Button81, Button82, Button83, Button84,
47 |     Button85, Button86, Button87, Button88, Button89, Button90, Button91,
48 |     Button92, Button93, Button94, Button95, Button96, Button97, Button98,
49 |     Button99, Button100, Button101, Button102, Button103, Button104, Button105,
50 |     Button106, Button107, Button108, Button109, Button110, Button111, Button112,
51 |     Button113, Button114, Button115, Button116, Button117, Button118, Button119,
52 |     Button120, Button121, Button122, Button123, Button124, Button125, Button126,
53 |     Button127, Button128;
54 | 
55 |   const HatSinkPtr Hat1, Hat2, Hat3, Hat4;
56 | };
57 | 
58 | }// namespace fredemmott::inputmapping
59 | 


--------------------------------------------------------------------------------
/lib/HatToButtons.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/HatToButtons.h>
10 | #include <cpp-remapper/MappableVJoyOutput.h>
11 | 
12 | namespace fredemmott::inputmapping {
13 | 
14 | HatToButtons::HatToButtons(
15 |   MappableVJoyOutput* output,
16 |   uint8_t first,
17 |   uint8_t count) {
18 |   assignToVJoy(output, first, count);
19 | }
20 | 
21 | const ButtonSinkPtr& HatToButtons::CenterButton::get() const {
22 |   return mButton;
23 | }
24 | 
25 | HatToButtons::HatToButtons(
26 |   const HatToButtons::CenterButton& center,
27 |   MappableVJoyOutput* output,
28 |   uint8_t first,
29 |   uint8_t count)
30 |   : mCenter(center.get()) {
31 |   assignToVJoy(output, first, count);
32 | }
33 | 
34 | void HatToButtons::map(Hat::Value value) {
35 |   if (mCenter) {
36 |     (*mCenter)->map(value == Hat::CENTER);
37 |   }
38 |   if (value == Hat::CENTER) {
39 |     for (auto& next: mButtons) {
40 |       next->map(false);
41 |     }
42 |     return;
43 |   }
44 | 
45 |   const auto step = 36000 / mButtons.size();
46 | 
47 |   if (mInterpolation == Interpolation::None) {
48 |     auto offset = 0;
49 |     for (auto i = 0; i < mButtons.size(); ++i) {
50 |       mButtons[i]->map(value == offset);
51 |       offset += step;
52 |     }
53 |     return;
54 |   }
55 | 
56 |   // Let's say we have 4 buttons: N, E, S, W
57 |   // If the hat is at NE, we want both N and E on, so there's an area that's
58 |   // "NE" - which goes half way from true NE to E - in another words, the N
59 |   // button is pressed when the hat is between WNW and ENE, and covers 3/8ths
60 |   // of the area
61 |   const auto range = ((36000 * 3) / (mButtons.size() * 2));
62 |   // first one is special, as North should be on for a bit both sides of 0
63 |   auto offset = range / 2;
64 |   mButtons[0]->map(value <= offset || value > 36000 - offset);
65 | 
66 |   // If we have 4 buttons, the 'E' button starts pressed active at NNE, while
67 |   // 'N' is still active. N drops off 45 degrees later at ENE
68 |   offset = 36000 / (mButtons.size() * 4);
69 |   for (auto i = 1; i < mButtons.size(); ++i) {
70 |     mButtons[i]->map(value > offset && value <= offset + range);
71 |     offset += step;
72 |   }
73 | }
74 | 
75 | void HatToButtons::assignToVJoy(
76 |   MappableVJoyOutput* output,
77 |   uint8_t first,
78 |   uint8_t count) {
79 |   for (auto i = first; i < first + count; ++i) {
80 |     mButtons.push_back(output->button(i));
81 |   }
82 | }
83 | 
84 | }// namespace fredemmott::inputmapping
85 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableFAVHIDOutput.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/MappableOutput.h>
11 | #include <cpp-remapper/SinkPtr.h>
12 | 
13 | #include <cstdint>
14 | 
15 | namespace fredemmott::inputmapping {
16 | 
17 | class FAVHIDDevice;
18 | 
19 | class MappableFAVHIDOutput final : public MappableOutput {
20 |  private:
21 |   struct Impl;
22 |   // Must be initialized before the const members
23 |   std::shared_ptr<Impl> p;
24 | 
25 |  public:
26 |   MappableFAVHIDOutput() = delete;
27 |   explicit MappableFAVHIDOutput(uint8_t vjoy_id);
28 |   MappableFAVHIDOutput(std::shared_ptr<FAVHIDDevice> dev);
29 |   ~MappableFAVHIDOutput();
30 | 
31 |   std::shared_ptr<OutputDevice> getDevice() const override;
32 | 
33 |   ButtonSinkPtr button(uint8_t id) const;
34 |   HatSinkPtr hat(uint8_t id) const;
35 | 
36 |   const AxisSinkPtr XAxis, YAxis, ZAxis, RXAxis, RYAxis, RZAxis, Slider, Dial;
37 | 
38 |   const ButtonSinkPtr Button1, Button2, Button3, Button4, Button5, Button6,
39 |     Button7, Button8, Button9, Button10, Button11, Button12, Button13, Button14,
40 |     Button15, Button16, Button17, Button18, Button19, Button20, Button21,
41 |     Button22, Button23, Button24, Button25, Button26, Button27, Button28,
42 |     Button29, Button30, Button31, Button32, Button33, Button34, Button35,
43 |     Button36, Button37, Button38, Button39, Button40, Button41, Button42,
44 |     Button43, Button44, Button45, Button46, Button47, Button48, Button49,
45 |     Button50, Button51, Button52, Button53, Button54, Button55, Button56,
46 |     Button57, Button58, Button59, Button60, Button61, Button62, Button63,
47 |     Button64, Button65, Button66, Button67, Button68, Button69, Button70,
48 |     Button71, Button72, Button73, Button74, Button75, Button76, Button77,
49 |     Button78, Button79, Button80, Button81, Button82, Button83, Button84,
50 |     Button85, Button86, Button87, Button88, Button89, Button90, Button91,
51 |     Button92, Button93, Button94, Button95, Button96, Button97, Button98,
52 |     Button99, Button100, Button101, Button102, Button103, Button104, Button105,
53 |     Button106, Button107, Button108, Button109, Button110, Button111, Button112,
54 |     Button113, Button114, Button115, Button116, Button117, Button118, Button119,
55 |     Button120, Button121, Button122, Button123, Button124, Button125, Button126,
56 |     Button127, Button128;
57 | 
58 |   const HatSinkPtr Hat1, Hat2, Hat3, Hat4;
59 | };
60 | }// namespace fredemmott::inputmapping


--------------------------------------------------------------------------------
/tests/AxisTrimmer_test.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | 
 9 | #include <cpp-remapper/AxisTrimmer.h>
10 | 
11 | #include "tests.h"
12 | 
13 | using namespace fredemmott::inputmapping;
14 | 
15 | TEST_CASE("SimpleRecenter") {
16 |   AxisTrimmer trim;
17 |   Axis::Value out;
18 |   trim >> &out;
19 |   trim.map(Axis::MID + 100);
20 |   REQUIRE(out == Axis::MID + 100);
21 |   trim.TrimButton->map(true);
22 |   trim.map(Axis::MID);
23 |   REQUIRE(out == Axis::MID + 100);
24 |   trim.TrimButton->map(false);
25 |   REQUIRE(out == Axis::MID + 100);
26 |   trim.map(Axis::MID + 1);
27 |   REQUIRE(out == Axis::MID + 101);
28 | }
29 | 
30 | TEST_CASE("OffCenterTrim") {
31 |   AxisTrimmer trim;
32 |   Axis::Value out;
33 |   trim >> &out;
34 | 
35 |   static_assert(Axis::MID > 100);
36 |   static_assert(Axis::MAX > 200);
37 | 
38 |   trim.map(200);
39 |   trim.TrimButton->map(true);
40 |   trim.map(100);
41 |   trim.TrimButton->map(false);
42 |   REQUIRE(out == 200);
43 |   trim.map(200);
44 |   REQUIRE(out == 300);
45 | }
46 | 
47 | TEST_CASE("ResetTrim") {
48 |   AxisTrimmer trim;
49 |   Axis::Value out;
50 |   trim >> &out;
51 |   trim.map(Axis::MID + 100);
52 |   trim.TrimButton->map(true);
53 |   trim.map(Axis::MID);
54 |   trim.TrimButton->map(false);
55 |   REQUIRE(out == Axis::MID + 100);
56 |   trim.ResetButton->map(true);
57 |   trim.ResetButton->map(false);
58 |   REQUIRE(out == Axis::MID);
59 | }
60 | 
61 | TEST_CASE("TrimmerBounds") {
62 |   AxisTrimmer trim;
63 |   Axis::Value out;
64 |   trim >> &out;
65 | 
66 |   SECTION("Trim to MAX") {
67 |     trim.map(Axis::MAX);
68 |     REQUIRE(out == Axis::MAX);
69 |     trim.TrimButton->map(true);
70 |     trim.map(Axis::MID);
71 |     trim.TrimButton->map(false);
72 |     REQUIRE(out == Axis::MAX);
73 |     trim.map(Axis::MID + 1);
74 |     REQUIRE(out == Axis::MAX);
75 |     trim.map(Axis::MAX);
76 |     REQUIRE(out == Axis::MAX);
77 |     trim.map(Axis::MID - 1);
78 |     REQUIRE(out == Axis::MAX - 1);
79 |     trim.map(Axis::MIN);
80 |     REQUIRE(out == Axis::MAX - Axis::MID);
81 |   }
82 | 
83 |   SECTION("Trim to MIN") {
84 |     trim.ResetButton->map(true);
85 |     trim.ResetButton->map(false);
86 |     trim.map(Axis::MIN);
87 |     trim.TrimButton->map(true);
88 |     trim.map(Axis::MID);
89 |     trim.TrimButton->map(false);
90 |     REQUIRE(out == Axis::MIN);
91 |     trim.map(Axis::MID - 1);
92 |     REQUIRE(out == Axis::MIN);
93 |     trim.map(Axis::MIN);
94 |     REQUIRE(out == Axis::MIN);
95 |     trim.map(Axis::MAX);
96 |     REQUIRE(out == Axis::MAX - Axis::MID);
97 |   }
98 | }
99 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/DeviceSpecifier.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <concepts>
11 | #include <cstdint>
12 | #include <string>
13 | #include <tuple>
14 | #include <variant>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class InputDevice;
19 | 
20 | // Add any subclasses to DeviceSpecifier::Impl typedef too.
21 | class DeviceSpecifierBase {
22 |  protected:
23 |   DeviceSpecifierBase();
24 | 
25 |  public:
26 |   virtual ~DeviceSpecifierBase();
27 |   virtual bool matches(const InputDevice& device) const = 0;
28 |   virtual std::string getHumanReadable() const = 0;
29 | };
30 | 
31 | class VIDPID final : public DeviceSpecifierBase {
32 |  public:
33 |   VIDPID(uint16_t vid, uint16_t pid) : mVID(vid), mPID(pid) {
34 |   }
35 | 
36 |   virtual ~VIDPID();
37 |   virtual bool matches(const InputDevice& device) const override;
38 |   virtual std::string getHumanReadable() const override;
39 | 
40 |   // allow `auto [vid, pid] = my_vidpid;`
41 |   operator std::tuple<uint16_t, uint16_t>() const {
42 |     return std::make_tuple(mVID, mPID);
43 |   }
44 | 
45 |  private:
46 |   uint16_t mVID;
47 |   uint16_t mPID;
48 | };
49 | 
50 | class StringBasedID : public DeviceSpecifierBase {
51 |  public:
52 |   StringBasedID(const std::string& id);
53 |   virtual ~StringBasedID();
54 | 
55 |   // This is primarily here for HidHide; these should be considered
56 |   // opaque identifiers
57 |   std::string toString() const;
58 |   std::wstring toWString() const;
59 | 
60 |  protected:
61 |   std::string mID;
62 | };
63 | 
64 | class HardwareID final : public StringBasedID {
65 |  public:
66 |   using StringBasedID::StringBasedID;
67 |   virtual bool matches(const InputDevice& device) const override;
68 |   virtual std::string getHumanReadable() const override;
69 | };
70 | 
71 | class InstanceID final : public StringBasedID {
72 |  public:
73 |   using StringBasedID::StringBasedID;
74 |   virtual bool matches(const InputDevice& device) const override;
75 |   virtual std::string getHumanReadable() const override;
76 | };
77 | 
78 | // Copyable wrapper around a DeviceSpecifierBase
79 | class DeviceSpecifier final : public DeviceSpecifierBase {
80 |  public:
81 |   typedef std::variant<VIDPID, HardwareID, InstanceID> Impl;
82 | 
83 |   template <std::derived_from<DeviceSpecifierBase> T>
84 |   DeviceSpecifier(const T& val) : p(val) {
85 |   }
86 | 
87 |   virtual ~DeviceSpecifier();
88 |   virtual bool matches(const InputDevice& device) const override;
89 |   virtual std::string getHumanReadable() const override;
90 | 
91 |  private:
92 |   Impl p;
93 | };
94 | 
95 | }// namespace fredemmott::inputmapping
96 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/MappableInput.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
 3 |  * All rights reserved.
 4 |  *
 5 |  * This source code is licensed under the ISC license found in the LICENSE file
 6 |  * in the root directory of this source tree.
 7 |  */
 8 | #pragma once
 9 | 
10 | #include <cpp-remapper/AxisInformation.h>
11 | #include <cpp-remapper/InputDevice.h>
12 | #include <cpp-remapper/SourcePtr.h>
13 | 
14 | #include <cstdint>
15 | 
16 | namespace fredemmott::inputmapping {
17 | 
18 | class EventSource;
19 | 
20 | class MappableInput final {
21 |  private:
22 |   class Impl;
23 |   std::shared_ptr<Impl> p;
24 | 
25 |  public:
26 |   MappableInput(const std::shared_ptr<InputDevice>& dev);
27 |   MappableInput(const MappableInput& other) = default;
28 |   ~MappableInput();
29 | 
30 |   std::shared_ptr<EventSource> getEventSource() const;
31 | 
32 |   AxisSourcePtr axis(uint8_t id) const;
33 |   ButtonSourcePtr button(uint8_t id) const;
34 |   HatSourcePtr hat(uint8_t id) const;
35 | 
36 |   // Convenience
37 | 
38 |   size_t getAxisCount() const;
39 |   size_t getButtonCount() const;
40 |   size_t getHatCount() const;
41 | 
42 |   AxisSourcePtr XAxis, YAxis, ZAxis, RXAxis, RYAxis, RZAxis, Slider, Dial;
43 | 
44 |   // `seq 1 128 | gsed 's/.\+/Button\0,/' | xargs -n 4 echo` :)
45 |   ButtonSourcePtr Button1, Button2, Button3, Button4, Button5, Button6, Button7,
46 |     Button8, Button9, Button10, Button11, Button12, Button13, Button14,
47 |     Button15, Button16, Button17, Button18, Button19, Button20, Button21,
48 |     Button22, Button23, Button24, Button25, Button26, Button27, Button28,
49 |     Button29, Button30, Button31, Button32, Button33, Button34, Button35,
50 |     Button36, Button37, Button38, Button39, Button40, Button41, Button42,
51 |     Button43, Button44, Button45, Button46, Button47, Button48, Button49,
52 |     Button50, Button51, Button52, Button53, Button54, Button55, Button56,
53 |     Button57, Button58, Button59, Button60, Button61, Button62, Button63,
54 |     Button64, Button65, Button66, Button67, Button68, Button69, Button70,
55 |     Button71, Button72, Button73, Button74, Button75, Button76, Button77,
56 |     Button78, Button79, Button80, Button81, Button82, Button83, Button84,
57 |     Button85, Button86, Button87, Button88, Button89, Button90, Button91,
58 |     Button92, Button93, Button94, Button95, Button96, Button97, Button98,
59 |     Button99, Button100, Button101, Button102, Button103, Button104, Button105,
60 |     Button106, Button107, Button108, Button109, Button110, Button111, Button112,
61 |     Button113, Button114, Button115, Button116, Button117, Button118, Button119,
62 |     Button120, Button121, Button122, Button123, Button124, Button125, Button126,
63 |     Button127, Button128;
64 | 
65 |   HatSourcePtr Hat1, Hat2, Hat3, Hat4;
66 | };
67 | }// namespace fredemmott::inputmapping
68 | 


--------------------------------------------------------------------------------
/lib/Profile.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/Profile.h>
  9 | 
 10 | #include <algorithm>
 11 | #include <cstdio>
 12 | 
 13 | #include <cpp-remapper/EventLoop.h>
 14 | #include <cpp-remapper/HidHide.h>
 15 | #include <cpp-remapper/InputDevice.h>
 16 | #include <cpp-remapper/InputDeviceCollection.h>
 17 | #include <cpp-remapper/MappableInput.h>
 18 | #include <cpp-remapper/MappableVJoyOutput.h>
 19 | #include <cpp-remapper/VJoyDevice.h>
 20 | #include <cpp-remapper/connections.h>
 21 | 
 22 | using namespace fredemmott::inputmapping;
 23 | 
 24 | namespace fredemmott::inputmapping {
 25 | struct Profile::Impl {
 26 |   std::shared_ptr<EventLoop> EventLoop;
 27 |   std::unique_ptr<HidHide> guardian;
 28 | };
 29 | 
 30 | Profile::Profile(const std::vector<HiddenDevice>& ids) : p(std::make_unique<Impl>()) {
 31 |   std::vector<DeviceSpecifier> specifiers;
 32 |   std::ranges::transform(ids, std::back_inserter(specifiers), [](auto it) {
 33 |     return it.getSpecifier();
 34 |   });
 35 |   *p = {
 36 |     std::make_shared<EventLoop>(),
 37 |     std::make_unique<HidHide>(specifiers),
 38 |   };
 39 | }
 40 | 
 41 | Profile::Profile(Profile&& moved) : p(std::move(moved.p)) {
 42 | }
 43 | 
 44 | Profile::~Profile() {
 45 | }
 46 | 
 47 | std::shared_ptr<EventLoop> Profile::getEventLoop() const {
 48 |   return p->EventLoop;
 49 | }
 50 | 
 51 | void Profile::run() {
 52 |   getEventLoop()->run();
 53 | }
 54 | 
 55 | DeviceWithVisibility::DeviceWithVisibility(const DeviceSpecifier& ds)
 56 |   : impl(ds) {
 57 | }
 58 | 
 59 | DeviceSpecifier DeviceWithVisibility::getSpecifier() const {
 60 |   return impl;
 61 | }
 62 | 
 63 | }// namespace fredemmott::inputmapping
 64 | 
 65 | namespace fredemmott::inputmapping::detail {
 66 | 
 67 | MappableInput get_device(InputDeviceCollection* c, const DeviceSpecifier& id) {
 68 |   auto device = c->get(id);
 69 |   if (!device) {
 70 |     auto desc = id.getHumanReadable();
 71 |     printf("ERROR: Failed to find device '%s'\n", desc.c_str());
 72 |     exit(0);
 73 |   }
 74 |   MappableInput ret(device);
 75 |   auto name = device->getProductName();
 76 |   auto instance_id = device->getInstanceID().getHumanReadable();
 77 |   auto hardware_id = device->getHardwareID().getHumanReadable();
 78 |   printf(
 79 |     "Found \"%s\":\n  %s\n  %s\n",
 80 |     name.c_str(),
 81 |     instance_id.c_str(),
 82 |     hardware_id.c_str());
 83 |   return ret;
 84 | }
 85 | 
 86 | std::tuple<> get_devices(Profile*, InputDeviceCollection*) {
 87 |   return std::make_tuple();
 88 | }
 89 | 
 90 | std::vector<std::shared_ptr<EventSource>> get_event_sources() {
 91 |   return {};
 92 | }
 93 | 
 94 | std::vector<std::shared_ptr<EventSink>> get_event_sinks() {
 95 |   return {};
 96 | }
 97 | 
 98 | void fill_hidden_ids(std::vector<HiddenDevice>&) {
 99 | }
100 | 
101 | }// namespace fredemmott::inputmapping::detail
102 | 


--------------------------------------------------------------------------------
/lib/DS4Device.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/Controls.h>
  9 | #include <cpp-remapper/DS4Device.h>
 10 | #include <cpp-remapper/ViGEmClient.h>
 11 | #include <cpp-remapper/ViGEmTarget.h>
 12 | 
 13 | #include <iostream>
 14 | 
 15 | namespace fredemmott::inputmapping {
 16 | 
 17 | class DS4Device::Impl final
 18 |   : public detail::ViGEmTarget<DS4_REPORT, DS4Device::Impl> {
 19 |  public:
 20 |   static void initState(DS4_REPORT* state) {
 21 |     DS4_REPORT_INIT(state);
 22 |   }
 23 | 
 24 |   static PVIGEM_TARGET allocTarget() {
 25 |     return vigem_target_ds4_alloc();
 26 |   }
 27 | 
 28 |   static const char* productShortName() {
 29 |     return "DS4 pad";
 30 |   }
 31 | };
 32 | 
 33 | DS4Device::DS4Device() : p(new Impl()) {
 34 |   if (p) {
 35 |     std::cout << "Attached ViGEm DS4 pad." << std::endl;
 36 |     return;
 37 |   }
 38 | 
 39 |   std::cerr << "---\nERROR\n---\nFailed to initialize ViGEm DS4 pad."
 40 |             << std::endl;
 41 |   exit(1);
 42 | }
 43 | 
 44 | DS4Device::~DS4Device() {
 45 | }
 46 | 
 47 | void DS4Device::flush() {
 48 |   auto& client = ViGEmClient::get();
 49 |   if (!client) {
 50 |     return;
 51 |   }
 52 |   vigem_target_ds4_update(client, p->pad, p->state);
 53 | }
 54 | 
 55 | DS4Device* DS4Device::setButton(Button button, bool value) {
 56 |   if (value) {
 57 |     p->state.wButtons |= static_cast<USHORT>(button);
 58 |   } else {
 59 |     p->state.wButtons &= ~static_cast<USHORT>(button);
 60 |   }
 61 |   return this;
 62 | }
 63 | 
 64 | DS4Device* DS4Device::setButton(SpecialButton button, bool value) {
 65 |   if (value) {
 66 |     p->state.bSpecial |= static_cast<BYTE>(button);
 67 |   } else {
 68 |     p->state.bSpecial &= ~static_cast<BYTE>(button);
 69 |   }
 70 |   return this;
 71 | }
 72 | 
 73 | DS4Device* DS4Device::setDPad(DPadDirection dpad) {
 74 |   DS4_SET_DPAD(&p->state, (DS4_DPAD_DIRECTIONS)dpad);
 75 |   return this;
 76 | }
 77 | 
 78 | namespace {
 79 | inline BYTE scale_axis(long value) {
 80 |   return (value * 255) / 65535;
 81 | }
 82 | }// namespace
 83 | 
 84 | DS4Device* DS4Device::setLXAxis(long value) {
 85 |   p->state.bThumbLX = scale_axis(value);
 86 |   return this;
 87 | }
 88 | DS4Device* DS4Device::setLYAxis(long value) {
 89 |   p->state.bThumbLY = scale_axis(value);
 90 |   return this;
 91 | }
 92 | DS4Device* DS4Device::setRXAxis(long value) {
 93 |   p->state.bThumbRX = scale_axis(value);
 94 |   return this;
 95 | }
 96 | DS4Device* DS4Device::setRYAxis(long value) {
 97 |   p->state.bThumbRY = scale_axis(value);
 98 |   return this;
 99 | }
100 | 
101 | DS4Device* DS4Device::setLTrigger(long value) {
102 |   p->state.bTriggerL = scale_axis(value);
103 |   return this;
104 | }
105 | DS4Device* DS4Device::setRTrigger(long value) {
106 |   p->state.bTriggerR = scale_axis(value);
107 |   return this;
108 | }
109 | 
110 | }// namespace fredemmott::inputmapping
111 | 


--------------------------------------------------------------------------------
/lib/render_axis.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | 
  9 | #include <cpp-remapper/render_axis.h>
 10 | 
 11 | #include <fstream>
 12 | 
 13 | #include <cpp-remapper/connections.h>
 14 | 
 15 | using std::ios;
 16 | using std::ofstream;
 17 | 
 18 | #pragma pack(push)
 19 | #pragma pack(1)
 20 | namespace {
 21 | struct Pixel {
 22 |   uint8_t b;
 23 |   uint8_t g;
 24 |   uint8_t r;
 25 |   // We don't use alpha, but it means we don't need to deal with 4-byte
 26 |   // padding at the end of each line
 27 |   uint8_t a = 0xff;
 28 | };
 29 | struct DIBHeader {
 30 |   uint32_t size = sizeof(DIBHeader);
 31 |   uint32_t width;
 32 |   uint32_t height;
 33 |   uint16_t color_planes = 1;
 34 |   uint16_t bits_per_pixel = 32;
 35 |   uint32_t format = 0;// BI_BITFIELD
 36 |   uint32_t data_size;
 37 |   uint32_t x_dpi = 72;
 38 |   uint32_t y_dpi = 72;
 39 |   uint32_t palette_colors = 0;
 40 |   uint32_t important_colors = 0;// all
 41 | };
 42 | struct BMPHeader {
 43 |   char magic[2] = {'B', 'M'};
 44 |   uint32_t file_size;
 45 |   uint16_t app_defined_1 = 0;
 46 |   uint16_t app_defined_2 = 0;
 47 |   uint32_t data_offset;
 48 | };
 49 | }// namespace
 50 | #pragma pack(pop)
 51 | 
 52 | namespace fredemmott::inputmapping {
 53 | 
 54 | void render_axis(
 55 |   const std::string& bmp_filename,
 56 |   AxisSinkPtr transform_in,
 57 |   AxisSourcePtr transform_out) {
 58 |   long fx = -1;
 59 |   transform_out >> &fx;
 60 |   const int step = 128;
 61 |   // + 1 for 'max value' vs 'number of distinct values'
 62 |   const auto resolution = (0xffff + 1) / step;
 63 | 
 64 |   auto data = std::make_unique<Pixel[]>(resolution * resolution);
 65 |   // fill with white
 66 |   memset(data.get(), 0xff, resolution * resolution * sizeof(Pixel));
 67 | 
 68 |   // draw axis in black
 69 |   auto offset = [&](int x, int y) { return (x + (y * resolution)); };
 70 |   for (int i = 0; i < resolution; ++i) {
 71 |     data[offset(i, resolution / 2)] = {0, 0, 0};
 72 |     data[offset(resolution / 2, i)] = {0, 0, 0};
 73 |   }
 74 | 
 75 |   // finally, the values :)
 76 |   for (int i = 0; i <= 0xffff; ++i) {
 77 |     transform_in->map(i);
 78 |     const auto x = i / step;
 79 |     const auto y = fx / step;
 80 |     Pixel& p = data[offset(x, y)];
 81 |     // The more inputs hit this pixel, the bluer it gets
 82 |     p.r -= 0xff / step;
 83 |     p.g -= 0xff / step;
 84 |     p.b = 0xff;
 85 |   }
 86 | 
 87 |   // Now to convert raw pixel data to a BMP image
 88 |   DIBHeader dib;
 89 |   dib.width = dib.height = resolution;
 90 |   dib.data_size = resolution * resolution * sizeof(Pixel);
 91 |   BMPHeader bmp;
 92 |   bmp.file_size = sizeof(bmp) + sizeof(dib) + dib.data_size;
 93 |   bmp.data_offset = sizeof(bmp) + sizeof(dib);
 94 | 
 95 |   ofstream file;
 96 |   file.open(bmp_filename, ios::out | ios::trunc | ios::binary);
 97 |   file.write((const char*)&bmp, sizeof(bmp));
 98 |   file.write((const char*)&dib, sizeof(dib));
 99 |   file.write((const char*)data.get(), dib.data_size);
100 |   file.close();
101 |   printf("Wrote to %s\n", bmp_filename.data());
102 | }
103 | 
104 | }// namespace fredemmott::inputmapping
105 | 


--------------------------------------------------------------------------------
/tests/connections_test.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | 
  9 | #include <cpp-remapper/connections.h>
 10 | 
 11 | #include <concepts>
 12 | 
 13 | #include <cpp-remapper/AxisCurve.h>
 14 | #include <cpp-remapper/AxisToButtons.h>
 15 | #include <cpp-remapper/MappableInput.h>
 16 | #include <cpp-remapper/MappableVJoyOutput.h>
 17 | #include <cpp-remapper/SquareDeadzone.h>
 18 | #include "tests.h"
 19 | 
 20 | using namespace fredemmott::inputmapping;
 21 | 
 22 | TEST_CASE("SourcePtr >> Value*") {
 23 |   Axis::Value out(-1);
 24 |   auto axis = std::make_shared<TestAxis>();
 25 |   axis >> &out;
 26 |   axis->emit(123);
 27 |   REQUIRE(out == 123);
 28 | }
 29 | 
 30 | TEST_CASE("Source& >> Value*") {
 31 |   Axis::Value out = -1;
 32 |   TestAxis axis;
 33 |   axis >> &out;
 34 |   axis.emit(123);
 35 |   REQUIRE(out == 123);
 36 | }
 37 | 
 38 | TEST_CASE("Source& >> Sink&&") {
 39 |   bool b1 = false, b2 = false;
 40 |   TestAxis axis;
 41 |   axis >> AxisToButtons {
 42 |     {0_percent, 10_percent, [&b1](bool value) { b1 = value; }},
 43 |     {90_percent, 100_percent, [&b2](bool value) { b2 = value; }}};
 44 |   axis.emit(0);
 45 |   REQUIRE(b1);
 46 |   REQUIRE(!b2);
 47 |   axis.emit(Axis::MAX / 10);
 48 |   REQUIRE(b1);
 49 |   REQUIRE(!b2);
 50 |   axis.emit(Axis::MAX / 2);
 51 |   REQUIRE(!b1);
 52 |   REQUIRE(!b2);
 53 |   axis.emit(Axis::MAX);
 54 |   REQUIRE(!b1);
 55 |   REQUIRE(b2);
 56 | }
 57 | 
 58 | TEST_CASE("Source& >> Transform*") {
 59 |   // Testing the plumbing of >>, not the specific transform
 60 |   long out = -1;
 61 |   TestAxis axis;
 62 |   SquareDeadzone dz(10_percent);
 63 | 
 64 |   axis >> &dz >> &out;
 65 |   axis.emit(0);
 66 |   REQUIRE(out == 0);
 67 |   axis.emit(Axis::MAX);
 68 |   REQUIRE(out == Axis::MAX);
 69 |   axis.emit(100);
 70 |   REQUIRE(out > 100);
 71 |   axis.emit(Axis::MAX - 100);
 72 |   REQUIRE(out < Axis::MAX - 100);
 73 | }
 74 | 
 75 | TEST_CASE("Source& >> Transform&&") {
 76 |   // Testing the plumbing of >>, not the specific transform
 77 |   long out = -1;
 78 |   TestAxis axis;
 79 |   SquareDeadzone dz(10_percent);
 80 | 
 81 |   // Via temporary
 82 |   axis >> SquareDeadzone {10_percent} >> &out;
 83 |   axis.emit(0);
 84 |   REQUIRE(out == 0);
 85 |   axis.emit(Axis::MAX);
 86 |   REQUIRE(out == Axis::MAX);
 87 | }
 88 | 
 89 | namespace {
 90 | 
 91 | void static_test_transform_pipelines() {
 92 |   auto x = std::make_shared<SquareDeadzone>(50_percent)
 93 |     >> std::make_shared<AxisCurve>(0.5);
 94 |   static_assert(
 95 |     std::same_as<decltype(x), std::shared_ptr<TransformPipeline<Axis, Axis>>>);
 96 | 
 97 |   auto y = std::make_shared<SquareDeadzone>(50_percent) >> AxisCurve(0.5);
 98 |   static_assert(std::same_as<decltype(x), decltype(y)>);
 99 | 
100 |   auto z = SquareDeadzone(50_percent) >> AxisCurve(0.5);
101 |   static_assert(std::same_as<decltype(x), decltype(z)>);
102 | }
103 | 
104 | void static_test_transfomed_source_pipelines() {
105 |   MappableInput stick(nullptr);
106 |   MappableVJoyOutput vj(nullptr);
107 |   stick.XAxis >> SquareDeadzone(10_percent) >> AxisCurve(-0.5) >> vj.XAxis;
108 | }
109 | 
110 | }// namespace
111 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/SinkPtr.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #pragma once
  9 | 
 10 | #include <concepts>
 11 | #include <functional>
 12 | #include <memory>
 13 | #include <type_traits>
 14 | 
 15 | #include <cpp-remapper/Controls.h>
 16 | #include <cpp-remapper/FunctionSink.h>
 17 | #include <cpp-remapper/Source.h>
 18 | #include <cpp-remapper/maybe_shared_ptr.h>
 19 | 
 20 | namespace fredemmott::inputmapping {
 21 | 
 22 | // clang-format off
 23 | template<typename T>
 24 | concept any_sink_ptr =
 25 |   any_sink<typename T::element_type>
 26 |   && std::convertible_to<T, maybe_shared_ptr<typename T::element_type>>;
 27 | 
 28 | template<typename T, typename TControl>
 29 | concept sink_ptr =
 30 |   any_sink_ptr<T>
 31 |   && sink<typename T::element_type, TControl>;
 32 | // clang-format on
 33 | 
 34 | template <typename T>
 35 | auto convert_to_any_sink_ptr(T&& in) {
 36 |   using DT = std::decay_t<T>;
 37 | 
 38 |   if constexpr (any_sink_ptr<DT>) {
 39 |     return in;
 40 |   }
 41 | 
 42 |   if constexpr (any_sink<DT>) {
 43 |     return maybe_shared_ptr<DT>(std::forward<T>(in));
 44 |   }
 45 | 
 46 |   if constexpr (any_sink<std::remove_pointer_t<DT>>) {
 47 |     return maybe_shared_ptr<DT>(std::forward<T>(in));
 48 |   }
 49 | 
 50 |   // Can't infer the inner generic :(
 51 |   if constexpr (sink_invocable<DT, Axis>) {
 52 |     return std::make_shared<FunctionSink<Axis>>(in);
 53 |   }
 54 |   if constexpr (sink_invocable<DT, Button>) {
 55 |     return std::make_shared<FunctionSink<Button>>(in);
 56 |   }
 57 |   if constexpr (sink_invocable<DT, Hat>) {
 58 |     return std::make_shared<FunctionSink<Hat>>(in);
 59 |   }
 60 | 
 61 |   if constexpr (std::same_as<DT, Axis::Value*>) {
 62 |     return std::make_shared<FunctionSink<Axis>>(
 63 |       [in](Axis::Value v) { *in = v; });
 64 |   }
 65 | 
 66 |   if constexpr (std::same_as<DT, Button::Value*>) {
 67 |     return std::make_shared<FunctionSink<Button>>(
 68 |       [in](Button::Value v) { *in = v; });
 69 |   }
 70 | 
 71 |   if constexpr (std::same_as<DT, Hat::Value*>) {
 72 |     return std::make_shared<FunctionSink<Hat>>([in](Hat::Value v) { *in = v; });
 73 |   }
 74 | }
 75 | 
 76 | // clang-format off
 77 | template <typename T>
 78 | concept convertible_to_any_sink_ptr = requires(T x) {
 79 |   { convert_to_any_sink_ptr(x) } -> any_sink_ptr;
 80 | };
 81 | 
 82 | template<typename T>
 83 | concept non_id_convertible_to_any_sink_ptr =
 84 |   !any_sink_ptr<std::decay_t<T>>
 85 |   && convertible_to_any_sink_ptr<T>;
 86 | 
 87 | template <typename T, typename TControl>
 88 | concept convertible_to_sink_ptr = requires(T x) {
 89 |   { convert_to_any_sink_ptr(x) } -> sink_ptr<TControl>;
 90 | };
 91 | 
 92 | template<typename T, typename TControl>
 93 | concept non_id_convertible_to_sink_ptr =
 94 |   !any_sink_ptr<T>
 95 |   && convertible_to_sink_ptr<T, TControl>;
 96 | // clang-format on
 97 | 
 98 | template <control TControl>
 99 | class SinkPtr : public maybe_shared_ptr<Sink<TControl>> {
100 |  public:
101 |   using maybe_shared_ptr<Sink<TControl>>::maybe_shared_ptr;
102 | 
103 |   template <typename T>
104 |     requires non_id_convertible_to_sink_ptr<T, TControl> SinkPtr(T in) {
105 |       *this = convert_to_any_sink_ptr(std::forward<T>(in));
106 |     }
107 | };
108 | 
109 | using AxisSinkPtr = SinkPtr<Axis>;
110 | using ButtonSinkPtr = SinkPtr<Button>;
111 | using HatSinkPtr = SinkPtr<Hat>;
112 | 
113 | }// namespace fredemmott::inputmapping
114 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/HatToButtons.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #pragma once
  9 | 
 10 | #include <cstdint>
 11 | #include <optional>
 12 | #include <vector>
 13 | 
 14 | #include <cpp-remapper/Sink.h>
 15 | #include <cpp-remapper/SinkPtr.h>
 16 | 
 17 | namespace fredemmott::inputmapping {
 18 | 
 19 | class MappableVJoyOutput;
 20 | 
 21 | class HatToButtons final : public Sink<Hat> {
 22 |  public:
 23 |   enum class Interpolation {
 24 |     // divide range by number of buttons, only press button when hat is pointing
 25 |     // *exactly* at it - e.g. 0 degrees == press button 1, 1 degree and 359 degrees
 26 |     // == press nothing
 27 |     None,
 28 |     // fill the range, and interpolate. e.g. if there are 4 buttons, if hat is
 29 |     // pointing North East, press both buttons 1 and 2
 30 |     MultiPress,
 31 |   };
 32 |   class CenterButton {
 33 |    private:
 34 |     ButtonSinkPtr mButton;
 35 | 
 36 |    public:
 37 |     // clang-format off
 38 |     template <typename T>
 39 |     requires
 40 |       (!std::derived_from<std::decay_t<T>, CenterButton>) // needed by clang
 41 |       && convertible_to_sink_ptr<T, Button>
 42 |       // clang-format on
 43 |       explicit CenterButton(T&& button)
 44 |       : mButton(convert_to_any_sink_ptr(std::forward<T>(button))) {
 45 |     }
 46 | 
 47 |     const ButtonSinkPtr& get() const;
 48 |   };
 49 |   static_assert(!convertible_to_any_sink_ptr<CenterButton>);
 50 | 
 51 |   HatToButtons() = delete;
 52 | 
 53 |   HatToButtons(MappableVJoyOutput* output, uint8_t first, uint8_t count);
 54 | 
 55 |   HatToButtons(
 56 |     const CenterButton& center,
 57 |     MappableVJoyOutput* output,
 58 |     uint8_t first,
 59 |     uint8_t count);
 60 | 
 61 |   // clang-format off
 62 |   template <typename First, convertible_to_sink_ptr<Button>... Rest>
 63 |   requires
 64 |     (!std::derived_from<std::decay_t<First>, HatToButtons>) // needed by clang
 65 |     && convertible_to_sink_ptr<First, Button>
 66 |   // clang-format on
 67 |   HatToButtons(First&& first, Rest&&... rest) {
 68 |     mButtons = {
 69 |       convert_to_any_sink_ptr(std::forward<First>(first)),
 70 |       convert_to_any_sink_ptr(std::forward<Rest>(rest))...};
 71 |   }
 72 | 
 73 |   template <
 74 |     convertible_to_sink_ptr<Button> First,
 75 |     convertible_to_sink_ptr<Button>... Rest>
 76 |   HatToButtons(const CenterButton& center, First&& first, Rest&&... rest) {
 77 |     mCenter = center.get();
 78 |     mButtons = {
 79 |       convert_to_any_sink_ptr(std::forward<First>(first)),
 80 |       convert_to_any_sink_ptr(std::forward<Rest>(rest))...};
 81 |   }
 82 | 
 83 |   template <class... Rest>
 84 |   HatToButtons(Interpolation interpolation, Rest&&... rest)
 85 |     : HatToButtons(std::forward<Rest>(rest)...) {
 86 |     mInterpolation = interpolation;
 87 |   }
 88 | 
 89 |   virtual void map(Hat::Value value) override;
 90 | 
 91 |  private:
 92 |   Interpolation mInterpolation = Interpolation::MultiPress;
 93 |   std::optional<ButtonSinkPtr> mCenter;
 94 |   std::vector<ButtonSinkPtr> mButtons;
 95 | 
 96 |   void assignToVJoy(MappableVJoyOutput* output, uint8_t first, uint8_t count);
 97 | };
 98 | 
 99 | // Given we're doing funky template overloads for the constructors, let's make
100 | // sure that we've not accidentally defined an implicit conversion path
101 | static_assert(!convertible_to_sink_ptr<HatToButtons, Axis>);
102 | static_assert(!convertible_to_sink_ptr<HatToButtons, Button>);
103 | static_assert(convertible_to_sink_ptr<HatToButtons, Hat>);
104 | 
105 | }// namespace fredemmott::inputmapping
106 | 


--------------------------------------------------------------------------------
/lib/MappableVJoyOutput.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/MappableVJoyOutput.h>
  9 | 
 10 | #include <cpp-remapper/AxisInformation.h>
 11 | #include <cpp-remapper/InputDevice.h>
 12 | #include <cpp-remapper/VJoyDevice.h>
 13 | 
 14 | namespace fredemmott::inputmapping {
 15 | 
 16 | MappableVJoyOutput::MappableVJoyOutput(uint8_t vjoy_id)
 17 |   : MappableVJoyOutput(std::make_shared<VJoyDevice>(vjoy_id)) {
 18 | }
 19 | 
 20 | MappableVJoyOutput::MappableVJoyOutput(std::shared_ptr<VJoyDevice> dev)
 21 |   : mDevice(dev),
 22 | #define A(a) a([dev](long value) { dev->set##a(value); })
 23 | #define AA(a) A(a##Axis)
 24 |     AA(X),
 25 |     AA(Y),
 26 |     AA(Z),
 27 |     AA(RX),
 28 |     AA(RY),
 29 |     AA(RZ),
 30 | #undef AA
 31 |     A(Slider),
 32 |     A(Dial),
 33 | #undef A
 34 | #define B(n) Button##n(button(n))
 35 |     B(1),
 36 |     B(2),
 37 |     B(3),
 38 |     B(4),
 39 |     B(5),
 40 |     B(6),
 41 |     B(7),
 42 |     B(8),
 43 |     B(9),
 44 |     B(10),
 45 |     B(11),
 46 |     B(12),
 47 |     B(13),
 48 |     B(14),
 49 |     B(15),
 50 |     B(16),
 51 |     B(17),
 52 |     B(18),
 53 |     B(19),
 54 |     B(20),
 55 |     B(21),
 56 |     B(22),
 57 |     B(23),
 58 |     B(24),
 59 |     B(25),
 60 |     B(26),
 61 |     B(27),
 62 |     B(28),
 63 |     B(29),
 64 |     B(30),
 65 |     B(31),
 66 |     B(32),
 67 |     B(33),
 68 |     B(34),
 69 |     B(35),
 70 |     B(36),
 71 |     B(37),
 72 |     B(38),
 73 |     B(39),
 74 |     B(40),
 75 |     B(41),
 76 |     B(42),
 77 |     B(43),
 78 |     B(44),
 79 |     B(45),
 80 |     B(46),
 81 |     B(47),
 82 |     B(48),
 83 |     B(49),
 84 |     B(50),
 85 |     B(51),
 86 |     B(52),
 87 |     B(53),
 88 |     B(54),
 89 |     B(55),
 90 |     B(56),
 91 |     B(57),
 92 |     B(58),
 93 |     B(59),
 94 |     B(60),
 95 |     B(61),
 96 |     B(62),
 97 |     B(63),
 98 |     B(64),
 99 |     B(65),
100 |     B(66),
101 |     B(67),
102 |     B(68),
103 |     B(69),
104 |     B(70),
105 |     B(71),
106 |     B(72),
107 |     B(73),
108 |     B(74),
109 |     B(75),
110 |     B(76),
111 |     B(77),
112 |     B(78),
113 |     B(79),
114 |     B(80),
115 |     B(81),
116 |     B(82),
117 |     B(83),
118 |     B(84),
119 |     B(85),
120 |     B(86),
121 |     B(87),
122 |     B(88),
123 |     B(89),
124 |     B(90),
125 |     B(91),
126 |     B(92),
127 |     B(93),
128 |     B(94),
129 |     B(95),
130 |     B(96),
131 |     B(97),
132 |     B(98),
133 |     B(99),
134 |     B(100),
135 |     B(101),
136 |     B(102),
137 |     B(103),
138 |     B(104),
139 |     B(105),
140 |     B(106),
141 |     B(107),
142 |     B(108),
143 |     B(109),
144 |     B(110),
145 |     B(111),
146 |     B(112),
147 |     B(113),
148 |     B(114),
149 |     B(115),
150 |     B(116),
151 |     B(117),
152 |     B(118),
153 |     B(119),
154 |     B(120),
155 |     B(121),
156 |     B(122),
157 |     B(123),
158 |     B(124),
159 |     B(125),
160 |     B(126),
161 |     B(127),
162 |     B(128),
163 | #undef B
164 | #define H(n) Hat##n(hat(n))
165 |     H(1),
166 |     H(2),
167 |     H(3),
168 |     H(4)
169 | #undef H
170 | {
171 | }
172 | 
173 | MappableVJoyOutput::~MappableVJoyOutput() {
174 | }
175 | 
176 | std::shared_ptr<OutputDevice> MappableVJoyOutput::getDevice() const {
177 |   return mDevice;
178 | }
179 | 
180 | ButtonSinkPtr MappableVJoyOutput::button(uint8_t id) const {
181 |   return
182 |     [dev = mDevice, id](Button::Value value) { dev->setButton(id, value); };
183 | }
184 | 
185 | HatSinkPtr MappableVJoyOutput::hat(uint8_t id) const {
186 |   return [dev = mDevice, id](Hat::Value value) { dev->setHat(id, value); };
187 | }
188 | 
189 | }// namespace fredemmott::inputmapping
190 | 


--------------------------------------------------------------------------------
/tests/HatToButtons_test.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | 
  9 | #include <cpp-remapper/HatToButtons.h>
 10 | 
 11 | #include <cpp-remapper/MappableVJoyOutput.h>
 12 | #include "tests.h"
 13 | 
 14 | using namespace fredemmott::inputmapping;
 15 | 
 16 | TEST_CASE("HatToButtons") {
 17 |   TestHat hat;
 18 |   Button::Value c, n, e, s, w;
 19 | 
 20 |   SECTION("Without Center") {
 21 |     hat >> HatToButtons(&n, &e, &s, &w);
 22 |     hat.emit(Hat::CENTER);
 23 |     REQUIRE(!n);
 24 |     REQUIRE(!e);
 25 |     REQUIRE(!s);
 26 |     REQUIRE(!w);
 27 | 
 28 |     hat.emit(Hat::NORTH);
 29 |     REQUIRE(n);
 30 |     REQUIRE(!e);
 31 |     REQUIRE(!s);
 32 |     REQUIRE(!w);
 33 | 
 34 |     hat.emit(Hat::NORTH_EAST);
 35 |     REQUIRE(n);
 36 |     REQUIRE(e);
 37 |     REQUIRE(!s);
 38 |     REQUIRE(!w);
 39 | 
 40 |     hat.emit(Hat::EAST);
 41 |     REQUIRE(!n);
 42 |     REQUIRE(e);
 43 |     REQUIRE(!s);
 44 |     REQUIRE(!w);
 45 | 
 46 |     hat.emit(Hat::SOUTH_EAST);
 47 |     REQUIRE(!n);
 48 |     REQUIRE(e);
 49 |     REQUIRE(s);
 50 |     REQUIRE(!w);
 51 | 
 52 |     hat.emit(Hat::SOUTH);
 53 |     REQUIRE(!n);
 54 |     REQUIRE(!e);
 55 |     REQUIRE(s);
 56 |     REQUIRE(!w);
 57 | 
 58 |     hat.emit(Hat::SOUTH_WEST);
 59 |     REQUIRE(!n);
 60 |     REQUIRE(!e);
 61 |     REQUIRE(s);
 62 |     REQUIRE(w);
 63 | 
 64 |     hat.emit(Hat::WEST);
 65 |     REQUIRE(!n);
 66 |     REQUIRE(!e);
 67 |     REQUIRE(!s);
 68 |     REQUIRE(w);
 69 | 
 70 |     hat.emit(Hat::NORTH_WEST);
 71 |     REQUIRE(n);
 72 |     REQUIRE(!e);
 73 |     REQUIRE(!s);
 74 |     REQUIRE(w);
 75 | 
 76 |     hat.emit(Hat::CENTER);
 77 |     REQUIRE(!n);
 78 |     REQUIRE(!e);
 79 |     REQUIRE(!s);
 80 |     REQUIRE(!w);
 81 | 
 82 |     // Let's spot-check a few edge cases: have 8 different button
 83 |     // combinations, so the boundaries should be at a 16th of a circle
 84 |     const auto delta = std::lround(Hat::MAX / 16.0);
 85 | 
 86 |     hat.emit(Hat::NORTH + delta);
 87 |     REQUIRE(n);
 88 |     REQUIRE(!e);
 89 | 
 90 |     hat.emit(Hat::NORTH + delta + 1);
 91 |     REQUIRE(n);
 92 |     REQUIRE(e);
 93 | 
 94 |     hat.emit(Hat::SOUTH + delta);
 95 |     REQUIRE(s);
 96 |     REQUIRE(!w);
 97 | 
 98 |     hat.emit(Hat::SOUTH + delta + 1);
 99 |     REQUIRE(s);
100 |     REQUIRE(w);
101 | 
102 |     hat.emit(Hat::NORTH_WEST + delta);
103 |     REQUIRE(n);
104 |     REQUIRE(w);
105 | 
106 |     hat.emit(Hat::NORTH_WEST + delta + 1);
107 |     REQUIRE(n);
108 |     REQUIRE(!w);
109 |   }
110 | 
111 |   SECTION("With Center") {
112 |     hat >> HatToButtons(HatToButtons::CenterButton(&c), &n, &e, &s, &w);
113 |     hat.emit(Hat::CENTER);
114 |     REQUIRE(c);
115 |     REQUIRE(!n);
116 |     REQUIRE(!e);
117 |     REQUIRE(!s);
118 |     REQUIRE(!w);
119 | 
120 |     hat.emit(Hat::NORTH);
121 |     REQUIRE(!c);
122 |     REQUIRE(n);
123 | 
124 |     hat.emit(Hat::EAST);
125 |     REQUIRE(!c);
126 |     REQUIRE(!n);
127 |     REQUIRE(e);
128 | 
129 |     hat.emit(Hat::CENTER);
130 |     REQUIRE(c);
131 |     REQUIRE(!n);
132 |     REQUIRE(!e);
133 |     REQUIRE(!s);
134 |     REQUIRE(!w);
135 |   }
136 | 
137 |   SECTION("Without Interpolation") {
138 |     hat >> HatToButtons(HatToButtons::Interpolation::None, &n, &e, &s, &w);
139 |     hat.emit(Hat::NORTH);
140 |     REQUIRE(n);
141 |     REQUIRE(!e);
142 |     REQUIRE(!s);
143 |     REQUIRE(!w);
144 |     hat.emit(Hat::NORTH + 1);
145 |     REQUIRE(!n);
146 |     REQUIRE(!e);
147 |     hat.emit(Hat::MAX - 1);
148 |     REQUIRE(!n);
149 |     REQUIRE(!w);
150 |     hat.emit(Hat::EAST);
151 |     REQUIRE(!n);
152 |     REQUIRE(!w);
153 |     REQUIRE(!s);
154 |     hat.emit(Hat::EAST - 1);
155 |     REQUIRE(!n);
156 |     REQUIRE(!e);
157 |     hat.emit(Hat::EAST + 1);
158 |     REQUIRE(!e);
159 |     REQUIRE(!s);
160 |   }
161 | }
162 | 
163 | namespace {
164 | static void static_test() {
165 |   MappableVJoyOutput o(nullptr);
166 |   HatToButtons(&o, 123, 4);
167 |   bool center;
168 |   HatToButtons(HatToButtons::CenterButton(&center), &o, 123, 4);
169 | }
170 | }// namespace
171 | 


--------------------------------------------------------------------------------
/lib/EventLoop.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/EventLoop.h>
  9 | #include <cpp-remapper/EventSink.h>
 10 | #include <cpp-remapper/EventSource.h>
 11 | #include <cpp-remapper/InputDevice.h>
 12 | 
 13 | namespace fredemmott::inputmapping {
 14 | 
 15 | namespace {
 16 | 
 17 | HANDLE gExitEvent {};
 18 | BOOL WINAPI exit_event_handler(DWORD dwCtrlType) {
 19 |   SetEvent(gExitEvent);
 20 |   return true;
 21 | }
 22 | 
 23 | EventLoop* gActiveInstance = nullptr;
 24 | 
 25 | struct ActiveInstanceGuard {
 26 |   ActiveInstanceGuard(EventLoop* active) {
 27 |     gActiveInstance = active;
 28 |   }
 29 |   ~ActiveInstanceGuard() {
 30 |     gActiveInstance = nullptr;
 31 |   }
 32 | };
 33 | }// namespace
 34 | 
 35 | void EventLoop::setEventSinks(
 36 |   const std::vector<std::shared_ptr<EventSink>>& sinks) {
 37 |   mEventSinks = sinks;
 38 | }
 39 | 
 40 | void EventLoop::setEventSources(
 41 |   const std::vector<std::shared_ptr<EventSource>>& sources) {
 42 |   mEventSources = sources;
 43 | }
 44 | 
 45 | void EventLoop::run() {
 46 |   if (mEventSources.empty()) {
 47 |     printf(
 48 |       "---\n"
 49 |       "!!! WARNING !!!\n"
 50 |       "No inputs were set. No mapping will be updated unless devices are\n"
 51 |       "manually polled.\n"
 52 |       "---\n");
 53 |   }
 54 |   if (mEventSinks.empty()) {
 55 |     printf(
 56 |       "---\n"
 57 |       "!!! WARNING !!!\n"
 58 |       "No outputs were set. VJoy/ViGEm outputs will not be updated\n"
 59 |       "unless manually flushed.\n"
 60 |       "---\n");
 61 |   }
 62 |   printf("Launching profile...\n");
 63 |   // We want to cleanly exit so that destructors are called - in particular,
 64 |   // we want to reset the HidHide configuration.
 65 |   gExitEvent = CreateEvent(nullptr, false, false, nullptr);
 66 |   SetConsoleCtrlHandler(&exit_event_handler, true);
 67 |   std::vector<HANDLE> fixed_events {gExitEvent};
 68 | 
 69 |   std::map<HANDLE, std::shared_ptr<EventSource>> handle_to_source;
 70 |   for (const auto& source: mEventSources) {
 71 |     auto handle = source->getHandle();
 72 |     fixed_events.push_back(handle);
 73 |     handle_to_source.insert({handle, source});
 74 |   }
 75 |   printf("---\nProfile running, hit Ctrl-C to exit and clean up HidHide.\n");
 76 |   while (true) {
 77 |     auto events = fixed_events;
 78 |     for (const auto& [event, _]: mInjected) {
 79 |       events.push_back(event);
 80 |     }
 81 |     const auto res
 82 |       = WaitForMultipleObjects(events.size(), events.data(), false, INFINITE);
 83 |     auto event = events[res - WAIT_OBJECT_0];
 84 |     if (event == gExitEvent) {
 85 |       SetConsoleCtrlHandler(nullptr, false);
 86 |       CloseHandle(gExitEvent);
 87 |       printf("Exiting.\n---\n");
 88 |       break;
 89 |     }
 90 | 
 91 |     ActiveInstanceGuard aig(this);
 92 | 
 93 |     auto injected = mInjected.find(event);
 94 |     if (injected != mInjected.end()) {
 95 |       injected->second();
 96 |       mInjected.erase(event);
 97 |       CloseHandle(event);
 98 |       flush();
 99 |       continue;
100 |     }
101 | 
102 |     auto source = handle_to_source.at(event);
103 |     source->poll();
104 |     gActiveInstance = nullptr;
105 | 
106 |     flush();
107 |   }
108 | }
109 | 
110 | void EventLoop::flush() {
111 |   for (const auto& output: mEventSinks) {
112 |     output->flush();
113 |   }
114 | }
115 | 
116 | namespace {
117 | typedef std::chrono::
118 |   duration<int64_t, std::ratio_multiply<std::hecto, std::nano>>
119 | 
120 |     FILETIME_RESOLUTION;
121 | }
122 | 
123 | void EventLoop::inject(
124 |   const std::chrono::steady_clock::duration& delay,
125 |   const std::function<void()>& handler) {
126 |   if (!gActiveInstance) {
127 |     return;
128 |   }
129 |   int64_t target_time;
130 |   GetSystemTimeAsFileTime((FILETIME*)&target_time);
131 |   target_time += std::chrono::duration_cast<FILETIME_RESOLUTION>(delay).count();
132 | 
133 |   auto timer = CreateWaitableTimer(nullptr, true, nullptr);
134 |   SetWaitableTimer(
135 |     timer, (LARGE_INTEGER*)&target_time, 0, nullptr, nullptr, false);
136 |   gActiveInstance->mInjected.emplace(timer, [handler, timer]() {
137 |     CloseHandle(timer);
138 |     handler();
139 |   });
140 | }
141 | }// namespace fredemmott::inputmapping
142 | 


--------------------------------------------------------------------------------
/lib/VJoyDevice.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/Controls.h>
  9 | #include <cpp-remapper/VJoyDevice.h>
 10 | 
 11 | #include <cassert>
 12 | #include <cstdio>
 13 | #include <stdexcept>
 14 | 
 15 | // clang-format off
 16 | #define WIN32_LEAN_AND_MEAN
 17 | #include <windows.h>
 18 | // vjoy:
 19 | #include <public.h>
 20 | #include <vjoyinterface.h>
 21 | // clang-format on
 22 | 
 23 | namespace fredemmott::inputmapping {
 24 | namespace {
 25 | bool vjoy_initialized = false;
 26 | 
 27 | void init_vjoy() {
 28 |   if (vjoy_initialized) {
 29 |     return;
 30 |   }
 31 |   vjoy_initialized = true;
 32 | 
 33 |   if (!vJoyEnabled()) {
 34 |     printf("vJoy is not enabled.\n");
 35 |     return;
 36 |   }
 37 |   WORD VerDll, VerDrv;
 38 |   if (!DriverMatch(&VerDll, &VerDrv)) {
 39 |     printf(
 40 |       "---\n"
 41 |       "!!! WARNING !!!\n"
 42 |       "vJoy driver version %04x does not match DLL version %04x\n"
 43 |       "---\n",
 44 |       VerDrv,
 45 |       VerDll);
 46 |   }
 47 | }
 48 | }// namespace
 49 | 
 50 | struct VJoyDevice::Impl {
 51 |   BYTE id;
 52 | #if USE_JOYSTICK_API_VERSION == 3
 53 |   JOYSTICK_POSITION_V3 state;
 54 | #elif USE_JOYSTICK_API_VERSION == 2
 55 |   JOYSTICK_POSITION_V2 state;
 56 | #endif
 57 | };
 58 | 
 59 | VJoyDevice::VJoyDevice(uint8_t id) : p(new Impl {id, {}}) {
 60 |   init_vjoy();
 61 |   AcquireVJD(id);
 62 |   // Just in case the state struct has been extended...
 63 |   ResetVJD(id);
 64 | 
 65 |   // ... but we also need to manually initialize our state struct
 66 |   // as we call UpdateVJD() rathe than SetAxis/SetButton
 67 |   memset(&p->state, 0, sizeof(p->state));
 68 |   p->state.bDevice = id;
 69 | 
 70 |   setXAxis(Axis::MID);
 71 |   setYAxis(Axis::MID);
 72 |   setZAxis(Axis::MID);
 73 | 
 74 |   setRXAxis(Axis::MID);
 75 |   setRYAxis(Axis::MID);
 76 |   setRZAxis(Axis::MID);
 77 | 
 78 |   setSlider(Axis::MID);
 79 |   setDial(Axis::MID);
 80 | 
 81 |   setHat(1, Hat::CENTER);
 82 |   setHat(2, Hat::CENTER);
 83 |   setHat(3, Hat::CENTER);
 84 |   setHat(4, Hat::CENTER);
 85 | }
 86 | 
 87 | VJoyDevice::~VJoyDevice() {
 88 |   RelinquishVJD(p->id);
 89 | }
 90 | 
 91 | namespace {
 92 | /* DX gives 0->0xffff
 93 |  * VJoy wants 1 -> 0x8000
 94 |  */
 95 | long normalize_axis(long dx) {
 96 |   return ((dx * (0x8000 - 1)) / 0xffff) + 1;
 97 | }
 98 | }// namespace
 99 | 
100 | VJoyDevice* VJoyDevice::setXAxis(long value) {
101 |   p->state.wAxisX = normalize_axis(value);
102 |   return this;
103 | }
104 | 
105 | VJoyDevice* VJoyDevice::setYAxis(long value) {
106 |   p->state.wAxisY = normalize_axis(value);
107 |   return this;
108 | }
109 | 
110 | VJoyDevice* VJoyDevice::setZAxis(long value) {
111 |   p->state.wAxisZ = normalize_axis(value);
112 |   return this;
113 | }
114 | 
115 | VJoyDevice* VJoyDevice::setRXAxis(long value) {
116 |   p->state.wAxisXRot = normalize_axis(value);
117 |   return this;
118 | }
119 | 
120 | VJoyDevice* VJoyDevice::setRYAxis(long value) {
121 |   p->state.wAxisYRot = normalize_axis(value);
122 |   return this;
123 | }
124 | 
125 | VJoyDevice* VJoyDevice::setRZAxis(long value) {
126 |   p->state.wAxisZRot = normalize_axis(value);
127 |   return this;
128 | }
129 | 
130 | VJoyDevice* VJoyDevice::setSlider(long value) {
131 |   p->state.wSlider = normalize_axis(value);
132 |   return this;
133 | }
134 | 
135 | VJoyDevice* VJoyDevice::setDial(long value) {
136 |   p->state.wDial = normalize_axis(value);
137 |   return this;
138 | }
139 | 
140 | VJoyDevice* VJoyDevice::setButton(uint8_t button, bool value) {
141 |   button--;
142 |   off_t offset = button % 32;
143 |   auto mask = 1 << offset;
144 | 
145 |   LONG* data = nullptr;
146 |   if (button < 32) {
147 |     data = &p->state.lButtons;
148 |   } else if (button < 64) {
149 |     data = &p->state.lButtonsEx1;
150 |   } else if (button < 96) {
151 |     data = &p->state.lButtonsEx2;
152 |   } else if (button < 128) {
153 |     data = &p->state.lButtonsEx3;
154 |   }
155 |   assert(data);
156 | 
157 |   if (value) {
158 |     *data |= mask;
159 |   } else {
160 |     *data &= ~mask;
161 |   }
162 | 
163 |   return this;
164 | }
165 | 
166 | VJoyDevice* VJoyDevice::setHat(uint8_t hat, uint16_t v) {
167 |   const DWORD value = v == Hat::CENTER ? DWORD(-1) : v;
168 |   switch (hat) {
169 |     case 1:
170 |       p->state.bHats = value;
171 |       break;
172 |     case 2:
173 |       p->state.bHatsEx1 = value;
174 |       break;
175 |     case 3:
176 |       p->state.bHatsEx2 = value;
177 |       break;
178 |     case 4:
179 |       p->state.bHatsEx3 = value;
180 |       break;
181 |   }
182 |   return this;
183 | }
184 | 
185 | void VJoyDevice::flush() {
186 |   UpdateVJD(p->id, &p->state);
187 | }
188 | 
189 | }// namespace fredemmott::inputmapping
190 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/TransformPtr.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #pragma once
  9 | 
 10 | #include <concepts>
 11 | 
 12 | #include <cpp-remapper/Sink.h>
 13 | #include <cpp-remapper/Source.h>
 14 | #include <cpp-remapper/function_traits.h>
 15 | 
 16 | namespace fredemmott::inputmapping {
 17 | 
 18 | // clang-format off
 19 | template<typename T>
 20 | concept any_transform =
 21 |   std::derived_from<T, AnySource>
 22 |   && std::derived_from<T, AnySink>;
 23 | 
 24 | template<typename T, typename TIn, typename TOut>
 25 | concept transform =
 26 |   std::derived_from<T, Sink<TIn>>
 27 |   && std::derived_from<T, Source<TOut>>;
 28 | 
 29 | template<typename T, typename TIn>
 30 | concept transform_from =
 31 |   any_transform<T>
 32 |   && std::derived_from<T, Sink<TIn>>;
 33 | 
 34 | template<typename T, typename TOut>
 35 | concept transform_to =
 36 |   any_transform<T>
 37 |   && std::derived_from<T, Source<TOut>>;
 38 | 
 39 | template<typename T, typename TIn>
 40 | concept transform_invocable_from =
 41 |   std::is_base_of_v<Control, TIn>
 42 |   && std::invocable<T, typename TIn::Value>
 43 |   && detail::exact_arguments<T, typename TIn::Value>;
 44 | 
 45 | template<typename T, typename TIn, typename TOut>
 46 | concept transform_invocable =
 47 |   transform_invocable_from<T, TIn>
 48 |   && detail::exact_return_type<T, typename TOut::Value>;
 49 | 
 50 | template<typename T>
 51 | concept any_transform_ptr =
 52 |   any_transform<typename T::element_type>
 53 |   && std::convertible_to<T, maybe_shared_ptr<typename T::element_type>>;
 54 | 
 55 | template<typename T, typename TIn>
 56 | concept transform_from_ptr =
 57 |   transform_from<typename T::element_type, TIn>
 58 |   && std::convertible_to<T, maybe_shared_ptr<typename T::element_type>>;
 59 | 
 60 | template<typename T, typename TOut>
 61 | concept transform_to_ptr =
 62 |   transform_to<typename T::element_type, TOut>
 63 |   && std::convertible_to<T, maybe_shared_ptr<typename T::element_type>>;
 64 | 
 65 | template<typename T, typename TIn, typename TOut>
 66 | concept transform_ptr =
 67 |   transform_from_ptr<T, TIn>
 68 |   && std::derived_from<typename T::element_type, Source<TOut>>;
 69 | 
 70 | template<typename T>
 71 | concept any_sink_or_transform = std::derived_from<T, AnySink>;
 72 | 
 73 | template<typename T>
 74 | concept any_sink_or_transform_ptr =
 75 |   any_sink_or_transform<typename T::element_type>;
 76 | 
 77 | template<typename T>
 78 | concept any_source_or_transform = std::derived_from<T, AnySource>;
 79 | 
 80 | template<typename T>
 81 | concept any_source_or_transform_ptr =
 82 |   any_source_or_transform<typename T::element_type>;
 83 | // clang-format on
 84 | 
 85 | template <typename T>
 86 | auto convert_to_any_transform_ptr(T&& in) {
 87 |   using DT = std::decay_t<T>;
 88 |   if constexpr (any_transform_ptr<DT>) {
 89 |     return in;
 90 |   }
 91 | 
 92 |   if constexpr (any_transform<DT>) {
 93 |     return maybe_shared_ptr<DT>(std::forward<T>(in));
 94 |   }
 95 | 
 96 |   if constexpr (any_transform<std::remove_pointer_t<DT>>) {
 97 |     return maybe_shared_ptr<std::remove_pointer_t<DT>>(in);
 98 |   }
 99 | 
100 |   if constexpr (transform_invocable<DT, Axis, Axis>) {
101 |     return std::make_shared<FunctionTransform<Axis, Axis>>(in);
102 |   }
103 | 
104 |   if constexpr (transform_invocable<DT, Button, Button>) {
105 |     return std::make_shared<FunctionTransform<Button, Button>>(in);
106 |   }
107 | 
108 |   if constexpr (transform_invocable<DT, Hat, Hat>) {
109 |     return std::make_shared<FunctionTransform<Hat, Hat>>(in);
110 |   }
111 | }
112 | 
113 | // clang-format off
114 | template <typename T>
115 | concept convertible_to_any_transform_ptr = requires(T x) {
116 | 	{ convert_to_any_transform_ptr(x) } -> any_transform_ptr;
117 | };
118 | 
119 | template <typename T>
120 | concept non_id_convertible_to_any_transform_ptr =
121 |   !any_transform_ptr<T>
122 |   && convertible_to_any_transform_ptr<T>;
123 | 
124 | template <typename T, typename TIn>
125 | concept convertible_to_transform_from_ptr = requires(T x) {
126 | 	{ convert_to_any_transform_ptr(x) } -> transform_from_ptr<TIn>;
127 | };
128 | 
129 | template <typename T, typename TIn>
130 | concept non_id_convertible_to_transform_from_ptr =
131 |   !any_transform_ptr<std::decay_t<T>>
132 |   && convertible_to_transform_from_ptr<T, TIn>;
133 | 
134 | template <typename T, typename TOut>
135 | concept convertible_to_transform_to_ptr = requires(T x) {
136 | 	{ convert_to_any_transform_ptr(x) } -> transform_to_ptr<TOut>;
137 | };
138 | 
139 | template <typename T, typename TOut>
140 | concept non_id_convertible_to_transform_to_ptr =
141 |   !any_transform_ptr<std::decay_t<T>>
142 |   && convertible_to_transform_to_ptr<T, TOut>;
143 | // clang-format on
144 | 
145 | }// namespace fredemmott::inputmapping
146 | 


--------------------------------------------------------------------------------
/lib/MappableFAVHIDOutput.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/AxisInformation.h>
  9 | #include <cpp-remapper/FAVHIDDevice.h>
 10 | #include <cpp-remapper/InputDevice.h>
 11 | #include <cpp-remapper/MappableFAVHIDOutput.h>
 12 | 
 13 | namespace fredemmott::inputmapping {
 14 | 
 15 | struct MappableFAVHIDOutput::Impl final {
 16 |   std::shared_ptr<FAVHIDDevice> mDevice;
 17 |   FAVHID::FAVJoyState2::Report mState {};
 18 | };
 19 | 
 20 | MappableFAVHIDOutput::MappableFAVHIDOutput(uint8_t favhid_id)
 21 |   : MappableFAVHIDOutput(std::make_shared<FAVHIDDevice>(favhid_id)) {
 22 | }
 23 | 
 24 | static constexpr decltype(FAVHID::FAVJoyState2::Report::x) ConvertAxisValue(
 25 |   Axis::Value input) {
 26 |   int64_t value = input;
 27 |   value -= Axis::MIN;
 28 | 
 29 |   constexpr auto inputRange = Axis::MAX - Axis::MIN;
 30 |   using outputLimits
 31 |     = std::numeric_limits<decltype(FAVHID::FAVJoyState2::Report::x)>;
 32 |   constexpr auto outputRange = outputLimits::max() - outputLimits::min();
 33 | 
 34 |   value *= outputRange;
 35 |   value /= inputRange;
 36 | 
 37 |   value += outputLimits::min();
 38 | 
 39 |   return value;
 40 | }
 41 | 
 42 | MappableFAVHIDOutput::MappableFAVHIDOutput(std::shared_ptr<FAVHIDDevice> dev)
 43 |   : p(new Impl {dev}),
 44 | #define A(myMember, reportMember) \
 45 |   myMember([this](long value) { \
 46 |     p->mState.reportMember = ConvertAxisValue(value); \
 47 |     p->mDevice->set(p->mState); \
 48 |   })
 49 | #define AA(myMember, reportMember) A(myMember##Axis, reportMember)
 50 |     AA(X, x),
 51 |     AA(Y, y),
 52 |     AA(Z, z),
 53 |     AA(RX, rx),
 54 |     AA(RY, ry),
 55 |     AA(RZ, rz),
 56 |     A(Slider, slider[0]),
 57 |     A(Dial, slider[1]),
 58 | #undef AA
 59 | #undef A
 60 | #define B(n) Button##n(button(n))
 61 |     B(1),
 62 |     B(2),
 63 |     B(3),
 64 |     B(4),
 65 |     B(5),
 66 |     B(6),
 67 |     B(7),
 68 |     B(8),
 69 |     B(9),
 70 |     B(10),
 71 |     B(11),
 72 |     B(12),
 73 |     B(13),
 74 |     B(14),
 75 |     B(15),
 76 |     B(16),
 77 |     B(17),
 78 |     B(18),
 79 |     B(19),
 80 |     B(20),
 81 |     B(21),
 82 |     B(22),
 83 |     B(23),
 84 |     B(24),
 85 |     B(25),
 86 |     B(26),
 87 |     B(27),
 88 |     B(28),
 89 |     B(29),
 90 |     B(30),
 91 |     B(31),
 92 |     B(32),
 93 |     B(33),
 94 |     B(34),
 95 |     B(35),
 96 |     B(36),
 97 |     B(37),
 98 |     B(38),
 99 |     B(39),
100 |     B(40),
101 |     B(41),
102 |     B(42),
103 |     B(43),
104 |     B(44),
105 |     B(45),
106 |     B(46),
107 |     B(47),
108 |     B(48),
109 |     B(49),
110 |     B(50),
111 |     B(51),
112 |     B(52),
113 |     B(53),
114 |     B(54),
115 |     B(55),
116 |     B(56),
117 |     B(57),
118 |     B(58),
119 |     B(59),
120 |     B(60),
121 |     B(61),
122 |     B(62),
123 |     B(63),
124 |     B(64),
125 |     B(65),
126 |     B(66),
127 |     B(67),
128 |     B(68),
129 |     B(69),
130 |     B(70),
131 |     B(71),
132 |     B(72),
133 |     B(73),
134 |     B(74),
135 |     B(75),
136 |     B(76),
137 |     B(77),
138 |     B(78),
139 |     B(79),
140 |     B(80),
141 |     B(81),
142 |     B(82),
143 |     B(83),
144 |     B(84),
145 |     B(85),
146 |     B(86),
147 |     B(87),
148 |     B(88),
149 |     B(89),
150 |     B(90),
151 |     B(91),
152 |     B(92),
153 |     B(93),
154 |     B(94),
155 |     B(95),
156 |     B(96),
157 |     B(97),
158 |     B(98),
159 |     B(99),
160 |     B(100),
161 |     B(101),
162 |     B(102),
163 |     B(103),
164 |     B(104),
165 |     B(105),
166 |     B(106),
167 |     B(107),
168 |     B(108),
169 |     B(109),
170 |     B(110),
171 |     B(111),
172 |     B(112),
173 |     B(113),
174 |     B(114),
175 |     B(115),
176 |     B(116),
177 |     B(117),
178 |     B(118),
179 |     B(119),
180 |     B(120),
181 |     B(121),
182 |     B(122),
183 |     B(123),
184 |     B(124),
185 |     B(125),
186 |     B(126),
187 |     B(127),
188 |     B(128),
189 | #undef B
190 | #define H(n) Hat##n(hat(n))
191 |     H(1),
192 |     H(2),
193 |     H(3),
194 |     H(4)
195 | #undef H
196 | {
197 | }
198 | 
199 | MappableFAVHIDOutput::~MappableFAVHIDOutput() {
200 | }
201 | 
202 | std::shared_ptr<OutputDevice> MappableFAVHIDOutput::getDevice() const {
203 |   if (!p) {
204 |     return {};
205 |   }
206 | 
207 |   return p->mDevice;
208 | }
209 | 
210 | ButtonSinkPtr MappableFAVHIDOutput::button(uint8_t id) const {
211 |   return [this, id](Button::Value value) {
212 |     p->mState.SetButton(id - 1, value);
213 |     p->mDevice->set(p->mState);
214 |   };
215 | }
216 | 
217 | static constexpr int8_t ConvertHatValue(Hat::Value value) {
218 |   if (value == Hat::CENTER) {
219 |     return 0b1111;
220 |   }
221 |   return value / 4500;
222 | }
223 | 
224 | HatSinkPtr MappableFAVHIDOutput::hat(uint8_t id) const {
225 |   return [this, id](Hat::Value value) {
226 |     p->mState.SetPOV(id - 1, ConvertHatValue(value));
227 |     p->mDevice->set(p->mState);
228 |   };
229 | }
230 | 
231 | }// namespace fredemmott::inputmapping
232 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/connections.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #pragma once
  9 | 
 10 | #include <cpp-remapper/ClosedPipeline.h>
 11 | #include <cpp-remapper/FunctionSink.h>
 12 | #include <cpp-remapper/FunctionTransform.h>
 13 | #include <cpp-remapper/SinkPipeline.h>
 14 | #include <cpp-remapper/SourcePipeline.h>
 15 | #include <cpp-remapper/TransformPipeline.h>
 16 | #include <cpp-remapper/TransformPtr.h>
 17 | 
 18 | namespace fredemmott::inputmapping {
 19 | 
 20 | class MappableInput;
 21 | class MappableFAVHIDOutput;
 22 | class MappableVJoyOutput;
 23 | 
 24 | /// Convenience: copy an entire input device to vjoy
 25 | void operator>>(MappableInput&, const MappableVJoyOutput&);
 26 | void operator>>(MappableInput&, const MappableFAVHIDOutput&);
 27 | 
 28 | /* Most of the 'how to tie stuff together' stuff works on '_ptr's, which is
 29 |  * essentially 'kinda looks like a `shared_ptr<>`.
 30 |  *
 31 |  * We work with `shared_ptr<>` where possible, but to support working with
 32 |  * lvalues, we also have `maybe_shared_ptr<T>`, which contains a raw pointer,
 33 |  * and an optional `shared_ptr<>` that must be equal to maintain the Ptrcount.'
 34 |  *
 35 |  * Let's start with the canonical Ptr-based operators:
 36 |  */
 37 | 
 38 | /// SourceOrTransformPtr >> SinkPtr
 39 | template <
 40 |   any_source_or_transform_ptr Left,
 41 |   sink_ptr<typename Left::element_type::OutControl> Right>
 42 | auto operator>>(Left left, const Right& right) {
 43 |   left->setNext(right);
 44 | 
 45 |   if constexpr (any_source_ptr<Left>) {
 46 |     return std::make_shared<ClosedPipeline>(left);
 47 |   }
 48 | 
 49 |   if constexpr (any_transform_ptr<Left>) {
 50 |     return std::make_shared<
 51 |       SinkPipeline<typename Left::element_type::InControl>>(left);
 52 |   }
 53 | }
 54 | 
 55 | /// SourceOrTransformPtr >> TransformPtr
 56 | template <
 57 |   any_source_or_transform_ptr Left,
 58 |   transform_from_ptr<typename Left::element_type::OutControl> Right>
 59 | auto operator>>(Left left, Right right) {
 60 |   left->setNext(right);
 61 | 
 62 |   if constexpr (any_source_ptr<Left>) {
 63 |     return std::make_shared<
 64 |       SourcePipeline<typename Right::element_type::OutControl>>(left, right);
 65 |   }
 66 | 
 67 |   if constexpr (any_transform_ptr<Left>) {
 68 |     return std::make_shared<TransformPipeline<
 69 |       typename Left::element_type::InControl,
 70 |       typename Right::element_type::OutControl>>(left, right);
 71 |   }
 72 | }
 73 | 
 74 | /* Okay, that's all combinations of Ptrs dealt with; now to wrap when
 75 |  * at least one side is not a Ptr */
 76 | 
 77 | /// SourceOrTransformPtr >> convertible_to_sink_ptr
 78 | template <
 79 |   any_source_or_transform_ptr Left,
 80 |   non_id_convertible_to_sink_ptr<typename Left::element_type::OutControl> Right>
 81 | auto operator>>(Left left, Right&& right) {
 82 |   return left >> convert_to_any_sink_ptr(std::forward<Right>(right));
 83 | }
 84 | 
 85 | /// SourceOrTransformPtr >> convertible_to_transform_ptr
 86 | template <
 87 |   any_source_or_transform_ptr Left,
 88 |   non_id_convertible_to_transform_from_ptr<
 89 |     typename Left::element_type::OutControl> Right>
 90 | auto operator>>(Left left, Right&& right) {
 91 |   return left >> convert_to_any_transform_ptr(std::forward<Right>(right));
 92 | }
 93 | 
 94 | /// convertible_to_source_ptr >> SinkOrTransformPtr
 95 | template <
 96 |   any_sink_or_transform_ptr Right,
 97 |   non_id_convertible_to_source_ptr<typename Right::element_type::InControl>
 98 |     Left>
 99 | auto operator>>(Left&& left, Right right) {
100 |   return convert_to_any_source_ptr(std::forward<Left>(left)) >> right;
101 | }
102 | 
103 | /// convertible_to_transform_ptr >> SinkOrTransformPtr
104 | template <
105 |   any_sink_or_transform_ptr Right,
106 |   non_id_convertible_to_transform_to_ptr<
107 |     typename Right::element_type::InControl> Left>
108 | auto operator>>(Left&& left, Right right) {
109 |   return convert_to_any_transform_ptr(std::forward<Left>(left)) >> right;
110 | }
111 | 
112 | // clang-format 13 doesn't fully support C++20 concepts and requirements yet.
113 | // clang-format off
114 | 
115 | /// convertible_to_source_ptr >> convertible_to_sink_or_transform_ptr
116 | template <non_id_convertible_to_any_source_ptr Left, class Right>
117 | requires
118 |   (non_id_convertible_to_any_sink_ptr<Right> || non_id_convertible_to_any_transform_ptr<Right>)
119 |   && requires(Left left, Right right) {
120 |     convert_to_any_source_ptr(left) >> right;
121 |   }
122 | auto operator>>(Left&& left, Right&& right) {
123 |   return convert_to_any_source_ptr(std::forward<Left>(left))
124 |     >> std::forward<Right>(right);
125 | }
126 | 
127 | /// convertible_to_transform_ptr >> convertible_to_sink_or_transform_ptr
128 | template <non_id_convertible_to_any_transform_ptr Left, class Right>
129 | requires
130 |   (non_id_convertible_to_any_sink_ptr<Right> || non_id_convertible_to_any_transform_ptr<Right>)
131 |   && requires(Left left, Right right) {
132 |     convert_to_any_transform_ptr(left) >> right;
133 |   }
134 | auto operator>>(Left&& left, Right&& right) {
135 |   return convert_to_any_transform_ptr(std::forward<Left>(left))
136 |     >> std::forward<Right>(right);
137 | }
138 | 
139 | // clang-format on
140 | 
141 | }// namespace fredemmott::inputmapping
142 | 


--------------------------------------------------------------------------------
/lib/include/cpp-remapper/Profile.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #pragma once
  9 | 
 10 | #include <cpp-remapper/DeviceSpecifier.h>
 11 | #include <cpp-remapper/EventLoop.h>
 12 | #include <cpp-remapper/InputDeviceCollection.h>
 13 | #include <cpp-remapper/MappableDS4Output.h>
 14 | #include <cpp-remapper/MappableFAVHIDOutput.h>
 15 | #include <cpp-remapper/MappableInput.h>
 16 | #include <cpp-remapper/MappableOutput.h>
 17 | #include <cpp-remapper/MappableVJoyOutput.h>
 18 | #include <cpp-remapper/MappableX360Output.h>
 19 | #include <cpp-remapper/OutputDevice.h>
 20 | 
 21 | #include <memory>
 22 | #include <tuple>
 23 | #include <vector>
 24 | 
 25 | namespace fredemmott::inputmapping {
 26 | 
 27 | namespace detail {
 28 | struct OutputID {};
 29 | struct ViGEmX360ID : public OutputID {};
 30 | struct ViGEmDS4ID : public OutputID {};
 31 | 
 32 | struct VJoyID : public OutputID {
 33 |   VJoyID() = delete;
 34 |   VJoyID(uint8_t value) : value(value) {
 35 |   }
 36 | 
 37 |   const uint8_t value;
 38 | };
 39 | 
 40 | struct FAVHIDID : public OutputID {
 41 |   FAVHIDID() = delete;
 42 | 
 43 |   FAVHIDID(uint8_t value) : value(value) {
 44 |   }
 45 | 
 46 |   const uint8_t value;
 47 | };
 48 | 
 49 | }// namespace detail
 50 | 
 51 | const detail::VJoyID VJOY_1 {1}, VJOY_2 {2}, VJOY_3 {3}, VJOY_4 {4}, VJOY_5 {5},
 52 |   VJOY_6 {6}, VJOY_7 {7}, VJOY_8 {8}, VJOY_9 {9}, VJOY_10 {10}, VJOY_11 {11},
 53 |   VJOY_12 {12}, VJOY_13 {13}, VJOY_14 {14}, VJOY_15 {15}, VJOY_16 {16};
 54 | 
 55 | const detail::FAVHIDID FAVHID_1 {0}, FAVHID_2 {1}, FAVHID_3 {2}, FAVHID_4 {3},
 56 |   FAVHID_5 {4}, FAVHID_6 {5}, FAVHID_7 {6}, FAVHID_8 {7};
 57 | 
 58 | const detail::ViGEmX360ID VIGEM_X360_PAD;
 59 | const detail::ViGEmDS4ID VIGEM_DS4_PAD;
 60 | 
 61 | class DeviceWithVisibility {
 62 |  private:
 63 |   DeviceSpecifier impl;
 64 | 
 65 |  public:
 66 |   explicit DeviceWithVisibility(const DeviceSpecifier& ds);
 67 |   DeviceSpecifier getSpecifier() const;
 68 | };
 69 | 
 70 | class UnhiddenDevice final : public DeviceWithVisibility {
 71 |  public:
 72 |   using DeviceWithVisibility::DeviceWithVisibility;
 73 | };
 74 | 
 75 | class HiddenDevice final : public DeviceWithVisibility {
 76 |  public:
 77 |   // clang-format off
 78 |     template<std::convertible_to<DeviceSpecifier> T>
 79 |     requires (!std::convertible_to<T, UnhiddenDevice>)
 80 |     explicit HiddenDevice(const T& ds): DeviceWithVisibility(DeviceSpecifier(ds)) {}
 81 |   // clang-format on
 82 |   HiddenDevice(const UnhiddenDevice&) = delete;
 83 | };
 84 | 
 85 | class Profile final {
 86 |  public:
 87 |   Profile(const std::vector<HiddenDevice>& hidden_ids);
 88 |   Profile(Profile&& other);
 89 |   ~Profile();
 90 |   void operator=(const Profile&) = delete;
 91 | 
 92 |   std::shared_ptr<EventLoop> getEventLoop() const;
 93 |   void run();
 94 | 
 95 |  private:
 96 |   struct Impl;
 97 |   std::unique_ptr<Impl> p;
 98 | };
 99 | 
100 | // Implementation details to make your eyes bleed.
101 | namespace detail {
102 | std::tuple<> get_devices(Profile*, InputDeviceCollection*);
103 | 
104 | MappableInput get_device(InputDeviceCollection*, const DeviceSpecifier&);
105 | 
106 | template <typename... Ts>
107 | auto get_devices(
108 |   Profile* p,
109 |   InputDeviceCollection* c,
110 |   const DeviceSpecifier& first,
111 |   Ts... rest) {
112 |   auto device = get_device(c, first);
113 |   return std::tuple_cat(std::make_tuple(device), get_devices(p, c, rest...));
114 | }
115 | 
116 | template <typename... Ts>
117 | auto get_devices(
118 |   Profile* p,
119 |   InputDeviceCollection* c,
120 |   const DeviceWithVisibility& first,
121 |   Ts... rest) {
122 |   auto device = get_device(c, first.getSpecifier());
123 |   return std::tuple_cat(std::make_tuple(device), get_devices(p, c, rest...));
124 | }
125 | 
126 | template <typename... Ts>
127 | auto get_devices(
128 |   Profile* p,
129 |   InputDeviceCollection* c,
130 |   const VJoyID& first,
131 |   Ts... rest) {
132 |   return std::tuple_cat(
133 |     std::make_tuple(MappableVJoyOutput(first.value)),
134 |     get_devices(p, c, rest...));
135 | }
136 | 
137 | template <typename... Ts>
138 | auto get_devices(
139 |   Profile* p,
140 |   InputDeviceCollection* c,
141 |   const FAVHIDID& first,
142 |   Ts... rest) {
143 |   return std::tuple_cat(
144 |     std::make_tuple(MappableFAVHIDOutput(first.value)),
145 |     get_devices(p, c, rest...));
146 | }
147 | 
148 | template <typename... Ts>
149 | auto get_devices(
150 |   Profile* p,
151 |   InputDeviceCollection* c,
152 |   const ViGEmX360ID& _first,
153 |   Ts... rest) {
154 |   return std::tuple_cat(
155 |     std::make_tuple(MappableX360Output()), get_devices(p, c, rest...));
156 | }
157 | 
158 | template <typename... Ts>
159 | auto get_devices(
160 |   Profile* p,
161 |   InputDeviceCollection* c,
162 |   const ViGEmDS4ID& _first,
163 |   Ts... rest) {
164 |   return std::tuple_cat(
165 |     std::make_tuple(MappableDS4Output()), get_devices(p, c, rest...));
166 | }
167 | 
168 | void fill_hidden_ids(std::vector<HiddenDevice>&);
169 | 
170 | template <typename First, typename... Rest>
171 | void fill_hidden_ids(
172 |   std::vector<HiddenDevice>& hidden_devices,
173 |   const First& first,
174 |   Rest... rest) {
175 |   if constexpr (std::is_constructible_v<HiddenDevice, First>) {
176 |     hidden_devices.push_back(HiddenDevice {first});
177 |   }
178 | 
179 |   fill_hidden_ids(hidden_devices, rest...);
180 | }
181 | 
182 | std::vector<std::shared_ptr<EventSink>> get_event_sinks();
183 | 
184 | template <typename First, typename... Rest>
185 | std::vector<std::shared_ptr<EventSink>> get_event_sinks(
186 |   const First& first,
187 |   Rest... rest) {
188 |   auto ret = get_event_sinks(rest...);
189 |   if constexpr (std::derived_from<First, MappableOutput>) {
190 |     ret.push_back(first.getDevice());
191 |   }
192 |   return ret;
193 | }
194 | 
195 | std::vector<std::shared_ptr<EventSource>> get_event_sources();
196 | 
197 | template <typename First, typename... Rest>
198 | std::vector<std::shared_ptr<EventSource>> get_event_sources(
199 |   const First& first,
200 |   Rest... rest) {
201 |   auto ret = get_event_sources(rest...);
202 |   if constexpr (std::convertible_to<First, MappableInput>) {
203 |     ret.push_back(first.getEventSource());
204 |   }
205 |   return ret;
206 | }
207 | 
208 | }// namespace detail
209 | 
210 | template <typename... Ts>
211 | auto create_profile(Ts... specifiers) {
212 |   std::vector<HiddenDevice> input_ids;
213 |   detail::fill_hidden_ids(input_ids, specifiers...);
214 | 
215 |   auto p = Profile(input_ids);
216 | 
217 |   InputDeviceCollection device_collection;
218 |   auto devices = detail::get_devices(&p, &device_collection, specifiers...);
219 |   // Lambda needed as the thing we're calling is a template: std::apply needs
220 |   // an `std::function`, and we can't take a reference to a template function
221 |   auto event_loop = p.getEventLoop();
222 |   event_loop->setEventSources(std::apply(
223 |     [](auto&&... args) { return detail::get_event_sources(args...); },
224 |     devices));
225 |   event_loop->setEventSinks(std::apply(
226 |     [](auto&&... args) { return detail::get_event_sinks(args...); }, devices));
227 |   return std::tuple_cat(std::make_tuple(std::move(p)), devices);
228 | }
229 | 
230 | }// namespace fredemmott::inputmapping
231 | 


--------------------------------------------------------------------------------
/lib/MappableInput.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (c) 2020-present, Fred Emmott <fred@fredemmott.com>
  3 |  * All rights reserved.
  4 |  *
  5 |  * This source code is licensed under the ISC license found in the LICENSE file
  6 |  * in the root directory of this source tree.
  7 |  */
  8 | #include <cpp-remapper/AxisInformation.h>
  9 | #include <cpp-remapper/EventSource.h>
 10 | #include <cpp-remapper/InputDevice.h>
 11 | #include <cpp-remapper/MappableInput.h>
 12 | 
 13 | #include <format>
 14 | 
 15 | namespace fredemmott::inputmapping {
 16 | 
 17 | namespace {
 18 | template <class Source>
 19 | class MISource : public Source {
 20 |  public:
 21 |   using Source::emit;
 22 | };
 23 | 
 24 | template <typename TControl>
 25 | class MissingSource final : public Source<TControl> {
 26 |   std::string mDevice;
 27 |   std::string mControl;
 28 | 
 29 |  public:
 30 |   MissingSource(const std::string& device, const std::string& control)
 31 |     : mDevice(device), mControl(control) {
 32 |   }
 33 | 
 34 |   void setNext(const maybe_shared_ptr<Sink<TControl>>&) override {
 35 |     printf(
 36 |       "WARNING: Attempted to attach to '%s', but that does not exist on '%s'. "
 37 |       "Ignoring.\n",
 38 |       mControl.c_str(),
 39 |       mDevice.c_str());
 40 |   }
 41 | };
 42 | 
 43 | class MIAxisSource final : public MISource<AxisSource> {};
 44 | class MIButtonSource final : public MISource<ButtonSource> {};
 45 | class MIHatSource final : public MISource<HatSource> {};
 46 | 
 47 | template <typename TSource>
 48 | std::vector<std::shared_ptr<TSource>> fill_sources(size_t count) {
 49 |   std::vector<std::shared_ptr<TSource>> ret;
 50 |   for (auto i = 0; i < count; ++i) {
 51 |     ret.push_back(std::make_shared<TSource>());
 52 |   }
 53 |   return ret;
 54 | }
 55 | 
 56 | AxisSourcePtr find_axis(
 57 |   const std::shared_ptr<InputDevice>& device,
 58 |   std::vector<std::shared_ptr<MIAxisSource>> inputs,
 59 |   AxisType t,
 60 |   uint8_t skip = 0) {
 61 |   const auto skip_in = skip;
 62 | 
 63 |   const auto info = device->getAxisInformation();
 64 |   for (uint8_t i = 0; i < info.size(); ++i) {
 65 |     if (info[i].type == t) {
 66 |       if (skip == 0) {
 67 |         return inputs.at(i);
 68 |       }
 69 |       --skip;
 70 |     }
 71 |   }
 72 |   auto axis_name = AxisInformation(t).name;
 73 |   if (skip_in) {
 74 |     axis_name += std::format("[{}]", skip_in);
 75 |   }
 76 |   auto product_name = device->getProductName();
 77 |   return std::make_shared<MissingSource<Axis>>(product_name, axis_name);
 78 | }
 79 | }// namespace
 80 | 
 81 | class MappableInput::Impl : public EventSource {
 82 |  public:
 83 |   std::shared_ptr<InputDevice> device;
 84 |   InputDevice::State state;
 85 |   std::vector<std::shared_ptr<MIAxisSource>> axisInputs;
 86 |   std::vector<std::shared_ptr<MIButtonSource>> buttonInputs;
 87 |   std::vector<std::shared_ptr<MIHatSource>> hatInputs;
 88 |   Impl() = delete;
 89 |   Impl(const std::shared_ptr<InputDevice>& dev)
 90 |     : device(dev),
 91 |       state(dev->getState()),
 92 |       axisInputs(fill_sources<MIAxisSource>(dev->getAxisCount())),
 93 |       buttonInputs(fill_sources<MIButtonSource>(dev->getButtonCount())),
 94 |       hatInputs(fill_sources<MIHatSource>(dev->getAxisCount())) {
 95 |   }
 96 | 
 97 |   virtual HANDLE getHandle() override {
 98 |     return device->getEvent();
 99 |   }
100 | 
101 |   virtual void poll() override;
102 | };
103 | 
104 | MappableInput::MappableInput(const std::shared_ptr<InputDevice>& dev)
105 |   : p(std::make_shared<Impl>(dev)),
106 | #define A(x) x##Axis(find_axis(dev, p->axisInputs, AxisType::x))
107 |     A(X),
108 |     A(Y),
109 |     A(Z),
110 |     A(RX),
111 |     A(RY),
112 |     A(RZ),
113 | #undef A
114 |     Slider(find_axis(dev, p->axisInputs, AxisType::SLIDER)),
115 |     Dial(find_axis(dev, p->axisInputs, AxisType::SLIDER, 1)),
116 | #define B(x) Button##x(button(x))
117 |     B(1),
118 |     B(2),
119 |     B(3),
120 |     B(4),
121 |     B(5),
122 |     B(6),
123 |     B(7),
124 |     B(8),
125 |     B(9),
126 |     B(10),
127 |     B(11),
128 |     B(12),
129 |     B(13),
130 |     B(14),
131 |     B(15),
132 |     B(16),
133 |     B(17),
134 |     B(18),
135 |     B(19),
136 |     B(20),
137 |     B(21),
138 |     B(22),
139 |     B(23),
140 |     B(24),
141 |     B(25),
142 |     B(26),
143 |     B(27),
144 |     B(28),
145 |     B(29),
146 |     B(30),
147 |     B(31),
148 |     B(32),
149 |     B(33),
150 |     B(34),
151 |     B(35),
152 |     B(36),
153 |     B(37),
154 |     B(38),
155 |     B(39),
156 |     B(40),
157 |     B(41),
158 |     B(42),
159 |     B(43),
160 |     B(44),
161 |     B(45),
162 |     B(46),
163 |     B(47),
164 |     B(48),
165 |     B(49),
166 |     B(50),
167 |     B(51),
168 |     B(52),
169 |     B(53),
170 |     B(54),
171 |     B(55),
172 |     B(56),
173 |     B(57),
174 |     B(58),
175 |     B(59),
176 |     B(60),
177 |     B(61),
178 |     B(62),
179 |     B(63),
180 |     B(64),
181 |     B(65),
182 |     B(66),
183 |     B(67),
184 |     B(68),
185 |     B(69),
186 |     B(70),
187 |     B(71),
188 |     B(72),
189 |     B(73),
190 |     B(74),
191 |     B(75),
192 |     B(76),
193 |     B(77),
194 |     B(78),
195 |     B(79),
196 |     B(80),
197 |     B(81),
198 |     B(82),
199 |     B(83),
200 |     B(84),
201 |     B(85),
202 |     B(86),
203 |     B(87),
204 |     B(88),
205 |     B(89),
206 |     B(90),
207 |     B(91),
208 |     B(92),
209 |     B(93),
210 |     B(94),
211 |     B(95),
212 |     B(96),
213 |     B(97),
214 |     B(98),
215 |     B(99),
216 |     B(100),
217 |     B(101),
218 |     B(102),
219 |     B(103),
220 |     B(104),
221 |     B(105),
222 |     B(106),
223 |     B(107),
224 |     B(108),
225 |     B(109),
226 |     B(110),
227 |     B(111),
228 |     B(112),
229 |     B(113),
230 |     B(114),
231 |     B(115),
232 |     B(116),
233 |     B(117),
234 |     B(118),
235 |     B(119),
236 |     B(120),
237 |     B(121),
238 |     B(122),
239 |     B(123),
240 |     B(124),
241 |     B(125),
242 |     B(126),
243 |     B(127),
244 |     B(128),
245 | #undef B
246 | #define H(x) Hat##x(hat(x))
247 |     H(1),
248 |     H(2),
249 |     H(3),
250 |     H(4)
251 | #undef H
252 | {
253 | }
254 | 
255 | MappableInput::~MappableInput() {
256 | }
257 | 
258 | size_t MappableInput::getAxisCount() const {
259 |   return p->device->getAxisCount();
260 | }
261 | 
262 | size_t MappableInput::getButtonCount() const {
263 |   return p->device->getButtonCount();
264 | }
265 | 
266 | size_t MappableInput::getHatCount() const {
267 |   return p->device->getHatCount();
268 | }
269 | 
270 | std::shared_ptr<EventSource> MappableInput::getEventSource() const {
271 |   return p;
272 | }
273 | 
274 | AxisSourcePtr MappableInput::axis(uint8_t id) const {
275 |   if (id == 0 || id > getAxisCount()) {
276 |     char buf[255];
277 |     snprintf(buf, sizeof(buf), "axis number %d of %zu", id, getAxisCount());
278 |     return std::make_shared<MissingSource<Axis>>(
279 |       p->device->getProductName(), buf);
280 |   }
281 | 
282 |   return p->axisInputs.at(id - 1);
283 | }
284 | 
285 | ButtonSourcePtr MappableInput::button(uint8_t id) const {
286 |   if (id == 0 || id > getButtonCount()) {
287 |     char buf[255];
288 |     // TODO: snprintf -> std::format
289 |     snprintf(buf, sizeof(buf), "button number %d of %zu", id, getButtonCount());
290 |     return std::make_shared<MissingSource<Button>>(
291 |       p->device->getProductName(), buf);
292 |   }
293 | 
294 |   return p->buttonInputs.at(id - 1);
295 | }
296 | 
297 | HatSourcePtr MappableInput::hat(uint8_t id) const {
298 |   if (id == 0 || id > getHatCount()) {
299 |     char buf[255];
300 |     snprintf(buf, sizeof(buf), "hat number %d of %zu", id, getHatCount());
301 |     return std::make_shared<MissingSource<Hat>>(
302 |       p->device->getProductName(), buf);
303 |   }
304 |   return p->hatInputs.at(id - 1);
305 | }
306 | 
307 | void MappableInput::Impl::poll() {
308 |   auto a = state;
309 |   auto b = device->getState();
310 |   state = b;
311 | 
312 | #ifdef VERBOSE_INPUT_DEBUG
313 |   printf("-");
314 |   a.dump();
315 |   printf("+");
316 |   b.dump();
317 | #endif
318 | 
319 |   const auto axes = axisInputs.size(), buttons = buttonInputs.size(),
320 |              hats = hatInputs.size();
321 | 
322 |   for (auto i = 0; i < axes; ++i) {
323 |     if (a.getAxis(i) != b.getAxis(i)) {
324 |       axisInputs[i]->emit(b.getAxis(i));
325 |     }
326 |   }
327 | 
328 |   for (auto i = 0; i < buttons; ++i) {
329 |     if (a.getButton(i) != b.getButton(i)) {
330 |       buttonInputs[i]->emit(b.getButton(i));
331 |     }
332 |   }
333 | 
334 |   for (auto i = 0; i < hats; ++i) {
335 |     if (a.getHat(i) != b.getHat(i)) {
336 |       hatInputs[i]->emit(b.getHat(i));
337 |     }
338 |   }
339 | }
340 | 
341 | }// namespace fredemmott::inputmapping
342 | 


--------------------------------------------------------------------------------