Merge branch 'main' into imgbot

Author: ButterscotchV

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

.github/workflows/c-cpp.yml

@@ -1,6 +1,6 @@
 name: SlimeVR OpenVR Driver
 
-on: [ push, pull_request ]
+on: [ push, pull_request, workflow_dispatch ]
 
 jobs:
   build:
@@ -15,33 +15,30 @@ jobs:
           - os: windows-latest
             triplet: x64-windows-static-md
             target: ALL_BUILD
-            release_dir: Release/driver # dir of driver binaries within env.CMAKE_BUILD_DIR, VS multi-config uses <CONFIG>/ subfolder
+            release_dir: Release # dir of driver binaries within env.CMAKE_BUILD_DIR, VS multi-config uses <CONFIG>/ subfolder
           - os: ubuntu-latest
             triplet: x64-linux
             target: all
-            release_dir: driver # makefile single config won't have subfolder
+            release_dir: "" # makefile single config won't have subfolder
     env:
       # Indicates the CMake build directory where project files and binaries are being produced.
       CMAKE_BUILD_DIR: ${{ github.workspace }}/build
       # Indicates the location of the vcpkg as a Git submodule of the project repository.
       VCPKG_ROOT: ${{ github.workspace }}/vcpkg
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         submodules: true
-      
+
     - uses: lukka/get-cmake@latest
-    
-    - name: Clone vcpkg
-      uses: actions/checkout@v2
-      with:
-        repository: microsoft/vcpkg
-        path: ${{ env.VCPKG_ROOT }}
-        submodules: true
+
+    - name: Get submodule commit hashes
+      id: submodule_hashes
+      run: git submodule foreach --recursive git rev-parse HEAD > submodule_hashes.txt
 
     - name: Restore vcpkg and its artifacts
-      uses: actions/cache@v2
+      uses: actions/cache@v4
       with:
         # The first path is where vcpkg generates artifacts while consuming the vcpkg.json manifest file.
         # The second path is the location of vcpkg (it contains the vcpkg executable and data files).
@@ -52,12 +49,11 @@ jobs:
           !${{ env.VCPKG_ROOT }}/buildtrees
           !${{ env.VCPKG_ROOT }}/packages
           !${{ env.VCPKG_ROOT }}/downloads
-        # The key is composed in a way that it gets properly invalidated: this must happen whenever vcpkg's Git commit id changes, or the list of packages changes. In this case a cache miss must happen and a new entry with a new key with be pushed to GitHub the cache service.
+        # The key is composed in a way that it gets properly invalidated: this must happen whenever vcpkg/submodule Git commit id changes, or the list of packages changes. In this case a cache miss must happen and a new entry with a new key with be pushed to GitHub the cache service.
         # The key includes: hash of the vcpkg.json file, the hash of the vcpkg Git commit id, and the used vcpkg's triplet. The vcpkg's commit id would suffice, but computing an hash out it does not harm.
         # Note: given a key, the cache content is immutable. If a cache entry has been created improperly, in order the recreate the right content the key must be changed as well, and it must be brand new (i.e. not existing already).
-        key: |
-          ${{ hashFiles( 'vcpkg_manifest/vcpkg.json' ) }}-${{ hashFiles( '.git/modules/vcpkg/HEAD' )}}-${{ hashFiles( '${{ env.VCPKG_ROOT }}/.git/HEAD' )}}-${{ matrix.triplet }}-invalidate
-    
+        key: ${{ matrix.triplet }}-${{ hashFiles( '**/vcpkg.json', '**/CMakeLists.txt' ) }}-${{ hashFiles( 'submodule_hashes.txt' )}}
+
     - if: matrix.os == 'windows-latest'
       name: Set up vcpkg for Windows
       run: ${{ env.VCPKG_ROOT }}/bootstrap-vcpkg.bat
@@ -67,29 +63,59 @@ jobs:
       run: ${{ env.VCPKG_ROOT }}/bootstrap-vcpkg.sh
 
     - name: Configure CMake
-      run: cmake -S "${{github.workspace}}" -B "${{env.CMAKE_BUILD_DIR}}" -DVCPKG_TARGET_TRIPLET=${{matrix.triplet}}
+      run: cmake -S "${{github.workspace}}" -B "${{env.CMAKE_BUILD_DIR}}" -DVCPKG_TARGET_TRIPLET=${{matrix.triplet}} -DCMAKE_BUILD_TYPE=Release
 
     - name: Build
       run: cmake --build "${{env.CMAKE_BUILD_DIR}}" --config Release --target "${{ matrix.target }}" -j 6 --
 
     - name: Upload a build artifact
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         # Artifact name
         name: slimevr-openvr-driver-${{ matrix.triplet }} # optional, default is artifact
         # A file, directory or wildcard pattern that describes what to upload
         # Using wildcards so that only the driver directory gets included (if you specify it, then it won't be included)
         path: |
-          ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/*
+          ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/driver/*
+          ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/tests*
 
     - name: Zip
       if: startsWith(github.ref, 'refs/tags/')
-      working-directory: ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}
-      run: cmake -E tar "cf" "${{env.CMAKE_BUILD_DIR}}/slimevr-openvr-driver-${{ matrix.triplet }}.zip" --format=zip -- ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/slimevr
+      working-directory: ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/driver
+      run: cmake -E tar "cf" "${{env.CMAKE_BUILD_DIR}}/slimevr-openvr-driver-${{ matrix.triplet }}.zip" --format=zip -- ${{env.CMAKE_BUILD_DIR}}/${{ matrix.release_dir }}/driver/slimevr
 
     - name: Release
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@v2
       if: startsWith(github.ref, 'refs/tags/')
       with:
         files: "${{env.CMAKE_BUILD_DIR}}/slimevr-openvr-driver-${{ matrix.triplet }}.zip"
-          
+  
+  test:
+    name: Run tests
+    needs: build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest]
+        include:
+          - os: windows-latest
+            triplet: x64-windows-static-md
+            target: RUN_TESTS
+          - os: ubuntu-latest
+            triplet: x64-linux
+            target: test
+    steps:
+      - name: Download build artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: slimevr-openvr-driver-${{ matrix.triplet }}
+          path: ${{ github.workspace }}
+      - if: matrix.os == 'windows-latest'
+        name: Run tests on Windows
+        working-directory: ${{ github.workspace }}/
+        run: .\tests.exe
+      - if: matrix.os != 'windows-latest'
+        name: Run tests on Unix
+        working-directory: ${{ github.workspace }}/
+        run: chmod +x ./tests && ./tests

.gitignore

@@ -11,12 +11,14 @@ compile_commands.json
 CTestTestfile.cmake
 _deps
 CMakeUserPresets.json
+vcpkg_installed/
 
 ### CMake Patch ###
 # External projects
 *-prefix/
 
 ### vscode ###
+.vs
 .vscode/*
 !.vscode/settings.json
 !.vscode/tasks.json
@@ -26,3 +28,4 @@ CMakeUserPresets.json
 
 # Project-specific
 build/*
+out/

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "libraries/linalg"]
 	path = libraries/linalg
 	url = https://github.com/sgorsten/linalg.git
+[submodule "vcpkg"]
+	path = vcpkg
+	url = https://github.com/Microsoft/vcpkg.git

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0.0)
+cmake_minimum_required(VERSION 3.5.0)
 
 #if (NOT DEFINED VCPKG_TARGET_TRIPLET)
     if(WIN32)
@@ -69,17 +69,56 @@ SET_SOURCE_FILES_PROPERTIES(${PROTO_SRC} ${PROTO_INCL} PROPERTIES GENERATED TRUE
 
 find_package(simdjson CONFIG REQUIRED)
 
+# libuv
+find_package(uvw CONFIG REQUIRED)
+
+# Catch2
+find_package(Catch2 3 REQUIRED)
+
 # Project
-file(GLOB_RECURSE HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
+set(DEPS_INCLUDES
+    "${OPENVR_INCLUDE_DIR}"
+    "${CMAKE_CURRENT_SOURCE_DIR}/libraries/linalg"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/"
+)
+set(DEPS_LIBS
+    "${OPENVR_LIB}"
+    protobuf::libprotoc
+    protobuf::libprotobuf
+    protobuf::libprotobuf-lite
+    simdjson::simdjson
+    uvw::uvw
+)
+
+# compile into a static lib
 file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
-add_library("${PROJECT_NAME}" SHARED "${HEADERS}" "${SOURCES}" ${PROTO_HEADER} ${PROTO_SRC})
-target_include_directories("${PROJECT_NAME}" PUBLIC "${OPENVR_INCLUDE_DIR}")
-target_include_directories("${PROJECT_NAME}" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/libraries/linalg")
-target_include_directories("${PROJECT_NAME}" PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/src/")
-target_link_libraries("${PROJECT_NAME}" PUBLIC "${OPENVR_LIB}" protobuf::libprotoc protobuf::libprotobuf protobuf::libprotobuf-lite simdjson::simdjson)
+file(GLOB_RECURSE HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
+add_library("${PROJECT_NAME}_static" STATIC ${SOURCES} ${PROTO_HEADER} ${PROTO_SRC})
+target_link_libraries("${PROJECT_NAME}_static" PUBLIC ${DEPS_LIBS})
+set_property(TARGET "${PROJECT_NAME}_static" PROPERTY CXX_STANDARD 17)
+include_directories("${PROJECT_NAME}_static" PUBLIC ${DEPS_INCLUDES} ${Protobuf_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+if(UNIX)
+    target_compile_options("${PROJECT_NAME}_static" PRIVATE "-fPIC")
+    target_link_libraries("${PROJECT_NAME}_static" PUBLIC atomic)
+endif()
+
+# compile driver
+file(GLOB_RECURSE DRIVER_MAIN "${CMAKE_CURRENT_SOURCE_DIR}/src/DriverFactory.cpp")
+add_library("${PROJECT_NAME}" SHARED ${DRIVER_MAIN} ${HEADERS} ${PROTO_HEADER})
+target_link_libraries("${PROJECT_NAME}" PUBLIC "${PROJECT_NAME}_static")
 set_property(TARGET "${PROJECT_NAME}" PROPERTY CXX_STANDARD 17)
-include_directories(${Protobuf_INCLUDE_DIRS})
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+# compile tests
+function(build_tests target_name test_dir)
+    file(GLOB TESTS "${CMAKE_CURRENT_SOURCE_DIR}/${test_dir}/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/${test_dir}/*.hpp")
+    file(GLOB TESTS_COMMON "${CMAKE_CURRENT_SOURCE_DIR}/test/common/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/test/common/*.hpp")
+    add_executable(${target_name} ${TESTS} ${TESTS_COMMON} ${HEADERS} ${PROTO_HEADER})
+    target_link_libraries(${target_name} PUBLIC "${PROJECT_NAME}_static" Catch2::Catch2WithMain)
+    set_property(TARGET ${target_name} PROPERTY CXX_STANDARD 17)
+endfunction()
+build_tests(tests "test")
+build_tests(tests_integration "test/integration")
+add_test(NAME tests COMMAND "tests")
 
 # IDE Config
 source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/src" PREFIX "Header Files" FILES ${HEADERS})

README.md

@@ -38,8 +38,16 @@ okay with this and that you are authorized to provide the above licenses.
 
 ### Building
 
-To build the project with VSCode you need to install two things: [vcpkg](https://vcpkg.io/en/getting-started.html) and [VS Build Tools](https://visualstudio.microsoft.com/downloads/).
+Clone the repo with `git clone --recurse-submodules https://github.com/SlimeVR/SlimeVR-OpenVR-Driver` to clone with all libraries and [vcpkg](https://vcpkg.io/en/getting-started.html) registry.
+
+To build the project with VSCode on Windows you need to install [VS Build Tools](https://visualstudio.microsoft.com/downloads/).
+
+Run the bootstrap script to build vcpkg binary `.\vcpkg\bootstrap-vcpkg.bat` or `./vcpkg/bootstrap-vcpkg.sh`.
 
 After installing vcpkg if you're on Windows, you need to run `vcpkg integrate install` command from the vcpkg folder to integrate it for VSCode.
 
 For other systems and IDEs instructions are not available as of now, contributions are welcome.
+
+### Updating vcpkg packages
+
+To update vcpkg packages set the vcpkg registry submodule to a newer commit and rerun the bootstrap script.

src/DriverFactory.cpp

@@ -6,21 +6,22 @@
 static std::shared_ptr<SlimeVRDriver::IVRDriver> driver;
 
 void* HmdDriverFactory(const char* interface_name, int* return_code) {
-	if (std::strcmp(interface_name, vr::IServerTrackedDeviceProvider_Version) == 0) {
-		if (!driver) {
-			// Instantiate concrete impl
-			driver = std::make_shared<SlimeVRDriver::VRDriver>();
-		}
-		// We always have at least 1 ref to the shared ptr in "driver" so passing out raw pointer is ok
-		return driver.get();
-	}
+    if (std::strcmp(interface_name, vr::IServerTrackedDeviceProvider_Version) == 0) {
+        if (!driver) {
+            // Instantiate concrete impl
+            driver = std::make_shared<SlimeVRDriver::VRDriver>();
+        }
+        // We always have at least 1 ref to the shared ptr in "driver" so passing out raw pointer is ok
+        return driver.get();
+    }
 
-	if (return_code)
-		*return_code = vr::VRInitError_Init_InterfaceNotFound;
+    if (return_code) {
+        *return_code = vr::VRInitError_Init_InterfaceNotFound;
+    }
 
-	return nullptr;
+    return nullptr;
 }
 
 std::shared_ptr<SlimeVRDriver::IVRDriver> SlimeVRDriver::GetDriver() {
-	return driver;
+    return driver;
 }