Merge pull request #2 from Swordmaster3214/test

Testing complete

Author: Swordmaster3214

.github/workflows/release-build.yml

@@ -17,13 +17,10 @@ jobs:
         include:
           - os: ubuntu-latest
             asset: psmoveapi-4.0.12-linux.tar.gz
-            executable: dsu_server_psmove
           - os: macos-13
             asset: psmoveapi-4.0.12-macos.tar.gz
-            executable: dsu_server_psmove
           - os: windows-latest
             asset: psmoveapi-4.0.12-windows-msvc2017-x64.zip
-            executable: dsu_server_psmove.exe
 
     steps:
       - uses: actions/checkout@v4
@@ -92,30 +89,58 @@ jobs:
           fi
         shell: bash
 
+      - name: Get executable name from CMake
+        id: cmake_info
+        run: |
+          if [ "${{ runner.os }}" = "Windows" ]; then
+            # For Windows, we need to find the actual executable name
+            if [ -f "build/Release/"*.exe ]; then
+              EXEC_NAME=$(basename build/Release/*.exe)
+            elif [ -f "build/Debug/"*.exe ]; then
+              EXEC_NAME=$(basename build/Debug/*.exe)
+            elif [ -f "build/"*.exe ]; then
+              EXEC_NAME=$(basename build/*.exe)
+            else
+              echo "ERROR: Could not find Windows executable"
+              exit 1
+            fi
+          else
+            # For Linux/macOS, find the executable (non-.exe files that are executable)
+            EXEC_NAME=$(find build/ -maxdepth 1 -type f -executable ! -name "*.so" ! -name "*.dylib" -printf '%f\n' | head -n1)
+            if [ -z "$EXEC_NAME" ]; then
+              echo "ERROR: Could not find executable"
+              exit 1
+            fi
+          fi
+          echo "executable_name=$EXEC_NAME" >> $GITHUB_OUTPUT
+          echo "Found executable: $EXEC_NAME"
+        shell: bash
+
       - name: Find and rename executable
         id: artifact
         run: |
           mkdir -p artifacts
+          EXEC_NAME="${{ steps.cmake_info.outputs.executable_name }}"
           
           if [ "${{ runner.os }}" = "Windows" ]; then
             # Try multiple possible locations for Windows executable
-            if [ -f "build/Release/${{ matrix.executable }}" ]; then
-              EXEC_PATH="build/Release/${{ matrix.executable }}"
-            elif [ -f "build/Debug/${{ matrix.executable }}" ]; then
-              EXEC_PATH="build/Debug/${{ matrix.executable }}"
-            elif [ -f "build/${{ matrix.executable }}" ]; then
-              EXEC_PATH="build/${{ matrix.executable }}"
+            if [ -f "build/Release/$EXEC_NAME" ]; then
+              EXEC_PATH="build/Release/$EXEC_NAME"
+            elif [ -f "build/Debug/$EXEC_NAME" ]; then
+              EXEC_PATH="build/Debug/$EXEC_NAME"
+            elif [ -f "build/$EXEC_NAME" ]; then
+              EXEC_PATH="build/$EXEC_NAME"
             else
-              echo "ERROR: Could not find Windows executable"
+              echo "ERROR: Could not find Windows executable $EXEC_NAME"
               exit 1
             fi
-            ARTIFACT_NAME="dsu_server_psmove-windows-x64.exe"
+            ARTIFACT_NAME="${EXEC_NAME%.exe}-windows-x64.exe"
           elif [ "${{ runner.os }}" = "macOS" ]; then
-            EXEC_PATH="build/${{ matrix.executable }}"
-            ARTIFACT_NAME="dsu_server_psmove-macos"
+            EXEC_PATH="build/$EXEC_NAME"
+            ARTIFACT_NAME="$EXEC_NAME-macos"
           else
-            EXEC_PATH="build/${{ matrix.executable }}"
-            ARTIFACT_NAME="dsu_server_psmove-linux"
+            EXEC_PATH="build/$EXEC_NAME"
+            ARTIFACT_NAME="$EXEC_NAME-linux"
           fi
           
           echo "name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT

CMakeLists.txt

@@ -1,8 +1,36 @@
 cmake_minimum_required(VERSION 3.10)
 project(dsu_server_psmove)
-
 set(CMAKE_CXX_STANDARD 17)
 
+# Determine platform suffix for executable name
+if(WIN32)
+    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+        set(PLATFORM_SUFFIX "win64")
+    else()
+        set(PLATFORM_SUFFIX "win32")
+    endif()
+elseif(APPLE)
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+        set(PLATFORM_SUFFIX "macos_arm64")
+    else()
+        set(PLATFORM_SUFFIX "macos_x64")
+    endif()
+else()
+    # Linux and other Unix-like systems
+    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+        if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
+            set(PLATFORM_SUFFIX "linux_arm64")
+        else()
+            set(PLATFORM_SUFFIX "linux_x64")
+        endif()
+    else()
+        set(PLATFORM_SUFFIX "linux_x86")
+    endif()
+endif()
+
+# Set the executable name with platform suffix
+set(EXECUTABLE_NAME "dsu_server_psmove_${PLATFORM_SUFFIX}")
+
 # Allow user to specify where psmoveapi is located
 if(NOT DEFINED PSMOVE_ROOT)
     set(PSMOVE_ROOT "${CMAKE_SOURCE_DIR}/psmoveapi_install")
@@ -15,76 +43,75 @@ endif()
 
 # Include headers
 include_directories(${PSMOVE_ROOT}/include)
+include_directories(src)
 
 # Add library search path
 link_directories(${PSMOVE_ROOT}/lib)
 
 # Source files
-add_executable(dsu_server_psmove dsu_server_psmove.cpp)
+set(SOURCES
+    src/main.cpp
+    src/dsu/dsu_server.cpp
+    src/dsu/dsu_protocol.cpp
+    src/psmove/psmove_manager.cpp
+    src/psmove/psmove_pairing.cpp
+    src/network/udp_server.cpp
+    src/utils/logging.cpp
+    src/utils/signal_handler.cpp
+)
+
+# Create executable with platform-specific name
+add_executable(${EXECUTABLE_NAME} ${SOURCES})
 
 # Platform-specific libraries
 if(WIN32)
-    # Windows libraries - added winmm for multimedia timer functions
-    target_link_libraries(dsu_server_psmove 
-        psmoveapi 
-        setupapi 
-        ws2_32 
-        winmm
+    target_link_libraries(${EXECUTABLE_NAME} 
+        psmoveapi setupapi ws2_32 winmm
     )
 elseif(APPLE)
-    # macOS libraries
     find_library(USB_LIBRARY usb-1.0 REQUIRED)
     find_library(COREFOUNDATION_LIBRARY CoreFoundation REQUIRED)
     find_library(IOKIT_LIBRARY IOKit REQUIRED)
 
-    target_link_libraries(dsu_server_psmove 
-        psmoveapi 
-        ${USB_LIBRARY}
-        ${COREFOUNDATION_LIBRARY}
-        ${IOKIT_LIBRARY}
+    target_link_libraries(${EXECUTABLE_NAME} 
+        psmoveapi ${USB_LIBRARY} ${COREFOUNDATION_LIBRARY} ${IOKIT_LIBRARY}
     )
 else()
-    # Linux
     find_package(PkgConfig REQUIRED)
     pkg_check_modules(LIBUSB REQUIRED libusb-1.0)
     pkg_check_modules(BLUETOOTH REQUIRED bluez)
-
-    # Check for udev (often needed for device enumeration)
     pkg_check_modules(UDEV libudev)
-
+    
     include_directories(${LIBUSB_INCLUDE_DIRS} ${BLUETOOTH_INCLUDE_DIRS})
     link_directories(${LIBUSB_LIBRARY_DIRS} ${BLUETOOTH_LIBRARY_DIRS})
-
-    set(LINUX_LIBS
-        psmoveapi
-        ${LIBUSB_LIBRARIES}
-        ${BLUETOOTH_LIBRARIES}
-        pthread
-    )
 
-    # Add udev if found
+    set(LINUX_LIBS psmoveapi ${LIBUSB_LIBRARIES} ${BLUETOOTH_LIBRARIES} pthread)
+    
     if(UDEV_FOUND)
         list(APPEND LINUX_LIBS ${UDEV_LIBRARIES})
         include_directories(${UDEV_INCLUDE_DIRS})
         link_directories(${UDEV_LIBRARY_DIRS})
     endif()
-
-    target_link_libraries(dsu_server_psmove ${LINUX_LIBS})
+    
+    target_link_libraries(${EXECUTABLE_NAME} ${LINUX_LIBS})
 endif()
 
-# Set output directory for consistency across platforms
-set_target_properties(dsu_server_psmove PROPERTIES
+# Set output directory
+set_target_properties(${EXECUTABLE_NAME} PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
     RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}
     RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}
 )
 
-# Enable debug info for release builds (useful for debugging)
+# Enable debug info for release builds
 if(CMAKE_BUILD_TYPE STREQUAL "Release")
     if(WIN32)
-        target_compile_options(dsu_server_psmove PRIVATE /Zi)
-        target_link_options(dsu_server_psmove PRIVATE /DEBUG)
+        target_compile_options(${EXECUTABLE_NAME} PRIVATE /Zi)
+        target_link_options(${EXECUTABLE_NAME} PRIVATE /DEBUG)
     else()
-        target_compile_options(dsu_server_psmove PRIVATE -g)
+        target_compile_options(${EXECUTABLE_NAME} PRIVATE -g)
     endif()
 endif()
+
+# Print the final executable name for confirmation
+message(STATUS "Building executable: ${EXECUTABLE_NAME}")

README.md

@@ -27,23 +27,26 @@ The server translates PS Move controller input (accelerometer, gyroscope, and bu
 ### Using Pre-built Binaries
 
 1. **Download** the latest release for your platform:
-   - [Windows](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/download/dsu_server_psmove-windows-x64.exe)
-   - [macOS](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/download/dsu_server_psmove-macos)
-   - [Linux](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/download/dsu_server_psmove-linux)
+   - [Windows](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/)
+   - [macOS](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/)
+   - [Linux](https://github.com/Swordmaster3214/PSMove-DSU/releases/latest/)
 
-2. **Connect your PS Move controller** via USB or Bluetooth
+2. **Connect your PS Move controller** via Bluetooth
 
 3. **Run the executable**:
+   #### Windows
    ```bash
-   # Windows
-   ./dsu_server_psmove-windows-x64.exe
-   
-   # macOS/Linux
-   ./dsu_server_psmove-macos
-   ./dsu_server_psmove-linux
+   ./dsu_server_psmove_windows_win64.exe
+   ```
+   #### macOS/Linux
+   ```bash
+   ./dsu_server_psmove_macos_x64
+   ```
+   ```bash
+   ./dsu_server_psmove_linux_x64
    ```
 
-4. **Configure your emulator** to connect to `127.0.0.1:26760` (default DSU port)
+5. **Configure your emulator** to connect to `127.0.0.1:26760` (default DSU port)
 
 ### Button Mappings
 
@@ -62,14 +65,10 @@ PS | PS
 ### Controller Setup
 
 #### Bluetooth Pairing
-**Note:** You will not need to do the following steps if you have already paired your controller with your computer using [PSMoveAPI](https://github.com/thp/psmoveapi)
-1. Connect the PS Move controller via USB first
-2. Use the auto-pairing utility in the program to pair via Bluetooth, note that it may require elevated permissions because it accesses your device's bluetooth stack
-
-Once paired, disconnect the cable and power it on, a solid red light indicates that the controller can be used wirelessly
-
-#### USB Connection
-Simply connect the PS Move controller via USB cable - it should be detected automatically.
+**Note:** You will not need to do the following if you have already paired your controller with your computer using [PSMoveAPI](https://github.com/thp/psmoveapi)
+```bash
+./dsu_server_psmove --pair
+```
 
 ## Building from Source
 
@@ -78,7 +77,7 @@ Simply connect the PS Move controller via USB cable - it should be detected auto
 #### All Platforms
 - **CMake** 3.10 or higher
 - **C++ compiler** with C++17 support
-- **PSMoveAPI 4.0.12** (automatically downloaded by build process)
+- **PSMoveAPI 4.0.12** [downloaded](https://github.com/thp/psmoveapi/releases/latest/)
 
 #### Linux
 ```bash
@@ -98,33 +97,32 @@ brew install libusb
 
 1. **Clone the repository**:
    ```bash
-   git clone https://github.com/Swordmaster3214/PSMove-DSU.git
-   cd PSMove-DSU
+   git clone https://github.com/Swordmaster3214/PSMove-DSU.git && cd PSMove-DSU
    ```
 
 2. **Create build directory**:
    ```bash
-   mkdir build
-   cd build
+   mkdir build && cd build
    ```
 
 3. **Configure with CMake**:
+   #### Linux/macOS
    ```bash
-   # Linux/macOS
-   cmake -DCMAKE_BUILD_TYPE=Release ..
-   
-   # Windows
-   cmake ..
+   cmake -DCMAKE_BUILD_TYPE=Release -DPSMOVE_ROOT=/path/to/psmoveapi ..
+   ```
+   #### Windows
+   ```bash
+   cmake -DPSMOVE_ROOT=/path/to/psmoveapi ..
    ```
 
-4. **Build the project**:
+5. **Build the project**:
    ```bash
    cmake --build . --config Release
    ```
 
-5. **Run the executable**:
+6. **Run the executable**:
+   The executable will be in the build directory
    ```bash
-   # The executable will be in the build directory
    ./dsu_server_psmove
    ```
 
@@ -135,7 +133,6 @@ If you have PSMoveAPI installed in a custom location:
 ```bash
 cmake -DPSMOVE_ROOT=/path/to/psmoveapi ..
 ```
-
 ## Configuration
 
 ### DSU Server Settings
@@ -158,7 +155,7 @@ The server runs on `127.0.0.1:26760` by default, which is the standard DSU port.
 ## Troubleshooting
 
 ### Controller Not Detected
-- Ensure the PS Move controller is properly connected (USB) or paired (Bluetooth)
+- Ensure the PS Move controller is properly paired
 - On Linux, you may need to run with `sudo` for USB access permissions
 - Check that no other applications are using the controller
 
@@ -174,11 +171,11 @@ The server runs on `127.0.0.1:26760` by default, which is the standard DSU port.
 
 ### Linux Permissions
 If you get permission errors accessing the controller:
+Add udev rules for PS Move controller
 ```bash
-# Add udev rules for PS Move controller
 sudo usermod -a -G plugdev $USER
-# Log out and back in for changes to take effect
 ```
+Log out and back in for changes to take effect
 
 ## Technical Details
 
@@ -196,7 +193,7 @@ sudo usermod -a -G plugdev $USER
 
 ### Performance
 - **Low latency**: Direct USB/Bluetooth communication
-- **Single-controller**: Supports one PS Move controller
+- **Multi-controller**: Support in the project is implemented for multiple controllers, but only one seems to be working 😅
 
 ## Contributing
 
@@ -221,9 +218,7 @@ Contributions are welcome! Please feel free to submit pull requests, report issu
 - **PSMoveAPI Documentation**: [psmoveapi.readthedocs.io](https://psmoveapi.readthedocs.io/)
 - **DSU Protocol**: [Cemuhook Documentation](https://cemuhook.sshnuke.net/)
 
----
 
-**Note**: PlayStation Move controllers require initial USB connection for setup, even when using Bluetooth. Ensure your controllers are properly calibrated using PSMoveAPI tools before use.
 
 ## Licensing
 License details for this project are in the LICENSE file.