diff --git a/.gitignore b/.gitignore index e7fd26cb6..64bd8b747 100644 --- a/.gitignore +++ b/.gitignore @@ -35,3 +35,4 @@ node_modules/ # direnv has been claimed for Nix usage .direnv/ +.kotlin diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 000000000..298ce083c --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,3 @@ +plugins { + base +} diff --git a/flake.lock b/flake.lock index c4142b3a6..217507ed4 100644 --- a/flake.lock +++ b/flake.lock @@ -17,11 +17,26 @@ }, "nixpkgs": { "locked": { - "lastModified": 1675327819, - "narHash": "sha256-Fd2BUNUsTO7wmoU1fbOC4HNkl370dYdkfKgWPretuj0=", + "lastModified": 1781577229, + "narHash": "sha256-lrp67w8AulE9Ks53n27I45ADSzbOCn4H+CNW1Ck8B+8=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "21efc622b939884db3c92f49d638ca89f12f22f8", + "rev": "567a49d1913ce81ac6e9582e3553dd90a955875f", + "type": "github" + }, + "original": { + "id": "nixpkgs", + "ref": "nixos-unstable", + "type": "indirect" + } + }, + "nixpkgs-flatbuffers": { + "locked": { + "lastModified": 1688392541, + "narHash": "sha256-lHrKvEkCPTUO+7tPfjIcb7Trk6k31rz18vkyqmkeJfY=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "ea4c80b39be4c09702b0cb3b42eab59e2ba4f24b", "type": "github" }, "original": { @@ -30,10 +45,28 @@ "type": "indirect" } }, + "nixpkgs-jdk24": { + "locked": { + "lastModified": 1756787288, + "narHash": "sha256-rw/PHa1cqiePdBxhF66V7R+WAP8WekQ0mCDG4CFqT8Y=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "d0fc30899600b9b3466ddb260fd83deb486c32f1", + "type": "github" + }, + "original": { + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "d0fc30899600b9b3466ddb260fd83deb486c32f1", + "type": "github" + } + }, "root": { "inputs": { "flake-utils": "flake-utils", - "nixpkgs": "nixpkgs" + "nixpkgs": "nixpkgs", + "nixpkgs-flatbuffers": "nixpkgs-flatbuffers", + "nixpkgs-jdk24": "nixpkgs-jdk24" } } }, diff --git a/flake.nix b/flake.nix index 5924d32f1..60147ed78 100644 --- a/flake.nix +++ b/flake.nix @@ -1,19 +1,29 @@ { description = "A hardware-agnostic serialization protocol for full body tracking (FBT) in VR"; - inputs.nixpkgs.url = "nixpkgs/nixos-22.11"; + inputs.nixpkgs.url = "nixpkgs/nixos-unstable"; + inputs.nixpkgs-jdk24.url = "github:NixOS/nixpkgs/d0fc30899600b9b3466ddb260fd83deb486c32f1"; + inputs.nixpkgs-flatbuffers.url = "nixpkgs/nixos-22.11"; inputs.flake-utils.url = "github:numtide/flake-utils"; - outputs = { self, nixpkgs, flake-utils }: + outputs = { self, nixpkgs, nixpkgs-jdk24, nixpkgs-flatbuffers, flake-utils }: flake-utils.lib.eachDefaultSystem (system: let pkgs = nixpkgs.legacyPackages.${system}; + jdkPkgs = import nixpkgs-jdk24 { inherit system; }; + java = jdkPkgs.javaPackages.compiler.temurin-bin.jdk-24; + pkgsFlatbuffers = nixpkgs-flatbuffers.legacyPackages.${system}; in { devShells.default = pkgs.mkShell { nativeBuildInputs = [ - pkgs.flatbuffers + pkgsFlatbuffers.flatbuffers pkgs.direnv + java ]; + shellHook = '' + export JAVA_HOME=${java} + export PATH="${java}/bin:$PATH" + ''; }; } ); diff --git a/generate-flatbuffer.ps1 b/generate-flatbuffer.ps1 index e6da45f68..9ba016bc8 100644 --- a/generate-flatbuffer.ps1 +++ b/generate-flatbuffer.ps1 @@ -6,11 +6,11 @@ Remove-Item -ErrorAction Ignore -Recurse protocol/java/src Remove-Item -ErrorAction Ignore -Recurse protocol/cpp/include/solarxr_protocol/generated Remove-Item -ErrorAction Ignore -Recurse protocol/typescript/src Remove-Item -ErrorAction Ignore -Recurse protocol/rust/src/generated -Remove-Item -ErrorAction Ignore -Recurse protocol/kotlin/src +Remove-Item -ErrorAction Ignore -Recurse protocol/kotlin/src/generated/kotlin ./flatc.exe --java --gen-object-api --gen-all -o protocol/java/src -I ./schema/ ./schema/all.fbs ./flatc.exe --cpp --scoped-enums --gen-all -o protocol/cpp/include/solarxr_protocol/generated -I ./schema/ ./schema/all.fbs ./flatc.exe --ts --gen-object-api --gen-all -o protocol/typescript/src -I ./schema/ ./schema/all.fbs ./flatc.exe --rust --rust-module-root-file --gen-all -o protocol/rust/src/generated ./schema/all.fbs -./flatc.exe --kotlin --gen-jvmstatic --gen-all -o ./protocol/kotlin/src -I ./schema/ ./schema/all.fbs +./gradlew.bat :codegen:run --args="-o ./protocol/kotlin/src/generated/kotlin -I ./schema/ ./schema/all.fbs" diff --git a/generate-flatbuffer.sh b/generate-flatbuffer.sh index 7999b9ef0..f4ab334ef 100755 --- a/generate-flatbuffer.sh +++ b/generate-flatbuffer.sh @@ -15,10 +15,10 @@ rm -rf protocol/java/src rm -rf protocol/cpp/include/solarxr_protocol/generated rm -rf protocol/typescript/src rm -rf protocol/rust/src/generated -rm -rf protocol/kotlin/src +rm -rf protocol/kotlin/src/generated/kotlin flatc --java --gen-object-api --gen-all -o ./protocol/java/src -I ./schema/ ./schema/all.fbs && \ flatc --cpp --scoped-enums --gen-all -o ./protocol/cpp/include/solarxr_protocol/generated -I ./schema/ ./schema/all.fbs && \ flatc --ts --gen-object-api --gen-all -o ./protocol/typescript/src -I ./schema/ ./schema/all.fbs && \ flatc --rust --rust-module-root-file --gen-all -o ./protocol/rust/src/generated ./schema/all.fbs && \ -flatc --kotlin --gen-jvmstatic --gen-all -o ./protocol/kotlin/src -I ./schema/ ./schema/all.fbs +./gradlew :codegen:run --args="-o ./protocol/kotlin/src/generated/kotlin -I ./schema/ ./schema/all.fbs" diff --git a/protocol/kotlin/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar similarity index 100% rename from protocol/kotlin/gradle/wrapper/gradle-wrapper.jar rename to gradle/wrapper/gradle-wrapper.jar diff --git a/protocol/kotlin/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties similarity index 91% rename from protocol/kotlin/gradle/wrapper/gradle-wrapper.properties rename to gradle/wrapper/gradle-wrapper.properties index ae04661ee..03b32a2e3 100644 --- a/protocol/kotlin/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.4-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/protocol/kotlin/gradlew b/gradlew similarity index 100% rename from protocol/kotlin/gradlew rename to gradlew diff --git a/protocol/kotlin/gradlew.bat b/gradlew.bat similarity index 96% rename from protocol/kotlin/gradlew.bat rename to gradlew.bat index f127cfd49..53a6b238d 100644 --- a/protocol/kotlin/gradlew.bat +++ b/gradlew.bat @@ -1,91 +1,91 @@ -@rem -@rem Copyright 2015 the original author or authors. -@rem -@rem Licensed under the Apache License, Version 2.0 (the "License"); -@rem you may not use this file except in compliance with the License. -@rem You may obtain a copy of the License at -@rem -@rem https://www.apache.org/licenses/LICENSE-2.0 -@rem -@rem Unless required by applicable law or agreed to in writing, software -@rem distributed under the License is distributed on an "AS IS" BASIS, -@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -@rem See the License for the specific language governing permissions and -@rem limitations under the License. -@rem - -@if "%DEBUG%"=="" @echo off -@rem ########################################################################## -@rem -@rem Gradle startup script for Windows -@rem -@rem ########################################################################## - -@rem Set local scope for the variables with windows NT shell -if "%OS%"=="Windows_NT" setlocal - -set DIRNAME=%~dp0 -if "%DIRNAME%"=="" set DIRNAME=. -set APP_BASE_NAME=%~n0 -set APP_HOME=%DIRNAME% - -@rem Resolve any "." and ".." in APP_HOME to make it shorter. -for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi - -@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" - -@rem Find java.exe -if defined JAVA_HOME goto findJavaFromJavaHome - -set JAVA_EXE=java.exe -%JAVA_EXE% -version >NUL 2>&1 -if %ERRORLEVEL% equ 0 goto execute - -echo. -echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:findJavaFromJavaHome -set JAVA_HOME=%JAVA_HOME:"=% -set JAVA_EXE=%JAVA_HOME%/bin/java.exe - -if exist "%JAVA_EXE%" goto execute - -echo. -echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% -echo. -echo Please set the JAVA_HOME variable in your environment to match the -echo location of your Java installation. - -goto fail - -:execute -@rem Setup the command line - -set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar - - -@rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* - -:end -@rem End local scope for the variables with windows NT shell -if %ERRORLEVEL% equ 0 goto mainEnd - -:fail -rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of -rem the _cmd.exe /c_ return code! -set EXIT_CODE=%ERRORLEVEL% -if %EXIT_CODE% equ 0 set EXIT_CODE=1 -if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% -exit /b %EXIT_CODE% - -:mainEnd -if "%OS%"=="Windows_NT" endlocal - -:omega +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/kotlin-codegen/.gitignore b/kotlin-codegen/.gitignore new file mode 100644 index 000000000..472681f52 --- /dev/null +++ b/kotlin-codegen/.gitignore @@ -0,0 +1,5 @@ +# Ignore Gradle project-specific cache directory +.gradle +.kotlin +# Ignore Gradle build output directory +build diff --git a/kotlin-codegen/build.gradle.kts b/kotlin-codegen/build.gradle.kts new file mode 100644 index 000000000..f9634a4ed --- /dev/null +++ b/kotlin-codegen/build.gradle.kts @@ -0,0 +1,71 @@ +plugins { + kotlin("jvm") + application +} + +repositories { + mavenCentral() +} + +val generatedTestSourcesDir = layout.buildDirectory.dir("generated/test-schemas") + +kotlin { + jvmToolchain(24) + compilerOptions { + jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_24 + } + sourceSets { + test { + kotlin.srcDir(generatedTestSourcesDir) + } + } +} + +application { + mainClass = "dev.slimevr.fbscodegen.MainKt" +} + +tasks.named("run") { + dependsOn(tasks.named("classes")) + workingDir = projectDir.parentFile +} + +val generateTestSchemas by tasks.registering(JavaExec::class) { + dependsOn(tasks.named("classes")) + group = "verification" + description = "Generates Kotlin fixtures from test FlatBuffers schemas." + classpath = sourceSets.main.get().runtimeClasspath + mainClass = application.mainClass + workingDir = projectDir + outputs.dir(generatedTestSourcesDir) + doFirst { + delete(generatedTestSourcesDir) + } + args( + "-o", + generatedTestSourcesDir.get().asFile.absolutePath, + "-I", + projectDir.resolve("src/test/resources/schemas").absolutePath, + projectDir.resolve("src/test/resources/schemas/all.fbs").absolutePath, + ) +} + +tasks.named("compileTestKotlin") { + dependsOn(generateTestSchemas) +} + +tasks.test { + useJUnitPlatform() +} + +dependencies { + implementation("com.squareup:kotlinpoet:2.2.0") + val generatedProjectPath = sequenceOf(":solarxr-protocol:generated", ":generated") + .firstOrNull { rootProject.findProject(it) != null } + ?: error("Cannot find the generated SolarXR protocol project") + + testImplementation(project(generatedProjectPath)) + testImplementation(gradleTestKit()) + testImplementation("com.google.flatbuffers:flatbuffers-java:22.10.26") + testImplementation(kotlin("test")) +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/EnumBuilder.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/EnumBuilder.kt new file mode 100644 index 000000000..96c1464f9 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/EnumBuilder.kt @@ -0,0 +1,51 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.ClassName +import com.squareup.kotlinpoet.FunSpec +import com.squareup.kotlinpoet.PropertySpec +import com.squareup.kotlinpoet.TypeSpec + +internal fun buildEnumType(decl: EnumDecl): TypeSpec { + val enumClass = ClassName("", decl.name) + val valueType = decl.baseType.info.kotlinType + + val builder = TypeSpec.enumBuilder(decl.name) + .addKdoc(decl.comments.joinToString("\n")) + .primaryConstructor( + FunSpec.constructorBuilder().addParameter("value", valueType).build() + ) + .addProperty(PropertySpec.builder("value", valueType).initializer("value").build()) + + var nextValue = 0L + decl.values.forEach { v -> + val actualValue = v.value ?: nextValue + nextValue = actualValue + 1 + val literal = when (decl.baseType) { + ScalarKind.UINT8 -> "${actualValue}.toUByte()" + ScalarKind.UINT16 -> "${actualValue}.toUShort()" + ScalarKind.UINT32 -> "${actualValue}u" + ScalarKind.UINT64 -> "${actualValue}uL" + ScalarKind.INT64 -> "${actualValue}L" + else -> "$actualValue" + } + builder.addEnumConstant( + v.name, + TypeSpec.anonymousClassBuilder() + .addKdoc(v.comments.joinToString("\n")) + .addSuperclassConstructorParameter(literal) + .build() + ) + } + builder.addType( + TypeSpec.companionObjectBuilder() + .addFunction( + FunSpec.builder("fromValue") + .addParameter("value", valueType) + .returns(enumClass.copy(nullable = true)) + .addStatement("return entries.firstOrNull { it.value == value }") + .build() + ) + .build() + ) + return builder.build() +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Generator.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Generator.kt new file mode 100644 index 000000000..0f3690b06 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Generator.kt @@ -0,0 +1,43 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.ClassName +import com.squareup.kotlinpoet.FileSpec + +class Generator( + internal val allSchemas: List, +) { + internal val symbolTable = SymbolTable(allSchemas) + internal val flatBufferWriter = ClassName("dev.slimevr.fbscodegen.runtime", "FlatBufferWriter") + internal val flatBufferReader = ClassName("dev.slimevr.fbscodegen.runtime", "FlatBufferReader") + internal val structLayouts = mutableMapOf, StructLayout>() + + private val unionMemberships: Map, List> by lazy { + val map = mutableMapOf, MutableList>() + allSchemas.forEach { schema -> + schema.declarations.filterIsInstance().forEach { union -> + val unionClass = ClassName(schema.namespace, union.name) + union.variants.forEach { variantRef -> + val resolved = symbolTable.resolve(variantRef, schema) + map.getOrPut(resolved.schema.namespace to resolved.decl.name) { mutableListOf() } += unionClass + } + } + } + map + } + + fun generate(): List = allSchemas.map { schema -> + val file = FileSpec.builder(schema.namespace, snakeToCamel(schema.fileName).replaceFirstChar { it.uppercase() }) + schema.declarations.forEach { decl -> + when (decl) { + is EnumDecl -> file.addType(buildEnumType(decl)) + is StructDecl -> file.addType(buildStructType(this, decl, schema)) + is TableDecl -> file.addType(buildTableType(this, decl, schema)) + is UnionDecl -> file.addType(buildUnionType(this, decl, schema)) + } + } + file.build() + } + + internal fun unionMembers(schema: Schema, name: String): List? = + unionMemberships[schema.namespace to name] +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Layout.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Layout.kt new file mode 100644 index 000000000..a12463b43 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Layout.kt @@ -0,0 +1,22 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.ClassName + +internal fun Generator.resolveDecl(ref: String, schema: Schema): Decl = + symbolTable.resolve(ref, schema).decl + +internal fun Generator.resolveRefTypeName(ref: String, schema: Schema): ClassName { + val (resolvedSchema, decl) = symbolTable.resolve(ref, schema) + return ClassName(resolvedSchema.namespace, decl.name) +} + +internal fun Generator.resolveSchema(ref: String, currentSchema: Schema): Schema = + symbolTable.resolve(ref, currentSchema).schema + +internal fun alignTo(value: Int, alignment: Int): Int = + ((value + alignment - 1) / alignment) * alignment + +internal fun snakeToCamel(name: String): String = + name.split('_').mapIndexed { index, part -> + if (index == 0) part.lowercase() else part.replaceFirstChar { it.uppercase() } + }.joinToString("") diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Main.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Main.kt new file mode 100644 index 000000000..292c998dc --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Main.kt @@ -0,0 +1,118 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.FileSpec +import java.io.File + +private data class CodegenArgs( + val outputDir: File, + val includeDirs: List, + val entryFile: File, +) + +/** + * CLI usage: + * flatbuffers-codegen -o [-I ]... + * + * Include directives in .fbs files are resolved against the provided -I directories + * (and the directory of the file that contains the include). All reachable schemas + * are collected transitively, deduplicated, and generated in dependency order. + */ +fun main(args: Array) { + val parsed = parseArgs(args) + if (parsed == null) { + System.err.println("Usage: flatbuffers-codegen -o [-I ]... ") + System.exit(1) + return + } + + val resolvedOutputDir = parsed.outputDir + val resolvedEntryFile = parsed.entryFile + + require(resolvedEntryFile.exists()) { "Entry file not found: $resolvedEntryFile" } + resolvedOutputDir.deleteRecursively() + resolvedOutputDir.mkdirs() + + // Add the entry file's own directory as an implicit include dir + val includeDirs = parsed.includeDirs.toMutableList() + resolvedEntryFile.parentFile?.let { includeDirs += it } + + val schemas = resolveIncludes(resolvedEntryFile, includeDirs, linkedSetOf()) + val fileSpecs = Generator(schemas).generate() + writeGeneratedFiles(resolvedOutputDir, fileSpecs) + println("Done. ${fileSpecs.size} file(s) generated.") +} + +private fun parseArgs(args: Array): CodegenArgs? { + var outputDir: File? = null + val includeDirs = mutableListOf() + var entryFile: File? = null + + var i = 0 + while (i < args.size) { + when (args[i]) { + "-o" -> { outputDir = File(args[++i]) } + "-I" -> { includeDirs += File(args[++i]) } + else -> { + if (entryFile != null) { + System.err.println("Only one entry .fbs file is supported.") + System.exit(1) + } + entryFile = File(args[i]) + } + } + i++ + } + + if (outputDir == null || entryFile == null) return null + return CodegenArgs(outputDir, includeDirs, entryFile) +} + +private fun writeGeneratedFiles(outputDir: File, fileSpecs: List) { + fileSpecs.forEach { spec -> + val packagePath = spec.packageName.replace('.', '/') + val outFile = outputDir.resolve("$packagePath/${spec.name}.kt") + outFile.parentFile.mkdirs() + outFile.writeText(spec.toString()) + println("Wrote ${spec.packageName}/${spec.name}.kt") + } +} + +/** + * Recursively resolves and parses .fbs files starting from [file]. + * Returns schemas in dependency order (dependencies before dependents). + * [visited] tracks canonical paths already processed to avoid cycles/duplicates. + */ +private fun resolveIncludes( + file: File, + includeDirs: List, + visited: LinkedHashSet, +): List { + val canonical = file.canonicalPath + if (canonical in visited) return emptyList() + visited += canonical + + println("Parsing ${file.name} ...") + val schema = Parser(file.readText()).parse().copy(fileName = file.nameWithoutExtension) + + val results = mutableListOf() + + // Resolve each include before adding this schema (dependencies first) + schema.includes.forEach { includePath -> + val resolved = resolveIncludePath(includePath, file.parentFile, includeDirs) + ?: error("Cannot resolve include \"$includePath\" from ${file.name} (searched: ${(listOf(file.parentFile) + includeDirs).map { it.path }})") + results += resolveIncludes(resolved, includeDirs, visited) + } + + results += schema + return results +} + +private fun resolveIncludePath( + includePath: String, + fileDir: File?, + includeDirs: List, +): File? { + // Try relative to the file's own directory first, then each -I directory + val searchDirs = listOfNotNull(fileDir) + includeDirs + return searchDirs.map { File(it, includePath) }.firstOrNull { it.exists() } +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Model.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Model.kt new file mode 100644 index 000000000..56ca52512 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Model.kt @@ -0,0 +1,103 @@ +package dev.slimevr.fbscodegen + +enum class ScalarKind { + BOOL, + INT8, INT16, INT32, INT64, + UINT8, UINT16, UINT32, UINT64, + FLOAT32, FLOAT64, + STRING, +} + +sealed interface Type + +data class ScalarType(val kind: ScalarKind) : Type + +data class RefType(val name: String) : Type + +data class VectorType(val element: Type) : Type + +data class Field( + val name: String, + val type: Type, + val defaultValue: String? = null, + val deprecated: Boolean = false, + val comments: List = emptyList(), +) + +data class EnumDeclValue( + val name: String, + val value: Long?, + val comments: List = emptyList(), +) + +sealed interface Decl { + val name: String + val comments: List +} + +data class StructDecl( + override val name: String, + val fields: List, + override val comments: List = emptyList(), +) : Decl + +data class TableDecl( + override val name: String, + val fields: List, + val rootType: Boolean = false, + override val comments: List = emptyList(), +) : Decl + +data class EnumDecl( + override val name: String, + val baseType: ScalarKind, + val values: List, + override val comments: List = emptyList(), +) : Decl + +data class UnionDecl( + override val name: String, + val variants: List, + override val comments: List = emptyList(), +) : Decl + +data class Schema( + val namespace: String, + val includes: List, + val declarations: List, + val fileIdentifier: String? = null, + val fileName: String = "Generated", +) + +data class ResolvedDecl( + val schema: Schema, + val decl: Decl, +) + +class SymbolTable(val schemas: List) { + private val decls = schemas.flatMap { schema -> + schema.declarations.map { decl -> (schema.namespace to decl.name) to ResolvedDecl(schema, decl) } + }.toMap() + + fun resolve(ref: String, context: Schema): ResolvedDecl { + val simple = ref.substringAfterLast('.') + val qualifiedNamespace = if (ref.contains('.')) ref.substringBeforeLast('.') else null + + if (qualifiedNamespace != null) { + return decls[qualifiedNamespace to simple] + ?: error("Unknown type reference '$ref' in ${context.namespace}") + } + + // Try context namespace first + decls[context.namespace to simple]?.let { return it } + + // Fallback to searching all (might be ambiguous) + val matches = decls.filter { it.key.second == simple }.values.toList() + return when (matches.size) { + 1 -> matches.single() + 0 -> error("Unknown type reference '$ref' in ${context.namespace}") + else -> error("Ambiguous type reference '$ref' in ${context.namespace}: ${matches.joinToString { it.schema.namespace + "." + it.decl.name }}") + } + } +} + diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Parser.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Parser.kt new file mode 100644 index 000000000..cdc1a2827 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/Parser.kt @@ -0,0 +1,376 @@ +package dev.slimevr.fbscodegen + + +/** + * Hand-written recursive-descent parser for a subset of the FlatBuffers IDL. + * + * Supported constructs: + * namespace, include, table, struct, enum, union, + * root_type, file_identifier, attribute (ignored) + */ +class Parser(private val src: String) { + + private var pos = 0 + + // ── Public API ──────────────────────────────────────────────────────────── + + fun parse(): Schema { + var namespace = "" + val includes = mutableListOf() + val decls = mutableListOf() + var rootType: String? = null + var fileIdentifier: String? = null + + while (pos < src.length) { + skipWhitespaceAndComments() + if (pos >= src.length) break + + when (val kw = peekWord()) { + "namespace" -> { + consume("namespace") + namespace = readUntilSemicolon().trim() + expect(';') + } + "include" -> { + consume("include") + skipWs() + val path = readStringLiteral() + skipWs() + expect(';') + includes += path + } + "table" -> decls += parseTable(popCommentBuffer()) + "struct" -> decls += parseStruct(popCommentBuffer()) + "enum" -> decls += parseEnum(popCommentBuffer()) + "union" -> decls += parseUnion(popCommentBuffer()) + "root_type" -> { + consume("root_type") + rootType = readUntilSemicolon().trim() + expect(';') + } + "file_identifier" -> { + consume("file_identifier") + skipWs() + fileIdentifier = readStringLiteral() + skipWs() + expect(';') + } + "attribute" -> { + // ignore attribute declarations + skipUntil(';') + expect(';') + } + else -> error("Unexpected keyword '$kw' at pos $pos") + } + commentBuffer.clear() + } + + // Mark root_type table + val finalDecls = if (rootType != null) { + decls.map { + if (it is TableDecl && it.name == rootType) it.copy(rootType = true) else it + } + } else decls + + return Schema(namespace, includes, finalDecls, fileIdentifier) + } + + // ── Comment buffer ──────────────────────────────────────────────────────── + + private val commentBuffer = mutableListOf() + + private fun popCommentBuffer(): List { + val result = commentBuffer.toList() + commentBuffer.clear() + return result + } + + // ── Table / Struct ──────────────────────────────────────────────────────── + + private fun parseTable(comments: List): TableDecl { + consume("table") + skipWs() + val name = readIdent() + skipWs() + // optional table-level metadata: (deprecated, ...) + if (pos < src.length && src[pos] == '(') readMetadata() + skipWs() + val fields = parseFieldBlock() + return TableDecl(name, fields, comments = comments) + } + + private fun parseStruct(comments: List): StructDecl { + consume("struct") + skipWs() + val name = readIdent() + skipWs() + // optional struct-level metadata + if (pos < src.length && src[pos] == '(') readMetadata() + skipWs() + val fields = parseFieldBlock() + return StructDecl(name, fields, comments) + } + + private fun parseFieldBlock(): List { + expect('{') + val fields = mutableListOf() + val localComments = mutableListOf() + while (true) { + skipWhitespaceAndComments(localComments) + if (pos >= src.length) break + if (src[pos] == '}') { pos++; break } + fields += parseField(localComments.toList()) + localComments.clear() + } + return fields + } + + private fun parseField(comments: List): Field { + val name = readIdent() + skipWs() + expect(':') + skipWs() + val type = parseType() + skipWs() + + var default: String? = null + var deprecated = false + + if (pos < src.length && src[pos] == '=') { + pos++ + skipWs() + default = readDefaultValue() + skipWs() + } + + // Optional metadata block: (deprecated, ...) + if (pos < src.length && src[pos] == '(') { + val meta = readMetadata() + if ("deprecated" in meta) deprecated = true + } + + skipWs() + expect(';') + return Field(name, type, default, deprecated, comments) + } + + private fun parseType(): Type { + if (pos < src.length && src[pos] == '[') { + pos++ + skipWs() + val elem = parseType() + skipWs() + expect(']') + return VectorType(elem) + } + val name = readQualifiedIdent() + return toScalarOrRef(name) + } + + private fun toScalarOrRef(name: String): Type = when (name) { + "bool" -> ScalarType(ScalarKind.BOOL) + "int8", "byte" -> ScalarType(ScalarKind.INT8) + "int16", "short" -> ScalarType(ScalarKind.INT16) + "int32", "int" -> ScalarType(ScalarKind.INT32) + "int64", "long" -> ScalarType(ScalarKind.INT64) + "uint8", "ubyte" -> ScalarType(ScalarKind.UINT8) + "uint16", "ushort" -> ScalarType(ScalarKind.UINT16) + "uint32", "uint" -> ScalarType(ScalarKind.UINT32) + "uint64", "ulong" -> ScalarType(ScalarKind.UINT64) + "float32", "float" -> ScalarType(ScalarKind.FLOAT32) + "float64", "double" -> ScalarType(ScalarKind.FLOAT64) + "string" -> ScalarType(ScalarKind.STRING) + else -> RefType(name) + } + + // ── Enum ────────────────────────────────────────────────────────────────── + + private fun parseEnum(comments: List): EnumDecl { + consume("enum") + skipWs() + val name = readIdent() + skipWs() + expect(':') + skipWs() + val baseKind = parseEnumBaseType(readIdent()) + skipWs() + expect('{') + val values = mutableListOf() + val localComments = mutableListOf() + while (true) { + skipWhitespaceAndComments(localComments) + if (pos >= src.length) break + if (src[pos] == '}') { pos++; break } + val vName = readIdent() + skipWs() + var vValue: Long? = null + if (pos < src.length && src[pos] == '=') { + pos++ + skipWs() + vValue = readLong() + skipWs() + } + skipWs() + // optional per-value metadata: (deprecated, ...) + if (pos < src.length && src[pos] == '(') readMetadata() + values += EnumDeclValue(vName, vValue, localComments.toList()) + localComments.clear() + skipWs() + // optional comma + if (pos < src.length && src[pos] == ',') pos++ + } + return EnumDecl(name, baseKind, values, comments) + } + + // ── Union ───────────────────────────────────────────────────────────────── + + private fun parseUnion(comments: List): UnionDecl { + consume("union") + skipWs() + val name = readIdent() + skipWs() + expect('{') + val variants = mutableListOf() + while (true) { + skipWhitespaceAndComments() + if (pos >= src.length) break + if (src[pos] == '}') { pos++; break } + variants += readQualifiedIdent() + skipWs() + if (pos < src.length && src[pos] == ',') pos++ + } + return UnionDecl(name, variants, comments) + } + + private fun parseEnumBaseType(baseTypeName: String): ScalarKind = when (baseTypeName) { + "int8", "byte" -> ScalarKind.INT8 + "int16", "short" -> ScalarKind.INT16 + "int32", "int" -> ScalarKind.INT32 + "int64", "long" -> ScalarKind.INT64 + "uint8", "ubyte" -> ScalarKind.UINT8 + "uint16", "ushort" -> ScalarKind.UINT16 + "uint32", "uint" -> ScalarKind.UINT32 + "uint64", "ulong" -> ScalarKind.UINT64 + else -> error("Unsupported enum base type '$baseTypeName' at pos $pos") + } + + // ── Lexer helpers ───────────────────────────────────────────────────────── + + private fun skipWs() { + while (pos < src.length && src[pos].isWhitespace()) pos++ + } + + private fun skipWhitespaceAndComments(accumulator: MutableList? = null) { + while (pos < src.length) { + when { + src[pos].isWhitespace() -> pos++ + src.startsWith("///", pos) -> { + pos += 3 + val start = pos + while (pos < src.length && src[pos] != '\n') pos++ + accumulator?.add(src.substring(start, pos).trim()) + ?: commentBuffer.add(src.substring(start, pos).trim()) + } + src.startsWith("//", pos) -> { + while (pos < src.length && src[pos] != '\n') pos++ + } + src.startsWith("/*", pos) -> { + pos += 2 + while (pos < src.length - 1 && !src.startsWith("*/", pos)) pos++ + pos += 2 + } + else -> break + } + } + } + + private fun peekWord(): String { + var i = pos + while (i < src.length && (src[i].isLetterOrDigit() || src[i] == '_')) i++ + return src.substring(pos, i) + } + + private fun consume(word: String) { + require(src.startsWith(word, pos)) { "Expected '$word' at $pos, got '${src.substring(pos, minOf(pos + 20, src.length))}'" } + pos += word.length + } + + private fun expect(ch: Char) { + skipWs() + require(pos < src.length && src[pos] == ch) { "Expected '$ch' at $pos, got '${src.getOrNull(pos)}'" } + pos++ + } + + private fun readIdent(): String { + val start = pos + while (pos < src.length && (src[pos].isLetterOrDigit() || src[pos] == '_')) pos++ + require(pos > start) { "Expected identifier at $pos" } + return src.substring(start, pos) + } + + private fun readQualifiedIdent(): String { + val sb = StringBuilder(readIdent()) + while (pos < src.length && src[pos] == '.') { + pos++ + sb.append('.') + sb.append(readIdent()) + } + return sb.toString() + } + + private fun readUntilSemicolon(): String { + val start = pos + while (pos < src.length && src[pos] != ';') pos++ + return src.substring(start, pos) + } + + private fun skipUntil(ch: Char) { + while (pos < src.length && src[pos] != ch) pos++ + } + + private fun readStringLiteral(): String { + expect('"') + val start = pos + while (pos < src.length && src[pos] != '"') pos++ + val s = src.substring(start, pos) + pos++ // closing " + return s + } + + private fun readDefaultValue(): String { + val start = pos + while (pos < src.length && src[pos] != ';' && src[pos] != '(' && !src[pos].isWhitespace()) pos++ + return src.substring(start, pos) + } + + private fun readMetadata(): Set { + expect('(') + val result = mutableSetOf() + while (pos < src.length && src[pos] != ')') { + skipWs() + if (src[pos] == ')') break + val key = readIdent() + result += key + skipWs() + if (pos < src.length && src[pos] == ':') { + pos++ + skipWs() + // skip value + while (pos < src.length && src[pos] != ',' && src[pos] != ')') pos++ + } + skipWs() + if (pos < src.length && src[pos] == ',') pos++ + } + if (pos < src.length) pos++ // ')' + return result + } + + private fun readLong(): Long { + val negative = pos < src.length && src[pos] == '-' + if (negative) pos++ + val start = pos + while (pos < src.length && src[pos].isDigit()) pos++ + val s = src.substring(start, pos) + return if (negative) -s.toLong() else s.toLong() + } +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/StructBuilder.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/StructBuilder.kt new file mode 100644 index 000000000..e19dabf6d --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/StructBuilder.kt @@ -0,0 +1,167 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.* + +internal fun buildStructType(generator: Generator, decl: StructDecl, schema: Schema): TypeSpec { + val layout = requireStructLayout(generator, decl, schema) + + val decodeFun = FunSpec.builder("decode") + .addParameter("bb", generator.flatBufferReader) + .addParameter("offset", INT) + .returns(ClassName("", decl.name)) + .apply { + val args = CodeBlock.builder() + layout.fields.forEachIndexed { i, fieldLayout -> + val f = fieldLayout.field + args.add("${snakeToCamel(f.name)} = %L", structFieldDecodeExpr(generator, f.type, schema, "offset + ${fieldLayout.offset}")) + if (i < layout.fields.size - 1) args.add(", ") + } + addStatement("return %T(%L)", ClassName("", decl.name), args.build()) + } + .build() + + val encodeFun = FunSpec.builder("encode") + .addParameter("builder", generator.flatBufferWriter) + .returns(INT) + .apply { + addStatement("builder.prep(%L, %L)", layout.alignment, layout.size) + addStatement("var written = 0") + layout.fields.asReversed().forEach { fieldLayout -> + val target = layout.size - (fieldLayout.offset + fieldLayout.size) + val name = snakeToCamel(fieldLayout.field.name) + addStatement("builder.pad(%L - written)", target) + addCode(structFieldEncodeBlock(generator, fieldLayout.field.type, schema, name)) + addStatement("written = %L", target + fieldLayout.size) + } + addStatement("return builder.offset()") + } + .build() + + val selfClass = TypeSpec.classBuilder(decl.name) + .addKdoc(decl.comments.joinToString("\n")) + .addModifiers(KModifier.DATA) + .apply { + generator.unionMembers(schema, decl.name)?.forEach { addSuperinterface(it) } + } + val ctor = FunSpec.constructorBuilder() + decl.fields.forEach { f -> + val kt = f.type.toKotlinType(generator.symbolTable, schema, nullable = false) + ctor.addParameter(snakeToCamel(f.name), kt) + selfClass.addProperty( + PropertySpec.builder(snakeToCamel(f.name), kt) + .initializer(snakeToCamel(f.name)) + .build() + ) + } + selfClass.primaryConstructor(ctor.build()) + selfClass.addFunction(encodeFun) + selfClass.addType(TypeSpec.companionObjectBuilder().addFunction(decodeFun).build()) + return selfClass.build() +} + +internal fun requireStructLayout(generator: Generator, decl: StructDecl, schema: Schema): StructLayout = + generator.structLayouts.getOrPut(schema.namespace to decl.name) { + var offset = 0 + var alignment = 1 + val fields = decl.fields.map { field -> + val fieldAlignment = fixedInlineAlignment(generator, field.type, schema) + val fieldSize = fixedInlineSize(generator, field.type, schema) + alignment = maxOf(alignment, fieldAlignment) + offset = alignTo(offset, fieldAlignment) + StructFieldLayout(field, offset, fieldSize).also { + offset += fieldSize + } + } + StructLayout(fields, alignTo(offset, alignment), alignment) + } + +private fun fixedInlineSize(generator: Generator, type: Type, schema: Schema): Int = when (type) { + is ScalarType -> { + require(type.kind != ScalarKind.STRING) { "Strings are not valid struct fields" } + type.kind.info.size + } + is RefType -> when (val decl = requireNotNull(generator.resolveDecl(type.name, schema)) { + "Unknown struct field type ${type.name}" + }) { + is EnumDecl -> decl.baseType.info.size + is StructDecl -> requireStructLayout(generator, decl, generator.resolveSchema(type.name, schema)).size + else -> error("Struct fields must be scalars, enums, or structs: ${type.name}") + } + is VectorType -> error("Vectors are not valid struct fields") +} + +private fun fixedInlineAlignment(generator: Generator, type: Type, schema: Schema): Int = when (type) { + is ScalarType -> { + require(type.kind != ScalarKind.STRING) { "Strings are not valid struct fields" } + type.kind.info.alignment + } + is RefType -> when (val decl = requireNotNull(generator.resolveDecl(type.name, schema)) { + "Unknown struct field type ${type.name}" + }) { + is EnumDecl -> decl.baseType.info.alignment + is StructDecl -> requireStructLayout(generator, decl, generator.resolveSchema(type.name, schema)).alignment + else -> error("Struct fields must be scalars, enums, or structs: ${type.name}") + } + is VectorType -> error("Vectors are not valid struct fields") +} + +private fun structFieldDecodeExpr(generator: Generator, type: Type, schema: Schema, absExpr: String): CodeBlock = when (type) { + is ScalarType -> { + if (type.kind == ScalarKind.BOOL) { + CodeBlock.of("bb.get($absExpr) != 0.toByte()") + } else { + val info = type.kind.info + CodeBlock.of("bb.${info.bbGetter}($absExpr)${info.readConv}") + } + } + is RefType -> when (val decl = requireNotNull(generator.resolveDecl(type.name, schema)) { + "Unknown struct field type ${type.name}" + }) { + is EnumDecl -> { + val info = decl.baseType.info + CodeBlock.of("%T.fromValue(bb.${info.bbGetter}($absExpr)${info.readConv})!!", generator.resolveRefTypeName(type.name, schema)) + } + is StructDecl -> CodeBlock.of("%T.decode(bb, $absExpr)", generator.resolveRefTypeName(type.name, schema)) + else -> error("Struct fields must be scalars, enums, or structs: ${type.name}") + } + is VectorType -> error("Vectors are not valid struct fields") +} + +private fun structFieldEncodeBlock(generator: Generator, type: Type, schema: Schema, valueExpr: String): CodeBlock = when (type) { + is ScalarType -> { + val info = type.kind.info + CodeBlock.of("builder.%L(%L)\n", info.putter, scalarVectorWriteValue(valueExpr, type.kind)) + } + is RefType -> when (val decl = requireNotNull(generator.resolveDecl(type.name, schema)) { + "Unknown struct field type ${type.name}" + }) { + is EnumDecl -> { + val info = decl.baseType.info + CodeBlock.of( + "builder.%L(%L)\n", + info.putter, + scalarVectorWriteValue("$valueExpr.value", decl.baseType) + ) + } + is StructDecl -> CodeBlock.of("%L.encode(builder)\n", valueExpr) + else -> error("Struct fields must be scalars, enums, or structs: ${type.name}") + } + is VectorType -> error("Vectors are not valid struct fields") +} + +private fun scalarVectorWriteValue(valueExpr: String, kind: ScalarKind): CodeBlock = when (kind) { + ScalarKind.BOOL -> CodeBlock.of("if ($valueExpr) 1.toByte() else 0.toByte()") + else -> CodeBlock.of("$valueExpr${kind.info.writeConv}") +} + +internal data class StructFieldLayout( + val field: Field, + val offset: Int, + val size: Int, +) + +internal data class StructLayout( + val fields: List, + val size: Int, + val alignment: Int, +) diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TableBuilder.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TableBuilder.kt new file mode 100644 index 000000000..e5751eb91 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TableBuilder.kt @@ -0,0 +1,349 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.* + +internal fun buildTableType(generator: Generator, decl: TableDecl, schema: Schema): TypeSpec { + val selfClass = TypeSpec.classBuilder(decl.name) + .addKdoc(decl.comments.joinToString("\n")) + .apply { + if (decl.fields.isNotEmpty()) addModifiers(KModifier.DATA) + generator.unionMembers(schema, decl.name)?.forEach { addSuperinterface(it) } + } + + if (decl.fields.isNotEmpty()) { + val ctor = FunSpec.constructorBuilder() + val symbols = generator.symbolTable + decl.fields.forEach { f -> + val kt = f.type.toKotlinType(symbols, schema, nullable = f.isNullable(symbols, schema)) + val default = f.kotlinDefault(symbols, schema) + val deprecated = f.deprecatedAnnotation() + ctor.addParameter( + ParameterSpec.builder(snakeToCamel(f.name), kt) + .apply { if (deprecated != null) addAnnotation(deprecated) } + .defaultValue(default) + .build() + ) + selfClass.addProperty( + PropertySpec.builder(snakeToCamel(f.name), kt) + .initializer(snakeToCamel(f.name)) + .build() + ) + } + selfClass.primaryConstructor(ctor.build()) + } + selfClass.addFunction(buildTableEncode(generator, decl, schema)) + selfClass.addType(buildTableCompanion(generator, decl, schema)) + return selfClass.build() +} + +internal fun buildTableCompanion(generator: Generator, decl: TableDecl, schema: Schema): TypeSpec { + val selfClass = ClassName("", decl.name) + val layouts = buildFieldLayouts(generator, decl, schema) + + val decodeFun = FunSpec.builder("decode") + .addParameter("bb", generator.flatBufferReader) + .addParameter("tableOffset", INT) + .returns(selfClass) + .apply { + if (layouts.isEmpty()) { + addStatement("return %T()", selfClass) + } else { + addStatement("val vtableOffset = tableOffset - bb.getInt(tableOffset)") + addStatement("val vtableSize = bb.getShort(vtableOffset).toInt()") + addCode("\n") + + layouts.forEach { layout -> + val p = layout.propName + if (layout.isUnion) { + val ts = layout.typeSlotByte + val ds = layout.dataSlotByte + addStatement( + "val __type_$p = if (vtableSize > %L && bb.getShort(vtableOffset + %L).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + %L).toInt()) else 0", + ts, ts, ts + ) + addStatement( + "val __offset_$p = if (vtableSize > %L) bb.getShort(vtableOffset + %L).toInt() else 0", + ds, ds + ) + } else { + val ds = layout.dataSlotByte + addStatement( + "val __offset_$p = if (vtableSize > %L) bb.getShort(vtableOffset + %L).toInt() else 0", + ds, ds + ) + } + } + addCode("\n") + + val fieldExprs = CodeBlock.builder() + layouts.forEachIndexed { i, layout -> + fieldExprs.add(" ${layout.propName} = %L", tableFieldDecodeExpr(generator, layout, schema)) + if (i < layouts.size - 1) fieldExprs.add(",\n") + } + addStatement("return %T(\n%L\n)", selfClass, fieldExprs.build()) + } + } + .build() + + val companionBuilder = TypeSpec.companionObjectBuilder().addFunction(decodeFun) + if (decl.rootType) { + companionBuilder.addFunction( + FunSpec.builder("fromByteBuffer") + .addParameter("bb", generator.flatBufferReader) + .returns(selfClass) + .addStatement("val root = bb.getInt(0) + 0") + .addStatement("return decode(bb, root)") + .build() + ) + } + return companionBuilder.build() +} + +internal fun buildTableEncode(generator: Generator, decl: TableDecl, schema: Schema): FunSpec { + val layouts = buildFieldLayouts(generator, decl, schema) + val totalSlots = layouts.sumOf { if (it.isUnion) 2 else 1 } + val symbols = generator.symbolTable + + return FunSpec.builder("encode") + .addParameter("builder", generator.flatBufferWriter) + .returns(INT) + .apply { + layouts.forEach { layout -> + val p = layout.propName + val f = layout.field + when (val type = f.type) { + is RefType -> if (layout.isUnion) { + val typeName = generator.resolveRefTypeName(type.name, schema) + addStatement("val __off_$p = $p?.let { %T.encode(it, builder) }", typeName) + addStatement("val __type_$p = $p?.let { %T.typeIndex(it) } ?: 0.toByte()", typeName) + } else { + when (generator.resolveDecl(type.name, schema)) { + is EnumDecl -> {} + is StructDecl -> {} + else -> addStatement("val __off_$p = $p?.encode(builder)") + } + } + is VectorType -> + addStatement("val __off_$p = $p?.let { %L }", vectorEncodeExpr(generator, type, schema)) + is ScalarType -> if (type.kind == ScalarKind.STRING) { + addStatement("val __off_$p = $p?.let { builder.createString(it) }") + } + } + } + if (layouts.isNotEmpty()) addCode("\n") + addStatement("builder.startTable(%L)", totalSlots) + + layouts.forEach { layout -> + val p = layout.propName + val f = layout.field + val slot = layout.slotIndex + when (val type = f.type) { + is RefType -> if (layout.isUnion) { + addStatement("builder.addByte(%L, __type_$p, 0)", slot) + addStatement("__off_$p?.let { builder.addOffset(%L, it, 0) }", slot + 1) + } else when (val refDecl = generator.resolveDecl(type.name, schema)) { + is EnumDecl -> { + val info = refDecl.baseType.info + val default = f.builderDefault(symbols, schema) + if (f.isNullable(symbols, schema)) { + addStatement("if ($p != null) { builder.forceDefaults(true); builder.%L(%L, $p.value%L, %L); builder.forceDefaults(false) }", info.adder, slot, info.writeConv, info.zeroBuilder) + } else { + addStatement("builder.%L(%L, $p.value%L, $default)", info.adder, slot, info.writeConv) + } + + } + is StructDecl -> + addStatement("$p?.let { builder.addStruct(%L, it.encode(builder), 0) }", slot) + else -> + addStatement("__off_$p?.let { builder.addOffset(%L, it, 0) }", slot) + } + is VectorType -> + addStatement("__off_$p?.let { builder.addOffset(%L, it, 0) }", slot) + is ScalarType -> when (type.kind) { + ScalarKind.STRING -> + addStatement("__off_$p?.let { builder.addOffset(%L, it, 0) }", slot) + ScalarKind.BOOL -> if (f.isNullable(symbols, schema)) { + addStatement("if ($p != null) { builder.forceDefaults(true); builder.addBoolean(%L, $p, false); builder.forceDefaults(false) }", slot) + } else { + addStatement("builder.addBoolean(%L, $p, %L)", slot, f.builderDefault(symbols, schema)) + } + else -> { + val info = type.kind.info + val default = f.builderDefault(symbols, schema) + if (f.isNullable(symbols, schema)) { + addStatement("if ($p != null) { builder.forceDefaults(true); builder.%L(%L, $p%L, %L); builder.forceDefaults(false) }", info.adder, slot, info.writeConv, info.zeroBuilder) + } else { + addStatement("builder.%L(%L, $p%L, %L)", info.adder, slot, info.writeConv, default) + } + } + } + } + } + addStatement("return builder.endTable()") + } + .build() +} + +internal fun tableFieldDecodeExpr(generator: Generator, layout: TableFieldLayout, schema: Schema): CodeBlock { + val f = layout.field + val p = layout.propName + val symbols = generator.symbolTable + val off = "__offset_$p" + val abs = "tableOffset + $off" + + if (layout.isUnion) { + val typeName = when (val type = f.type) { + is RefType -> generator.resolveRefTypeName(type.name, schema) + else -> error("Union field must be a reference type: ${f.name}") + } + return CodeBlock.of("if ($off != 0) %T.decode(__type_$p, bb, $abs + bb.getInt($abs)) else null", typeName) + } + + return when (val t = f.type) { + is ScalarType -> scalarTableReadExpr(t.kind, off, abs, f.kotlinDefault(symbols, schema)) + is RefType -> when (val decl = generator.resolveDecl(t.name, schema)) { + is EnumDecl -> { + val info = decl.baseType.info + val typeName = generator.resolveRefTypeName(t.name, schema) + val nullable = f.isNullable(symbols, schema) + val absent = f.kotlinDefault(symbols, schema) + if (nullable) { + CodeBlock.of("if ($off != 0) %T.fromValue(bb.${info.bbGetter}($abs)${info.readConv}) else $absent", typeName) + } else { + CodeBlock.of("if ($off != 0) %T.fromValue(bb.${info.bbGetter}($abs)${info.readConv}) ?: %L else %L", typeName, absent, absent) + } + } + is StructDecl -> + CodeBlock.of("if ($off != 0) %T.decode(bb, $abs) else null", generator.resolveRefTypeName(t.name, schema)) + else -> + CodeBlock.of("if ($off != 0) %T.decode(bb, $abs + bb.getInt($abs)) else null", generator.resolveRefTypeName(t.name, schema)) + } + is VectorType -> { + val elem = t.element + CodeBlock.of("if ($off != 0) { val vecOff = $abs + bb.getInt($abs); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> %L } } else null", vectorElemReadExpr(generator, elem, schema, "vecOff + 4 + i * ${vectorElemSize(generator, elem, schema)}")) + } + } +} + +private fun buildFieldLayouts(generator: Generator, decl: TableDecl, schema: Schema): List { + val layouts = mutableListOf() + var slotByte = 4 + var slotIndex = 0 + decl.fields.forEach { f -> + val propName = snakeToCamel(f.name) + when (val type = f.type) { + is RefType -> if (generator.resolveDecl(type.name, schema) is UnionDecl) { + layouts += TableFieldLayout(f, propName, slotByte, slotByte + 2, slotIndex, true) + slotByte += 4 + slotIndex += 2 + } else { + layouts += TableFieldLayout(f, propName, -1, slotByte, slotIndex, false) + slotByte += 2 + slotIndex += 1 + } + else -> { + layouts += TableFieldLayout(f, propName, -1, slotByte, slotIndex, false) + slotByte += 2 + slotIndex += 1 + } + } + } + return layouts +} + +internal data class TableFieldLayout( + val field: Field, + val propName: String, + val typeSlotByte: Int, + val dataSlotByte: Int, + val slotIndex: Int, + val isUnion: Boolean, +) + +private fun scalarTableReadExpr(kind: ScalarKind, off: String, abs: String, absent: String): CodeBlock { + val info = kind.info + return when (kind) { + ScalarKind.BOOL -> CodeBlock.of("if ($off != 0) bb.get($abs) != 0.toByte() else $absent") + ScalarKind.STRING -> CodeBlock.of("if ($off != 0) %M(bb, $abs) else null", readFlatBufferString) + else -> CodeBlock.of("if ($off != 0) bb.${info.bbGetter}($abs)${info.readConv} else $absent") + } +} + +private fun vectorElemReadExpr(generator: Generator, elem: Type, schema: Schema, absExpr: String): CodeBlock = when (elem) { + is ScalarType -> { + val info = elem.kind.info + when (elem.kind) { + ScalarKind.BOOL -> CodeBlock.of("bb.get($absExpr) != 0.toByte()") + ScalarKind.STRING -> CodeBlock.of("%M(bb, $absExpr)", readFlatBufferString) + else -> CodeBlock.of("bb.${info.bbGetter}($absExpr)${info.readConv}") + } + } + is RefType -> when (val refDecl = generator.resolveDecl(elem.name, schema)) { + is EnumDecl -> { + val info = refDecl.baseType.info + CodeBlock.of("%T.fromValue(bb.${info.bbGetter}($absExpr)${info.readConv})", generator.resolveRefTypeName(elem.name, schema)) + } + is StructDecl -> CodeBlock.of("%T.decode(bb, $absExpr)", generator.resolveRefTypeName(elem.name, schema)) + else -> { + val typeName = generator.resolveRefTypeName(elem.name, schema) + CodeBlock.of("if (bb.getInt($absExpr) != 0) %T.decode(bb, $absExpr + bb.getInt($absExpr)) else null", typeName) + } + } + is VectorType -> "error(\"nested vectors not supported\")".let { CodeBlock.of(it) } +} + +private fun vectorElemSize(generator: Generator, elem: Type, schema: Schema? = null): Int = when (elem) { + is ScalarType -> elem.kind.info.size + is RefType -> when (val refDecl = if (schema != null) generator.resolveDecl(elem.name, schema) else null) { + is EnumDecl -> refDecl.baseType.info.size + is StructDecl -> requireStructLayout(generator, refDecl, requireNotNull(schema)).size + else -> 4 + } + else -> 4 +} + +private fun vectorEncodeExpr(generator: Generator, type: VectorType, schema: Schema): CodeBlock { + val elem = type.element + return when (elem) { + is ScalarType -> when (elem.kind) { + ScalarKind.STRING -> + CodeBlock.of("builder.createVectorOfTables(it.map { s -> builder.createString(s) }.toIntArray())") + ScalarKind.INT8, ScalarKind.UINT8 -> + CodeBlock.of("builder.createByteVector(it.map { b -> b${elem.kind.info.writeConv} }.toByteArray())") + else -> vectorScalarEncodeExpr(elem.kind, "it") + } + is RefType -> when (val refDecl = generator.resolveDecl(elem.name, schema)) { + is EnumDecl -> { + when (refDecl.baseType) { + ScalarKind.INT8, ScalarKind.UINT8 -> + CodeBlock.of("builder.createByteVector(it.map { e -> e.value${refDecl.baseType.info.writeConv} }.toByteArray())") + else -> vectorScalarEncodeExpr(refDecl.baseType, "it.map { e -> e.value }") + } + } + is StructDecl -> vectorStructEncodeExpr(generator, refDecl, schema) + else -> CodeBlock.of("builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray())") + } + is VectorType -> "error(\"nested vectors not supported\")".let { CodeBlock.of(it) } + } +} + +private fun vectorScalarEncodeExpr(kind: ScalarKind, valuesExpr: String): CodeBlock { + val info = kind.info + val valueExpr = scalarVectorWriteValue("value", kind) + return CodeBlock.builder() + .add("run { val values = $valuesExpr; ") + .add("builder.startVector(%L, values.size, %L); ", info.size, info.alignment) + .add("for (value in values.asReversed()) builder.%L(%L); ", info.putter, valueExpr) + .add("builder.endVector() }") + .build() +} + +private fun vectorStructEncodeExpr(generator: Generator, decl: StructDecl, schema: Schema): CodeBlock { + val layout = requireStructLayout(generator, decl, schema) + return CodeBlock.of("run { val values = it; builder.startVector(%L, values.size, %L); for (value in values.asReversed()) value.encode(builder); builder.endVector() }", layout.size, layout.alignment) +} + +private fun scalarVectorWriteValue(valueExpr: String, kind: ScalarKind): CodeBlock = when (kind) { + ScalarKind.BOOL -> CodeBlock.of("if ($valueExpr) 1.toByte() else 0.toByte()") + else -> CodeBlock.of("$valueExpr${kind.info.writeConv}") +} diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TypeMapping.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TypeMapping.kt new file mode 100644 index 000000000..a843e2f37 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/TypeMapping.kt @@ -0,0 +1,121 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.* +import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy + +/** + * Metadata about a FlatBuffers scalar type. + */ +internal data class ScalarInfo( + val size: Int, + val alignment: Int = size, + val kotlinType: TypeName, + val bbGetter: String, + val adder: String, + val putter: String, + val readConv: String = "", + val writeConv: String = "", + val zeroKotlin: String, + val zeroBuilder: String +) + +internal val ScalarKind.info: ScalarInfo get() = when (this) { + ScalarKind.BOOL -> ScalarInfo(1, 1, BOOLEAN, "get", "addBoolean", "putByte", zeroKotlin = "false", zeroBuilder = "false") + ScalarKind.INT8 -> ScalarInfo(1, 1, BYTE, "get", "addByte", "putByte", zeroKotlin = "0", zeroBuilder = "0") + ScalarKind.UINT8 -> ScalarInfo(1, 1, U_BYTE, "get", "addByte", "putByte", ".toUByte()", ".toByte()", "0.toUByte()", "0") + ScalarKind.INT16 -> ScalarInfo(2, 2, SHORT, "getShort", "addShort", "putShort", zeroKotlin = "0", zeroBuilder = "0") + ScalarKind.UINT16 -> ScalarInfo(2, 2, U_SHORT, "getShort", "addShort", "putShort", ".toUShort()", ".toShort()", "0.toUShort()", "0") + ScalarKind.INT32 -> ScalarInfo(4, 4, INT, "getInt", "addInt", "putInt", zeroKotlin = "0", zeroBuilder = "0") + ScalarKind.UINT32 -> ScalarInfo(4, 4, U_INT, "getInt", "addInt", "putInt", ".toUInt()", ".toInt()", "0u", "0") + ScalarKind.INT64 -> ScalarInfo(8, 8, LONG, "getLong", "addLong", "putLong", zeroKotlin = "0L", zeroBuilder = "0L") + ScalarKind.UINT64 -> ScalarInfo(8, 8, U_LONG, "getLong", "addLong", "putLong", ".toULong()", ".toLong()", "0uL", "0L") + ScalarKind.FLOAT32 -> ScalarInfo(4, 4, FLOAT, "getFloat", "addFloat", "putFloat", zeroKotlin = "0.0f", zeroBuilder = "0.0") + ScalarKind.FLOAT64 -> ScalarInfo(8, 8, DOUBLE, "getDouble", "addDouble", "putDouble", zeroKotlin = "0.0", zeroBuilder = "0.0") + ScalarKind.STRING -> ScalarInfo(4, 4, STRING, "getInt", "addOffset", "putInt", zeroKotlin = "null", zeroBuilder = "0") +} + +// ── Type Extensions ───────────────────────────────────────────────────────── + +internal fun Type.toKotlinType(symbols: SymbolTable, schema: Schema, nullable: Boolean = false): TypeName { + val base = when (this) { + is ScalarType -> kind.info.kotlinType + is RefType -> symbols.resolve(name, schema).let { ClassName(it.schema.namespace, it.decl.name) } + is VectorType -> LIST.parameterizedBy(element.toKotlinType(symbols, schema, false)) + } + return if (nullable) base.copy(nullable = true) else base +} + +// ── Field Extensions ──────────────────────────────────────────────────────── + +internal fun Field.isNullable(symbols: SymbolTable, schema: Schema): Boolean { + if (defaultValue == "null" || defaultValue == null) return true + return when (val t = type) { + is ScalarType -> t.kind == ScalarKind.STRING + is RefType -> symbols.resolve(t.name, schema).decl !is EnumDecl + is VectorType -> true + } +} + +internal fun Field.kotlinDefault(symbols: SymbolTable, schema: Schema): String { + if (isNullable(symbols, schema)) return "null" + return when (val t = type) { + is ScalarType -> t.kind.toKotlinLiteral(defaultValue) + is RefType -> { + val res = symbols.resolve(t.name, schema) + val decl = res.decl as? EnumDecl ?: return "null" + val variant = defaultValue ?: decl.values.first().name + "${decl.name}.$variant" + } + else -> "null" + } +} + +internal fun Field.builderDefault(symbols: SymbolTable, schema: Schema): String = when (val t = type) { + is ScalarType -> t.kind.toBuilderLiteral(defaultValue) + is RefType -> { + val decl = symbols.resolve(t.name, schema).decl as? EnumDecl ?: return "0" + val variantName = defaultValue ?: decl.values.first().name + val variantValue = decl.values.find { it.name == variantName }?.value + ?: decl.values.indexOfFirst { it.name == variantName }.toLong().takeIf { it != -1L } + ?: 0L + decl.baseType.toBuilderLiteral(variantValue.toString()) + } + else -> "0" +} + +// ── Literal Helpers ───────────────────────────────────────────────────────── + +private fun ScalarKind.toKotlinLiteral(raw: String?): String { + val v = raw ?: return info.zeroKotlin + if (v == "null") return info.zeroKotlin + return when (this) { + ScalarKind.INT64 -> if (v.endsWith("L")) v else "${v}L" + ScalarKind.UINT8 -> "${v}.toUByte()" + ScalarKind.UINT16 -> "${v}.toUShort()" + ScalarKind.UINT32 -> if (v.endsWith("u")) v else "${v}u" + ScalarKind.UINT64 -> if (v.endsWith("uL")) v else "${v}uL" + ScalarKind.FLOAT32 -> if (v.endsWith("f")) v else "${v}f" + ScalarKind.STRING -> "null" + else -> v + } +} + +private fun ScalarKind.toBuilderLiteral(raw: String?): String { + val v = raw ?: return info.zeroBuilder + if (v == "null") return info.zeroBuilder + return when (this) { + ScalarKind.INT64 -> if (v.endsWith("L")) v else "${v}L" + ScalarKind.UINT32 -> "${v}u.toInt()" + ScalarKind.UINT64 -> "${v}uL.toLong()" + ScalarKind.STRING -> "0" + else -> v + } +} + +internal fun Field.deprecatedAnnotation(): AnnotationSpec? = + if (!deprecated) null + else AnnotationSpec.builder(Deprecated::class) + .addMember("%S", "FlatBuffers field `$name` is deprecated.") + .build() + +internal val readFlatBufferString = MemberName("dev.slimevr.fbscodegen.runtime", "readFlatBufferString") diff --git a/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/UnionBuilder.kt b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/UnionBuilder.kt new file mode 100644 index 000000000..ef936d866 --- /dev/null +++ b/kotlin-codegen/src/main/kotlin/dev/slimevr/fbscodegen/UnionBuilder.kt @@ -0,0 +1,71 @@ +package dev.slimevr.fbscodegen + +import com.squareup.kotlinpoet.BYTE +import com.squareup.kotlinpoet.ClassName +import com.squareup.kotlinpoet.FunSpec +import com.squareup.kotlinpoet.INT +import com.squareup.kotlinpoet.KModifier +import com.squareup.kotlinpoet.TypeSpec + +internal fun buildUnionType(generator: Generator, decl: UnionDecl, schema: Schema): TypeSpec { + val selfClass = ClassName(schema.namespace, decl.name) + + val decodeFun = FunSpec.builder("decode") + .addParameter("type", BYTE) + .addParameter("bb", generator.flatBufferReader) + .addParameter("offset", INT) + .returns(selfClass.copy(nullable = true)) + .apply { + beginControlFlow("return when (type.toInt())") + decl.variants.forEachIndexed { i, variantRef -> + addStatement("%L -> %T.decode(bb, offset)", i + 1, generator.resolveRefTypeName(variantRef, schema)) + } + addStatement("else -> null") + endControlFlow() + } + .build() + + val allVariantsInSamePackage = decl.variants.all { variantRef -> + generator.resolveRefTypeName(variantRef, schema).packageName == schema.namespace + } + + val typeIndexFun = FunSpec.builder("typeIndex") + .addParameter("value", selfClass) + .returns(BYTE) + .apply { + beginControlFlow("return when (value)") + decl.variants.forEachIndexed { i, variantRef -> + addStatement("is %T -> %L", generator.resolveRefTypeName(variantRef, schema), i + 1) + } + if (!allVariantsInSamePackage) addStatement("else -> 0") + endControlFlow() + } + .build() + + val encodeFun = FunSpec.builder("encode") + .addParameter("value", selfClass) + .addParameter("builder", generator.flatBufferWriter) + .returns(INT) + .apply { + beginControlFlow("return when (value)") + decl.variants.forEach { variantRef -> + addStatement("is %T -> value.encode(builder)", generator.resolveRefTypeName(variantRef, schema)) + } + if (!allVariantsInSamePackage) addStatement("else -> 0") + endControlFlow() + } + .build() + val interfaceBuilder = TypeSpec.interfaceBuilder(decl.name) + .addKdoc(decl.comments.joinToString("\n")) + if (allVariantsInSamePackage) interfaceBuilder.addModifiers(KModifier.SEALED) + + return interfaceBuilder + .addType( + TypeSpec.companionObjectBuilder() + .addFunction(decodeFun) + .addFunction(typeIndexFun) + .addFunction(encodeFun) + .build() + ) + .build() +} diff --git a/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/ComplexTest.kt b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/ComplexTest.kt new file mode 100644 index 000000000..6b5a1b177 --- /dev/null +++ b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/ComplexTest.kt @@ -0,0 +1,98 @@ +package dev.slimevr.fbscodegen + +import com.google.flatbuffers.FlatBufferBuilder +import dev.slimevr.fbscodegen.runtime.JvmFlatBufferReader +import dev.slimevr.fbscodegen.runtime.JvmFlatBufferWriter +import fixture.complex.* +import java.nio.ByteBuffer +import java.nio.ByteOrder +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +class ComplexTest { + + @Test + fun `round trips enums and unions`() { + val root = ComplexRoot( + singleEnum = TestEnum.B, + optionalEnum = TestEnum.C, + explicitEnum = TestEnum.A, + singleUnion = TestStruct(a = 42, b = 3.14f), + enumVector = listOf(TestEnum.A, TestEnum.B, TestEnum.C) + ) + + val decoded = encodeDecode(root) + assertEquals(root, decoded) + } + + @Test + fun `handles nullable enums and empty vectors`() { + val root = ComplexRoot( + singleEnum = null, + optionalEnum = null, + explicitEnum = TestEnum.B, // non-nullable because explicit default + singleUnion = null, + enumVector = null + ) + + val decoded = encodeDecode(root) + assertEquals(root, decoded) + assertNull(decoded.singleEnum) + assertNull(decoded.optionalEnum) + assertEquals(TestEnum.B, decoded.explicitEnum) + assertNull(decoded.singleUnion) + assertNull(decoded.enumVector) + } + + @Test + fun `handles unknown enum values by returning null`() { + // Manually build a buffer with an invalid enum value (e.g., 99) + val builder = FlatBufferBuilder(0) + + // Add an enum vector [0, 99, 1] - MUST be done before starting the table + val vOff = run { + builder.startVector(1, 3, 1) + builder.putByte(1.toByte()) + builder.putByte(99.toByte()) + builder.putByte(0.toByte()) + builder.endVector() + } + + // ComplexRoot layout: + // 0: singleEnum (1 byte) + // 1: optionalEnum (1 byte) + // 2: explicitEnum (1 byte) + // 3: singleUnion type (1 byte) + // 4: singleUnion data (offset) + // 5: enumVector (offset) + + builder.startTable(6) + + // Add singleEnum = 99 + builder.forceDefaults(true) + builder.addByte(0, 99.toByte(), 0) + builder.forceDefaults(false) + + builder.addOffset(5, vOff, 0) + + val rootOff = builder.endTable() + builder.finish(rootOff) + + val bb = builder.dataBuffer().duplicate().order(ByteOrder.LITTLE_ENDIAN) + val decoded = ComplexRoot.fromByteBuffer(JvmFlatBufferReader(bb)) + + // singleEnum should be null because 99 is invalid + assertNull(decoded.singleEnum) + + // enumVector should be [A, B] because 99 was filtered out by mapNotNull + assertEquals(listOf(TestEnum.A, TestEnum.B), decoded.enumVector) + } + + private fun encodeDecode(root: ComplexRoot): ComplexRoot { + val builder = FlatBufferBuilder(0) + builder.finish(root.encode(JvmFlatBufferWriter(builder))) + val bb = builder.dataBuffer().duplicate().order(ByteOrder.LITTLE_ENDIAN) + return ComplexRoot.fromByteBuffer(JvmFlatBufferReader(bb)) + } +} diff --git a/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/FixturesTest.kt b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/FixturesTest.kt new file mode 100644 index 000000000..8ab9bdd0f --- /dev/null +++ b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/FixturesTest.kt @@ -0,0 +1,163 @@ +package dev.slimevr.fbscodegen + +import com.google.flatbuffers.FlatBufferBuilder +import dev.slimevr.fbscodegen.runtime.JvmFlatBufferReader +import dev.slimevr.fbscodegen.runtime.JvmFlatBufferWriter +import fixture.compound.NestedStruct +import fixture.compound.RootTable +import fixture.compound.ScalarVectors +import fixture.scalars.AllScalarStruct +import fixture.scalars.DefaultScalars +import fixture.scalars.OptionalScalars +import java.nio.ByteBuffer +import java.nio.ByteOrder +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +class FixturesTest { + @Test + fun `round trips all scalar kinds through compound schema`() { + val scalarStruct = AllScalarStruct( + b = true, + i8 = (-128).toByte(), + u8 = 255.toUByte(), + i16 = (-32000).toShort(), + u16 = 65000.toUShort(), + i32 = -123456789, + u32 = 4_000_000_000u, + i64 = -9_876_543_210_123_456L, + u64 = 18_000_000_000_000_000_000uL, + f32 = 123.5f, + f64 = -9876.125, + ) + + val root = RootTable( + inlineStruct = scalarStruct, + nestedStruct = NestedStruct( + prefix = 7.toUByte(), + inner = scalarStruct, + suffix = (-123).toShort(), + ), + optionalScalars = OptionalScalars( + obool = true, + oi8 = (-7).toByte(), + ou8 = 200.toUByte(), + oi16 = (-1024).toShort(), + ou16 = 2048.toUShort(), + oi32 = -12345, + ou32 = 54321u, + oi64 = -999_999_999L, + ou64 = 999_999_999uL, + of32 = 6.25f, + of64 = -8.5, + ), + defaultScalars = DefaultScalars(), + vectors = ScalarVectors( + bools = listOf(true, false, true), + i8s = listOf((-128).toByte(), 0, 127), + u8s = listOf(0.toUByte(), 1.toUByte(), 255.toUByte()), + i16s = listOf((-32768).toShort(), 0, 32767.toShort()), + u16s = listOf(0.toUShort(), 42.toUShort(), 65535.toUShort()), + i32s = listOf(Int.MIN_VALUE, 0, Int.MAX_VALUE), + u32s = listOf(0u, 1u, 4_000_000_000u), + i64s = listOf(Long.MIN_VALUE, 0L, Long.MAX_VALUE), + u64s = listOf(0uL, 1uL, ULong.MAX_VALUE), + f32s = listOf(-1.25f, 0.0f, 3.5f), + f64s = listOf(-1.25, 0.0, 3.5), + names = listOf("alpha", "beta", "gamma"), + structs = listOf( + scalarStruct, + scalarStruct.copy( + b = false, + i8 = 64, + u8 = 12.toUByte(), + i16 = 2048, + u16 = 4096.toUShort(), + i32 = 987654321, + u32 = 123u, + i64 = 42L, + u64 = 77uL, + f32 = -0.5f, + f64 = 0.25, + ), + ), + ), + label = "scalar-root", + ) + + assertEquals(root, encodeDecodeWithNonZeroPosition(root)) + } + + @Test + fun `preserves defaults and nullable scalar absence`() { + val root = RootTable( + inlineStruct = AllScalarStruct( + b = false, + i8 = 0, + u8 = 0.toUByte(), + i16 = 0, + u16 = 0.toUShort(), + i32 = 0, + u32 = 0u, + i64 = 0L, + u64 = 0uL, + f32 = 0.0f, + f64 = 0.0, + ), + nestedStruct = NestedStruct( + prefix = 0.toUByte(), + inner = AllScalarStruct( + b = false, + i8 = 0, + u8 = 0.toUByte(), + i16 = 0, + u16 = 0.toUShort(), + i32 = 0, + u32 = 0u, + i64 = 0L, + u64 = 0uL, + f32 = 0.0f, + f64 = 0.0, + ), + suffix = 0, + ), + optionalScalars = OptionalScalars(), + defaultScalars = DefaultScalars(), + vectors = ScalarVectors(), + label = "defaults", + ) + + val decoded = encodeDecodeWithNonZeroPosition(root) + + assertEquals(root, decoded) + assertEquals(DefaultScalars(), decoded.defaultScalars) + + assertNull(decoded.optionalScalars?.obool) + assertNull(decoded.optionalScalars?.oi8) + assertNull(decoded.optionalScalars?.ou8) + assertNull(decoded.optionalScalars?.oi16) + assertNull(decoded.optionalScalars?.ou16) + assertNull(decoded.optionalScalars?.oi32) + assertNull(decoded.optionalScalars?.ou32) + assertNull(decoded.optionalScalars?.oi64) + assertNull(decoded.optionalScalars?.ou64) + assertNull(decoded.optionalScalars?.of32) + assertNull(decoded.optionalScalars?.of64) + } + + private fun encodeDecodeWithNonZeroPosition(root: RootTable): RootTable { + val builder = FlatBufferBuilder(0) + builder.finish(root.encode(JvmFlatBufferWriter(builder))) + val built = builder.dataBuffer().duplicate().order(ByteOrder.LITTLE_ENDIAN) + + val prefixed = ByteBuffer.allocate(built.remaining() + 8).order(ByteOrder.LITTLE_ENDIAN) + prefixed.position(8) + prefixed.put(built) + prefixed.position(8) + + // For non-zero starting position, we slice the buffer so that get(0) is the start of the FlatBuffer + val sliced = prefixed.slice().order(ByteOrder.LITTLE_ENDIAN) + return RootTable.fromByteBuffer(JvmFlatBufferReader(sliced)) + } +} diff --git a/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/GeneratorTest.kt b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/GeneratorTest.kt new file mode 100644 index 000000000..6b6e6b56c --- /dev/null +++ b/kotlin-codegen/src/test/kotlin/dev/slimevr/fbscodegen/GeneratorTest.kt @@ -0,0 +1,55 @@ +package dev.slimevr.fbscodegen + +import kotlin.test.Test +import kotlin.test.assertFailsWith +import kotlin.test.assertTrue + +class GeneratorTest { + @Test + fun `fails on ambiguous unqualified type references`() { + val schemaOne = Schema( + namespace = "one", + includes = emptyList(), + declarations = listOf( + StructDecl( + name = "Shared", + fields = listOf( + Field("value", ScalarType(ScalarKind.INT32)), + ), + ), + ), + ) + + val schemaTwo = Schema( + namespace = "two", + includes = emptyList(), + declarations = listOf( + StructDecl( + name = "Shared", + fields = listOf( + Field("value", ScalarType(ScalarKind.INT32)), + ), + ), + ), + ) + + val schemaThree = Schema( + namespace = "three", + includes = emptyList(), + declarations = listOf( + TableDecl( + name = "Root", + fields = listOf( + Field("shared", RefType("Shared")), + ), + ), + ), + ) + + val error = assertFailsWith { + Generator(listOf(schemaOne, schemaTwo, schemaThree)).generate() + } + + assertTrue(error.message.orEmpty().contains("Ambiguous")) + } +} diff --git a/kotlin-codegen/src/test/resources/schemas/all.fbs b/kotlin-codegen/src/test/resources/schemas/all.fbs new file mode 100644 index 000000000..0239e12d3 --- /dev/null +++ b/kotlin-codegen/src/test/resources/schemas/all.fbs @@ -0,0 +1,3 @@ +include "scalars.fbs"; +include "compound.fbs"; +include "complex.fbs"; diff --git a/kotlin-codegen/src/test/resources/schemas/complex.fbs b/kotlin-codegen/src/test/resources/schemas/complex.fbs new file mode 100644 index 000000000..fae5dc9fa --- /dev/null +++ b/kotlin-codegen/src/test/resources/schemas/complex.fbs @@ -0,0 +1,33 @@ +namespace fixture.complex; + +enum TestEnum : uint8 { + A = 0, + B = 1, + C = 2 +} + +struct TestStruct { + a: int32; + b: float32; +} + +table TestTable { + name: string; +} + +union TestUnion { + TestStruct, + TestTable +} + +table ComplexRoot { + single_enum: TestEnum; + optional_enum: TestEnum = null; + explicit_enum: TestEnum = B; + + single_union: TestUnion; + + enum_vector: [TestEnum]; +} + +root_type ComplexRoot; diff --git a/kotlin-codegen/src/test/resources/schemas/compound.fbs b/kotlin-codegen/src/test/resources/schemas/compound.fbs new file mode 100644 index 000000000..618244913 --- /dev/null +++ b/kotlin-codegen/src/test/resources/schemas/compound.fbs @@ -0,0 +1,36 @@ +include "scalars.fbs"; + +namespace fixture.compound; + +table ScalarVectors { + bools: [bool]; + i8s: [int8]; + u8s: [uint8]; + i16s: [int16]; + u16s: [uint16]; + i32s: [int32]; + u32s: [uint32]; + i64s: [int64]; + u64s: [uint64]; + f32s: [float32]; + f64s: [float64]; + names: [string]; + structs: [fixture.scalars.AllScalarStruct]; +} + +struct NestedStruct { + prefix: uint8; + inner: fixture.scalars.AllScalarStruct; + suffix: int16; +} + +table RootTable { + inline_struct: fixture.scalars.AllScalarStruct; + nested_struct: NestedStruct; + optional_scalars: fixture.scalars.OptionalScalars; + default_scalars: fixture.scalars.DefaultScalars; + vectors: ScalarVectors; + label: string; +} + +root_type RootTable; diff --git a/kotlin-codegen/src/test/resources/schemas/scalars.fbs b/kotlin-codegen/src/test/resources/schemas/scalars.fbs new file mode 100644 index 000000000..dcda26663 --- /dev/null +++ b/kotlin-codegen/src/test/resources/schemas/scalars.fbs @@ -0,0 +1,43 @@ +namespace fixture.scalars; + +struct AllScalarStruct { + b: bool; + i8: int8; + u8: uint8; + i16: int16; + u16: uint16; + i32: int32; + u32: uint32; + i64: int64; + u64: uint64; + f32: float32; + f64: float64; +} + +table OptionalScalars { + obool: bool = null; + oi8: int8 = null; + ou8: uint8 = null; + oi16: int16 = null; + ou16: uint16 = null; + oi32: int32 = null; + ou32: uint32 = null; + oi64: int64 = null; + ou64: uint64 = null; + of32: float32 = null; + of64: float64 = null; +} + +table DefaultScalars { + dbool: bool = true; + di8: int8 = -12; + du8: uint8 = 250; + di16: int16 = -1234; + du16: uint16 = 65000; + di32: int32 = -12345678; + du32: uint32 = 4000000000; + di64: int64 = -1234567890123; + du64: uint64 = 9000000000000000000; + df32: float32 = 1.5; + df64: float64 = -2.25; +} diff --git a/package.json b/package.json index 1370fa5ae..ad020312a 100644 --- a/package.json +++ b/package.json @@ -4,6 +4,12 @@ "description": "Serialization Protocol for SlimeVR", "main": "./protocol/typescript/dist/all_generated.js", "types": "./protocol/typescript/dist/all_generated.d.ts", + "files": [ + "protocol/typescript/**", + "schema/**", + "README.md", + "LICENSE-*" + ], "scripts": { "build": "tsc", "prepare": "npm run build" diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index 85ab3e014..5dd8f67de 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -20,14 +20,6 @@ struct HzF32; struct TransactionId; -struct DeviceId; - -struct DeviceIdTable; -struct DeviceIdTableBuilder; - -struct TrackerId; -struct TrackerIdBuilder; - struct LogData; struct LogDataBuilder; @@ -35,12 +27,6 @@ struct Temperature; struct Ipv4Address; -struct Bytes; -struct BytesBuilder; - -struct StringTable; -struct StringTableBuilder; - namespace hardware_info { struct HardwareAddress; @@ -76,7 +62,7 @@ struct StayAlignedTrackerBuilder; } // namespace stay_aligned -namespace tracker { +namespace tracker_data { struct TrackerData; struct TrackerDataBuilder; @@ -87,7 +73,7 @@ struct TrackerDataMaskBuilder; struct TrackerInfo; struct TrackerInfoBuilder; -} // namespace tracker +} // namespace tracker_data namespace device_data { @@ -127,150 +113,123 @@ struct DataFeedConfigBuilder; } // namespace data_feed namespace rpc { -namespace settings { - -struct ModelToggles; -struct ModelTogglesBuilder; - -struct ModelRatios; -struct ModelRatiosBuilder; - -struct LegTweaksSettings; -struct LegTweaksSettingsBuilder; - -struct SkeletonHeight; -struct SkeletonHeightBuilder; - -struct ModelSettings; -struct ModelSettingsBuilder; - -} // namespace settings - -struct Keybind; -struct KeybindBuilder; -struct KeybindRequest; -struct KeybindRequestBuilder; - -struct KeybindResponse; -struct KeybindResponseBuilder; - -struct ChangeKeybindRequest; -struct ChangeKeybindRequestBuilder; +struct AutoBoneProcessRequest; +struct AutoBoneProcessRequestBuilder; -struct OpenUriRequest; -struct OpenUriRequestBuilder; +struct AutoBoneProcessStatusResponse; +struct AutoBoneProcessStatusResponseBuilder; -struct OpenUriResponse; -struct OpenUriResponseBuilder; +struct AutoBoneEpochResponse; +struct AutoBoneEpochResponseBuilder; -struct RpcMessageHeader; -struct RpcMessageHeaderBuilder; +struct AutoBoneApplyRequest; +struct AutoBoneApplyRequestBuilder; -struct InstalledInfoRequest; -struct InstalledInfoRequestBuilder; +struct AutoBoneStopRecordingRequest; +struct AutoBoneStopRecordingRequestBuilder; -struct InstalledInfoResponse; -struct InstalledInfoResponseBuilder; +struct AutoBoneCancelRecordingRequest; +struct AutoBoneCancelRecordingRequestBuilder; -struct HeartbeatRequest; -struct HeartbeatRequestBuilder; +struct RecordBVHRequest; +struct RecordBVHRequestBuilder; -struct HeartbeatResponse; -struct HeartbeatResponseBuilder; +struct RecordBVHStatus; +struct RecordBVHStatusBuilder; -struct ResetRequest; -struct ResetRequestBuilder; +struct RecordBVHStatusRequest; +struct RecordBVHStatusRequestBuilder; -struct ResetResponse; -struct ResetResponseBuilder; +struct UnknownDeviceHandshakeNotification; +struct UnknownDeviceHandshakeNotificationBuilder; -struct AssignTrackerRequest; -struct AssignTrackerRequestBuilder; +struct AddUnknownDeviceRequest; +struct AddUnknownDeviceRequestBuilder; -struct ClearDriftCompensationRequest; -struct ClearDriftCompensationRequestBuilder; +struct ForgetDeviceRequest; +struct ForgetDeviceRequestBuilder; -struct SettingsRequest; -struct SettingsRequestBuilder; +struct SerialDevicePort; +struct SerialDevicePortBuilder; -struct SettingsResponse; -struct SettingsResponseBuilder; +struct FirmwareDeviceIdTable; +struct FirmwareDeviceIdTableBuilder; -struct ChangeSettingsRequest; -struct ChangeSettingsRequestBuilder; +struct FirmwarePart; +struct FirmwarePartBuilder; -struct SteamVRTrackersSetting; -struct SteamVRTrackersSettingBuilder; +struct FirmwareUpdateRequest; +struct FirmwareUpdateRequestBuilder; -struct FilteringSettings; -struct FilteringSettingsBuilder; +struct OTAFirmwareUpdate; +struct OTAFirmwareUpdateBuilder; -struct DriftCompensationSettings; -struct DriftCompensationSettingsBuilder; +struct SerialFirmwareUpdate; +struct SerialFirmwareUpdateBuilder; -struct OSCRouterSettings; -struct OSCRouterSettingsBuilder; +struct FirmwareUpdateStatusResponse; +struct FirmwareUpdateStatusResponseBuilder; -struct VRCOSCSettings; -struct VRCOSCSettingsBuilder; +struct FirmwareUpdateStopQueuesRequest; +struct FirmwareUpdateStopQueuesRequestBuilder; -struct VMCOSCSettings; -struct VMCOSCSettingsBuilder; +struct StartUserHeightCalibration; +struct StartUserHeightCalibrationBuilder; -struct VRMSettings; -struct VRMSettingsBuilder; +struct CancelUserHeightCalibration; +struct CancelUserHeightCalibrationBuilder; -struct OSCSettings; -struct OSCSettingsBuilder; +struct UserHeightRecordingStatusResponse; +struct UserHeightRecordingStatusResponseBuilder; -struct OSCTrackersSetting; -struct OSCTrackersSettingBuilder; +struct Keybind; +struct KeybindBuilder; -struct TapDetectionSettings; -struct TapDetectionSettingsBuilder; +struct KeybindRequest; +struct KeybindRequestBuilder; -struct ResetsSettings; -struct ResetsSettingsBuilder; +struct KeybindResponse; +struct KeybindResponseBuilder; -struct StayAlignedSettings; -struct StayAlignedSettingsBuilder; +struct ChangeKeybindRequest; +struct ChangeKeybindRequestBuilder; -struct HIDSettings; -struct HIDSettingsBuilder; +struct OverlayDisplayModeRequest; +struct OverlayDisplayModeRequestBuilder; -struct TimeoutSettings; -struct TimeoutSettingsBuilder; +struct OverlayDisplayModeChangeRequest; +struct OverlayDisplayModeChangeRequestBuilder; -struct VelocitySettings; -struct VelocitySettingsBuilder; +struct OverlayDisplayModeResponse; +struct OverlayDisplayModeResponseBuilder; -struct TapDetectionSetupNotification; -struct TapDetectionSetupNotificationBuilder; +struct StartWifiProvisioningRequest; +struct StartWifiProvisioningRequestBuilder; -struct RecordBVHRequest; -struct RecordBVHRequestBuilder; +struct StopWifiProvisioningRequest; +struct StopWifiProvisioningRequestBuilder; -struct RecordBVHStatus; -struct RecordBVHStatusBuilder; +struct WifiProvisioningStatusResponse; +struct WifiProvisioningStatusResponseBuilder; -struct RecordBVHStatusRequest; -struct RecordBVHStatusRequestBuilder; +struct ResetRequest; +struct ResetRequestBuilder; -struct SkeletonPart; -struct SkeletonPartBuilder; +struct ResetResponse; +struct ResetResponseBuilder; -struct SkeletonConfigRequest; -struct SkeletonConfigRequestBuilder; +struct ClearMountingResetRequest; +struct ClearMountingResetRequestBuilder; -struct SkeletonConfigResponse; -struct SkeletonConfigResponseBuilder; +struct ResetsSettingsRequest; +struct ResetsSettingsRequestBuilder; -struct SkeletonResetAllRequest; -struct SkeletonResetAllRequestBuilder; +struct ResetsSettingsResponse; +struct ResetsSettingsResponseBuilder; -struct ChangeSkeletonConfigRequest; -struct ChangeSkeletonConfigRequestBuilder; +struct ChangeResetsSettingsRequest; +struct ChangeResetsSettingsRequestBuilder; struct SerialDevice; struct SerialDeviceBuilder; @@ -281,9 +240,6 @@ struct OpenSerialRequestBuilder; struct CloseSerialRequest; struct CloseSerialRequestBuilder; -struct SetWifiRequest; -struct SetWifiRequestBuilder; - struct SerialUpdateResponse; struct SerialUpdateResponseBuilder; @@ -308,56 +264,32 @@ struct SerialDevicesResponseBuilder; struct NewSerialDeviceResponse; struct NewSerialDeviceResponseBuilder; -struct StartWifiProvisioningRequest; -struct StartWifiProvisioningRequestBuilder; - -struct StopWifiProvisioningRequest; -struct StopWifiProvisioningRequestBuilder; - -struct WifiProvisioningStatusResponse; -struct WifiProvisioningStatusResponseBuilder; - -struct AutoBoneProcessRequest; -struct AutoBoneProcessRequestBuilder; - -struct AutoBoneProcessStatusResponse; -struct AutoBoneProcessStatusResponseBuilder; - -struct AutoBoneEpochResponse; -struct AutoBoneEpochResponseBuilder; - -struct AutoBoneSettings; -struct AutoBoneSettingsBuilder; - -struct HeightRequest; -struct HeightRequestBuilder; - -struct HeightResponse; -struct HeightResponseBuilder; +struct SerialTrackerGetWifiScanRequest; +struct SerialTrackerGetWifiScanRequestBuilder; -struct AutoBoneApplyRequest; -struct AutoBoneApplyRequestBuilder; +struct HIDSettingsRequest; +struct HIDSettingsRequestBuilder; -struct AutoBoneStopRecordingRequest; -struct AutoBoneStopRecordingRequestBuilder; +struct HIDSettingsResponse; +struct HIDSettingsResponseBuilder; -struct AutoBoneCancelRecordingRequest; -struct AutoBoneCancelRecordingRequestBuilder; +struct ChangeHIDSettingsRequest; +struct ChangeHIDSettingsRequestBuilder; -struct OverlayDisplayModeRequest; -struct OverlayDisplayModeRequestBuilder; +struct SkeletonPart; +struct SkeletonPartBuilder; -struct OverlayDisplayModeChangeRequest; -struct OverlayDisplayModeChangeRequestBuilder; +struct SkeletonProportionsRequest; +struct SkeletonProportionsRequestBuilder; -struct OverlayDisplayModeResponse; -struct OverlayDisplayModeResponseBuilder; +struct SkeletonProportionsResponse; +struct SkeletonProportionsResponseBuilder; -struct ServerInfosRequest; -struct ServerInfosRequestBuilder; +struct ChangeSkeletonProportionsRequest; +struct ChangeSkeletonProportionsRequestBuilder; -struct ServerInfosResponse; -struct ServerInfosResponseBuilder; +struct SkeletonProportionsResetAllRequest; +struct SkeletonProportionsResetAllRequestBuilder; struct LegTweaksTmpChange; struct LegTweaksTmpChangeBuilder; @@ -365,86 +297,86 @@ struct LegTweaksTmpChangeBuilder; struct LegTweaksTmpClear; struct LegTweaksTmpClearBuilder; -struct StatusTrackerReset; -struct StatusTrackerResetBuilder; +struct SetPauseTrackingRequest; +struct SetPauseTrackingRequestBuilder; -struct StatusTrackerError; -struct StatusTrackerErrorBuilder; +struct TrackingPauseStateRequest; +struct TrackingPauseStateRequestBuilder; -struct StatusSteamVRDisconnected; -struct StatusSteamVRDisconnectedBuilder; +struct TrackingPauseStateResponse; +struct TrackingPauseStateResponseBuilder; -struct StatusUnassignedHMD; -struct StatusUnassignedHMDBuilder; +struct SkeletonToggles; +struct SkeletonTogglesBuilder; -struct StatusSystemRequest; -struct StatusSystemRequestBuilder; +struct SkeletonRatios; +struct SkeletonRatiosBuilder; -struct StatusSystemResponse; -struct StatusSystemResponseBuilder; +struct SkeletonFiltering; +struct SkeletonFilteringBuilder; -struct StatusSystemUpdate; -struct StatusSystemUpdateBuilder; +struct SkeletonHeight; +struct SkeletonHeightBuilder; -struct StatusSystemFixed; -struct StatusSystemFixedBuilder; +struct SkeletonSettingsRequest; +struct SkeletonSettingsRequestBuilder; -struct StatusPublicNetwork; -struct StatusPublicNetworkBuilder; +struct SkeletonSettingsResponse; +struct SkeletonSettingsResponseBuilder; -struct StatusMessage; -struct StatusMessageBuilder; +struct ChangeSkeletonSettingsRequest; +struct ChangeSkeletonSettingsRequestBuilder; -struct SetPauseTrackingRequest; -struct SetPauseTrackingRequestBuilder; +struct OutputTrackersSettingsRequest; +struct OutputTrackersSettingsRequestBuilder; -struct ClearMountingResetRequest; -struct ClearMountingResetRequestBuilder; +struct OutputTrackersSettingsResponse; +struct OutputTrackersSettingsResponseBuilder; -struct SaveFileNotification; -struct SaveFileNotificationBuilder; +struct ChangeOutputTrackersSettingsRequest; +struct ChangeOutputTrackersSettingsRequestBuilder; -struct SerialDevicePort; -struct SerialDevicePortBuilder; +struct EnableStayAlignedRequest; +struct EnableStayAlignedRequestBuilder; -struct FirmwarePart; -struct FirmwarePartBuilder; +struct DetectStayAlignedRelaxedPoseRequest; +struct DetectStayAlignedRelaxedPoseRequestBuilder; -struct FirmwareUpdateRequest; -struct FirmwareUpdateRequestBuilder; +struct ResetStayAlignedRelaxedPoseRequest; +struct ResetStayAlignedRelaxedPoseRequestBuilder; -struct OTAFirmwareUpdate; -struct OTAFirmwareUpdateBuilder; +struct StayAlignedSettingsRequest; +struct StayAlignedSettingsRequestBuilder; -struct SerialFirmwareUpdate; -struct SerialFirmwareUpdateBuilder; +struct StayAlignedSettingsResponse; +struct StayAlignedSettingsResponseBuilder; -struct FirmwareUpdateStatusResponse; -struct FirmwareUpdateStatusResponseBuilder; +struct ChangeStayAlignedSettingsRequest; +struct ChangeStayAlignedSettingsRequestBuilder; -struct FirmwareUpdateStopQueuesRequest; -struct FirmwareUpdateStopQueuesRequestBuilder; +struct CompleteStayAlignedResponse; +struct CompleteStayAlignedResponseBuilder; -struct TrackingPauseStateRequest; -struct TrackingPauseStateRequestBuilder; +struct StayAlignedHideCorrectionRequest; +struct StayAlignedHideCorrectionRequestBuilder; -struct TrackingPauseStateResponse; -struct TrackingPauseStateResponseBuilder; +struct AssignTrackerRequest; +struct AssignTrackerRequestBuilder; -struct SerialTrackerGetWifiScanRequest; -struct SerialTrackerGetWifiScanRequestBuilder; +struct TapDetectionSettingsRequest; +struct TapDetectionSettingsRequestBuilder; -struct UnknownDeviceHandshakeNotification; -struct UnknownDeviceHandshakeNotificationBuilder; +struct TapDetectionSettingsResponse; +struct TapDetectionSettingsResponseBuilder; -struct AddUnknownDeviceRequest; -struct AddUnknownDeviceRequestBuilder; +struct ChangeTapDetectionSettingsRequest; +struct ChangeTapDetectionSettingsRequestBuilder; -struct ForgetDeviceRequest; -struct ForgetDeviceRequestBuilder; +struct TapDetectionSetupModeRequest; +struct TapDetectionSetupModeRequestBuilder; -struct SettingsResetRequest; -struct SettingsResetRequestBuilder; +struct TapDetectionSetupNotification; +struct TapDetectionSetupNotificationBuilder; struct MagToggleRequest; struct MagToggleRequestBuilder; @@ -455,24 +387,6 @@ struct MagToggleResponseBuilder; struct ChangeMagToggleRequest; struct ChangeMagToggleRequestBuilder; -struct VRCConfigValidity; -struct VRCConfigValidityBuilder; - -struct VRCConfigValues; -struct VRCConfigValuesBuilder; - -struct VRCConfigRecommendedValues; -struct VRCConfigRecommendedValuesBuilder; - -struct VRCConfigStateRequest; -struct VRCConfigStateRequestBuilder; - -struct VRCConfigStateChangeResponse; -struct VRCConfigStateChangeResponseBuilder; - -struct VRCConfigSettingToggleMute; -struct VRCConfigSettingToggleMuteBuilder; - struct TrackingChecklistTrackerReset; struct TrackingChecklistTrackerResetBuilder; @@ -506,53 +420,97 @@ struct TrackingChecklistResponseBuilder; struct IgnoreTrackingChecklistStepRequest; struct IgnoreTrackingChecklistStepRequestBuilder; -struct EnableStayAlignedRequest; -struct EnableStayAlignedRequestBuilder; +struct VMCOSCSettingsRequest; +struct VMCOSCSettingsRequestBuilder; -struct DetectStayAlignedRelaxedPoseRequest; -struct DetectStayAlignedRelaxedPoseRequestBuilder; +struct VMCOSCSettingsResponse; +struct VMCOSCSettingsResponseBuilder; -struct ResetStayAlignedRelaxedPoseRequest; -struct ResetStayAlignedRelaxedPoseRequestBuilder; +struct ChangeVMCOSCSettingsRequest; +struct ChangeVMCOSCSettingsRequestBuilder; -struct StartUserHeightCalibration; -struct StartUserHeightCalibrationBuilder; +struct VRMSettingsRequest; +struct VRMSettingsRequestBuilder; -struct CancelUserHeightCalibration; -struct CancelUserHeightCalibrationBuilder; +struct VRMSettingsResponse; +struct VRMSettingsResponseBuilder; -struct UserHeightRecordingStatusResponse; -struct UserHeightRecordingStatusResponseBuilder; +struct ChangeVRMSettingsRequest; +struct ChangeVRMSettingsRequestBuilder; -} // namespace rpc +struct VRCConfigValidity; +struct VRCConfigValidityBuilder; -namespace pub_sub { +struct VRCConfigValues; +struct VRCConfigValuesBuilder; -struct TopicId; -struct TopicIdBuilder; +struct VRCConfigRecommendedValues; +struct VRCConfigRecommendedValuesBuilder; -struct TopicHandle; -struct TopicHandleBuilder; +struct VRCConfigStateRequest; +struct VRCConfigStateRequestBuilder; -struct TopicMapping; -struct TopicMappingBuilder; +struct VRCConfigStateChangeResponse; +struct VRCConfigStateChangeResponseBuilder; + +struct VRCConfigSettingToggleMute; +struct VRCConfigSettingToggleMuteBuilder; + +struct VRCOSCNetworkSettings; +struct VRCOSCNetworkSettingsBuilder; + +struct VRCOSCDiscoveredTarget; +struct VRCOSCDiscoveredTargetBuilder; + +struct VRCOSCStatusRequest; +struct VRCOSCStatusRequestBuilder; + +struct VRCOSCStatusChangeResponse; +struct VRCOSCStatusChangeResponseBuilder; + +struct VRCOSCSettingsRequest; +struct VRCOSCSettingsRequestBuilder; + +struct VRCOSCSettingsResponse; +struct VRCOSCSettingsResponseBuilder; + +struct ChangeVRCOSCSettingsRequest; +struct ChangeVRCOSCSettingsRequestBuilder; + +struct RpcMessageHeader; +struct RpcMessageHeaderBuilder; + +struct HeartbeatRequest; +struct HeartbeatRequestBuilder; + +struct HeartbeatResponse; +struct HeartbeatResponseBuilder; + +struct SettingsResetRequest; +struct SettingsResetRequestBuilder; -struct TopicHandleRequest; -struct TopicHandleRequestBuilder; +struct OpenUriRequest; +struct OpenUriRequestBuilder; + +struct OpenUriResponse; +struct OpenUriResponseBuilder; + +struct InstalledInfoRequest; +struct InstalledInfoRequestBuilder; -struct SubscriptionRequest; -struct SubscriptionRequestBuilder; +struct InstalledInfoResponse; +struct InstalledInfoResponseBuilder; -struct PubSubHeader; -struct PubSubHeaderBuilder; +struct ServerInfosRequest; +struct ServerInfosRequestBuilder; -struct Message; -struct MessageBuilder; +struct ServerInfosResponse; +struct ServerInfosResponseBuilder; -struct KeyValues; -struct KeyValuesBuilder; +struct SaveFileNotification; +struct SaveFileNotificationBuilder; -} // namespace pub_sub +} // namespace rpc struct MessageBundle; struct MessageBundleBuilder; @@ -596,40 +554,6 @@ inline const char *EnumNameFirmwareErrorCode(FirmwareErrorCode e) { return EnumNamesFirmwareErrorCode()[index]; } -/// Used for filtering tracker rotations in software -enum class FilteringType : uint8_t { - NONE = 0, - SMOOTHING = 1, - PREDICTION = 2, - MIN = NONE, - MAX = PREDICTION -}; - -inline const FilteringType (&EnumValuesFilteringType())[3] { - static const FilteringType values[] = { - FilteringType::NONE, - FilteringType::SMOOTHING, - FilteringType::PREDICTION - }; - return values; -} - -inline const char * const *EnumNamesFilteringType() { - static const char * const names[4] = { - "NONE", - "SMOOTHING", - "PREDICTION", - nullptr - }; - return names; -} - -inline const char *EnumNameFilteringType(FilteringType e) { - if (flatbuffers::IsOutRange(e, FilteringType::NONE, FilteringType::PREDICTION)) return ""; - const size_t index = static_cast(e); - return EnumNamesFilteringType()[index]; -} - /// Possible tracker roles /// They're not perfect match for SteamVR tracker roles, /// because we support more possible roles. Host can @@ -992,7 +916,7 @@ inline const char *EnumNameMagnetometerStatus(MagnetometerStatus e) { namespace hardware_info { enum class McuType : uint16_t { - Other = 0, + UNKNOWN = 0, ESP8266 = 1, ESP32 = 2, OWOTRACK_ANDROID = 3, @@ -1004,13 +928,13 @@ enum class McuType : uint16_t { NRF52 = 9, NRF54L = 10, DEV_RESERVED = 250, - MIN = Other, + MIN = UNKNOWN, MAX = DEV_RESERVED }; inline const McuType (&EnumValuesMcuType())[12] { static const McuType values[] = { - McuType::Other, + McuType::UNKNOWN, McuType::ESP8266, McuType::ESP32, McuType::OWOTRACK_ANDROID, @@ -1028,7 +952,7 @@ inline const McuType (&EnumValuesMcuType())[12] { inline const char *EnumNameMcuType(McuType e) { switch (e) { - case McuType::Other: return "Other"; + case McuType::UNKNOWN: return "UNKNOWN"; case McuType::ESP8266: return "ESP8266"; case McuType::ESP32: return "ESP32"; case McuType::OWOTRACK_ANDROID: return "OWOTRACK_ANDROID"; @@ -1045,7 +969,7 @@ inline const char *EnumNameMcuType(McuType e) { } enum class ImuType : uint16_t { - Other = 0, + UNKNOWN = 0, MPU9250 = 1, MPU6500 = 2, BNO080 = 3, @@ -1066,13 +990,13 @@ enum class ImuType : uint16_t { ADC_RESISTANCE = 18, ICM55686 = 19, DEV_RESERVED = 250, - MIN = Other, + MIN = UNKNOWN, MAX = DEV_RESERVED }; inline const ImuType (&EnumValuesImuType())[21] { static const ImuType values[] = { - ImuType::Other, + ImuType::UNKNOWN, ImuType::MPU9250, ImuType::MPU6500, ImuType::BNO080, @@ -1099,7 +1023,7 @@ inline const ImuType (&EnumValuesImuType())[21] { inline const char *EnumNameImuType(ImuType e) { switch (e) { - case ImuType::Other: return "Other"; + case ImuType::UNKNOWN: return "UNKNOWN"; case ImuType::MPU9250: return "MPU9250"; case ImuType::MPU6500: return "MPU6500"; case ImuType::BNO080: return "BNO080"; @@ -1225,7 +1149,7 @@ inline const char *EnumNameBoardType(BoardType e) { } } -/// What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. +/// What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. enum class TrackerDataType : uint8_t { /// Rotation (e.g: IMUs or computed rotations in firmware) ROTATION = 0, @@ -1333,1917 +1257,1973 @@ bool VerifyDataFeedMessageVector(flatbuffers::Verifier &verifier, const flatbuff namespace rpc { -enum class RpcMessage : uint8_t { +enum class AutoBoneProcessType : uint8_t { NONE = 0, - HeartbeatRequest = 1, - HeartbeatResponse = 2, - ResetRequest = 3, - ResetResponse = 4, - AssignTrackerRequest = 5, - SettingsRequest = 6, - SettingsResponse = 7, - ChangeSettingsRequest = 8, - ClearDriftCompensationRequest = 9, - RecordBVHRequest = 10, - RecordBVHStatus = 11, - SkeletonConfigRequest = 12, - ChangeSkeletonConfigRequest = 13, - SkeletonResetAllRequest = 14, - SkeletonConfigResponse = 15, - OpenSerialRequest = 16, - CloseSerialRequest = 17, - SetWifiRequest = 18, - SerialUpdateResponse = 19, - AutoBoneProcessRequest = 20, - AutoBoneProcessStatusResponse = 21, - AutoBoneEpochResponse = 22, - OverlayDisplayModeRequest = 23, - OverlayDisplayModeChangeRequest = 24, - OverlayDisplayModeResponse = 25, - SerialTrackerRebootRequest = 26, - SerialTrackerGetInfoRequest = 27, - SerialTrackerFactoryResetRequest = 28, - SerialDevicesRequest = 29, - SerialDevicesResponse = 30, - NewSerialDeviceResponse = 31, - StartWifiProvisioningRequest = 32, - StopWifiProvisioningRequest = 33, - WifiProvisioningStatusResponse = 34, - ServerInfosRequest = 35, - ServerInfosResponse = 36, - LegTweaksTmpChange = 37, - LegTweaksTmpClear = 38, - TapDetectionSetupNotification = 39, - SetPauseTrackingRequest = 40, - StatusSystemRequest = 41, - StatusSystemResponse = 42, - StatusSystemUpdate = 43, - StatusSystemFixed = 44, - ClearMountingResetRequest = 45, - HeightRequest = 46, - HeightResponse = 47, - AutoBoneApplyRequest = 48, - AutoBoneStopRecordingRequest = 49, - AutoBoneCancelRecordingRequest = 50, - SaveFileNotification = 51, - TrackingPauseStateRequest = 52, - TrackingPauseStateResponse = 53, - SerialTrackerGetWifiScanRequest = 54, - UnknownDeviceHandshakeNotification = 55, - AddUnknownDeviceRequest = 56, - ForgetDeviceRequest = 57, - FirmwareUpdateRequest = 58, - FirmwareUpdateStatusResponse = 59, - FirmwareUpdateStopQueuesRequest = 60, - SettingsResetRequest = 61, - MagToggleRequest = 62, - MagToggleResponse = 63, - ChangeMagToggleRequest = 64, - RecordBVHStatusRequest = 65, - VRCConfigStateRequest = 66, - VRCConfigStateChangeResponse = 67, - EnableStayAlignedRequest = 68, - DetectStayAlignedRelaxedPoseRequest = 69, - ResetStayAlignedRelaxedPoseRequest = 70, - SerialTrackerCustomCommandRequest = 71, - VRCConfigSettingToggleMute = 72, - TrackingChecklistRequest = 73, - TrackingChecklistResponse = 74, - IgnoreTrackingChecklistStepRequest = 75, - StartUserHeightCalibration = 76, - CancelUserHeightCalibration = 77, - UserHeightRecordingStatusResponse = 78, - KeybindRequest = 79, - ChangeKeybindRequest = 80, - KeybindResponse = 81, - InstalledInfoRequest = 82, - InstalledInfoResponse = 83, - OpenUriRequest = 84, - OpenUriResponse = 85, - EnableSteamVRDriverRequest = 86, + RECORD = 1, + SAVE = 2, + PROCESS = 3, MIN = NONE, - MAX = EnableSteamVRDriverRequest + MAX = PROCESS }; -inline const RpcMessage (&EnumValuesRpcMessage())[87] { - static const RpcMessage values[] = { - RpcMessage::NONE, - RpcMessage::HeartbeatRequest, - RpcMessage::HeartbeatResponse, - RpcMessage::ResetRequest, - RpcMessage::ResetResponse, - RpcMessage::AssignTrackerRequest, - RpcMessage::SettingsRequest, - RpcMessage::SettingsResponse, - RpcMessage::ChangeSettingsRequest, - RpcMessage::ClearDriftCompensationRequest, - RpcMessage::RecordBVHRequest, - RpcMessage::RecordBVHStatus, - RpcMessage::SkeletonConfigRequest, - RpcMessage::ChangeSkeletonConfigRequest, - RpcMessage::SkeletonResetAllRequest, - RpcMessage::SkeletonConfigResponse, - RpcMessage::OpenSerialRequest, - RpcMessage::CloseSerialRequest, - RpcMessage::SetWifiRequest, - RpcMessage::SerialUpdateResponse, - RpcMessage::AutoBoneProcessRequest, - RpcMessage::AutoBoneProcessStatusResponse, - RpcMessage::AutoBoneEpochResponse, - RpcMessage::OverlayDisplayModeRequest, - RpcMessage::OverlayDisplayModeChangeRequest, - RpcMessage::OverlayDisplayModeResponse, - RpcMessage::SerialTrackerRebootRequest, - RpcMessage::SerialTrackerGetInfoRequest, - RpcMessage::SerialTrackerFactoryResetRequest, - RpcMessage::SerialDevicesRequest, - RpcMessage::SerialDevicesResponse, - RpcMessage::NewSerialDeviceResponse, - RpcMessage::StartWifiProvisioningRequest, - RpcMessage::StopWifiProvisioningRequest, - RpcMessage::WifiProvisioningStatusResponse, - RpcMessage::ServerInfosRequest, - RpcMessage::ServerInfosResponse, - RpcMessage::LegTweaksTmpChange, - RpcMessage::LegTweaksTmpClear, - RpcMessage::TapDetectionSetupNotification, - RpcMessage::SetPauseTrackingRequest, - RpcMessage::StatusSystemRequest, - RpcMessage::StatusSystemResponse, - RpcMessage::StatusSystemUpdate, - RpcMessage::StatusSystemFixed, - RpcMessage::ClearMountingResetRequest, - RpcMessage::HeightRequest, - RpcMessage::HeightResponse, - RpcMessage::AutoBoneApplyRequest, - RpcMessage::AutoBoneStopRecordingRequest, - RpcMessage::AutoBoneCancelRecordingRequest, - RpcMessage::SaveFileNotification, - RpcMessage::TrackingPauseStateRequest, - RpcMessage::TrackingPauseStateResponse, - RpcMessage::SerialTrackerGetWifiScanRequest, - RpcMessage::UnknownDeviceHandshakeNotification, - RpcMessage::AddUnknownDeviceRequest, - RpcMessage::ForgetDeviceRequest, - RpcMessage::FirmwareUpdateRequest, - RpcMessage::FirmwareUpdateStatusResponse, - RpcMessage::FirmwareUpdateStopQueuesRequest, - RpcMessage::SettingsResetRequest, - RpcMessage::MagToggleRequest, - RpcMessage::MagToggleResponse, - RpcMessage::ChangeMagToggleRequest, - RpcMessage::RecordBVHStatusRequest, - RpcMessage::VRCConfigStateRequest, - RpcMessage::VRCConfigStateChangeResponse, - RpcMessage::EnableStayAlignedRequest, - RpcMessage::DetectStayAlignedRelaxedPoseRequest, - RpcMessage::ResetStayAlignedRelaxedPoseRequest, - RpcMessage::SerialTrackerCustomCommandRequest, - RpcMessage::VRCConfigSettingToggleMute, - RpcMessage::TrackingChecklistRequest, - RpcMessage::TrackingChecklistResponse, - RpcMessage::IgnoreTrackingChecklistStepRequest, - RpcMessage::StartUserHeightCalibration, - RpcMessage::CancelUserHeightCalibration, - RpcMessage::UserHeightRecordingStatusResponse, - RpcMessage::KeybindRequest, - RpcMessage::ChangeKeybindRequest, - RpcMessage::KeybindResponse, - RpcMessage::InstalledInfoRequest, - RpcMessage::InstalledInfoResponse, - RpcMessage::OpenUriRequest, - RpcMessage::OpenUriResponse, - RpcMessage::EnableSteamVRDriverRequest +inline const AutoBoneProcessType (&EnumValuesAutoBoneProcessType())[4] { + static const AutoBoneProcessType values[] = { + AutoBoneProcessType::NONE, + AutoBoneProcessType::RECORD, + AutoBoneProcessType::SAVE, + AutoBoneProcessType::PROCESS }; return values; } -inline const char * const *EnumNamesRpcMessage() { - static const char * const names[88] = { +inline const char * const *EnumNamesAutoBoneProcessType() { + static const char * const names[5] = { "NONE", - "HeartbeatRequest", - "HeartbeatResponse", - "ResetRequest", - "ResetResponse", - "AssignTrackerRequest", - "SettingsRequest", - "SettingsResponse", - "ChangeSettingsRequest", - "ClearDriftCompensationRequest", - "RecordBVHRequest", - "RecordBVHStatus", - "SkeletonConfigRequest", - "ChangeSkeletonConfigRequest", - "SkeletonResetAllRequest", - "SkeletonConfigResponse", - "OpenSerialRequest", - "CloseSerialRequest", - "SetWifiRequest", - "SerialUpdateResponse", - "AutoBoneProcessRequest", - "AutoBoneProcessStatusResponse", - "AutoBoneEpochResponse", - "OverlayDisplayModeRequest", - "OverlayDisplayModeChangeRequest", - "OverlayDisplayModeResponse", - "SerialTrackerRebootRequest", - "SerialTrackerGetInfoRequest", - "SerialTrackerFactoryResetRequest", - "SerialDevicesRequest", - "SerialDevicesResponse", - "NewSerialDeviceResponse", - "StartWifiProvisioningRequest", - "StopWifiProvisioningRequest", - "WifiProvisioningStatusResponse", - "ServerInfosRequest", - "ServerInfosResponse", - "LegTweaksTmpChange", - "LegTweaksTmpClear", - "TapDetectionSetupNotification", - "SetPauseTrackingRequest", - "StatusSystemRequest", - "StatusSystemResponse", - "StatusSystemUpdate", - "StatusSystemFixed", - "ClearMountingResetRequest", - "HeightRequest", - "HeightResponse", - "AutoBoneApplyRequest", - "AutoBoneStopRecordingRequest", - "AutoBoneCancelRecordingRequest", - "SaveFileNotification", - "TrackingPauseStateRequest", - "TrackingPauseStateResponse", - "SerialTrackerGetWifiScanRequest", - "UnknownDeviceHandshakeNotification", - "AddUnknownDeviceRequest", - "ForgetDeviceRequest", - "FirmwareUpdateRequest", - "FirmwareUpdateStatusResponse", - "FirmwareUpdateStopQueuesRequest", - "SettingsResetRequest", - "MagToggleRequest", - "MagToggleResponse", - "ChangeMagToggleRequest", - "RecordBVHStatusRequest", - "VRCConfigStateRequest", - "VRCConfigStateChangeResponse", - "EnableStayAlignedRequest", - "DetectStayAlignedRelaxedPoseRequest", - "ResetStayAlignedRelaxedPoseRequest", - "SerialTrackerCustomCommandRequest", - "VRCConfigSettingToggleMute", - "TrackingChecklistRequest", - "TrackingChecklistResponse", - "IgnoreTrackingChecklistStepRequest", - "StartUserHeightCalibration", - "CancelUserHeightCalibration", - "UserHeightRecordingStatusResponse", - "KeybindRequest", - "ChangeKeybindRequest", - "KeybindResponse", - "InstalledInfoRequest", - "InstalledInfoResponse", - "OpenUriRequest", - "OpenUriResponse", - "EnableSteamVRDriverRequest", + "RECORD", + "SAVE", + "PROCESS", nullptr }; return names; } -inline const char *EnumNameRpcMessage(RpcMessage e) { - if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::EnableSteamVRDriverRequest)) return ""; +inline const char *EnumNameAutoBoneProcessType(AutoBoneProcessType e) { + if (flatbuffers::IsOutRange(e, AutoBoneProcessType::NONE, AutoBoneProcessType::PROCESS)) return ""; const size_t index = static_cast(e); - return EnumNamesRpcMessage()[index]; + return EnumNamesAutoBoneProcessType()[index]; } -template struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::NONE; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::HeartbeatRequest; +enum class FirmwareUpdateStatus : uint8_t { + /// The server is downloading the firmware + DOWNLOADING = 0, + /// The server is waiting for the tracker to be rebooted by the user + /// Note that is is not the same as REBOOTING + NEED_MANUAL_REBOOT = 1, + /// The server tries to authenticate with the MCU + AUTHENTICATING = 2, + /// The server is uploading the firmware to the Device + UPLOADING = 3, + /// The serial flasher tries to sync with the MCU + /// You can use this event to prompt the user to press the boot btn + SYNCING_WITH_MCU = 4, + /// The MCU is rebooting + REBOOTING = 5, + /// The server is provisioning the tracker + PROVISIONING = 6, + /// The update process completed with success + DONE = 7, + /// Could not find the device + ERROR_DEVICE_NOT_FOUND = 8, + /// The operation timed out, > 1min + ERROR_TIMEOUT = 9, + /// The firmware download failed + ERROR_DOWNLOAD_FAILED = 10, + /// The server could not authenticate with the MCU + ERROR_AUTHENTICATION_FAILED = 11, + /// Could not upload the firmware to the MCU + ERROR_UPLOAD_FAILED = 12, + /// The provision of the tracker failed, usually wifi credentials + ERROR_PROVISIONING_FAILED = 13, + /// An unsupported Flashing method was used + ERROR_UNSUPPORTED_METHOD = 14, + ERROR_UNKNOWN = 15, + MIN = DOWNLOADING, + MAX = ERROR_UNKNOWN }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::HeartbeatResponse; -}; +inline const FirmwareUpdateStatus (&EnumValuesFirmwareUpdateStatus())[16] { + static const FirmwareUpdateStatus values[] = { + FirmwareUpdateStatus::DOWNLOADING, + FirmwareUpdateStatus::NEED_MANUAL_REBOOT, + FirmwareUpdateStatus::AUTHENTICATING, + FirmwareUpdateStatus::UPLOADING, + FirmwareUpdateStatus::SYNCING_WITH_MCU, + FirmwareUpdateStatus::REBOOTING, + FirmwareUpdateStatus::PROVISIONING, + FirmwareUpdateStatus::DONE, + FirmwareUpdateStatus::ERROR_DEVICE_NOT_FOUND, + FirmwareUpdateStatus::ERROR_TIMEOUT, + FirmwareUpdateStatus::ERROR_DOWNLOAD_FAILED, + FirmwareUpdateStatus::ERROR_AUTHENTICATION_FAILED, + FirmwareUpdateStatus::ERROR_UPLOAD_FAILED, + FirmwareUpdateStatus::ERROR_PROVISIONING_FAILED, + FirmwareUpdateStatus::ERROR_UNSUPPORTED_METHOD, + FirmwareUpdateStatus::ERROR_UNKNOWN + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ResetRequest; -}; +inline const char * const *EnumNamesFirmwareUpdateStatus() { + static const char * const names[17] = { + "DOWNLOADING", + "NEED_MANUAL_REBOOT", + "AUTHENTICATING", + "UPLOADING", + "SYNCING_WITH_MCU", + "REBOOTING", + "PROVISIONING", + "DONE", + "ERROR_DEVICE_NOT_FOUND", + "ERROR_TIMEOUT", + "ERROR_DOWNLOAD_FAILED", + "ERROR_AUTHENTICATION_FAILED", + "ERROR_UPLOAD_FAILED", + "ERROR_PROVISIONING_FAILED", + "ERROR_UNSUPPORTED_METHOD", + "ERROR_UNKNOWN", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ResetResponse; -}; +inline const char *EnumNameFirmwareUpdateStatus(FirmwareUpdateStatus e) { + if (flatbuffers::IsOutRange(e, FirmwareUpdateStatus::DOWNLOADING, FirmwareUpdateStatus::ERROR_UNKNOWN)) return ""; + const size_t index = static_cast(e); + return EnumNamesFirmwareUpdateStatus()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AssignTrackerRequest; +enum class FirmwareUpdateDeviceId : uint8_t { + NONE = 0, + FirmwareDeviceIdTable = 1, + SerialDevicePort = 2, + MIN = NONE, + MAX = SerialDevicePort }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SettingsRequest; -}; +inline const FirmwareUpdateDeviceId (&EnumValuesFirmwareUpdateDeviceId())[3] { + static const FirmwareUpdateDeviceId values[] = { + FirmwareUpdateDeviceId::NONE, + FirmwareUpdateDeviceId::FirmwareDeviceIdTable, + FirmwareUpdateDeviceId::SerialDevicePort + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SettingsResponse; -}; +inline const char * const *EnumNamesFirmwareUpdateDeviceId() { + static const char * const names[4] = { + "NONE", + "FirmwareDeviceIdTable", + "SerialDevicePort", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ChangeSettingsRequest; -}; +inline const char *EnumNameFirmwareUpdateDeviceId(FirmwareUpdateDeviceId e) { + if (flatbuffers::IsOutRange(e, FirmwareUpdateDeviceId::NONE, FirmwareUpdateDeviceId::SerialDevicePort)) return ""; + const size_t index = static_cast(e); + return EnumNamesFirmwareUpdateDeviceId()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ClearDriftCompensationRequest; +template struct FirmwareUpdateDeviceIdTraits { + static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::NONE; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::RecordBVHRequest; +template<> struct FirmwareUpdateDeviceIdTraits { + static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::FirmwareDeviceIdTable; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::RecordBVHStatus; +template<> struct FirmwareUpdateDeviceIdTraits { + static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::SerialDevicePort; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SkeletonConfigRequest; -}; +bool VerifyFirmwareUpdateDeviceId(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateDeviceId type); +bool VerifyFirmwareUpdateDeviceIdVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ChangeSkeletonConfigRequest; +enum class FirmwareUpdateMethod : uint8_t { + NONE = 0, + OTAFirmwareUpdate = 1, + SerialFirmwareUpdate = 2, + MIN = NONE, + MAX = SerialFirmwareUpdate }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SkeletonResetAllRequest; -}; +inline const FirmwareUpdateMethod (&EnumValuesFirmwareUpdateMethod())[3] { + static const FirmwareUpdateMethod values[] = { + FirmwareUpdateMethod::NONE, + FirmwareUpdateMethod::OTAFirmwareUpdate, + FirmwareUpdateMethod::SerialFirmwareUpdate + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SkeletonConfigResponse; -}; +inline const char * const *EnumNamesFirmwareUpdateMethod() { + static const char * const names[4] = { + "NONE", + "OTAFirmwareUpdate", + "SerialFirmwareUpdate", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OpenSerialRequest; -}; +inline const char *EnumNameFirmwareUpdateMethod(FirmwareUpdateMethod e) { + if (flatbuffers::IsOutRange(e, FirmwareUpdateMethod::NONE, FirmwareUpdateMethod::SerialFirmwareUpdate)) return ""; + const size_t index = static_cast(e); + return EnumNamesFirmwareUpdateMethod()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::CloseSerialRequest; +template struct FirmwareUpdateMethodTraits { + static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::NONE; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SetWifiRequest; +template<> struct FirmwareUpdateMethodTraits { + static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::OTAFirmwareUpdate; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialUpdateResponse; +template<> struct FirmwareUpdateMethodTraits { + static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::SerialFirmwareUpdate; }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneProcessRequest; -}; +bool VerifyFirmwareUpdateMethod(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateMethod type); +bool VerifyFirmwareUpdateMethodVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneProcessStatusResponse; +enum class UserHeightCalibrationStatus : uint8_t { + NONE = 0, + RECORDING_FLOOR = 1, + WAITING_FOR_CONTROLLER_PITCH = 2, + WAITING_FOR_RISE = 3, + WAITING_FOR_FW_LOOK = 4, + RECORDING_HEIGHT = 5, + DONE = 6, + ERROR_TOO_HIGH = 7, + ERROR_TOO_SMALL = 8, + ERROR_TIMEOUT = 9, + MIN = NONE, + MAX = ERROR_TIMEOUT }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneEpochResponse; -}; +inline const UserHeightCalibrationStatus (&EnumValuesUserHeightCalibrationStatus())[10] { + static const UserHeightCalibrationStatus values[] = { + UserHeightCalibrationStatus::NONE, + UserHeightCalibrationStatus::RECORDING_FLOOR, + UserHeightCalibrationStatus::WAITING_FOR_CONTROLLER_PITCH, + UserHeightCalibrationStatus::WAITING_FOR_RISE, + UserHeightCalibrationStatus::WAITING_FOR_FW_LOOK, + UserHeightCalibrationStatus::RECORDING_HEIGHT, + UserHeightCalibrationStatus::DONE, + UserHeightCalibrationStatus::ERROR_TOO_HIGH, + UserHeightCalibrationStatus::ERROR_TOO_SMALL, + UserHeightCalibrationStatus::ERROR_TIMEOUT + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeRequest; -}; +inline const char * const *EnumNamesUserHeightCalibrationStatus() { + static const char * const names[11] = { + "NONE", + "RECORDING_FLOOR", + "WAITING_FOR_CONTROLLER_PITCH", + "WAITING_FOR_RISE", + "WAITING_FOR_FW_LOOK", + "RECORDING_HEIGHT", + "DONE", + "ERROR_TOO_HIGH", + "ERROR_TOO_SMALL", + "ERROR_TIMEOUT", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeChangeRequest; -}; +inline const char *EnumNameUserHeightCalibrationStatus(UserHeightCalibrationStatus e) { + if (flatbuffers::IsOutRange(e, UserHeightCalibrationStatus::NONE, UserHeightCalibrationStatus::ERROR_TIMEOUT)) return ""; + const size_t index = static_cast(e); + return EnumNamesUserHeightCalibrationStatus()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeResponse; +enum class KeybindId : uint8_t { + FULL_RESET = 0, + YAW_RESET = 1, + MOUNTING_RESET = 2, + PAUSE_TRACKING = 3, + FEET_MOUNTING_RESET = 4, + MIN = FULL_RESET, + MAX = FEET_MOUNTING_RESET }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialTrackerRebootRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialTrackerGetInfoRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialTrackerFactoryResetRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialDevicesRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialDevicesResponse; -}; +inline const KeybindId (&EnumValuesKeybindId())[5] { + static const KeybindId values[] = { + KeybindId::FULL_RESET, + KeybindId::YAW_RESET, + KeybindId::MOUNTING_RESET, + KeybindId::PAUSE_TRACKING, + KeybindId::FEET_MOUNTING_RESET + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::NewSerialDeviceResponse; -}; +inline const char * const *EnumNamesKeybindId() { + static const char * const names[6] = { + "FULL_RESET", + "YAW_RESET", + "MOUNTING_RESET", + "PAUSE_TRACKING", + "FEET_MOUNTING_RESET", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StartWifiProvisioningRequest; -}; +inline const char *EnumNameKeybindId(KeybindId e) { + if (flatbuffers::IsOutRange(e, KeybindId::FULL_RESET, KeybindId::FEET_MOUNTING_RESET)) return ""; + const size_t index = static_cast(e); + return EnumNamesKeybindId()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StopWifiProvisioningRequest; +enum class WifiProvisioningStatus : uint8_t { + NONE = 0, + SERIAL_INIT = 1, + PROVISIONING = 2, + CONNECTING = 3, + CONNECTION_ERROR = 4, + LOOKING_FOR_SERVER = 5, + COULD_NOT_FIND_SERVER = 6, + DONE = 7, + OBTAINING_MAC_ADDRESS = 8, + NO_SERIAL_LOGS_ERROR = 9, + NO_SERIAL_DEVICE_FOUND = 10, + MIN = NONE, + MAX = NO_SERIAL_DEVICE_FOUND }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::WifiProvisioningStatusResponse; -}; +inline const WifiProvisioningStatus (&EnumValuesWifiProvisioningStatus())[11] { + static const WifiProvisioningStatus values[] = { + WifiProvisioningStatus::NONE, + WifiProvisioningStatus::SERIAL_INIT, + WifiProvisioningStatus::PROVISIONING, + WifiProvisioningStatus::CONNECTING, + WifiProvisioningStatus::CONNECTION_ERROR, + WifiProvisioningStatus::LOOKING_FOR_SERVER, + WifiProvisioningStatus::COULD_NOT_FIND_SERVER, + WifiProvisioningStatus::DONE, + WifiProvisioningStatus::OBTAINING_MAC_ADDRESS, + WifiProvisioningStatus::NO_SERIAL_LOGS_ERROR, + WifiProvisioningStatus::NO_SERIAL_DEVICE_FOUND + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ServerInfosRequest; -}; +inline const char * const *EnumNamesWifiProvisioningStatus() { + static const char * const names[12] = { + "NONE", + "SERIAL_INIT", + "PROVISIONING", + "CONNECTING", + "CONNECTION_ERROR", + "LOOKING_FOR_SERVER", + "COULD_NOT_FIND_SERVER", + "DONE", + "OBTAINING_MAC_ADDRESS", + "NO_SERIAL_LOGS_ERROR", + "NO_SERIAL_DEVICE_FOUND", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ServerInfosResponse; -}; +inline const char *EnumNameWifiProvisioningStatus(WifiProvisioningStatus e) { + if (flatbuffers::IsOutRange(e, WifiProvisioningStatus::NONE, WifiProvisioningStatus::NO_SERIAL_DEVICE_FOUND)) return ""; + const size_t index = static_cast(e); + return EnumNamesWifiProvisioningStatus()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::LegTweaksTmpChange; +enum class ResetType : uint8_t { + /// Resets the yaw (horizontal) axis + YAW = 0, + /// Resets all axes + FULL = 1, + /// Second pose for calibrating mounting rotation + MOUNTING = 2, + MIN = YAW, + MAX = MOUNTING }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::LegTweaksTmpClear; -}; +inline const ResetType (&EnumValuesResetType())[3] { + static const ResetType values[] = { + ResetType::YAW, + ResetType::FULL, + ResetType::MOUNTING + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::TapDetectionSetupNotification; -}; +inline const char * const *EnumNamesResetType() { + static const char * const names[4] = { + "YAW", + "FULL", + "MOUNTING", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SetPauseTrackingRequest; -}; +inline const char *EnumNameResetType(ResetType e) { + if (flatbuffers::IsOutRange(e, ResetType::YAW, ResetType::MOUNTING)) return ""; + const size_t index = static_cast(e); + return EnumNamesResetType()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StatusSystemRequest; +enum class ResetStatus : uint8_t { + STARTED = 0, + FINISHED = 1, + MIN = STARTED, + MAX = FINISHED }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StatusSystemResponse; -}; +inline const ResetStatus (&EnumValuesResetStatus())[2] { + static const ResetStatus values[] = { + ResetStatus::STARTED, + ResetStatus::FINISHED + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StatusSystemUpdate; -}; +inline const char * const *EnumNamesResetStatus() { + static const char * const names[3] = { + "STARTED", + "FINISHED", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StatusSystemFixed; -}; +inline const char *EnumNameResetStatus(ResetStatus e) { + if (flatbuffers::IsOutRange(e, ResetStatus::STARTED, ResetStatus::FINISHED)) return ""; + const size_t index = static_cast(e); + return EnumNamesResetStatus()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ClearMountingResetRequest; +enum class ArmsResetMode : uint8_t { + /// Down to the sides for full. Upper arm going back and forearm going forward for mounting. + BACK = 0, + /// Down to the sides for full. Arms going forward for mounting. + FORWARD = 1, + /// Down to the sides for full. T-pose for mounting. + T_POSE_UP = 2, + /// T-pose for full. Down to the sides for mounting. + T_POSE_DOWN = 3, + MIN = BACK, + MAX = T_POSE_DOWN }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::HeightRequest; -}; +inline const ArmsResetMode (&EnumValuesArmsResetMode())[4] { + static const ArmsResetMode values[] = { + ArmsResetMode::BACK, + ArmsResetMode::FORWARD, + ArmsResetMode::T_POSE_UP, + ArmsResetMode::T_POSE_DOWN + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::HeightResponse; -}; +inline const char * const *EnumNamesArmsResetMode() { + static const char * const names[5] = { + "BACK", + "FORWARD", + "T_POSE_UP", + "T_POSE_DOWN", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneApplyRequest; -}; +inline const char *EnumNameArmsResetMode(ArmsResetMode e) { + if (flatbuffers::IsOutRange(e, ArmsResetMode::BACK, ArmsResetMode::T_POSE_DOWN)) return ""; + const size_t index = static_cast(e); + return EnumNamesArmsResetMode()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneStopRecordingRequest; +enum class SerialDeviceType : uint8_t { + ESP_TRACKER = 0, + HID_RECEIVER = 1, + HID_TRACKER = 2, + MIN = ESP_TRACKER, + MAX = HID_TRACKER }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AutoBoneCancelRecordingRequest; -}; +inline const SerialDeviceType (&EnumValuesSerialDeviceType())[3] { + static const SerialDeviceType values[] = { + SerialDeviceType::ESP_TRACKER, + SerialDeviceType::HID_RECEIVER, + SerialDeviceType::HID_TRACKER + }; + return values; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SaveFileNotification; -}; +inline const char * const *EnumNamesSerialDeviceType() { + static const char * const names[4] = { + "ESP_TRACKER", + "HID_RECEIVER", + "HID_TRACKER", + nullptr + }; + return names; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::TrackingPauseStateRequest; -}; +inline const char *EnumNameSerialDeviceType(SerialDeviceType e) { + if (flatbuffers::IsOutRange(e, SerialDeviceType::ESP_TRACKER, SerialDeviceType::HID_TRACKER)) return ""; + const size_t index = static_cast(e); + return EnumNamesSerialDeviceType()[index]; +} -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::TrackingPauseStateResponse; +enum class SkeletonBone : uint8_t { + NONE = 0, + HEAD = 1, + NECK = 2, + CHEST = 3, + CHEST_OFFSET = 4, + WAIST = 5, + HIP = 6, + HIP_OFFSET = 7, + HIPS_WIDTH = 8, + UPPER_LEG = 9, + LOWER_LEG = 10, + FOOT_LENGTH = 11, + FOOT_SHIFT = 12, + SKELETON_OFFSET = 13, + SHOULDERS_DISTANCE = 14, + SHOULDERS_WIDTH = 15, + UPPER_ARM = 16, + LOWER_ARM = 17, + HAND_Y = 18, + HAND_Z = 19, + ELBOW_OFFSET = 20, + UPPER_CHEST = 21, + MIN = NONE, + MAX = UPPER_CHEST }; -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialTrackerGetWifiScanRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::UnknownDeviceHandshakeNotification; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::AddUnknownDeviceRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ForgetDeviceRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::FirmwareUpdateRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::FirmwareUpdateStatusResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::FirmwareUpdateStopQueuesRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SettingsResetRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::MagToggleRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::MagToggleResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ChangeMagToggleRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::RecordBVHStatusRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::VRCConfigStateRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::VRCConfigStateChangeResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::EnableStayAlignedRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::DetectStayAlignedRelaxedPoseRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ResetStayAlignedRelaxedPoseRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::SerialTrackerCustomCommandRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::VRCConfigSettingToggleMute; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::TrackingChecklistRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::TrackingChecklistResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::IgnoreTrackingChecklistStepRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::StartUserHeightCalibration; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::CancelUserHeightCalibration; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::UserHeightRecordingStatusResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::KeybindRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::ChangeKeybindRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::KeybindResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::InstalledInfoRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::InstalledInfoResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OpenUriRequest; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::OpenUriResponse; -}; - -template<> struct RpcMessageTraits { - static const RpcMessage enum_value = RpcMessage::EnableSteamVRDriverRequest; -}; - -bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); -bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); - -enum class KeybindId : uint8_t { - FULL_RESET = 0, - YAW_RESET = 1, - MOUNTING_RESET = 2, - PAUSE_TRACKING = 3, - FEET_MOUNTING_RESET = 4, - MIN = FULL_RESET, - MAX = FEET_MOUNTING_RESET -}; - -inline const KeybindId (&EnumValuesKeybindId())[5] { - static const KeybindId values[] = { - KeybindId::FULL_RESET, - KeybindId::YAW_RESET, - KeybindId::MOUNTING_RESET, - KeybindId::PAUSE_TRACKING, - KeybindId::FEET_MOUNTING_RESET +inline const SkeletonBone (&EnumValuesSkeletonBone())[22] { + static const SkeletonBone values[] = { + SkeletonBone::NONE, + SkeletonBone::HEAD, + SkeletonBone::NECK, + SkeletonBone::CHEST, + SkeletonBone::CHEST_OFFSET, + SkeletonBone::WAIST, + SkeletonBone::HIP, + SkeletonBone::HIP_OFFSET, + SkeletonBone::HIPS_WIDTH, + SkeletonBone::UPPER_LEG, + SkeletonBone::LOWER_LEG, + SkeletonBone::FOOT_LENGTH, + SkeletonBone::FOOT_SHIFT, + SkeletonBone::SKELETON_OFFSET, + SkeletonBone::SHOULDERS_DISTANCE, + SkeletonBone::SHOULDERS_WIDTH, + SkeletonBone::UPPER_ARM, + SkeletonBone::LOWER_ARM, + SkeletonBone::HAND_Y, + SkeletonBone::HAND_Z, + SkeletonBone::ELBOW_OFFSET, + SkeletonBone::UPPER_CHEST }; return values; } -inline const char * const *EnumNamesKeybindId() { - static const char * const names[6] = { - "FULL_RESET", - "YAW_RESET", - "MOUNTING_RESET", - "PAUSE_TRACKING", - "FEET_MOUNTING_RESET", +inline const char * const *EnumNamesSkeletonBone() { + static const char * const names[23] = { + "NONE", + "HEAD", + "NECK", + "CHEST", + "CHEST_OFFSET", + "WAIST", + "HIP", + "HIP_OFFSET", + "HIPS_WIDTH", + "UPPER_LEG", + "LOWER_LEG", + "FOOT_LENGTH", + "FOOT_SHIFT", + "SKELETON_OFFSET", + "SHOULDERS_DISTANCE", + "SHOULDERS_WIDTH", + "UPPER_ARM", + "LOWER_ARM", + "HAND_Y", + "HAND_Z", + "ELBOW_OFFSET", + "UPPER_CHEST", nullptr }; return names; } -inline const char *EnumNameKeybindId(KeybindId e) { - if (flatbuffers::IsOutRange(e, KeybindId::FULL_RESET, KeybindId::FEET_MOUNTING_RESET)) return ""; +inline const char *EnumNameSkeletonBone(SkeletonBone e) { + if (flatbuffers::IsOutRange(e, SkeletonBone::NONE, SkeletonBone::UPPER_CHEST)) return ""; const size_t index = static_cast(e); - return EnumNamesKeybindId()[index]; + return EnumNamesSkeletonBone()[index]; } -enum class ResetType : uint8_t { - Yaw = 0, - Full = 1, - /// Second pose for calibrating mounting rotation - Mounting = 2, - MIN = Yaw, - MAX = Mounting +enum class FilteringType : uint8_t { + NONE = 0, + SMOOTHING = 1, + PREDICTION = 2, + MIN = NONE, + MAX = PREDICTION }; -inline const ResetType (&EnumValuesResetType())[3] { - static const ResetType values[] = { - ResetType::Yaw, - ResetType::Full, - ResetType::Mounting +inline const FilteringType (&EnumValuesFilteringType())[3] { + static const FilteringType values[] = { + FilteringType::NONE, + FilteringType::SMOOTHING, + FilteringType::PREDICTION }; return values; } -inline const char * const *EnumNamesResetType() { +inline const char * const *EnumNamesFilteringType() { static const char * const names[4] = { - "Yaw", - "Full", - "Mounting", + "NONE", + "SMOOTHING", + "PREDICTION", nullptr }; return names; } -inline const char *EnumNameResetType(ResetType e) { - if (flatbuffers::IsOutRange(e, ResetType::Yaw, ResetType::Mounting)) return ""; +inline const char *EnumNameFilteringType(FilteringType e) { + if (flatbuffers::IsOutRange(e, FilteringType::NONE, FilteringType::PREDICTION)) return ""; const size_t index = static_cast(e); - return EnumNamesResetType()[index]; + return EnumNamesFilteringType()[index]; } -enum class ResetStatus : uint8_t { - STARTED = 0, - FINISHED = 1, - MIN = STARTED, - MAX = FINISHED +enum class StayAlignedRelaxedPose : uint8_t { + STANDING = 0, + SITTING = 1, + FLAT = 2, + MIN = STANDING, + MAX = FLAT }; -inline const ResetStatus (&EnumValuesResetStatus())[2] { - static const ResetStatus values[] = { - ResetStatus::STARTED, - ResetStatus::FINISHED - }; - return values; -} - -inline const char * const *EnumNamesResetStatus() { - static const char * const names[3] = { - "STARTED", - "FINISHED", +inline const StayAlignedRelaxedPose (&EnumValuesStayAlignedRelaxedPose())[3] { + static const StayAlignedRelaxedPose values[] = { + StayAlignedRelaxedPose::STANDING, + StayAlignedRelaxedPose::SITTING, + StayAlignedRelaxedPose::FLAT + }; + return values; +} + +inline const char * const *EnumNamesStayAlignedRelaxedPose() { + static const char * const names[4] = { + "STANDING", + "SITTING", + "FLAT", nullptr }; return names; } -inline const char *EnumNameResetStatus(ResetStatus e) { - if (flatbuffers::IsOutRange(e, ResetStatus::STARTED, ResetStatus::FINISHED)) return ""; +inline const char *EnumNameStayAlignedRelaxedPose(StayAlignedRelaxedPose e) { + if (flatbuffers::IsOutRange(e, StayAlignedRelaxedPose::STANDING, StayAlignedRelaxedPose::FLAT)) return ""; const size_t index = static_cast(e); - return EnumNamesResetStatus()[index]; + return EnumNamesStayAlignedRelaxedPose()[index]; } -enum class ArmsMountingResetMode : uint8_t { - /// Upper arm going back and forearm going forward - BACK = 0, - /// Arms going forward - FORWARD = 1, - /// Arms going up to the sides into a tpose - TPOSE_UP = 2, - /// Arms going down to the sides from a tpose - TPOSE_DOWN = 3, - MIN = BACK, - MAX = TPOSE_DOWN +enum class TrackingChecklistStepId : uint8_t { + UNKNOWN = 0, + TRACKERS_REST_CALIBRATION = 1, + FULL_RESET = 2, + VRCHAT_SETTINGS = 3, + STEAMVR_DISCONNECTED = 4, + UNASSIGNED_HMD = 5, + TRACKER_ERROR = 6, + NETWORK_PROFILE_PUBLIC = 7, + MOUNTING_CALIBRATION = 8, + FEET_MOUNTING_CALIBRATION = 9, + STAY_ALIGNED_CONFIGURED = 10, + STEAMVR_HANDS_ENABLED = 11, + STANDABLE_INSTALLED = 12, + MIN = UNKNOWN, + MAX = STANDABLE_INSTALLED }; -inline const ArmsMountingResetMode (&EnumValuesArmsMountingResetMode())[4] { - static const ArmsMountingResetMode values[] = { - ArmsMountingResetMode::BACK, - ArmsMountingResetMode::FORWARD, - ArmsMountingResetMode::TPOSE_UP, - ArmsMountingResetMode::TPOSE_DOWN +inline const TrackingChecklistStepId (&EnumValuesTrackingChecklistStepId())[13] { + static const TrackingChecklistStepId values[] = { + TrackingChecklistStepId::UNKNOWN, + TrackingChecklistStepId::TRACKERS_REST_CALIBRATION, + TrackingChecklistStepId::FULL_RESET, + TrackingChecklistStepId::VRCHAT_SETTINGS, + TrackingChecklistStepId::STEAMVR_DISCONNECTED, + TrackingChecklistStepId::UNASSIGNED_HMD, + TrackingChecklistStepId::TRACKER_ERROR, + TrackingChecklistStepId::NETWORK_PROFILE_PUBLIC, + TrackingChecklistStepId::MOUNTING_CALIBRATION, + TrackingChecklistStepId::FEET_MOUNTING_CALIBRATION, + TrackingChecklistStepId::STAY_ALIGNED_CONFIGURED, + TrackingChecklistStepId::STEAMVR_HANDS_ENABLED, + TrackingChecklistStepId::STANDABLE_INSTALLED }; return values; } -inline const char * const *EnumNamesArmsMountingResetMode() { - static const char * const names[5] = { - "BACK", - "FORWARD", - "TPOSE_UP", - "TPOSE_DOWN", +inline const char * const *EnumNamesTrackingChecklistStepId() { + static const char * const names[14] = { + "UNKNOWN", + "TRACKERS_REST_CALIBRATION", + "FULL_RESET", + "VRCHAT_SETTINGS", + "STEAMVR_DISCONNECTED", + "UNASSIGNED_HMD", + "TRACKER_ERROR", + "NETWORK_PROFILE_PUBLIC", + "MOUNTING_CALIBRATION", + "FEET_MOUNTING_CALIBRATION", + "STAY_ALIGNED_CONFIGURED", + "STEAMVR_HANDS_ENABLED", + "STANDABLE_INSTALLED", nullptr }; return names; } -inline const char *EnumNameArmsMountingResetMode(ArmsMountingResetMode e) { - if (flatbuffers::IsOutRange(e, ArmsMountingResetMode::BACK, ArmsMountingResetMode::TPOSE_DOWN)) return ""; +inline const char *EnumNameTrackingChecklistStepId(TrackingChecklistStepId e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistStepId::UNKNOWN, TrackingChecklistStepId::STANDABLE_INSTALLED)) return ""; const size_t index = static_cast(e); - return EnumNamesArmsMountingResetMode()[index]; + return EnumNamesTrackingChecklistStepId()[index]; } -enum class SkeletonBone : uint8_t { - NONE = 0, - HEAD = 1, - NECK = 2, - CHEST = 3, - CHEST_OFFSET = 4, - WAIST = 5, - HIP = 6, - HIP_OFFSET = 7, - HIPS_WIDTH = 8, - UPPER_LEG = 9, - LOWER_LEG = 10, - FOOT_LENGTH = 11, - FOOT_SHIFT = 12, - SKELETON_OFFSET = 13, - SHOULDERS_DISTANCE = 14, - SHOULDERS_WIDTH = 15, - UPPER_ARM = 16, - LOWER_ARM = 17, - HAND_Y = 18, - HAND_Z = 19, - ELBOW_OFFSET = 20, - UPPER_CHEST = 21, - MIN = NONE, - MAX = UPPER_CHEST +enum class TrackingChecklistStepVisibility : uint8_t { + ALWAYS = 0, + WHEN_INVALID = 1, + MIN = ALWAYS, + MAX = WHEN_INVALID }; -inline const SkeletonBone (&EnumValuesSkeletonBone())[22] { - static const SkeletonBone values[] = { - SkeletonBone::NONE, - SkeletonBone::HEAD, - SkeletonBone::NECK, - SkeletonBone::CHEST, - SkeletonBone::CHEST_OFFSET, - SkeletonBone::WAIST, - SkeletonBone::HIP, - SkeletonBone::HIP_OFFSET, - SkeletonBone::HIPS_WIDTH, - SkeletonBone::UPPER_LEG, - SkeletonBone::LOWER_LEG, - SkeletonBone::FOOT_LENGTH, - SkeletonBone::FOOT_SHIFT, - SkeletonBone::SKELETON_OFFSET, - SkeletonBone::SHOULDERS_DISTANCE, - SkeletonBone::SHOULDERS_WIDTH, - SkeletonBone::UPPER_ARM, - SkeletonBone::LOWER_ARM, - SkeletonBone::HAND_Y, - SkeletonBone::HAND_Z, - SkeletonBone::ELBOW_OFFSET, - SkeletonBone::UPPER_CHEST +inline const TrackingChecklistStepVisibility (&EnumValuesTrackingChecklistStepVisibility())[2] { + static const TrackingChecklistStepVisibility values[] = { + TrackingChecklistStepVisibility::ALWAYS, + TrackingChecklistStepVisibility::WHEN_INVALID }; return values; } -inline const char * const *EnumNamesSkeletonBone() { - static const char * const names[23] = { - "NONE", - "HEAD", - "NECK", - "CHEST", - "CHEST_OFFSET", - "WAIST", - "HIP", - "HIP_OFFSET", - "HIPS_WIDTH", - "UPPER_LEG", - "LOWER_LEG", - "FOOT_LENGTH", - "FOOT_SHIFT", - "SKELETON_OFFSET", - "SHOULDERS_DISTANCE", - "SHOULDERS_WIDTH", - "UPPER_ARM", - "LOWER_ARM", - "HAND_Y", - "HAND_Z", - "ELBOW_OFFSET", - "UPPER_CHEST", +inline const char * const *EnumNamesTrackingChecklistStepVisibility() { + static const char * const names[3] = { + "ALWAYS", + "WHEN_INVALID", nullptr }; return names; } -inline const char *EnumNameSkeletonBone(SkeletonBone e) { - if (flatbuffers::IsOutRange(e, SkeletonBone::NONE, SkeletonBone::UPPER_CHEST)) return ""; +inline const char *EnumNameTrackingChecklistStepVisibility(TrackingChecklistStepVisibility e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistStepVisibility::ALWAYS, TrackingChecklistStepVisibility::WHEN_INVALID)) return ""; const size_t index = static_cast(e); - return EnumNamesSkeletonBone()[index]; + return EnumNamesTrackingChecklistStepVisibility()[index]; } -enum class SerialDeviceType : uint8_t { - ESP_TRACKER = 0, - HID_RECEIVER = 1, - HID_TRACKER = 2, - MIN = ESP_TRACKER, - MAX = HID_TRACKER +enum class TrackingChecklistExtraData : uint8_t { + NONE = 0, + TrackingChecklistTrackerReset = 1, + TrackingChecklistTrackerError = 2, + TrackingChecklistSteamVRDisconnected = 3, + TrackingChecklistUnassignedHMD = 4, + TrackingChecklistNeedCalibration = 5, + TrackingChecklistPublicNetworks = 6, + MIN = NONE, + MAX = TrackingChecklistPublicNetworks }; -inline const SerialDeviceType (&EnumValuesSerialDeviceType())[3] { - static const SerialDeviceType values[] = { - SerialDeviceType::ESP_TRACKER, - SerialDeviceType::HID_RECEIVER, - SerialDeviceType::HID_TRACKER +inline const TrackingChecklistExtraData (&EnumValuesTrackingChecklistExtraData())[7] { + static const TrackingChecklistExtraData values[] = { + TrackingChecklistExtraData::NONE, + TrackingChecklistExtraData::TrackingChecklistTrackerReset, + TrackingChecklistExtraData::TrackingChecklistTrackerError, + TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected, + TrackingChecklistExtraData::TrackingChecklistUnassignedHMD, + TrackingChecklistExtraData::TrackingChecklistNeedCalibration, + TrackingChecklistExtraData::TrackingChecklistPublicNetworks }; return values; } -inline const char * const *EnumNamesSerialDeviceType() { - static const char * const names[4] = { - "ESP_TRACKER", - "HID_RECEIVER", - "HID_TRACKER", +inline const char * const *EnumNamesTrackingChecklistExtraData() { + static const char * const names[8] = { + "NONE", + "TrackingChecklistTrackerReset", + "TrackingChecklistTrackerError", + "TrackingChecklistSteamVRDisconnected", + "TrackingChecklistUnassignedHMD", + "TrackingChecklistNeedCalibration", + "TrackingChecklistPublicNetworks", nullptr }; return names; } -inline const char *EnumNameSerialDeviceType(SerialDeviceType e) { - if (flatbuffers::IsOutRange(e, SerialDeviceType::ESP_TRACKER, SerialDeviceType::HID_TRACKER)) return ""; +inline const char *EnumNameTrackingChecklistExtraData(TrackingChecklistExtraData e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistExtraData::NONE, TrackingChecklistExtraData::TrackingChecklistPublicNetworks)) return ""; const size_t index = static_cast(e); - return EnumNamesSerialDeviceType()[index]; + return EnumNamesTrackingChecklistExtraData()[index]; } -enum class WifiProvisioningStatus : uint8_t { - NONE = 0, - SERIAL_INIT = 1, - PROVISIONING = 2, - CONNECTING = 3, - CONNECTION_ERROR = 4, - LOOKING_FOR_SERVER = 5, - COULD_NOT_FIND_SERVER = 6, - DONE = 7, - OBTAINING_MAC_ADDRESS = 8, - NO_SERIAL_LOGS_ERROR = 9, - NO_SERIAL_DEVICE_FOUND = 10, - MIN = NONE, - MAX = NO_SERIAL_DEVICE_FOUND +template struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::NONE; }; -inline const WifiProvisioningStatus (&EnumValuesWifiProvisioningStatus())[11] { - static const WifiProvisioningStatus values[] = { - WifiProvisioningStatus::NONE, - WifiProvisioningStatus::SERIAL_INIT, - WifiProvisioningStatus::PROVISIONING, - WifiProvisioningStatus::CONNECTING, - WifiProvisioningStatus::CONNECTION_ERROR, - WifiProvisioningStatus::LOOKING_FOR_SERVER, - WifiProvisioningStatus::COULD_NOT_FIND_SERVER, - WifiProvisioningStatus::DONE, - WifiProvisioningStatus::OBTAINING_MAC_ADDRESS, - WifiProvisioningStatus::NO_SERIAL_LOGS_ERROR, - WifiProvisioningStatus::NO_SERIAL_DEVICE_FOUND - }; - return values; -} +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerReset; +}; -inline const char * const *EnumNamesWifiProvisioningStatus() { - static const char * const names[12] = { - "NONE", - "SERIAL_INIT", - "PROVISIONING", - "CONNECTING", - "CONNECTION_ERROR", - "LOOKING_FOR_SERVER", - "COULD_NOT_FIND_SERVER", - "DONE", - "OBTAINING_MAC_ADDRESS", - "NO_SERIAL_LOGS_ERROR", - "NO_SERIAL_DEVICE_FOUND", - nullptr - }; - return names; -} +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerError; +}; -inline const char *EnumNameWifiProvisioningStatus(WifiProvisioningStatus e) { - if (flatbuffers::IsOutRange(e, WifiProvisioningStatus::NONE, WifiProvisioningStatus::NO_SERIAL_DEVICE_FOUND)) return ""; - const size_t index = static_cast(e); - return EnumNamesWifiProvisioningStatus()[index]; -} +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected; +}; -enum class AutoBoneProcessType : uint8_t { - NONE = 0, - RECORD = 1, - SAVE = 2, - PROCESS = 3, - /// @deprecated - /// Use AutoBoneApplyRequest instead - APPLY = 4, - MIN = NONE, - MAX = APPLY +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistUnassignedHMD; }; -inline const AutoBoneProcessType (&EnumValuesAutoBoneProcessType())[5] { - static const AutoBoneProcessType values[] = { - AutoBoneProcessType::NONE, - AutoBoneProcessType::RECORD, - AutoBoneProcessType::SAVE, - AutoBoneProcessType::PROCESS, - AutoBoneProcessType::APPLY +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistNeedCalibration; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistPublicNetworks; +}; + +bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type); +bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class VRCTrackerModel : uint8_t { + UNKNOWN = 0, + SPHERE = 1, + SYSTEM = 2, + BOX = 3, + AXIS = 4, + MIN = UNKNOWN, + MAX = AXIS +}; + +inline const VRCTrackerModel (&EnumValuesVRCTrackerModel())[5] { + static const VRCTrackerModel values[] = { + VRCTrackerModel::UNKNOWN, + VRCTrackerModel::SPHERE, + VRCTrackerModel::SYSTEM, + VRCTrackerModel::BOX, + VRCTrackerModel::AXIS }; return values; } -inline const char * const *EnumNamesAutoBoneProcessType() { +inline const char * const *EnumNamesVRCTrackerModel() { static const char * const names[6] = { - "NONE", - "RECORD", - "SAVE", - "PROCESS", - "APPLY", + "UNKNOWN", + "SPHERE", + "SYSTEM", + "BOX", + "AXIS", nullptr }; return names; } -inline const char *EnumNameAutoBoneProcessType(AutoBoneProcessType e) { - if (flatbuffers::IsOutRange(e, AutoBoneProcessType::NONE, AutoBoneProcessType::APPLY)) return ""; +inline const char *EnumNameVRCTrackerModel(VRCTrackerModel e) { + if (flatbuffers::IsOutRange(e, VRCTrackerModel::UNKNOWN, VRCTrackerModel::AXIS)) return ""; const size_t index = static_cast(e); - return EnumNamesAutoBoneProcessType()[index]; + return EnumNamesVRCTrackerModel()[index]; } -enum class StatusData : uint8_t { - NONE = 0, - StatusTrackerReset = 1, - StatusTrackerError = 2, - StatusSteamVRDisconnected = 3, - StatusUnassignedHMD = 4, - StatusPublicNetwork = 5, - MIN = NONE, - MAX = StatusPublicNetwork +enum class VRCSpineMode : uint8_t { + UNKNOWN = 0, + LOCK_HIP = 1, + LOCK_HEAD = 2, + LOCK_BOTH = 3, + MIN = UNKNOWN, + MAX = LOCK_BOTH }; -inline const StatusData (&EnumValuesStatusData())[6] { - static const StatusData values[] = { - StatusData::NONE, - StatusData::StatusTrackerReset, - StatusData::StatusTrackerError, - StatusData::StatusSteamVRDisconnected, - StatusData::StatusUnassignedHMD, - StatusData::StatusPublicNetwork +inline const VRCSpineMode (&EnumValuesVRCSpineMode())[4] { + static const VRCSpineMode values[] = { + VRCSpineMode::UNKNOWN, + VRCSpineMode::LOCK_HIP, + VRCSpineMode::LOCK_HEAD, + VRCSpineMode::LOCK_BOTH }; return values; } -inline const char * const *EnumNamesStatusData() { - static const char * const names[7] = { - "NONE", - "StatusTrackerReset", - "StatusTrackerError", - "StatusSteamVRDisconnected", - "StatusUnassignedHMD", - "StatusPublicNetwork", +inline const char * const *EnumNamesVRCSpineMode() { + static const char * const names[5] = { + "UNKNOWN", + "LOCK_HIP", + "LOCK_HEAD", + "LOCK_BOTH", nullptr }; return names; } -inline const char *EnumNameStatusData(StatusData e) { - if (flatbuffers::IsOutRange(e, StatusData::NONE, StatusData::StatusPublicNetwork)) return ""; +inline const char *EnumNameVRCSpineMode(VRCSpineMode e) { + if (flatbuffers::IsOutRange(e, VRCSpineMode::UNKNOWN, VRCSpineMode::LOCK_BOTH)) return ""; const size_t index = static_cast(e); - return EnumNamesStatusData()[index]; + return EnumNamesVRCSpineMode()[index]; } -template struct StatusDataTraits { - static const StatusData enum_value = StatusData::NONE; -}; - -template<> struct StatusDataTraits { - static const StatusData enum_value = StatusData::StatusTrackerReset; -}; - -template<> struct StatusDataTraits { - static const StatusData enum_value = StatusData::StatusTrackerError; -}; - -template<> struct StatusDataTraits { - static const StatusData enum_value = StatusData::StatusSteamVRDisconnected; +enum class VRCAvatarMeasurementType : uint8_t { + UNKNOWN = 0, + HEIGHT = 1, + ARM_SPAN = 2, + MIN = UNKNOWN, + MAX = ARM_SPAN }; -template<> struct StatusDataTraits { - static const StatusData enum_value = StatusData::StatusUnassignedHMD; -}; +inline const VRCAvatarMeasurementType (&EnumValuesVRCAvatarMeasurementType())[3] { + static const VRCAvatarMeasurementType values[] = { + VRCAvatarMeasurementType::UNKNOWN, + VRCAvatarMeasurementType::HEIGHT, + VRCAvatarMeasurementType::ARM_SPAN + }; + return values; +} -template<> struct StatusDataTraits { - static const StatusData enum_value = StatusData::StatusPublicNetwork; -}; +inline const char * const *EnumNamesVRCAvatarMeasurementType() { + static const char * const names[4] = { + "UNKNOWN", + "HEIGHT", + "ARM_SPAN", + nullptr + }; + return names; +} -bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, StatusData type); -bool VerifyStatusDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +inline const char *EnumNameVRCAvatarMeasurementType(VRCAvatarMeasurementType e) { + if (flatbuffers::IsOutRange(e, VRCAvatarMeasurementType::UNKNOWN, VRCAvatarMeasurementType::ARM_SPAN)) return ""; + const size_t index = static_cast(e); + return EnumNamesVRCAvatarMeasurementType()[index]; +} -/// Common folders often used in computers for storing files -enum class ComputerDirectory : uint8_t { - Documents = 0, - MIN = Documents, - MAX = Documents +enum class VRCOSCInputState : uint8_t { + IDLE = 0, + LISTENING = 1, + ERROR = 2, + MIN = IDLE, + MAX = ERROR }; -inline const ComputerDirectory (&EnumValuesComputerDirectory())[1] { - static const ComputerDirectory values[] = { - ComputerDirectory::Documents +inline const VRCOSCInputState (&EnumValuesVRCOSCInputState())[3] { + static const VRCOSCInputState values[] = { + VRCOSCInputState::IDLE, + VRCOSCInputState::LISTENING, + VRCOSCInputState::ERROR }; return values; } -inline const char * const *EnumNamesComputerDirectory() { - static const char * const names[2] = { - "Documents", +inline const char * const *EnumNamesVRCOSCInputState() { + static const char * const names[4] = { + "IDLE", + "LISTENING", + "ERROR", nullptr }; return names; } -inline const char *EnumNameComputerDirectory(ComputerDirectory e) { - if (flatbuffers::IsOutRange(e, ComputerDirectory::Documents, ComputerDirectory::Documents)) return ""; +inline const char *EnumNameVRCOSCInputState(VRCOSCInputState e) { + if (flatbuffers::IsOutRange(e, VRCOSCInputState::IDLE, VRCOSCInputState::ERROR)) return ""; const size_t index = static_cast(e); - return EnumNamesComputerDirectory()[index]; + return EnumNamesVRCOSCInputState()[index]; } -enum class FirmwareUpdateStatus : uint8_t { - /// The server is downloading the firmware - DOWNLOADING = 0, - /// The server is waiting for the tracker to be rebooted by the user - /// Note that is is not the same as REBOOTING - NEED_MANUAL_REBOOT = 1, - /// The server tries to authenticate with the MCU - AUTHENTICATING = 2, - /// The server is uploading the firmware to the Device - UPLOADING = 3, - /// The serial flasher tries to sync with the MCU - /// You can use this event to prompt the user to press the boot btn - SYNCING_WITH_MCU = 4, - /// The MCU is rebooting - REBOOTING = 5, - /// The server is provisioning the tracker - PROVISIONING = 6, - DONE = 7, - /// Could not find the device - ERROR_DEVICE_NOT_FOUND = 8, - /// The operation timed out, > 1min - ERROR_TIMEOUT = 9, - /// The firmware download failed - ERROR_DOWNLOAD_FAILED = 10, - /// The server could not authenticate with the MCU - ERROR_AUTHENTICATION_FAILED = 11, - /// Could not upload the firmware to the MCU - ERROR_UPLOAD_FAILED = 12, - /// The provision of the tracker failed, usually wifi credentials - ERROR_PROVISIONING_FAILED = 13, - /// An unsupported Flashing method was used - ERROR_UNSUPPORTED_METHOD = 14, - ERROR_UNKNOWN = 15, - MIN = DOWNLOADING, - MAX = ERROR_UNKNOWN +enum class VRCOSCOutputState : uint8_t { + IDLE = 0, + READY = 1, + ERROR = 2, + MIN = IDLE, + MAX = ERROR }; -inline const FirmwareUpdateStatus (&EnumValuesFirmwareUpdateStatus())[16] { - static const FirmwareUpdateStatus values[] = { - FirmwareUpdateStatus::DOWNLOADING, - FirmwareUpdateStatus::NEED_MANUAL_REBOOT, - FirmwareUpdateStatus::AUTHENTICATING, - FirmwareUpdateStatus::UPLOADING, - FirmwareUpdateStatus::SYNCING_WITH_MCU, - FirmwareUpdateStatus::REBOOTING, - FirmwareUpdateStatus::PROVISIONING, - FirmwareUpdateStatus::DONE, - FirmwareUpdateStatus::ERROR_DEVICE_NOT_FOUND, - FirmwareUpdateStatus::ERROR_TIMEOUT, - FirmwareUpdateStatus::ERROR_DOWNLOAD_FAILED, - FirmwareUpdateStatus::ERROR_AUTHENTICATION_FAILED, - FirmwareUpdateStatus::ERROR_UPLOAD_FAILED, - FirmwareUpdateStatus::ERROR_PROVISIONING_FAILED, - FirmwareUpdateStatus::ERROR_UNSUPPORTED_METHOD, - FirmwareUpdateStatus::ERROR_UNKNOWN +inline const VRCOSCOutputState (&EnumValuesVRCOSCOutputState())[3] { + static const VRCOSCOutputState values[] = { + VRCOSCOutputState::IDLE, + VRCOSCOutputState::READY, + VRCOSCOutputState::ERROR }; return values; } -inline const char * const *EnumNamesFirmwareUpdateStatus() { - static const char * const names[17] = { - "DOWNLOADING", - "NEED_MANUAL_REBOOT", - "AUTHENTICATING", - "UPLOADING", - "SYNCING_WITH_MCU", - "REBOOTING", - "PROVISIONING", - "DONE", - "ERROR_DEVICE_NOT_FOUND", - "ERROR_TIMEOUT", - "ERROR_DOWNLOAD_FAILED", - "ERROR_AUTHENTICATION_FAILED", - "ERROR_UPLOAD_FAILED", - "ERROR_PROVISIONING_FAILED", - "ERROR_UNSUPPORTED_METHOD", - "ERROR_UNKNOWN", +inline const char * const *EnumNamesVRCOSCOutputState() { + static const char * const names[4] = { + "IDLE", + "READY", + "ERROR", nullptr }; return names; } -inline const char *EnumNameFirmwareUpdateStatus(FirmwareUpdateStatus e) { - if (flatbuffers::IsOutRange(e, FirmwareUpdateStatus::DOWNLOADING, FirmwareUpdateStatus::ERROR_UNKNOWN)) return ""; +inline const char *EnumNameVRCOSCOutputState(VRCOSCOutputState e) { + if (flatbuffers::IsOutRange(e, VRCOSCOutputState::IDLE, VRCOSCOutputState::ERROR)) return ""; const size_t index = static_cast(e); - return EnumNamesFirmwareUpdateStatus()[index]; + return EnumNamesVRCOSCOutputState()[index]; } -enum class FirmwareUpdateDeviceId : uint8_t { +enum class VRCOSCTargetSource : uint8_t { NONE = 0, - solarxr_protocol_datatypes_DeviceIdTable = 1, - SerialDevicePort = 2, + MANUAL = 1, + DISCOVERED = 2, MIN = NONE, - MAX = SerialDevicePort + MAX = DISCOVERED }; -inline const FirmwareUpdateDeviceId (&EnumValuesFirmwareUpdateDeviceId())[3] { - static const FirmwareUpdateDeviceId values[] = { - FirmwareUpdateDeviceId::NONE, - FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable, - FirmwareUpdateDeviceId::SerialDevicePort +inline const VRCOSCTargetSource (&EnumValuesVRCOSCTargetSource())[3] { + static const VRCOSCTargetSource values[] = { + VRCOSCTargetSource::NONE, + VRCOSCTargetSource::MANUAL, + VRCOSCTargetSource::DISCOVERED }; return values; } -inline const char * const *EnumNamesFirmwareUpdateDeviceId() { +inline const char * const *EnumNamesVRCOSCTargetSource() { static const char * const names[4] = { "NONE", - "solarxr_protocol_datatypes_DeviceIdTable", - "SerialDevicePort", + "MANUAL", + "DISCOVERED", nullptr }; return names; } -inline const char *EnumNameFirmwareUpdateDeviceId(FirmwareUpdateDeviceId e) { - if (flatbuffers::IsOutRange(e, FirmwareUpdateDeviceId::NONE, FirmwareUpdateDeviceId::SerialDevicePort)) return ""; +inline const char *EnumNameVRCOSCTargetSource(VRCOSCTargetSource e) { + if (flatbuffers::IsOutRange(e, VRCOSCTargetSource::NONE, VRCOSCTargetSource::DISCOVERED)) return ""; const size_t index = static_cast(e); - return EnumNamesFirmwareUpdateDeviceId()[index]; + return EnumNamesVRCOSCTargetSource()[index]; } -template struct FirmwareUpdateDeviceIdTraits { - static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::NONE; -}; - -template<> struct FirmwareUpdateDeviceIdTraits { - static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable; -}; - -template<> struct FirmwareUpdateDeviceIdTraits { - static const FirmwareUpdateDeviceId enum_value = FirmwareUpdateDeviceId::SerialDevicePort; +enum class VRCOSCOscQueryState : uint8_t { + DISABLED = 0, + SEARCHING = 1, + FOUND = 2, + ERROR = 3, + MIN = DISABLED, + MAX = ERROR }; -bool VerifyFirmwareUpdateDeviceId(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateDeviceId type); -bool VerifyFirmwareUpdateDeviceIdVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +inline const VRCOSCOscQueryState (&EnumValuesVRCOSCOscQueryState())[4] { + static const VRCOSCOscQueryState values[] = { + VRCOSCOscQueryState::DISABLED, + VRCOSCOscQueryState::SEARCHING, + VRCOSCOscQueryState::FOUND, + VRCOSCOscQueryState::ERROR + }; + return values; +} -enum class FirmwareUpdateMethod : uint8_t { +inline const char * const *EnumNamesVRCOSCOscQueryState() { + static const char * const names[5] = { + "DISABLED", + "SEARCHING", + "FOUND", + "ERROR", + nullptr + }; + return names; +} + +inline const char *EnumNameVRCOSCOscQueryState(VRCOSCOscQueryState e) { + if (flatbuffers::IsOutRange(e, VRCOSCOscQueryState::DISABLED, VRCOSCOscQueryState::ERROR)) return ""; + const size_t index = static_cast(e); + return EnumNamesVRCOSCOscQueryState()[index]; +} + +enum class RpcMessage : uint8_t { NONE = 0, - OTAFirmwareUpdate = 1, - SerialFirmwareUpdate = 2, + HeartbeatRequest = 1, + HeartbeatResponse = 2, + ResetRequest = 3, + ResetResponse = 4, + AssignTrackerRequest = 5, + OutputTrackersSettingsRequest = 6, + OutputTrackersSettingsResponse = 7, + ChangeOutputTrackersSettingsRequest = 8, + VMCOSCSettingsRequest = 9, + VMCOSCSettingsResponse = 10, + ChangeVMCOSCSettingsRequest = 11, + VRMSettingsRequest = 12, + VRMSettingsResponse = 13, + ChangeVRMSettingsRequest = 14, + SkeletonSettingsRequest = 15, + SkeletonSettingsResponse = 16, + ChangeSkeletonSettingsRequest = 17, + TapDetectionSettingsRequest = 18, + TapDetectionSettingsResponse = 19, + ChangeTapDetectionSettingsRequest = 20, + TapDetectionSetupModeRequest = 21, + ResetsSettingsRequest = 22, + ResetsSettingsResponse = 23, + ChangeResetsSettingsRequest = 24, + StayAlignedSettingsRequest = 25, + StayAlignedSettingsResponse = 26, + ChangeStayAlignedSettingsRequest = 27, + CompleteStayAlignedResponse = 28, + StayAlignedHideCorrectionRequest = 29, + HIDSettingsRequest = 30, + HIDSettingsResponse = 31, + ChangeHIDSettingsRequest = 32, + RecordBVHRequest = 33, + RecordBVHStatus = 34, + SkeletonProportionsRequest = 35, + ChangeSkeletonProportionsRequest = 36, + SkeletonProportionsResetAllRequest = 37, + SkeletonProportionsResponse = 38, + OpenSerialRequest = 39, + CloseSerialRequest = 40, + SerialUpdateResponse = 41, + AutoBoneProcessRequest = 42, + AutoBoneProcessStatusResponse = 43, + AutoBoneEpochResponse = 44, + OverlayDisplayModeRequest = 45, + OverlayDisplayModeChangeRequest = 46, + OverlayDisplayModeResponse = 47, + SerialTrackerRebootRequest = 48, + SerialTrackerGetInfoRequest = 49, + SerialTrackerFactoryResetRequest = 50, + SerialDevicesRequest = 51, + SerialDevicesResponse = 52, + NewSerialDeviceResponse = 53, + StartWifiProvisioningRequest = 54, + StopWifiProvisioningRequest = 55, + WifiProvisioningStatusResponse = 56, + ServerInfosRequest = 57, + ServerInfosResponse = 58, + LegTweaksTmpChange = 59, + LegTweaksTmpClear = 60, + TapDetectionSetupNotification = 61, + SetPauseTrackingRequest = 62, + ClearMountingResetRequest = 63, + AutoBoneApplyRequest = 64, + AutoBoneStopRecordingRequest = 65, + AutoBoneCancelRecordingRequest = 66, + SaveFileNotification = 67, + TrackingPauseStateRequest = 68, + TrackingPauseStateResponse = 69, + SerialTrackerGetWifiScanRequest = 70, + UnknownDeviceHandshakeNotification = 71, + AddUnknownDeviceRequest = 72, + ForgetDeviceRequest = 73, + FirmwareUpdateRequest = 74, + FirmwareUpdateStatusResponse = 75, + FirmwareUpdateStopQueuesRequest = 76, + SettingsResetRequest = 77, + MagToggleRequest = 78, + MagToggleResponse = 79, + ChangeMagToggleRequest = 80, + RecordBVHStatusRequest = 81, + VRCConfigStateRequest = 82, + VRCConfigStateChangeResponse = 83, + EnableStayAlignedRequest = 84, + DetectStayAlignedRelaxedPoseRequest = 85, + ResetStayAlignedRelaxedPoseRequest = 86, + SerialTrackerCustomCommandRequest = 87, + VRCConfigSettingToggleMute = 88, + TrackingChecklistRequest = 89, + TrackingChecklistResponse = 90, + IgnoreTrackingChecklistStepRequest = 91, + StartUserHeightCalibration = 92, + CancelUserHeightCalibration = 93, + UserHeightRecordingStatusResponse = 94, + VRCOSCSettingsRequest = 95, + VRCOSCSettingsResponse = 96, + ChangeVRCOSCSettingsRequest = 97, + VRCOSCStatusRequest = 98, + VRCOSCStatusChangeResponse = 99, + KeybindRequest = 100, + ChangeKeybindRequest = 101, + KeybindResponse = 102, + InstalledInfoRequest = 103, + InstalledInfoResponse = 104, + OpenUriRequest = 105, + OpenUriResponse = 106, + EnableSteamVRDriverRequest = 107, MIN = NONE, - MAX = SerialFirmwareUpdate + MAX = EnableSteamVRDriverRequest }; -inline const FirmwareUpdateMethod (&EnumValuesFirmwareUpdateMethod())[3] { - static const FirmwareUpdateMethod values[] = { - FirmwareUpdateMethod::NONE, - FirmwareUpdateMethod::OTAFirmwareUpdate, - FirmwareUpdateMethod::SerialFirmwareUpdate +inline const RpcMessage (&EnumValuesRpcMessage())[108] { + static const RpcMessage values[] = { + RpcMessage::NONE, + RpcMessage::HeartbeatRequest, + RpcMessage::HeartbeatResponse, + RpcMessage::ResetRequest, + RpcMessage::ResetResponse, + RpcMessage::AssignTrackerRequest, + RpcMessage::OutputTrackersSettingsRequest, + RpcMessage::OutputTrackersSettingsResponse, + RpcMessage::ChangeOutputTrackersSettingsRequest, + RpcMessage::VMCOSCSettingsRequest, + RpcMessage::VMCOSCSettingsResponse, + RpcMessage::ChangeVMCOSCSettingsRequest, + RpcMessage::VRMSettingsRequest, + RpcMessage::VRMSettingsResponse, + RpcMessage::ChangeVRMSettingsRequest, + RpcMessage::SkeletonSettingsRequest, + RpcMessage::SkeletonSettingsResponse, + RpcMessage::ChangeSkeletonSettingsRequest, + RpcMessage::TapDetectionSettingsRequest, + RpcMessage::TapDetectionSettingsResponse, + RpcMessage::ChangeTapDetectionSettingsRequest, + RpcMessage::TapDetectionSetupModeRequest, + RpcMessage::ResetsSettingsRequest, + RpcMessage::ResetsSettingsResponse, + RpcMessage::ChangeResetsSettingsRequest, + RpcMessage::StayAlignedSettingsRequest, + RpcMessage::StayAlignedSettingsResponse, + RpcMessage::ChangeStayAlignedSettingsRequest, + RpcMessage::CompleteStayAlignedResponse, + RpcMessage::StayAlignedHideCorrectionRequest, + RpcMessage::HIDSettingsRequest, + RpcMessage::HIDSettingsResponse, + RpcMessage::ChangeHIDSettingsRequest, + RpcMessage::RecordBVHRequest, + RpcMessage::RecordBVHStatus, + RpcMessage::SkeletonProportionsRequest, + RpcMessage::ChangeSkeletonProportionsRequest, + RpcMessage::SkeletonProportionsResetAllRequest, + RpcMessage::SkeletonProportionsResponse, + RpcMessage::OpenSerialRequest, + RpcMessage::CloseSerialRequest, + RpcMessage::SerialUpdateResponse, + RpcMessage::AutoBoneProcessRequest, + RpcMessage::AutoBoneProcessStatusResponse, + RpcMessage::AutoBoneEpochResponse, + RpcMessage::OverlayDisplayModeRequest, + RpcMessage::OverlayDisplayModeChangeRequest, + RpcMessage::OverlayDisplayModeResponse, + RpcMessage::SerialTrackerRebootRequest, + RpcMessage::SerialTrackerGetInfoRequest, + RpcMessage::SerialTrackerFactoryResetRequest, + RpcMessage::SerialDevicesRequest, + RpcMessage::SerialDevicesResponse, + RpcMessage::NewSerialDeviceResponse, + RpcMessage::StartWifiProvisioningRequest, + RpcMessage::StopWifiProvisioningRequest, + RpcMessage::WifiProvisioningStatusResponse, + RpcMessage::ServerInfosRequest, + RpcMessage::ServerInfosResponse, + RpcMessage::LegTweaksTmpChange, + RpcMessage::LegTweaksTmpClear, + RpcMessage::TapDetectionSetupNotification, + RpcMessage::SetPauseTrackingRequest, + RpcMessage::ClearMountingResetRequest, + RpcMessage::AutoBoneApplyRequest, + RpcMessage::AutoBoneStopRecordingRequest, + RpcMessage::AutoBoneCancelRecordingRequest, + RpcMessage::SaveFileNotification, + RpcMessage::TrackingPauseStateRequest, + RpcMessage::TrackingPauseStateResponse, + RpcMessage::SerialTrackerGetWifiScanRequest, + RpcMessage::UnknownDeviceHandshakeNotification, + RpcMessage::AddUnknownDeviceRequest, + RpcMessage::ForgetDeviceRequest, + RpcMessage::FirmwareUpdateRequest, + RpcMessage::FirmwareUpdateStatusResponse, + RpcMessage::FirmwareUpdateStopQueuesRequest, + RpcMessage::SettingsResetRequest, + RpcMessage::MagToggleRequest, + RpcMessage::MagToggleResponse, + RpcMessage::ChangeMagToggleRequest, + RpcMessage::RecordBVHStatusRequest, + RpcMessage::VRCConfigStateRequest, + RpcMessage::VRCConfigStateChangeResponse, + RpcMessage::EnableStayAlignedRequest, + RpcMessage::DetectStayAlignedRelaxedPoseRequest, + RpcMessage::ResetStayAlignedRelaxedPoseRequest, + RpcMessage::SerialTrackerCustomCommandRequest, + RpcMessage::VRCConfigSettingToggleMute, + RpcMessage::TrackingChecklistRequest, + RpcMessage::TrackingChecklistResponse, + RpcMessage::IgnoreTrackingChecklistStepRequest, + RpcMessage::StartUserHeightCalibration, + RpcMessage::CancelUserHeightCalibration, + RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::VRCOSCSettingsRequest, + RpcMessage::VRCOSCSettingsResponse, + RpcMessage::ChangeVRCOSCSettingsRequest, + RpcMessage::VRCOSCStatusRequest, + RpcMessage::VRCOSCStatusChangeResponse, + RpcMessage::KeybindRequest, + RpcMessage::ChangeKeybindRequest, + RpcMessage::KeybindResponse, + RpcMessage::InstalledInfoRequest, + RpcMessage::InstalledInfoResponse, + RpcMessage::OpenUriRequest, + RpcMessage::OpenUriResponse, + RpcMessage::EnableSteamVRDriverRequest }; return values; } -inline const char * const *EnumNamesFirmwareUpdateMethod() { - static const char * const names[4] = { +inline const char * const *EnumNamesRpcMessage() { + static const char * const names[109] = { "NONE", - "OTAFirmwareUpdate", - "SerialFirmwareUpdate", + "HeartbeatRequest", + "HeartbeatResponse", + "ResetRequest", + "ResetResponse", + "AssignTrackerRequest", + "OutputTrackersSettingsRequest", + "OutputTrackersSettingsResponse", + "ChangeOutputTrackersSettingsRequest", + "VMCOSCSettingsRequest", + "VMCOSCSettingsResponse", + "ChangeVMCOSCSettingsRequest", + "VRMSettingsRequest", + "VRMSettingsResponse", + "ChangeVRMSettingsRequest", + "SkeletonSettingsRequest", + "SkeletonSettingsResponse", + "ChangeSkeletonSettingsRequest", + "TapDetectionSettingsRequest", + "TapDetectionSettingsResponse", + "ChangeTapDetectionSettingsRequest", + "TapDetectionSetupModeRequest", + "ResetsSettingsRequest", + "ResetsSettingsResponse", + "ChangeResetsSettingsRequest", + "StayAlignedSettingsRequest", + "StayAlignedSettingsResponse", + "ChangeStayAlignedSettingsRequest", + "CompleteStayAlignedResponse", + "StayAlignedHideCorrectionRequest", + "HIDSettingsRequest", + "HIDSettingsResponse", + "ChangeHIDSettingsRequest", + "RecordBVHRequest", + "RecordBVHStatus", + "SkeletonProportionsRequest", + "ChangeSkeletonProportionsRequest", + "SkeletonProportionsResetAllRequest", + "SkeletonProportionsResponse", + "OpenSerialRequest", + "CloseSerialRequest", + "SerialUpdateResponse", + "AutoBoneProcessRequest", + "AutoBoneProcessStatusResponse", + "AutoBoneEpochResponse", + "OverlayDisplayModeRequest", + "OverlayDisplayModeChangeRequest", + "OverlayDisplayModeResponse", + "SerialTrackerRebootRequest", + "SerialTrackerGetInfoRequest", + "SerialTrackerFactoryResetRequest", + "SerialDevicesRequest", + "SerialDevicesResponse", + "NewSerialDeviceResponse", + "StartWifiProvisioningRequest", + "StopWifiProvisioningRequest", + "WifiProvisioningStatusResponse", + "ServerInfosRequest", + "ServerInfosResponse", + "LegTweaksTmpChange", + "LegTweaksTmpClear", + "TapDetectionSetupNotification", + "SetPauseTrackingRequest", + "ClearMountingResetRequest", + "AutoBoneApplyRequest", + "AutoBoneStopRecordingRequest", + "AutoBoneCancelRecordingRequest", + "SaveFileNotification", + "TrackingPauseStateRequest", + "TrackingPauseStateResponse", + "SerialTrackerGetWifiScanRequest", + "UnknownDeviceHandshakeNotification", + "AddUnknownDeviceRequest", + "ForgetDeviceRequest", + "FirmwareUpdateRequest", + "FirmwareUpdateStatusResponse", + "FirmwareUpdateStopQueuesRequest", + "SettingsResetRequest", + "MagToggleRequest", + "MagToggleResponse", + "ChangeMagToggleRequest", + "RecordBVHStatusRequest", + "VRCConfigStateRequest", + "VRCConfigStateChangeResponse", + "EnableStayAlignedRequest", + "DetectStayAlignedRelaxedPoseRequest", + "ResetStayAlignedRelaxedPoseRequest", + "SerialTrackerCustomCommandRequest", + "VRCConfigSettingToggleMute", + "TrackingChecklistRequest", + "TrackingChecklistResponse", + "IgnoreTrackingChecklistStepRequest", + "StartUserHeightCalibration", + "CancelUserHeightCalibration", + "UserHeightRecordingStatusResponse", + "VRCOSCSettingsRequest", + "VRCOSCSettingsResponse", + "ChangeVRCOSCSettingsRequest", + "VRCOSCStatusRequest", + "VRCOSCStatusChangeResponse", + "KeybindRequest", + "ChangeKeybindRequest", + "KeybindResponse", + "InstalledInfoRequest", + "InstalledInfoResponse", + "OpenUriRequest", + "OpenUriResponse", + "EnableSteamVRDriverRequest", nullptr }; return names; } -inline const char *EnumNameFirmwareUpdateMethod(FirmwareUpdateMethod e) { - if (flatbuffers::IsOutRange(e, FirmwareUpdateMethod::NONE, FirmwareUpdateMethod::SerialFirmwareUpdate)) return ""; +inline const char *EnumNameRpcMessage(RpcMessage e) { + if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::EnableSteamVRDriverRequest)) return ""; const size_t index = static_cast(e); - return EnumNamesFirmwareUpdateMethod()[index]; + return EnumNamesRpcMessage()[index]; } -template struct FirmwareUpdateMethodTraits { - static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::NONE; +template struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::NONE; }; -template<> struct FirmwareUpdateMethodTraits { - static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::OTAFirmwareUpdate; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HeartbeatRequest; }; -template<> struct FirmwareUpdateMethodTraits { - static const FirmwareUpdateMethod enum_value = FirmwareUpdateMethod::SerialFirmwareUpdate; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HeartbeatResponse; }; -bool VerifyFirmwareUpdateMethod(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateMethod type); -bool VerifyFirmwareUpdateMethodVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ResetRequest; +}; -enum class VRCTrackerModel : uint8_t { - UNKNOWN = 0, - SPHERE = 1, - SYSTEM = 2, - BOX = 3, - AXIS = 4, - MIN = UNKNOWN, - MAX = AXIS +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ResetResponse; }; -inline const VRCTrackerModel (&EnumValuesVRCTrackerModel())[5] { - static const VRCTrackerModel values[] = { - VRCTrackerModel::UNKNOWN, - VRCTrackerModel::SPHERE, - VRCTrackerModel::SYSTEM, - VRCTrackerModel::BOX, - VRCTrackerModel::AXIS - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AssignTrackerRequest; +}; -inline const char * const *EnumNamesVRCTrackerModel() { - static const char * const names[6] = { - "UNKNOWN", - "SPHERE", - "SYSTEM", - "BOX", - "AXIS", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OutputTrackersSettingsRequest; +}; -inline const char *EnumNameVRCTrackerModel(VRCTrackerModel e) { - if (flatbuffers::IsOutRange(e, VRCTrackerModel::UNKNOWN, VRCTrackerModel::AXIS)) return ""; - const size_t index = static_cast(e); - return EnumNamesVRCTrackerModel()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OutputTrackersSettingsResponse; +}; -enum class VRCSpineMode : uint8_t { - UNKNOWN = 0, - LOCK_HIP = 1, - LOCK_HEAD = 2, - LOCK_BOTH = 3, - MIN = UNKNOWN, - MAX = LOCK_BOTH +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeOutputTrackersSettingsRequest; }; -inline const VRCSpineMode (&EnumValuesVRCSpineMode())[4] { - static const VRCSpineMode values[] = { - VRCSpineMode::UNKNOWN, - VRCSpineMode::LOCK_HIP, - VRCSpineMode::LOCK_HEAD, - VRCSpineMode::LOCK_BOTH - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VMCOSCSettingsRequest; +}; -inline const char * const *EnumNamesVRCSpineMode() { - static const char * const names[5] = { - "UNKNOWN", - "LOCK_HIP", - "LOCK_HEAD", - "LOCK_BOTH", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VMCOSCSettingsResponse; +}; -inline const char *EnumNameVRCSpineMode(VRCSpineMode e) { - if (flatbuffers::IsOutRange(e, VRCSpineMode::UNKNOWN, VRCSpineMode::LOCK_BOTH)) return ""; - const size_t index = static_cast(e); - return EnumNamesVRCSpineMode()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeVMCOSCSettingsRequest; +}; -enum class VRCAvatarMeasurementType : uint8_t { - UNKNOWN = 0, - HEIGHT = 1, - ARM_SPAN = 2, - MIN = UNKNOWN, - MAX = ARM_SPAN +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRMSettingsRequest; }; -inline const VRCAvatarMeasurementType (&EnumValuesVRCAvatarMeasurementType())[3] { - static const VRCAvatarMeasurementType values[] = { - VRCAvatarMeasurementType::UNKNOWN, - VRCAvatarMeasurementType::HEIGHT, - VRCAvatarMeasurementType::ARM_SPAN - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRMSettingsResponse; +}; -inline const char * const *EnumNamesVRCAvatarMeasurementType() { - static const char * const names[4] = { - "UNKNOWN", - "HEIGHT", - "ARM_SPAN", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeVRMSettingsRequest; +}; -inline const char *EnumNameVRCAvatarMeasurementType(VRCAvatarMeasurementType e) { - if (flatbuffers::IsOutRange(e, VRCAvatarMeasurementType::UNKNOWN, VRCAvatarMeasurementType::ARM_SPAN)) return ""; - const size_t index = static_cast(e); - return EnumNamesVRCAvatarMeasurementType()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SkeletonSettingsRequest; +}; -enum class TrackingChecklistStepId : uint8_t { - UNKNOWN = 0, - TRACKERS_REST_CALIBRATION = 1, - FULL_RESET = 2, - VRCHAT_SETTINGS = 3, - STEAMVR_DISCONNECTED = 4, - UNASSIGNED_HMD = 5, - TRACKER_ERROR = 6, - NETWORK_PROFILE_PUBLIC = 7, - MOUNTING_CALIBRATION = 8, - FEET_MOUNTING_CALIBRATION = 9, - STAY_ALIGNED_CONFIGURED = 10, - STEAMVR_HANDS_ENABLED = 11, - STANDABLE_INSTALLED = 12, - MIN = UNKNOWN, - MAX = STANDABLE_INSTALLED +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SkeletonSettingsResponse; }; -inline const TrackingChecklistStepId (&EnumValuesTrackingChecklistStepId())[13] { - static const TrackingChecklistStepId values[] = { - TrackingChecklistStepId::UNKNOWN, - TrackingChecklistStepId::TRACKERS_REST_CALIBRATION, - TrackingChecklistStepId::FULL_RESET, - TrackingChecklistStepId::VRCHAT_SETTINGS, - TrackingChecklistStepId::STEAMVR_DISCONNECTED, - TrackingChecklistStepId::UNASSIGNED_HMD, - TrackingChecklistStepId::TRACKER_ERROR, - TrackingChecklistStepId::NETWORK_PROFILE_PUBLIC, - TrackingChecklistStepId::MOUNTING_CALIBRATION, - TrackingChecklistStepId::FEET_MOUNTING_CALIBRATION, - TrackingChecklistStepId::STAY_ALIGNED_CONFIGURED, - TrackingChecklistStepId::STEAMVR_HANDS_ENABLED, - TrackingChecklistStepId::STANDABLE_INSTALLED - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeSkeletonSettingsRequest; +}; -inline const char * const *EnumNamesTrackingChecklistStepId() { - static const char * const names[14] = { - "UNKNOWN", - "TRACKERS_REST_CALIBRATION", - "FULL_RESET", - "VRCHAT_SETTINGS", - "STEAMVR_DISCONNECTED", - "UNASSIGNED_HMD", - "TRACKER_ERROR", - "NETWORK_PROFILE_PUBLIC", - "MOUNTING_CALIBRATION", - "FEET_MOUNTING_CALIBRATION", - "STAY_ALIGNED_CONFIGURED", - "STEAMVR_HANDS_ENABLED", - "STANDABLE_INSTALLED", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TapDetectionSettingsRequest; +}; -inline const char *EnumNameTrackingChecklistStepId(TrackingChecklistStepId e) { - if (flatbuffers::IsOutRange(e, TrackingChecklistStepId::UNKNOWN, TrackingChecklistStepId::STANDABLE_INSTALLED)) return ""; - const size_t index = static_cast(e); - return EnumNamesTrackingChecklistStepId()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TapDetectionSettingsResponse; +}; -enum class TrackingChecklistStepVisibility : uint8_t { - ALWAYS = 0, - WHEN_INVALID = 1, - MIN = ALWAYS, - MAX = WHEN_INVALID +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeTapDetectionSettingsRequest; }; -inline const TrackingChecklistStepVisibility (&EnumValuesTrackingChecklistStepVisibility())[2] { - static const TrackingChecklistStepVisibility values[] = { - TrackingChecklistStepVisibility::ALWAYS, - TrackingChecklistStepVisibility::WHEN_INVALID - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TapDetectionSetupModeRequest; +}; -inline const char * const *EnumNamesTrackingChecklistStepVisibility() { - static const char * const names[3] = { - "ALWAYS", - "WHEN_INVALID", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ResetsSettingsRequest; +}; -inline const char *EnumNameTrackingChecklistStepVisibility(TrackingChecklistStepVisibility e) { - if (flatbuffers::IsOutRange(e, TrackingChecklistStepVisibility::ALWAYS, TrackingChecklistStepVisibility::WHEN_INVALID)) return ""; - const size_t index = static_cast(e); - return EnumNamesTrackingChecklistStepVisibility()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ResetsSettingsResponse; +}; -enum class TrackingChecklistExtraData : uint8_t { - NONE = 0, - TrackingChecklistTrackerReset = 1, - TrackingChecklistTrackerError = 2, - TrackingChecklistSteamVRDisconnected = 3, - TrackingChecklistUnassignedHMD = 4, - TrackingChecklistNeedCalibration = 5, - TrackingChecklistPublicNetworks = 6, - MIN = NONE, - MAX = TrackingChecklistPublicNetworks +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeResetsSettingsRequest; }; -inline const TrackingChecklistExtraData (&EnumValuesTrackingChecklistExtraData())[7] { - static const TrackingChecklistExtraData values[] = { - TrackingChecklistExtraData::NONE, - TrackingChecklistExtraData::TrackingChecklistTrackerReset, - TrackingChecklistExtraData::TrackingChecklistTrackerError, - TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected, - TrackingChecklistExtraData::TrackingChecklistUnassignedHMD, - TrackingChecklistExtraData::TrackingChecklistNeedCalibration, - TrackingChecklistExtraData::TrackingChecklistPublicNetworks - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StayAlignedSettingsRequest; +}; -inline const char * const *EnumNamesTrackingChecklistExtraData() { - static const char * const names[8] = { - "NONE", - "TrackingChecklistTrackerReset", - "TrackingChecklistTrackerError", - "TrackingChecklistSteamVRDisconnected", - "TrackingChecklistUnassignedHMD", - "TrackingChecklistNeedCalibration", - "TrackingChecklistPublicNetworks", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StayAlignedSettingsResponse; +}; -inline const char *EnumNameTrackingChecklistExtraData(TrackingChecklistExtraData e) { - if (flatbuffers::IsOutRange(e, TrackingChecklistExtraData::NONE, TrackingChecklistExtraData::TrackingChecklistPublicNetworks)) return ""; - const size_t index = static_cast(e); - return EnumNamesTrackingChecklistExtraData()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeStayAlignedSettingsRequest; +}; -template struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::NONE; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::CompleteStayAlignedResponse; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerReset; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StayAlignedHideCorrectionRequest; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerError; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HIDSettingsRequest; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HIDSettingsResponse; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistUnassignedHMD; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeHIDSettingsRequest; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistNeedCalibration; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::RecordBVHRequest; }; -template<> struct TrackingChecklistExtraDataTraits { - static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistPublicNetworks; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::RecordBVHStatus; }; -bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type); -bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SkeletonProportionsRequest; +}; -enum class StayAlignedRelaxedPose : uint8_t { - STANDING = 0, - SITTING = 1, - FLAT = 2, - MIN = STANDING, - MAX = FLAT +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeSkeletonProportionsRequest; }; -inline const StayAlignedRelaxedPose (&EnumValuesStayAlignedRelaxedPose())[3] { - static const StayAlignedRelaxedPose values[] = { - StayAlignedRelaxedPose::STANDING, - StayAlignedRelaxedPose::SITTING, - StayAlignedRelaxedPose::FLAT - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SkeletonProportionsResetAllRequest; +}; -inline const char * const *EnumNamesStayAlignedRelaxedPose() { - static const char * const names[4] = { - "STANDING", - "SITTING", - "FLAT", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SkeletonProportionsResponse; +}; -inline const char *EnumNameStayAlignedRelaxedPose(StayAlignedRelaxedPose e) { - if (flatbuffers::IsOutRange(e, StayAlignedRelaxedPose::STANDING, StayAlignedRelaxedPose::FLAT)) return ""; - const size_t index = static_cast(e); - return EnumNamesStayAlignedRelaxedPose()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OpenSerialRequest; +}; -enum class UserHeightCalibrationStatus : uint8_t { - NONE = 0, - RECORDING_FLOOR = 1, - WAITING_FOR_CONTROLLER_PITCH = 2, - WAITING_FOR_RISE = 3, - WAITING_FOR_FW_LOOK = 4, - RECORDING_HEIGHT = 5, - DONE = 6, - ERROR_TOO_HIGH = 7, - ERROR_TOO_SMALL = 8, - ERROR_TIMEOUT = 9, - MIN = NONE, - MAX = ERROR_TIMEOUT +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::CloseSerialRequest; }; -inline const UserHeightCalibrationStatus (&EnumValuesUserHeightCalibrationStatus())[10] { - static const UserHeightCalibrationStatus values[] = { - UserHeightCalibrationStatus::NONE, - UserHeightCalibrationStatus::RECORDING_FLOOR, - UserHeightCalibrationStatus::WAITING_FOR_CONTROLLER_PITCH, - UserHeightCalibrationStatus::WAITING_FOR_RISE, - UserHeightCalibrationStatus::WAITING_FOR_FW_LOOK, - UserHeightCalibrationStatus::RECORDING_HEIGHT, - UserHeightCalibrationStatus::DONE, - UserHeightCalibrationStatus::ERROR_TOO_HIGH, - UserHeightCalibrationStatus::ERROR_TOO_SMALL, - UserHeightCalibrationStatus::ERROR_TIMEOUT - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialUpdateResponse; +}; -inline const char * const *EnumNamesUserHeightCalibrationStatus() { - static const char * const names[11] = { - "NONE", - "RECORDING_FLOOR", - "WAITING_FOR_CONTROLLER_PITCH", - "WAITING_FOR_RISE", - "WAITING_FOR_FW_LOOK", - "RECORDING_HEIGHT", - "DONE", - "ERROR_TOO_HIGH", - "ERROR_TOO_SMALL", - "ERROR_TIMEOUT", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneProcessRequest; +}; -inline const char *EnumNameUserHeightCalibrationStatus(UserHeightCalibrationStatus e) { - if (flatbuffers::IsOutRange(e, UserHeightCalibrationStatus::NONE, UserHeightCalibrationStatus::ERROR_TIMEOUT)) return ""; - const size_t index = static_cast(e); - return EnumNamesUserHeightCalibrationStatus()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneProcessStatusResponse; +}; -} // namespace rpc +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneEpochResponse; +}; -namespace pub_sub { +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeRequest; +}; -enum class Topic : uint8_t { - NONE = 0, - TopicHandle = 1, - TopicId = 2, - MIN = NONE, - MAX = TopicId +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeChangeRequest; }; -inline const Topic (&EnumValuesTopic())[3] { - static const Topic values[] = { - Topic::NONE, - Topic::TopicHandle, - Topic::TopicId - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OverlayDisplayModeResponse; +}; -inline const char * const *EnumNamesTopic() { - static const char * const names[4] = { - "NONE", - "TopicHandle", - "TopicId", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialTrackerRebootRequest; +}; -inline const char *EnumNameTopic(Topic e) { - if (flatbuffers::IsOutRange(e, Topic::NONE, Topic::TopicId)) return ""; - const size_t index = static_cast(e); - return EnumNamesTopic()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialTrackerGetInfoRequest; +}; -template struct TopicTraits { - static const Topic enum_value = Topic::NONE; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialTrackerFactoryResetRequest; }; -template<> struct TopicTraits { - static const Topic enum_value = Topic::TopicHandle; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialDevicesRequest; }; -template<> struct TopicTraits { - static const Topic enum_value = Topic::TopicId; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialDevicesResponse; }; -bool VerifyTopic(flatbuffers::Verifier &verifier, const void *obj, Topic type); -bool VerifyTopicVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::NewSerialDeviceResponse; +}; -enum class PubSubUnion : uint8_t { - NONE = 0, - Message = 1, - SubscriptionRequest = 2, - TopicHandleRequest = 3, - TopicMapping = 4, - MIN = NONE, - MAX = TopicMapping +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StartWifiProvisioningRequest; }; -inline const PubSubUnion (&EnumValuesPubSubUnion())[5] { - static const PubSubUnion values[] = { - PubSubUnion::NONE, - PubSubUnion::Message, - PubSubUnion::SubscriptionRequest, - PubSubUnion::TopicHandleRequest, - PubSubUnion::TopicMapping - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StopWifiProvisioningRequest; +}; -inline const char * const *EnumNamesPubSubUnion() { - static const char * const names[6] = { - "NONE", - "Message", - "SubscriptionRequest", - "TopicHandleRequest", - "TopicMapping", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::WifiProvisioningStatusResponse; +}; -inline const char *EnumNamePubSubUnion(PubSubUnion e) { - if (flatbuffers::IsOutRange(e, PubSubUnion::NONE, PubSubUnion::TopicMapping)) return ""; - const size_t index = static_cast(e); - return EnumNamesPubSubUnion()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ServerInfosRequest; +}; -template struct PubSubUnionTraits { - static const PubSubUnion enum_value = PubSubUnion::NONE; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ServerInfosResponse; }; -template<> struct PubSubUnionTraits { - static const PubSubUnion enum_value = PubSubUnion::Message; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::LegTweaksTmpChange; }; -template<> struct PubSubUnionTraits { - static const PubSubUnion enum_value = PubSubUnion::SubscriptionRequest; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::LegTweaksTmpClear; }; -template<> struct PubSubUnionTraits { - static const PubSubUnion enum_value = PubSubUnion::TopicHandleRequest; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TapDetectionSetupNotification; }; -template<> struct PubSubUnionTraits { - static const PubSubUnion enum_value = PubSubUnion::TopicMapping; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SetPauseTrackingRequest; }; -bool VerifyPubSubUnion(flatbuffers::Verifier &verifier, const void *obj, PubSubUnion type); -bool VerifyPubSubUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ClearMountingResetRequest; +}; -enum class Payload : uint8_t { - NONE = 0, - solarxr_protocol_datatypes_StringTable = 1, - solarxr_protocol_datatypes_Bytes = 2, - KeyValues = 3, - MIN = NONE, - MAX = KeyValues +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneApplyRequest; }; -inline const Payload (&EnumValuesPayload())[4] { - static const Payload values[] = { - Payload::NONE, - Payload::solarxr_protocol_datatypes_StringTable, - Payload::solarxr_protocol_datatypes_Bytes, - Payload::KeyValues - }; - return values; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneStopRecordingRequest; +}; -inline const char * const *EnumNamesPayload() { - static const char * const names[5] = { - "NONE", - "solarxr_protocol_datatypes_StringTable", - "solarxr_protocol_datatypes_Bytes", - "KeyValues", - nullptr - }; - return names; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AutoBoneCancelRecordingRequest; +}; -inline const char *EnumNamePayload(Payload e) { - if (flatbuffers::IsOutRange(e, Payload::NONE, Payload::KeyValues)) return ""; - const size_t index = static_cast(e); - return EnumNamesPayload()[index]; -} +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SaveFileNotification; +}; -template struct PayloadTraits { - static const Payload enum_value = Payload::NONE; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingPauseStateRequest; }; -template<> struct PayloadTraits { - static const Payload enum_value = Payload::solarxr_protocol_datatypes_StringTable; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingPauseStateResponse; }; -template<> struct PayloadTraits { - static const Payload enum_value = Payload::solarxr_protocol_datatypes_Bytes; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialTrackerGetWifiScanRequest; }; -template<> struct PayloadTraits { - static const Payload enum_value = Payload::KeyValues; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UnknownDeviceHandshakeNotification; }; -bool VerifyPayload(flatbuffers::Verifier &verifier, const void *obj, Payload type); -bool VerifyPayloadVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AddUnknownDeviceRequest; +}; -} // namespace pub_sub +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ForgetDeviceRequest; +}; -namespace datatypes { +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::FirmwareUpdateRequest; +}; -/// Frequency as 32 bit float -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) HzF32 FLATBUFFERS_FINAL_CLASS { - private: - float f_; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::FirmwareUpdateStatusResponse; +}; - public: - HzF32() - : f_(0) { - } - HzF32(float _f) - : f_(flatbuffers::EndianScalar(_f)) { - } - float f() const { - return flatbuffers::EndianScalar(f_); - } +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::FirmwareUpdateStopQueuesRequest; }; -FLATBUFFERS_STRUCT_END(HzF32, 4); -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) TransactionId FLATBUFFERS_FINAL_CLASS { - private: - uint32_t id_; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SettingsResetRequest; +}; - public: - TransactionId() - : id_(0) { - } - TransactionId(uint32_t _id) - : id_(flatbuffers::EndianScalar(_id)) { - } - /// This is expected to overflow, networking logic should handle this case. - uint32_t id() const { - return flatbuffers::EndianScalar(id_); - } +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::MagToggleRequest; }; -FLATBUFFERS_STRUCT_END(TransactionId, 4); -/// A unique ID for the device. IDs are not guaranteed to be the same after -/// the connection is terminated. -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) DeviceId FLATBUFFERS_FINAL_CLASS { - private: - uint8_t id_; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::MagToggleResponse; +}; - public: - DeviceId() - : id_(0) { - } - DeviceId(uint8_t _id) - : id_(flatbuffers::EndianScalar(_id)) { - } - uint8_t id() const { - return flatbuffers::EndianScalar(id_); - } +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeMagToggleRequest; }; -FLATBUFFERS_STRUCT_END(DeviceId, 1); -/// Temperature in degrees celsius -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Temperature FLATBUFFERS_FINAL_CLASS { - private: - float temp_; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::RecordBVHStatusRequest; +}; - public: - Temperature() - : temp_(0) { - } - Temperature(float _temp) - : temp_(flatbuffers::EndianScalar(_temp)) { - } - float temp() const { - return flatbuffers::EndianScalar(temp_); - } +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCConfigStateRequest; }; -FLATBUFFERS_STRUCT_END(Temperature, 4); -/// The 4 bytes of an ip address are stored in 32 bits in big endian order. -/// We will switch over to fixed size arrays when they are supported better. -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ipv4Address FLATBUFFERS_FINAL_CLASS { - private: - uint32_t addr_; +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCConfigStateChangeResponse; +}; - public: - Ipv4Address() - : addr_(0) { - } - Ipv4Address(uint32_t _addr) - : addr_(flatbuffers::EndianScalar(_addr)) { - } - uint32_t addr() const { - return flatbuffers::EndianScalar(addr_); - } +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::EnableStayAlignedRequest; }; -FLATBUFFERS_STRUCT_END(Ipv4Address, 4); -namespace hardware_info { +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::DetectStayAlignedRelaxedPoseRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ResetStayAlignedRelaxedPoseRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::SerialTrackerCustomCommandRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCConfigSettingToggleMute; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingChecklistRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingChecklistResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::IgnoreTrackingChecklistStepRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StartUserHeightCalibration; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::CancelUserHeightCalibration; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UserHeightRecordingStatusResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCOSCSettingsRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCOSCSettingsResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeVRCOSCSettingsRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCOSCStatusRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCOSCStatusChangeResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::KeybindRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeKeybindRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::KeybindResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::InstalledInfoRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::InstalledInfoResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OpenUriRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::OpenUriResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::EnableSteamVRDriverRequest; +}; + +bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); +bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +/// Common folders often used in computers for storing files +enum class ComputerDirectory : uint8_t { + DOCUMENTS = 0, + MIN = DOCUMENTS, + MAX = DOCUMENTS +}; + +inline const ComputerDirectory (&EnumValuesComputerDirectory())[1] { + static const ComputerDirectory values[] = { + ComputerDirectory::DOCUMENTS + }; + return values; +} + +inline const char * const *EnumNamesComputerDirectory() { + static const char * const names[2] = { + "DOCUMENTS", + nullptr + }; + return names; +} + +inline const char *EnumNameComputerDirectory(ComputerDirectory e) { + if (flatbuffers::IsOutRange(e, ComputerDirectory::DOCUMENTS, ComputerDirectory::DOCUMENTS)) return ""; + const size_t index = static_cast(e); + return EnumNamesComputerDirectory()[index]; +} + +} // namespace rpc + +namespace datatypes { + +/// Frequency as 32 bit float +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) HzF32 FLATBUFFERS_FINAL_CLASS { + private: + float f_; + + public: + HzF32() + : f_(0) { + } + HzF32(float _f) + : f_(flatbuffers::EndianScalar(_f)) { + } + float f() const { + return flatbuffers::EndianScalar(f_); + } +}; +FLATBUFFERS_STRUCT_END(HzF32, 4); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) TransactionId FLATBUFFERS_FINAL_CLASS { + private: + uint32_t id_; + + public: + TransactionId() + : id_(0) { + } + TransactionId(uint32_t _id) + : id_(flatbuffers::EndianScalar(_id)) { + } + /// This is expected to overflow, networking logic should handle this case. + uint32_t id() const { + return flatbuffers::EndianScalar(id_); + } +}; +FLATBUFFERS_STRUCT_END(TransactionId, 4); + +/// Temperature in degrees celsius +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Temperature FLATBUFFERS_FINAL_CLASS { + private: + float temp_; + + public: + Temperature() + : temp_(0) { + } + Temperature(float _temp) + : temp_(flatbuffers::EndianScalar(_temp)) { + } + float temp() const { + return flatbuffers::EndianScalar(temp_); + } +}; +FLATBUFFERS_STRUCT_END(Temperature, 4); + +/// The 4 bytes of an ip address are stored in 32 bits in big endian order. +/// We will switch over to fixed size arrays when they are supported better. +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ipv4Address FLATBUFFERS_FINAL_CLASS { + private: + uint32_t addr_; + + public: + Ipv4Address() + : addr_(0) { + } + Ipv4Address(uint32_t _addr) + : addr_(flatbuffers::EndianScalar(_addr)) { + } + uint32_t addr() const { + return flatbuffers::EndianScalar(addr_); + } +}; +FLATBUFFERS_STRUCT_END(Ipv4Address, 4); + +namespace hardware_info { /// A MAC address or a bluetooth address, or some other uniquely identifying address /// associated with the endpoint that we are communicating with. If it doesn't take @@ -3335,102 +3315,6 @@ FLATBUFFERS_STRUCT_END(Vec3f, 12); } // namespace math -/// To be used inside unions -struct DeviceIdTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef DeviceIdTableBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4 - }; - const solarxr_protocol::datatypes::DeviceId *id() const { - return GetStruct(VT_ID); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ID, 1) && - verifier.EndTable(); - } -}; - -struct DeviceIdTableBuilder { - typedef DeviceIdTable Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_id(const solarxr_protocol::datatypes::DeviceId *id) { - fbb_.AddStruct(DeviceIdTable::VT_ID, id); - } - explicit DeviceIdTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateDeviceIdTable( - flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::DeviceId *id = nullptr) { - DeviceIdTableBuilder builder_(_fbb); - builder_.add_id(id); - return builder_.Finish(); -} - -struct TrackerId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackerIdBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICE_ID = 4, - VT_TRACKER_NUM = 6 - }; - /// The device the tracker is associated with. If there is no hardware device it is - /// associated with, this should be `null`. - const solarxr_protocol::datatypes::DeviceId *device_id() const { - return GetStruct(VT_DEVICE_ID); - } - /// There are possibly multiple trackers per device. This identifies which one. - uint8_t tracker_num() const { - return GetField(VT_TRACKER_NUM, 0); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_DEVICE_ID, 1) && - VerifyField(verifier, VT_TRACKER_NUM, 1) && - verifier.EndTable(); - } -}; - -struct TrackerIdBuilder { - typedef TrackerId Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_device_id(const solarxr_protocol::datatypes::DeviceId *device_id) { - fbb_.AddStruct(TrackerId::VT_DEVICE_ID, device_id); - } - void add_tracker_num(uint8_t tracker_num) { - fbb_.AddElement(TrackerId::VT_TRACKER_NUM, tracker_num, 0); - } - explicit TrackerIdBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateTrackerId( - flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::DeviceId *device_id = nullptr, - uint8_t tracker_num = 0) { - TrackerIdBuilder builder_(_fbb); - builder_.add_device_id(device_id); - builder_.add_tracker_num(tracker_num); - return builder_.Finish(); -} - /// General purpose logging datatype struct LogData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef LogDataBuilder Builder; @@ -3497,130 +3381,28 @@ inline flatbuffers::Offset CreateLogDataDirect( data__); } -struct Bytes FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef BytesBuilder Builder; +namespace hardware_info { + +/// Mostly static info about the device's hardware/firmware. +struct HardwareInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HardwareInfoBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_B = 4 + VT_MCU_ID = 4, + VT_DISPLAY_NAME = 6, + VT_MODEL = 8, + VT_MANUFACTURER = 10, + VT_HARDWARE_REVISION = 12, + VT_FIRMWARE_VERSION = 14, + VT_HARDWARE_ADDRESS = 16, + VT_IP_ADDRESS = 18, + VT_BOARD_TYPE = 20, + VT_OFFICIAL_BOARD_TYPE = 22, + VT_HARDWARE_IDENTIFIER = 24, + VT_NETWORK_PROTOCOL_VERSION = 26, + VT_FIRMWARE_DATE = 28 }; - const flatbuffers::Vector *b() const { - return GetPointer *>(VT_B); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_B) && - verifier.VerifyVector(b()) && - verifier.EndTable(); - } -}; - -struct BytesBuilder { - typedef Bytes Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_b(flatbuffers::Offset> b) { - fbb_.AddOffset(Bytes::VT_B, b); - } - explicit BytesBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateBytes( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> b = 0) { - BytesBuilder builder_(_fbb); - builder_.add_b(b); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateBytesDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *b = nullptr) { - auto b__ = b ? _fbb.CreateVector(*b) : 0; - return solarxr_protocol::datatypes::CreateBytes( - _fbb, - b__); -} - -struct StringTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StringTableBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_S = 4 - }; - const flatbuffers::String *s() const { - return GetPointer(VT_S); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_S) && - verifier.VerifyString(s()) && - verifier.EndTable(); - } -}; - -struct StringTableBuilder { - typedef StringTable Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_s(flatbuffers::Offset s) { - fbb_.AddOffset(StringTable::VT_S, s); - } - explicit StringTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateStringTable( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset s = 0) { - StringTableBuilder builder_(_fbb); - builder_.add_s(s); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateStringTableDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *s = nullptr) { - auto s__ = s ? _fbb.CreateString(s) : 0; - return solarxr_protocol::datatypes::CreateStringTable( - _fbb, - s__); -} - -namespace hardware_info { - -/// Mostly static info about the device's hardware/firmware. -struct HardwareInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HardwareInfoBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MCU_ID = 4, - VT_DISPLAY_NAME = 6, - VT_MODEL = 8, - VT_MANUFACTURER = 10, - VT_HARDWARE_REVISION = 12, - VT_FIRMWARE_VERSION = 14, - VT_HARDWARE_ADDRESS = 16, - VT_IP_ADDRESS = 18, - VT_BOARD_TYPE = 20, - VT_OFFICIAL_BOARD_TYPE = 22, - VT_HARDWARE_IDENTIFIER = 24, - VT_NETWORK_PROTOCOL_VERSION = 26, - VT_FIRMWARE_DATE = 28 - }; - solarxr_protocol::datatypes::hardware_info::McuType mcu_id() const { - return static_cast(GetField(VT_MCU_ID, 0)); + solarxr_protocol::datatypes::hardware_info::McuType mcu_id() const { + return static_cast(GetField(VT_MCU_ID, 0)); } /// A human-friendly name to display as the name of the device. const flatbuffers::String *display_name() const { @@ -3752,7 +3534,7 @@ struct HardwareInfoBuilder { inline flatbuffers::Offset CreateHardwareInfo( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::datatypes::hardware_info::McuType mcu_id = solarxr_protocol::datatypes::hardware_info::McuType::Other, + solarxr_protocol::datatypes::hardware_info::McuType mcu_id = solarxr_protocol::datatypes::hardware_info::McuType::UNKNOWN, flatbuffers::Offset display_name = 0, flatbuffers::Offset model = 0, flatbuffers::Offset manufacturer = 0, @@ -3784,7 +3566,7 @@ inline flatbuffers::Offset CreateHardwareInfo( inline flatbuffers::Offset CreateHardwareInfoDirect( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::datatypes::hardware_info::McuType mcu_id = solarxr_protocol::datatypes::hardware_info::McuType::Other, + solarxr_protocol::datatypes::hardware_info::McuType mcu_id = solarxr_protocol::datatypes::hardware_info::McuType::UNKNOWN, const char *display_name = nullptr, const char *model = nullptr, const char *manufacturer = nullptr, @@ -3827,16 +3609,16 @@ struct HardwareStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef HardwareStatusBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_ERROR_STATUS = 4, - VT_PING = 8, - VT_RSSI = 10, - VT_MCU_TEMP = 12, - VT_BATTERY_VOLTAGE = 14, - VT_BATTERY_PCT_ESTIMATE = 16, - VT_LOG_DATA = 18, - VT_PACKET_LOSS = 20, - VT_PACKETS_LOST = 22, - VT_PACKETS_RECEIVED = 24, - VT_BATTERY_RUNTIME_ESTIMATE = 26 + VT_PING = 6, + VT_RSSI = 8, + VT_MCU_TEMP = 10, + VT_BATTERY_VOLTAGE = 12, + VT_BATTERY_PCT_ESTIMATE = 14, + VT_LOG_DATA = 16, + VT_PACKET_LOSS = 18, + VT_PACKETS_LOST = 20, + VT_PACKETS_RECEIVED = 22, + VT_BATTERY_RUNTIME_ESTIMATE = 24 }; flatbuffers::Optional error_status() const { return GetOptional(VT_ERROR_STATUS); @@ -4230,7 +4012,7 @@ inline flatbuffers::Offset CreateStayAlignedTracker( } // namespace stay_aligned -namespace tracker { +namespace tracker_data { /// Describes all possible information about a tracker. A tracker is anything that /// provides kinematic data about a particular body part. @@ -4240,26 +4022,30 @@ namespace tracker { struct TrackerData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef TrackerDataBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4, - VT_INFO = 6, - VT_STATUS = 8, - VT_ROTATION = 10, - VT_POSITION = 12, - VT_RAW_ANGULAR_VELOCITY = 14, - VT_RAW_ACCELERATION = 16, - VT_TEMP = 18, - VT_LINEAR_ACCELERATION = 20, - VT_ROTATION_REFERENCE_ADJUSTED = 22, - VT_ROTATION_IDENTITY_ADJUSTED = 24, - VT_TPS = 26, - VT_RAW_MAGNETIC_VECTOR = 28, - VT_STAY_ALIGNED = 30 - }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); - } - const solarxr_protocol::data_feed::tracker::TrackerInfo *info() const { - return GetPointer(VT_INFO); + VT_DEVICE_ID = 4, + VT_TRACKER_ID = 6, + VT_INFO = 8, + VT_STATUS = 10, + VT_ROTATION = 12, + VT_POSITION = 14, + VT_RAW_ANGULAR_VELOCITY = 16, + VT_RAW_ACCELERATION = 18, + VT_TEMP = 20, + VT_LINEAR_ACCELERATION = 22, + VT_ROTATION_REFERENCE_ADJUSTED = 24, + VT_ROTATION_IDENTITY_ADJUSTED = 26, + VT_TPS = 28, + VT_RAW_MAGNETIC_VECTOR = 30, + VT_STAY_ALIGNED = 32 + }; + uint16_t device_id() const { + return GetField(VT_DEVICE_ID, 0); + } + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); + } + const solarxr_protocol::data_feed::tracker_data::TrackerInfo *info() const { + return GetPointer(VT_INFO); } solarxr_protocol::datatypes::TrackerStatus status() const { return static_cast(GetField(VT_STATUS, 0)); @@ -4268,7 +4054,7 @@ struct TrackerData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::datatypes::math::Quat *rotation() const { return GetStruct(VT_ROTATION); } - /// Position, in meters + /// Position in meters in OpenVR's space (left-handed, X+ Right, Y+ Up, Z- Forward) const solarxr_protocol::datatypes::math::Vec3f *position() const { return GetStruct(VT_POSITION); } @@ -4289,7 +4075,7 @@ struct TrackerData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { return GetStruct(VT_LINEAR_ACCELERATION); } /// Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - /// In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), + /// In other words, a rotation that is aligned to a reliable source of rotation (0, HMD YAW, 0), /// triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: mounting orientation, full, quick and mounting reset adjustments. @@ -4298,7 +4084,7 @@ struct TrackerData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { return GetStruct(VT_ROTATION_REFERENCE_ADJUSTED); } /// Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - /// In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by + /// In other words, a rotation that is aligned to a zero vector (0, 0, 0) by /// inverting the current rotation, triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: only full and quick reset adjustments. @@ -4320,8 +4106,8 @@ struct TrackerData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && + VerifyField(verifier, VT_DEVICE_ID, 2) && + VerifyField(verifier, VT_TRACKER_ID, 2) && VerifyOffset(verifier, VT_INFO) && verifier.VerifyTable(info()) && VerifyField(verifier, VT_STATUS, 1) && @@ -4345,10 +4131,13 @@ struct TrackerDataBuilder { typedef TrackerData Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(TrackerData::VT_TRACKER_ID, tracker_id); + void add_device_id(uint16_t device_id) { + fbb_.AddElement(TrackerData::VT_DEVICE_ID, device_id, 0); } - void add_info(flatbuffers::Offset info) { + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(TrackerData::VT_TRACKER_ID, tracker_id, 0); + } + void add_info(flatbuffers::Offset info) { fbb_.AddOffset(TrackerData::VT_INFO, info); } void add_status(solarxr_protocol::datatypes::TrackerStatus status) { @@ -4400,8 +4189,9 @@ struct TrackerDataBuilder { inline flatbuffers::Offset CreateTrackerData( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0, - flatbuffers::Offset info = 0, + uint16_t device_id = 0, + uint16_t tracker_id = 0, + flatbuffers::Offset info = 0, solarxr_protocol::datatypes::TrackerStatus status = solarxr_protocol::datatypes::TrackerStatus::NONE, const solarxr_protocol::datatypes::math::Quat *rotation = nullptr, const solarxr_protocol::datatypes::math::Vec3f *position = nullptr, @@ -4426,8 +4216,9 @@ inline flatbuffers::Offset CreateTrackerData( builder_.add_position(position); builder_.add_rotation(rotation); builder_.add_info(info); - builder_.add_tracker_id(tracker_id); if(tps) { builder_.add_tps(*tps); } + builder_.add_tracker_id(tracker_id); + builder_.add_device_id(device_id); builder_.add_status(status); return builder_.Finish(); } @@ -4607,11 +4398,10 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_IS_IMU = 16, VT_DISPLAY_NAME = 18, VT_CUSTOM_NAME = 20, - VT_ALLOW_DRIFT_COMPENSATION = 22, - VT_MOUNTING_RESET_ORIENTATION = 24, - VT_IS_HMD = 26, - VT_MAGNETOMETER = 28, - VT_DATA_SUPPORT = 30 + VT_MOUNTING_RESET_ORIENTATION = 22, + VT_IS_HMD = 24, + VT_MAGNETOMETER = 26, + VT_DATA_SUPPORT = 28 }; solarxr_protocol::datatypes::hardware_info::ImuType imu_type() const { return static_cast(GetField(VT_IMU_TYPE, 0)); @@ -4620,7 +4410,7 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { solarxr_protocol::datatypes::BodyPart body_part() const { return static_cast(GetField(VT_BODY_PART, 0)); } - /// average samples per second + /// Average samples per second const solarxr_protocol::datatypes::HzF32 *poll_rate() const { return GetStruct(VT_POLL_RATE); } @@ -4648,24 +4438,20 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const flatbuffers::String *custom_name() const { return GetPointer(VT_CUSTOM_NAME); } - /// Whether to allow yaw drift compensation for this tracker or not. - bool allow_drift_compensation() const { - return GetField(VT_ALLOW_DRIFT_COMPENSATION, 0) != 0; - } /// Mounting Reset orientation overrides the current `mounting_orientation` of /// the tracker, this orientation is not saved and needs to be calculated /// each time the server is ran const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation() const { return GetStruct(VT_MOUNTING_RESET_ORIENTATION); } - /// Indicates if the tracker is actually an HMD + /// Indicates if the tracker is actually a VR headset bool is_hmd() const { return GetField(VT_IS_HMD, 0) != 0; } solarxr_protocol::datatypes::MagnetometerStatus magnetometer() const { return static_cast(GetField(VT_MAGNETOMETER, 0)); } - /// Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) + /// Indicates what type of data the tracker sends (that gets transformed into a rotation) solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support() const { return static_cast(GetField(VT_DATA_SUPPORT, 0)); } @@ -4682,7 +4468,6 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyString(display_name()) && VerifyOffset(verifier, VT_CUSTOM_NAME) && verifier.VerifyString(custom_name()) && - VerifyField(verifier, VT_ALLOW_DRIFT_COMPENSATION, 1) && VerifyField(verifier, VT_MOUNTING_RESET_ORIENTATION, 4) && VerifyField(verifier, VT_IS_HMD, 1) && VerifyField(verifier, VT_MAGNETOMETER, 1) && @@ -4722,9 +4507,6 @@ struct TrackerInfoBuilder { void add_custom_name(flatbuffers::Offset custom_name) { fbb_.AddOffset(TrackerInfo::VT_CUSTOM_NAME, custom_name); } - void add_allow_drift_compensation(bool allow_drift_compensation) { - fbb_.AddElement(TrackerInfo::VT_ALLOW_DRIFT_COMPENSATION, static_cast(allow_drift_compensation), 0); - } void add_mounting_reset_orientation(const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation) { fbb_.AddStruct(TrackerInfo::VT_MOUNTING_RESET_ORIENTATION, mounting_reset_orientation); } @@ -4750,7 +4532,7 @@ struct TrackerInfoBuilder { inline flatbuffers::Offset CreateTrackerInfo( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::datatypes::hardware_info::ImuType imu_type = solarxr_protocol::datatypes::hardware_info::ImuType::Other, + solarxr_protocol::datatypes::hardware_info::ImuType imu_type = solarxr_protocol::datatypes::hardware_info::ImuType::UNKNOWN, solarxr_protocol::datatypes::BodyPart body_part = solarxr_protocol::datatypes::BodyPart::NONE, const solarxr_protocol::datatypes::HzF32 *poll_rate = nullptr, const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, @@ -4759,7 +4541,6 @@ inline flatbuffers::Offset CreateTrackerInfo( bool is_imu = false, flatbuffers::Offset display_name = 0, flatbuffers::Offset custom_name = 0, - bool allow_drift_compensation = false, const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr, bool is_hmd = false, solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED, @@ -4774,7 +4555,6 @@ inline flatbuffers::Offset CreateTrackerInfo( builder_.add_data_support(data_support); builder_.add_magnetometer(magnetometer); builder_.add_is_hmd(is_hmd); - builder_.add_allow_drift_compensation(allow_drift_compensation); builder_.add_is_imu(is_imu); builder_.add_is_computed(is_computed); builder_.add_editable(editable); @@ -4784,7 +4564,7 @@ inline flatbuffers::Offset CreateTrackerInfo( inline flatbuffers::Offset CreateTrackerInfoDirect( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::datatypes::hardware_info::ImuType imu_type = solarxr_protocol::datatypes::hardware_info::ImuType::Other, + solarxr_protocol::datatypes::hardware_info::ImuType imu_type = solarxr_protocol::datatypes::hardware_info::ImuType::UNKNOWN, solarxr_protocol::datatypes::BodyPart body_part = solarxr_protocol::datatypes::BodyPart::NONE, const solarxr_protocol::datatypes::HzF32 *poll_rate = nullptr, const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, @@ -4793,14 +4573,13 @@ inline flatbuffers::Offset CreateTrackerInfoDirect( bool is_imu = false, const char *display_name = nullptr, const char *custom_name = nullptr, - bool allow_drift_compensation = false, const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr, bool is_hmd = false, solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED, solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION) { auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0; auto custom_name__ = custom_name ? _fbb.CreateString(custom_name) : 0; - return solarxr_protocol::data_feed::tracker::CreateTrackerInfo( + return solarxr_protocol::data_feed::tracker_data::CreateTrackerInfo( _fbb, imu_type, body_part, @@ -4811,14 +4590,13 @@ inline flatbuffers::Offset CreateTrackerInfoDirect( is_imu, display_name__, custom_name__, - allow_drift_compensation, mounting_reset_orientation, is_hmd, magnetometer, data_support); } -} // namespace tracker +} // namespace tracker_data namespace device_data { @@ -4835,8 +4613,8 @@ struct DeviceDataMask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_DEVICE_DATA = 6 }; /// Which tracker data should be sent in this data feed - const solarxr_protocol::data_feed::tracker::TrackerDataMask *tracker_data() const { - return GetPointer(VT_TRACKER_DATA); + const solarxr_protocol::data_feed::tracker_data::TrackerDataMask *tracker_data() const { + return GetPointer(VT_TRACKER_DATA); } /// true if device data should be sent in this data feed bool device_data() const { @@ -4855,7 +4633,7 @@ struct DeviceDataMaskBuilder { typedef DeviceDataMask Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_data(flatbuffers::Offset tracker_data) { + void add_tracker_data(flatbuffers::Offset tracker_data) { fbb_.AddOffset(DeviceDataMask::VT_TRACKER_DATA, tracker_data); } void add_device_data(bool device_data) { @@ -4874,7 +4652,7 @@ struct DeviceDataMaskBuilder { inline flatbuffers::Offset CreateDeviceDataMask( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_data = 0, + flatbuffers::Offset tracker_data = 0, bool device_data = false) { DeviceDataMaskBuilder builder_(_fbb); builder_.add_tracker_data(tracker_data); @@ -4883,7 +4661,7 @@ inline flatbuffers::Offset CreateDeviceDataMask( } /// Describes all possible information about a hardware device. For example, a -/// vive tracker is a single hardware device, and a slime tracker with two +/// vive tracker is a single hardware device, and a slime tracker with two /// extensions is a single hardware device but two trackers. struct DeviceData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef DeviceDataBuilder Builder; @@ -4894,8 +4672,8 @@ struct DeviceData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_HARDWARE_STATUS = 10, VT_TRACKERS = 12 }; - const solarxr_protocol::datatypes::DeviceId *id() const { - return GetStruct(VT_ID); + uint16_t id() const { + return GetField(VT_ID, 0); } /// The dynamically changeable name of the device. This might be set by the /// user to help them remember which tracker is which. @@ -4911,12 +4689,12 @@ struct DeviceData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { return GetPointer(VT_HARDWARE_STATUS); } /// Info about all trackers attached to this device - const flatbuffers::Vector> *trackers() const { - return GetPointer> *>(VT_TRACKERS); + const flatbuffers::Vector> *trackers() const { + return GetPointer> *>(VT_TRACKERS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ID, 1) && + VerifyField(verifier, VT_ID, 2) && VerifyOffset(verifier, VT_CUSTOM_NAME) && verifier.VerifyString(custom_name()) && VerifyOffset(verifier, VT_HARDWARE_INFO) && @@ -4934,8 +4712,8 @@ struct DeviceDataBuilder { typedef DeviceData Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_id(const solarxr_protocol::datatypes::DeviceId *id) { - fbb_.AddStruct(DeviceData::VT_ID, id); + void add_id(uint16_t id) { + fbb_.AddElement(DeviceData::VT_ID, id, 0); } void add_custom_name(flatbuffers::Offset custom_name) { fbb_.AddOffset(DeviceData::VT_CUSTOM_NAME, custom_name); @@ -4946,7 +4724,7 @@ struct DeviceDataBuilder { void add_hardware_status(flatbuffers::Offset hardware_status) { fbb_.AddOffset(DeviceData::VT_HARDWARE_STATUS, hardware_status); } - void add_trackers(flatbuffers::Offset>> trackers) { + void add_trackers(flatbuffers::Offset>> trackers) { fbb_.AddOffset(DeviceData::VT_TRACKERS, trackers); } explicit DeviceDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -4962,11 +4740,11 @@ struct DeviceDataBuilder { inline flatbuffers::Offset CreateDeviceData( flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::DeviceId *id = nullptr, + uint16_t id = 0, flatbuffers::Offset custom_name = 0, flatbuffers::Offset hardware_info = 0, flatbuffers::Offset hardware_status = 0, - flatbuffers::Offset>> trackers = 0) { + flatbuffers::Offset>> trackers = 0) { DeviceDataBuilder builder_(_fbb); builder_.add_trackers(trackers); builder_.add_hardware_status(hardware_status); @@ -4978,13 +4756,13 @@ inline flatbuffers::Offset CreateDeviceData( inline flatbuffers::Offset CreateDeviceDataDirect( flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::DeviceId *id = nullptr, + uint16_t id = 0, const char *custom_name = nullptr, flatbuffers::Offset hardware_info = 0, flatbuffers::Offset hardware_status = 0, - const std::vector> *trackers = nullptr) { + const std::vector> *trackers = nullptr) { auto custom_name__ = custom_name ? _fbb.CreateString(custom_name) : 0; - auto trackers__ = trackers ? _fbb.CreateVector>(*trackers) : 0; + auto trackers__ = trackers ? _fbb.CreateVector>(*trackers) : 0; return solarxr_protocol::data_feed::device_data::CreateDeviceData( _fbb, id, @@ -5077,27 +4855,31 @@ inline flatbuffers::Offset CreateBone( namespace server { +/// Contains various of flags / guards that inform the GUI +/// about possible actions or blocked states. +/// The idea is to have one source of truth for all these rules +/// that are spread accross the GUI. struct ServerGuards FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ServerGuardsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CANDOMOUNTING = 4, - VT_CANDOYAWRESET = 6, - VT_CANDOUSERHEIGHTCALIBRATION = 8 + VT_CAN_DO_MOUNTING_RESET = 4, + VT_CAN_DO_YAW_RESET = 6, + VT_CAN_DO_USER_HEIGHT_CALIBRATION = 8 }; - bool canDoMounting() const { - return GetField(VT_CANDOMOUNTING, 0) != 0; + bool can_do_mounting_reset() const { + return GetField(VT_CAN_DO_MOUNTING_RESET, 0) != 0; } - bool canDoYawReset() const { - return GetField(VT_CANDOYAWRESET, 0) != 0; + bool can_do_yaw_reset() const { + return GetField(VT_CAN_DO_YAW_RESET, 0) != 0; } - bool canDoUserHeightCalibration() const { - return GetField(VT_CANDOUSERHEIGHTCALIBRATION, 0) != 0; + bool can_do_user_height_calibration() const { + return GetField(VT_CAN_DO_USER_HEIGHT_CALIBRATION, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_CANDOMOUNTING, 1) && - VerifyField(verifier, VT_CANDOYAWRESET, 1) && - VerifyField(verifier, VT_CANDOUSERHEIGHTCALIBRATION, 1) && + VerifyField(verifier, VT_CAN_DO_MOUNTING_RESET, 1) && + VerifyField(verifier, VT_CAN_DO_YAW_RESET, 1) && + VerifyField(verifier, VT_CAN_DO_USER_HEIGHT_CALIBRATION, 1) && verifier.EndTable(); } }; @@ -5106,14 +4888,14 @@ struct ServerGuardsBuilder { typedef ServerGuards Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_canDoMounting(bool canDoMounting) { - fbb_.AddElement(ServerGuards::VT_CANDOMOUNTING, static_cast(canDoMounting), 0); + void add_can_do_mounting_reset(bool can_do_mounting_reset) { + fbb_.AddElement(ServerGuards::VT_CAN_DO_MOUNTING_RESET, static_cast(can_do_mounting_reset), 0); } - void add_canDoYawReset(bool canDoYawReset) { - fbb_.AddElement(ServerGuards::VT_CANDOYAWRESET, static_cast(canDoYawReset), 0); + void add_can_do_yaw_reset(bool can_do_yaw_reset) { + fbb_.AddElement(ServerGuards::VT_CAN_DO_YAW_RESET, static_cast(can_do_yaw_reset), 0); } - void add_canDoUserHeightCalibration(bool canDoUserHeightCalibration) { - fbb_.AddElement(ServerGuards::VT_CANDOUSERHEIGHTCALIBRATION, static_cast(canDoUserHeightCalibration), 0); + void add_can_do_user_height_calibration(bool can_do_user_height_calibration) { + fbb_.AddElement(ServerGuards::VT_CAN_DO_USER_HEIGHT_CALIBRATION, static_cast(can_do_user_height_calibration), 0); } explicit ServerGuardsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { @@ -5128,13 +4910,13 @@ struct ServerGuardsBuilder { inline flatbuffers::Offset CreateServerGuards( flatbuffers::FlatBufferBuilder &_fbb, - bool canDoMounting = false, - bool canDoYawReset = false, - bool canDoUserHeightCalibration = false) { + bool can_do_mounting_reset = false, + bool can_do_yaw_reset = false, + bool can_do_user_height_calibration = false) { ServerGuardsBuilder builder_(_fbb); - builder_.add_canDoUserHeightCalibration(canDoUserHeightCalibration); - builder_.add_canDoYawReset(canDoYawReset); - builder_.add_canDoMounting(canDoMounting); + builder_.add_can_do_user_height_calibration(can_do_user_height_calibration); + builder_.add_can_do_yaw_reset(can_do_yaw_reset); + builder_.add_can_do_mounting_reset(can_do_mounting_reset); return builder_.Finish(); } @@ -5345,8 +5127,8 @@ struct DataFeedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const flatbuffers::Vector> *devices() const { return GetPointer> *>(VT_DEVICES); } - const flatbuffers::Vector> *synthetic_trackers() const { - return GetPointer> *>(VT_SYNTHETIC_TRACKERS); + const flatbuffers::Vector> *synthetic_trackers() const { + return GetPointer> *>(VT_SYNTHETIC_TRACKERS); } /// This must represent a set, where there is no more than one bone for a `BodyPart`. const flatbuffers::Vector> *bones() const { @@ -5355,6 +5137,7 @@ struct DataFeedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::data_feed::stay_aligned::StayAlignedPose *stay_aligned_pose() const { return GetPointer(VT_STAY_ALIGNED_POSE); } + /// gives the index of the datafeed config that initiated the update uint8_t index() const { return GetField(VT_INDEX, 0); } @@ -5388,7 +5171,7 @@ struct DataFeedUpdateBuilder { void add_devices(flatbuffers::Offset>> devices) { fbb_.AddOffset(DataFeedUpdate::VT_DEVICES, devices); } - void add_synthetic_trackers(flatbuffers::Offset>> synthetic_trackers) { + void add_synthetic_trackers(flatbuffers::Offset>> synthetic_trackers) { fbb_.AddOffset(DataFeedUpdate::VT_SYNTHETIC_TRACKERS, synthetic_trackers); } void add_bones(flatbuffers::Offset>> bones) { @@ -5417,7 +5200,7 @@ struct DataFeedUpdateBuilder { inline flatbuffers::Offset CreateDataFeedUpdate( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset>> devices = 0, - flatbuffers::Offset>> synthetic_trackers = 0, + flatbuffers::Offset>> synthetic_trackers = 0, flatbuffers::Offset>> bones = 0, flatbuffers::Offset stay_aligned_pose = 0, uint8_t index = 0, @@ -5435,13 +5218,13 @@ inline flatbuffers::Offset CreateDataFeedUpdate( inline flatbuffers::Offset CreateDataFeedUpdateDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector> *devices = nullptr, - const std::vector> *synthetic_trackers = nullptr, + const std::vector> *synthetic_trackers = nullptr, const std::vector> *bones = nullptr, flatbuffers::Offset stay_aligned_pose = 0, uint8_t index = 0, flatbuffers::Offset server_guards = 0) { auto devices__ = devices ? _fbb.CreateVector>(*devices) : 0; - auto synthetic_trackers__ = synthetic_trackers ? _fbb.CreateVector>(*synthetic_trackers) : 0; + auto synthetic_trackers__ = synthetic_trackers ? _fbb.CreateVector>(*synthetic_trackers) : 0; auto bones__ = bones ? _fbb.CreateVector>(*bones) : 0; return solarxr_protocol::data_feed::CreateDataFeedUpdate( _fbb, @@ -5473,8 +5256,8 @@ struct DataFeedConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::data_feed::device_data::DeviceDataMask *data_mask() const { return GetPointer(VT_DATA_MASK); } - const solarxr_protocol::data_feed::tracker::TrackerDataMask *synthetic_trackers_mask() const { - return GetPointer(VT_SYNTHETIC_TRACKERS_MASK); + const solarxr_protocol::data_feed::tracker_data::TrackerDataMask *synthetic_trackers_mask() const { + return GetPointer(VT_SYNTHETIC_TRACKERS_MASK); } bool bone_mask() const { return GetField(VT_BONE_MASK, 0) != 0; @@ -5509,7 +5292,7 @@ struct DataFeedConfigBuilder { void add_data_mask(flatbuffers::Offset data_mask) { fbb_.AddOffset(DataFeedConfig::VT_DATA_MASK, data_mask); } - void add_synthetic_trackers_mask(flatbuffers::Offset synthetic_trackers_mask) { + void add_synthetic_trackers_mask(flatbuffers::Offset synthetic_trackers_mask) { fbb_.AddOffset(DataFeedConfig::VT_SYNTHETIC_TRACKERS_MASK, synthetic_trackers_mask); } void add_bone_mask(bool bone_mask) { @@ -5536,7 +5319,7 @@ inline flatbuffers::Offset CreateDataFeedConfig( flatbuffers::FlatBufferBuilder &_fbb, uint16_t minimum_time_since_last = 0, flatbuffers::Offset data_mask = 0, - flatbuffers::Offset synthetic_trackers_mask = 0, + flatbuffers::Offset synthetic_trackers_mask = 0, bool bone_mask = false, bool stay_aligned_pose_mask = false, bool server_guards_mask = false) { @@ -5553,1547 +5336,1767 @@ inline flatbuffers::Offset CreateDataFeedConfig( } // namespace data_feed namespace rpc { -namespace settings { -/// Settings for the skeletal model that are toggles. -struct ModelToggles FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ModelTogglesBuilder Builder; +struct AutoBoneProcessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneProcessRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_EXTENDED_SPINE = 4, - VT_EXTENDED_PELVIS = 6, - VT_EXTENDED_KNEE = 8, - VT_FORCE_ARMS_FROM_HMD = 10, - VT_FLOOR_CLIP = 12, - VT_SKATING_CORRECTION = 14, - VT_TOE_SNAP = 18, - VT_FOOT_PLANT = 20, - VT_SELF_LOCALIZATION = 22, - VT_USE_POSITION = 24, - VT_ENFORCE_CONSTRAINTS = 26, - VT_CORRECT_CONSTRAINTS = 28 - }; - flatbuffers::Optional extended_spine() const { - return GetOptional(VT_EXTENDED_SPINE); - } - flatbuffers::Optional extended_pelvis() const { - return GetOptional(VT_EXTENDED_PELVIS); - } - flatbuffers::Optional extended_knee() const { - return GetOptional(VT_EXTENDED_KNEE); - } - flatbuffers::Optional force_arms_from_hmd() const { - return GetOptional(VT_FORCE_ARMS_FROM_HMD); - } - flatbuffers::Optional floor_clip() const { - return GetOptional(VT_FLOOR_CLIP); - } - flatbuffers::Optional skating_correction() const { - return GetOptional(VT_SKATING_CORRECTION); - } - flatbuffers::Optional toe_snap() const { - return GetOptional(VT_TOE_SNAP); - } - flatbuffers::Optional foot_plant() const { - return GetOptional(VT_FOOT_PLANT); - } - flatbuffers::Optional self_localization() const { - return GetOptional(VT_SELF_LOCALIZATION); - } - flatbuffers::Optional use_position() const { - return GetOptional(VT_USE_POSITION); - } - flatbuffers::Optional enforce_constraints() const { - return GetOptional(VT_ENFORCE_CONSTRAINTS); - } - flatbuffers::Optional correct_constraints() const { - return GetOptional(VT_CORRECT_CONSTRAINTS); + VT_PROCESS_TYPE = 4 + }; + solarxr_protocol::rpc::AutoBoneProcessType process_type() const { + return static_cast(GetField(VT_PROCESS_TYPE, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_EXTENDED_SPINE, 1) && - VerifyField(verifier, VT_EXTENDED_PELVIS, 1) && - VerifyField(verifier, VT_EXTENDED_KNEE, 1) && - VerifyField(verifier, VT_FORCE_ARMS_FROM_HMD, 1) && - VerifyField(verifier, VT_FLOOR_CLIP, 1) && - VerifyField(verifier, VT_SKATING_CORRECTION, 1) && - VerifyField(verifier, VT_TOE_SNAP, 1) && - VerifyField(verifier, VT_FOOT_PLANT, 1) && - VerifyField(verifier, VT_SELF_LOCALIZATION, 1) && - VerifyField(verifier, VT_USE_POSITION, 1) && - VerifyField(verifier, VT_ENFORCE_CONSTRAINTS, 1) && - VerifyField(verifier, VT_CORRECT_CONSTRAINTS, 1) && + VerifyField(verifier, VT_PROCESS_TYPE, 1) && verifier.EndTable(); } }; -struct ModelTogglesBuilder { - typedef ModelToggles Table; +struct AutoBoneProcessRequestBuilder { + typedef AutoBoneProcessRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_extended_spine(bool extended_spine) { - fbb_.AddElement(ModelToggles::VT_EXTENDED_SPINE, static_cast(extended_spine)); - } - void add_extended_pelvis(bool extended_pelvis) { - fbb_.AddElement(ModelToggles::VT_EXTENDED_PELVIS, static_cast(extended_pelvis)); - } - void add_extended_knee(bool extended_knee) { - fbb_.AddElement(ModelToggles::VT_EXTENDED_KNEE, static_cast(extended_knee)); - } - void add_force_arms_from_hmd(bool force_arms_from_hmd) { - fbb_.AddElement(ModelToggles::VT_FORCE_ARMS_FROM_HMD, static_cast(force_arms_from_hmd)); - } - void add_floor_clip(bool floor_clip) { - fbb_.AddElement(ModelToggles::VT_FLOOR_CLIP, static_cast(floor_clip)); - } - void add_skating_correction(bool skating_correction) { - fbb_.AddElement(ModelToggles::VT_SKATING_CORRECTION, static_cast(skating_correction)); - } - void add_toe_snap(bool toe_snap) { - fbb_.AddElement(ModelToggles::VT_TOE_SNAP, static_cast(toe_snap)); - } - void add_foot_plant(bool foot_plant) { - fbb_.AddElement(ModelToggles::VT_FOOT_PLANT, static_cast(foot_plant)); - } - void add_self_localization(bool self_localization) { - fbb_.AddElement(ModelToggles::VT_SELF_LOCALIZATION, static_cast(self_localization)); - } - void add_use_position(bool use_position) { - fbb_.AddElement(ModelToggles::VT_USE_POSITION, static_cast(use_position)); - } - void add_enforce_constraints(bool enforce_constraints) { - fbb_.AddElement(ModelToggles::VT_ENFORCE_CONSTRAINTS, static_cast(enforce_constraints)); - } - void add_correct_constraints(bool correct_constraints) { - fbb_.AddElement(ModelToggles::VT_CORRECT_CONSTRAINTS, static_cast(correct_constraints)); + void add_process_type(solarxr_protocol::rpc::AutoBoneProcessType process_type) { + fbb_.AddElement(AutoBoneProcessRequest::VT_PROCESS_TYPE, static_cast(process_type), 0); } - explicit ModelTogglesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AutoBoneProcessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateModelToggles( +inline flatbuffers::Offset CreateAutoBoneProcessRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional extended_spine = flatbuffers::nullopt, - flatbuffers::Optional extended_pelvis = flatbuffers::nullopt, - flatbuffers::Optional extended_knee = flatbuffers::nullopt, - flatbuffers::Optional force_arms_from_hmd = flatbuffers::nullopt, - flatbuffers::Optional floor_clip = flatbuffers::nullopt, - flatbuffers::Optional skating_correction = flatbuffers::nullopt, - flatbuffers::Optional toe_snap = flatbuffers::nullopt, - flatbuffers::Optional foot_plant = flatbuffers::nullopt, - flatbuffers::Optional self_localization = flatbuffers::nullopt, - flatbuffers::Optional use_position = flatbuffers::nullopt, - flatbuffers::Optional enforce_constraints = flatbuffers::nullopt, - flatbuffers::Optional correct_constraints = flatbuffers::nullopt) { - ModelTogglesBuilder builder_(_fbb); - if(correct_constraints) { builder_.add_correct_constraints(*correct_constraints); } - if(enforce_constraints) { builder_.add_enforce_constraints(*enforce_constraints); } - if(use_position) { builder_.add_use_position(*use_position); } - if(self_localization) { builder_.add_self_localization(*self_localization); } - if(foot_plant) { builder_.add_foot_plant(*foot_plant); } - if(toe_snap) { builder_.add_toe_snap(*toe_snap); } - if(skating_correction) { builder_.add_skating_correction(*skating_correction); } - if(floor_clip) { builder_.add_floor_clip(*floor_clip); } - if(force_arms_from_hmd) { builder_.add_force_arms_from_hmd(*force_arms_from_hmd); } - if(extended_knee) { builder_.add_extended_knee(*extended_knee); } - if(extended_pelvis) { builder_.add_extended_pelvis(*extended_pelvis); } - if(extended_spine) { builder_.add_extended_spine(*extended_spine); } + solarxr_protocol::rpc::AutoBoneProcessType process_type = solarxr_protocol::rpc::AutoBoneProcessType::NONE) { + AutoBoneProcessRequestBuilder builder_(_fbb); + builder_.add_process_type(process_type); return builder_.Finish(); } -/// Settings for the skeletal model that are ratios. -/// These values range from 0 to 1. -struct ModelRatios FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ModelRatiosBuilder Builder; +struct AutoBoneProcessStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneProcessStatusResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_IMPUTE_WAIST_FROM_CHEST_HIP = 4, - VT_IMPUTE_WAIST_FROM_CHEST_LEGS = 6, - VT_IMPUTE_HIP_FROM_CHEST_LEGS = 8, - VT_IMPUTE_HIP_FROM_WAIST_LEGS = 10, - VT_INTERP_HIP_LEGS = 12, - VT_INTERP_KNEE_TRACKER_ANKLE = 14, - VT_INTERP_KNEE_ANKLE = 16 + VT_PROCESS_TYPE = 4, + VT_CURRENT = 6, + VT_TOTAL = 8, + VT_COMPLETED = 10, + VT_SUCCESS = 12, + VT_ETA = 14 }; - flatbuffers::Optional impute_waist_from_chest_hip() const { - return GetOptional(VT_IMPUTE_WAIST_FROM_CHEST_HIP); - } - flatbuffers::Optional impute_waist_from_chest_legs() const { - return GetOptional(VT_IMPUTE_WAIST_FROM_CHEST_LEGS); + solarxr_protocol::rpc::AutoBoneProcessType process_type() const { + return static_cast(GetField(VT_PROCESS_TYPE, 0)); } - flatbuffers::Optional impute_hip_from_chest_legs() const { - return GetOptional(VT_IMPUTE_HIP_FROM_CHEST_LEGS); + /// The current count. This value is -1 if there is nothing to report. + uint32_t current() const { + return GetField(VT_CURRENT, 0); } - flatbuffers::Optional impute_hip_from_waist_legs() const { - return GetOptional(VT_IMPUTE_HIP_FROM_WAIST_LEGS); + /// The total count. This value is -1 if there is nothing to report. + uint32_t total() const { + return GetField(VT_TOTAL, 0); } - /// Hip's yaw and roll is set to the average of legs when 1.0 - flatbuffers::Optional interp_hip_legs() const { - return GetOptional(VT_INTERP_HIP_LEGS); + /// True if the operation has completed with any result, successful or not. + bool completed() const { + return GetField(VT_COMPLETED, 0) != 0; } - /// Knee trackers' yaw and roll is set to the lower leg's when 1.0 - flatbuffers::Optional interp_knee_tracker_ankle() const { - return GetOptional(VT_INTERP_KNEE_TRACKER_ANKLE); + /// True if the completed operation was successful, only observe if `completed` is true. + bool success() const { + return GetField(VT_SUCCESS, 0) != 0; } - /// Upper leg's yaw and roll is set to the lower leg's when 1.0 - flatbuffers::Optional interp_knee_ankle() const { - return GetOptional(VT_INTERP_KNEE_ANKLE); + /// The time remaining in seconds. This value is -1 if there is nothing to report. + float eta() const { + return GetField(VT_ETA, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_IMPUTE_WAIST_FROM_CHEST_HIP, 4) && - VerifyField(verifier, VT_IMPUTE_WAIST_FROM_CHEST_LEGS, 4) && - VerifyField(verifier, VT_IMPUTE_HIP_FROM_CHEST_LEGS, 4) && - VerifyField(verifier, VT_IMPUTE_HIP_FROM_WAIST_LEGS, 4) && - VerifyField(verifier, VT_INTERP_HIP_LEGS, 4) && - VerifyField(verifier, VT_INTERP_KNEE_TRACKER_ANKLE, 4) && - VerifyField(verifier, VT_INTERP_KNEE_ANKLE, 4) && + VerifyField(verifier, VT_PROCESS_TYPE, 1) && + VerifyField(verifier, VT_CURRENT, 4) && + VerifyField(verifier, VT_TOTAL, 4) && + VerifyField(verifier, VT_COMPLETED, 1) && + VerifyField(verifier, VT_SUCCESS, 1) && + VerifyField(verifier, VT_ETA, 4) && verifier.EndTable(); } }; -struct ModelRatiosBuilder { - typedef ModelRatios Table; +struct AutoBoneProcessStatusResponseBuilder { + typedef AutoBoneProcessStatusResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_impute_waist_from_chest_hip(float impute_waist_from_chest_hip) { - fbb_.AddElement(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_HIP, impute_waist_from_chest_hip); - } - void add_impute_waist_from_chest_legs(float impute_waist_from_chest_legs) { - fbb_.AddElement(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_LEGS, impute_waist_from_chest_legs); + void add_process_type(solarxr_protocol::rpc::AutoBoneProcessType process_type) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_PROCESS_TYPE, static_cast(process_type), 0); } - void add_impute_hip_from_chest_legs(float impute_hip_from_chest_legs) { - fbb_.AddElement(ModelRatios::VT_IMPUTE_HIP_FROM_CHEST_LEGS, impute_hip_from_chest_legs); + void add_current(uint32_t current) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_CURRENT, current, 0); } - void add_impute_hip_from_waist_legs(float impute_hip_from_waist_legs) { - fbb_.AddElement(ModelRatios::VT_IMPUTE_HIP_FROM_WAIST_LEGS, impute_hip_from_waist_legs); + void add_total(uint32_t total) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_TOTAL, total, 0); } - void add_interp_hip_legs(float interp_hip_legs) { - fbb_.AddElement(ModelRatios::VT_INTERP_HIP_LEGS, interp_hip_legs); + void add_completed(bool completed) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_COMPLETED, static_cast(completed), 0); } - void add_interp_knee_tracker_ankle(float interp_knee_tracker_ankle) { - fbb_.AddElement(ModelRatios::VT_INTERP_KNEE_TRACKER_ANKLE, interp_knee_tracker_ankle); + void add_success(bool success) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_SUCCESS, static_cast(success), 0); } - void add_interp_knee_ankle(float interp_knee_ankle) { - fbb_.AddElement(ModelRatios::VT_INTERP_KNEE_ANKLE, interp_knee_ankle); + void add_eta(float eta) { + fbb_.AddElement(AutoBoneProcessStatusResponse::VT_ETA, eta, 0.0f); } - explicit ModelRatiosBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AutoBoneProcessStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateModelRatios( +inline flatbuffers::Offset CreateAutoBoneProcessStatusResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional impute_waist_from_chest_hip = flatbuffers::nullopt, - flatbuffers::Optional impute_waist_from_chest_legs = flatbuffers::nullopt, - flatbuffers::Optional impute_hip_from_chest_legs = flatbuffers::nullopt, - flatbuffers::Optional impute_hip_from_waist_legs = flatbuffers::nullopt, - flatbuffers::Optional interp_hip_legs = flatbuffers::nullopt, - flatbuffers::Optional interp_knee_tracker_ankle = flatbuffers::nullopt, - flatbuffers::Optional interp_knee_ankle = flatbuffers::nullopt) { - ModelRatiosBuilder builder_(_fbb); - if(interp_knee_ankle) { builder_.add_interp_knee_ankle(*interp_knee_ankle); } - if(interp_knee_tracker_ankle) { builder_.add_interp_knee_tracker_ankle(*interp_knee_tracker_ankle); } - if(interp_hip_legs) { builder_.add_interp_hip_legs(*interp_hip_legs); } - if(impute_hip_from_waist_legs) { builder_.add_impute_hip_from_waist_legs(*impute_hip_from_waist_legs); } - if(impute_hip_from_chest_legs) { builder_.add_impute_hip_from_chest_legs(*impute_hip_from_chest_legs); } - if(impute_waist_from_chest_legs) { builder_.add_impute_waist_from_chest_legs(*impute_waist_from_chest_legs); } - if(impute_waist_from_chest_hip) { builder_.add_impute_waist_from_chest_hip(*impute_waist_from_chest_hip); } - return builder_.Finish(); -} - -struct LegTweaksSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef LegTweaksSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CORRECTION_STRENGTH = 4 - }; - flatbuffers::Optional correction_strength() const { - return GetOptional(VT_CORRECTION_STRENGTH); - } - bool Verify(flatbuffers::Verifier &verifier) const { + solarxr_protocol::rpc::AutoBoneProcessType process_type = solarxr_protocol::rpc::AutoBoneProcessType::NONE, + uint32_t current = 0, + uint32_t total = 0, + bool completed = false, + bool success = false, + float eta = 0.0f) { + AutoBoneProcessStatusResponseBuilder builder_(_fbb); + builder_.add_eta(eta); + builder_.add_total(total); + builder_.add_current(current); + builder_.add_success(success); + builder_.add_completed(completed); + builder_.add_process_type(process_type); + return builder_.Finish(); +} + +struct AutoBoneEpochResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneEpochResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CURRENT_EPOCH = 4, + VT_TOTAL_EPOCHS = 6, + VT_EPOCH_ERROR = 8, + VT_ADJUSTED_SKELETON_PARTS = 10 + }; + uint32_t current_epoch() const { + return GetField(VT_CURRENT_EPOCH, 0); + } + uint32_t total_epochs() const { + return GetField(VT_TOTAL_EPOCHS, 0); + } + /// The current error value. This can be any positive number, where lower is better. + float epoch_error() const { + return GetField(VT_EPOCH_ERROR, 0.0f); + } + /// A list of the current estimated body proportions. + const flatbuffers::Vector> *adjusted_skeleton_parts() const { + return GetPointer> *>(VT_ADJUSTED_SKELETON_PARTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_CORRECTION_STRENGTH, 4) && + VerifyField(verifier, VT_CURRENT_EPOCH, 4) && + VerifyField(verifier, VT_TOTAL_EPOCHS, 4) && + VerifyField(verifier, VT_EPOCH_ERROR, 4) && + VerifyOffset(verifier, VT_ADJUSTED_SKELETON_PARTS) && + verifier.VerifyVector(adjusted_skeleton_parts()) && + verifier.VerifyVectorOfTables(adjusted_skeleton_parts()) && verifier.EndTable(); } }; -struct LegTweaksSettingsBuilder { - typedef LegTweaksSettings Table; +struct AutoBoneEpochResponseBuilder { + typedef AutoBoneEpochResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_correction_strength(float correction_strength) { - fbb_.AddElement(LegTweaksSettings::VT_CORRECTION_STRENGTH, correction_strength); + void add_current_epoch(uint32_t current_epoch) { + fbb_.AddElement(AutoBoneEpochResponse::VT_CURRENT_EPOCH, current_epoch, 0); + } + void add_total_epochs(uint32_t total_epochs) { + fbb_.AddElement(AutoBoneEpochResponse::VT_TOTAL_EPOCHS, total_epochs, 0); + } + void add_epoch_error(float epoch_error) { + fbb_.AddElement(AutoBoneEpochResponse::VT_EPOCH_ERROR, epoch_error, 0.0f); + } + void add_adjusted_skeleton_parts(flatbuffers::Offset>> adjusted_skeleton_parts) { + fbb_.AddOffset(AutoBoneEpochResponse::VT_ADJUSTED_SKELETON_PARTS, adjusted_skeleton_parts); } - explicit LegTweaksSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AutoBoneEpochResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLegTweaksSettings( +inline flatbuffers::Offset CreateAutoBoneEpochResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional correction_strength = flatbuffers::nullopt) { - LegTweaksSettingsBuilder builder_(_fbb); - if(correction_strength) { builder_.add_correction_strength(*correction_strength); } + uint32_t current_epoch = 0, + uint32_t total_epochs = 0, + float epoch_error = 0.0f, + flatbuffers::Offset>> adjusted_skeleton_parts = 0) { + AutoBoneEpochResponseBuilder builder_(_fbb); + builder_.add_adjusted_skeleton_parts(adjusted_skeleton_parts); + builder_.add_epoch_error(epoch_error); + builder_.add_total_epochs(total_epochs); + builder_.add_current_epoch(current_epoch); return builder_.Finish(); } -struct SkeletonHeight FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SkeletonHeightBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_HMD_HEIGHT = 4, - VT_FLOOR_HEIGHT = 6 - }; - flatbuffers::Optional hmd_height() const { - return GetOptional(VT_HMD_HEIGHT); - } - flatbuffers::Optional floor_height() const { - return GetOptional(VT_FLOOR_HEIGHT); - } +inline flatbuffers::Offset CreateAutoBoneEpochResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + uint32_t current_epoch = 0, + uint32_t total_epochs = 0, + float epoch_error = 0.0f, + const std::vector> *adjusted_skeleton_parts = nullptr) { + auto adjusted_skeleton_parts__ = adjusted_skeleton_parts ? _fbb.CreateVector>(*adjusted_skeleton_parts) : 0; + return solarxr_protocol::rpc::CreateAutoBoneEpochResponse( + _fbb, + current_epoch, + total_epochs, + epoch_error, + adjusted_skeleton_parts__); +} + +/// Applies the estimated proportions +struct AutoBoneApplyRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneApplyRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_HMD_HEIGHT, 4) && - VerifyField(verifier, VT_FLOOR_HEIGHT, 4) && verifier.EndTable(); } }; -struct SkeletonHeightBuilder { - typedef SkeletonHeight Table; +struct AutoBoneApplyRequestBuilder { + typedef AutoBoneApplyRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_hmd_height(float hmd_height) { - fbb_.AddElement(SkeletonHeight::VT_HMD_HEIGHT, hmd_height); - } - void add_floor_height(float floor_height) { - fbb_.AddElement(SkeletonHeight::VT_FLOOR_HEIGHT, floor_height); - } - explicit SkeletonHeightBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AutoBoneApplyRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkeletonHeight( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional hmd_height = flatbuffers::nullopt, - flatbuffers::Optional floor_height = flatbuffers::nullopt) { - SkeletonHeightBuilder builder_(_fbb); - if(floor_height) { builder_.add_floor_height(*floor_height); } - if(hmd_height) { builder_.add_hmd_height(*hmd_height); } +inline flatbuffers::Offset CreateAutoBoneApplyRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + AutoBoneApplyRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Settings for the skeletal model. -struct ModelSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ModelSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TOGGLES = 4, - VT_RATIOS = 6, - VT_LEG_TWEAKS = 8, - VT_SKELETON_HEIGHT = 10 - }; - const solarxr_protocol::rpc::settings::ModelToggles *toggles() const { - return GetPointer(VT_TOGGLES); - } - const solarxr_protocol::rpc::settings::ModelRatios *ratios() const { - return GetPointer(VT_RATIOS); - } - const solarxr_protocol::rpc::settings::LegTweaksSettings *leg_tweaks() const { - return GetPointer(VT_LEG_TWEAKS); - } - const solarxr_protocol::rpc::settings::SkeletonHeight *skeleton_height() const { - return GetPointer(VT_SKELETON_HEIGHT); - } +/// Stops the current recording, using it as far as it has been recorded +struct AutoBoneStopRecordingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneStopRecordingRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TOGGLES) && - verifier.VerifyTable(toggles()) && - VerifyOffset(verifier, VT_RATIOS) && - verifier.VerifyTable(ratios()) && - VerifyOffset(verifier, VT_LEG_TWEAKS) && - verifier.VerifyTable(leg_tweaks()) && - VerifyOffset(verifier, VT_SKELETON_HEIGHT) && - verifier.VerifyTable(skeleton_height()) && verifier.EndTable(); } }; -struct ModelSettingsBuilder { - typedef ModelSettings Table; +struct AutoBoneStopRecordingRequestBuilder { + typedef AutoBoneStopRecordingRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_toggles(flatbuffers::Offset toggles) { - fbb_.AddOffset(ModelSettings::VT_TOGGLES, toggles); - } - void add_ratios(flatbuffers::Offset ratios) { - fbb_.AddOffset(ModelSettings::VT_RATIOS, ratios); + explicit AutoBoneStopRecordingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - void add_leg_tweaks(flatbuffers::Offset leg_tweaks) { - fbb_.AddOffset(ModelSettings::VT_LEG_TWEAKS, leg_tweaks); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - void add_skeleton_height(flatbuffers::Offset skeleton_height) { - fbb_.AddOffset(ModelSettings::VT_SKELETON_HEIGHT, skeleton_height); +}; + +inline flatbuffers::Offset CreateAutoBoneStopRecordingRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + AutoBoneStopRecordingRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +/// Cancels the current recording, aborting the process and discarding the data +struct AutoBoneCancelRecordingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AutoBoneCancelRecordingRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - explicit ModelSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) +}; + +struct AutoBoneCancelRecordingRequestBuilder { + typedef AutoBoneCancelRecordingRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit AutoBoneCancelRecordingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateModelSettings( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset toggles = 0, - flatbuffers::Offset ratios = 0, - flatbuffers::Offset leg_tweaks = 0, - flatbuffers::Offset skeleton_height = 0) { - ModelSettingsBuilder builder_(_fbb); - builder_.add_skeleton_height(skeleton_height); - builder_.add_leg_tweaks(leg_tweaks); - builder_.add_ratios(ratios); - builder_.add_toggles(toggles); +inline flatbuffers::Offset CreateAutoBoneCancelRecordingRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + AutoBoneCancelRecordingRequestBuilder builder_(_fbb); return builder_.Finish(); } -} // namespace settings - -struct Keybind FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef KeybindBuilder Builder; +struct RecordBVHRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RecordBVHRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEYBIND_ID = 4, - VT_KEYBIND_NAME_ID = 6, - VT_KEYBIND_VALUE = 8, - VT_KEYBIND_DELAY = 10 + VT_STOP = 4, + VT_PATH = 6 }; - solarxr_protocol::rpc::KeybindId keybind_id() const { - return static_cast(GetField(VT_KEYBIND_ID, 0)); - } - const flatbuffers::String *keybind_name_id() const { - return GetPointer(VT_KEYBIND_NAME_ID); - } - const flatbuffers::String *keybind_value() const { - return GetPointer(VT_KEYBIND_VALUE); + bool stop() const { + return GetField(VT_STOP, 0) != 0; } - float keybind_delay() const { - return GetField(VT_KEYBIND_DELAY, 0.0f); + /// Path sent when starting the recording, if null the recording won't happen. + /// Has different behavior depending if its a file path or a directory path. + const flatbuffers::String *path() const { + return GetPointer(VT_PATH); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_KEYBIND_ID, 1) && - VerifyOffset(verifier, VT_KEYBIND_NAME_ID) && - verifier.VerifyString(keybind_name_id()) && - VerifyOffset(verifier, VT_KEYBIND_VALUE) && - verifier.VerifyString(keybind_value()) && - VerifyField(verifier, VT_KEYBIND_DELAY, 4) && + VerifyField(verifier, VT_STOP, 1) && + VerifyOffset(verifier, VT_PATH) && + verifier.VerifyString(path()) && verifier.EndTable(); } }; -struct KeybindBuilder { - typedef Keybind Table; +struct RecordBVHRequestBuilder { + typedef RecordBVHRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_keybind_id(solarxr_protocol::rpc::KeybindId keybind_id) { - fbb_.AddElement(Keybind::VT_KEYBIND_ID, static_cast(keybind_id), 0); - } - void add_keybind_name_id(flatbuffers::Offset keybind_name_id) { - fbb_.AddOffset(Keybind::VT_KEYBIND_NAME_ID, keybind_name_id); - } - void add_keybind_value(flatbuffers::Offset keybind_value) { - fbb_.AddOffset(Keybind::VT_KEYBIND_VALUE, keybind_value); + void add_stop(bool stop) { + fbb_.AddElement(RecordBVHRequest::VT_STOP, static_cast(stop), 0); } - void add_keybind_delay(float keybind_delay) { - fbb_.AddElement(Keybind::VT_KEYBIND_DELAY, keybind_delay, 0.0f); + void add_path(flatbuffers::Offset path) { + fbb_.AddOffset(RecordBVHRequest::VT_PATH, path); } - explicit KeybindBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit RecordBVHRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateKeybind( +inline flatbuffers::Offset CreateRecordBVHRequest( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET, - flatbuffers::Offset keybind_name_id = 0, - flatbuffers::Offset keybind_value = 0, - float keybind_delay = 0.0f) { - KeybindBuilder builder_(_fbb); - builder_.add_keybind_delay(keybind_delay); - builder_.add_keybind_value(keybind_value); - builder_.add_keybind_name_id(keybind_name_id); - builder_.add_keybind_id(keybind_id); + bool stop = false, + flatbuffers::Offset path = 0) { + RecordBVHRequestBuilder builder_(_fbb); + builder_.add_path(path); + builder_.add_stop(stop); return builder_.Finish(); } -inline flatbuffers::Offset CreateKeybindDirect( +inline flatbuffers::Offset CreateRecordBVHRequestDirect( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET, - const char *keybind_name_id = nullptr, - const char *keybind_value = nullptr, - float keybind_delay = 0.0f) { - auto keybind_name_id__ = keybind_name_id ? _fbb.CreateString(keybind_name_id) : 0; - auto keybind_value__ = keybind_value ? _fbb.CreateString(keybind_value) : 0; - return solarxr_protocol::rpc::CreateKeybind( + bool stop = false, + const char *path = nullptr) { + auto path__ = path ? _fbb.CreateString(path) : 0; + return solarxr_protocol::rpc::CreateRecordBVHRequest( _fbb, - keybind_id, - keybind_name_id__, - keybind_value__, - keybind_delay); + stop, + path__); } -struct KeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef KeybindRequestBuilder Builder; +struct RecordBVHStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RecordBVHStatusBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEYBIND_ID = 4 + VT_RECORDING = 4 }; - solarxr_protocol::rpc::KeybindId keybind_id() const { - return static_cast(GetField(VT_KEYBIND_ID, 0)); + bool recording() const { + return GetField(VT_RECORDING, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_KEYBIND_ID, 1) && + VerifyField(verifier, VT_RECORDING, 1) && verifier.EndTable(); } }; -struct KeybindRequestBuilder { - typedef KeybindRequest Table; +struct RecordBVHStatusBuilder { + typedef RecordBVHStatus Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_keybind_id(solarxr_protocol::rpc::KeybindId keybind_id) { - fbb_.AddElement(KeybindRequest::VT_KEYBIND_ID, static_cast(keybind_id), 0); + void add_recording(bool recording) { + fbb_.AddElement(RecordBVHStatus::VT_RECORDING, static_cast(recording), 0); } - explicit KeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit RecordBVHStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateKeybindRequest( +inline flatbuffers::Offset CreateRecordBVHStatus( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET) { - KeybindRequestBuilder builder_(_fbb); - builder_.add_keybind_id(keybind_id); + bool recording = false) { + RecordBVHStatusBuilder builder_(_fbb); + builder_.add_recording(recording); return builder_.Finish(); } -struct KeybindResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef KeybindResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEYBIND = 4, - VT_DEFAULT_KEYBINDS = 6 - }; - const flatbuffers::Vector> *keybind() const { - return GetPointer> *>(VT_KEYBIND); - } - const flatbuffers::Vector> *default_keybinds() const { - return GetPointer> *>(VT_DEFAULT_KEYBINDS); - } +struct RecordBVHStatusRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RecordBVHStatusRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_KEYBIND) && - verifier.VerifyVector(keybind()) && - verifier.VerifyVectorOfTables(keybind()) && - VerifyOffset(verifier, VT_DEFAULT_KEYBINDS) && - verifier.VerifyVector(default_keybinds()) && - verifier.VerifyVectorOfTables(default_keybinds()) && verifier.EndTable(); } }; -struct KeybindResponseBuilder { - typedef KeybindResponse Table; +struct RecordBVHStatusRequestBuilder { + typedef RecordBVHStatusRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_keybind(flatbuffers::Offset>> keybind) { - fbb_.AddOffset(KeybindResponse::VT_KEYBIND, keybind); - } - void add_default_keybinds(flatbuffers::Offset>> default_keybinds) { - fbb_.AddOffset(KeybindResponse::VT_DEFAULT_KEYBINDS, default_keybinds); - } - explicit KeybindResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit RecordBVHStatusRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateKeybindResponse( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> keybind = 0, - flatbuffers::Offset>> default_keybinds = 0) { - KeybindResponseBuilder builder_(_fbb); - builder_.add_default_keybinds(default_keybinds); - builder_.add_keybind(keybind); +inline flatbuffers::Offset CreateRecordBVHStatusRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + RecordBVHStatusRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateKeybindResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *keybind = nullptr, - const std::vector> *default_keybinds = nullptr) { - auto keybind__ = keybind ? _fbb.CreateVector>(*keybind) : 0; - auto default_keybinds__ = default_keybinds ? _fbb.CreateVector>(*default_keybinds) : 0; - return solarxr_protocol::rpc::CreateKeybindResponse( - _fbb, - keybind__, - default_keybinds__); -} - -struct ChangeKeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ChangeKeybindRequestBuilder Builder; +/// Server notifies connection of an unknown device. +/// If the notification is no longer sent, it means the device connected to another +/// server, got connected to this server or it was turned off. +struct UnknownDeviceHandshakeNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UnknownDeviceHandshakeNotificationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEYBIND = 4 + VT_MAC_ADDRESS = 4 }; - const solarxr_protocol::rpc::Keybind *keybind() const { - return GetPointer(VT_KEYBIND); + const flatbuffers::String *mac_address() const { + return GetPointer(VT_MAC_ADDRESS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_KEYBIND) && - verifier.VerifyTable(keybind()) && + VerifyOffset(verifier, VT_MAC_ADDRESS) && + verifier.VerifyString(mac_address()) && verifier.EndTable(); } }; -struct ChangeKeybindRequestBuilder { - typedef ChangeKeybindRequest Table; +struct UnknownDeviceHandshakeNotificationBuilder { + typedef UnknownDeviceHandshakeNotification Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_keybind(flatbuffers::Offset keybind) { - fbb_.AddOffset(ChangeKeybindRequest::VT_KEYBIND, keybind); + void add_mac_address(flatbuffers::Offset mac_address) { + fbb_.AddOffset(UnknownDeviceHandshakeNotification::VT_MAC_ADDRESS, mac_address); } - explicit ChangeKeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit UnknownDeviceHandshakeNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateChangeKeybindRequest( +inline flatbuffers::Offset CreateUnknownDeviceHandshakeNotification( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset keybind = 0) { - ChangeKeybindRequestBuilder builder_(_fbb); - builder_.add_keybind(keybind); + flatbuffers::Offset mac_address = 0) { + UnknownDeviceHandshakeNotificationBuilder builder_(_fbb); + builder_.add_mac_address(mac_address); return builder_.Finish(); } -struct OpenUriRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OpenUriRequestBuilder Builder; +inline flatbuffers::Offset CreateUnknownDeviceHandshakeNotificationDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *mac_address = nullptr) { + auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; + return solarxr_protocol::rpc::CreateUnknownDeviceHandshakeNotification( + _fbb, + mac_address__); +} + +struct AddUnknownDeviceRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AddUnknownDeviceRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MAC_ADDRESS = 4 + }; + const flatbuffers::String *mac_address() const { + return GetPointer(VT_MAC_ADDRESS); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_MAC_ADDRESS) && + verifier.VerifyString(mac_address()) && verifier.EndTable(); } }; -struct OpenUriRequestBuilder { - typedef OpenUriRequest Table; +struct AddUnknownDeviceRequestBuilder { + typedef AddUnknownDeviceRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit OpenUriRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_mac_address(flatbuffers::Offset mac_address) { + fbb_.AddOffset(AddUnknownDeviceRequest::VT_MAC_ADDRESS, mac_address); + } + explicit AddUnknownDeviceRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOpenUriRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - OpenUriRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateAddUnknownDeviceRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset mac_address = 0) { + AddUnknownDeviceRequestBuilder builder_(_fbb); + builder_.add_mac_address(mac_address); return builder_.Finish(); } -struct OpenUriResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OpenUriResponseBuilder Builder; +inline flatbuffers::Offset CreateAddUnknownDeviceRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *mac_address = nullptr) { + auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; + return solarxr_protocol::rpc::CreateAddUnknownDeviceRequest( + _fbb, + mac_address__); +} + +struct ForgetDeviceRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ForgetDeviceRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SUCCESS = 4 + VT_MAC_ADDRESS = 4 }; - bool success() const { - return GetField(VT_SUCCESS, 0) != 0; + const flatbuffers::String *mac_address() const { + return GetPointer(VT_MAC_ADDRESS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_SUCCESS, 1) && + VerifyOffset(verifier, VT_MAC_ADDRESS) && + verifier.VerifyString(mac_address()) && verifier.EndTable(); } }; -struct OpenUriResponseBuilder { - typedef OpenUriResponse Table; +struct ForgetDeviceRequestBuilder { + typedef ForgetDeviceRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_success(bool success) { - fbb_.AddElement(OpenUriResponse::VT_SUCCESS, static_cast(success), 0); + void add_mac_address(flatbuffers::Offset mac_address) { + fbb_.AddOffset(ForgetDeviceRequest::VT_MAC_ADDRESS, mac_address); } - explicit OpenUriResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ForgetDeviceRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOpenUriResponse( +inline flatbuffers::Offset CreateForgetDeviceRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool success = false) { - OpenUriResponseBuilder builder_(_fbb); - builder_.add_success(success); + flatbuffers::Offset mac_address = 0) { + ForgetDeviceRequestBuilder builder_(_fbb); + builder_.add_mac_address(mac_address); return builder_.Finish(); } -struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef RpcMessageHeaderBuilder Builder; +inline flatbuffers::Offset CreateForgetDeviceRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *mac_address = nullptr) { + auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; + return solarxr_protocol::rpc::CreateForgetDeviceRequest( + _fbb, + mac_address__); +} + +struct SerialDevicePort FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialDevicePortBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TX_ID = 4, - VT_MESSAGE_TYPE = 6, - VT_MESSAGE = 8 + VT_PORT = 4 }; - /// For a request, this identifies the request. For a response, this corresponds - /// to the request that it is responding to. - const solarxr_protocol::datatypes::TransactionId *tx_id() const { - return GetStruct(VT_TX_ID); - } - solarxr_protocol::rpc::RpcMessage message_type() const { - return static_cast(GetField(VT_MESSAGE_TYPE, 0)); + const flatbuffers::String *port() const { + return GetPointer(VT_PORT); } - const void *message() const { - return GetPointer(VT_MESSAGE); + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PORT) && + verifier.VerifyString(port()) && + verifier.EndTable(); } - template const T *message_as() const; - const solarxr_protocol::rpc::HeartbeatRequest *message_as_HeartbeatRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::HeartbeatRequest ? static_cast(message()) : nullptr; +}; + +struct SerialDevicePortBuilder { + typedef SerialDevicePort Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_port(flatbuffers::Offset port) { + fbb_.AddOffset(SerialDevicePort::VT_PORT, port); } - const solarxr_protocol::rpc::HeartbeatResponse *message_as_HeartbeatResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::HeartbeatResponse ? static_cast(message()) : nullptr; + explicit SerialDevicePortBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::ResetRequest *message_as_ResetRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ResetRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::ResetResponse *message_as_ResetResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ResetResponse ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateSerialDevicePort( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset port = 0) { + SerialDevicePortBuilder builder_(_fbb); + builder_.add_port(port); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSerialDevicePortDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *port = nullptr) { + auto port__ = port ? _fbb.CreateString(port) : 0; + return solarxr_protocol::rpc::CreateSerialDevicePort( + _fbb, + port__); +} + +struct FirmwareDeviceIdTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FirmwareDeviceIdTableBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4 + }; + uint16_t id() const { + return GetField(VT_ID, 0); } - const solarxr_protocol::rpc::AssignTrackerRequest *message_as_AssignTrackerRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AssignTrackerRequest ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 2) && + verifier.EndTable(); } - const solarxr_protocol::rpc::SettingsRequest *message_as_SettingsRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SettingsRequest ? static_cast(message()) : nullptr; +}; + +struct FirmwareDeviceIdTableBuilder { + typedef FirmwareDeviceIdTable Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(uint16_t id) { + fbb_.AddElement(FirmwareDeviceIdTable::VT_ID, id, 0); } - const solarxr_protocol::rpc::SettingsResponse *message_as_SettingsResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SettingsResponse ? static_cast(message()) : nullptr; + explicit FirmwareDeviceIdTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::ChangeSettingsRequest *message_as_ChangeSettingsRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeSettingsRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::ClearDriftCompensationRequest *message_as_ClearDriftCompensationRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ClearDriftCompensationRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateFirmwareDeviceIdTable( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t id = 0) { + FirmwareDeviceIdTableBuilder builder_(_fbb); + builder_.add_id(id); + return builder_.Finish(); +} + +struct FirmwarePart FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FirmwarePartBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_URL = 4, + VT_OFFSET = 6, + VT_DIGEST = 8 + }; + /// Url of the firmware bin to download + const flatbuffers::String *url() const { + return GetPointer(VT_URL); } - const solarxr_protocol::rpc::RecordBVHRequest *message_as_RecordBVHRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHRequest ? static_cast(message()) : nullptr; + /// Offset of the firmware, used when flashing to the mcu, it indicates where to write this file in memory + /// Will be ignored in the case of OTA flashing + uint32_t offset() const { + return GetField(VT_OFFSET, 0); } - const solarxr_protocol::rpc::RecordBVHStatus *message_as_RecordBVHStatus() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHStatus ? static_cast(message()) : nullptr; + /// Checksum of the file + const flatbuffers::String *digest() const { + return GetPointer(VT_DIGEST); } - const solarxr_protocol::rpc::SkeletonConfigRequest *message_as_SkeletonConfigRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonConfigRequest ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_URL) && + verifier.VerifyString(url()) && + VerifyField(verifier, VT_OFFSET, 4) && + VerifyOffset(verifier, VT_DIGEST) && + verifier.VerifyString(digest()) && + verifier.EndTable(); } - const solarxr_protocol::rpc::ChangeSkeletonConfigRequest *message_as_ChangeSkeletonConfigRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeSkeletonConfigRequest ? static_cast(message()) : nullptr; +}; + +struct FirmwarePartBuilder { + typedef FirmwarePart Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_url(flatbuffers::Offset url) { + fbb_.AddOffset(FirmwarePart::VT_URL, url); } - const solarxr_protocol::rpc::SkeletonResetAllRequest *message_as_SkeletonResetAllRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonResetAllRequest ? static_cast(message()) : nullptr; + void add_offset(uint32_t offset) { + fbb_.AddElement(FirmwarePart::VT_OFFSET, offset, 0); } - const solarxr_protocol::rpc::SkeletonConfigResponse *message_as_SkeletonConfigResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonConfigResponse ? static_cast(message()) : nullptr; + void add_digest(flatbuffers::Offset digest) { + fbb_.AddOffset(FirmwarePart::VT_DIGEST, digest); } - const solarxr_protocol::rpc::OpenSerialRequest *message_as_OpenSerialRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OpenSerialRequest ? static_cast(message()) : nullptr; + explicit FirmwarePartBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::CloseSerialRequest *message_as_CloseSerialRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::CloseSerialRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::SetWifiRequest *message_as_SetWifiRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SetWifiRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateFirmwarePart( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset url = 0, + uint32_t offset = 0, + flatbuffers::Offset digest = 0) { + FirmwarePartBuilder builder_(_fbb); + builder_.add_digest(digest); + builder_.add_offset(offset); + builder_.add_url(url); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateFirmwarePartDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *url = nullptr, + uint32_t offset = 0, + const char *digest = nullptr) { + auto url__ = url ? _fbb.CreateString(url) : 0; + auto digest__ = digest ? _fbb.CreateString(digest) : 0; + return solarxr_protocol::rpc::CreateFirmwarePart( + _fbb, + url__, + offset, + digest__); +} + +struct FirmwareUpdateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FirmwareUpdateRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_METHOD_TYPE = 4, + VT_METHOD = 6 + }; + solarxr_protocol::rpc::FirmwareUpdateMethod method_type() const { + return static_cast(GetField(VT_METHOD_TYPE, 0)); } - const solarxr_protocol::rpc::SerialUpdateResponse *message_as_SerialUpdateResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialUpdateResponse ? static_cast(message()) : nullptr; + const void *method() const { + return GetPointer(VT_METHOD); } - const solarxr_protocol::rpc::AutoBoneProcessRequest *message_as_AutoBoneProcessRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneProcessRequest ? static_cast(message()) : nullptr; + template const T *method_as() const; + const solarxr_protocol::rpc::OTAFirmwareUpdate *method_as_OTAFirmwareUpdate() const { + return method_type() == solarxr_protocol::rpc::FirmwareUpdateMethod::OTAFirmwareUpdate ? static_cast(method()) : nullptr; } - const solarxr_protocol::rpc::AutoBoneProcessStatusResponse *message_as_AutoBoneProcessStatusResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneProcessStatusResponse ? static_cast(message()) : nullptr; + const solarxr_protocol::rpc::SerialFirmwareUpdate *method_as_SerialFirmwareUpdate() const { + return method_type() == solarxr_protocol::rpc::FirmwareUpdateMethod::SerialFirmwareUpdate ? static_cast(method()) : nullptr; } - const solarxr_protocol::rpc::AutoBoneEpochResponse *message_as_AutoBoneEpochResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneEpochResponse ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_METHOD_TYPE, 1) && + VerifyOffset(verifier, VT_METHOD) && + VerifyFirmwareUpdateMethod(verifier, method(), method_type()) && + verifier.EndTable(); } - const solarxr_protocol::rpc::OverlayDisplayModeRequest *message_as_OverlayDisplayModeRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeRequest ? static_cast(message()) : nullptr; +}; + +template<> inline const solarxr_protocol::rpc::OTAFirmwareUpdate *FirmwareUpdateRequest::method_as() const { + return method_as_OTAFirmwareUpdate(); +} + +template<> inline const solarxr_protocol::rpc::SerialFirmwareUpdate *FirmwareUpdateRequest::method_as() const { + return method_as_SerialFirmwareUpdate(); +} + +struct FirmwareUpdateRequestBuilder { + typedef FirmwareUpdateRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_method_type(solarxr_protocol::rpc::FirmwareUpdateMethod method_type) { + fbb_.AddElement(FirmwareUpdateRequest::VT_METHOD_TYPE, static_cast(method_type), 0); } - const solarxr_protocol::rpc::OverlayDisplayModeChangeRequest *message_as_OverlayDisplayModeChangeRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeChangeRequest ? static_cast(message()) : nullptr; + void add_method(flatbuffers::Offset method) { + fbb_.AddOffset(FirmwareUpdateRequest::VT_METHOD, method); } - const solarxr_protocol::rpc::OverlayDisplayModeResponse *message_as_OverlayDisplayModeResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeResponse ? static_cast(message()) : nullptr; + explicit FirmwareUpdateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::SerialTrackerRebootRequest *message_as_SerialTrackerRebootRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerRebootRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::SerialTrackerGetInfoRequest *message_as_SerialTrackerGetInfoRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerGetInfoRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateFirmwareUpdateRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::FirmwareUpdateMethod method_type = solarxr_protocol::rpc::FirmwareUpdateMethod::NONE, + flatbuffers::Offset method = 0) { + FirmwareUpdateRequestBuilder builder_(_fbb); + builder_.add_method(method); + builder_.add_method_type(method_type); + return builder_.Finish(); +} + +struct OTAFirmwareUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OTAFirmwareUpdateBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE_ID = 4, + VT_FIRMWARE_PART = 6 + }; + /// Id of the device + uint16_t device_id() const { + return GetField(VT_DEVICE_ID, 0); } - const solarxr_protocol::rpc::SerialTrackerFactoryResetRequest *message_as_SerialTrackerFactoryResetRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerFactoryResetRequest ? static_cast(message()) : nullptr; + /// A table containing the url and offset of the firmware bin file + const solarxr_protocol::rpc::FirmwarePart *firmware_part() const { + return GetPointer(VT_FIRMWARE_PART); } - const solarxr_protocol::rpc::SerialDevicesRequest *message_as_SerialDevicesRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialDevicesRequest ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::SerialDevicesResponse *message_as_SerialDevicesResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialDevicesResponse ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::NewSerialDeviceResponse *message_as_NewSerialDeviceResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::NewSerialDeviceResponse ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::StartWifiProvisioningRequest *message_as_StartWifiProvisioningRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StartWifiProvisioningRequest ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DEVICE_ID, 2) && + VerifyOffset(verifier, VT_FIRMWARE_PART) && + verifier.VerifyTable(firmware_part()) && + verifier.EndTable(); } - const solarxr_protocol::rpc::StopWifiProvisioningRequest *message_as_StopWifiProvisioningRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StopWifiProvisioningRequest ? static_cast(message()) : nullptr; +}; + +struct OTAFirmwareUpdateBuilder { + typedef OTAFirmwareUpdate Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_device_id(uint16_t device_id) { + fbb_.AddElement(OTAFirmwareUpdate::VT_DEVICE_ID, device_id, 0); } - const solarxr_protocol::rpc::WifiProvisioningStatusResponse *message_as_WifiProvisioningStatusResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::WifiProvisioningStatusResponse ? static_cast(message()) : nullptr; + void add_firmware_part(flatbuffers::Offset firmware_part) { + fbb_.AddOffset(OTAFirmwareUpdate::VT_FIRMWARE_PART, firmware_part); } - const solarxr_protocol::rpc::ServerInfosRequest *message_as_ServerInfosRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ServerInfosRequest ? static_cast(message()) : nullptr; + explicit OTAFirmwareUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::ServerInfosResponse *message_as_ServerInfosResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ServerInfosResponse ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::LegTweaksTmpChange *message_as_LegTweaksTmpChange() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::LegTweaksTmpChange ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateOTAFirmwareUpdate( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t device_id = 0, + flatbuffers::Offset firmware_part = 0) { + OTAFirmwareUpdateBuilder builder_(_fbb); + builder_.add_firmware_part(firmware_part); + builder_.add_device_id(device_id); + return builder_.Finish(); +} + +struct SerialFirmwareUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialFirmwareUpdateBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE_ID = 4, + VT_NEED_MANUAL_REBOOT = 6, + VT_SSID = 8, + VT_PASSWORD = 10, + VT_FIRMWARE_PART = 12 + }; + /// id of the device, this refer to a serial port id + const solarxr_protocol::rpc::SerialDevicePort *device_id() const { + return GetPointer(VT_DEVICE_ID); } - const solarxr_protocol::rpc::LegTweaksTmpClear *message_as_LegTweaksTmpClear() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::LegTweaksTmpClear ? static_cast(message()) : nullptr; + /// Will make the server ask for the tracker to be manually rebooted by the user + /// after the tracker is done flashing + bool need_manual_reboot() const { + return GetField(VT_NEED_MANUAL_REBOOT, 0) != 0; } - const solarxr_protocol::rpc::TapDetectionSetupNotification *message_as_TapDetectionSetupNotification() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::TapDetectionSetupNotification ? static_cast(message()) : nullptr; + /// Credentials to provision after the flashing + /// Only used with Serial flashing, because OTA is already connected to the wifi + const flatbuffers::String *ssid() const { + return GetPointer(VT_SSID); } - const solarxr_protocol::rpc::SetPauseTrackingRequest *message_as_SetPauseTrackingRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SetPauseTrackingRequest ? static_cast(message()) : nullptr; + const flatbuffers::String *password() const { + return GetPointer(VT_PASSWORD); } - const solarxr_protocol::rpc::StatusSystemRequest *message_as_StatusSystemRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StatusSystemRequest ? static_cast(message()) : nullptr; + /// A list of urls and offsets of the different firmware files to flash + const flatbuffers::Vector> *firmware_part() const { + return GetPointer> *>(VT_FIRMWARE_PART); } - const solarxr_protocol::rpc::StatusSystemResponse *message_as_StatusSystemResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StatusSystemResponse ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DEVICE_ID) && + verifier.VerifyTable(device_id()) && + VerifyField(verifier, VT_NEED_MANUAL_REBOOT, 1) && + VerifyOffset(verifier, VT_SSID) && + verifier.VerifyString(ssid()) && + VerifyOffset(verifier, VT_PASSWORD) && + verifier.VerifyString(password()) && + VerifyOffset(verifier, VT_FIRMWARE_PART) && + verifier.VerifyVector(firmware_part()) && + verifier.VerifyVectorOfTables(firmware_part()) && + verifier.EndTable(); } - const solarxr_protocol::rpc::StatusSystemUpdate *message_as_StatusSystemUpdate() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StatusSystemUpdate ? static_cast(message()) : nullptr; +}; + +struct SerialFirmwareUpdateBuilder { + typedef SerialFirmwareUpdate Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_device_id(flatbuffers::Offset device_id) { + fbb_.AddOffset(SerialFirmwareUpdate::VT_DEVICE_ID, device_id); } - const solarxr_protocol::rpc::StatusSystemFixed *message_as_StatusSystemFixed() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StatusSystemFixed ? static_cast(message()) : nullptr; + void add_need_manual_reboot(bool need_manual_reboot) { + fbb_.AddElement(SerialFirmwareUpdate::VT_NEED_MANUAL_REBOOT, static_cast(need_manual_reboot), 0); } - const solarxr_protocol::rpc::ClearMountingResetRequest *message_as_ClearMountingResetRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ClearMountingResetRequest ? static_cast(message()) : nullptr; + void add_ssid(flatbuffers::Offset ssid) { + fbb_.AddOffset(SerialFirmwareUpdate::VT_SSID, ssid); } - const solarxr_protocol::rpc::HeightRequest *message_as_HeightRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::HeightRequest ? static_cast(message()) : nullptr; + void add_password(flatbuffers::Offset password) { + fbb_.AddOffset(SerialFirmwareUpdate::VT_PASSWORD, password); } - const solarxr_protocol::rpc::HeightResponse *message_as_HeightResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::HeightResponse ? static_cast(message()) : nullptr; + void add_firmware_part(flatbuffers::Offset>> firmware_part) { + fbb_.AddOffset(SerialFirmwareUpdate::VT_FIRMWARE_PART, firmware_part); } - const solarxr_protocol::rpc::AutoBoneApplyRequest *message_as_AutoBoneApplyRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneApplyRequest ? static_cast(message()) : nullptr; + explicit SerialFirmwareUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::AutoBoneStopRecordingRequest *message_as_AutoBoneStopRecordingRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneStopRecordingRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::AutoBoneCancelRecordingRequest *message_as_AutoBoneCancelRecordingRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneCancelRecordingRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateSerialFirmwareUpdate( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset device_id = 0, + bool need_manual_reboot = false, + flatbuffers::Offset ssid = 0, + flatbuffers::Offset password = 0, + flatbuffers::Offset>> firmware_part = 0) { + SerialFirmwareUpdateBuilder builder_(_fbb); + builder_.add_firmware_part(firmware_part); + builder_.add_password(password); + builder_.add_ssid(ssid); + builder_.add_device_id(device_id); + builder_.add_need_manual_reboot(need_manual_reboot); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSerialFirmwareUpdateDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset device_id = 0, + bool need_manual_reboot = false, + const char *ssid = nullptr, + const char *password = nullptr, + const std::vector> *firmware_part = nullptr) { + auto ssid__ = ssid ? _fbb.CreateString(ssid) : 0; + auto password__ = password ? _fbb.CreateString(password) : 0; + auto firmware_part__ = firmware_part ? _fbb.CreateVector>(*firmware_part) : 0; + return solarxr_protocol::rpc::CreateSerialFirmwareUpdate( + _fbb, + device_id, + need_manual_reboot, + ssid__, + password__, + firmware_part__); +} + +struct FirmwareUpdateStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FirmwareUpdateStatusResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE_ID_TYPE = 4, + VT_DEVICE_ID = 6, + VT_STATUS = 8, + VT_PROGRESS = 10 + }; + solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type() const { + return static_cast(GetField(VT_DEVICE_ID_TYPE, 0)); } - const solarxr_protocol::rpc::SaveFileNotification *message_as_SaveFileNotification() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SaveFileNotification ? static_cast(message()) : nullptr; + const void *device_id() const { + return GetPointer(VT_DEVICE_ID); } - const solarxr_protocol::rpc::TrackingPauseStateRequest *message_as_TrackingPauseStateRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingPauseStateRequest ? static_cast(message()) : nullptr; + template const T *device_id_as() const; + const solarxr_protocol::rpc::FirmwareDeviceIdTable *device_id_as_FirmwareDeviceIdTable() const { + return device_id_type() == solarxr_protocol::rpc::FirmwareUpdateDeviceId::FirmwareDeviceIdTable ? static_cast(device_id()) : nullptr; } - const solarxr_protocol::rpc::TrackingPauseStateResponse *message_as_TrackingPauseStateResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingPauseStateResponse ? static_cast(message()) : nullptr; + const solarxr_protocol::rpc::SerialDevicePort *device_id_as_SerialDevicePort() const { + return device_id_type() == solarxr_protocol::rpc::FirmwareUpdateDeviceId::SerialDevicePort ? static_cast(device_id()) : nullptr; } - const solarxr_protocol::rpc::SerialTrackerGetWifiScanRequest *message_as_SerialTrackerGetWifiScanRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerGetWifiScanRequest ? static_cast(message()) : nullptr; + solarxr_protocol::rpc::FirmwareUpdateStatus status() const { + return static_cast(GetField(VT_STATUS, 0)); } - const solarxr_protocol::rpc::UnknownDeviceHandshakeNotification *message_as_UnknownDeviceHandshakeNotification() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::UnknownDeviceHandshakeNotification ? static_cast(message()) : nullptr; + /// from 0 to 100 + int8_t progress() const { + return GetField(VT_PROGRESS, 0); } - const solarxr_protocol::rpc::AddUnknownDeviceRequest *message_as_AddUnknownDeviceRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::AddUnknownDeviceRequest ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_DEVICE_ID_TYPE, 1) && + VerifyOffset(verifier, VT_DEVICE_ID) && + VerifyFirmwareUpdateDeviceId(verifier, device_id(), device_id_type()) && + VerifyField(verifier, VT_STATUS, 1) && + VerifyField(verifier, VT_PROGRESS, 1) && + verifier.EndTable(); } - const solarxr_protocol::rpc::ForgetDeviceRequest *message_as_ForgetDeviceRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ForgetDeviceRequest ? static_cast(message()) : nullptr; +}; + +template<> inline const solarxr_protocol::rpc::FirmwareDeviceIdTable *FirmwareUpdateStatusResponse::device_id_as() const { + return device_id_as_FirmwareDeviceIdTable(); +} + +template<> inline const solarxr_protocol::rpc::SerialDevicePort *FirmwareUpdateStatusResponse::device_id_as() const { + return device_id_as_SerialDevicePort(); +} + +struct FirmwareUpdateStatusResponseBuilder { + typedef FirmwareUpdateStatusResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_device_id_type(solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type) { + fbb_.AddElement(FirmwareUpdateStatusResponse::VT_DEVICE_ID_TYPE, static_cast(device_id_type), 0); } - const solarxr_protocol::rpc::FirmwareUpdateRequest *message_as_FirmwareUpdateRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateRequest ? static_cast(message()) : nullptr; + void add_device_id(flatbuffers::Offset device_id) { + fbb_.AddOffset(FirmwareUpdateStatusResponse::VT_DEVICE_ID, device_id); } - const solarxr_protocol::rpc::FirmwareUpdateStatusResponse *message_as_FirmwareUpdateStatusResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateStatusResponse ? static_cast(message()) : nullptr; + void add_status(solarxr_protocol::rpc::FirmwareUpdateStatus status) { + fbb_.AddElement(FirmwareUpdateStatusResponse::VT_STATUS, static_cast(status), 0); } - const solarxr_protocol::rpc::FirmwareUpdateStopQueuesRequest *message_as_FirmwareUpdateStopQueuesRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateStopQueuesRequest ? static_cast(message()) : nullptr; + void add_progress(int8_t progress) { + fbb_.AddElement(FirmwareUpdateStatusResponse::VT_PROGRESS, progress, 0); } - const solarxr_protocol::rpc::SettingsResetRequest *message_as_SettingsResetRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SettingsResetRequest ? static_cast(message()) : nullptr; + explicit FirmwareUpdateStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::MagToggleRequest *message_as_MagToggleRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::MagToggleRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::MagToggleResponse *message_as_MagToggleResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::MagToggleResponse ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateFirmwareUpdateStatusResponse( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type = solarxr_protocol::rpc::FirmwareUpdateDeviceId::NONE, + flatbuffers::Offset device_id = 0, + solarxr_protocol::rpc::FirmwareUpdateStatus status = solarxr_protocol::rpc::FirmwareUpdateStatus::DOWNLOADING, + int8_t progress = 0) { + FirmwareUpdateStatusResponseBuilder builder_(_fbb); + builder_.add_device_id(device_id); + builder_.add_progress(progress); + builder_.add_status(status); + builder_.add_device_id_type(device_id_type); + return builder_.Finish(); +} + +struct FirmwareUpdateStopQueuesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FirmwareUpdateStopQueuesRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - const solarxr_protocol::rpc::ChangeMagToggleRequest *message_as_ChangeMagToggleRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeMagToggleRequest ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::RecordBVHStatusRequest *message_as_RecordBVHStatusRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHStatusRequest ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::VRCConfigStateRequest *message_as_VRCConfigStateRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigStateRequest ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::VRCConfigStateChangeResponse *message_as_VRCConfigStateChangeResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigStateChangeResponse ? static_cast(message()) : nullptr; - } - const solarxr_protocol::rpc::EnableStayAlignedRequest *message_as_EnableStayAlignedRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::EnableStayAlignedRequest ? static_cast(message()) : nullptr; +}; + +struct FirmwareUpdateStopQueuesRequestBuilder { + typedef FirmwareUpdateStopQueuesRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit FirmwareUpdateStopQueuesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::DetectStayAlignedRelaxedPoseRequest *message_as_DetectStayAlignedRelaxedPoseRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::DetectStayAlignedRelaxedPoseRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::ResetStayAlignedRelaxedPoseRequest *message_as_ResetStayAlignedRelaxedPoseRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ResetStayAlignedRelaxedPoseRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateFirmwareUpdateStopQueuesRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + FirmwareUpdateStopQueuesRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct StartUserHeightCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StartUserHeightCalibrationBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest *message_as_SerialTrackerCustomCommandRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerCustomCommandRequest ? static_cast(message()) : nullptr; +}; + +struct StartUserHeightCalibrationBuilder { + typedef StartUserHeightCalibration Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit StartUserHeightCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::VRCConfigSettingToggleMute *message_as_VRCConfigSettingToggleMute() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigSettingToggleMute ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::TrackingChecklistRequest *message_as_TrackingChecklistRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistRequest ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateStartUserHeightCalibration( + flatbuffers::FlatBufferBuilder &_fbb) { + StartUserHeightCalibrationBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct CancelUserHeightCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CancelUserHeightCalibrationBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - const solarxr_protocol::rpc::TrackingChecklistResponse *message_as_TrackingChecklistResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistResponse ? static_cast(message()) : nullptr; +}; + +struct CancelUserHeightCalibrationBuilder { + typedef CancelUserHeightCalibration Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit CancelUserHeightCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *message_as_IgnoreTrackingChecklistStepRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::IgnoreTrackingChecklistStepRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::StartUserHeightCalibration *message_as_StartUserHeightCalibration() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::StartUserHeightCalibration ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateCancelUserHeightCalibration( + flatbuffers::FlatBufferBuilder &_fbb) { + CancelUserHeightCalibrationBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct UserHeightRecordingStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UserHeightRecordingStatusResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_HMD_HEIGHT = 4, + VT_STATUS = 6 + }; + float hmd_height() const { + return GetField(VT_HMD_HEIGHT, 0.0f); } - const solarxr_protocol::rpc::CancelUserHeightCalibration *message_as_CancelUserHeightCalibration() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::CancelUserHeightCalibration ? static_cast(message()) : nullptr; + solarxr_protocol::rpc::UserHeightCalibrationStatus status() const { + return static_cast(GetField(VT_STATUS, 0)); } - const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *message_as_UserHeightRecordingStatusResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::UserHeightRecordingStatusResponse ? static_cast(message()) : nullptr; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_HMD_HEIGHT, 4) && + VerifyField(verifier, VT_STATUS, 1) && + verifier.EndTable(); } - const solarxr_protocol::rpc::KeybindRequest *message_as_KeybindRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindRequest ? static_cast(message()) : nullptr; +}; + +struct UserHeightRecordingStatusResponseBuilder { + typedef UserHeightRecordingStatusResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_hmd_height(float hmd_height) { + fbb_.AddElement(UserHeightRecordingStatusResponse::VT_HMD_HEIGHT, hmd_height, 0.0f); } - const solarxr_protocol::rpc::ChangeKeybindRequest *message_as_ChangeKeybindRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeKeybindRequest ? static_cast(message()) : nullptr; + void add_status(solarxr_protocol::rpc::UserHeightCalibrationStatus status) { + fbb_.AddElement(UserHeightRecordingStatusResponse::VT_STATUS, static_cast(status), 0); } - const solarxr_protocol::rpc::KeybindResponse *message_as_KeybindResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindResponse ? static_cast(message()) : nullptr; + explicit UserHeightRecordingStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - const solarxr_protocol::rpc::InstalledInfoRequest *message_as_InstalledInfoRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::InstalledInfoRequest ? static_cast(message()) : nullptr; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - const solarxr_protocol::rpc::InstalledInfoResponse *message_as_InstalledInfoResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::InstalledInfoResponse ? static_cast(message()) : nullptr; +}; + +inline flatbuffers::Offset CreateUserHeightRecordingStatusResponse( + flatbuffers::FlatBufferBuilder &_fbb, + float hmd_height = 0.0f, + solarxr_protocol::rpc::UserHeightCalibrationStatus status = solarxr_protocol::rpc::UserHeightCalibrationStatus::NONE) { + UserHeightRecordingStatusResponseBuilder builder_(_fbb); + builder_.add_hmd_height(hmd_height); + builder_.add_status(status); + return builder_.Finish(); +} + +struct Keybind FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND_ID = 4, + VT_KEYBIND_NAME_ID = 6, + VT_KEYBIND_VALUE = 8, + VT_KEYBIND_DELAY = 10 + }; + solarxr_protocol::rpc::KeybindId keybind_id() const { + return static_cast(GetField(VT_KEYBIND_ID, 0)); } - const solarxr_protocol::rpc::OpenUriRequest *message_as_OpenUriRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OpenUriRequest ? static_cast(message()) : nullptr; + const flatbuffers::String *keybind_name_id() const { + return GetPointer(VT_KEYBIND_NAME_ID); } - const solarxr_protocol::rpc::OpenUriResponse *message_as_OpenUriResponse() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::OpenUriResponse ? static_cast(message()) : nullptr; + const flatbuffers::String *keybind_value() const { + return GetPointer(VT_KEYBIND_VALUE); } - const solarxr_protocol::rpc::EnableSteamVRDriverRequest *message_as_EnableSteamVRDriverRequest() const { - return message_type() == solarxr_protocol::rpc::RpcMessage::EnableSteamVRDriverRequest ? static_cast(message()) : nullptr; + float keybind_delay() const { + return GetField(VT_KEYBIND_DELAY, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_TX_ID, 4) && - VerifyField(verifier, VT_MESSAGE_TYPE, 1) && - VerifyOffset(verifier, VT_MESSAGE) && - VerifyRpcMessage(verifier, message(), message_type()) && + VerifyField(verifier, VT_KEYBIND_ID, 1) && + VerifyOffset(verifier, VT_KEYBIND_NAME_ID) && + verifier.VerifyString(keybind_name_id()) && + VerifyOffset(verifier, VT_KEYBIND_VALUE) && + verifier.VerifyString(keybind_value()) && + VerifyField(verifier, VT_KEYBIND_DELAY, 4) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::rpc::HeartbeatRequest *RpcMessageHeader::message_as() const { - return message_as_HeartbeatRequest(); -} - -template<> inline const solarxr_protocol::rpc::HeartbeatResponse *RpcMessageHeader::message_as() const { - return message_as_HeartbeatResponse(); -} - -template<> inline const solarxr_protocol::rpc::ResetRequest *RpcMessageHeader::message_as() const { - return message_as_ResetRequest(); -} +struct KeybindBuilder { + typedef Keybind Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind_id(solarxr_protocol::rpc::KeybindId keybind_id) { + fbb_.AddElement(Keybind::VT_KEYBIND_ID, static_cast(keybind_id), 0); + } + void add_keybind_name_id(flatbuffers::Offset keybind_name_id) { + fbb_.AddOffset(Keybind::VT_KEYBIND_NAME_ID, keybind_name_id); + } + void add_keybind_value(flatbuffers::Offset keybind_value) { + fbb_.AddOffset(Keybind::VT_KEYBIND_VALUE, keybind_value); + } + void add_keybind_delay(float keybind_delay) { + fbb_.AddElement(Keybind::VT_KEYBIND_DELAY, keybind_delay, 0.0f); + } + explicit KeybindBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::ResetResponse *RpcMessageHeader::message_as() const { - return message_as_ResetResponse(); +inline flatbuffers::Offset CreateKeybind( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET, + flatbuffers::Offset keybind_name_id = 0, + flatbuffers::Offset keybind_value = 0, + float keybind_delay = 0.0f) { + KeybindBuilder builder_(_fbb); + builder_.add_keybind_delay(keybind_delay); + builder_.add_keybind_value(keybind_value); + builder_.add_keybind_name_id(keybind_name_id); + builder_.add_keybind_id(keybind_id); + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::AssignTrackerRequest *RpcMessageHeader::message_as() const { - return message_as_AssignTrackerRequest(); +inline flatbuffers::Offset CreateKeybindDirect( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET, + const char *keybind_name_id = nullptr, + const char *keybind_value = nullptr, + float keybind_delay = 0.0f) { + auto keybind_name_id__ = keybind_name_id ? _fbb.CreateString(keybind_name_id) : 0; + auto keybind_value__ = keybind_value ? _fbb.CreateString(keybind_value) : 0; + return solarxr_protocol::rpc::CreateKeybind( + _fbb, + keybind_id, + keybind_name_id__, + keybind_value__, + keybind_delay); } -template<> inline const solarxr_protocol::rpc::SettingsRequest *RpcMessageHeader::message_as() const { - return message_as_SettingsRequest(); -} +/// Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui +struct KeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND_ID = 4 + }; + solarxr_protocol::rpc::KeybindId keybind_id() const { + return static_cast(GetField(VT_KEYBIND_ID, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_KEYBIND_ID, 1) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::SettingsResponse *RpcMessageHeader::message_as() const { - return message_as_SettingsResponse(); -} +struct KeybindRequestBuilder { + typedef KeybindRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind_id(solarxr_protocol::rpc::KeybindId keybind_id) { + fbb_.AddElement(KeybindRequest::VT_KEYBIND_ID, static_cast(keybind_id), 0); + } + explicit KeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::ChangeSettingsRequest *RpcMessageHeader::message_as() const { - return message_as_ChangeSettingsRequest(); +inline flatbuffers::Offset CreateKeybindRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindId keybind_id = solarxr_protocol::rpc::KeybindId::FULL_RESET) { + KeybindRequestBuilder builder_(_fbb); + builder_.add_keybind_id(keybind_id); + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::ClearDriftCompensationRequest *RpcMessageHeader::message_as() const { - return message_as_ClearDriftCompensationRequest(); -} +/// Returns keybinds for displaying in gui +struct KeybindResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND = 4, + VT_DEFAULT_KEYBINDS = 6 + }; + const flatbuffers::Vector> *keybind() const { + return GetPointer> *>(VT_KEYBIND); + } + const flatbuffers::Vector> *default_keybinds() const { + return GetPointer> *>(VT_DEFAULT_KEYBINDS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_KEYBIND) && + verifier.VerifyVector(keybind()) && + verifier.VerifyVectorOfTables(keybind()) && + VerifyOffset(verifier, VT_DEFAULT_KEYBINDS) && + verifier.VerifyVector(default_keybinds()) && + verifier.VerifyVectorOfTables(default_keybinds()) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::RecordBVHRequest *RpcMessageHeader::message_as() const { - return message_as_RecordBVHRequest(); -} +struct KeybindResponseBuilder { + typedef KeybindResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind(flatbuffers::Offset>> keybind) { + fbb_.AddOffset(KeybindResponse::VT_KEYBIND, keybind); + } + void add_default_keybinds(flatbuffers::Offset>> default_keybinds) { + fbb_.AddOffset(KeybindResponse::VT_DEFAULT_KEYBINDS, default_keybinds); + } + explicit KeybindResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::RecordBVHStatus *RpcMessageHeader::message_as() const { - return message_as_RecordBVHStatus(); +inline flatbuffers::Offset CreateKeybindResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> keybind = 0, + flatbuffers::Offset>> default_keybinds = 0) { + KeybindResponseBuilder builder_(_fbb); + builder_.add_default_keybinds(default_keybinds); + builder_.add_keybind(keybind); + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::SkeletonConfigRequest *RpcMessageHeader::message_as() const { - return message_as_SkeletonConfigRequest(); +inline flatbuffers::Offset CreateKeybindResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *keybind = nullptr, + const std::vector> *default_keybinds = nullptr) { + auto keybind__ = keybind ? _fbb.CreateVector>(*keybind) : 0; + auto default_keybinds__ = default_keybinds ? _fbb.CreateVector>(*default_keybinds) : 0; + return solarxr_protocol::rpc::CreateKeybindResponse( + _fbb, + keybind__, + default_keybinds__); } -template<> inline const solarxr_protocol::rpc::ChangeSkeletonConfigRequest *RpcMessageHeader::message_as() const { - return message_as_ChangeSkeletonConfigRequest(); -} +struct ChangeKeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeKeybindRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND = 4 + }; + const solarxr_protocol::rpc::Keybind *keybind() const { + return GetPointer(VT_KEYBIND); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_KEYBIND) && + verifier.VerifyTable(keybind()) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::SkeletonResetAllRequest *RpcMessageHeader::message_as() const { - return message_as_SkeletonResetAllRequest(); -} +struct ChangeKeybindRequestBuilder { + typedef ChangeKeybindRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind(flatbuffers::Offset keybind) { + fbb_.AddOffset(ChangeKeybindRequest::VT_KEYBIND, keybind); + } + explicit ChangeKeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::SkeletonConfigResponse *RpcMessageHeader::message_as() const { - return message_as_SkeletonConfigResponse(); +inline flatbuffers::Offset CreateChangeKeybindRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset keybind = 0) { + ChangeKeybindRequestBuilder builder_(_fbb); + builder_.add_keybind(keybind); + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::OpenSerialRequest *RpcMessageHeader::message_as() const { - return message_as_OpenSerialRequest(); -} +/// Requests the current state of `OverlayDisplayModeResponse`. +struct OverlayDisplayModeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OverlayDisplayModeRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::CloseSerialRequest *RpcMessageHeader::message_as() const { - return message_as_CloseSerialRequest(); -} +struct OverlayDisplayModeRequestBuilder { + typedef OverlayDisplayModeRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit OverlayDisplayModeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::SetWifiRequest *RpcMessageHeader::message_as() const { - return message_as_SetWifiRequest(); +inline flatbuffers::Offset CreateOverlayDisplayModeRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + OverlayDisplayModeRequestBuilder builder_(_fbb); + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::SerialUpdateResponse *RpcMessageHeader::message_as() const { - return message_as_SerialUpdateResponse(); -} +/// Changes the state of the overlay's display mode. +struct OverlayDisplayModeChangeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OverlayDisplayModeChangeRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IS_VISIBLE = 4, + VT_IS_MIRRORED = 6 + }; + flatbuffers::Optional is_visible() const { + return GetOptional(VT_IS_VISIBLE); + } + flatbuffers::Optional is_mirrored() const { + return GetOptional(VT_IS_MIRRORED); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IS_VISIBLE, 1) && + VerifyField(verifier, VT_IS_MIRRORED, 1) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::AutoBoneProcessRequest *RpcMessageHeader::message_as() const { - return message_as_AutoBoneProcessRequest(); -} +struct OverlayDisplayModeChangeRequestBuilder { + typedef OverlayDisplayModeChangeRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_is_visible(bool is_visible) { + fbb_.AddElement(OverlayDisplayModeChangeRequest::VT_IS_VISIBLE, static_cast(is_visible)); + } + void add_is_mirrored(bool is_mirrored) { + fbb_.AddElement(OverlayDisplayModeChangeRequest::VT_IS_MIRRORED, static_cast(is_mirrored)); + } + explicit OverlayDisplayModeChangeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; -template<> inline const solarxr_protocol::rpc::AutoBoneProcessStatusResponse *RpcMessageHeader::message_as() const { - return message_as_AutoBoneProcessStatusResponse(); +inline flatbuffers::Offset CreateOverlayDisplayModeChangeRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Optional is_visible = flatbuffers::nullopt, + flatbuffers::Optional is_mirrored = flatbuffers::nullopt) { + OverlayDisplayModeChangeRequestBuilder builder_(_fbb); + if(is_mirrored) { builder_.add_is_mirrored(*is_mirrored); } + if(is_visible) { builder_.add_is_visible(*is_visible); } + return builder_.Finish(); } -template<> inline const solarxr_protocol::rpc::AutoBoneEpochResponse *RpcMessageHeader::message_as() const { - return message_as_AutoBoneEpochResponse(); -} +/// The current state of the overlay's display mode. +struct OverlayDisplayModeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OverlayDisplayModeResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IS_VISIBLE = 4, + VT_IS_MIRRORED = 6 + }; + bool is_visible() const { + return GetField(VT_IS_VISIBLE, 0) != 0; + } + bool is_mirrored() const { + return GetField(VT_IS_MIRRORED, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IS_VISIBLE, 1) && + VerifyField(verifier, VT_IS_MIRRORED, 1) && + verifier.EndTable(); + } +}; -template<> inline const solarxr_protocol::rpc::OverlayDisplayModeRequest *RpcMessageHeader::message_as() const { - return message_as_OverlayDisplayModeRequest(); -} - -template<> inline const solarxr_protocol::rpc::OverlayDisplayModeChangeRequest *RpcMessageHeader::message_as() const { - return message_as_OverlayDisplayModeChangeRequest(); -} - -template<> inline const solarxr_protocol::rpc::OverlayDisplayModeResponse *RpcMessageHeader::message_as() const { - return message_as_OverlayDisplayModeResponse(); -} - -template<> inline const solarxr_protocol::rpc::SerialTrackerRebootRequest *RpcMessageHeader::message_as() const { - return message_as_SerialTrackerRebootRequest(); -} - -template<> inline const solarxr_protocol::rpc::SerialTrackerGetInfoRequest *RpcMessageHeader::message_as() const { - return message_as_SerialTrackerGetInfoRequest(); -} - -template<> inline const solarxr_protocol::rpc::SerialTrackerFactoryResetRequest *RpcMessageHeader::message_as() const { - return message_as_SerialTrackerFactoryResetRequest(); -} - -template<> inline const solarxr_protocol::rpc::SerialDevicesRequest *RpcMessageHeader::message_as() const { - return message_as_SerialDevicesRequest(); -} - -template<> inline const solarxr_protocol::rpc::SerialDevicesResponse *RpcMessageHeader::message_as() const { - return message_as_SerialDevicesResponse(); -} - -template<> inline const solarxr_protocol::rpc::NewSerialDeviceResponse *RpcMessageHeader::message_as() const { - return message_as_NewSerialDeviceResponse(); -} - -template<> inline const solarxr_protocol::rpc::StartWifiProvisioningRequest *RpcMessageHeader::message_as() const { - return message_as_StartWifiProvisioningRequest(); -} - -template<> inline const solarxr_protocol::rpc::StopWifiProvisioningRequest *RpcMessageHeader::message_as() const { - return message_as_StopWifiProvisioningRequest(); -} - -template<> inline const solarxr_protocol::rpc::WifiProvisioningStatusResponse *RpcMessageHeader::message_as() const { - return message_as_WifiProvisioningStatusResponse(); -} - -template<> inline const solarxr_protocol::rpc::ServerInfosRequest *RpcMessageHeader::message_as() const { - return message_as_ServerInfosRequest(); -} - -template<> inline const solarxr_protocol::rpc::ServerInfosResponse *RpcMessageHeader::message_as() const { - return message_as_ServerInfosResponse(); -} - -template<> inline const solarxr_protocol::rpc::LegTweaksTmpChange *RpcMessageHeader::message_as() const { - return message_as_LegTweaksTmpChange(); -} - -template<> inline const solarxr_protocol::rpc::LegTweaksTmpClear *RpcMessageHeader::message_as() const { - return message_as_LegTweaksTmpClear(); -} - -template<> inline const solarxr_protocol::rpc::TapDetectionSetupNotification *RpcMessageHeader::message_as() const { - return message_as_TapDetectionSetupNotification(); -} - -template<> inline const solarxr_protocol::rpc::SetPauseTrackingRequest *RpcMessageHeader::message_as() const { - return message_as_SetPauseTrackingRequest(); -} - -template<> inline const solarxr_protocol::rpc::StatusSystemRequest *RpcMessageHeader::message_as() const { - return message_as_StatusSystemRequest(); -} - -template<> inline const solarxr_protocol::rpc::StatusSystemResponse *RpcMessageHeader::message_as() const { - return message_as_StatusSystemResponse(); -} - -template<> inline const solarxr_protocol::rpc::StatusSystemUpdate *RpcMessageHeader::message_as() const { - return message_as_StatusSystemUpdate(); -} - -template<> inline const solarxr_protocol::rpc::StatusSystemFixed *RpcMessageHeader::message_as() const { - return message_as_StatusSystemFixed(); -} - -template<> inline const solarxr_protocol::rpc::ClearMountingResetRequest *RpcMessageHeader::message_as() const { - return message_as_ClearMountingResetRequest(); -} - -template<> inline const solarxr_protocol::rpc::HeightRequest *RpcMessageHeader::message_as() const { - return message_as_HeightRequest(); -} - -template<> inline const solarxr_protocol::rpc::HeightResponse *RpcMessageHeader::message_as() const { - return message_as_HeightResponse(); -} - -template<> inline const solarxr_protocol::rpc::AutoBoneApplyRequest *RpcMessageHeader::message_as() const { - return message_as_AutoBoneApplyRequest(); -} - -template<> inline const solarxr_protocol::rpc::AutoBoneStopRecordingRequest *RpcMessageHeader::message_as() const { - return message_as_AutoBoneStopRecordingRequest(); -} - -template<> inline const solarxr_protocol::rpc::AutoBoneCancelRecordingRequest *RpcMessageHeader::message_as() const { - return message_as_AutoBoneCancelRecordingRequest(); -} - -template<> inline const solarxr_protocol::rpc::SaveFileNotification *RpcMessageHeader::message_as() const { - return message_as_SaveFileNotification(); -} - -template<> inline const solarxr_protocol::rpc::TrackingPauseStateRequest *RpcMessageHeader::message_as() const { - return message_as_TrackingPauseStateRequest(); -} - -template<> inline const solarxr_protocol::rpc::TrackingPauseStateResponse *RpcMessageHeader::message_as() const { - return message_as_TrackingPauseStateResponse(); -} - -template<> inline const solarxr_protocol::rpc::SerialTrackerGetWifiScanRequest *RpcMessageHeader::message_as() const { - return message_as_SerialTrackerGetWifiScanRequest(); -} - -template<> inline const solarxr_protocol::rpc::UnknownDeviceHandshakeNotification *RpcMessageHeader::message_as() const { - return message_as_UnknownDeviceHandshakeNotification(); -} - -template<> inline const solarxr_protocol::rpc::AddUnknownDeviceRequest *RpcMessageHeader::message_as() const { - return message_as_AddUnknownDeviceRequest(); -} - -template<> inline const solarxr_protocol::rpc::ForgetDeviceRequest *RpcMessageHeader::message_as() const { - return message_as_ForgetDeviceRequest(); -} - -template<> inline const solarxr_protocol::rpc::FirmwareUpdateRequest *RpcMessageHeader::message_as() const { - return message_as_FirmwareUpdateRequest(); -} - -template<> inline const solarxr_protocol::rpc::FirmwareUpdateStatusResponse *RpcMessageHeader::message_as() const { - return message_as_FirmwareUpdateStatusResponse(); -} - -template<> inline const solarxr_protocol::rpc::FirmwareUpdateStopQueuesRequest *RpcMessageHeader::message_as() const { - return message_as_FirmwareUpdateStopQueuesRequest(); -} - -template<> inline const solarxr_protocol::rpc::SettingsResetRequest *RpcMessageHeader::message_as() const { - return message_as_SettingsResetRequest(); -} - -template<> inline const solarxr_protocol::rpc::MagToggleRequest *RpcMessageHeader::message_as() const { - return message_as_MagToggleRequest(); -} - -template<> inline const solarxr_protocol::rpc::MagToggleResponse *RpcMessageHeader::message_as() const { - return message_as_MagToggleResponse(); -} - -template<> inline const solarxr_protocol::rpc::ChangeMagToggleRequest *RpcMessageHeader::message_as() const { - return message_as_ChangeMagToggleRequest(); -} - -template<> inline const solarxr_protocol::rpc::RecordBVHStatusRequest *RpcMessageHeader::message_as() const { - return message_as_RecordBVHStatusRequest(); -} - -template<> inline const solarxr_protocol::rpc::VRCConfigStateRequest *RpcMessageHeader::message_as() const { - return message_as_VRCConfigStateRequest(); -} - -template<> inline const solarxr_protocol::rpc::VRCConfigStateChangeResponse *RpcMessageHeader::message_as() const { - return message_as_VRCConfigStateChangeResponse(); -} - -template<> inline const solarxr_protocol::rpc::EnableStayAlignedRequest *RpcMessageHeader::message_as() const { - return message_as_EnableStayAlignedRequest(); -} - -template<> inline const solarxr_protocol::rpc::DetectStayAlignedRelaxedPoseRequest *RpcMessageHeader::message_as() const { - return message_as_DetectStayAlignedRelaxedPoseRequest(); -} - -template<> inline const solarxr_protocol::rpc::ResetStayAlignedRelaxedPoseRequest *RpcMessageHeader::message_as() const { - return message_as_ResetStayAlignedRelaxedPoseRequest(); -} - -template<> inline const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest *RpcMessageHeader::message_as() const { - return message_as_SerialTrackerCustomCommandRequest(); -} - -template<> inline const solarxr_protocol::rpc::VRCConfigSettingToggleMute *RpcMessageHeader::message_as() const { - return message_as_VRCConfigSettingToggleMute(); -} - -template<> inline const solarxr_protocol::rpc::TrackingChecklistRequest *RpcMessageHeader::message_as() const { - return message_as_TrackingChecklistRequest(); -} - -template<> inline const solarxr_protocol::rpc::TrackingChecklistResponse *RpcMessageHeader::message_as() const { - return message_as_TrackingChecklistResponse(); -} - -template<> inline const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *RpcMessageHeader::message_as() const { - return message_as_IgnoreTrackingChecklistStepRequest(); -} - -template<> inline const solarxr_protocol::rpc::StartUserHeightCalibration *RpcMessageHeader::message_as() const { - return message_as_StartUserHeightCalibration(); -} - -template<> inline const solarxr_protocol::rpc::CancelUserHeightCalibration *RpcMessageHeader::message_as() const { - return message_as_CancelUserHeightCalibration(); -} - -template<> inline const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *RpcMessageHeader::message_as() const { - return message_as_UserHeightRecordingStatusResponse(); -} - -template<> inline const solarxr_protocol::rpc::KeybindRequest *RpcMessageHeader::message_as() const { - return message_as_KeybindRequest(); -} - -template<> inline const solarxr_protocol::rpc::ChangeKeybindRequest *RpcMessageHeader::message_as() const { - return message_as_ChangeKeybindRequest(); -} - -template<> inline const solarxr_protocol::rpc::KeybindResponse *RpcMessageHeader::message_as() const { - return message_as_KeybindResponse(); -} - -template<> inline const solarxr_protocol::rpc::InstalledInfoRequest *RpcMessageHeader::message_as() const { - return message_as_InstalledInfoRequest(); -} - -template<> inline const solarxr_protocol::rpc::InstalledInfoResponse *RpcMessageHeader::message_as() const { - return message_as_InstalledInfoResponse(); -} - -template<> inline const solarxr_protocol::rpc::OpenUriRequest *RpcMessageHeader::message_as() const { - return message_as_OpenUriRequest(); -} - -template<> inline const solarxr_protocol::rpc::OpenUriResponse *RpcMessageHeader::message_as() const { - return message_as_OpenUriResponse(); -} - -template<> inline const solarxr_protocol::rpc::EnableSteamVRDriverRequest *RpcMessageHeader::message_as() const { - return message_as_EnableSteamVRDriverRequest(); -} - -struct RpcMessageHeaderBuilder { - typedef RpcMessageHeader Table; +struct OverlayDisplayModeResponseBuilder { + typedef OverlayDisplayModeResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tx_id(const solarxr_protocol::datatypes::TransactionId *tx_id) { - fbb_.AddStruct(RpcMessageHeader::VT_TX_ID, tx_id); - } - void add_message_type(solarxr_protocol::rpc::RpcMessage message_type) { - fbb_.AddElement(RpcMessageHeader::VT_MESSAGE_TYPE, static_cast(message_type), 0); + void add_is_visible(bool is_visible) { + fbb_.AddElement(OverlayDisplayModeResponse::VT_IS_VISIBLE, static_cast(is_visible), 0); } - void add_message(flatbuffers::Offset message) { - fbb_.AddOffset(RpcMessageHeader::VT_MESSAGE, message); + void add_is_mirrored(bool is_mirrored) { + fbb_.AddElement(OverlayDisplayModeResponse::VT_IS_MIRRORED, static_cast(is_mirrored), 0); } - explicit RpcMessageHeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OverlayDisplayModeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRpcMessageHeader( +inline flatbuffers::Offset CreateOverlayDisplayModeResponse( flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::TransactionId *tx_id = nullptr, - solarxr_protocol::rpc::RpcMessage message_type = solarxr_protocol::rpc::RpcMessage::NONE, - flatbuffers::Offset message = 0) { - RpcMessageHeaderBuilder builder_(_fbb); - builder_.add_message(message); - builder_.add_tx_id(tx_id); - builder_.add_message_type(message_type); - return builder_.Finish(); -} - -struct InstalledInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef InstalledInfoRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; - -struct InstalledInfoRequestBuilder { - typedef InstalledInfoRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit InstalledInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateInstalledInfoRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - InstalledInfoRequestBuilder builder_(_fbb); + bool is_visible = false, + bool is_mirrored = false) { + OverlayDisplayModeResponseBuilder builder_(_fbb); + builder_.add_is_mirrored(is_mirrored); + builder_.add_is_visible(is_visible); return builder_.Finish(); } -struct InstalledInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef InstalledInfoResponseBuilder Builder; +struct StartWifiProvisioningRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StartWifiProvisioningRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ISUDEVINSTALLED = 4, - VT_ISWAYLAND = 6 + VT_SSID = 4, + VT_PASSWORD = 6, + VT_PORT = 8 }; - bool isUdevInstalled() const { - return GetField(VT_ISUDEVINSTALLED, 0) != 0; + const flatbuffers::String *ssid() const { + return GetPointer(VT_SSID); + } + const flatbuffers::String *password() const { + return GetPointer(VT_PASSWORD); } - bool isWayland() const { - return GetField(VT_ISWAYLAND, 0) != 0; + const flatbuffers::String *port() const { + return GetPointer(VT_PORT); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ISUDEVINSTALLED, 1) && - VerifyField(verifier, VT_ISWAYLAND, 1) && + VerifyOffset(verifier, VT_SSID) && + verifier.VerifyString(ssid()) && + VerifyOffset(verifier, VT_PASSWORD) && + verifier.VerifyString(password()) && + VerifyOffset(verifier, VT_PORT) && + verifier.VerifyString(port()) && verifier.EndTable(); } }; -struct InstalledInfoResponseBuilder { - typedef InstalledInfoResponse Table; +struct StartWifiProvisioningRequestBuilder { + typedef StartWifiProvisioningRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_isUdevInstalled(bool isUdevInstalled) { - fbb_.AddElement(InstalledInfoResponse::VT_ISUDEVINSTALLED, static_cast(isUdevInstalled), 0); + void add_ssid(flatbuffers::Offset ssid) { + fbb_.AddOffset(StartWifiProvisioningRequest::VT_SSID, ssid); } - void add_isWayland(bool isWayland) { - fbb_.AddElement(InstalledInfoResponse::VT_ISWAYLAND, static_cast(isWayland), 0); + void add_password(flatbuffers::Offset password) { + fbb_.AddOffset(StartWifiProvisioningRequest::VT_PASSWORD, password); } - explicit InstalledInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_port(flatbuffers::Offset port) { + fbb_.AddOffset(StartWifiProvisioningRequest::VT_PORT, port); + } + explicit StartWifiProvisioningRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateInstalledInfoResponse( +inline flatbuffers::Offset CreateStartWifiProvisioningRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool isUdevInstalled = false, - bool isWayland = false) { - InstalledInfoResponseBuilder builder_(_fbb); - builder_.add_isWayland(isWayland); - builder_.add_isUdevInstalled(isUdevInstalled); + flatbuffers::Offset ssid = 0, + flatbuffers::Offset password = 0, + flatbuffers::Offset port = 0) { + StartWifiProvisioningRequestBuilder builder_(_fbb); + builder_.add_port(port); + builder_.add_password(password); + builder_.add_ssid(ssid); return builder_.Finish(); } -struct HeartbeatRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HeartbeatRequestBuilder Builder; +inline flatbuffers::Offset CreateStartWifiProvisioningRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *ssid = nullptr, + const char *password = nullptr, + const char *port = nullptr) { + auto ssid__ = ssid ? _fbb.CreateString(ssid) : 0; + auto password__ = password ? _fbb.CreateString(password) : 0; + auto port__ = port ? _fbb.CreateString(port) : 0; + return solarxr_protocol::rpc::CreateStartWifiProvisioningRequest( + _fbb, + ssid__, + password__, + port__); +} + +struct StopWifiProvisioningRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StopWifiProvisioningRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct HeartbeatRequestBuilder { - typedef HeartbeatRequest Table; +struct StopWifiProvisioningRequestBuilder { + typedef StopWifiProvisioningRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit HeartbeatRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StopWifiProvisioningRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHeartbeatRequest( +inline flatbuffers::Offset CreateStopWifiProvisioningRequest( flatbuffers::FlatBufferBuilder &_fbb) { - HeartbeatRequestBuilder builder_(_fbb); + StopWifiProvisioningRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct HeartbeatResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HeartbeatResponseBuilder Builder; +struct WifiProvisioningStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef WifiProvisioningStatusResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_STATUS = 4 + }; + solarxr_protocol::rpc::WifiProvisioningStatus status() const { + return static_cast(GetField(VT_STATUS, 0)); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_STATUS, 1) && verifier.EndTable(); } }; -struct HeartbeatResponseBuilder { - typedef HeartbeatResponse Table; +struct WifiProvisioningStatusResponseBuilder { + typedef WifiProvisioningStatusResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit HeartbeatResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_status(solarxr_protocol::rpc::WifiProvisioningStatus status) { + fbb_.AddElement(WifiProvisioningStatusResponse::VT_STATUS, static_cast(status), 0); + } + explicit WifiProvisioningStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHeartbeatResponse( - flatbuffers::FlatBufferBuilder &_fbb) { - HeartbeatResponseBuilder builder_(_fbb); +inline flatbuffers::Offset CreateWifiProvisioningStatusResponse( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::WifiProvisioningStatus status = solarxr_protocol::rpc::WifiProvisioningStatus::NONE) { + WifiProvisioningStatusResponseBuilder builder_(_fbb); + builder_.add_status(status); return builder_.Finish(); } @@ -7150,7 +7153,7 @@ struct ResetRequestBuilder { inline flatbuffers::Offset CreateResetRequest( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, + solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::YAW, flatbuffers::Offset> body_parts = 0, flatbuffers::Optional delay = flatbuffers::nullopt) { ResetRequestBuilder builder_(_fbb); @@ -7162,7 +7165,7 @@ inline flatbuffers::Offset CreateResetRequest( inline flatbuffers::Offset CreateResetRequestDirect( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, + solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::YAW, const std::vector *body_parts = nullptr, flatbuffers::Optional delay = flatbuffers::nullopt) { auto body_parts__ = body_parts ? _fbb.CreateVector(*body_parts) : 0; @@ -7188,13 +7191,12 @@ struct ResetResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { solarxr_protocol::rpc::ResetStatus status() const { return static_cast(GetField(VT_STATUS, 0)); } - /// Should return the body parts reseted / being reset + /// Should return the body parts reset / being reset const flatbuffers::Vector *body_parts() const { return GetPointer *>(VT_BODY_PARTS); } /// gives the time in seconds passed since the start of the reset - /// is 0 when status == FINISHED - /// starts at 0 + /// Starts at 0. Should be equal to 'duration' when status == FINISHED int32_t progress() const { return GetField(VT_PROGRESS, 0); } @@ -7245,7 +7247,7 @@ struct ResetResponseBuilder { inline flatbuffers::Offset CreateResetResponse( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, + solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::YAW, solarxr_protocol::rpc::ResetStatus status = solarxr_protocol::rpc::ResetStatus::STARTED, flatbuffers::Offset> body_parts = 0, int32_t progress = 0, @@ -7261,7 +7263,7 @@ inline flatbuffers::Offset CreateResetResponse( inline flatbuffers::Offset CreateResetResponseDirect( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, + solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::YAW, solarxr_protocol::rpc::ResetStatus status = solarxr_protocol::rpc::ResetStatus::STARTED, const std::vector *body_parts = nullptr, int32_t progress = 0, @@ -7276,7625 +7278,6682 @@ inline flatbuffers::Offset CreateResetResponseDirect( duration); } -struct AssignTrackerRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AssignTrackerRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4, - VT_BODY_POSITION = 6, - VT_MOUNTING_ORIENTATION = 8, - VT_DISPLAY_NAME = 10, - VT_ALLOW_DRIFT_COMPENSATION = 12 - }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); - } - solarxr_protocol::datatypes::BodyPart body_position() const { - return static_cast(GetField(VT_BODY_POSITION, 0)); - } - const solarxr_protocol::datatypes::math::Quat *mounting_orientation() const { - return GetStruct(VT_MOUNTING_ORIENTATION); - } - const flatbuffers::String *display_name() const { - return GetPointer(VT_DISPLAY_NAME); - } - bool allow_drift_compensation() const { - return GetField(VT_ALLOW_DRIFT_COMPENSATION, 0) != 0; - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && - VerifyField(verifier, VT_BODY_POSITION, 1) && - VerifyField(verifier, VT_MOUNTING_ORIENTATION, 4) && - VerifyOffset(verifier, VT_DISPLAY_NAME) && - verifier.VerifyString(display_name()) && - VerifyField(verifier, VT_ALLOW_DRIFT_COMPENSATION, 1) && - verifier.EndTable(); - } -}; - -struct AssignTrackerRequestBuilder { - typedef AssignTrackerRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(AssignTrackerRequest::VT_TRACKER_ID, tracker_id); - } - void add_body_position(solarxr_protocol::datatypes::BodyPart body_position) { - fbb_.AddElement(AssignTrackerRequest::VT_BODY_POSITION, static_cast(body_position), 0); - } - void add_mounting_orientation(const solarxr_protocol::datatypes::math::Quat *mounting_orientation) { - fbb_.AddStruct(AssignTrackerRequest::VT_MOUNTING_ORIENTATION, mounting_orientation); - } - void add_display_name(flatbuffers::Offset display_name) { - fbb_.AddOffset(AssignTrackerRequest::VT_DISPLAY_NAME, display_name); - } - void add_allow_drift_compensation(bool allow_drift_compensation) { - fbb_.AddElement(AssignTrackerRequest::VT_ALLOW_DRIFT_COMPENSATION, static_cast(allow_drift_compensation), 0); - } - explicit AssignTrackerRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateAssignTrackerRequest( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0, - solarxr_protocol::datatypes::BodyPart body_position = solarxr_protocol::datatypes::BodyPart::NONE, - const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, - flatbuffers::Offset display_name = 0, - bool allow_drift_compensation = false) { - AssignTrackerRequestBuilder builder_(_fbb); - builder_.add_display_name(display_name); - builder_.add_mounting_orientation(mounting_orientation); - builder_.add_tracker_id(tracker_id); - builder_.add_allow_drift_compensation(allow_drift_compensation); - builder_.add_body_position(body_position); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateAssignTrackerRequestDirect( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0, - solarxr_protocol::datatypes::BodyPart body_position = solarxr_protocol::datatypes::BodyPart::NONE, - const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, - const char *display_name = nullptr, - bool allow_drift_compensation = false) { - auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0; - return solarxr_protocol::rpc::CreateAssignTrackerRequest( - _fbb, - tracker_id, - body_position, - mounting_orientation, - display_name__, - allow_drift_compensation); -} - -struct ClearDriftCompensationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ClearDriftCompensationRequestBuilder Builder; +/// Clears mounting reset data, defaulting to the manually set mounting orientations +struct ClearMountingResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ClearMountingResetRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct ClearDriftCompensationRequestBuilder { - typedef ClearDriftCompensationRequest Table; +struct ClearMountingResetRequestBuilder { + typedef ClearMountingResetRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit ClearDriftCompensationRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ClearMountingResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateClearDriftCompensationRequest( +inline flatbuffers::Offset CreateClearMountingResetRequest( flatbuffers::FlatBufferBuilder &_fbb) { - ClearDriftCompensationRequestBuilder builder_(_fbb); + ClearMountingResetRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct SettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SettingsRequestBuilder Builder; +struct ResetsSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResetsSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct SettingsRequestBuilder { - typedef SettingsRequest Table; +struct ResetsSettingsRequestBuilder { + typedef ResetsSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ResetsSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSettingsRequest( +inline flatbuffers::Offset CreateResetsSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb) { - SettingsRequestBuilder builder_(_fbb); - return builder_.Finish(); -} - -struct SettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SettingsResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STEAM_VR_TRACKERS = 4, - VT_FILTERING = 6, - VT_DRIFT_COMPENSATION = 8, - VT_OSC_ROUTER = 10, - VT_VRC_OSC = 12, - VT_VMC_OSC = 14, - VT_MODEL_SETTINGS = 16, - VT_TAP_DETECTION_SETTINGS = 18, - VT_AUTO_BONE_SETTINGS = 20, - VT_RESETS_SETTINGS = 22, - VT_STAY_ALIGNED = 24, - VT_HID_SETTINGS = 26, - VT_TIMEOUT = 28, - VT_VELOCITY_SETTINGS = 30, - VT_VRM = 32 - }; - const solarxr_protocol::rpc::SteamVRTrackersSetting *steam_vr_trackers() const { - return GetPointer(VT_STEAM_VR_TRACKERS); - } - const solarxr_protocol::rpc::FilteringSettings *filtering() const { - return GetPointer(VT_FILTERING); - } - const solarxr_protocol::rpc::DriftCompensationSettings *drift_compensation() const { - return GetPointer(VT_DRIFT_COMPENSATION); - } - const solarxr_protocol::rpc::OSCRouterSettings *osc_router() const { - return GetPointer(VT_OSC_ROUTER); - } - const solarxr_protocol::rpc::VRCOSCSettings *vrc_osc() const { - return GetPointer(VT_VRC_OSC); - } - const solarxr_protocol::rpc::VMCOSCSettings *vmc_osc() const { - return GetPointer(VT_VMC_OSC); - } - const solarxr_protocol::rpc::settings::ModelSettings *model_settings() const { - return GetPointer(VT_MODEL_SETTINGS); - } - const solarxr_protocol::rpc::TapDetectionSettings *tap_detection_settings() const { - return GetPointer(VT_TAP_DETECTION_SETTINGS); - } - const solarxr_protocol::rpc::AutoBoneSettings *auto_bone_settings() const { - return GetPointer(VT_AUTO_BONE_SETTINGS); - } - const solarxr_protocol::rpc::ResetsSettings *resets_settings() const { - return GetPointer(VT_RESETS_SETTINGS); - } - const solarxr_protocol::rpc::StayAlignedSettings *stay_aligned() const { - return GetPointer(VT_STAY_ALIGNED); - } - const solarxr_protocol::rpc::HIDSettings *hid_settings() const { - return GetPointer(VT_HID_SETTINGS); - } - const solarxr_protocol::rpc::TimeoutSettings *timeout() const { - return GetPointer(VT_TIMEOUT); - } - const solarxr_protocol::rpc::VelocitySettings *velocity_settings() const { - return GetPointer(VT_VELOCITY_SETTINGS); - } - const solarxr_protocol::rpc::VRMSettings *vrm() const { - return GetPointer(VT_VRM); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_STEAM_VR_TRACKERS) && - verifier.VerifyTable(steam_vr_trackers()) && - VerifyOffset(verifier, VT_FILTERING) && - verifier.VerifyTable(filtering()) && - VerifyOffset(verifier, VT_DRIFT_COMPENSATION) && - verifier.VerifyTable(drift_compensation()) && - VerifyOffset(verifier, VT_OSC_ROUTER) && - verifier.VerifyTable(osc_router()) && - VerifyOffset(verifier, VT_VRC_OSC) && - verifier.VerifyTable(vrc_osc()) && - VerifyOffset(verifier, VT_VMC_OSC) && - verifier.VerifyTable(vmc_osc()) && - VerifyOffset(verifier, VT_MODEL_SETTINGS) && - verifier.VerifyTable(model_settings()) && - VerifyOffset(verifier, VT_TAP_DETECTION_SETTINGS) && - verifier.VerifyTable(tap_detection_settings()) && - VerifyOffset(verifier, VT_AUTO_BONE_SETTINGS) && - verifier.VerifyTable(auto_bone_settings()) && - VerifyOffset(verifier, VT_RESETS_SETTINGS) && - verifier.VerifyTable(resets_settings()) && - VerifyOffset(verifier, VT_STAY_ALIGNED) && - verifier.VerifyTable(stay_aligned()) && - VerifyOffset(verifier, VT_HID_SETTINGS) && - verifier.VerifyTable(hid_settings()) && - VerifyOffset(verifier, VT_TIMEOUT) && - verifier.VerifyTable(timeout()) && - VerifyOffset(verifier, VT_VELOCITY_SETTINGS) && - verifier.VerifyTable(velocity_settings()) && - VerifyOffset(verifier, VT_VRM) && - verifier.VerifyTable(vrm()) && - verifier.EndTable(); - } -}; - -struct SettingsResponseBuilder { - typedef SettingsResponse Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_steam_vr_trackers(flatbuffers::Offset steam_vr_trackers) { - fbb_.AddOffset(SettingsResponse::VT_STEAM_VR_TRACKERS, steam_vr_trackers); - } - void add_filtering(flatbuffers::Offset filtering) { - fbb_.AddOffset(SettingsResponse::VT_FILTERING, filtering); - } - void add_drift_compensation(flatbuffers::Offset drift_compensation) { - fbb_.AddOffset(SettingsResponse::VT_DRIFT_COMPENSATION, drift_compensation); - } - void add_osc_router(flatbuffers::Offset osc_router) { - fbb_.AddOffset(SettingsResponse::VT_OSC_ROUTER, osc_router); - } - void add_vrc_osc(flatbuffers::Offset vrc_osc) { - fbb_.AddOffset(SettingsResponse::VT_VRC_OSC, vrc_osc); - } - void add_vmc_osc(flatbuffers::Offset vmc_osc) { - fbb_.AddOffset(SettingsResponse::VT_VMC_OSC, vmc_osc); - } - void add_model_settings(flatbuffers::Offset model_settings) { - fbb_.AddOffset(SettingsResponse::VT_MODEL_SETTINGS, model_settings); - } - void add_tap_detection_settings(flatbuffers::Offset tap_detection_settings) { - fbb_.AddOffset(SettingsResponse::VT_TAP_DETECTION_SETTINGS, tap_detection_settings); - } - void add_auto_bone_settings(flatbuffers::Offset auto_bone_settings) { - fbb_.AddOffset(SettingsResponse::VT_AUTO_BONE_SETTINGS, auto_bone_settings); - } - void add_resets_settings(flatbuffers::Offset resets_settings) { - fbb_.AddOffset(SettingsResponse::VT_RESETS_SETTINGS, resets_settings); - } - void add_stay_aligned(flatbuffers::Offset stay_aligned) { - fbb_.AddOffset(SettingsResponse::VT_STAY_ALIGNED, stay_aligned); - } - void add_hid_settings(flatbuffers::Offset hid_settings) { - fbb_.AddOffset(SettingsResponse::VT_HID_SETTINGS, hid_settings); - } - void add_timeout(flatbuffers::Offset timeout) { - fbb_.AddOffset(SettingsResponse::VT_TIMEOUT, timeout); - } - void add_velocity_settings(flatbuffers::Offset velocity_settings) { - fbb_.AddOffset(SettingsResponse::VT_VELOCITY_SETTINGS, velocity_settings); - } - void add_vrm(flatbuffers::Offset vrm) { - fbb_.AddOffset(SettingsResponse::VT_VRM, vrm); - } - explicit SettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateSettingsResponse( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset steam_vr_trackers = 0, - flatbuffers::Offset filtering = 0, - flatbuffers::Offset drift_compensation = 0, - flatbuffers::Offset osc_router = 0, - flatbuffers::Offset vrc_osc = 0, - flatbuffers::Offset vmc_osc = 0, - flatbuffers::Offset model_settings = 0, - flatbuffers::Offset tap_detection_settings = 0, - flatbuffers::Offset auto_bone_settings = 0, - flatbuffers::Offset resets_settings = 0, - flatbuffers::Offset stay_aligned = 0, - flatbuffers::Offset hid_settings = 0, - flatbuffers::Offset timeout = 0, - flatbuffers::Offset velocity_settings = 0, - flatbuffers::Offset vrm = 0) { - SettingsResponseBuilder builder_(_fbb); - builder_.add_vrm(vrm); - builder_.add_velocity_settings(velocity_settings); - builder_.add_timeout(timeout); - builder_.add_hid_settings(hid_settings); - builder_.add_stay_aligned(stay_aligned); - builder_.add_resets_settings(resets_settings); - builder_.add_auto_bone_settings(auto_bone_settings); - builder_.add_tap_detection_settings(tap_detection_settings); - builder_.add_model_settings(model_settings); - builder_.add_vmc_osc(vmc_osc); - builder_.add_vrc_osc(vrc_osc); - builder_.add_osc_router(osc_router); - builder_.add_drift_compensation(drift_compensation); - builder_.add_filtering(filtering); - builder_.add_steam_vr_trackers(steam_vr_trackers); + ResetsSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct ChangeSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ChangeSettingsRequestBuilder Builder; +struct ResetsSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResetsSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STEAM_VR_TRACKERS = 4, - VT_FILTERING = 6, - VT_DRIFT_COMPENSATION = 8, - VT_OSC_ROUTER = 10, - VT_VRC_OSC = 12, - VT_VMC_OSC = 14, - VT_MODEL_SETTINGS = 16, - VT_TAP_DETECTION_SETTINGS = 18, - VT_AUTO_BONE_SETTINGS = 20, - VT_RESETS_SETTINGS = 22, - VT_STAY_ALIGNED = 24, - VT_HID_SETTINGS = 26, - VT_TIMEOUT = 28, - VT_VELOCITY_SETTINGS = 30, - VT_VRM = 32 + VT_RESET_MOUNTING_FEET = 4, + VT_ARMS_RESET_MODE = 6, + VT_YAW_RESET_SMOOTH_TIME = 8, + VT_SAVE_MOUNTING_RESET = 10, + VT_RESET_HMD_PITCH = 12 }; - const solarxr_protocol::rpc::SteamVRTrackersSetting *steam_vr_trackers() const { - return GetPointer(VT_STEAM_VR_TRACKERS); - } - const solarxr_protocol::rpc::FilteringSettings *filtering() const { - return GetPointer(VT_FILTERING); - } - const solarxr_protocol::rpc::DriftCompensationSettings *drift_compensation() const { - return GetPointer(VT_DRIFT_COMPENSATION); - } - const solarxr_protocol::rpc::OSCRouterSettings *osc_router() const { - return GetPointer(VT_OSC_ROUTER); - } - const solarxr_protocol::rpc::VRCOSCSettings *vrc_osc() const { - return GetPointer(VT_VRC_OSC); - } - const solarxr_protocol::rpc::VMCOSCSettings *vmc_osc() const { - return GetPointer(VT_VMC_OSC); - } - const solarxr_protocol::rpc::settings::ModelSettings *model_settings() const { - return GetPointer(VT_MODEL_SETTINGS); - } - const solarxr_protocol::rpc::TapDetectionSettings *tap_detection_settings() const { - return GetPointer(VT_TAP_DETECTION_SETTINGS); - } - const solarxr_protocol::rpc::AutoBoneSettings *auto_bone_settings() const { - return GetPointer(VT_AUTO_BONE_SETTINGS); - } - const solarxr_protocol::rpc::ResetsSettings *resets_settings() const { - return GetPointer(VT_RESETS_SETTINGS); - } - const solarxr_protocol::rpc::StayAlignedSettings *stay_aligned() const { - return GetPointer(VT_STAY_ALIGNED); + /// Makes it so feet will be mounting reset when passing no BodyPart + bool reset_mounting_feet() const { + return GetField(VT_RESET_MOUNTING_FEET, 0) != 0; } - const solarxr_protocol::rpc::HIDSettings *hid_settings() const { - return GetPointer(VT_HID_SETTINGS); + solarxr_protocol::rpc::ArmsResetMode arms_reset_mode() const { + return static_cast(GetField(VT_ARMS_RESET_MODE, 0)); } - const solarxr_protocol::rpc::TimeoutSettings *timeout() const { - return GetPointer(VT_TIMEOUT); + float yaw_reset_smooth_time() const { + return GetField(VT_YAW_RESET_SMOOTH_TIME, 0.0f); } - const solarxr_protocol::rpc::VelocitySettings *velocity_settings() const { - return GetPointer(VT_VELOCITY_SETTINGS); + bool save_mounting_reset() const { + return GetField(VT_SAVE_MOUNTING_RESET, 0) != 0; } - const solarxr_protocol::rpc::VRMSettings *vrm() const { - return GetPointer(VT_VRM); + bool reset_hmd_pitch() const { + return GetField(VT_RESET_HMD_PITCH, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_STEAM_VR_TRACKERS) && - verifier.VerifyTable(steam_vr_trackers()) && - VerifyOffset(verifier, VT_FILTERING) && - verifier.VerifyTable(filtering()) && - VerifyOffset(verifier, VT_DRIFT_COMPENSATION) && - verifier.VerifyTable(drift_compensation()) && - VerifyOffset(verifier, VT_OSC_ROUTER) && - verifier.VerifyTable(osc_router()) && - VerifyOffset(verifier, VT_VRC_OSC) && - verifier.VerifyTable(vrc_osc()) && - VerifyOffset(verifier, VT_VMC_OSC) && - verifier.VerifyTable(vmc_osc()) && - VerifyOffset(verifier, VT_MODEL_SETTINGS) && - verifier.VerifyTable(model_settings()) && - VerifyOffset(verifier, VT_TAP_DETECTION_SETTINGS) && - verifier.VerifyTable(tap_detection_settings()) && - VerifyOffset(verifier, VT_AUTO_BONE_SETTINGS) && - verifier.VerifyTable(auto_bone_settings()) && - VerifyOffset(verifier, VT_RESETS_SETTINGS) && - verifier.VerifyTable(resets_settings()) && - VerifyOffset(verifier, VT_STAY_ALIGNED) && - verifier.VerifyTable(stay_aligned()) && - VerifyOffset(verifier, VT_HID_SETTINGS) && - verifier.VerifyTable(hid_settings()) && - VerifyOffset(verifier, VT_TIMEOUT) && - verifier.VerifyTable(timeout()) && - VerifyOffset(verifier, VT_VELOCITY_SETTINGS) && - verifier.VerifyTable(velocity_settings()) && - VerifyOffset(verifier, VT_VRM) && - verifier.VerifyTable(vrm()) && + VerifyField(verifier, VT_RESET_MOUNTING_FEET, 1) && + VerifyField(verifier, VT_ARMS_RESET_MODE, 1) && + VerifyField(verifier, VT_YAW_RESET_SMOOTH_TIME, 4) && + VerifyField(verifier, VT_SAVE_MOUNTING_RESET, 1) && + VerifyField(verifier, VT_RESET_HMD_PITCH, 1) && verifier.EndTable(); } }; -struct ChangeSettingsRequestBuilder { - typedef ChangeSettingsRequest Table; +struct ResetsSettingsResponseBuilder { + typedef ResetsSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_steam_vr_trackers(flatbuffers::Offset steam_vr_trackers) { - fbb_.AddOffset(ChangeSettingsRequest::VT_STEAM_VR_TRACKERS, steam_vr_trackers); - } - void add_filtering(flatbuffers::Offset filtering) { - fbb_.AddOffset(ChangeSettingsRequest::VT_FILTERING, filtering); - } - void add_drift_compensation(flatbuffers::Offset drift_compensation) { - fbb_.AddOffset(ChangeSettingsRequest::VT_DRIFT_COMPENSATION, drift_compensation); - } - void add_osc_router(flatbuffers::Offset osc_router) { - fbb_.AddOffset(ChangeSettingsRequest::VT_OSC_ROUTER, osc_router); - } - void add_vrc_osc(flatbuffers::Offset vrc_osc) { - fbb_.AddOffset(ChangeSettingsRequest::VT_VRC_OSC, vrc_osc); - } - void add_vmc_osc(flatbuffers::Offset vmc_osc) { - fbb_.AddOffset(ChangeSettingsRequest::VT_VMC_OSC, vmc_osc); - } - void add_model_settings(flatbuffers::Offset model_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_MODEL_SETTINGS, model_settings); - } - void add_tap_detection_settings(flatbuffers::Offset tap_detection_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_TAP_DETECTION_SETTINGS, tap_detection_settings); - } - void add_auto_bone_settings(flatbuffers::Offset auto_bone_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_AUTO_BONE_SETTINGS, auto_bone_settings); - } - void add_resets_settings(flatbuffers::Offset resets_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_RESETS_SETTINGS, resets_settings); - } - void add_stay_aligned(flatbuffers::Offset stay_aligned) { - fbb_.AddOffset(ChangeSettingsRequest::VT_STAY_ALIGNED, stay_aligned); + void add_reset_mounting_feet(bool reset_mounting_feet) { + fbb_.AddElement(ResetsSettingsResponse::VT_RESET_MOUNTING_FEET, static_cast(reset_mounting_feet), 0); } - void add_hid_settings(flatbuffers::Offset hid_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_HID_SETTINGS, hid_settings); + void add_arms_reset_mode(solarxr_protocol::rpc::ArmsResetMode arms_reset_mode) { + fbb_.AddElement(ResetsSettingsResponse::VT_ARMS_RESET_MODE, static_cast(arms_reset_mode), 0); } - void add_timeout(flatbuffers::Offset timeout) { - fbb_.AddOffset(ChangeSettingsRequest::VT_TIMEOUT, timeout); + void add_yaw_reset_smooth_time(float yaw_reset_smooth_time) { + fbb_.AddElement(ResetsSettingsResponse::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0f); } - void add_velocity_settings(flatbuffers::Offset velocity_settings) { - fbb_.AddOffset(ChangeSettingsRequest::VT_VELOCITY_SETTINGS, velocity_settings); + void add_save_mounting_reset(bool save_mounting_reset) { + fbb_.AddElement(ResetsSettingsResponse::VT_SAVE_MOUNTING_RESET, static_cast(save_mounting_reset), 0); } - void add_vrm(flatbuffers::Offset vrm) { - fbb_.AddOffset(ChangeSettingsRequest::VT_VRM, vrm); + void add_reset_hmd_pitch(bool reset_hmd_pitch) { + fbb_.AddElement(ResetsSettingsResponse::VT_RESET_HMD_PITCH, static_cast(reset_hmd_pitch), 0); } - explicit ChangeSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ResetsSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateChangeSettingsRequest( +inline flatbuffers::Offset CreateResetsSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset steam_vr_trackers = 0, - flatbuffers::Offset filtering = 0, - flatbuffers::Offset drift_compensation = 0, - flatbuffers::Offset osc_router = 0, - flatbuffers::Offset vrc_osc = 0, - flatbuffers::Offset vmc_osc = 0, - flatbuffers::Offset model_settings = 0, - flatbuffers::Offset tap_detection_settings = 0, - flatbuffers::Offset auto_bone_settings = 0, - flatbuffers::Offset resets_settings = 0, - flatbuffers::Offset stay_aligned = 0, - flatbuffers::Offset hid_settings = 0, - flatbuffers::Offset timeout = 0, - flatbuffers::Offset velocity_settings = 0, - flatbuffers::Offset vrm = 0) { - ChangeSettingsRequestBuilder builder_(_fbb); - builder_.add_vrm(vrm); - builder_.add_velocity_settings(velocity_settings); - builder_.add_timeout(timeout); - builder_.add_hid_settings(hid_settings); - builder_.add_stay_aligned(stay_aligned); - builder_.add_resets_settings(resets_settings); - builder_.add_auto_bone_settings(auto_bone_settings); - builder_.add_tap_detection_settings(tap_detection_settings); - builder_.add_model_settings(model_settings); - builder_.add_vmc_osc(vmc_osc); - builder_.add_vrc_osc(vrc_osc); - builder_.add_osc_router(osc_router); - builder_.add_drift_compensation(drift_compensation); - builder_.add_filtering(filtering); - builder_.add_steam_vr_trackers(steam_vr_trackers); + bool reset_mounting_feet = false, + solarxr_protocol::rpc::ArmsResetMode arms_reset_mode = solarxr_protocol::rpc::ArmsResetMode::BACK, + float yaw_reset_smooth_time = 0.0f, + bool save_mounting_reset = false, + bool reset_hmd_pitch = false) { + ResetsSettingsResponseBuilder builder_(_fbb); + builder_.add_yaw_reset_smooth_time(yaw_reset_smooth_time); + builder_.add_reset_hmd_pitch(reset_hmd_pitch); + builder_.add_save_mounting_reset(save_mounting_reset); + builder_.add_arms_reset_mode(arms_reset_mode); + builder_.add_reset_mounting_feet(reset_mounting_feet); return builder_.Finish(); } -struct SteamVRTrackersSetting FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SteamVRTrackersSettingBuilder Builder; +struct ChangeResetsSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeResetsSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_WAIST = 4, - VT_CHEST = 6, - VT_AUTOMATICTRACKERTOGGLE = 16, - VT_LEFT_FOOT = 18, - VT_RIGHT_FOOT = 20, - VT_LEFT_KNEE = 22, - VT_RIGHT_KNEE = 24, - VT_LEFT_ELBOW = 26, - VT_RIGHT_ELBOW = 28, - VT_LEFT_HAND = 30, - VT_RIGHT_HAND = 32 + VT_RESET_MOUNTING_FEET = 4, + VT_ARMS_RESET_MODE = 6, + VT_YAW_RESET_SMOOTH_TIME = 8, + VT_SAVE_MOUNTING_RESET = 10, + VT_RESET_HMD_PITCH = 12 }; - bool waist() const { - return GetField(VT_WAIST, 0) != 0; - } - bool chest() const { - return GetField(VT_CHEST, 0) != 0; - } - bool automaticTrackerToggle() const { - return GetField(VT_AUTOMATICTRACKERTOGGLE, 0) != 0; - } - bool left_foot() const { - return GetField(VT_LEFT_FOOT, 0) != 0; - } - bool right_foot() const { - return GetField(VT_RIGHT_FOOT, 0) != 0; - } - bool left_knee() const { - return GetField(VT_LEFT_KNEE, 0) != 0; - } - bool right_knee() const { - return GetField(VT_RIGHT_KNEE, 0) != 0; + /// Makes it so feet will be mounting reset when passing no BodyPart + bool reset_mounting_feet() const { + return GetField(VT_RESET_MOUNTING_FEET, 0) != 0; } - bool left_elbow() const { - return GetField(VT_LEFT_ELBOW, 0) != 0; + solarxr_protocol::rpc::ArmsResetMode arms_reset_mode() const { + return static_cast(GetField(VT_ARMS_RESET_MODE, 0)); } - bool right_elbow() const { - return GetField(VT_RIGHT_ELBOW, 0) != 0; + float yaw_reset_smooth_time() const { + return GetField(VT_YAW_RESET_SMOOTH_TIME, 0.0f); } - bool left_hand() const { - return GetField(VT_LEFT_HAND, 0) != 0; + bool save_mounting_reset() const { + return GetField(VT_SAVE_MOUNTING_RESET, 0) != 0; } - bool right_hand() const { - return GetField(VT_RIGHT_HAND, 0) != 0; + bool reset_hmd_pitch() const { + return GetField(VT_RESET_HMD_PITCH, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_WAIST, 1) && - VerifyField(verifier, VT_CHEST, 1) && - VerifyField(verifier, VT_AUTOMATICTRACKERTOGGLE, 1) && - VerifyField(verifier, VT_LEFT_FOOT, 1) && - VerifyField(verifier, VT_RIGHT_FOOT, 1) && - VerifyField(verifier, VT_LEFT_KNEE, 1) && - VerifyField(verifier, VT_RIGHT_KNEE, 1) && - VerifyField(verifier, VT_LEFT_ELBOW, 1) && - VerifyField(verifier, VT_RIGHT_ELBOW, 1) && - VerifyField(verifier, VT_LEFT_HAND, 1) && - VerifyField(verifier, VT_RIGHT_HAND, 1) && + VerifyField(verifier, VT_RESET_MOUNTING_FEET, 1) && + VerifyField(verifier, VT_ARMS_RESET_MODE, 1) && + VerifyField(verifier, VT_YAW_RESET_SMOOTH_TIME, 4) && + VerifyField(verifier, VT_SAVE_MOUNTING_RESET, 1) && + VerifyField(verifier, VT_RESET_HMD_PITCH, 1) && verifier.EndTable(); } }; -struct SteamVRTrackersSettingBuilder { - typedef SteamVRTrackersSetting Table; +struct ChangeResetsSettingsRequestBuilder { + typedef ChangeResetsSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_waist(bool waist) { - fbb_.AddElement(SteamVRTrackersSetting::VT_WAIST, static_cast(waist), 0); - } - void add_chest(bool chest) { - fbb_.AddElement(SteamVRTrackersSetting::VT_CHEST, static_cast(chest), 0); - } - void add_automaticTrackerToggle(bool automaticTrackerToggle) { - fbb_.AddElement(SteamVRTrackersSetting::VT_AUTOMATICTRACKERTOGGLE, static_cast(automaticTrackerToggle), 0); - } - void add_left_foot(bool left_foot) { - fbb_.AddElement(SteamVRTrackersSetting::VT_LEFT_FOOT, static_cast(left_foot), 0); - } - void add_right_foot(bool right_foot) { - fbb_.AddElement(SteamVRTrackersSetting::VT_RIGHT_FOOT, static_cast(right_foot), 0); - } - void add_left_knee(bool left_knee) { - fbb_.AddElement(SteamVRTrackersSetting::VT_LEFT_KNEE, static_cast(left_knee), 0); - } - void add_right_knee(bool right_knee) { - fbb_.AddElement(SteamVRTrackersSetting::VT_RIGHT_KNEE, static_cast(right_knee), 0); + void add_reset_mounting_feet(bool reset_mounting_feet) { + fbb_.AddElement(ChangeResetsSettingsRequest::VT_RESET_MOUNTING_FEET, static_cast(reset_mounting_feet), 0); } - void add_left_elbow(bool left_elbow) { - fbb_.AddElement(SteamVRTrackersSetting::VT_LEFT_ELBOW, static_cast(left_elbow), 0); + void add_arms_reset_mode(solarxr_protocol::rpc::ArmsResetMode arms_reset_mode) { + fbb_.AddElement(ChangeResetsSettingsRequest::VT_ARMS_RESET_MODE, static_cast(arms_reset_mode), 0); } - void add_right_elbow(bool right_elbow) { - fbb_.AddElement(SteamVRTrackersSetting::VT_RIGHT_ELBOW, static_cast(right_elbow), 0); + void add_yaw_reset_smooth_time(float yaw_reset_smooth_time) { + fbb_.AddElement(ChangeResetsSettingsRequest::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0f); } - void add_left_hand(bool left_hand) { - fbb_.AddElement(SteamVRTrackersSetting::VT_LEFT_HAND, static_cast(left_hand), 0); + void add_save_mounting_reset(bool save_mounting_reset) { + fbb_.AddElement(ChangeResetsSettingsRequest::VT_SAVE_MOUNTING_RESET, static_cast(save_mounting_reset), 0); } - void add_right_hand(bool right_hand) { - fbb_.AddElement(SteamVRTrackersSetting::VT_RIGHT_HAND, static_cast(right_hand), 0); + void add_reset_hmd_pitch(bool reset_hmd_pitch) { + fbb_.AddElement(ChangeResetsSettingsRequest::VT_RESET_HMD_PITCH, static_cast(reset_hmd_pitch), 0); } - explicit SteamVRTrackersSettingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ChangeResetsSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSteamVRTrackersSetting( +inline flatbuffers::Offset CreateChangeResetsSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool waist = false, - bool chest = false, - bool automaticTrackerToggle = false, - bool left_foot = false, - bool right_foot = false, - bool left_knee = false, - bool right_knee = false, - bool left_elbow = false, - bool right_elbow = false, - bool left_hand = false, - bool right_hand = false) { - SteamVRTrackersSettingBuilder builder_(_fbb); - builder_.add_right_hand(right_hand); - builder_.add_left_hand(left_hand); - builder_.add_right_elbow(right_elbow); - builder_.add_left_elbow(left_elbow); - builder_.add_right_knee(right_knee); - builder_.add_left_knee(left_knee); - builder_.add_right_foot(right_foot); - builder_.add_left_foot(left_foot); - builder_.add_automaticTrackerToggle(automaticTrackerToggle); - builder_.add_chest(chest); - builder_.add_waist(waist); + bool reset_mounting_feet = false, + solarxr_protocol::rpc::ArmsResetMode arms_reset_mode = solarxr_protocol::rpc::ArmsResetMode::BACK, + float yaw_reset_smooth_time = 0.0f, + bool save_mounting_reset = false, + bool reset_hmd_pitch = false) { + ChangeResetsSettingsRequestBuilder builder_(_fbb); + builder_.add_yaw_reset_smooth_time(yaw_reset_smooth_time); + builder_.add_reset_hmd_pitch(reset_hmd_pitch); + builder_.add_save_mounting_reset(save_mounting_reset); + builder_.add_arms_reset_mode(arms_reset_mode); + builder_.add_reset_mounting_feet(reset_mounting_feet); return builder_.Finish(); } -struct FilteringSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef FilteringSettingsBuilder Builder; +struct SerialDevice FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialDeviceBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TYPE = 4, - VT_AMOUNT = 6 + VT_PORT = 4, + VT_NAME = 6, + VT_TYPE = 8 }; - solarxr_protocol::datatypes::FilteringType type() const { - return static_cast(GetField(VT_TYPE, 0)); + const flatbuffers::String *port() const { + return GetPointer(VT_PORT); } - /// 0 to 1. A higher value results in more smoothing or prediction - float amount() const { - return GetField(VT_AMOUNT, 0.0f); + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + solarxr_protocol::rpc::SerialDeviceType type() const { + return static_cast(GetField(VT_TYPE, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PORT) && + verifier.VerifyString(port()) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && VerifyField(verifier, VT_TYPE, 1) && - VerifyField(verifier, VT_AMOUNT, 4) && verifier.EndTable(); } }; -struct FilteringSettingsBuilder { - typedef FilteringSettings Table; +struct SerialDeviceBuilder { + typedef SerialDevice Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_type(solarxr_protocol::datatypes::FilteringType type) { - fbb_.AddElement(FilteringSettings::VT_TYPE, static_cast(type), 0); + void add_port(flatbuffers::Offset port) { + fbb_.AddOffset(SerialDevice::VT_PORT, port); } - void add_amount(float amount) { - fbb_.AddElement(FilteringSettings::VT_AMOUNT, amount, 0.0f); + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(SerialDevice::VT_NAME, name); + } + void add_type(solarxr_protocol::rpc::SerialDeviceType type) { + fbb_.AddElement(SerialDevice::VT_TYPE, static_cast(type), 0); } - explicit FilteringSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialDeviceBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFilteringSettings( +inline flatbuffers::Offset CreateSerialDevice( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::datatypes::FilteringType type = solarxr_protocol::datatypes::FilteringType::NONE, - float amount = 0.0f) { - FilteringSettingsBuilder builder_(_fbb); - builder_.add_amount(amount); + flatbuffers::Offset port = 0, + flatbuffers::Offset name = 0, + solarxr_protocol::rpc::SerialDeviceType type = solarxr_protocol::rpc::SerialDeviceType::ESP_TRACKER) { + SerialDeviceBuilder builder_(_fbb); + builder_.add_name(name); + builder_.add_port(port); builder_.add_type(type); return builder_.Finish(); } -/// Settings related to IMU yaw drift compensation -struct DriftCompensationSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef DriftCompensationSettingsBuilder Builder; +inline flatbuffers::Offset CreateSerialDeviceDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *port = nullptr, + const char *name = nullptr, + solarxr_protocol::rpc::SerialDeviceType type = solarxr_protocol::rpc::SerialDeviceType::ESP_TRACKER) { + auto port__ = port ? _fbb.CreateString(port) : 0; + auto name__ = name ? _fbb.CreateString(name) : 0; + return solarxr_protocol::rpc::CreateSerialDevice( + _fbb, + port__, + name__, + type); +} + +struct OpenSerialRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OpenSerialRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENABLED = 4, - VT_PREDICTION = 6, - VT_AMOUNT = 8, - VT_MAX_RESETS = 10 + VT_AUTO_ = 4, + VT_PORT = 6 }; - bool enabled() const { - return GetField(VT_ENABLED, 0) != 0; - } - bool prediction() const { - return GetField(VT_PREDICTION, 0) != 0; - } - /// 0 to 1. A higher value results in more yaw drift compensation - float amount() const { - return GetField(VT_AMOUNT, 0.0f); + /// Automatically pick the first serial device available + bool auto_() const { + return GetField(VT_AUTO_, 0) != 0; } - /// Number of previous resets to take into account when calculating yaw drift - uint16_t max_resets() const { - return GetField(VT_MAX_RESETS, 0); + const flatbuffers::String *port() const { + return GetPointer(VT_PORT); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ENABLED, 1) && - VerifyField(verifier, VT_PREDICTION, 1) && - VerifyField(verifier, VT_AMOUNT, 4) && - VerifyField(verifier, VT_MAX_RESETS, 2) && + VerifyField(verifier, VT_AUTO_, 1) && + VerifyOffset(verifier, VT_PORT) && + verifier.VerifyString(port()) && verifier.EndTable(); } }; -struct DriftCompensationSettingsBuilder { - typedef DriftCompensationSettings Table; +struct OpenSerialRequestBuilder { + typedef OpenSerialRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_enabled(bool enabled) { - fbb_.AddElement(DriftCompensationSettings::VT_ENABLED, static_cast(enabled), 0); - } - void add_prediction(bool prediction) { - fbb_.AddElement(DriftCompensationSettings::VT_PREDICTION, static_cast(prediction), 0); - } - void add_amount(float amount) { - fbb_.AddElement(DriftCompensationSettings::VT_AMOUNT, amount, 0.0f); + void add_auto_(bool auto_) { + fbb_.AddElement(OpenSerialRequest::VT_AUTO_, static_cast(auto_), 0); } - void add_max_resets(uint16_t max_resets) { - fbb_.AddElement(DriftCompensationSettings::VT_MAX_RESETS, max_resets, 0); + void add_port(flatbuffers::Offset port) { + fbb_.AddOffset(OpenSerialRequest::VT_PORT, port); } - explicit DriftCompensationSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OpenSerialRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDriftCompensationSettings( +inline flatbuffers::Offset CreateOpenSerialRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool enabled = false, - bool prediction = false, - float amount = 0.0f, - uint16_t max_resets = 0) { - DriftCompensationSettingsBuilder builder_(_fbb); - builder_.add_amount(amount); - builder_.add_max_resets(max_resets); - builder_.add_prediction(prediction); - builder_.add_enabled(enabled); + bool auto_ = false, + flatbuffers::Offset port = 0) { + OpenSerialRequestBuilder builder_(_fbb); + builder_.add_port(port); + builder_.add_auto_(auto_); return builder_.Finish(); } -/// OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. -struct OSCRouterSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OSCRouterSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_OSC_SETTINGS = 4 - }; - const solarxr_protocol::rpc::OSCSettings *osc_settings() const { - return GetPointer(VT_OSC_SETTINGS); - } +inline flatbuffers::Offset CreateOpenSerialRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool auto_ = false, + const char *port = nullptr) { + auto port__ = port ? _fbb.CreateString(port) : 0; + return solarxr_protocol::rpc::CreateOpenSerialRequest( + _fbb, + auto_, + port__); +} + +struct CloseSerialRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CloseSerialRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_OSC_SETTINGS) && - verifier.VerifyTable(osc_settings()) && verifier.EndTable(); } }; -struct OSCRouterSettingsBuilder { - typedef OSCRouterSettings Table; +struct CloseSerialRequestBuilder { + typedef CloseSerialRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_osc_settings(flatbuffers::Offset osc_settings) { - fbb_.AddOffset(OSCRouterSettings::VT_OSC_SETTINGS, osc_settings); - } - explicit OSCRouterSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit CloseSerialRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOSCRouterSettings( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset osc_settings = 0) { - OSCRouterSettingsBuilder builder_(_fbb); - builder_.add_osc_settings(osc_settings); +inline flatbuffers::Offset CreateCloseSerialRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + CloseSerialRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// OSC Settings specific to VRChat -struct VRCOSCSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCOSCSettingsBuilder Builder; +struct SerialUpdateResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialUpdateResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_OSC_SETTINGS = 4, - VT_TRACKERS = 6, - VT_OSCQUERY_ENABLED = 8 + VT_LOG = 4, + VT_CLOSED = 6, + VT_DEVICE = 8 }; - const solarxr_protocol::rpc::OSCSettings *osc_settings() const { - return GetPointer(VT_OSC_SETTINGS); + const flatbuffers::String *log() const { + return GetPointer(VT_LOG); } - const solarxr_protocol::rpc::OSCTrackersSetting *trackers() const { - return GetPointer(VT_TRACKERS); + bool closed() const { + return GetField(VT_CLOSED, 0) != 0; } - bool oscquery_enabled() const { - return GetField(VT_OSCQUERY_ENABLED, 0) != 0; + const solarxr_protocol::rpc::SerialDevice *device() const { + return GetPointer(VT_DEVICE); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_OSC_SETTINGS) && - verifier.VerifyTable(osc_settings()) && - VerifyOffset(verifier, VT_TRACKERS) && - verifier.VerifyTable(trackers()) && - VerifyField(verifier, VT_OSCQUERY_ENABLED, 1) && + VerifyOffset(verifier, VT_LOG) && + verifier.VerifyString(log()) && + VerifyField(verifier, VT_CLOSED, 1) && + VerifyOffset(verifier, VT_DEVICE) && + verifier.VerifyTable(device()) && verifier.EndTable(); } }; -struct VRCOSCSettingsBuilder { - typedef VRCOSCSettings Table; +struct SerialUpdateResponseBuilder { + typedef SerialUpdateResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_osc_settings(flatbuffers::Offset osc_settings) { - fbb_.AddOffset(VRCOSCSettings::VT_OSC_SETTINGS, osc_settings); + void add_log(flatbuffers::Offset log) { + fbb_.AddOffset(SerialUpdateResponse::VT_LOG, log); } - void add_trackers(flatbuffers::Offset trackers) { - fbb_.AddOffset(VRCOSCSettings::VT_TRACKERS, trackers); + void add_closed(bool closed) { + fbb_.AddElement(SerialUpdateResponse::VT_CLOSED, static_cast(closed), 0); } - void add_oscquery_enabled(bool oscquery_enabled) { - fbb_.AddElement(VRCOSCSettings::VT_OSCQUERY_ENABLED, static_cast(oscquery_enabled), 0); + void add_device(flatbuffers::Offset device) { + fbb_.AddOffset(SerialUpdateResponse::VT_DEVICE, device); } - explicit VRCOSCSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialUpdateResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVRCOSCSettings( +inline flatbuffers::Offset CreateSerialUpdateResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset osc_settings = 0, - flatbuffers::Offset trackers = 0, - bool oscquery_enabled = false) { - VRCOSCSettingsBuilder builder_(_fbb); - builder_.add_trackers(trackers); - builder_.add_osc_settings(osc_settings); - builder_.add_oscquery_enabled(oscquery_enabled); + flatbuffers::Offset log = 0, + bool closed = false, + flatbuffers::Offset device = 0) { + SerialUpdateResponseBuilder builder_(_fbb); + builder_.add_device(device); + builder_.add_log(log); + builder_.add_closed(closed); return builder_.Finish(); } -/// OSC Settings specific to VMC -struct VMCOSCSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VMCOSCSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_OSC_SETTINGS = 4, - VT_ANCHOR_HIP = 8, - VT_MIRROR_TRACKING = 10 - }; - const solarxr_protocol::rpc::OSCSettings *osc_settings() const { - return GetPointer(VT_OSC_SETTINGS); - } - bool anchor_hip() const { - return GetField(VT_ANCHOR_HIP, 0) != 0; - } - bool mirror_tracking() const { - return GetField(VT_MIRROR_TRACKING, 0) != 0; - } +inline flatbuffers::Offset CreateSerialUpdateResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *log = nullptr, + bool closed = false, + flatbuffers::Offset device = 0) { + auto log__ = log ? _fbb.CreateString(log) : 0; + return solarxr_protocol::rpc::CreateSerialUpdateResponse( + _fbb, + log__, + closed, + device); +} + +/// Reboots the tracker connected to the serial monitor +struct SerialTrackerRebootRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialTrackerRebootRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_OSC_SETTINGS) && - verifier.VerifyTable(osc_settings()) && - VerifyField(verifier, VT_ANCHOR_HIP, 1) && - VerifyField(verifier, VT_MIRROR_TRACKING, 1) && verifier.EndTable(); } }; -struct VMCOSCSettingsBuilder { - typedef VMCOSCSettings Table; +struct SerialTrackerRebootRequestBuilder { + typedef SerialTrackerRebootRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_osc_settings(flatbuffers::Offset osc_settings) { - fbb_.AddOffset(VMCOSCSettings::VT_OSC_SETTINGS, osc_settings); - } - void add_anchor_hip(bool anchor_hip) { - fbb_.AddElement(VMCOSCSettings::VT_ANCHOR_HIP, static_cast(anchor_hip), 0); - } - void add_mirror_tracking(bool mirror_tracking) { - fbb_.AddElement(VMCOSCSettings::VT_MIRROR_TRACKING, static_cast(mirror_tracking), 0); - } - explicit VMCOSCSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialTrackerRebootRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVMCOSCSettings( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset osc_settings = 0, - bool anchor_hip = false, - bool mirror_tracking = false) { - VMCOSCSettingsBuilder builder_(_fbb); - builder_.add_osc_settings(osc_settings); - builder_.add_mirror_tracking(mirror_tracking); - builder_.add_anchor_hip(anchor_hip); +inline flatbuffers::Offset CreateSerialTrackerRebootRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SerialTrackerRebootRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// VRM Settings for rescaling to avatar-scale -struct VRMSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRMSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_VRM_JSON = 4 - }; - const flatbuffers::String *vrm_json() const { - return GetPointer(VT_VRM_JSON); - } +/// Sends the GET INFO cmd to the current tracker on the serial monitor +struct SerialTrackerGetInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialTrackerGetInfoRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_VRM_JSON) && - verifier.VerifyString(vrm_json()) && verifier.EndTable(); } }; -struct VRMSettingsBuilder { - typedef VRMSettings Table; +struct SerialTrackerGetInfoRequestBuilder { + typedef SerialTrackerGetInfoRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_vrm_json(flatbuffers::Offset vrm_json) { - fbb_.AddOffset(VRMSettings::VT_VRM_JSON, vrm_json); - } - explicit VRMSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialTrackerGetInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVRMSettings( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset vrm_json = 0) { - VRMSettingsBuilder builder_(_fbb); - builder_.add_vrm_json(vrm_json); +inline flatbuffers::Offset CreateSerialTrackerGetInfoRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SerialTrackerGetInfoRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateVRMSettingsDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *vrm_json = nullptr) { - auto vrm_json__ = vrm_json ? _fbb.CreateString(vrm_json) : 0; - return solarxr_protocol::rpc::CreateVRMSettings( - _fbb, - vrm_json__); +/// Sends the FRST cmd to the currently connected Tracker over the Serial Monitor +struct SerialTrackerFactoryResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialTrackerFactoryResetRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct SerialTrackerFactoryResetRequestBuilder { + typedef SerialTrackerFactoryResetRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit SerialTrackerFactoryResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateSerialTrackerFactoryResetRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SerialTrackerFactoryResetRequestBuilder builder_(_fbb); + return builder_.Finish(); } -/// OSC Settings that are used in *any* osc application. -struct OSCSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OSCSettingsBuilder Builder; +/// Sends a custom cmd to the currently connected Tracker over the Serial Monitor +struct SerialTrackerCustomCommandRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialTrackerCustomCommandRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENABLED = 4, - VT_PORT_IN = 6, - VT_PORT_OUT = 8, - VT_ADDRESS = 10 + VT_COMMAND = 4 }; - bool enabled() const { - return GetField(VT_ENABLED, 0) != 0; - } - uint16_t port_in() const { - return GetField(VT_PORT_IN, 0); - } - uint16_t port_out() const { - return GetField(VT_PORT_OUT, 0); - } - const flatbuffers::String *address() const { - return GetPointer(VT_ADDRESS); + const flatbuffers::String *command() const { + return GetPointer(VT_COMMAND); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ENABLED, 1) && - VerifyField(verifier, VT_PORT_IN, 2) && - VerifyField(verifier, VT_PORT_OUT, 2) && - VerifyOffset(verifier, VT_ADDRESS) && - verifier.VerifyString(address()) && + VerifyOffset(verifier, VT_COMMAND) && + verifier.VerifyString(command()) && verifier.EndTable(); } }; -struct OSCSettingsBuilder { - typedef OSCSettings Table; +struct SerialTrackerCustomCommandRequestBuilder { + typedef SerialTrackerCustomCommandRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_enabled(bool enabled) { - fbb_.AddElement(OSCSettings::VT_ENABLED, static_cast(enabled), 0); - } - void add_port_in(uint16_t port_in) { - fbb_.AddElement(OSCSettings::VT_PORT_IN, port_in, 0); - } - void add_port_out(uint16_t port_out) { - fbb_.AddElement(OSCSettings::VT_PORT_OUT, port_out, 0); - } - void add_address(flatbuffers::Offset address) { - fbb_.AddOffset(OSCSettings::VT_ADDRESS, address); + void add_command(flatbuffers::Offset command) { + fbb_.AddOffset(SerialTrackerCustomCommandRequest::VT_COMMAND, command); } - explicit OSCSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialTrackerCustomCommandRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOSCSettings( +inline flatbuffers::Offset CreateSerialTrackerCustomCommandRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool enabled = false, - uint16_t port_in = 0, - uint16_t port_out = 0, - flatbuffers::Offset address = 0) { - OSCSettingsBuilder builder_(_fbb); - builder_.add_address(address); - builder_.add_port_out(port_out); - builder_.add_port_in(port_in); - builder_.add_enabled(enabled); + flatbuffers::Offset command = 0) { + SerialTrackerCustomCommandRequestBuilder builder_(_fbb); + builder_.add_command(command); return builder_.Finish(); } -inline flatbuffers::Offset CreateOSCSettingsDirect( +inline flatbuffers::Offset CreateSerialTrackerCustomCommandRequestDirect( flatbuffers::FlatBufferBuilder &_fbb, - bool enabled = false, - uint16_t port_in = 0, - uint16_t port_out = 0, - const char *address = nullptr) { - auto address__ = address ? _fbb.CreateString(address) : 0; - return solarxr_protocol::rpc::CreateOSCSettings( + const char *command = nullptr) { + auto command__ = command ? _fbb.CreateString(command) : 0; + return solarxr_protocol::rpc::CreateSerialTrackerCustomCommandRequest( _fbb, - enabled, - port_in, - port_out, - address__); + command__); } -struct OSCTrackersSetting FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OSCTrackersSettingBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_HEAD = 4, - VT_CHEST = 6, - VT_WAIST = 8, - VT_KNEES = 10, - VT_FEET = 12, - VT_ELBOWS = 14, - VT_HANDS = 16 - }; - bool head() const { - return GetField(VT_HEAD, 0) != 0; - } - bool chest() const { - return GetField(VT_CHEST, 0) != 0; - } - bool waist() const { - return GetField(VT_WAIST, 0) != 0; - } - bool knees() const { - return GetField(VT_KNEES, 0) != 0; - } - bool feet() const { - return GetField(VT_FEET, 0) != 0; - } - bool elbows() const { - return GetField(VT_ELBOWS, 0) != 0; - } - bool hands() const { - return GetField(VT_HANDS, 0) != 0; - } +struct SerialDevicesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialDevicesRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_HEAD, 1) && - VerifyField(verifier, VT_CHEST, 1) && - VerifyField(verifier, VT_WAIST, 1) && - VerifyField(verifier, VT_KNEES, 1) && - VerifyField(verifier, VT_FEET, 1) && - VerifyField(verifier, VT_ELBOWS, 1) && - VerifyField(verifier, VT_HANDS, 1) && verifier.EndTable(); } }; -struct OSCTrackersSettingBuilder { - typedef OSCTrackersSetting Table; +struct SerialDevicesRequestBuilder { + typedef SerialDevicesRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_head(bool head) { - fbb_.AddElement(OSCTrackersSetting::VT_HEAD, static_cast(head), 0); - } - void add_chest(bool chest) { - fbb_.AddElement(OSCTrackersSetting::VT_CHEST, static_cast(chest), 0); - } - void add_waist(bool waist) { - fbb_.AddElement(OSCTrackersSetting::VT_WAIST, static_cast(waist), 0); - } - void add_knees(bool knees) { - fbb_.AddElement(OSCTrackersSetting::VT_KNEES, static_cast(knees), 0); - } - void add_feet(bool feet) { - fbb_.AddElement(OSCTrackersSetting::VT_FEET, static_cast(feet), 0); - } - void add_elbows(bool elbows) { - fbb_.AddElement(OSCTrackersSetting::VT_ELBOWS, static_cast(elbows), 0); - } - void add_hands(bool hands) { - fbb_.AddElement(OSCTrackersSetting::VT_HANDS, static_cast(hands), 0); - } - explicit OSCTrackersSettingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialDevicesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOSCTrackersSetting( - flatbuffers::FlatBufferBuilder &_fbb, - bool head = false, - bool chest = false, - bool waist = false, - bool knees = false, - bool feet = false, - bool elbows = false, - bool hands = false) { - OSCTrackersSettingBuilder builder_(_fbb); - builder_.add_hands(hands); - builder_.add_elbows(elbows); - builder_.add_feet(feet); - builder_.add_knees(knees); - builder_.add_waist(waist); - builder_.add_chest(chest); - builder_.add_head(head); +inline flatbuffers::Offset CreateSerialDevicesRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SerialDevicesRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct TapDetectionSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TapDetectionSettingsBuilder Builder; +struct SerialDevicesResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialDevicesResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FULL_RESET_DELAY = 4, - VT_FULL_RESET_ENABLED = 6, - VT_FULL_RESET_TAPS = 8, - VT_YAW_RESET_DELAY = 10, - VT_YAW_RESET_ENABLED = 12, - VT_YAW_RESET_TAPS = 14, - VT_MOUNTING_RESET_DELAY = 16, - VT_MOUNTING_RESET_ENABLED = 18, - VT_MOUNTING_RESET_TAPS = 20, - VT_SETUP_MODE = 22, - VT_NUMBER_TRACKERS_OVER_THRESHOLD = 24, - VT_YAW_RESET_TRACKER = 26, - VT_FULL_RESET_TRACKER = 28, - VT_MOUNTING_RESET_TRACKER = 30 + VT_DEVICES = 4 }; - flatbuffers::Optional full_reset_delay() const { - return GetOptional(VT_FULL_RESET_DELAY); - } - flatbuffers::Optional full_reset_enabled() const { - return GetOptional(VT_FULL_RESET_ENABLED); - } - flatbuffers::Optional full_reset_taps() const { - return GetOptional(VT_FULL_RESET_TAPS); - } - flatbuffers::Optional yaw_reset_delay() const { - return GetOptional(VT_YAW_RESET_DELAY); - } - flatbuffers::Optional yaw_reset_enabled() const { - return GetOptional(VT_YAW_RESET_ENABLED); - } - flatbuffers::Optional yaw_reset_taps() const { - return GetOptional(VT_YAW_RESET_TAPS); - } - flatbuffers::Optional mounting_reset_delay() const { - return GetOptional(VT_MOUNTING_RESET_DELAY); - } - flatbuffers::Optional mounting_reset_enabled() const { - return GetOptional(VT_MOUNTING_RESET_ENABLED); - } - flatbuffers::Optional mounting_reset_taps() const { - return GetOptional(VT_MOUNTING_RESET_TAPS); - } - /// If true, disables reset behavior of tap detection and sends a - /// TapDetectionSetupNotification, each time 2 taps are detected on any tracker - flatbuffers::Optional setup_mode() const { - return GetOptional(VT_SETUP_MODE); - } - flatbuffers::Optional number_trackers_over_threshold() const { - return GetOptional(VT_NUMBER_TRACKERS_OVER_THRESHOLD); - } - flatbuffers::Optional yaw_reset_tracker() const { - return GetOptional(VT_YAW_RESET_TRACKER); - } - flatbuffers::Optional full_reset_tracker() const { - return GetOptional(VT_FULL_RESET_TRACKER); - } - flatbuffers::Optional mounting_reset_tracker() const { - return GetOptional(VT_MOUNTING_RESET_TRACKER); + const flatbuffers::Vector> *devices() const { + return GetPointer> *>(VT_DEVICES); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_FULL_RESET_DELAY, 4) && - VerifyField(verifier, VT_FULL_RESET_ENABLED, 1) && - VerifyField(verifier, VT_FULL_RESET_TAPS, 1) && - VerifyField(verifier, VT_YAW_RESET_DELAY, 4) && - VerifyField(verifier, VT_YAW_RESET_ENABLED, 1) && - VerifyField(verifier, VT_YAW_RESET_TAPS, 1) && - VerifyField(verifier, VT_MOUNTING_RESET_DELAY, 4) && - VerifyField(verifier, VT_MOUNTING_RESET_ENABLED, 1) && - VerifyField(verifier, VT_MOUNTING_RESET_TAPS, 1) && - VerifyField(verifier, VT_SETUP_MODE, 1) && - VerifyField(verifier, VT_NUMBER_TRACKERS_OVER_THRESHOLD, 1) && - VerifyField(verifier, VT_YAW_RESET_TRACKER, 1) && - VerifyField(verifier, VT_FULL_RESET_TRACKER, 1) && - VerifyField(verifier, VT_MOUNTING_RESET_TRACKER, 1) && + VerifyOffset(verifier, VT_DEVICES) && + verifier.VerifyVector(devices()) && + verifier.VerifyVectorOfTables(devices()) && verifier.EndTable(); } }; -struct TapDetectionSettingsBuilder { - typedef TapDetectionSettings Table; +struct SerialDevicesResponseBuilder { + typedef SerialDevicesResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_full_reset_delay(float full_reset_delay) { - fbb_.AddElement(TapDetectionSettings::VT_FULL_RESET_DELAY, full_reset_delay); - } - void add_full_reset_enabled(bool full_reset_enabled) { - fbb_.AddElement(TapDetectionSettings::VT_FULL_RESET_ENABLED, static_cast(full_reset_enabled)); - } - void add_full_reset_taps(uint8_t full_reset_taps) { - fbb_.AddElement(TapDetectionSettings::VT_FULL_RESET_TAPS, full_reset_taps); - } - void add_yaw_reset_delay(float yaw_reset_delay) { - fbb_.AddElement(TapDetectionSettings::VT_YAW_RESET_DELAY, yaw_reset_delay); - } - void add_yaw_reset_enabled(bool yaw_reset_enabled) { - fbb_.AddElement(TapDetectionSettings::VT_YAW_RESET_ENABLED, static_cast(yaw_reset_enabled)); - } - void add_yaw_reset_taps(uint8_t yaw_reset_taps) { - fbb_.AddElement(TapDetectionSettings::VT_YAW_RESET_TAPS, yaw_reset_taps); - } - void add_mounting_reset_delay(float mounting_reset_delay) { - fbb_.AddElement(TapDetectionSettings::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); - } - void add_mounting_reset_enabled(bool mounting_reset_enabled) { - fbb_.AddElement(TapDetectionSettings::VT_MOUNTING_RESET_ENABLED, static_cast(mounting_reset_enabled)); - } - void add_mounting_reset_taps(uint8_t mounting_reset_taps) { - fbb_.AddElement(TapDetectionSettings::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); - } - void add_setup_mode(bool setup_mode) { - fbb_.AddElement(TapDetectionSettings::VT_SETUP_MODE, static_cast(setup_mode)); - } - void add_number_trackers_over_threshold(uint8_t number_trackers_over_threshold) { - fbb_.AddElement(TapDetectionSettings::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); - } - void add_yaw_reset_tracker(solarxr_protocol::datatypes::BodyPart yaw_reset_tracker) { - fbb_.AddElement(TapDetectionSettings::VT_YAW_RESET_TRACKER, static_cast(yaw_reset_tracker)); - } - void add_full_reset_tracker(solarxr_protocol::datatypes::BodyPart full_reset_tracker) { - fbb_.AddElement(TapDetectionSettings::VT_FULL_RESET_TRACKER, static_cast(full_reset_tracker)); - } - void add_mounting_reset_tracker(solarxr_protocol::datatypes::BodyPart mounting_reset_tracker) { - fbb_.AddElement(TapDetectionSettings::VT_MOUNTING_RESET_TRACKER, static_cast(mounting_reset_tracker)); + void add_devices(flatbuffers::Offset>> devices) { + fbb_.AddOffset(SerialDevicesResponse::VT_DEVICES, devices); } - explicit TapDetectionSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SerialDevicesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTapDetectionSettings( +inline flatbuffers::Offset CreateSerialDevicesResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional full_reset_delay = flatbuffers::nullopt, - flatbuffers::Optional full_reset_enabled = flatbuffers::nullopt, - flatbuffers::Optional full_reset_taps = flatbuffers::nullopt, - flatbuffers::Optional yaw_reset_delay = flatbuffers::nullopt, - flatbuffers::Optional yaw_reset_enabled = flatbuffers::nullopt, - flatbuffers::Optional yaw_reset_taps = flatbuffers::nullopt, - flatbuffers::Optional mounting_reset_delay = flatbuffers::nullopt, - flatbuffers::Optional mounting_reset_enabled = flatbuffers::nullopt, - flatbuffers::Optional mounting_reset_taps = flatbuffers::nullopt, - flatbuffers::Optional setup_mode = flatbuffers::nullopt, - flatbuffers::Optional number_trackers_over_threshold = flatbuffers::nullopt, - flatbuffers::Optional yaw_reset_tracker = flatbuffers::nullopt, - flatbuffers::Optional full_reset_tracker = flatbuffers::nullopt, - flatbuffers::Optional mounting_reset_tracker = flatbuffers::nullopt) { - TapDetectionSettingsBuilder builder_(_fbb); - if(mounting_reset_delay) { builder_.add_mounting_reset_delay(*mounting_reset_delay); } - if(yaw_reset_delay) { builder_.add_yaw_reset_delay(*yaw_reset_delay); } - if(full_reset_delay) { builder_.add_full_reset_delay(*full_reset_delay); } - if(mounting_reset_tracker) { builder_.add_mounting_reset_tracker(*mounting_reset_tracker); } - if(full_reset_tracker) { builder_.add_full_reset_tracker(*full_reset_tracker); } - if(yaw_reset_tracker) { builder_.add_yaw_reset_tracker(*yaw_reset_tracker); } - if(number_trackers_over_threshold) { builder_.add_number_trackers_over_threshold(*number_trackers_over_threshold); } - if(setup_mode) { builder_.add_setup_mode(*setup_mode); } - if(mounting_reset_taps) { builder_.add_mounting_reset_taps(*mounting_reset_taps); } - if(mounting_reset_enabled) { builder_.add_mounting_reset_enabled(*mounting_reset_enabled); } - if(yaw_reset_taps) { builder_.add_yaw_reset_taps(*yaw_reset_taps); } - if(yaw_reset_enabled) { builder_.add_yaw_reset_enabled(*yaw_reset_enabled); } - if(full_reset_taps) { builder_.add_full_reset_taps(*full_reset_taps); } - if(full_reset_enabled) { builder_.add_full_reset_enabled(*full_reset_enabled); } + flatbuffers::Offset>> devices = 0) { + SerialDevicesResponseBuilder builder_(_fbb); + builder_.add_devices(devices); return builder_.Finish(); } -struct ResetsSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ResetsSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_RESET_MOUNTING_FEET = 4, - VT_ARMS_MOUNTING_RESET_MODE = 6, - VT_YAW_RESET_SMOOTH_TIME = 8, - VT_SAVE_MOUNTING_RESET = 10, - VT_RESET_HMD_PITCH = 12 +inline flatbuffers::Offset CreateSerialDevicesResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *devices = nullptr) { + auto devices__ = devices ? _fbb.CreateVector>(*devices) : 0; + return solarxr_protocol::rpc::CreateSerialDevicesResponse( + _fbb, + devices__); +} + +struct NewSerialDeviceResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef NewSerialDeviceResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE = 4 }; - bool reset_mounting_feet() const { - return GetField(VT_RESET_MOUNTING_FEET, 0) != 0; - } - solarxr_protocol::rpc::ArmsMountingResetMode arms_mounting_reset_mode() const { - return static_cast(GetField(VT_ARMS_MOUNTING_RESET_MODE, 0)); - } - float yaw_reset_smooth_time() const { - return GetField(VT_YAW_RESET_SMOOTH_TIME, 0.0f); - } - bool save_mounting_reset() const { - return GetField(VT_SAVE_MOUNTING_RESET, 0) != 0; - } - bool reset_hmd_pitch() const { - return GetField(VT_RESET_HMD_PITCH, 0) != 0; + const solarxr_protocol::rpc::SerialDevice *device() const { + return GetPointer(VT_DEVICE); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_RESET_MOUNTING_FEET, 1) && - VerifyField(verifier, VT_ARMS_MOUNTING_RESET_MODE, 1) && - VerifyField(verifier, VT_YAW_RESET_SMOOTH_TIME, 4) && - VerifyField(verifier, VT_SAVE_MOUNTING_RESET, 1) && - VerifyField(verifier, VT_RESET_HMD_PITCH, 1) && + VerifyOffset(verifier, VT_DEVICE) && + verifier.VerifyTable(device()) && verifier.EndTable(); } }; -struct ResetsSettingsBuilder { - typedef ResetsSettings Table; +struct NewSerialDeviceResponseBuilder { + typedef NewSerialDeviceResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_reset_mounting_feet(bool reset_mounting_feet) { - fbb_.AddElement(ResetsSettings::VT_RESET_MOUNTING_FEET, static_cast(reset_mounting_feet), 0); - } - void add_arms_mounting_reset_mode(solarxr_protocol::rpc::ArmsMountingResetMode arms_mounting_reset_mode) { - fbb_.AddElement(ResetsSettings::VT_ARMS_MOUNTING_RESET_MODE, static_cast(arms_mounting_reset_mode), 0); - } - void add_yaw_reset_smooth_time(float yaw_reset_smooth_time) { - fbb_.AddElement(ResetsSettings::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0f); - } - void add_save_mounting_reset(bool save_mounting_reset) { - fbb_.AddElement(ResetsSettings::VT_SAVE_MOUNTING_RESET, static_cast(save_mounting_reset), 0); - } - void add_reset_hmd_pitch(bool reset_hmd_pitch) { - fbb_.AddElement(ResetsSettings::VT_RESET_HMD_PITCH, static_cast(reset_hmd_pitch), 0); + void add_device(flatbuffers::Offset device) { + fbb_.AddOffset(NewSerialDeviceResponse::VT_DEVICE, device); } - explicit ResetsSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit NewSerialDeviceResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateResetsSettings( +inline flatbuffers::Offset CreateNewSerialDeviceResponse( flatbuffers::FlatBufferBuilder &_fbb, - bool reset_mounting_feet = false, - solarxr_protocol::rpc::ArmsMountingResetMode arms_mounting_reset_mode = solarxr_protocol::rpc::ArmsMountingResetMode::BACK, - float yaw_reset_smooth_time = 0.0f, - bool save_mounting_reset = false, - bool reset_hmd_pitch = false) { - ResetsSettingsBuilder builder_(_fbb); - builder_.add_yaw_reset_smooth_time(yaw_reset_smooth_time); - builder_.add_reset_hmd_pitch(reset_hmd_pitch); - builder_.add_save_mounting_reset(save_mounting_reset); - builder_.add_arms_mounting_reset_mode(arms_mounting_reset_mode); - builder_.add_reset_mounting_feet(reset_mounting_feet); + flatbuffers::Offset device = 0) { + NewSerialDeviceResponseBuilder builder_(_fbb); + builder_.add_device(device); return builder_.Finish(); } -struct StayAlignedSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StayAlignedSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENABLED = 4, - VT_EXTRAYAWCORRECTION = 6, - VT_HIDEYAWCORRECTION = 8, - VT_STANDINGENABLED = 10, - VT_STANDINGUPPERLEGANGLE = 12, - VT_STANDINGLOWERLEGANGLE = 14, - VT_STANDINGFOOTANGLE = 16, - VT_SITTINGENABLED = 18, - VT_SITTINGUPPERLEGANGLE = 20, - VT_SITTINGLOWERLEGANGLE = 22, - VT_SITTINGFOOTANGLE = 24, - VT_FLATENABLED = 26, - VT_FLATUPPERLEGANGLE = 28, - VT_FLATLOWERLEGANGLE = 30, - VT_FLATFOOTANGLE = 32, - VT_SETUPCOMPLETE = 34 - }; - bool enabled() const { - return GetField(VT_ENABLED, 0) != 0; - } - bool extraYawCorrection() const { - return GetField(VT_EXTRAYAWCORRECTION, 0) != 0; - } - bool hideYawCorrection() const { - return GetField(VT_HIDEYAWCORRECTION, 0) != 0; - } - bool standingEnabled() const { - return GetField(VT_STANDINGENABLED, 0) != 0; - } - float standingUpperLegAngle() const { - return GetField(VT_STANDINGUPPERLEGANGLE, 0.0f); - } - float standingLowerLegAngle() const { - return GetField(VT_STANDINGLOWERLEGANGLE, 0.0f); - } - float standingFootAngle() const { - return GetField(VT_STANDINGFOOTANGLE, 0.0f); - } - bool sittingEnabled() const { - return GetField(VT_SITTINGENABLED, 0) != 0; - } - float sittingUpperLegAngle() const { - return GetField(VT_SITTINGUPPERLEGANGLE, 0.0f); - } - float sittingLowerLegAngle() const { - return GetField(VT_SITTINGLOWERLEGANGLE, 0.0f); - } - float sittingFootAngle() const { - return GetField(VT_SITTINGFOOTANGLE, 0.0f); - } - bool flatEnabled() const { - return GetField(VT_FLATENABLED, 0) != 0; - } - float flatUpperLegAngle() const { - return GetField(VT_FLATUPPERLEGANGLE, 0.0f); - } - float flatLowerLegAngle() const { - return GetField(VT_FLATLOWERLEGANGLE, 0.0f); - } - float flatFootAngle() const { - return GetField(VT_FLATFOOTANGLE, 0.0f); - } - bool setupComplete() const { - return GetField(VT_SETUPCOMPLETE, 0) != 0; - } +/// Sends the GET WIFISCAN cmd to the current tracker on the serial monitor +struct SerialTrackerGetWifiScanRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SerialTrackerGetWifiScanRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ENABLED, 1) && - VerifyField(verifier, VT_EXTRAYAWCORRECTION, 1) && - VerifyField(verifier, VT_HIDEYAWCORRECTION, 1) && - VerifyField(verifier, VT_STANDINGENABLED, 1) && - VerifyField(verifier, VT_STANDINGUPPERLEGANGLE, 4) && - VerifyField(verifier, VT_STANDINGLOWERLEGANGLE, 4) && - VerifyField(verifier, VT_STANDINGFOOTANGLE, 4) && - VerifyField(verifier, VT_SITTINGENABLED, 1) && - VerifyField(verifier, VT_SITTINGUPPERLEGANGLE, 4) && - VerifyField(verifier, VT_SITTINGLOWERLEGANGLE, 4) && - VerifyField(verifier, VT_SITTINGFOOTANGLE, 4) && - VerifyField(verifier, VT_FLATENABLED, 1) && - VerifyField(verifier, VT_FLATUPPERLEGANGLE, 4) && - VerifyField(verifier, VT_FLATLOWERLEGANGLE, 4) && - VerifyField(verifier, VT_FLATFOOTANGLE, 4) && - VerifyField(verifier, VT_SETUPCOMPLETE, 1) && verifier.EndTable(); } }; -struct StayAlignedSettingsBuilder { - typedef StayAlignedSettings Table; +struct SerialTrackerGetWifiScanRequestBuilder { + typedef SerialTrackerGetWifiScanRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_enabled(bool enabled) { - fbb_.AddElement(StayAlignedSettings::VT_ENABLED, static_cast(enabled), 0); - } - void add_extraYawCorrection(bool extraYawCorrection) { - fbb_.AddElement(StayAlignedSettings::VT_EXTRAYAWCORRECTION, static_cast(extraYawCorrection), 0); - } - void add_hideYawCorrection(bool hideYawCorrection) { - fbb_.AddElement(StayAlignedSettings::VT_HIDEYAWCORRECTION, static_cast(hideYawCorrection), 0); - } - void add_standingEnabled(bool standingEnabled) { - fbb_.AddElement(StayAlignedSettings::VT_STANDINGENABLED, static_cast(standingEnabled), 0); - } - void add_standingUpperLegAngle(float standingUpperLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_STANDINGUPPERLEGANGLE, standingUpperLegAngle, 0.0f); - } - void add_standingLowerLegAngle(float standingLowerLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_STANDINGLOWERLEGANGLE, standingLowerLegAngle, 0.0f); - } - void add_standingFootAngle(float standingFootAngle) { - fbb_.AddElement(StayAlignedSettings::VT_STANDINGFOOTANGLE, standingFootAngle, 0.0f); - } - void add_sittingEnabled(bool sittingEnabled) { - fbb_.AddElement(StayAlignedSettings::VT_SITTINGENABLED, static_cast(sittingEnabled), 0); - } - void add_sittingUpperLegAngle(float sittingUpperLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_SITTINGUPPERLEGANGLE, sittingUpperLegAngle, 0.0f); - } - void add_sittingLowerLegAngle(float sittingLowerLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_SITTINGLOWERLEGANGLE, sittingLowerLegAngle, 0.0f); - } - void add_sittingFootAngle(float sittingFootAngle) { - fbb_.AddElement(StayAlignedSettings::VT_SITTINGFOOTANGLE, sittingFootAngle, 0.0f); - } - void add_flatEnabled(bool flatEnabled) { - fbb_.AddElement(StayAlignedSettings::VT_FLATENABLED, static_cast(flatEnabled), 0); - } - void add_flatUpperLegAngle(float flatUpperLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_FLATUPPERLEGANGLE, flatUpperLegAngle, 0.0f); - } - void add_flatLowerLegAngle(float flatLowerLegAngle) { - fbb_.AddElement(StayAlignedSettings::VT_FLATLOWERLEGANGLE, flatLowerLegAngle, 0.0f); + explicit SerialTrackerGetWifiScanRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - void add_flatFootAngle(float flatFootAngle) { - fbb_.AddElement(StayAlignedSettings::VT_FLATFOOTANGLE, flatFootAngle, 0.0f); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - void add_setupComplete(bool setupComplete) { - fbb_.AddElement(StayAlignedSettings::VT_SETUPCOMPLETE, static_cast(setupComplete), 0); +}; + +inline flatbuffers::Offset CreateSerialTrackerGetWifiScanRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SerialTrackerGetWifiScanRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct HIDSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HIDSettingsRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - explicit StayAlignedSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) +}; + +struct HIDSettingsRequestBuilder { + typedef HIDSettingsRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit HIDSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStayAlignedSettings( - flatbuffers::FlatBufferBuilder &_fbb, - bool enabled = false, - bool extraYawCorrection = false, - bool hideYawCorrection = false, - bool standingEnabled = false, - float standingUpperLegAngle = 0.0f, - float standingLowerLegAngle = 0.0f, - float standingFootAngle = 0.0f, - bool sittingEnabled = false, - float sittingUpperLegAngle = 0.0f, - float sittingLowerLegAngle = 0.0f, - float sittingFootAngle = 0.0f, - bool flatEnabled = false, - float flatUpperLegAngle = 0.0f, - float flatLowerLegAngle = 0.0f, - float flatFootAngle = 0.0f, - bool setupComplete = false) { - StayAlignedSettingsBuilder builder_(_fbb); - builder_.add_flatFootAngle(flatFootAngle); - builder_.add_flatLowerLegAngle(flatLowerLegAngle); - builder_.add_flatUpperLegAngle(flatUpperLegAngle); - builder_.add_sittingFootAngle(sittingFootAngle); - builder_.add_sittingLowerLegAngle(sittingLowerLegAngle); - builder_.add_sittingUpperLegAngle(sittingUpperLegAngle); - builder_.add_standingFootAngle(standingFootAngle); - builder_.add_standingLowerLegAngle(standingLowerLegAngle); - builder_.add_standingUpperLegAngle(standingUpperLegAngle); - builder_.add_setupComplete(setupComplete); - builder_.add_flatEnabled(flatEnabled); - builder_.add_sittingEnabled(sittingEnabled); - builder_.add_standingEnabled(standingEnabled); - builder_.add_hideYawCorrection(hideYawCorrection); - builder_.add_extraYawCorrection(extraYawCorrection); - builder_.add_enabled(enabled); +inline flatbuffers::Offset CreateHIDSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + HIDSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct HIDSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HIDSettingsBuilder Builder; +struct HIDSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HIDSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKERSOVERHID = 4 + VT_TRACKERS_OVER_HID = 4 }; - bool trackersOverHID() const { - return GetField(VT_TRACKERSOVERHID, 0) != 0; + bool trackers_over_hid() const { + return GetField(VT_TRACKERS_OVER_HID, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_TRACKERSOVERHID, 1) && + VerifyField(verifier, VT_TRACKERS_OVER_HID, 1) && verifier.EndTable(); } }; -struct HIDSettingsBuilder { - typedef HIDSettings Table; +struct HIDSettingsResponseBuilder { + typedef HIDSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_trackersOverHID(bool trackersOverHID) { - fbb_.AddElement(HIDSettings::VT_TRACKERSOVERHID, static_cast(trackersOverHID), 0); + void add_trackers_over_hid(bool trackers_over_hid) { + fbb_.AddElement(HIDSettingsResponse::VT_TRACKERS_OVER_HID, static_cast(trackers_over_hid), 0); } - explicit HIDSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit HIDSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHIDSettings( +inline flatbuffers::Offset CreateHIDSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - bool trackersOverHID = false) { - HIDSettingsBuilder builder_(_fbb); - builder_.add_trackersOverHID(trackersOverHID); + bool trackers_over_hid = false) { + HIDSettingsResponseBuilder builder_(_fbb); + builder_.add_trackers_over_hid(trackers_over_hid); return builder_.Finish(); } -struct TimeoutSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TimeoutSettingsBuilder Builder; +struct ChangeHIDSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeHIDSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DURATION = 4 + VT_TRACKERS_OVER_HID = 4 }; - float duration() const { - return GetField(VT_DURATION, 0.0f); + bool trackers_over_hid() const { + return GetField(VT_TRACKERS_OVER_HID, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_DURATION, 4) && + VerifyField(verifier, VT_TRACKERS_OVER_HID, 1) && verifier.EndTable(); } }; -struct TimeoutSettingsBuilder { - typedef TimeoutSettings Table; +struct ChangeHIDSettingsRequestBuilder { + typedef ChangeHIDSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_duration(float duration) { - fbb_.AddElement(TimeoutSettings::VT_DURATION, duration, 0.0f); + void add_trackers_over_hid(bool trackers_over_hid) { + fbb_.AddElement(ChangeHIDSettingsRequest::VT_TRACKERS_OVER_HID, static_cast(trackers_over_hid), 0); } - explicit TimeoutSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ChangeHIDSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTimeoutSettings( +inline flatbuffers::Offset CreateChangeHIDSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - float duration = 0.0f) { - TimeoutSettingsBuilder builder_(_fbb); - builder_.add_duration(duration); + bool trackers_over_hid = false) { + ChangeHIDSettingsRequestBuilder builder_(_fbb); + builder_.add_trackers_over_hid(trackers_over_hid); return builder_.Finish(); } -struct VelocitySettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VelocitySettingsBuilder Builder; +struct SkeletonPart FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonPartBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SEND_DERIVED_VELOCITY = 4 + VT_BONE = 4, + VT_VALUE = 6 }; - bool send_derived_velocity() const { - return GetField(VT_SEND_DERIVED_VELOCITY, 0) != 0; + solarxr_protocol::rpc::SkeletonBone bone() const { + return static_cast(GetField(VT_BONE, 0)); + } + float value() const { + return GetField(VT_VALUE, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_SEND_DERIVED_VELOCITY, 1) && + VerifyField(verifier, VT_BONE, 1) && + VerifyField(verifier, VT_VALUE, 4) && verifier.EndTable(); } }; -struct VelocitySettingsBuilder { - typedef VelocitySettings Table; +struct SkeletonPartBuilder { + typedef SkeletonPart Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_send_derived_velocity(bool send_derived_velocity) { - fbb_.AddElement(VelocitySettings::VT_SEND_DERIVED_VELOCITY, static_cast(send_derived_velocity), 0); + void add_bone(solarxr_protocol::rpc::SkeletonBone bone) { + fbb_.AddElement(SkeletonPart::VT_BONE, static_cast(bone), 0); + } + void add_value(float value) { + fbb_.AddElement(SkeletonPart::VT_VALUE, value, 0.0f); } - explicit VelocitySettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonPartBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateVelocitySettings( +inline flatbuffers::Offset CreateSkeletonPart( flatbuffers::FlatBufferBuilder &_fbb, - bool send_derived_velocity = false) { - VelocitySettingsBuilder builder_(_fbb); - builder_.add_send_derived_velocity(send_derived_velocity); + solarxr_protocol::rpc::SkeletonBone bone = solarxr_protocol::rpc::SkeletonBone::NONE, + float value = 0.0f) { + SkeletonPartBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_bone(bone); return builder_.Finish(); } -/// See TapDetectionSettings::setup_mode -struct TapDetectionSetupNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TapDetectionSetupNotificationBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 - }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); - } +struct SkeletonProportionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonProportionsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && verifier.EndTable(); } }; -struct TapDetectionSetupNotificationBuilder { - typedef TapDetectionSetupNotification Table; +struct SkeletonProportionsRequestBuilder { + typedef SkeletonProportionsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(TapDetectionSetupNotification::VT_TRACKER_ID, tracker_id); - } - explicit TapDetectionSetupNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonProportionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTapDetectionSetupNotification( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { - TapDetectionSetupNotificationBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); +inline flatbuffers::Offset CreateSkeletonProportionsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SkeletonProportionsRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct RecordBVHRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef RecordBVHRequestBuilder Builder; +struct SkeletonProportionsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonProportionsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STOP = 4, - VT_PATH = 6 + VT_SKELETON_PARTS = 4, + VT_USER_HEIGHT = 6 }; - bool stop() const { - return GetField(VT_STOP, 0) != 0; + const flatbuffers::Vector> *skeleton_parts() const { + return GetPointer> *>(VT_SKELETON_PARTS); } - /// Path sent when starting the recording, if null the recording won't happen. - /// Has different behavior depending if its a file path or a directory path. - const flatbuffers::String *path() const { - return GetPointer(VT_PATH); + float user_height() const { + return GetField(VT_USER_HEIGHT, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_STOP, 1) && - VerifyOffset(verifier, VT_PATH) && - verifier.VerifyString(path()) && + VerifyOffset(verifier, VT_SKELETON_PARTS) && + verifier.VerifyVector(skeleton_parts()) && + verifier.VerifyVectorOfTables(skeleton_parts()) && + VerifyField(verifier, VT_USER_HEIGHT, 4) && verifier.EndTable(); } }; -struct RecordBVHRequestBuilder { - typedef RecordBVHRequest Table; +struct SkeletonProportionsResponseBuilder { + typedef SkeletonProportionsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_stop(bool stop) { - fbb_.AddElement(RecordBVHRequest::VT_STOP, static_cast(stop), 0); + void add_skeleton_parts(flatbuffers::Offset>> skeleton_parts) { + fbb_.AddOffset(SkeletonProportionsResponse::VT_SKELETON_PARTS, skeleton_parts); } - void add_path(flatbuffers::Offset path) { - fbb_.AddOffset(RecordBVHRequest::VT_PATH, path); + void add_user_height(float user_height) { + fbb_.AddElement(SkeletonProportionsResponse::VT_USER_HEIGHT, user_height, 0.0f); } - explicit RecordBVHRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonProportionsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRecordBVHRequest( +inline flatbuffers::Offset CreateSkeletonProportionsResponse( flatbuffers::FlatBufferBuilder &_fbb, - bool stop = false, - flatbuffers::Offset path = 0) { - RecordBVHRequestBuilder builder_(_fbb); - builder_.add_path(path); - builder_.add_stop(stop); + flatbuffers::Offset>> skeleton_parts = 0, + float user_height = 0.0f) { + SkeletonProportionsResponseBuilder builder_(_fbb); + builder_.add_user_height(user_height); + builder_.add_skeleton_parts(skeleton_parts); return builder_.Finish(); } -inline flatbuffers::Offset CreateRecordBVHRequestDirect( +inline flatbuffers::Offset CreateSkeletonProportionsResponseDirect( flatbuffers::FlatBufferBuilder &_fbb, - bool stop = false, - const char *path = nullptr) { - auto path__ = path ? _fbb.CreateString(path) : 0; - return solarxr_protocol::rpc::CreateRecordBVHRequest( + const std::vector> *skeleton_parts = nullptr, + float user_height = 0.0f) { + auto skeleton_parts__ = skeleton_parts ? _fbb.CreateVector>(*skeleton_parts) : 0; + return solarxr_protocol::rpc::CreateSkeletonProportionsResponse( _fbb, - stop, - path__); + skeleton_parts__, + user_height); } -struct RecordBVHStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef RecordBVHStatusBuilder Builder; +struct ChangeSkeletonProportionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeSkeletonProportionsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_RECORDING = 4 + VT_BONE = 4, + VT_VALUE = 6 }; - bool recording() const { - return GetField(VT_RECORDING, 0) != 0; + solarxr_protocol::rpc::SkeletonBone bone() const { + return static_cast(GetField(VT_BONE, 0)); + } + float value() const { + return GetField(VT_VALUE, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_RECORDING, 1) && + VerifyField(verifier, VT_BONE, 1) && + VerifyField(verifier, VT_VALUE, 4) && verifier.EndTable(); } }; -struct RecordBVHStatusBuilder { - typedef RecordBVHStatus Table; +struct ChangeSkeletonProportionsRequestBuilder { + typedef ChangeSkeletonProportionsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_recording(bool recording) { - fbb_.AddElement(RecordBVHStatus::VT_RECORDING, static_cast(recording), 0); + void add_bone(solarxr_protocol::rpc::SkeletonBone bone) { + fbb_.AddElement(ChangeSkeletonProportionsRequest::VT_BONE, static_cast(bone), 0); } - explicit RecordBVHStatusBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_value(float value) { + fbb_.AddElement(ChangeSkeletonProportionsRequest::VT_VALUE, value, 0.0f); + } + explicit ChangeSkeletonProportionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRecordBVHStatus( +inline flatbuffers::Offset CreateChangeSkeletonProportionsRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool recording = false) { - RecordBVHStatusBuilder builder_(_fbb); - builder_.add_recording(recording); + solarxr_protocol::rpc::SkeletonBone bone = solarxr_protocol::rpc::SkeletonBone::NONE, + float value = 0.0f) { + ChangeSkeletonProportionsRequestBuilder builder_(_fbb); + builder_.add_value(value); + builder_.add_bone(bone); return builder_.Finish(); } -struct RecordBVHStatusRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef RecordBVHStatusRequestBuilder Builder; +struct SkeletonProportionsResetAllRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonProportionsResetAllRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct RecordBVHStatusRequestBuilder { - typedef RecordBVHStatusRequest Table; +struct SkeletonProportionsResetAllRequestBuilder { + typedef SkeletonProportionsResetAllRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit RecordBVHStatusRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonProportionsResetAllRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateRecordBVHStatusRequest( +inline flatbuffers::Offset CreateSkeletonProportionsResetAllRequest( flatbuffers::FlatBufferBuilder &_fbb) { - RecordBVHStatusRequestBuilder builder_(_fbb); + SkeletonProportionsResetAllRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct SkeletonPart FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SkeletonPartBuilder Builder; +/// Makes a temporary change to legtweaks. This is not saved to disk, and can be +/// cleared with `LegTweaksTmpClear` +struct LegTweaksTmpChange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LegTweaksTmpChangeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_BONE = 4, - VT_VALUE = 6 + VT_FLOOR_CLIP = 4, + VT_SKATING_CORRECTION = 6, + VT_TOE_SNAP = 8, + VT_FOOT_PLANT = 10 }; - solarxr_protocol::rpc::SkeletonBone bone() const { - return static_cast(GetField(VT_BONE, 0)); + flatbuffers::Optional floor_clip() const { + return GetOptional(VT_FLOOR_CLIP); } - float value() const { - return GetField(VT_VALUE, 0.0f); + flatbuffers::Optional skating_correction() const { + return GetOptional(VT_SKATING_CORRECTION); + } + flatbuffers::Optional toe_snap() const { + return GetOptional(VT_TOE_SNAP); + } + flatbuffers::Optional foot_plant() const { + return GetOptional(VT_FOOT_PLANT); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_BONE, 1) && - VerifyField(verifier, VT_VALUE, 4) && + VerifyField(verifier, VT_FLOOR_CLIP, 1) && + VerifyField(verifier, VT_SKATING_CORRECTION, 1) && + VerifyField(verifier, VT_TOE_SNAP, 1) && + VerifyField(verifier, VT_FOOT_PLANT, 1) && verifier.EndTable(); } }; -struct SkeletonPartBuilder { - typedef SkeletonPart Table; +struct LegTweaksTmpChangeBuilder { + typedef LegTweaksTmpChange Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_bone(solarxr_protocol::rpc::SkeletonBone bone) { - fbb_.AddElement(SkeletonPart::VT_BONE, static_cast(bone), 0); + void add_floor_clip(bool floor_clip) { + fbb_.AddElement(LegTweaksTmpChange::VT_FLOOR_CLIP, static_cast(floor_clip)); } - void add_value(float value) { - fbb_.AddElement(SkeletonPart::VT_VALUE, value, 0.0f); + void add_skating_correction(bool skating_correction) { + fbb_.AddElement(LegTweaksTmpChange::VT_SKATING_CORRECTION, static_cast(skating_correction)); } - explicit SkeletonPartBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_toe_snap(bool toe_snap) { + fbb_.AddElement(LegTweaksTmpChange::VT_TOE_SNAP, static_cast(toe_snap)); + } + void add_foot_plant(bool foot_plant) { + fbb_.AddElement(LegTweaksTmpChange::VT_FOOT_PLANT, static_cast(foot_plant)); + } + explicit LegTweaksTmpChangeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkeletonPart( +inline flatbuffers::Offset CreateLegTweaksTmpChange( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::SkeletonBone bone = solarxr_protocol::rpc::SkeletonBone::NONE, - float value = 0.0f) { - SkeletonPartBuilder builder_(_fbb); - builder_.add_value(value); - builder_.add_bone(bone); + flatbuffers::Optional floor_clip = flatbuffers::nullopt, + flatbuffers::Optional skating_correction = flatbuffers::nullopt, + flatbuffers::Optional toe_snap = flatbuffers::nullopt, + flatbuffers::Optional foot_plant = flatbuffers::nullopt) { + LegTweaksTmpChangeBuilder builder_(_fbb); + if(foot_plant) { builder_.add_foot_plant(*foot_plant); } + if(toe_snap) { builder_.add_toe_snap(*toe_snap); } + if(skating_correction) { builder_.add_skating_correction(*skating_correction); } + if(floor_clip) { builder_.add_floor_clip(*floor_clip); } return builder_.Finish(); } -struct SkeletonConfigRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SkeletonConfigRequestBuilder Builder; +/// Clears the legtweaks temporary state back to what the config has. +/// Setting a field to `true` will reset that field. +struct LegTweaksTmpClear FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef LegTweaksTmpClearBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_FLOOR_CLIP = 4, + VT_SKATING_CORRECTION = 6, + VT_TOE_SNAP = 8, + VT_FOOT_PLANT = 10 + }; + bool floor_clip() const { + return GetField(VT_FLOOR_CLIP, 0) != 0; + } + bool skating_correction() const { + return GetField(VT_SKATING_CORRECTION, 0) != 0; + } + bool toe_snap() const { + return GetField(VT_TOE_SNAP, 0) != 0; + } + bool foot_plant() const { + return GetField(VT_FOOT_PLANT, 0) != 0; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FLOOR_CLIP, 1) && + VerifyField(verifier, VT_SKATING_CORRECTION, 1) && + VerifyField(verifier, VT_TOE_SNAP, 1) && + VerifyField(verifier, VT_FOOT_PLANT, 1) && verifier.EndTable(); } }; -struct SkeletonConfigRequestBuilder { - typedef SkeletonConfigRequest Table; +struct LegTweaksTmpClearBuilder { + typedef LegTweaksTmpClear Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SkeletonConfigRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_floor_clip(bool floor_clip) { + fbb_.AddElement(LegTweaksTmpClear::VT_FLOOR_CLIP, static_cast(floor_clip), 0); + } + void add_skating_correction(bool skating_correction) { + fbb_.AddElement(LegTweaksTmpClear::VT_SKATING_CORRECTION, static_cast(skating_correction), 0); + } + void add_toe_snap(bool toe_snap) { + fbb_.AddElement(LegTweaksTmpClear::VT_TOE_SNAP, static_cast(toe_snap), 0); + } + void add_foot_plant(bool foot_plant) { + fbb_.AddElement(LegTweaksTmpClear::VT_FOOT_PLANT, static_cast(foot_plant), 0); + } + explicit LegTweaksTmpClearBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkeletonConfigRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SkeletonConfigRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateLegTweaksTmpClear( + flatbuffers::FlatBufferBuilder &_fbb, + bool floor_clip = false, + bool skating_correction = false, + bool toe_snap = false, + bool foot_plant = false) { + LegTweaksTmpClearBuilder builder_(_fbb); + builder_.add_foot_plant(foot_plant); + builder_.add_toe_snap(toe_snap); + builder_.add_skating_correction(skating_correction); + builder_.add_floor_clip(floor_clip); return builder_.Finish(); } -struct SkeletonConfigResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SkeletonConfigResponseBuilder Builder; +struct SetPauseTrackingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SetPauseTrackingRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SKELETON_PARTS = 4, - VT_USER_HEIGHT = 6 + VT_PAUSE_TRACKING = 4 }; - const flatbuffers::Vector> *skeleton_parts() const { - return GetPointer> *>(VT_SKELETON_PARTS); - } - float user_height() const { - return GetField(VT_USER_HEIGHT, 0.0f); + /// Pauses skeleton tracking if true, resumes skeleton tracking if false. + bool pause_tracking() const { + return GetField(VT_PAUSE_TRACKING, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_SKELETON_PARTS) && - verifier.VerifyVector(skeleton_parts()) && - verifier.VerifyVectorOfTables(skeleton_parts()) && - VerifyField(verifier, VT_USER_HEIGHT, 4) && + VerifyField(verifier, VT_PAUSE_TRACKING, 1) && verifier.EndTable(); } }; -struct SkeletonConfigResponseBuilder { - typedef SkeletonConfigResponse Table; +struct SetPauseTrackingRequestBuilder { + typedef SetPauseTrackingRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_skeleton_parts(flatbuffers::Offset>> skeleton_parts) { - fbb_.AddOffset(SkeletonConfigResponse::VT_SKELETON_PARTS, skeleton_parts); - } - void add_user_height(float user_height) { - fbb_.AddElement(SkeletonConfigResponse::VT_USER_HEIGHT, user_height, 0.0f); + void add_pause_tracking(bool pause_tracking) { + fbb_.AddElement(SetPauseTrackingRequest::VT_PAUSE_TRACKING, static_cast(pause_tracking), 0); } - explicit SkeletonConfigResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SetPauseTrackingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkeletonConfigResponse( +inline flatbuffers::Offset CreateSetPauseTrackingRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> skeleton_parts = 0, - float user_height = 0.0f) { - SkeletonConfigResponseBuilder builder_(_fbb); - builder_.add_user_height(user_height); - builder_.add_skeleton_parts(skeleton_parts); + bool pause_tracking = false) { + SetPauseTrackingRequestBuilder builder_(_fbb); + builder_.add_pause_tracking(pause_tracking); return builder_.Finish(); } -inline flatbuffers::Offset CreateSkeletonConfigResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *skeleton_parts = nullptr, - float user_height = 0.0f) { - auto skeleton_parts__ = skeleton_parts ? _fbb.CreateVector>(*skeleton_parts) : 0; - return solarxr_protocol::rpc::CreateSkeletonConfigResponse( - _fbb, - skeleton_parts__, - user_height); +/// Requests the current state of tracking pause +struct TrackingPauseStateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingPauseStateRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct TrackingPauseStateRequestBuilder { + typedef TrackingPauseStateRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit TrackingPauseStateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingPauseStateRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + TrackingPauseStateRequestBuilder builder_(_fbb); + return builder_.Finish(); } -struct SkeletonResetAllRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SkeletonResetAllRequestBuilder Builder; +struct TrackingPauseStateResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingPauseStateResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKING_PAUSED = 4 + }; + /// Skeleton tracking is paused if true, skeleton tracking is unpaused if false. + bool tracking_paused() const { + return GetField(VT_TRACKING_PAUSED, 0) != 0; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TRACKING_PAUSED, 1) && verifier.EndTable(); } }; -struct SkeletonResetAllRequestBuilder { - typedef SkeletonResetAllRequest Table; +struct TrackingPauseStateResponseBuilder { + typedef TrackingPauseStateResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SkeletonResetAllRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_tracking_paused(bool tracking_paused) { + fbb_.AddElement(TrackingPauseStateResponse::VT_TRACKING_PAUSED, static_cast(tracking_paused), 0); + } + explicit TrackingPauseStateResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSkeletonResetAllRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SkeletonResetAllRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateTrackingPauseStateResponse( + flatbuffers::FlatBufferBuilder &_fbb, + bool tracking_paused = false) { + TrackingPauseStateResponseBuilder builder_(_fbb); + builder_.add_tracking_paused(tracking_paused); return builder_.Finish(); } -struct ChangeSkeletonConfigRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ChangeSkeletonConfigRequestBuilder Builder; +/// Toggles for the skeletal model. +struct SkeletonToggles FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonTogglesBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_BONE = 4, - VT_VALUE = 6 + VT_FORCE_ARMS_FROM_HMD = 4, + VT_FLOOR_CLIP = 6, + VT_SKATING_CORRECTION = 8, + VT_TOE_SNAP = 10, + VT_FOOT_PLANT = 12, + VT_SELF_LOCALIZATION = 14, + VT_USE_POSITION = 16, + VT_ENFORCE_CONSTRAINTS = 18, + VT_CORRECT_CONSTRAINTS = 20 }; - solarxr_protocol::rpc::SkeletonBone bone() const { - return static_cast(GetField(VT_BONE, 0)); + flatbuffers::Optional force_arms_from_hmd() const { + return GetOptional(VT_FORCE_ARMS_FROM_HMD); } - float value() const { - return GetField(VT_VALUE, 0.0f); + flatbuffers::Optional floor_clip() const { + return GetOptional(VT_FLOOR_CLIP); + } + flatbuffers::Optional skating_correction() const { + return GetOptional(VT_SKATING_CORRECTION); + } + flatbuffers::Optional toe_snap() const { + return GetOptional(VT_TOE_SNAP); + } + flatbuffers::Optional foot_plant() const { + return GetOptional(VT_FOOT_PLANT); + } + flatbuffers::Optional self_localization() const { + return GetOptional(VT_SELF_LOCALIZATION); + } + flatbuffers::Optional use_position() const { + return GetOptional(VT_USE_POSITION); + } + flatbuffers::Optional enforce_constraints() const { + return GetOptional(VT_ENFORCE_CONSTRAINTS); + } + flatbuffers::Optional correct_constraints() const { + return GetOptional(VT_CORRECT_CONSTRAINTS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_BONE, 1) && - VerifyField(verifier, VT_VALUE, 4) && + VerifyField(verifier, VT_FORCE_ARMS_FROM_HMD, 1) && + VerifyField(verifier, VT_FLOOR_CLIP, 1) && + VerifyField(verifier, VT_SKATING_CORRECTION, 1) && + VerifyField(verifier, VT_TOE_SNAP, 1) && + VerifyField(verifier, VT_FOOT_PLANT, 1) && + VerifyField(verifier, VT_SELF_LOCALIZATION, 1) && + VerifyField(verifier, VT_USE_POSITION, 1) && + VerifyField(verifier, VT_ENFORCE_CONSTRAINTS, 1) && + VerifyField(verifier, VT_CORRECT_CONSTRAINTS, 1) && verifier.EndTable(); } }; -struct ChangeSkeletonConfigRequestBuilder { - typedef ChangeSkeletonConfigRequest Table; +struct SkeletonTogglesBuilder { + typedef SkeletonToggles Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_bone(solarxr_protocol::rpc::SkeletonBone bone) { - fbb_.AddElement(ChangeSkeletonConfigRequest::VT_BONE, static_cast(bone), 0); + void add_force_arms_from_hmd(bool force_arms_from_hmd) { + fbb_.AddElement(SkeletonToggles::VT_FORCE_ARMS_FROM_HMD, static_cast(force_arms_from_hmd)); } - void add_value(float value) { - fbb_.AddElement(ChangeSkeletonConfigRequest::VT_VALUE, value, 0.0f); + void add_floor_clip(bool floor_clip) { + fbb_.AddElement(SkeletonToggles::VT_FLOOR_CLIP, static_cast(floor_clip)); + } + void add_skating_correction(bool skating_correction) { + fbb_.AddElement(SkeletonToggles::VT_SKATING_CORRECTION, static_cast(skating_correction)); + } + void add_toe_snap(bool toe_snap) { + fbb_.AddElement(SkeletonToggles::VT_TOE_SNAP, static_cast(toe_snap)); + } + void add_foot_plant(bool foot_plant) { + fbb_.AddElement(SkeletonToggles::VT_FOOT_PLANT, static_cast(foot_plant)); + } + void add_self_localization(bool self_localization) { + fbb_.AddElement(SkeletonToggles::VT_SELF_LOCALIZATION, static_cast(self_localization)); + } + void add_use_position(bool use_position) { + fbb_.AddElement(SkeletonToggles::VT_USE_POSITION, static_cast(use_position)); + } + void add_enforce_constraints(bool enforce_constraints) { + fbb_.AddElement(SkeletonToggles::VT_ENFORCE_CONSTRAINTS, static_cast(enforce_constraints)); + } + void add_correct_constraints(bool correct_constraints) { + fbb_.AddElement(SkeletonToggles::VT_CORRECT_CONSTRAINTS, static_cast(correct_constraints)); } - explicit ChangeSkeletonConfigRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonTogglesBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateChangeSkeletonConfigRequest( +inline flatbuffers::Offset CreateSkeletonToggles( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::SkeletonBone bone = solarxr_protocol::rpc::SkeletonBone::NONE, - float value = 0.0f) { - ChangeSkeletonConfigRequestBuilder builder_(_fbb); - builder_.add_value(value); - builder_.add_bone(bone); + flatbuffers::Optional force_arms_from_hmd = flatbuffers::nullopt, + flatbuffers::Optional floor_clip = flatbuffers::nullopt, + flatbuffers::Optional skating_correction = flatbuffers::nullopt, + flatbuffers::Optional toe_snap = flatbuffers::nullopt, + flatbuffers::Optional foot_plant = flatbuffers::nullopt, + flatbuffers::Optional self_localization = flatbuffers::nullopt, + flatbuffers::Optional use_position = flatbuffers::nullopt, + flatbuffers::Optional enforce_constraints = flatbuffers::nullopt, + flatbuffers::Optional correct_constraints = flatbuffers::nullopt) { + SkeletonTogglesBuilder builder_(_fbb); + if(correct_constraints) { builder_.add_correct_constraints(*correct_constraints); } + if(enforce_constraints) { builder_.add_enforce_constraints(*enforce_constraints); } + if(use_position) { builder_.add_use_position(*use_position); } + if(self_localization) { builder_.add_self_localization(*self_localization); } + if(foot_plant) { builder_.add_foot_plant(*foot_plant); } + if(toe_snap) { builder_.add_toe_snap(*toe_snap); } + if(skating_correction) { builder_.add_skating_correction(*skating_correction); } + if(floor_clip) { builder_.add_floor_clip(*floor_clip); } + if(force_arms_from_hmd) { builder_.add_force_arms_from_hmd(*force_arms_from_hmd); } return builder_.Finish(); } -struct SerialDevice FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialDeviceBuilder Builder; +/// Ratios for the skeletal model. Accepted values for them range from 0 to 1 +struct SkeletonRatios FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonRatiosBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PORT = 4, - VT_NAME = 6, - VT_TYPE = 8 + VT_IMPUTE_SPINE_FROM_UPPER_LOWER = 4, + VT_IMPUTE_SPINE_CURVATURE = 6, + VT_INTERP_HIP_LEGS = 8, + VT_INTERP_KNEE_TRACKER_ANKLE = 10, + VT_INTERP_KNEE_ANKLE = 12, + VT_SKATING_CORRECTION_STRENGTH = 14 }; - const flatbuffers::String *port() const { - return GetPointer(VT_PORT); + /// Compute missing spine bones as a ratio of the next available upper and lower bones. + flatbuffers::Optional impute_spine_from_upper_lower() const { + return GetOptional(VT_IMPUTE_SPINE_FROM_UPPER_LOWER); } - const flatbuffers::String *name() const { - return GetPointer(VT_NAME); + /// Computes the curvature between 2 adjacent missing spine bones. Higher = more curvature. + flatbuffers::Optional impute_spine_curvature() const { + return GetOptional(VT_IMPUTE_SPINE_CURVATURE); } - solarxr_protocol::rpc::SerialDeviceType type() const { - return static_cast(GetField(VT_TYPE, 0)); + /// How much to average the hip's yaw and roll with the upper legs'. + flatbuffers::Optional interp_hip_legs() const { + return GetOptional(VT_INTERP_HIP_LEGS); + } + /// How much to average the knee trackers' yaw and roll with the lower legs'. + flatbuffers::Optional interp_knee_tracker_ankle() const { + return GetOptional(VT_INTERP_KNEE_TRACKER_ANKLE); + } + /// How much to average the upper leg's yaw and roll with the lower legs'. + flatbuffers::Optional interp_knee_ankle() const { + return GetOptional(VT_INTERP_KNEE_ANKLE); + } + /// Strength of skating correction. Enabled via SkeletonToggles.skating_correction + flatbuffers::Optional skating_correction_strength() const { + return GetOptional(VT_SKATING_CORRECTION_STRENGTH); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_PORT) && - verifier.VerifyString(port()) && - VerifyOffset(verifier, VT_NAME) && - verifier.VerifyString(name()) && - VerifyField(verifier, VT_TYPE, 1) && + VerifyField(verifier, VT_IMPUTE_SPINE_FROM_UPPER_LOWER, 4) && + VerifyField(verifier, VT_IMPUTE_SPINE_CURVATURE, 4) && + VerifyField(verifier, VT_INTERP_HIP_LEGS, 4) && + VerifyField(verifier, VT_INTERP_KNEE_TRACKER_ANKLE, 4) && + VerifyField(verifier, VT_INTERP_KNEE_ANKLE, 4) && + VerifyField(verifier, VT_SKATING_CORRECTION_STRENGTH, 4) && verifier.EndTable(); } }; -struct SerialDeviceBuilder { - typedef SerialDevice Table; +struct SkeletonRatiosBuilder { + typedef SkeletonRatios Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_port(flatbuffers::Offset port) { - fbb_.AddOffset(SerialDevice::VT_PORT, port); + void add_impute_spine_from_upper_lower(float impute_spine_from_upper_lower) { + fbb_.AddElement(SkeletonRatios::VT_IMPUTE_SPINE_FROM_UPPER_LOWER, impute_spine_from_upper_lower); } - void add_name(flatbuffers::Offset name) { - fbb_.AddOffset(SerialDevice::VT_NAME, name); + void add_impute_spine_curvature(float impute_spine_curvature) { + fbb_.AddElement(SkeletonRatios::VT_IMPUTE_SPINE_CURVATURE, impute_spine_curvature); } - void add_type(solarxr_protocol::rpc::SerialDeviceType type) { - fbb_.AddElement(SerialDevice::VT_TYPE, static_cast(type), 0); + void add_interp_hip_legs(float interp_hip_legs) { + fbb_.AddElement(SkeletonRatios::VT_INTERP_HIP_LEGS, interp_hip_legs); } - explicit SerialDeviceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_interp_knee_tracker_ankle(float interp_knee_tracker_ankle) { + fbb_.AddElement(SkeletonRatios::VT_INTERP_KNEE_TRACKER_ANKLE, interp_knee_tracker_ankle); + } + void add_interp_knee_ankle(float interp_knee_ankle) { + fbb_.AddElement(SkeletonRatios::VT_INTERP_KNEE_ANKLE, interp_knee_ankle); + } + void add_skating_correction_strength(float skating_correction_strength) { + fbb_.AddElement(SkeletonRatios::VT_SKATING_CORRECTION_STRENGTH, skating_correction_strength); + } + explicit SkeletonRatiosBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialDevice( +inline flatbuffers::Offset CreateSkeletonRatios( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset port = 0, - flatbuffers::Offset name = 0, - solarxr_protocol::rpc::SerialDeviceType type = solarxr_protocol::rpc::SerialDeviceType::ESP_TRACKER) { - SerialDeviceBuilder builder_(_fbb); - builder_.add_name(name); - builder_.add_port(port); - builder_.add_type(type); + flatbuffers::Optional impute_spine_from_upper_lower = flatbuffers::nullopt, + flatbuffers::Optional impute_spine_curvature = flatbuffers::nullopt, + flatbuffers::Optional interp_hip_legs = flatbuffers::nullopt, + flatbuffers::Optional interp_knee_tracker_ankle = flatbuffers::nullopt, + flatbuffers::Optional interp_knee_ankle = flatbuffers::nullopt, + flatbuffers::Optional skating_correction_strength = flatbuffers::nullopt) { + SkeletonRatiosBuilder builder_(_fbb); + if(skating_correction_strength) { builder_.add_skating_correction_strength(*skating_correction_strength); } + if(interp_knee_ankle) { builder_.add_interp_knee_ankle(*interp_knee_ankle); } + if(interp_knee_tracker_ankle) { builder_.add_interp_knee_tracker_ankle(*interp_knee_tracker_ankle); } + if(interp_hip_legs) { builder_.add_interp_hip_legs(*interp_hip_legs); } + if(impute_spine_curvature) { builder_.add_impute_spine_curvature(*impute_spine_curvature); } + if(impute_spine_from_upper_lower) { builder_.add_impute_spine_from_upper_lower(*impute_spine_from_upper_lower); } return builder_.Finish(); } -inline flatbuffers::Offset CreateSerialDeviceDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *port = nullptr, - const char *name = nullptr, - solarxr_protocol::rpc::SerialDeviceType type = solarxr_protocol::rpc::SerialDeviceType::ESP_TRACKER) { - auto port__ = port ? _fbb.CreateString(port) : 0; - auto name__ = name ? _fbb.CreateString(name) : 0; - return solarxr_protocol::rpc::CreateSerialDevice( - _fbb, - port__, - name__, - type); -} - -struct OpenSerialRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OpenSerialRequestBuilder Builder; +/// Filtering (e.g smoothing) applied to the skeleton's movements +struct SkeletonFiltering FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonFilteringBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_AUTO_ = 4, - VT_PORT = 6 + VT_TYPE = 4, + VT_AMOUNT = 6 }; - /// Automatically pick the first serial device available - bool auto_() const { - return GetField(VT_AUTO_, 0) != 0; + solarxr_protocol::rpc::FilteringType type() const { + return static_cast(GetField(VT_TYPE, 0)); } - const flatbuffers::String *port() const { - return GetPointer(VT_PORT); + /// A higher value results in more filtering (0 to 1). + float amount() const { + return GetField(VT_AMOUNT, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_AUTO_, 1) && - VerifyOffset(verifier, VT_PORT) && - verifier.VerifyString(port()) && + VerifyField(verifier, VT_TYPE, 1) && + VerifyField(verifier, VT_AMOUNT, 4) && verifier.EndTable(); } }; -struct OpenSerialRequestBuilder { - typedef OpenSerialRequest Table; +struct SkeletonFilteringBuilder { + typedef SkeletonFiltering Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_auto_(bool auto_) { - fbb_.AddElement(OpenSerialRequest::VT_AUTO_, static_cast(auto_), 0); + void add_type(solarxr_protocol::rpc::FilteringType type) { + fbb_.AddElement(SkeletonFiltering::VT_TYPE, static_cast(type), 0); } - void add_port(flatbuffers::Offset port) { - fbb_.AddOffset(OpenSerialRequest::VT_PORT, port); + void add_amount(float amount) { + fbb_.AddElement(SkeletonFiltering::VT_AMOUNT, amount, 0.0f); } - explicit OpenSerialRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonFilteringBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOpenSerialRequest( - flatbuffers::FlatBufferBuilder &_fbb, - bool auto_ = false, - flatbuffers::Offset port = 0) { - OpenSerialRequestBuilder builder_(_fbb); - builder_.add_port(port); - builder_.add_auto_(auto_); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateOpenSerialRequestDirect( +inline flatbuffers::Offset CreateSkeletonFiltering( flatbuffers::FlatBufferBuilder &_fbb, - bool auto_ = false, - const char *port = nullptr) { - auto port__ = port ? _fbb.CreateString(port) : 0; - return solarxr_protocol::rpc::CreateOpenSerialRequest( - _fbb, - auto_, - port__); -} - -struct CloseSerialRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef CloseSerialRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; - -struct CloseSerialRequestBuilder { - typedef CloseSerialRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit CloseSerialRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateCloseSerialRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - CloseSerialRequestBuilder builder_(_fbb); + solarxr_protocol::rpc::FilteringType type = solarxr_protocol::rpc::FilteringType::NONE, + float amount = 0.0f) { + SkeletonFilteringBuilder builder_(_fbb); + builder_.add_amount(amount); + builder_.add_type(type); return builder_.Finish(); } -struct SetWifiRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SetWifiRequestBuilder Builder; +/// Data used to compute the skeleton's height. +struct SkeletonHeight FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonHeightBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SSID = 4, - VT_PASSWORD = 6 + VT_HMD_HEIGHT = 4, + VT_FLOOR_HEIGHT = 6 }; - const flatbuffers::String *ssid() const { - return GetPointer(VT_SSID); + flatbuffers::Optional hmd_height() const { + return GetOptional(VT_HMD_HEIGHT); } - const flatbuffers::String *password() const { - return GetPointer(VT_PASSWORD); + flatbuffers::Optional floor_height() const { + return GetOptional(VT_FLOOR_HEIGHT); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_SSID) && - verifier.VerifyString(ssid()) && - VerifyOffset(verifier, VT_PASSWORD) && - verifier.VerifyString(password()) && + VerifyField(verifier, VT_HMD_HEIGHT, 4) && + VerifyField(verifier, VT_FLOOR_HEIGHT, 4) && verifier.EndTable(); } }; -struct SetWifiRequestBuilder { - typedef SetWifiRequest Table; +struct SkeletonHeightBuilder { + typedef SkeletonHeight Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_ssid(flatbuffers::Offset ssid) { - fbb_.AddOffset(SetWifiRequest::VT_SSID, ssid); + void add_hmd_height(float hmd_height) { + fbb_.AddElement(SkeletonHeight::VT_HMD_HEIGHT, hmd_height); } - void add_password(flatbuffers::Offset password) { - fbb_.AddOffset(SetWifiRequest::VT_PASSWORD, password); + void add_floor_height(float floor_height) { + fbb_.AddElement(SkeletonHeight::VT_FLOOR_HEIGHT, floor_height); } - explicit SetWifiRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonHeightBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; - -inline flatbuffers::Offset CreateSetWifiRequest( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset ssid = 0, - flatbuffers::Offset password = 0) { - SetWifiRequestBuilder builder_(_fbb); - builder_.add_password(password); - builder_.add_ssid(ssid); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateSetWifiRequestDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *ssid = nullptr, - const char *password = nullptr) { - auto ssid__ = ssid ? _fbb.CreateString(ssid) : 0; - auto password__ = password ? _fbb.CreateString(password) : 0; - return solarxr_protocol::rpc::CreateSetWifiRequest( - _fbb, - ssid__, - password__); -} - -struct SerialUpdateResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialUpdateResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LOG = 4, - VT_CLOSED = 6, - VT_DEVICE = 8 - }; - const flatbuffers::String *log() const { - return GetPointer(VT_LOG); - } - bool closed() const { - return GetField(VT_CLOSED, 0) != 0; - } - const solarxr_protocol::rpc::SerialDevice *device() const { - return GetPointer(VT_DEVICE); + auto o = flatbuffers::Offset(end); + return o; } +}; + +inline flatbuffers::Offset CreateSkeletonHeight( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Optional hmd_height = flatbuffers::nullopt, + flatbuffers::Optional floor_height = flatbuffers::nullopt) { + SkeletonHeightBuilder builder_(_fbb); + if(floor_height) { builder_.add_floor_height(*floor_height); } + if(hmd_height) { builder_.add_hmd_height(*hmd_height); } + return builder_.Finish(); +} + +struct SkeletonSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_LOG) && - verifier.VerifyString(log()) && - VerifyField(verifier, VT_CLOSED, 1) && - VerifyOffset(verifier, VT_DEVICE) && - verifier.VerifyTable(device()) && verifier.EndTable(); } }; -struct SerialUpdateResponseBuilder { - typedef SerialUpdateResponse Table; +struct SkeletonSettingsRequestBuilder { + typedef SkeletonSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_log(flatbuffers::Offset log) { - fbb_.AddOffset(SerialUpdateResponse::VT_LOG, log); - } - void add_closed(bool closed) { - fbb_.AddElement(SerialUpdateResponse::VT_CLOSED, static_cast(closed), 0); - } - void add_device(flatbuffers::Offset device) { - fbb_.AddOffset(SerialUpdateResponse::VT_DEVICE, device); - } - explicit SerialUpdateResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SkeletonSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialUpdateResponse( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset log = 0, - bool closed = false, - flatbuffers::Offset device = 0) { - SerialUpdateResponseBuilder builder_(_fbb); - builder_.add_device(device); - builder_.add_log(log); - builder_.add_closed(closed); +inline flatbuffers::Offset CreateSkeletonSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SkeletonSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateSerialUpdateResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *log = nullptr, - bool closed = false, - flatbuffers::Offset device = 0) { - auto log__ = log ? _fbb.CreateString(log) : 0; - return solarxr_protocol::rpc::CreateSerialUpdateResponse( - _fbb, - log__, - closed, - device); -} - -/// Reboots the tracker connected to the serial monitor -struct SerialTrackerRebootRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialTrackerRebootRequestBuilder Builder; +struct SkeletonSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SkeletonSettingsResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TOGGLES = 4, + VT_RATIOS = 6, + VT_FILTERING = 8, + VT_SKELETON_HEIGHT = 10 + }; + const solarxr_protocol::rpc::SkeletonToggles *toggles() const { + return GetPointer(VT_TOGGLES); + } + const solarxr_protocol::rpc::SkeletonRatios *ratios() const { + return GetPointer(VT_RATIOS); + } + const solarxr_protocol::rpc::SkeletonFiltering *filtering() const { + return GetPointer(VT_FILTERING); + } + const solarxr_protocol::rpc::SkeletonHeight *skeleton_height() const { + return GetPointer(VT_SKELETON_HEIGHT); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TOGGLES) && + verifier.VerifyTable(toggles()) && + VerifyOffset(verifier, VT_RATIOS) && + verifier.VerifyTable(ratios()) && + VerifyOffset(verifier, VT_FILTERING) && + verifier.VerifyTable(filtering()) && + VerifyOffset(verifier, VT_SKELETON_HEIGHT) && + verifier.VerifyTable(skeleton_height()) && verifier.EndTable(); } }; -struct SerialTrackerRebootRequestBuilder { - typedef SerialTrackerRebootRequest Table; +struct SkeletonSettingsResponseBuilder { + typedef SkeletonSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SerialTrackerRebootRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_toggles(flatbuffers::Offset toggles) { + fbb_.AddOffset(SkeletonSettingsResponse::VT_TOGGLES, toggles); + } + void add_ratios(flatbuffers::Offset ratios) { + fbb_.AddOffset(SkeletonSettingsResponse::VT_RATIOS, ratios); + } + void add_filtering(flatbuffers::Offset filtering) { + fbb_.AddOffset(SkeletonSettingsResponse::VT_FILTERING, filtering); + } + void add_skeleton_height(flatbuffers::Offset skeleton_height) { + fbb_.AddOffset(SkeletonSettingsResponse::VT_SKELETON_HEIGHT, skeleton_height); + } + explicit SkeletonSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialTrackerRebootRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SerialTrackerRebootRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateSkeletonSettingsResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset toggles = 0, + flatbuffers::Offset ratios = 0, + flatbuffers::Offset filtering = 0, + flatbuffers::Offset skeleton_height = 0) { + SkeletonSettingsResponseBuilder builder_(_fbb); + builder_.add_skeleton_height(skeleton_height); + builder_.add_filtering(filtering); + builder_.add_ratios(ratios); + builder_.add_toggles(toggles); return builder_.Finish(); } -/// Sends the GET INFO cmd to the current tracker on the serial monitor -struct SerialTrackerGetInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialTrackerGetInfoRequestBuilder Builder; +struct ChangeSkeletonSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeSkeletonSettingsRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TOGGLES = 4, + VT_RATIOS = 6, + VT_FILTERING = 8, + VT_SKELETON_HEIGHT = 10 + }; + const solarxr_protocol::rpc::SkeletonToggles *toggles() const { + return GetPointer(VT_TOGGLES); + } + const solarxr_protocol::rpc::SkeletonRatios *ratios() const { + return GetPointer(VT_RATIOS); + } + const solarxr_protocol::rpc::SkeletonFiltering *filtering() const { + return GetPointer(VT_FILTERING); + } + const solarxr_protocol::rpc::SkeletonHeight *skeleton_height() const { + return GetPointer(VT_SKELETON_HEIGHT); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TOGGLES) && + verifier.VerifyTable(toggles()) && + VerifyOffset(verifier, VT_RATIOS) && + verifier.VerifyTable(ratios()) && + VerifyOffset(verifier, VT_FILTERING) && + verifier.VerifyTable(filtering()) && + VerifyOffset(verifier, VT_SKELETON_HEIGHT) && + verifier.VerifyTable(skeleton_height()) && verifier.EndTable(); } }; -struct SerialTrackerGetInfoRequestBuilder { - typedef SerialTrackerGetInfoRequest Table; +struct ChangeSkeletonSettingsRequestBuilder { + typedef ChangeSkeletonSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SerialTrackerGetInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_toggles(flatbuffers::Offset toggles) { + fbb_.AddOffset(ChangeSkeletonSettingsRequest::VT_TOGGLES, toggles); + } + void add_ratios(flatbuffers::Offset ratios) { + fbb_.AddOffset(ChangeSkeletonSettingsRequest::VT_RATIOS, ratios); + } + void add_filtering(flatbuffers::Offset filtering) { + fbb_.AddOffset(ChangeSkeletonSettingsRequest::VT_FILTERING, filtering); + } + void add_skeleton_height(flatbuffers::Offset skeleton_height) { + fbb_.AddOffset(ChangeSkeletonSettingsRequest::VT_SKELETON_HEIGHT, skeleton_height); + } + explicit ChangeSkeletonSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialTrackerGetInfoRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SerialTrackerGetInfoRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateChangeSkeletonSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset toggles = 0, + flatbuffers::Offset ratios = 0, + flatbuffers::Offset filtering = 0, + flatbuffers::Offset skeleton_height = 0) { + ChangeSkeletonSettingsRequestBuilder builder_(_fbb); + builder_.add_skeleton_height(skeleton_height); + builder_.add_filtering(filtering); + builder_.add_ratios(ratios); + builder_.add_toggles(toggles); return builder_.Finish(); } -/// Sends the FRST cmd to the currently connected Tracker over the Serial Monitor -struct SerialTrackerFactoryResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialTrackerFactoryResetRequestBuilder Builder; +struct OutputTrackersSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OutputTrackersSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct SerialTrackerFactoryResetRequestBuilder { - typedef SerialTrackerFactoryResetRequest Table; +struct OutputTrackersSettingsRequestBuilder { + typedef OutputTrackersSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SerialTrackerFactoryResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OutputTrackersSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialTrackerFactoryResetRequest( +inline flatbuffers::Offset CreateOutputTrackersSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb) { - SerialTrackerFactoryResetRequestBuilder builder_(_fbb); + OutputTrackersSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Sends a custom cmd to the currently connected Tracker over the Serial Monitor -struct SerialTrackerCustomCommandRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialTrackerCustomCommandRequestBuilder Builder; +struct OutputTrackersSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OutputTrackersSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_COMMAND = 4 + VT_AUTOMATIC_TRACKER_TOGGLE = 4, + VT_TRACKERS = 6, + VT_SEND_DERIVED_VELOCITY = 8 }; - const flatbuffers::String *command() const { - return GetPointer(VT_COMMAND); + bool automatic_tracker_toggle() const { + return GetField(VT_AUTOMATIC_TRACKER_TOGGLE, 0) != 0; + } + const flatbuffers::Vector *trackers() const { + return GetPointer *>(VT_TRACKERS); + } + bool send_derived_velocity() const { + return GetField(VT_SEND_DERIVED_VELOCITY, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_COMMAND) && - verifier.VerifyString(command()) && + VerifyField(verifier, VT_AUTOMATIC_TRACKER_TOGGLE, 1) && + VerifyOffset(verifier, VT_TRACKERS) && + verifier.VerifyVector(trackers()) && + VerifyField(verifier, VT_SEND_DERIVED_VELOCITY, 1) && verifier.EndTable(); } }; -struct SerialTrackerCustomCommandRequestBuilder { - typedef SerialTrackerCustomCommandRequest Table; +struct OutputTrackersSettingsResponseBuilder { + typedef OutputTrackersSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_command(flatbuffers::Offset command) { - fbb_.AddOffset(SerialTrackerCustomCommandRequest::VT_COMMAND, command); + void add_automatic_tracker_toggle(bool automatic_tracker_toggle) { + fbb_.AddElement(OutputTrackersSettingsResponse::VT_AUTOMATIC_TRACKER_TOGGLE, static_cast(automatic_tracker_toggle), 0); } - explicit SerialTrackerCustomCommandRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_trackers(flatbuffers::Offset> trackers) { + fbb_.AddOffset(OutputTrackersSettingsResponse::VT_TRACKERS, trackers); + } + void add_send_derived_velocity(bool send_derived_velocity) { + fbb_.AddElement(OutputTrackersSettingsResponse::VT_SEND_DERIVED_VELOCITY, static_cast(send_derived_velocity), 0); + } + explicit OutputTrackersSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialTrackerCustomCommandRequest( +inline flatbuffers::Offset CreateOutputTrackersSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset command = 0) { - SerialTrackerCustomCommandRequestBuilder builder_(_fbb); - builder_.add_command(command); + bool automatic_tracker_toggle = false, + flatbuffers::Offset> trackers = 0, + bool send_derived_velocity = false) { + OutputTrackersSettingsResponseBuilder builder_(_fbb); + builder_.add_trackers(trackers); + builder_.add_send_derived_velocity(send_derived_velocity); + builder_.add_automatic_tracker_toggle(automatic_tracker_toggle); return builder_.Finish(); } -inline flatbuffers::Offset CreateSerialTrackerCustomCommandRequestDirect( +inline flatbuffers::Offset CreateOutputTrackersSettingsResponseDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *command = nullptr) { - auto command__ = command ? _fbb.CreateString(command) : 0; - return solarxr_protocol::rpc::CreateSerialTrackerCustomCommandRequest( + bool automatic_tracker_toggle = false, + const std::vector *trackers = nullptr, + bool send_derived_velocity = false) { + auto trackers__ = trackers ? _fbb.CreateVector(*trackers) : 0; + return solarxr_protocol::rpc::CreateOutputTrackersSettingsResponse( _fbb, - command__); + automatic_tracker_toggle, + trackers__, + send_derived_velocity); } -struct SerialDevicesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialDevicesRequestBuilder Builder; +struct ChangeOutputTrackersSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeOutputTrackersSettingsRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AUTOMATIC_TRACKER_TOGGLE = 4, + VT_TRACKERS = 6, + VT_SEND_DERIVED_VELOCITY = 8 + }; + bool automatic_tracker_toggle() const { + return GetField(VT_AUTOMATIC_TRACKER_TOGGLE, 0) != 0; + } + const flatbuffers::Vector *trackers() const { + return GetPointer *>(VT_TRACKERS); + } + bool send_derived_velocity() const { + return GetField(VT_SEND_DERIVED_VELOCITY, 0) != 0; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_AUTOMATIC_TRACKER_TOGGLE, 1) && + VerifyOffset(verifier, VT_TRACKERS) && + verifier.VerifyVector(trackers()) && + VerifyField(verifier, VT_SEND_DERIVED_VELOCITY, 1) && verifier.EndTable(); } }; -struct SerialDevicesRequestBuilder { - typedef SerialDevicesRequest Table; +struct ChangeOutputTrackersSettingsRequestBuilder { + typedef ChangeOutputTrackersSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SerialDevicesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_automatic_tracker_toggle(bool automatic_tracker_toggle) { + fbb_.AddElement(ChangeOutputTrackersSettingsRequest::VT_AUTOMATIC_TRACKER_TOGGLE, static_cast(automatic_tracker_toggle), 0); + } + void add_trackers(flatbuffers::Offset> trackers) { + fbb_.AddOffset(ChangeOutputTrackersSettingsRequest::VT_TRACKERS, trackers); + } + void add_send_derived_velocity(bool send_derived_velocity) { + fbb_.AddElement(ChangeOutputTrackersSettingsRequest::VT_SEND_DERIVED_VELOCITY, static_cast(send_derived_velocity), 0); + } + explicit ChangeOutputTrackersSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialDevicesRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SerialDevicesRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateChangeOutputTrackersSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb, + bool automatic_tracker_toggle = false, + flatbuffers::Offset> trackers = 0, + bool send_derived_velocity = false) { + ChangeOutputTrackersSettingsRequestBuilder builder_(_fbb); + builder_.add_trackers(trackers); + builder_.add_send_derived_velocity(send_derived_velocity); + builder_.add_automatic_tracker_toggle(automatic_tracker_toggle); return builder_.Finish(); } -struct SerialDevicesResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialDevicesResponseBuilder Builder; +inline flatbuffers::Offset CreateChangeOutputTrackersSettingsRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool automatic_tracker_toggle = false, + const std::vector *trackers = nullptr, + bool send_derived_velocity = false) { + auto trackers__ = trackers ? _fbb.CreateVector(*trackers) : 0; + return solarxr_protocol::rpc::CreateChangeOutputTrackersSettingsRequest( + _fbb, + automatic_tracker_toggle, + trackers__, + send_derived_velocity); +} + +struct EnableStayAlignedRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EnableStayAlignedRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICES = 4 + VT_ENABLE = 4 }; - const flatbuffers::Vector> *devices() const { - return GetPointer> *>(VT_DEVICES); + bool enable() const { + return GetField(VT_ENABLE, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_DEVICES) && - verifier.VerifyVector(devices()) && - verifier.VerifyVectorOfTables(devices()) && + VerifyField(verifier, VT_ENABLE, 1) && verifier.EndTable(); } }; -struct SerialDevicesResponseBuilder { - typedef SerialDevicesResponse Table; +struct EnableStayAlignedRequestBuilder { + typedef EnableStayAlignedRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_devices(flatbuffers::Offset>> devices) { - fbb_.AddOffset(SerialDevicesResponse::VT_DEVICES, devices); + void add_enable(bool enable) { + fbb_.AddElement(EnableStayAlignedRequest::VT_ENABLE, static_cast(enable), 0); } - explicit SerialDevicesResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit EnableStayAlignedRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialDevicesResponse( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> devices = 0) { - SerialDevicesResponseBuilder builder_(_fbb); - builder_.add_devices(devices); - return builder_.Finish(); -} - -inline flatbuffers::Offset CreateSerialDevicesResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *devices = nullptr) { - auto devices__ = devices ? _fbb.CreateVector>(*devices) : 0; - return solarxr_protocol::rpc::CreateSerialDevicesResponse( - _fbb, - devices__); +inline flatbuffers::Offset CreateEnableStayAlignedRequest( + flatbuffers::FlatBufferBuilder &_fbb, + bool enable = false) { + EnableStayAlignedRequestBuilder builder_(_fbb); + builder_.add_enable(enable); + return builder_.Finish(); } -struct NewSerialDeviceResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef NewSerialDeviceResponseBuilder Builder; +struct DetectStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DetectStayAlignedRelaxedPoseRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICE = 4 + VT_POSE = 4 }; - const solarxr_protocol::rpc::SerialDevice *device() const { - return GetPointer(VT_DEVICE); + solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { + return static_cast(GetField(VT_POSE, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_DEVICE) && - verifier.VerifyTable(device()) && + VerifyField(verifier, VT_POSE, 1) && verifier.EndTable(); } }; -struct NewSerialDeviceResponseBuilder { - typedef NewSerialDeviceResponse Table; +struct DetectStayAlignedRelaxedPoseRequestBuilder { + typedef DetectStayAlignedRelaxedPoseRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_device(flatbuffers::Offset device) { - fbb_.AddOffset(NewSerialDeviceResponse::VT_DEVICE, device); + void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { + fbb_.AddElement(DetectStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); } - explicit NewSerialDeviceResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit DetectStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateNewSerialDeviceResponse( +inline flatbuffers::Offset CreateDetectStayAlignedRelaxedPoseRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset device = 0) { - NewSerialDeviceResponseBuilder builder_(_fbb); - builder_.add_device(device); + solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { + DetectStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); + builder_.add_pose(pose); return builder_.Finish(); } -struct StartWifiProvisioningRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StartWifiProvisioningRequestBuilder Builder; +struct ResetStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResetStayAlignedRelaxedPoseRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_SSID = 4, - VT_PASSWORD = 6, - VT_PORT = 8 + VT_POSE = 4 }; - const flatbuffers::String *ssid() const { - return GetPointer(VT_SSID); - } - const flatbuffers::String *password() const { - return GetPointer(VT_PASSWORD); - } - const flatbuffers::String *port() const { - return GetPointer(VT_PORT); + solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { + return static_cast(GetField(VT_POSE, 0)); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_SSID) && - verifier.VerifyString(ssid()) && - VerifyOffset(verifier, VT_PASSWORD) && - verifier.VerifyString(password()) && - VerifyOffset(verifier, VT_PORT) && - verifier.VerifyString(port()) && + VerifyField(verifier, VT_POSE, 1) && verifier.EndTable(); } }; -struct StartWifiProvisioningRequestBuilder { - typedef StartWifiProvisioningRequest Table; +struct ResetStayAlignedRelaxedPoseRequestBuilder { + typedef ResetStayAlignedRelaxedPoseRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_ssid(flatbuffers::Offset ssid) { - fbb_.AddOffset(StartWifiProvisioningRequest::VT_SSID, ssid); - } - void add_password(flatbuffers::Offset password) { - fbb_.AddOffset(StartWifiProvisioningRequest::VT_PASSWORD, password); - } - void add_port(flatbuffers::Offset port) { - fbb_.AddOffset(StartWifiProvisioningRequest::VT_PORT, port); + void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { + fbb_.AddElement(ResetStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); } - explicit StartWifiProvisioningRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ResetStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStartWifiProvisioningRequest( +inline flatbuffers::Offset CreateResetStayAlignedRelaxedPoseRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset ssid = 0, - flatbuffers::Offset password = 0, - flatbuffers::Offset port = 0) { - StartWifiProvisioningRequestBuilder builder_(_fbb); - builder_.add_port(port); - builder_.add_password(password); - builder_.add_ssid(ssid); + solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { + ResetStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); + builder_.add_pose(pose); return builder_.Finish(); } -inline flatbuffers::Offset CreateStartWifiProvisioningRequestDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *ssid = nullptr, - const char *password = nullptr, - const char *port = nullptr) { - auto ssid__ = ssid ? _fbb.CreateString(ssid) : 0; - auto password__ = password ? _fbb.CreateString(password) : 0; - auto port__ = port ? _fbb.CreateString(port) : 0; - return solarxr_protocol::rpc::CreateStartWifiProvisioningRequest( - _fbb, - ssid__, - password__, - port__); -} - -struct StopWifiProvisioningRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StopWifiProvisioningRequestBuilder Builder; +struct StayAlignedSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StayAlignedSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct StopWifiProvisioningRequestBuilder { - typedef StopWifiProvisioningRequest Table; +struct StayAlignedSettingsRequestBuilder { + typedef StayAlignedSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit StopWifiProvisioningRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StayAlignedSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStopWifiProvisioningRequest( +inline flatbuffers::Offset CreateStayAlignedSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb) { - StopWifiProvisioningRequestBuilder builder_(_fbb); + StayAlignedSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct WifiProvisioningStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef WifiProvisioningStatusResponseBuilder Builder; +struct StayAlignedSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StayAlignedSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STATUS = 4 + VT_ENABLED = 4, + VT_STANDING_ENABLED = 6, + VT_STANDING_UPPER_LEG_ANGLE = 8, + VT_STANDING_LOWER_LEG_ANGLE = 10, + VT_STANDING_FOOT_ANGLE = 12, + VT_SITTING_ENABLED = 14, + VT_SITTING_UPPER_LEG_ANGLE = 16, + VT_SITTING_LOWER_LEG_ANGLE = 18, + VT_SITTING_FOOT_ANGLE = 20, + VT_FLAT_ENABLED = 22, + VT_FLAT_UPPER_LEG_ANGLE = 24, + VT_FLAT_LOWER_LEG_ANGLE = 26, + VT_FLAT_FOOT_ANGLE = 28 }; - solarxr_protocol::rpc::WifiProvisioningStatus status() const { - return static_cast(GetField(VT_STATUS, 0)); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + bool standing_enabled() const { + return GetField(VT_STANDING_ENABLED, 0) != 0; + } + float standing_upper_leg_angle() const { + return GetField(VT_STANDING_UPPER_LEG_ANGLE, 0.0f); + } + float standing_lower_leg_angle() const { + return GetField(VT_STANDING_LOWER_LEG_ANGLE, 0.0f); + } + float standing_foot_angle() const { + return GetField(VT_STANDING_FOOT_ANGLE, 0.0f); + } + bool sitting_enabled() const { + return GetField(VT_SITTING_ENABLED, 0) != 0; + } + float sitting_upper_leg_angle() const { + return GetField(VT_SITTING_UPPER_LEG_ANGLE, 0.0f); + } + float sitting_lower_leg_angle() const { + return GetField(VT_SITTING_LOWER_LEG_ANGLE, 0.0f); + } + float sitting_foot_angle() const { + return GetField(VT_SITTING_FOOT_ANGLE, 0.0f); + } + bool flat_enabled() const { + return GetField(VT_FLAT_ENABLED, 0) != 0; + } + float flat_upper_leg_angle() const { + return GetField(VT_FLAT_UPPER_LEG_ANGLE, 0.0f); + } + float flat_lower_leg_angle() const { + return GetField(VT_FLAT_LOWER_LEG_ANGLE, 0.0f); + } + float flat_foot_angle() const { + return GetField(VT_FLAT_FOOT_ANGLE, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_STATUS, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_STANDING_ENABLED, 1) && + VerifyField(verifier, VT_STANDING_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_STANDING_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_STANDING_FOOT_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_ENABLED, 1) && + VerifyField(verifier, VT_SITTING_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_FOOT_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_ENABLED, 1) && + VerifyField(verifier, VT_FLAT_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_FOOT_ANGLE, 4) && verifier.EndTable(); } }; -struct WifiProvisioningStatusResponseBuilder { - typedef WifiProvisioningStatusResponse Table; +struct StayAlignedSettingsResponseBuilder { + typedef StayAlignedSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_status(solarxr_protocol::rpc::WifiProvisioningStatus status) { - fbb_.AddElement(WifiProvisioningStatusResponse::VT_STATUS, static_cast(status), 0); + void add_enabled(bool enabled) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_ENABLED, static_cast(enabled), 0); } - explicit WifiProvisioningStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_standing_enabled(bool standing_enabled) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_STANDING_ENABLED, static_cast(standing_enabled), 0); + } + void add_standing_upper_leg_angle(float standing_upper_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_STANDING_UPPER_LEG_ANGLE, standing_upper_leg_angle, 0.0f); + } + void add_standing_lower_leg_angle(float standing_lower_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_STANDING_LOWER_LEG_ANGLE, standing_lower_leg_angle, 0.0f); + } + void add_standing_foot_angle(float standing_foot_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_STANDING_FOOT_ANGLE, standing_foot_angle, 0.0f); + } + void add_sitting_enabled(bool sitting_enabled) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_SITTING_ENABLED, static_cast(sitting_enabled), 0); + } + void add_sitting_upper_leg_angle(float sitting_upper_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_SITTING_UPPER_LEG_ANGLE, sitting_upper_leg_angle, 0.0f); + } + void add_sitting_lower_leg_angle(float sitting_lower_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_SITTING_LOWER_LEG_ANGLE, sitting_lower_leg_angle, 0.0f); + } + void add_sitting_foot_angle(float sitting_foot_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_SITTING_FOOT_ANGLE, sitting_foot_angle, 0.0f); + } + void add_flat_enabled(bool flat_enabled) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_FLAT_ENABLED, static_cast(flat_enabled), 0); + } + void add_flat_upper_leg_angle(float flat_upper_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_FLAT_UPPER_LEG_ANGLE, flat_upper_leg_angle, 0.0f); + } + void add_flat_lower_leg_angle(float flat_lower_leg_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_FLAT_LOWER_LEG_ANGLE, flat_lower_leg_angle, 0.0f); + } + void add_flat_foot_angle(float flat_foot_angle) { + fbb_.AddElement(StayAlignedSettingsResponse::VT_FLAT_FOOT_ANGLE, flat_foot_angle, 0.0f); + } + explicit StayAlignedSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateWifiProvisioningStatusResponse( +inline flatbuffers::Offset CreateStayAlignedSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::WifiProvisioningStatus status = solarxr_protocol::rpc::WifiProvisioningStatus::NONE) { - WifiProvisioningStatusResponseBuilder builder_(_fbb); - builder_.add_status(status); + bool enabled = false, + bool standing_enabled = false, + float standing_upper_leg_angle = 0.0f, + float standing_lower_leg_angle = 0.0f, + float standing_foot_angle = 0.0f, + bool sitting_enabled = false, + float sitting_upper_leg_angle = 0.0f, + float sitting_lower_leg_angle = 0.0f, + float sitting_foot_angle = 0.0f, + bool flat_enabled = false, + float flat_upper_leg_angle = 0.0f, + float flat_lower_leg_angle = 0.0f, + float flat_foot_angle = 0.0f) { + StayAlignedSettingsResponseBuilder builder_(_fbb); + builder_.add_flat_foot_angle(flat_foot_angle); + builder_.add_flat_lower_leg_angle(flat_lower_leg_angle); + builder_.add_flat_upper_leg_angle(flat_upper_leg_angle); + builder_.add_sitting_foot_angle(sitting_foot_angle); + builder_.add_sitting_lower_leg_angle(sitting_lower_leg_angle); + builder_.add_sitting_upper_leg_angle(sitting_upper_leg_angle); + builder_.add_standing_foot_angle(standing_foot_angle); + builder_.add_standing_lower_leg_angle(standing_lower_leg_angle); + builder_.add_standing_upper_leg_angle(standing_upper_leg_angle); + builder_.add_flat_enabled(flat_enabled); + builder_.add_sitting_enabled(sitting_enabled); + builder_.add_standing_enabled(standing_enabled); + builder_.add_enabled(enabled); return builder_.Finish(); } -struct AutoBoneProcessRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneProcessRequestBuilder Builder; +struct ChangeStayAlignedSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeStayAlignedSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PROCESS_TYPE = 4 + VT_ENABLED = 4, + VT_STANDING_ENABLED = 6, + VT_STANDING_UPPER_LEG_ANGLE = 8, + VT_STANDING_LOWER_LEG_ANGLE = 10, + VT_STANDING_FOOT_ANGLE = 12, + VT_SITTING_ENABLED = 14, + VT_SITTING_UPPER_LEG_ANGLE = 16, + VT_SITTING_LOWER_LEG_ANGLE = 18, + VT_SITTING_FOOT_ANGLE = 20, + VT_FLAT_ENABLED = 22, + VT_FLAT_UPPER_LEG_ANGLE = 24, + VT_FLAT_LOWER_LEG_ANGLE = 26, + VT_FLAT_FOOT_ANGLE = 28 }; - solarxr_protocol::rpc::AutoBoneProcessType process_type() const { - return static_cast(GetField(VT_PROCESS_TYPE, 0)); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + bool standing_enabled() const { + return GetField(VT_STANDING_ENABLED, 0) != 0; + } + float standing_upper_leg_angle() const { + return GetField(VT_STANDING_UPPER_LEG_ANGLE, 0.0f); + } + float standing_lower_leg_angle() const { + return GetField(VT_STANDING_LOWER_LEG_ANGLE, 0.0f); + } + float standing_foot_angle() const { + return GetField(VT_STANDING_FOOT_ANGLE, 0.0f); + } + bool sitting_enabled() const { + return GetField(VT_SITTING_ENABLED, 0) != 0; + } + float sitting_upper_leg_angle() const { + return GetField(VT_SITTING_UPPER_LEG_ANGLE, 0.0f); + } + float sitting_lower_leg_angle() const { + return GetField(VT_SITTING_LOWER_LEG_ANGLE, 0.0f); + } + float sitting_foot_angle() const { + return GetField(VT_SITTING_FOOT_ANGLE, 0.0f); + } + bool flat_enabled() const { + return GetField(VT_FLAT_ENABLED, 0) != 0; + } + float flat_upper_leg_angle() const { + return GetField(VT_FLAT_UPPER_LEG_ANGLE, 0.0f); + } + float flat_lower_leg_angle() const { + return GetField(VT_FLAT_LOWER_LEG_ANGLE, 0.0f); + } + float flat_foot_angle() const { + return GetField(VT_FLAT_FOOT_ANGLE, 0.0f); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_PROCESS_TYPE, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_STANDING_ENABLED, 1) && + VerifyField(verifier, VT_STANDING_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_STANDING_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_STANDING_FOOT_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_ENABLED, 1) && + VerifyField(verifier, VT_SITTING_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_SITTING_FOOT_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_ENABLED, 1) && + VerifyField(verifier, VT_FLAT_UPPER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_LOWER_LEG_ANGLE, 4) && + VerifyField(verifier, VT_FLAT_FOOT_ANGLE, 4) && verifier.EndTable(); } }; -struct AutoBoneProcessRequestBuilder { - typedef AutoBoneProcessRequest Table; +struct ChangeStayAlignedSettingsRequestBuilder { + typedef ChangeStayAlignedSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_process_type(solarxr_protocol::rpc::AutoBoneProcessType process_type) { - fbb_.AddElement(AutoBoneProcessRequest::VT_PROCESS_TYPE, static_cast(process_type), 0); + void add_enabled(bool enabled) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_ENABLED, static_cast(enabled), 0); } - explicit AutoBoneProcessRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_standing_enabled(bool standing_enabled) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_STANDING_ENABLED, static_cast(standing_enabled), 0); + } + void add_standing_upper_leg_angle(float standing_upper_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_STANDING_UPPER_LEG_ANGLE, standing_upper_leg_angle, 0.0f); + } + void add_standing_lower_leg_angle(float standing_lower_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_STANDING_LOWER_LEG_ANGLE, standing_lower_leg_angle, 0.0f); + } + void add_standing_foot_angle(float standing_foot_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_STANDING_FOOT_ANGLE, standing_foot_angle, 0.0f); + } + void add_sitting_enabled(bool sitting_enabled) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_SITTING_ENABLED, static_cast(sitting_enabled), 0); + } + void add_sitting_upper_leg_angle(float sitting_upper_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_SITTING_UPPER_LEG_ANGLE, sitting_upper_leg_angle, 0.0f); + } + void add_sitting_lower_leg_angle(float sitting_lower_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_SITTING_LOWER_LEG_ANGLE, sitting_lower_leg_angle, 0.0f); + } + void add_sitting_foot_angle(float sitting_foot_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_SITTING_FOOT_ANGLE, sitting_foot_angle, 0.0f); + } + void add_flat_enabled(bool flat_enabled) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_FLAT_ENABLED, static_cast(flat_enabled), 0); + } + void add_flat_upper_leg_angle(float flat_upper_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_FLAT_UPPER_LEG_ANGLE, flat_upper_leg_angle, 0.0f); + } + void add_flat_lower_leg_angle(float flat_lower_leg_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_FLAT_LOWER_LEG_ANGLE, flat_lower_leg_angle, 0.0f); + } + void add_flat_foot_angle(float flat_foot_angle) { + fbb_.AddElement(ChangeStayAlignedSettingsRequest::VT_FLAT_FOOT_ANGLE, flat_foot_angle, 0.0f); + } + explicit ChangeStayAlignedSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAutoBoneProcessRequest( +inline flatbuffers::Offset CreateChangeStayAlignedSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::AutoBoneProcessType process_type = solarxr_protocol::rpc::AutoBoneProcessType::NONE) { - AutoBoneProcessRequestBuilder builder_(_fbb); - builder_.add_process_type(process_type); + bool enabled = false, + bool standing_enabled = false, + float standing_upper_leg_angle = 0.0f, + float standing_lower_leg_angle = 0.0f, + float standing_foot_angle = 0.0f, + bool sitting_enabled = false, + float sitting_upper_leg_angle = 0.0f, + float sitting_lower_leg_angle = 0.0f, + float sitting_foot_angle = 0.0f, + bool flat_enabled = false, + float flat_upper_leg_angle = 0.0f, + float flat_lower_leg_angle = 0.0f, + float flat_foot_angle = 0.0f) { + ChangeStayAlignedSettingsRequestBuilder builder_(_fbb); + builder_.add_flat_foot_angle(flat_foot_angle); + builder_.add_flat_lower_leg_angle(flat_lower_leg_angle); + builder_.add_flat_upper_leg_angle(flat_upper_leg_angle); + builder_.add_sitting_foot_angle(sitting_foot_angle); + builder_.add_sitting_lower_leg_angle(sitting_lower_leg_angle); + builder_.add_sitting_upper_leg_angle(sitting_upper_leg_angle); + builder_.add_standing_foot_angle(standing_foot_angle); + builder_.add_standing_lower_leg_angle(standing_lower_leg_angle); + builder_.add_standing_upper_leg_angle(standing_upper_leg_angle); + builder_.add_flat_enabled(flat_enabled); + builder_.add_sitting_enabled(sitting_enabled); + builder_.add_standing_enabled(standing_enabled); + builder_.add_enabled(enabled); return builder_.Finish(); } -struct AutoBoneProcessStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneProcessStatusResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PROCESS_TYPE = 4, - VT_CURRENT = 8, - VT_TOTAL = 10, - VT_COMPLETED = 12, - VT_SUCCESS = 14, - VT_ETA = 16 - }; - solarxr_protocol::rpc::AutoBoneProcessType process_type() const { - return static_cast(GetField(VT_PROCESS_TYPE, 0)); - } - /// The current count. This value is -1 if there is nothing to report. - uint32_t current() const { - return GetField(VT_CURRENT, 0); - } - /// The total count. This value is -1 if there is nothing to report. - uint32_t total() const { - return GetField(VT_TOTAL, 0); +struct CompleteStayAlignedResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CompleteStayAlignedResponseBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - /// True if the operation has completed with any result, successful or not. - bool completed() const { - return GetField(VT_COMPLETED, 0) != 0; +}; + +struct CompleteStayAlignedResponseBuilder { + typedef CompleteStayAlignedResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit CompleteStayAlignedResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - /// True if the completed operation was successful, only observe if `completed` is true. - bool success() const { - return GetField(VT_SUCCESS, 0) != 0; + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - /// The time remaining in seconds. This value is -1 if there is nothing to report. - float eta() const { - return GetField(VT_ETA, 0.0f); +}; + +inline flatbuffers::Offset CreateCompleteStayAlignedResponse( + flatbuffers::FlatBufferBuilder &_fbb) { + CompleteStayAlignedResponseBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct StayAlignedHideCorrectionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StayAlignedHideCorrectionRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_HIDE_CORRECTION = 4 + }; + bool hide_correction() const { + return GetField(VT_HIDE_CORRECTION, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_PROCESS_TYPE, 1) && - VerifyField(verifier, VT_CURRENT, 4) && - VerifyField(verifier, VT_TOTAL, 4) && - VerifyField(verifier, VT_COMPLETED, 1) && - VerifyField(verifier, VT_SUCCESS, 1) && - VerifyField(verifier, VT_ETA, 4) && + VerifyField(verifier, VT_HIDE_CORRECTION, 1) && verifier.EndTable(); } }; -struct AutoBoneProcessStatusResponseBuilder { - typedef AutoBoneProcessStatusResponse Table; +struct StayAlignedHideCorrectionRequestBuilder { + typedef StayAlignedHideCorrectionRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_process_type(solarxr_protocol::rpc::AutoBoneProcessType process_type) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_PROCESS_TYPE, static_cast(process_type), 0); - } - void add_current(uint32_t current) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_CURRENT, current, 0); - } - void add_total(uint32_t total) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_TOTAL, total, 0); - } - void add_completed(bool completed) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_COMPLETED, static_cast(completed), 0); - } - void add_success(bool success) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_SUCCESS, static_cast(success), 0); - } - void add_eta(float eta) { - fbb_.AddElement(AutoBoneProcessStatusResponse::VT_ETA, eta, 0.0f); + void add_hide_correction(bool hide_correction) { + fbb_.AddElement(StayAlignedHideCorrectionRequest::VT_HIDE_CORRECTION, static_cast(hide_correction), 0); } - explicit AutoBoneProcessStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit StayAlignedHideCorrectionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAutoBoneProcessStatusResponse( +inline flatbuffers::Offset CreateStayAlignedHideCorrectionRequest( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::AutoBoneProcessType process_type = solarxr_protocol::rpc::AutoBoneProcessType::NONE, - uint32_t current = 0, - uint32_t total = 0, - bool completed = false, - bool success = false, - float eta = 0.0f) { - AutoBoneProcessStatusResponseBuilder builder_(_fbb); - builder_.add_eta(eta); - builder_.add_total(total); - builder_.add_current(current); - builder_.add_success(success); - builder_.add_completed(completed); - builder_.add_process_type(process_type); + bool hide_correction = false) { + StayAlignedHideCorrectionRequestBuilder builder_(_fbb); + builder_.add_hide_correction(hide_correction); return builder_.Finish(); } -struct AutoBoneEpochResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneEpochResponseBuilder Builder; +struct AssignTrackerRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AssignTrackerRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CURRENT_EPOCH = 4, - VT_TOTAL_EPOCHS = 6, - VT_EPOCH_ERROR = 8, - VT_ADJUSTED_SKELETON_PARTS = 10 + VT_TRACKER_ID = 4, + VT_BODY_POSITION = 6, + VT_MOUNTING_ORIENTATION = 8, + VT_DISPLAY_NAME = 10 }; - uint32_t current_epoch() const { - return GetField(VT_CURRENT_EPOCH, 0); + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); } - uint32_t total_epochs() const { - return GetField(VT_TOTAL_EPOCHS, 0); + solarxr_protocol::datatypes::BodyPart body_position() const { + return static_cast(GetField(VT_BODY_POSITION, 0)); } - /// The current error value. This can be any positive number, where lower is better. - float epoch_error() const { - return GetField(VT_EPOCH_ERROR, 0.0f); + const solarxr_protocol::datatypes::math::Quat *mounting_orientation() const { + return GetStruct(VT_MOUNTING_ORIENTATION); } - /// A list of the current estimated body proportions. - const flatbuffers::Vector> *adjusted_skeleton_parts() const { - return GetPointer> *>(VT_ADJUSTED_SKELETON_PARTS); + const flatbuffers::String *display_name() const { + return GetPointer(VT_DISPLAY_NAME); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_CURRENT_EPOCH, 4) && - VerifyField(verifier, VT_TOTAL_EPOCHS, 4) && - VerifyField(verifier, VT_EPOCH_ERROR, 4) && - VerifyOffset(verifier, VT_ADJUSTED_SKELETON_PARTS) && - verifier.VerifyVector(adjusted_skeleton_parts()) && - verifier.VerifyVectorOfTables(adjusted_skeleton_parts()) && + VerifyField(verifier, VT_TRACKER_ID, 2) && + VerifyField(verifier, VT_BODY_POSITION, 1) && + VerifyField(verifier, VT_MOUNTING_ORIENTATION, 4) && + VerifyOffset(verifier, VT_DISPLAY_NAME) && + verifier.VerifyString(display_name()) && verifier.EndTable(); } }; -struct AutoBoneEpochResponseBuilder { - typedef AutoBoneEpochResponse Table; +struct AssignTrackerRequestBuilder { + typedef AssignTrackerRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_current_epoch(uint32_t current_epoch) { - fbb_.AddElement(AutoBoneEpochResponse::VT_CURRENT_EPOCH, current_epoch, 0); + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(AssignTrackerRequest::VT_TRACKER_ID, tracker_id, 0); } - void add_total_epochs(uint32_t total_epochs) { - fbb_.AddElement(AutoBoneEpochResponse::VT_TOTAL_EPOCHS, total_epochs, 0); + void add_body_position(solarxr_protocol::datatypes::BodyPart body_position) { + fbb_.AddElement(AssignTrackerRequest::VT_BODY_POSITION, static_cast(body_position), 0); } - void add_epoch_error(float epoch_error) { - fbb_.AddElement(AutoBoneEpochResponse::VT_EPOCH_ERROR, epoch_error, 0.0f); + void add_mounting_orientation(const solarxr_protocol::datatypes::math::Quat *mounting_orientation) { + fbb_.AddStruct(AssignTrackerRequest::VT_MOUNTING_ORIENTATION, mounting_orientation); } - void add_adjusted_skeleton_parts(flatbuffers::Offset>> adjusted_skeleton_parts) { - fbb_.AddOffset(AutoBoneEpochResponse::VT_ADJUSTED_SKELETON_PARTS, adjusted_skeleton_parts); + void add_display_name(flatbuffers::Offset display_name) { + fbb_.AddOffset(AssignTrackerRequest::VT_DISPLAY_NAME, display_name); } - explicit AutoBoneEpochResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit AssignTrackerRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAutoBoneEpochResponse( +inline flatbuffers::Offset CreateAssignTrackerRequest( flatbuffers::FlatBufferBuilder &_fbb, - uint32_t current_epoch = 0, - uint32_t total_epochs = 0, - float epoch_error = 0.0f, - flatbuffers::Offset>> adjusted_skeleton_parts = 0) { - AutoBoneEpochResponseBuilder builder_(_fbb); - builder_.add_adjusted_skeleton_parts(adjusted_skeleton_parts); - builder_.add_epoch_error(epoch_error); - builder_.add_total_epochs(total_epochs); - builder_.add_current_epoch(current_epoch); + uint16_t tracker_id = 0, + solarxr_protocol::datatypes::BodyPart body_position = solarxr_protocol::datatypes::BodyPart::NONE, + const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, + flatbuffers::Offset display_name = 0) { + AssignTrackerRequestBuilder builder_(_fbb); + builder_.add_display_name(display_name); + builder_.add_mounting_orientation(mounting_orientation); + builder_.add_tracker_id(tracker_id); + builder_.add_body_position(body_position); return builder_.Finish(); } -inline flatbuffers::Offset CreateAutoBoneEpochResponseDirect( +inline flatbuffers::Offset CreateAssignTrackerRequestDirect( flatbuffers::FlatBufferBuilder &_fbb, - uint32_t current_epoch = 0, - uint32_t total_epochs = 0, - float epoch_error = 0.0f, - const std::vector> *adjusted_skeleton_parts = nullptr) { - auto adjusted_skeleton_parts__ = adjusted_skeleton_parts ? _fbb.CreateVector>(*adjusted_skeleton_parts) : 0; - return solarxr_protocol::rpc::CreateAutoBoneEpochResponse( + uint16_t tracker_id = 0, + solarxr_protocol::datatypes::BodyPart body_position = solarxr_protocol::datatypes::BodyPart::NONE, + const solarxr_protocol::datatypes::math::Quat *mounting_orientation = nullptr, + const char *display_name = nullptr) { + auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0; + return solarxr_protocol::rpc::CreateAssignTrackerRequest( _fbb, - current_epoch, - total_epochs, - epoch_error, - adjusted_skeleton_parts__); + tracker_id, + body_position, + mounting_orientation, + display_name__); } -/// https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt -struct AutoBoneSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneSettingsBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CURSOR_INCREMENT = 4, - VT_MIN_DATA_DISTANCE = 6, - VT_MAX_DATA_DISTANCE = 8, - VT_NUM_EPOCHS = 10, - VT_PRINT_EVERY_NUM_EPOCHS = 12, - VT_INITIAL_ADJUST_RATE = 14, - VT_ADJUST_RATE_DECAY = 16, - VT_SLIDE_ERROR_FACTOR = 18, - VT_OFFSET_SLIDE_ERROR_FACTOR = 20, - VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR = 22, - VT_BODY_PROPORTION_ERROR_FACTOR = 24, - VT_HEIGHT_ERROR_FACTOR = 26, - VT_POSITION_ERROR_FACTOR = 28, - VT_POSITION_OFFSET_ERROR_FACTOR = 30, - VT_CALC_INIT_ERROR = 32, - VT_RANDOMIZE_FRAME_ORDER = 34, - VT_SCALE_EACH_STEP = 36, - VT_SAMPLE_COUNT = 38, - VT_SAMPLE_RATE_MS = 40, - VT_SAVE_RECORDINGS = 42, - VT_USE_SKELETON_HEIGHT = 44, - VT_RAND_SEED = 46 - }; - flatbuffers::Optional cursor_increment() const { - return GetOptional(VT_CURSOR_INCREMENT); - } - flatbuffers::Optional min_data_distance() const { - return GetOptional(VT_MIN_DATA_DISTANCE); - } - flatbuffers::Optional max_data_distance() const { - return GetOptional(VT_MAX_DATA_DISTANCE); - } - flatbuffers::Optional num_epochs() const { - return GetOptional(VT_NUM_EPOCHS); - } - flatbuffers::Optional print_every_num_epochs() const { - return GetOptional(VT_PRINT_EVERY_NUM_EPOCHS); - } - flatbuffers::Optional initial_adjust_rate() const { - return GetOptional(VT_INITIAL_ADJUST_RATE); - } - flatbuffers::Optional adjust_rate_decay() const { - return GetOptional(VT_ADJUST_RATE_DECAY); +struct TapDetectionSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TapDetectionSettingsRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); } - flatbuffers::Optional slide_error_factor() const { - return GetOptional(VT_SLIDE_ERROR_FACTOR); +}; + +struct TapDetectionSettingsRequestBuilder { + typedef TapDetectionSettingsRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit TapDetectionSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } - flatbuffers::Optional offset_slide_error_factor() const { - return GetOptional(VT_OFFSET_SLIDE_ERROR_FACTOR); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; } - flatbuffers::Optional foot_height_offset_error_factor() const { - return GetOptional(VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR); +}; + +inline flatbuffers::Offset CreateTapDetectionSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + TapDetectionSettingsRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct TapDetectionSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TapDetectionSettingsResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_FULL_RESET_DELAY = 4, + VT_FULL_RESET_ENABLED = 6, + VT_FULL_RESET_TAPS = 8, + VT_YAW_RESET_DELAY = 10, + VT_YAW_RESET_ENABLED = 12, + VT_YAW_RESET_TAPS = 14, + VT_MOUNTING_RESET_DELAY = 16, + VT_MOUNTING_RESET_ENABLED = 18, + VT_MOUNTING_RESET_TAPS = 20, + VT_NUMBER_TRACKERS_OVER_THRESHOLD = 22, + VT_YAW_RESET_TRACKER = 24, + VT_FULL_RESET_TRACKER = 26, + VT_MOUNTING_RESET_TRACKER = 28 + }; + flatbuffers::Optional full_reset_delay() const { + return GetOptional(VT_FULL_RESET_DELAY); } - flatbuffers::Optional body_proportion_error_factor() const { - return GetOptional(VT_BODY_PROPORTION_ERROR_FACTOR); + flatbuffers::Optional full_reset_enabled() const { + return GetOptional(VT_FULL_RESET_ENABLED); } - flatbuffers::Optional height_error_factor() const { - return GetOptional(VT_HEIGHT_ERROR_FACTOR); + flatbuffers::Optional full_reset_taps() const { + return GetOptional(VT_FULL_RESET_TAPS); } - flatbuffers::Optional position_error_factor() const { - return GetOptional(VT_POSITION_ERROR_FACTOR); + flatbuffers::Optional yaw_reset_delay() const { + return GetOptional(VT_YAW_RESET_DELAY); } - flatbuffers::Optional position_offset_error_factor() const { - return GetOptional(VT_POSITION_OFFSET_ERROR_FACTOR); + flatbuffers::Optional yaw_reset_enabled() const { + return GetOptional(VT_YAW_RESET_ENABLED); } - flatbuffers::Optional calc_init_error() const { - return GetOptional(VT_CALC_INIT_ERROR); + flatbuffers::Optional yaw_reset_taps() const { + return GetOptional(VT_YAW_RESET_TAPS); } - flatbuffers::Optional randomize_frame_order() const { - return GetOptional(VT_RANDOMIZE_FRAME_ORDER); + flatbuffers::Optional mounting_reset_delay() const { + return GetOptional(VT_MOUNTING_RESET_DELAY); } - flatbuffers::Optional scale_each_step() const { - return GetOptional(VT_SCALE_EACH_STEP); + flatbuffers::Optional mounting_reset_enabled() const { + return GetOptional(VT_MOUNTING_RESET_ENABLED); } - flatbuffers::Optional sample_count() const { - return GetOptional(VT_SAMPLE_COUNT); + flatbuffers::Optional mounting_reset_taps() const { + return GetOptional(VT_MOUNTING_RESET_TAPS); } - flatbuffers::Optional sample_rate_ms() const { - return GetOptional(VT_SAMPLE_RATE_MS); + flatbuffers::Optional number_trackers_over_threshold() const { + return GetOptional(VT_NUMBER_TRACKERS_OVER_THRESHOLD); } - flatbuffers::Optional save_recordings() const { - return GetOptional(VT_SAVE_RECORDINGS); + flatbuffers::Optional yaw_reset_tracker() const { + return GetOptional(VT_YAW_RESET_TRACKER); } - flatbuffers::Optional use_skeleton_height() const { - return GetOptional(VT_USE_SKELETON_HEIGHT); + flatbuffers::Optional full_reset_tracker() const { + return GetOptional(VT_FULL_RESET_TRACKER); } - flatbuffers::Optional rand_seed() const { - return GetOptional(VT_RAND_SEED); + flatbuffers::Optional mounting_reset_tracker() const { + return GetOptional(VT_MOUNTING_RESET_TRACKER); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_CURSOR_INCREMENT, 4) && - VerifyField(verifier, VT_MIN_DATA_DISTANCE, 4) && - VerifyField(verifier, VT_MAX_DATA_DISTANCE, 4) && - VerifyField(verifier, VT_NUM_EPOCHS, 4) && - VerifyField(verifier, VT_PRINT_EVERY_NUM_EPOCHS, 4) && - VerifyField(verifier, VT_INITIAL_ADJUST_RATE, 4) && - VerifyField(verifier, VT_ADJUST_RATE_DECAY, 4) && - VerifyField(verifier, VT_SLIDE_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_OFFSET_SLIDE_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_BODY_PROPORTION_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_HEIGHT_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_POSITION_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_POSITION_OFFSET_ERROR_FACTOR, 4) && - VerifyField(verifier, VT_CALC_INIT_ERROR, 1) && - VerifyField(verifier, VT_RANDOMIZE_FRAME_ORDER, 1) && - VerifyField(verifier, VT_SCALE_EACH_STEP, 1) && - VerifyField(verifier, VT_SAMPLE_COUNT, 4) && - VerifyField(verifier, VT_SAMPLE_RATE_MS, 8) && - VerifyField(verifier, VT_SAVE_RECORDINGS, 1) && - VerifyField(verifier, VT_USE_SKELETON_HEIGHT, 1) && - VerifyField(verifier, VT_RAND_SEED, 8) && + VerifyField(verifier, VT_FULL_RESET_DELAY, 4) && + VerifyField(verifier, VT_FULL_RESET_ENABLED, 1) && + VerifyField(verifier, VT_FULL_RESET_TAPS, 1) && + VerifyField(verifier, VT_YAW_RESET_DELAY, 4) && + VerifyField(verifier, VT_YAW_RESET_ENABLED, 1) && + VerifyField(verifier, VT_YAW_RESET_TAPS, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_DELAY, 4) && + VerifyField(verifier, VT_MOUNTING_RESET_ENABLED, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_TAPS, 1) && + VerifyField(verifier, VT_NUMBER_TRACKERS_OVER_THRESHOLD, 1) && + VerifyField(verifier, VT_YAW_RESET_TRACKER, 1) && + VerifyField(verifier, VT_FULL_RESET_TRACKER, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_TRACKER, 1) && verifier.EndTable(); } }; -struct AutoBoneSettingsBuilder { - typedef AutoBoneSettings Table; +struct TapDetectionSettingsResponseBuilder { + typedef TapDetectionSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_cursor_increment(int32_t cursor_increment) { - fbb_.AddElement(AutoBoneSettings::VT_CURSOR_INCREMENT, cursor_increment); - } - void add_min_data_distance(int32_t min_data_distance) { - fbb_.AddElement(AutoBoneSettings::VT_MIN_DATA_DISTANCE, min_data_distance); - } - void add_max_data_distance(int32_t max_data_distance) { - fbb_.AddElement(AutoBoneSettings::VT_MAX_DATA_DISTANCE, max_data_distance); - } - void add_num_epochs(int32_t num_epochs) { - fbb_.AddElement(AutoBoneSettings::VT_NUM_EPOCHS, num_epochs); - } - void add_print_every_num_epochs(int32_t print_every_num_epochs) { - fbb_.AddElement(AutoBoneSettings::VT_PRINT_EVERY_NUM_EPOCHS, print_every_num_epochs); - } - void add_initial_adjust_rate(float initial_adjust_rate) { - fbb_.AddElement(AutoBoneSettings::VT_INITIAL_ADJUST_RATE, initial_adjust_rate); - } - void add_adjust_rate_decay(float adjust_rate_decay) { - fbb_.AddElement(AutoBoneSettings::VT_ADJUST_RATE_DECAY, adjust_rate_decay); - } - void add_slide_error_factor(float slide_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_SLIDE_ERROR_FACTOR, slide_error_factor); - } - void add_offset_slide_error_factor(float offset_slide_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_OFFSET_SLIDE_ERROR_FACTOR, offset_slide_error_factor); - } - void add_foot_height_offset_error_factor(float foot_height_offset_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR, foot_height_offset_error_factor); - } - void add_body_proportion_error_factor(float body_proportion_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_BODY_PROPORTION_ERROR_FACTOR, body_proportion_error_factor); - } - void add_height_error_factor(float height_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_HEIGHT_ERROR_FACTOR, height_error_factor); - } - void add_position_error_factor(float position_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_POSITION_ERROR_FACTOR, position_error_factor); - } - void add_position_offset_error_factor(float position_offset_error_factor) { - fbb_.AddElement(AutoBoneSettings::VT_POSITION_OFFSET_ERROR_FACTOR, position_offset_error_factor); - } - void add_calc_init_error(bool calc_init_error) { - fbb_.AddElement(AutoBoneSettings::VT_CALC_INIT_ERROR, static_cast(calc_init_error)); + void add_full_reset_delay(float full_reset_delay) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_FULL_RESET_DELAY, full_reset_delay); } - void add_randomize_frame_order(bool randomize_frame_order) { - fbb_.AddElement(AutoBoneSettings::VT_RANDOMIZE_FRAME_ORDER, static_cast(randomize_frame_order)); + void add_full_reset_enabled(bool full_reset_enabled) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_FULL_RESET_ENABLED, static_cast(full_reset_enabled)); } - void add_scale_each_step(bool scale_each_step) { - fbb_.AddElement(AutoBoneSettings::VT_SCALE_EACH_STEP, static_cast(scale_each_step)); + void add_full_reset_taps(uint8_t full_reset_taps) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_FULL_RESET_TAPS, full_reset_taps); } - void add_sample_count(int32_t sample_count) { - fbb_.AddElement(AutoBoneSettings::VT_SAMPLE_COUNT, sample_count); + void add_yaw_reset_delay(float yaw_reset_delay) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_YAW_RESET_DELAY, yaw_reset_delay); } - void add_sample_rate_ms(int64_t sample_rate_ms) { - fbb_.AddElement(AutoBoneSettings::VT_SAMPLE_RATE_MS, sample_rate_ms); + void add_yaw_reset_enabled(bool yaw_reset_enabled) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_YAW_RESET_ENABLED, static_cast(yaw_reset_enabled)); } - void add_save_recordings(bool save_recordings) { - fbb_.AddElement(AutoBoneSettings::VT_SAVE_RECORDINGS, static_cast(save_recordings)); + void add_yaw_reset_taps(uint8_t yaw_reset_taps) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_YAW_RESET_TAPS, yaw_reset_taps); } - void add_use_skeleton_height(bool use_skeleton_height) { - fbb_.AddElement(AutoBoneSettings::VT_USE_SKELETON_HEIGHT, static_cast(use_skeleton_height)); + void add_mounting_reset_delay(float mounting_reset_delay) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); } - void add_rand_seed(int64_t rand_seed) { - fbb_.AddElement(AutoBoneSettings::VT_RAND_SEED, rand_seed); + void add_mounting_reset_enabled(bool mounting_reset_enabled) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_MOUNTING_RESET_ENABLED, static_cast(mounting_reset_enabled)); } - explicit AutoBoneSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + void add_mounting_reset_taps(uint8_t mounting_reset_taps) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + void add_number_trackers_over_threshold(uint8_t number_trackers_over_threshold) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); } -}; - -inline flatbuffers::Offset CreateAutoBoneSettings( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional cursor_increment = flatbuffers::nullopt, - flatbuffers::Optional min_data_distance = flatbuffers::nullopt, - flatbuffers::Optional max_data_distance = flatbuffers::nullopt, - flatbuffers::Optional num_epochs = flatbuffers::nullopt, - flatbuffers::Optional print_every_num_epochs = flatbuffers::nullopt, - flatbuffers::Optional initial_adjust_rate = flatbuffers::nullopt, - flatbuffers::Optional adjust_rate_decay = flatbuffers::nullopt, - flatbuffers::Optional slide_error_factor = flatbuffers::nullopt, - flatbuffers::Optional offset_slide_error_factor = flatbuffers::nullopt, - flatbuffers::Optional foot_height_offset_error_factor = flatbuffers::nullopt, - flatbuffers::Optional body_proportion_error_factor = flatbuffers::nullopt, - flatbuffers::Optional height_error_factor = flatbuffers::nullopt, - flatbuffers::Optional position_error_factor = flatbuffers::nullopt, - flatbuffers::Optional position_offset_error_factor = flatbuffers::nullopt, - flatbuffers::Optional calc_init_error = flatbuffers::nullopt, - flatbuffers::Optional randomize_frame_order = flatbuffers::nullopt, - flatbuffers::Optional scale_each_step = flatbuffers::nullopt, - flatbuffers::Optional sample_count = flatbuffers::nullopt, - flatbuffers::Optional sample_rate_ms = flatbuffers::nullopt, - flatbuffers::Optional save_recordings = flatbuffers::nullopt, - flatbuffers::Optional use_skeleton_height = flatbuffers::nullopt, - flatbuffers::Optional rand_seed = flatbuffers::nullopt) { - AutoBoneSettingsBuilder builder_(_fbb); - if(rand_seed) { builder_.add_rand_seed(*rand_seed); } - if(sample_rate_ms) { builder_.add_sample_rate_ms(*sample_rate_ms); } - if(sample_count) { builder_.add_sample_count(*sample_count); } - if(position_offset_error_factor) { builder_.add_position_offset_error_factor(*position_offset_error_factor); } - if(position_error_factor) { builder_.add_position_error_factor(*position_error_factor); } - if(height_error_factor) { builder_.add_height_error_factor(*height_error_factor); } - if(body_proportion_error_factor) { builder_.add_body_proportion_error_factor(*body_proportion_error_factor); } - if(foot_height_offset_error_factor) { builder_.add_foot_height_offset_error_factor(*foot_height_offset_error_factor); } - if(offset_slide_error_factor) { builder_.add_offset_slide_error_factor(*offset_slide_error_factor); } - if(slide_error_factor) { builder_.add_slide_error_factor(*slide_error_factor); } - if(adjust_rate_decay) { builder_.add_adjust_rate_decay(*adjust_rate_decay); } - if(initial_adjust_rate) { builder_.add_initial_adjust_rate(*initial_adjust_rate); } - if(print_every_num_epochs) { builder_.add_print_every_num_epochs(*print_every_num_epochs); } - if(num_epochs) { builder_.add_num_epochs(*num_epochs); } - if(max_data_distance) { builder_.add_max_data_distance(*max_data_distance); } - if(min_data_distance) { builder_.add_min_data_distance(*min_data_distance); } - if(cursor_increment) { builder_.add_cursor_increment(*cursor_increment); } - if(use_skeleton_height) { builder_.add_use_skeleton_height(*use_skeleton_height); } - if(save_recordings) { builder_.add_save_recordings(*save_recordings); } - if(scale_each_step) { builder_.add_scale_each_step(*scale_each_step); } - if(randomize_frame_order) { builder_.add_randomize_frame_order(*randomize_frame_order); } - if(calc_init_error) { builder_.add_calc_init_error(*calc_init_error); } - return builder_.Finish(); -} - -struct HeightRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HeightRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); + void add_yaw_reset_tracker(solarxr_protocol::datatypes::BodyPart yaw_reset_tracker) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_YAW_RESET_TRACKER, static_cast(yaw_reset_tracker)); } -}; - -struct HeightRequestBuilder { - typedef HeightRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit HeightRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_full_reset_tracker(solarxr_protocol::datatypes::BodyPart full_reset_tracker) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_FULL_RESET_TRACKER, static_cast(full_reset_tracker)); + } + void add_mounting_reset_tracker(solarxr_protocol::datatypes::BodyPart mounting_reset_tracker) { + fbb_.AddElement(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TRACKER, static_cast(mounting_reset_tracker)); + } + explicit TapDetectionSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateHeightRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - HeightRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateTapDetectionSettingsResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Optional full_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional full_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional full_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional number_trackers_over_threshold = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_tracker = flatbuffers::nullopt, + flatbuffers::Optional full_reset_tracker = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_tracker = flatbuffers::nullopt) { + TapDetectionSettingsResponseBuilder builder_(_fbb); + if(mounting_reset_delay) { builder_.add_mounting_reset_delay(*mounting_reset_delay); } + if(yaw_reset_delay) { builder_.add_yaw_reset_delay(*yaw_reset_delay); } + if(full_reset_delay) { builder_.add_full_reset_delay(*full_reset_delay); } + if(mounting_reset_tracker) { builder_.add_mounting_reset_tracker(*mounting_reset_tracker); } + if(full_reset_tracker) { builder_.add_full_reset_tracker(*full_reset_tracker); } + if(yaw_reset_tracker) { builder_.add_yaw_reset_tracker(*yaw_reset_tracker); } + if(number_trackers_over_threshold) { builder_.add_number_trackers_over_threshold(*number_trackers_over_threshold); } + if(mounting_reset_taps) { builder_.add_mounting_reset_taps(*mounting_reset_taps); } + if(mounting_reset_enabled) { builder_.add_mounting_reset_enabled(*mounting_reset_enabled); } + if(yaw_reset_taps) { builder_.add_yaw_reset_taps(*yaw_reset_taps); } + if(yaw_reset_enabled) { builder_.add_yaw_reset_enabled(*yaw_reset_enabled); } + if(full_reset_taps) { builder_.add_full_reset_taps(*full_reset_taps); } + if(full_reset_enabled) { builder_.add_full_reset_enabled(*full_reset_enabled); } return builder_.Finish(); } -/// Returns the current min and max positional tracker heights -struct HeightResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef HeightResponseBuilder Builder; +struct ChangeTapDetectionSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeTapDetectionSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MIN_HEIGHT = 4, - VT_MAX_HEIGHT = 6 + VT_FULL_RESET_DELAY = 4, + VT_FULL_RESET_ENABLED = 6, + VT_FULL_RESET_TAPS = 8, + VT_YAW_RESET_DELAY = 10, + VT_YAW_RESET_ENABLED = 12, + VT_YAW_RESET_TAPS = 14, + VT_MOUNTING_RESET_DELAY = 16, + VT_MOUNTING_RESET_ENABLED = 18, + VT_MOUNTING_RESET_TAPS = 20, + VT_NUMBER_TRACKERS_OVER_THRESHOLD = 22, + VT_YAW_RESET_TRACKER = 24, + VT_FULL_RESET_TRACKER = 26, + VT_MOUNTING_RESET_TRACKER = 28 }; - float min_height() const { - return GetField(VT_MIN_HEIGHT, 0.0f); + flatbuffers::Optional full_reset_delay() const { + return GetOptional(VT_FULL_RESET_DELAY); } - float max_height() const { - return GetField(VT_MAX_HEIGHT, 0.0f); + flatbuffers::Optional full_reset_enabled() const { + return GetOptional(VT_FULL_RESET_ENABLED); } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_MIN_HEIGHT, 4) && - VerifyField(verifier, VT_MAX_HEIGHT, 4) && - verifier.EndTable(); + flatbuffers::Optional full_reset_taps() const { + return GetOptional(VT_FULL_RESET_TAPS); } -}; - -struct HeightResponseBuilder { - typedef HeightResponse Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_min_height(float min_height) { - fbb_.AddElement(HeightResponse::VT_MIN_HEIGHT, min_height, 0.0f); + flatbuffers::Optional yaw_reset_delay() const { + return GetOptional(VT_YAW_RESET_DELAY); } - void add_max_height(float max_height) { - fbb_.AddElement(HeightResponse::VT_MAX_HEIGHT, max_height, 0.0f); + flatbuffers::Optional yaw_reset_enabled() const { + return GetOptional(VT_YAW_RESET_ENABLED); } - explicit HeightResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + flatbuffers::Optional yaw_reset_taps() const { + return GetOptional(VT_YAW_RESET_TAPS); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + flatbuffers::Optional mounting_reset_delay() const { + return GetOptional(VT_MOUNTING_RESET_DELAY); } -}; - -inline flatbuffers::Offset CreateHeightResponse( - flatbuffers::FlatBufferBuilder &_fbb, - float min_height = 0.0f, - float max_height = 0.0f) { - HeightResponseBuilder builder_(_fbb); - builder_.add_max_height(max_height); - builder_.add_min_height(min_height); - return builder_.Finish(); -} - -/// Applies the estimated proportions -struct AutoBoneApplyRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneApplyRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); + flatbuffers::Optional mounting_reset_enabled() const { + return GetOptional(VT_MOUNTING_RESET_ENABLED); } -}; - -struct AutoBoneApplyRequestBuilder { - typedef AutoBoneApplyRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit AutoBoneApplyRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + flatbuffers::Optional mounting_reset_taps() const { + return GetOptional(VT_MOUNTING_RESET_TAPS); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + flatbuffers::Optional number_trackers_over_threshold() const { + return GetOptional(VT_NUMBER_TRACKERS_OVER_THRESHOLD); } -}; - -inline flatbuffers::Offset CreateAutoBoneApplyRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - AutoBoneApplyRequestBuilder builder_(_fbb); - return builder_.Finish(); -} - -/// Stops the current recording, using it as far as it has been recorded -struct AutoBoneStopRecordingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneStopRecordingRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); + flatbuffers::Optional yaw_reset_tracker() const { + return GetOptional(VT_YAW_RESET_TRACKER); } -}; - -struct AutoBoneStopRecordingRequestBuilder { - typedef AutoBoneStopRecordingRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit AutoBoneStopRecordingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + flatbuffers::Optional full_reset_tracker() const { + return GetOptional(VT_FULL_RESET_TRACKER); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + flatbuffers::Optional mounting_reset_tracker() const { + return GetOptional(VT_MOUNTING_RESET_TRACKER); } -}; - -inline flatbuffers::Offset CreateAutoBoneStopRecordingRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - AutoBoneStopRecordingRequestBuilder builder_(_fbb); - return builder_.Finish(); -} - -/// Cancels the current recording, aborting the process and discarding the data -struct AutoBoneCancelRecordingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AutoBoneCancelRecordingRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FULL_RESET_DELAY, 4) && + VerifyField(verifier, VT_FULL_RESET_ENABLED, 1) && + VerifyField(verifier, VT_FULL_RESET_TAPS, 1) && + VerifyField(verifier, VT_YAW_RESET_DELAY, 4) && + VerifyField(verifier, VT_YAW_RESET_ENABLED, 1) && + VerifyField(verifier, VT_YAW_RESET_TAPS, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_DELAY, 4) && + VerifyField(verifier, VT_MOUNTING_RESET_ENABLED, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_TAPS, 1) && + VerifyField(verifier, VT_NUMBER_TRACKERS_OVER_THRESHOLD, 1) && + VerifyField(verifier, VT_YAW_RESET_TRACKER, 1) && + VerifyField(verifier, VT_FULL_RESET_TRACKER, 1) && + VerifyField(verifier, VT_MOUNTING_RESET_TRACKER, 1) && verifier.EndTable(); } }; -struct AutoBoneCancelRecordingRequestBuilder { - typedef AutoBoneCancelRecordingRequest Table; +struct ChangeTapDetectionSettingsRequestBuilder { + typedef ChangeTapDetectionSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit AutoBoneCancelRecordingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + void add_full_reset_delay(float full_reset_delay) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_DELAY, full_reset_delay); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + void add_full_reset_enabled(bool full_reset_enabled) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_ENABLED, static_cast(full_reset_enabled)); } -}; - -inline flatbuffers::Offset CreateAutoBoneCancelRecordingRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - AutoBoneCancelRecordingRequestBuilder builder_(_fbb); - return builder_.Finish(); -} - -/// Requests the current state of `OverlayDisplayModeResponse`. -struct OverlayDisplayModeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OverlayDisplayModeRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); + void add_full_reset_taps(uint8_t full_reset_taps) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TAPS, full_reset_taps); } -}; - -struct OverlayDisplayModeRequestBuilder { - typedef OverlayDisplayModeRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit OverlayDisplayModeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_yaw_reset_delay(float yaw_reset_delay) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_DELAY, yaw_reset_delay); + } + void add_yaw_reset_enabled(bool yaw_reset_enabled) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_ENABLED, static_cast(yaw_reset_enabled)); + } + void add_yaw_reset_taps(uint8_t yaw_reset_taps) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TAPS, yaw_reset_taps); + } + void add_mounting_reset_delay(float mounting_reset_delay) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); + } + void add_mounting_reset_enabled(bool mounting_reset_enabled) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_ENABLED, static_cast(mounting_reset_enabled)); + } + void add_mounting_reset_taps(uint8_t mounting_reset_taps) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); + } + void add_number_trackers_over_threshold(uint8_t number_trackers_over_threshold) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); + } + void add_yaw_reset_tracker(solarxr_protocol::datatypes::BodyPart yaw_reset_tracker) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TRACKER, static_cast(yaw_reset_tracker)); + } + void add_full_reset_tracker(solarxr_protocol::datatypes::BodyPart full_reset_tracker) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TRACKER, static_cast(full_reset_tracker)); + } + void add_mounting_reset_tracker(solarxr_protocol::datatypes::BodyPart mounting_reset_tracker) { + fbb_.AddElement(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TRACKER, static_cast(mounting_reset_tracker)); + } + explicit ChangeTapDetectionSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOverlayDisplayModeRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - OverlayDisplayModeRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateChangeTapDetectionSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Optional full_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional full_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional full_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_delay = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_enabled = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_taps = flatbuffers::nullopt, + flatbuffers::Optional number_trackers_over_threshold = flatbuffers::nullopt, + flatbuffers::Optional yaw_reset_tracker = flatbuffers::nullopt, + flatbuffers::Optional full_reset_tracker = flatbuffers::nullopt, + flatbuffers::Optional mounting_reset_tracker = flatbuffers::nullopt) { + ChangeTapDetectionSettingsRequestBuilder builder_(_fbb); + if(mounting_reset_delay) { builder_.add_mounting_reset_delay(*mounting_reset_delay); } + if(yaw_reset_delay) { builder_.add_yaw_reset_delay(*yaw_reset_delay); } + if(full_reset_delay) { builder_.add_full_reset_delay(*full_reset_delay); } + if(mounting_reset_tracker) { builder_.add_mounting_reset_tracker(*mounting_reset_tracker); } + if(full_reset_tracker) { builder_.add_full_reset_tracker(*full_reset_tracker); } + if(yaw_reset_tracker) { builder_.add_yaw_reset_tracker(*yaw_reset_tracker); } + if(number_trackers_over_threshold) { builder_.add_number_trackers_over_threshold(*number_trackers_over_threshold); } + if(mounting_reset_taps) { builder_.add_mounting_reset_taps(*mounting_reset_taps); } + if(mounting_reset_enabled) { builder_.add_mounting_reset_enabled(*mounting_reset_enabled); } + if(yaw_reset_taps) { builder_.add_yaw_reset_taps(*yaw_reset_taps); } + if(yaw_reset_enabled) { builder_.add_yaw_reset_enabled(*yaw_reset_enabled); } + if(full_reset_taps) { builder_.add_full_reset_taps(*full_reset_taps); } + if(full_reset_enabled) { builder_.add_full_reset_enabled(*full_reset_enabled); } return builder_.Finish(); } -/// Changes the state of the overlay's display mode. -struct OverlayDisplayModeChangeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OverlayDisplayModeChangeRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_IS_VISIBLE = 4, - VT_IS_MIRRORED = 6 - }; - flatbuffers::Optional is_visible() const { - return GetOptional(VT_IS_VISIBLE); - } - flatbuffers::Optional is_mirrored() const { - return GetOptional(VT_IS_MIRRORED); +/// Sets the TapDetection setup mode. +struct TapDetectionSetupModeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TapDetectionSetupModeRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SETUP_MODE = 4 + }; + /// When true, TapDetection triggering a tracker will assign it instead of doing a reset. + flatbuffers::Optional setup_mode() const { + return GetOptional(VT_SETUP_MODE); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_IS_VISIBLE, 1) && - VerifyField(verifier, VT_IS_MIRRORED, 1) && + VerifyField(verifier, VT_SETUP_MODE, 1) && verifier.EndTable(); } }; -struct OverlayDisplayModeChangeRequestBuilder { - typedef OverlayDisplayModeChangeRequest Table; +struct TapDetectionSetupModeRequestBuilder { + typedef TapDetectionSetupModeRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_is_visible(bool is_visible) { - fbb_.AddElement(OverlayDisplayModeChangeRequest::VT_IS_VISIBLE, static_cast(is_visible)); - } - void add_is_mirrored(bool is_mirrored) { - fbb_.AddElement(OverlayDisplayModeChangeRequest::VT_IS_MIRRORED, static_cast(is_mirrored)); + void add_setup_mode(bool setup_mode) { + fbb_.AddElement(TapDetectionSetupModeRequest::VT_SETUP_MODE, static_cast(setup_mode)); } - explicit OverlayDisplayModeChangeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TapDetectionSetupModeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOverlayDisplayModeChangeRequest( +inline flatbuffers::Offset CreateTapDetectionSetupModeRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional is_visible = flatbuffers::nullopt, - flatbuffers::Optional is_mirrored = flatbuffers::nullopt) { - OverlayDisplayModeChangeRequestBuilder builder_(_fbb); - if(is_mirrored) { builder_.add_is_mirrored(*is_mirrored); } - if(is_visible) { builder_.add_is_visible(*is_visible); } + flatbuffers::Optional setup_mode = flatbuffers::nullopt) { + TapDetectionSetupModeRequestBuilder builder_(_fbb); + if(setup_mode) { builder_.add_setup_mode(*setup_mode); } return builder_.Finish(); } -/// The current state of the overlay's display mode. -struct OverlayDisplayModeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OverlayDisplayModeResponseBuilder Builder; +/// Indicates which tracker got triggered by TapDetection while setup mode is enabled +struct TapDetectionSetupNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TapDetectionSetupNotificationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_IS_VISIBLE = 4, - VT_IS_MIRRORED = 6 + VT_TRACKER_ID = 4 }; - bool is_visible() const { - return GetField(VT_IS_VISIBLE, 0) != 0; - } - bool is_mirrored() const { - return GetField(VT_IS_MIRRORED, 0) != 0; + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_IS_VISIBLE, 1) && - VerifyField(verifier, VT_IS_MIRRORED, 1) && + VerifyField(verifier, VT_TRACKER_ID, 2) && verifier.EndTable(); } }; -struct OverlayDisplayModeResponseBuilder { - typedef OverlayDisplayModeResponse Table; +struct TapDetectionSetupNotificationBuilder { + typedef TapDetectionSetupNotification Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_is_visible(bool is_visible) { - fbb_.AddElement(OverlayDisplayModeResponse::VT_IS_VISIBLE, static_cast(is_visible), 0); - } - void add_is_mirrored(bool is_mirrored) { - fbb_.AddElement(OverlayDisplayModeResponse::VT_IS_MIRRORED, static_cast(is_mirrored), 0); + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(TapDetectionSetupNotification::VT_TRACKER_ID, tracker_id, 0); } - explicit OverlayDisplayModeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TapDetectionSetupNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOverlayDisplayModeResponse( +inline flatbuffers::Offset CreateTapDetectionSetupNotification( flatbuffers::FlatBufferBuilder &_fbb, - bool is_visible = false, - bool is_mirrored = false) { - OverlayDisplayModeResponseBuilder builder_(_fbb); - builder_.add_is_mirrored(is_mirrored); - builder_.add_is_visible(is_visible); + uint16_t tracker_id = 0) { + TapDetectionSetupNotificationBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); return builder_.Finish(); } -/// Allows to ask generic infos about the server, -/// like the local ip address, the version of the server, the java version, -/// the current working dir and other information we might want to show in the gui -/// for information/debug purposes -struct ServerInfosRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ServerInfosRequestBuilder Builder; +/// If no tracker ID is given, it's the setting for every tracker/device +struct MagToggleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MagToggleRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4 + }; + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TRACKER_ID, 2) && verifier.EndTable(); } }; -struct ServerInfosRequestBuilder { - typedef ServerInfosRequest Table; +struct MagToggleRequestBuilder { + typedef MagToggleRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit ServerInfosRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(MagToggleRequest::VT_TRACKER_ID, tracker_id, 0); + } + explicit MagToggleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateServerInfosRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - ServerInfosRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateMagToggleRequest( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t tracker_id = 0) { + MagToggleRequestBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); return builder_.Finish(); } -/// Holds the Server information, this is a basic table holding various information about the currently running server -/// like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more -/// infos we might want to add in the future. (like java version, working dir, server version ....) -/// This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance -struct ServerInfosResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ServerInfosResponseBuilder Builder; +/// If no tracker ID is given, it's the setting for every tracker/device +struct MagToggleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MagToggleResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LOCALIP = 4 + VT_TRACKER_ID = 4, + VT_ENABLE = 6 }; - const flatbuffers::String *localIp() const { - return GetPointer(VT_LOCALIP); + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); + } + bool enable() const { + return GetField(VT_ENABLE, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_LOCALIP) && - verifier.VerifyString(localIp()) && + VerifyField(verifier, VT_TRACKER_ID, 2) && + VerifyField(verifier, VT_ENABLE, 1) && verifier.EndTable(); } }; -struct ServerInfosResponseBuilder { - typedef ServerInfosResponse Table; +struct MagToggleResponseBuilder { + typedef MagToggleResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_localIp(flatbuffers::Offset localIp) { - fbb_.AddOffset(ServerInfosResponse::VT_LOCALIP, localIp); + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(MagToggleResponse::VT_TRACKER_ID, tracker_id, 0); } - explicit ServerInfosResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_enable(bool enable) { + fbb_.AddElement(MagToggleResponse::VT_ENABLE, static_cast(enable), 0); + } + explicit MagToggleResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateServerInfosResponse( +inline flatbuffers::Offset CreateMagToggleResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset localIp = 0) { - ServerInfosResponseBuilder builder_(_fbb); - builder_.add_localIp(localIp); + uint16_t tracker_id = 0, + bool enable = false) { + MagToggleResponseBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); + builder_.add_enable(enable); return builder_.Finish(); } -inline flatbuffers::Offset CreateServerInfosResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *localIp = nullptr) { - auto localIp__ = localIp ? _fbb.CreateString(localIp) : 0; - return solarxr_protocol::rpc::CreateServerInfosResponse( - _fbb, - localIp__); -} - -/// Makes a temporary change to legtweaks. This is not saved to disk, and can be -/// cleared with `LegTweaksTmpClear` -struct LegTweaksTmpChange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef LegTweaksTmpChangeBuilder Builder; +/// If no tracker ID is given, it's the setting for every tracker/device +struct ChangeMagToggleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeMagToggleRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FLOOR_CLIP = 4, - VT_SKATING_CORRECTION = 6, - VT_TOE_SNAP = 8, - VT_FOOT_PLANT = 10 + VT_TRACKER_ID = 4, + VT_ENABLE = 6 }; - flatbuffers::Optional floor_clip() const { - return GetOptional(VT_FLOOR_CLIP); - } - flatbuffers::Optional skating_correction() const { - return GetOptional(VT_SKATING_CORRECTION); - } - flatbuffers::Optional toe_snap() const { - return GetOptional(VT_TOE_SNAP); + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); } - flatbuffers::Optional foot_plant() const { - return GetOptional(VT_FOOT_PLANT); + bool enable() const { + return GetField(VT_ENABLE, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_FLOOR_CLIP, 1) && - VerifyField(verifier, VT_SKATING_CORRECTION, 1) && - VerifyField(verifier, VT_TOE_SNAP, 1) && - VerifyField(verifier, VT_FOOT_PLANT, 1) && + VerifyField(verifier, VT_TRACKER_ID, 2) && + VerifyField(verifier, VT_ENABLE, 1) && verifier.EndTable(); } }; -struct LegTweaksTmpChangeBuilder { - typedef LegTweaksTmpChange Table; +struct ChangeMagToggleRequestBuilder { + typedef ChangeMagToggleRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_floor_clip(bool floor_clip) { - fbb_.AddElement(LegTweaksTmpChange::VT_FLOOR_CLIP, static_cast(floor_clip)); - } - void add_skating_correction(bool skating_correction) { - fbb_.AddElement(LegTweaksTmpChange::VT_SKATING_CORRECTION, static_cast(skating_correction)); - } - void add_toe_snap(bool toe_snap) { - fbb_.AddElement(LegTweaksTmpChange::VT_TOE_SNAP, static_cast(toe_snap)); + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(ChangeMagToggleRequest::VT_TRACKER_ID, tracker_id, 0); } - void add_foot_plant(bool foot_plant) { - fbb_.AddElement(LegTweaksTmpChange::VT_FOOT_PLANT, static_cast(foot_plant)); + void add_enable(bool enable) { + fbb_.AddElement(ChangeMagToggleRequest::VT_ENABLE, static_cast(enable), 0); } - explicit LegTweaksTmpChangeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ChangeMagToggleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLegTweaksTmpChange( +inline flatbuffers::Offset CreateChangeMagToggleRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Optional floor_clip = flatbuffers::nullopt, - flatbuffers::Optional skating_correction = flatbuffers::nullopt, - flatbuffers::Optional toe_snap = flatbuffers::nullopt, - flatbuffers::Optional foot_plant = flatbuffers::nullopt) { - LegTweaksTmpChangeBuilder builder_(_fbb); - if(foot_plant) { builder_.add_foot_plant(*foot_plant); } - if(toe_snap) { builder_.add_toe_snap(*toe_snap); } - if(skating_correction) { builder_.add_skating_correction(*skating_correction); } - if(floor_clip) { builder_.add_floor_clip(*floor_clip); } + uint16_t tracker_id = 0, + bool enable = false) { + ChangeMagToggleRequestBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); + builder_.add_enable(enable); return builder_.Finish(); } -/// Clears the legtweaks temporary state back to what the config has. -/// Setting a field to `true` will reset that field. -struct LegTweaksTmpClear FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef LegTweaksTmpClearBuilder Builder; +/// Trackers that need a reset +struct TrackingChecklistTrackerReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistTrackerResetBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FLOOR_CLIP = 4, - VT_SKATING_CORRECTION = 6, - VT_TOE_SNAP = 8, - VT_FOOT_PLANT = 10 + VT_TRACKERS_ID = 4 }; - bool floor_clip() const { - return GetField(VT_FLOOR_CLIP, 0) != 0; - } - bool skating_correction() const { - return GetField(VT_SKATING_CORRECTION, 0) != 0; - } - bool toe_snap() const { - return GetField(VT_TOE_SNAP, 0) != 0; - } - bool foot_plant() const { - return GetField(VT_FOOT_PLANT, 0) != 0; + const flatbuffers::Vector *trackers_id() const { + return GetPointer *>(VT_TRACKERS_ID); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_FLOOR_CLIP, 1) && - VerifyField(verifier, VT_SKATING_CORRECTION, 1) && - VerifyField(verifier, VT_TOE_SNAP, 1) && - VerifyField(verifier, VT_FOOT_PLANT, 1) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && verifier.EndTable(); } }; -struct LegTweaksTmpClearBuilder { - typedef LegTweaksTmpClear Table; +struct TrackingChecklistTrackerResetBuilder { + typedef TrackingChecklistTrackerReset Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_floor_clip(bool floor_clip) { - fbb_.AddElement(LegTweaksTmpClear::VT_FLOOR_CLIP, static_cast(floor_clip), 0); - } - void add_skating_correction(bool skating_correction) { - fbb_.AddElement(LegTweaksTmpClear::VT_SKATING_CORRECTION, static_cast(skating_correction), 0); - } - void add_toe_snap(bool toe_snap) { - fbb_.AddElement(LegTweaksTmpClear::VT_TOE_SNAP, static_cast(toe_snap), 0); - } - void add_foot_plant(bool foot_plant) { - fbb_.AddElement(LegTweaksTmpClear::VT_FOOT_PLANT, static_cast(foot_plant), 0); + void add_trackers_id(flatbuffers::Offset> trackers_id) { + fbb_.AddOffset(TrackingChecklistTrackerReset::VT_TRACKERS_ID, trackers_id); } - explicit LegTweaksTmpClearBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistTrackerResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateLegTweaksTmpClear( +inline flatbuffers::Offset CreateTrackingChecklistTrackerReset( flatbuffers::FlatBufferBuilder &_fbb, - bool floor_clip = false, - bool skating_correction = false, - bool toe_snap = false, - bool foot_plant = false) { - LegTweaksTmpClearBuilder builder_(_fbb); - builder_.add_foot_plant(foot_plant); - builder_.add_toe_snap(toe_snap); - builder_.add_skating_correction(skating_correction); - builder_.add_floor_clip(floor_clip); + flatbuffers::Offset> trackers_id = 0) { + TrackingChecklistTrackerResetBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); return builder_.Finish(); } -/// Tracker requires full reset -struct StatusTrackerReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusTrackerResetBuilder Builder; +inline flatbuffers::Offset CreateTrackingChecklistTrackerResetDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistTrackerReset( + _fbb, + trackers_id__); +} + +/// Trackers with error state +struct TrackingChecklistTrackerError FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistTrackerErrorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 + VT_TRACKERS_ID = 4 }; - const flatbuffers::Vector> *tracker_id() const { - return GetPointer> *>(VT_TRACKER_ID); + const flatbuffers::Vector *trackers_id() const { + return GetPointer *>(VT_TRACKERS_ID); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyVector(tracker_id()) && - verifier.VerifyVectorOfTables(tracker_id()) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && verifier.EndTable(); } }; -struct StatusTrackerResetBuilder { - typedef StatusTrackerReset Table; +struct TrackingChecklistTrackerErrorBuilder { + typedef TrackingChecklistTrackerError Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset>> tracker_id) { - fbb_.AddOffset(StatusTrackerReset::VT_TRACKER_ID, tracker_id); + void add_trackers_id(flatbuffers::Offset> trackers_id) { + fbb_.AddOffset(TrackingChecklistTrackerError::VT_TRACKERS_ID, trackers_id); } - explicit StatusTrackerResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistTrackerErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusTrackerReset( +inline flatbuffers::Offset CreateTrackingChecklistTrackerError( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> tracker_id = 0) { - StatusTrackerResetBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); + flatbuffers::Offset> trackers_id = 0) { + TrackingChecklistTrackerErrorBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); return builder_.Finish(); } -inline flatbuffers::Offset CreateStatusTrackerResetDirect( +inline flatbuffers::Offset CreateTrackingChecklistTrackerErrorDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *tracker_id = nullptr) { - auto tracker_id__ = tracker_id ? _fbb.CreateVector>(*tracker_id) : 0; - return solarxr_protocol::rpc::CreateStatusTrackerReset( + const std::vector *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistTrackerError( _fbb, - tracker_id__); + trackers_id__); } -/// Trackers with error state -struct StatusTrackerError FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusTrackerErrorBuilder Builder; +struct TrackingChecklistNeedCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistNeedCalibrationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 + VT_TRACKERS_ID = 4 }; - const flatbuffers::Vector> *tracker_id() const { - return GetPointer> *>(VT_TRACKER_ID); + const flatbuffers::Vector *trackers_id() const { + return GetPointer *>(VT_TRACKERS_ID); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyVector(tracker_id()) && - verifier.VerifyVectorOfTables(tracker_id()) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && verifier.EndTable(); } }; -struct StatusTrackerErrorBuilder { - typedef StatusTrackerError Table; +struct TrackingChecklistNeedCalibrationBuilder { + typedef TrackingChecklistNeedCalibration Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset>> tracker_id) { - fbb_.AddOffset(StatusTrackerError::VT_TRACKER_ID, tracker_id); + void add_trackers_id(flatbuffers::Offset> trackers_id) { + fbb_.AddOffset(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, trackers_id); } - explicit StatusTrackerErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistNeedCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusTrackerError( +inline flatbuffers::Offset CreateTrackingChecklistNeedCalibration( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> tracker_id = 0) { - StatusTrackerErrorBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); + flatbuffers::Offset> trackers_id = 0) { + TrackingChecklistNeedCalibrationBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); return builder_.Finish(); } -inline flatbuffers::Offset CreateStatusTrackerErrorDirect( +inline flatbuffers::Offset CreateTrackingChecklistNeedCalibrationDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *tracker_id = nullptr) { - auto tracker_id__ = tracker_id ? _fbb.CreateVector>(*tracker_id) : 0; - return solarxr_protocol::rpc::CreateStatusTrackerError( + const std::vector *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistNeedCalibration( _fbb, - tracker_id__); + trackers_id__); } -/// SteamVR bridge is disconnected -struct StatusSteamVRDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusSteamVRDisconnectedBuilder Builder; +struct TrackingChecklistSteamVRDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistSteamVRDisconnectedBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_BRIDGE_SETTINGS_NAME = 4 + VT_BRIDGE_SETTINGS_NAME = 4, + VT_DRIVER_INSTALLED = 6, + VT_DRIVER_BLOCKED_BY_SAFE_MODE = 8, + VT_DRIVER_ENABLED = 10 }; /// Name of bridge in the server's config const flatbuffers::String *bridge_settings_name() const { return GetPointer(VT_BRIDGE_SETTINGS_NAME); } + /// Is the driver installed? + bool driver_installed() const { + return GetField(VT_DRIVER_INSTALLED, 0) != 0; + } + /// Has the driver been blocked due to SteamVR's "safe mode"? + bool driver_blocked_by_safe_mode() const { + return GetField(VT_DRIVER_BLOCKED_BY_SAFE_MODE, 0) != 0; + } + /// Is the driver enabled in SteamVR settings? + bool driver_enabled() const { + return GetField(VT_DRIVER_ENABLED, 0) != 0; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_BRIDGE_SETTINGS_NAME) && verifier.VerifyString(bridge_settings_name()) && + VerifyField(verifier, VT_DRIVER_INSTALLED, 1) && + VerifyField(verifier, VT_DRIVER_BLOCKED_BY_SAFE_MODE, 1) && + VerifyField(verifier, VT_DRIVER_ENABLED, 1) && verifier.EndTable(); } }; -struct StatusSteamVRDisconnectedBuilder { - typedef StatusSteamVRDisconnected Table; +struct TrackingChecklistSteamVRDisconnectedBuilder { + typedef TrackingChecklistSteamVRDisconnected Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; void add_bridge_settings_name(flatbuffers::Offset bridge_settings_name) { - fbb_.AddOffset(StatusSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); + fbb_.AddOffset(TrackingChecklistSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); + } + void add_driver_installed(bool driver_installed) { + fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_INSTALLED, static_cast(driver_installed), 0); + } + void add_driver_blocked_by_safe_mode(bool driver_blocked_by_safe_mode) { + fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_BLOCKED_BY_SAFE_MODE, static_cast(driver_blocked_by_safe_mode), 0); } - explicit StatusSteamVRDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_driver_enabled(bool driver_enabled) { + fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_ENABLED, static_cast(driver_enabled), 0); + } + explicit TrackingChecklistSteamVRDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusSteamVRDisconnected( +inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnected( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset bridge_settings_name = 0) { - StatusSteamVRDisconnectedBuilder builder_(_fbb); + flatbuffers::Offset bridge_settings_name = 0, + bool driver_installed = false, + bool driver_blocked_by_safe_mode = false, + bool driver_enabled = false) { + TrackingChecklistSteamVRDisconnectedBuilder builder_(_fbb); builder_.add_bridge_settings_name(bridge_settings_name); + builder_.add_driver_enabled(driver_enabled); + builder_.add_driver_blocked_by_safe_mode(driver_blocked_by_safe_mode); + builder_.add_driver_installed(driver_installed); return builder_.Finish(); } -inline flatbuffers::Offset CreateStatusSteamVRDisconnectedDirect( +inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnectedDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *bridge_settings_name = nullptr) { + const char *bridge_settings_name = nullptr, + bool driver_installed = false, + bool driver_blocked_by_safe_mode = false, + bool driver_enabled = false) { auto bridge_settings_name__ = bridge_settings_name ? _fbb.CreateString(bridge_settings_name) : 0; - return solarxr_protocol::rpc::CreateStatusSteamVRDisconnected( + return solarxr_protocol::rpc::CreateTrackingChecklistSteamVRDisconnected( _fbb, - bridge_settings_name__); + bridge_settings_name__, + driver_installed, + driver_blocked_by_safe_mode, + driver_enabled); } -/// There is an available HMD tracker and it's not assigned to head -struct StatusUnassignedHMD FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusUnassignedHMDBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 - }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); - } +struct EnableSteamVRDriverRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EnableSteamVRDriverRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && verifier.EndTable(); } }; -struct StatusUnassignedHMDBuilder { - typedef StatusUnassignedHMD Table; +struct EnableSteamVRDriverRequestBuilder { + typedef EnableSteamVRDriverRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(StatusUnassignedHMD::VT_TRACKER_ID, tracker_id); - } - explicit StatusUnassignedHMDBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit EnableSteamVRDriverRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusUnassignedHMD( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { - StatusUnassignedHMDBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); +inline flatbuffers::Offset CreateEnableSteamVRDriverRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + EnableSteamVRDriverRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Request current statuses that we have -struct StatusSystemRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusSystemRequestBuilder Builder; +struct TrackingChecklistUnassignedHMD FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistUnassignedHMDBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4 + }; + uint16_t tracker_id() const { + return GetField(VT_TRACKER_ID, 0); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TRACKER_ID, 2) && verifier.EndTable(); } }; -struct StatusSystemRequestBuilder { - typedef StatusSystemRequest Table; +struct TrackingChecklistUnassignedHMDBuilder { + typedef TrackingChecklistUnassignedHMD Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit StatusSystemRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_tracker_id(uint16_t tracker_id) { + fbb_.AddElement(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id, 0); + } + explicit TrackingChecklistUnassignedHMDBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusSystemRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - StatusSystemRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateTrackingChecklistUnassignedHMD( + flatbuffers::FlatBufferBuilder &_fbb, + uint16_t tracker_id = 0) { + TrackingChecklistUnassignedHMDBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); return builder_.Finish(); } -/// Response containing all current valid statuses -struct StatusSystemResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusSystemResponseBuilder Builder; +struct TrackingChecklistPublicNetworks FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistPublicNetworksBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_CURRENT_STATUSES = 4 + VT_ADAPTERS = 4 }; - const flatbuffers::Vector> *current_statuses() const { - return GetPointer> *>(VT_CURRENT_STATUSES); + const flatbuffers::Vector> *adapters() const { + return GetPointer> *>(VT_ADAPTERS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_CURRENT_STATUSES) && - verifier.VerifyVector(current_statuses()) && - verifier.VerifyVectorOfTables(current_statuses()) && + VerifyOffset(verifier, VT_ADAPTERS) && + verifier.VerifyVector(adapters()) && + verifier.VerifyVectorOfStrings(adapters()) && verifier.EndTable(); } }; -struct StatusSystemResponseBuilder { - typedef StatusSystemResponse Table; +struct TrackingChecklistPublicNetworksBuilder { + typedef TrackingChecklistPublicNetworks Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_current_statuses(flatbuffers::Offset>> current_statuses) { - fbb_.AddOffset(StatusSystemResponse::VT_CURRENT_STATUSES, current_statuses); + void add_adapters(flatbuffers::Offset>> adapters) { + fbb_.AddOffset(TrackingChecklistPublicNetworks::VT_ADAPTERS, adapters); } - explicit StatusSystemResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistPublicNetworksBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusSystemResponse( +inline flatbuffers::Offset CreateTrackingChecklistPublicNetworks( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> current_statuses = 0) { - StatusSystemResponseBuilder builder_(_fbb); - builder_.add_current_statuses(current_statuses); + flatbuffers::Offset>> adapters = 0) { + TrackingChecklistPublicNetworksBuilder builder_(_fbb); + builder_.add_adapters(adapters); return builder_.Finish(); } -inline flatbuffers::Offset CreateStatusSystemResponseDirect( +inline flatbuffers::Offset CreateTrackingChecklistPublicNetworksDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *current_statuses = nullptr) { - auto current_statuses__ = current_statuses ? _fbb.CreateVector>(*current_statuses) : 0; - return solarxr_protocol::rpc::CreateStatusSystemResponse( + const std::vector> *adapters = nullptr) { + auto adapters__ = adapters ? _fbb.CreateVector>(*adapters) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistPublicNetworks( _fbb, - current_statuses__); + adapters__); } -/// When a new status appears, it's sent alone -struct StatusSystemUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusSystemUpdateBuilder Builder; +struct TrackingChecklistStep FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistStepBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_NEW_STATUS = 4 + VT_ID = 4, + VT_VALID = 6, + VT_ENABLED = 8, + VT_VISIBILITY = 10, + VT_OPTIONAL = 12, + VT_IGNORABLE = 14, + VT_EXTRA_DATA_TYPE = 16, + VT_EXTRA_DATA = 18 }; - const solarxr_protocol::rpc::StatusMessage *new_status() const { - return GetPointer(VT_NEW_STATUS); + solarxr_protocol::rpc::TrackingChecklistStepId id() const { + return static_cast(GetField(VT_ID, 0)); + } + bool valid() const { + return GetField(VT_VALID, 0) != 0; + } + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility() const { + return static_cast(GetField(VT_VISIBILITY, 0)); + } + bool optional() const { + return GetField(VT_OPTIONAL, 0) != 0; + } + bool ignorable() const { + return GetField(VT_IGNORABLE, 0) != 0; + } + solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type() const { + return static_cast(GetField(VT_EXTRA_DATA_TYPE, 0)); + } + const void *extra_data() const { + return GetPointer(VT_EXTRA_DATA); + } + template const T *extra_data_as() const; + const solarxr_protocol::rpc::TrackingChecklistTrackerReset *extra_data_as_TrackingChecklistTrackerReset() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerReset ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistTrackerError *extra_data_as_TrackingChecklistTrackerError() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerError ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *extra_data_as_TrackingChecklistSteamVRDisconnected() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *extra_data_as_TrackingChecklistUnassignedHMD() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistUnassignedHMD ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *extra_data_as_TrackingChecklistNeedCalibration() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistNeedCalibration ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *extra_data_as_TrackingChecklistPublicNetworks() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistPublicNetworks ? static_cast(extra_data()) : nullptr; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_NEW_STATUS) && - verifier.VerifyTable(new_status()) && + VerifyField(verifier, VT_ID, 1) && + VerifyField(verifier, VT_VALID, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_VISIBILITY, 1) && + VerifyField(verifier, VT_OPTIONAL, 1) && + VerifyField(verifier, VT_IGNORABLE, 1) && + VerifyField(verifier, VT_EXTRA_DATA_TYPE, 1) && + VerifyOffset(verifier, VT_EXTRA_DATA) && + VerifyTrackingChecklistExtraData(verifier, extra_data(), extra_data_type()) && verifier.EndTable(); } }; -struct StatusSystemUpdateBuilder { - typedef StatusSystemUpdate Table; +template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerReset *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistTrackerReset(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerError *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistTrackerError(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistSteamVRDisconnected(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistUnassignedHMD(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistNeedCalibration(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistPublicNetworks(); +} + +struct TrackingChecklistStepBuilder { + typedef TrackingChecklistStep Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_new_status(flatbuffers::Offset new_status) { - fbb_.AddOffset(StatusSystemUpdate::VT_NEW_STATUS, new_status); + void add_id(solarxr_protocol::rpc::TrackingChecklistStepId id) { + fbb_.AddElement(TrackingChecklistStep::VT_ID, static_cast(id), 0); } - explicit StatusSystemUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + void add_valid(bool valid) { + fbb_.AddElement(TrackingChecklistStep::VT_VALID, static_cast(valid), 0); } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + void add_enabled(bool enabled) { + fbb_.AddElement(TrackingChecklistStep::VT_ENABLED, static_cast(enabled), 0); } -}; - -inline flatbuffers::Offset CreateStatusSystemUpdate( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset new_status = 0) { - StatusSystemUpdateBuilder builder_(_fbb); - builder_.add_new_status(new_status); - return builder_.Finish(); -} - -/// When an status is fixed and it's removed, it's ID is sent -struct StatusSystemFixed FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusSystemFixedBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_FIXED_STATUS_ID = 4 - }; - uint32_t fixed_status_id() const { - return GetField(VT_FIXED_STATUS_ID, 0); + void add_visibility(solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility) { + fbb_.AddElement(TrackingChecklistStep::VT_VISIBILITY, static_cast(visibility), 0); } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_FIXED_STATUS_ID, 4) && - verifier.EndTable(); + void add_optional(bool optional) { + fbb_.AddElement(TrackingChecklistStep::VT_OPTIONAL, static_cast(optional), 0); } -}; - -struct StatusSystemFixedBuilder { - typedef StatusSystemFixed Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_fixed_status_id(uint32_t fixed_status_id) { - fbb_.AddElement(StatusSystemFixed::VT_FIXED_STATUS_ID, fixed_status_id, 0); + void add_ignorable(bool ignorable) { + fbb_.AddElement(TrackingChecklistStep::VT_IGNORABLE, static_cast(ignorable), 0); + } + void add_extra_data_type(solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type) { + fbb_.AddElement(TrackingChecklistStep::VT_EXTRA_DATA_TYPE, static_cast(extra_data_type), 0); } - explicit StatusSystemFixedBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_extra_data(flatbuffers::Offset extra_data) { + fbb_.AddOffset(TrackingChecklistStep::VT_EXTRA_DATA, extra_data); + } + explicit TrackingChecklistStepBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusSystemFixed( +inline flatbuffers::Offset CreateTrackingChecklistStep( flatbuffers::FlatBufferBuilder &_fbb, - uint32_t fixed_status_id = 0) { - StatusSystemFixedBuilder builder_(_fbb); - builder_.add_fixed_status_id(fixed_status_id); + solarxr_protocol::rpc::TrackingChecklistStepId id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, + bool valid = false, + bool enabled = false, + solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility = solarxr_protocol::rpc::TrackingChecklistStepVisibility::ALWAYS, + bool optional = false, + bool ignorable = false, + solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type = solarxr_protocol::rpc::TrackingChecklistExtraData::NONE, + flatbuffers::Offset extra_data = 0) { + TrackingChecklistStepBuilder builder_(_fbb); + builder_.add_extra_data(extra_data); + builder_.add_extra_data_type(extra_data_type); + builder_.add_ignorable(ignorable); + builder_.add_optional(optional); + builder_.add_visibility(visibility); + builder_.add_enabled(enabled); + builder_.add_valid(valid); + builder_.add_id(id); return builder_.Finish(); } -/// When the server detects a public network profile -struct StatusPublicNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusPublicNetworkBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ADAPTERS = 4 - }; - /// names of the adapters set to public - const flatbuffers::Vector> *adapters() const { - return GetPointer> *>(VT_ADAPTERS); - } +struct TrackingChecklistRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ADAPTERS) && - verifier.VerifyVector(adapters()) && - verifier.VerifyVectorOfStrings(adapters()) && verifier.EndTable(); } }; -struct StatusPublicNetworkBuilder { - typedef StatusPublicNetwork Table; +struct TrackingChecklistRequestBuilder { + typedef TrackingChecklistRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_adapters(flatbuffers::Offset>> adapters) { - fbb_.AddOffset(StatusPublicNetwork::VT_ADAPTERS, adapters); - } - explicit StatusPublicNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusPublicNetwork( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> adapters = 0) { - StatusPublicNetworkBuilder builder_(_fbb); - builder_.add_adapters(adapters); +inline flatbuffers::Offset CreateTrackingChecklistRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + TrackingChecklistRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateStatusPublicNetworkDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *adapters = nullptr) { - auto adapters__ = adapters ? _fbb.CreateVector>(*adapters) : 0; - return solarxr_protocol::rpc::CreateStatusPublicNetwork( - _fbb, - adapters__); -} - -/// An status is some kind of warning sent by the server, it's mainly made for -/// showing problems with the server and need attention from the user. -struct StatusMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StatusMessageBuilder Builder; +struct TrackingChecklistResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4, - VT_PRIORITIZED = 6, - VT_DATA_TYPE = 8, - VT_DATA = 10 + VT_STEPS = 4, + VT_IGNORED_STEPS = 6 }; - /// The status ID - uint32_t id() const { - return GetField(VT_ID, 0); - } - /// This should be prioritized in the GUI in some way if true - bool prioritized() const { - return GetField(VT_PRIORITIZED, 0) != 0; - } - solarxr_protocol::rpc::StatusData data_type() const { - return static_cast(GetField(VT_DATA_TYPE, 0)); - } - const void *data() const { - return GetPointer(VT_DATA); - } - template const T *data_as() const; - const solarxr_protocol::rpc::StatusTrackerReset *data_as_StatusTrackerReset() const { - return data_type() == solarxr_protocol::rpc::StatusData::StatusTrackerReset ? static_cast(data()) : nullptr; - } - const solarxr_protocol::rpc::StatusTrackerError *data_as_StatusTrackerError() const { - return data_type() == solarxr_protocol::rpc::StatusData::StatusTrackerError ? static_cast(data()) : nullptr; - } - const solarxr_protocol::rpc::StatusSteamVRDisconnected *data_as_StatusSteamVRDisconnected() const { - return data_type() == solarxr_protocol::rpc::StatusData::StatusSteamVRDisconnected ? static_cast(data()) : nullptr; - } - const solarxr_protocol::rpc::StatusUnassignedHMD *data_as_StatusUnassignedHMD() const { - return data_type() == solarxr_protocol::rpc::StatusData::StatusUnassignedHMD ? static_cast(data()) : nullptr; + const flatbuffers::Vector> *steps() const { + return GetPointer> *>(VT_STEPS); } - const solarxr_protocol::rpc::StatusPublicNetwork *data_as_StatusPublicNetwork() const { - return data_type() == solarxr_protocol::rpc::StatusData::StatusPublicNetwork ? static_cast(data()) : nullptr; + const flatbuffers::Vector *ignored_steps() const { + return GetPointer *>(VT_IGNORED_STEPS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ID, 4) && - VerifyField(verifier, VT_PRIORITIZED, 1) && - VerifyField(verifier, VT_DATA_TYPE, 1) && - VerifyOffset(verifier, VT_DATA) && - VerifyStatusData(verifier, data(), data_type()) && + VerifyOffset(verifier, VT_STEPS) && + verifier.VerifyVector(steps()) && + verifier.VerifyVectorOfTables(steps()) && + VerifyOffset(verifier, VT_IGNORED_STEPS) && + verifier.VerifyVector(ignored_steps()) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::rpc::StatusTrackerReset *StatusMessage::data_as() const { - return data_as_StatusTrackerReset(); -} - -template<> inline const solarxr_protocol::rpc::StatusTrackerError *StatusMessage::data_as() const { - return data_as_StatusTrackerError(); -} - -template<> inline const solarxr_protocol::rpc::StatusSteamVRDisconnected *StatusMessage::data_as() const { - return data_as_StatusSteamVRDisconnected(); -} - -template<> inline const solarxr_protocol::rpc::StatusUnassignedHMD *StatusMessage::data_as() const { - return data_as_StatusUnassignedHMD(); -} - -template<> inline const solarxr_protocol::rpc::StatusPublicNetwork *StatusMessage::data_as() const { - return data_as_StatusPublicNetwork(); -} - -struct StatusMessageBuilder { - typedef StatusMessage Table; +struct TrackingChecklistResponseBuilder { + typedef TrackingChecklistResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_id(uint32_t id) { - fbb_.AddElement(StatusMessage::VT_ID, id, 0); - } - void add_prioritized(bool prioritized) { - fbb_.AddElement(StatusMessage::VT_PRIORITIZED, static_cast(prioritized), 0); - } - void add_data_type(solarxr_protocol::rpc::StatusData data_type) { - fbb_.AddElement(StatusMessage::VT_DATA_TYPE, static_cast(data_type), 0); + void add_steps(flatbuffers::Offset>> steps) { + fbb_.AddOffset(TrackingChecklistResponse::VT_STEPS, steps); } - void add_data(flatbuffers::Offset data) { - fbb_.AddOffset(StatusMessage::VT_DATA, data); + void add_ignored_steps(flatbuffers::Offset> ignored_steps) { + fbb_.AddOffset(TrackingChecklistResponse::VT_IGNORED_STEPS, ignored_steps); } - explicit StatusMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStatusMessage( +inline flatbuffers::Offset CreateTrackingChecklistResponse( flatbuffers::FlatBufferBuilder &_fbb, - uint32_t id = 0, - bool prioritized = false, - solarxr_protocol::rpc::StatusData data_type = solarxr_protocol::rpc::StatusData::NONE, - flatbuffers::Offset data = 0) { - StatusMessageBuilder builder_(_fbb); - builder_.add_data(data); - builder_.add_id(id); - builder_.add_data_type(data_type); - builder_.add_prioritized(prioritized); + flatbuffers::Offset>> steps = 0, + flatbuffers::Offset> ignored_steps = 0) { + TrackingChecklistResponseBuilder builder_(_fbb); + builder_.add_ignored_steps(ignored_steps); + builder_.add_steps(steps); return builder_.Finish(); } -struct SetPauseTrackingRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SetPauseTrackingRequestBuilder Builder; +inline flatbuffers::Offset CreateTrackingChecklistResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *steps = nullptr, + const std::vector *ignored_steps = nullptr) { + auto steps__ = steps ? _fbb.CreateVector>(*steps) : 0; + auto ignored_steps__ = ignored_steps ? _fbb.CreateVector(*ignored_steps) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistResponse( + _fbb, + steps__, + ignored_steps__); +} + +struct IgnoreTrackingChecklistStepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IgnoreTrackingChecklistStepRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PAUSETRACKING = 4 + VT_STEP_ID = 4, + VT_IGNORE = 6 }; - /// Pauses skeleton tracking if true, resumes skeleton tracking if false. - bool pauseTracking() const { - return GetField(VT_PAUSETRACKING, 0) != 0; + solarxr_protocol::rpc::TrackingChecklistStepId step_id() const { + return static_cast(GetField(VT_STEP_ID, 0)); + } + bool ignore() const { + return GetField(VT_IGNORE, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_PAUSETRACKING, 1) && + VerifyField(verifier, VT_STEP_ID, 1) && + VerifyField(verifier, VT_IGNORE, 1) && verifier.EndTable(); } }; -struct SetPauseTrackingRequestBuilder { - typedef SetPauseTrackingRequest Table; +struct IgnoreTrackingChecklistStepRequestBuilder { + typedef IgnoreTrackingChecklistStepRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_pauseTracking(bool pauseTracking) { - fbb_.AddElement(SetPauseTrackingRequest::VT_PAUSETRACKING, static_cast(pauseTracking), 0); + void add_step_id(solarxr_protocol::rpc::TrackingChecklistStepId step_id) { + fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_STEP_ID, static_cast(step_id), 0); } - explicit SetPauseTrackingRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_ignore(bool ignore) { + fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_IGNORE, static_cast(ignore), 0); + } + explicit IgnoreTrackingChecklistStepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSetPauseTrackingRequest( +inline flatbuffers::Offset CreateIgnoreTrackingChecklistStepRequest( flatbuffers::FlatBufferBuilder &_fbb, - bool pauseTracking = false) { - SetPauseTrackingRequestBuilder builder_(_fbb); - builder_.add_pauseTracking(pauseTracking); + solarxr_protocol::rpc::TrackingChecklistStepId step_id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, + bool ignore = false) { + IgnoreTrackingChecklistStepRequestBuilder builder_(_fbb); + builder_.add_ignore(ignore); + builder_.add_step_id(step_id); return builder_.Finish(); } -/// Clears mounting reset data, defaulting to the manually set mounting orientations -struct ClearMountingResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ClearMountingResetRequestBuilder Builder; +struct VMCOSCSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VMCOSCSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct ClearMountingResetRequestBuilder { - typedef ClearMountingResetRequest Table; +struct VMCOSCSettingsRequestBuilder { + typedef VMCOSCSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit ClearMountingResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VMCOSCSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateClearMountingResetRequest( +inline flatbuffers::Offset CreateVMCOSCSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb) { - ClearMountingResetRequestBuilder builder_(_fbb); + VMCOSCSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Used for the server to save a file and have it prompt in the user side -struct SaveFileNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SaveFileNotificationBuilder Builder; +struct VMCOSCSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VMCOSCSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DATA = 4, - VT_MIME_TYPE = 6, - VT_FILE_EXTENSION = 8, - VT_EXPECTED_DIR = 10, - VT_EXPECTED_FILENAME = 12 + VT_ENABLED = 4, + VT_PORT_IN = 6, + VT_PORT_OUT = 8, + VT_ADDRESS = 10, + VT_ANCHOR_HIP = 12, + VT_MIRROR_TRACKING = 14 }; - /// Binary data of the file - const flatbuffers::Vector *data() const { - return GetPointer *>(VT_DATA); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; } - /// MIME type of file if one exists, use `file_extension` otherwise - const flatbuffers::String *mime_type() const { - return GetPointer(VT_MIME_TYPE); + uint16_t port_in() const { + return GetField(VT_PORT_IN, 0); } - /// Use MIME type preferably if one exists - const flatbuffers::String *file_extension() const { - return GetPointer(VT_FILE_EXTENSION); + uint16_t port_out() const { + return GetField(VT_PORT_OUT, 0); } - /// Directory recommended to save the file on - flatbuffers::Optional expected_dir() const { - return GetOptional(VT_EXPECTED_DIR); + const flatbuffers::String *address() const { + return GetPointer(VT_ADDRESS); } - /// Recommended filename - const flatbuffers::String *expected_filename() const { - return GetPointer(VT_EXPECTED_FILENAME); + bool anchor_hip() const { + return GetField(VT_ANCHOR_HIP, 0) != 0; + } + bool mirror_tracking() const { + return GetField(VT_MIRROR_TRACKING, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_DATA) && - verifier.VerifyVector(data()) && - VerifyOffset(verifier, VT_MIME_TYPE) && - verifier.VerifyString(mime_type()) && - VerifyOffset(verifier, VT_FILE_EXTENSION) && - verifier.VerifyString(file_extension()) && - VerifyField(verifier, VT_EXPECTED_DIR, 1) && - VerifyOffset(verifier, VT_EXPECTED_FILENAME) && - verifier.VerifyString(expected_filename()) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_PORT_IN, 2) && + VerifyField(verifier, VT_PORT_OUT, 2) && + VerifyOffset(verifier, VT_ADDRESS) && + verifier.VerifyString(address()) && + VerifyField(verifier, VT_ANCHOR_HIP, 1) && + VerifyField(verifier, VT_MIRROR_TRACKING, 1) && verifier.EndTable(); } }; -struct SaveFileNotificationBuilder { - typedef SaveFileNotification Table; +struct VMCOSCSettingsResponseBuilder { + typedef VMCOSCSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_data(flatbuffers::Offset> data) { - fbb_.AddOffset(SaveFileNotification::VT_DATA, data); + void add_enabled(bool enabled) { + fbb_.AddElement(VMCOSCSettingsResponse::VT_ENABLED, static_cast(enabled), 0); } - void add_mime_type(flatbuffers::Offset mime_type) { - fbb_.AddOffset(SaveFileNotification::VT_MIME_TYPE, mime_type); + void add_port_in(uint16_t port_in) { + fbb_.AddElement(VMCOSCSettingsResponse::VT_PORT_IN, port_in, 0); } - void add_file_extension(flatbuffers::Offset file_extension) { - fbb_.AddOffset(SaveFileNotification::VT_FILE_EXTENSION, file_extension); + void add_port_out(uint16_t port_out) { + fbb_.AddElement(VMCOSCSettingsResponse::VT_PORT_OUT, port_out, 0); } - void add_expected_dir(solarxr_protocol::rpc::ComputerDirectory expected_dir) { - fbb_.AddElement(SaveFileNotification::VT_EXPECTED_DIR, static_cast(expected_dir)); + void add_address(flatbuffers::Offset address) { + fbb_.AddOffset(VMCOSCSettingsResponse::VT_ADDRESS, address); } - void add_expected_filename(flatbuffers::Offset expected_filename) { - fbb_.AddOffset(SaveFileNotification::VT_EXPECTED_FILENAME, expected_filename); + void add_anchor_hip(bool anchor_hip) { + fbb_.AddElement(VMCOSCSettingsResponse::VT_ANCHOR_HIP, static_cast(anchor_hip), 0); } - explicit SaveFileNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_mirror_tracking(bool mirror_tracking) { + fbb_.AddElement(VMCOSCSettingsResponse::VT_MIRROR_TRACKING, static_cast(mirror_tracking), 0); + } + explicit VMCOSCSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSaveFileNotification( +inline flatbuffers::Offset CreateVMCOSCSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset> data = 0, - flatbuffers::Offset mime_type = 0, - flatbuffers::Offset file_extension = 0, - flatbuffers::Optional expected_dir = flatbuffers::nullopt, - flatbuffers::Offset expected_filename = 0) { - SaveFileNotificationBuilder builder_(_fbb); - builder_.add_expected_filename(expected_filename); - builder_.add_file_extension(file_extension); - builder_.add_mime_type(mime_type); - builder_.add_data(data); - if(expected_dir) { builder_.add_expected_dir(*expected_dir); } + bool enabled = false, + uint16_t port_in = 0, + uint16_t port_out = 0, + flatbuffers::Offset address = 0, + bool anchor_hip = false, + bool mirror_tracking = false) { + VMCOSCSettingsResponseBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_port_out(port_out); + builder_.add_port_in(port_in); + builder_.add_mirror_tracking(mirror_tracking); + builder_.add_anchor_hip(anchor_hip); + builder_.add_enabled(enabled); return builder_.Finish(); } -inline flatbuffers::Offset CreateSaveFileNotificationDirect( +inline flatbuffers::Offset CreateVMCOSCSettingsResponseDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *data = nullptr, - const char *mime_type = nullptr, - const char *file_extension = nullptr, - flatbuffers::Optional expected_dir = flatbuffers::nullopt, - const char *expected_filename = nullptr) { - auto data__ = data ? _fbb.CreateVector(*data) : 0; - auto mime_type__ = mime_type ? _fbb.CreateString(mime_type) : 0; - auto file_extension__ = file_extension ? _fbb.CreateString(file_extension) : 0; - auto expected_filename__ = expected_filename ? _fbb.CreateString(expected_filename) : 0; - return solarxr_protocol::rpc::CreateSaveFileNotification( + bool enabled = false, + uint16_t port_in = 0, + uint16_t port_out = 0, + const char *address = nullptr, + bool anchor_hip = false, + bool mirror_tracking = false) { + auto address__ = address ? _fbb.CreateString(address) : 0; + return solarxr_protocol::rpc::CreateVMCOSCSettingsResponse( _fbb, - data__, - mime_type__, - file_extension__, - expected_dir, - expected_filename__); + enabled, + port_in, + port_out, + address__, + anchor_hip, + mirror_tracking); } -struct SerialDevicePort FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialDevicePortBuilder Builder; +struct ChangeVMCOSCSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeVMCOSCSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_PORT = 4 + VT_ENABLED = 4, + VT_PORT_IN = 6, + VT_PORT_OUT = 8, + VT_ADDRESS = 10, + VT_ANCHOR_HIP = 12, + VT_MIRROR_TRACKING = 14 }; - const flatbuffers::String *port() const { - return GetPointer(VT_PORT); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + uint16_t port_in() const { + return GetField(VT_PORT_IN, 0); + } + uint16_t port_out() const { + return GetField(VT_PORT_OUT, 0); + } + const flatbuffers::String *address() const { + return GetPointer(VT_ADDRESS); + } + bool anchor_hip() const { + return GetField(VT_ANCHOR_HIP, 0) != 0; + } + bool mirror_tracking() const { + return GetField(VT_MIRROR_TRACKING, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_PORT) && - verifier.VerifyString(port()) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_PORT_IN, 2) && + VerifyField(verifier, VT_PORT_OUT, 2) && + VerifyOffset(verifier, VT_ADDRESS) && + verifier.VerifyString(address()) && + VerifyField(verifier, VT_ANCHOR_HIP, 1) && + VerifyField(verifier, VT_MIRROR_TRACKING, 1) && verifier.EndTable(); } }; -struct SerialDevicePortBuilder { - typedef SerialDevicePort Table; +struct ChangeVMCOSCSettingsRequestBuilder { + typedef ChangeVMCOSCSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_port(flatbuffers::Offset port) { - fbb_.AddOffset(SerialDevicePort::VT_PORT, port); + void add_enabled(bool enabled) { + fbb_.AddElement(ChangeVMCOSCSettingsRequest::VT_ENABLED, static_cast(enabled), 0); } - explicit SerialDevicePortBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_port_in(uint16_t port_in) { + fbb_.AddElement(ChangeVMCOSCSettingsRequest::VT_PORT_IN, port_in, 0); + } + void add_port_out(uint16_t port_out) { + fbb_.AddElement(ChangeVMCOSCSettingsRequest::VT_PORT_OUT, port_out, 0); + } + void add_address(flatbuffers::Offset address) { + fbb_.AddOffset(ChangeVMCOSCSettingsRequest::VT_ADDRESS, address); + } + void add_anchor_hip(bool anchor_hip) { + fbb_.AddElement(ChangeVMCOSCSettingsRequest::VT_ANCHOR_HIP, static_cast(anchor_hip), 0); + } + void add_mirror_tracking(bool mirror_tracking) { + fbb_.AddElement(ChangeVMCOSCSettingsRequest::VT_MIRROR_TRACKING, static_cast(mirror_tracking), 0); + } + explicit ChangeVMCOSCSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialDevicePort( +inline flatbuffers::Offset CreateChangeVMCOSCSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset port = 0) { - SerialDevicePortBuilder builder_(_fbb); - builder_.add_port(port); + bool enabled = false, + uint16_t port_in = 0, + uint16_t port_out = 0, + flatbuffers::Offset address = 0, + bool anchor_hip = false, + bool mirror_tracking = false) { + ChangeVMCOSCSettingsRequestBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_port_out(port_out); + builder_.add_port_in(port_in); + builder_.add_mirror_tracking(mirror_tracking); + builder_.add_anchor_hip(anchor_hip); + builder_.add_enabled(enabled); return builder_.Finish(); } -inline flatbuffers::Offset CreateSerialDevicePortDirect( +inline flatbuffers::Offset CreateChangeVMCOSCSettingsRequestDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *port = nullptr) { - auto port__ = port ? _fbb.CreateString(port) : 0; - return solarxr_protocol::rpc::CreateSerialDevicePort( + bool enabled = false, + uint16_t port_in = 0, + uint16_t port_out = 0, + const char *address = nullptr, + bool anchor_hip = false, + bool mirror_tracking = false) { + auto address__ = address ? _fbb.CreateString(address) : 0; + return solarxr_protocol::rpc::CreateChangeVMCOSCSettingsRequest( _fbb, - port__); + enabled, + port_in, + port_out, + address__, + anchor_hip, + mirror_tracking); } -struct FirmwarePart FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef FirmwarePartBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_URL = 4, - VT_OFFSET = 6, - VT_DIGEST = 8 - }; - /// Url of the firmware bin to download - const flatbuffers::String *url() const { - return GetPointer(VT_URL); - } - /// Offset of the firmware, used when flashing to the mcu, it indicates where to write this file in memory - /// Will be ignored in the case of OTA flashing - uint32_t offset() const { - return GetField(VT_OFFSET, 0); - } - /// Checksum of the file - const flatbuffers::String *digest() const { - return GetPointer(VT_DIGEST); - } +struct VRMSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRMSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_URL) && - verifier.VerifyString(url()) && - VerifyField(verifier, VT_OFFSET, 4) && - VerifyOffset(verifier, VT_DIGEST) && - verifier.VerifyString(digest()) && verifier.EndTable(); } }; -struct FirmwarePartBuilder { - typedef FirmwarePart Table; +struct VRMSettingsRequestBuilder { + typedef VRMSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_url(flatbuffers::Offset url) { - fbb_.AddOffset(FirmwarePart::VT_URL, url); - } - void add_offset(uint32_t offset) { - fbb_.AddElement(FirmwarePart::VT_OFFSET, offset, 0); - } - void add_digest(flatbuffers::Offset digest) { - fbb_.AddOffset(FirmwarePart::VT_DIGEST, digest); - } - explicit FirmwarePartBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRMSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFirmwarePart( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset url = 0, - uint32_t offset = 0, - flatbuffers::Offset digest = 0) { - FirmwarePartBuilder builder_(_fbb); - builder_.add_digest(digest); - builder_.add_offset(offset); - builder_.add_url(url); +inline flatbuffers::Offset CreateVRMSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + VRMSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateFirmwarePartDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *url = nullptr, - uint32_t offset = 0, - const char *digest = nullptr) { - auto url__ = url ? _fbb.CreateString(url) : 0; - auto digest__ = digest ? _fbb.CreateString(digest) : 0; - return solarxr_protocol::rpc::CreateFirmwarePart( - _fbb, - url__, - offset, - digest__); -} - -struct FirmwareUpdateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef FirmwareUpdateRequestBuilder Builder; +struct VRMSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRMSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_METHOD_TYPE = 4, - VT_METHOD = 6 + VT_VRM_JSON = 4 }; - solarxr_protocol::rpc::FirmwareUpdateMethod method_type() const { - return static_cast(GetField(VT_METHOD_TYPE, 0)); - } - const void *method() const { - return GetPointer(VT_METHOD); - } - template const T *method_as() const; - const solarxr_protocol::rpc::OTAFirmwareUpdate *method_as_OTAFirmwareUpdate() const { - return method_type() == solarxr_protocol::rpc::FirmwareUpdateMethod::OTAFirmwareUpdate ? static_cast(method()) : nullptr; - } - const solarxr_protocol::rpc::SerialFirmwareUpdate *method_as_SerialFirmwareUpdate() const { - return method_type() == solarxr_protocol::rpc::FirmwareUpdateMethod::SerialFirmwareUpdate ? static_cast(method()) : nullptr; + const flatbuffers::String *vrm_json() const { + return GetPointer(VT_VRM_JSON); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_METHOD_TYPE, 1) && - VerifyOffset(verifier, VT_METHOD) && - VerifyFirmwareUpdateMethod(verifier, method(), method_type()) && + VerifyOffset(verifier, VT_VRM_JSON) && + verifier.VerifyString(vrm_json()) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::rpc::OTAFirmwareUpdate *FirmwareUpdateRequest::method_as() const { - return method_as_OTAFirmwareUpdate(); -} - -template<> inline const solarxr_protocol::rpc::SerialFirmwareUpdate *FirmwareUpdateRequest::method_as() const { - return method_as_SerialFirmwareUpdate(); -} - -struct FirmwareUpdateRequestBuilder { - typedef FirmwareUpdateRequest Table; +struct VRMSettingsResponseBuilder { + typedef VRMSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_method_type(solarxr_protocol::rpc::FirmwareUpdateMethod method_type) { - fbb_.AddElement(FirmwareUpdateRequest::VT_METHOD_TYPE, static_cast(method_type), 0); - } - void add_method(flatbuffers::Offset method) { - fbb_.AddOffset(FirmwareUpdateRequest::VT_METHOD, method); + void add_vrm_json(flatbuffers::Offset vrm_json) { + fbb_.AddOffset(VRMSettingsResponse::VT_VRM_JSON, vrm_json); } - explicit FirmwareUpdateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRMSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFirmwareUpdateRequest( +inline flatbuffers::Offset CreateVRMSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::FirmwareUpdateMethod method_type = solarxr_protocol::rpc::FirmwareUpdateMethod::NONE, - flatbuffers::Offset method = 0) { - FirmwareUpdateRequestBuilder builder_(_fbb); - builder_.add_method(method); - builder_.add_method_type(method_type); + flatbuffers::Offset vrm_json = 0) { + VRMSettingsResponseBuilder builder_(_fbb); + builder_.add_vrm_json(vrm_json); return builder_.Finish(); } -struct OTAFirmwareUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef OTAFirmwareUpdateBuilder Builder; +inline flatbuffers::Offset CreateVRMSettingsResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *vrm_json = nullptr) { + auto vrm_json__ = vrm_json ? _fbb.CreateString(vrm_json) : 0; + return solarxr_protocol::rpc::CreateVRMSettingsResponse( + _fbb, + vrm_json__); +} + +struct ChangeVRMSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeVRMSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICE_ID = 4, - VT_FIRMWARE_PART = 6 + VT_VRM_JSON = 4 }; - /// id of the device, this refer to the actual DeviceId from the protocol - const solarxr_protocol::datatypes::DeviceId *device_id() const { - return GetStruct(VT_DEVICE_ID); - } - /// A table containing the url and offset of the firmware bin file - const solarxr_protocol::rpc::FirmwarePart *firmware_part() const { - return GetPointer(VT_FIRMWARE_PART); + const flatbuffers::String *vrm_json() const { + return GetPointer(VT_VRM_JSON); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_DEVICE_ID, 1) && - VerifyOffset(verifier, VT_FIRMWARE_PART) && - verifier.VerifyTable(firmware_part()) && + VerifyOffset(verifier, VT_VRM_JSON) && + verifier.VerifyString(vrm_json()) && verifier.EndTable(); } }; -struct OTAFirmwareUpdateBuilder { - typedef OTAFirmwareUpdate Table; +struct ChangeVRMSettingsRequestBuilder { + typedef ChangeVRMSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_device_id(const solarxr_protocol::datatypes::DeviceId *device_id) { - fbb_.AddStruct(OTAFirmwareUpdate::VT_DEVICE_ID, device_id); - } - void add_firmware_part(flatbuffers::Offset firmware_part) { - fbb_.AddOffset(OTAFirmwareUpdate::VT_FIRMWARE_PART, firmware_part); + void add_vrm_json(flatbuffers::Offset vrm_json) { + fbb_.AddOffset(ChangeVRMSettingsRequest::VT_VRM_JSON, vrm_json); } - explicit OTAFirmwareUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ChangeVRMSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateOTAFirmwareUpdate( +inline flatbuffers::Offset CreateChangeVRMSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - const solarxr_protocol::datatypes::DeviceId *device_id = nullptr, - flatbuffers::Offset firmware_part = 0) { - OTAFirmwareUpdateBuilder builder_(_fbb); - builder_.add_firmware_part(firmware_part); - builder_.add_device_id(device_id); + flatbuffers::Offset vrm_json = 0) { + ChangeVRMSettingsRequestBuilder builder_(_fbb); + builder_.add_vrm_json(vrm_json); return builder_.Finish(); } -struct SerialFirmwareUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialFirmwareUpdateBuilder Builder; +inline flatbuffers::Offset CreateChangeVRMSettingsRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *vrm_json = nullptr) { + auto vrm_json__ = vrm_json ? _fbb.CreateString(vrm_json) : 0; + return solarxr_protocol::rpc::CreateChangeVRMSettingsRequest( + _fbb, + vrm_json__); +} + +struct VRCConfigValidity FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigValidityBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICE_ID = 4, - VT_NEEDMANUALREBOOT = 6, - VT_SSID = 8, - VT_PASSWORD = 10, - VT_FIRMWARE_PART = 12 + VT_LEGACY_MODE_OK = 4, + VT_SHOULDER_TRACKING_OK = 6, + VT_USER_HEIGHT_OK = 8, + VT_CALIBRATION_RANGE_OK = 10, + VT_CALIBRATION_VISUALS_OK = 12, + VT_TRACKER_MODEL_OK = 14, + VT_SPINE_MODE_OK = 16, + VT_AVATAR_MEASUREMENT_TYPE_OK = 18, + VT_SHOULDER_WIDTH_COMPENSATION_OK = 20 }; - /// id of the device, this refer to a serial port id - const solarxr_protocol::rpc::SerialDevicePort *device_id() const { - return GetPointer(VT_DEVICE_ID); + bool legacy_mode_ok() const { + return GetField(VT_LEGACY_MODE_OK, 0) != 0; } - /// Will make the server ask for the tracker to be manually rebooted by the user - /// after the tracker is done flashing - bool needManualReboot() const { - return GetField(VT_NEEDMANUALREBOOT, 0) != 0; + bool shoulder_tracking_ok() const { + return GetField(VT_SHOULDER_TRACKING_OK, 0) != 0; } - /// Credentials to provision after the flashing - /// Only used with Serial flashing, because OTA is already connected to the wifi - const flatbuffers::String *ssid() const { - return GetPointer(VT_SSID); + bool user_height_ok() const { + return GetField(VT_USER_HEIGHT_OK, 0) != 0; } - const flatbuffers::String *password() const { - return GetPointer(VT_PASSWORD); + bool calibration_range_ok() const { + return GetField(VT_CALIBRATION_RANGE_OK, 0) != 0; } - /// A list of urls and offsets of the different firmware files to flash - const flatbuffers::Vector> *firmware_part() const { - return GetPointer> *>(VT_FIRMWARE_PART); + bool calibration_visuals_ok() const { + return GetField(VT_CALIBRATION_VISUALS_OK, 0) != 0; + } + bool tracker_model_ok() const { + return GetField(VT_TRACKER_MODEL_OK, 0) != 0; + } + bool spine_mode_ok() const { + return GetField(VT_SPINE_MODE_OK, 0) != 0; + } + bool avatar_measurement_type_ok() const { + return GetField(VT_AVATAR_MEASUREMENT_TYPE_OK, 0) != 0; + } + bool shoulder_width_compensation_ok() const { + return GetField(VT_SHOULDER_WIDTH_COMPENSATION_OK, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_DEVICE_ID) && - verifier.VerifyTable(device_id()) && - VerifyField(verifier, VT_NEEDMANUALREBOOT, 1) && - VerifyOffset(verifier, VT_SSID) && - verifier.VerifyString(ssid()) && - VerifyOffset(verifier, VT_PASSWORD) && - verifier.VerifyString(password()) && - VerifyOffset(verifier, VT_FIRMWARE_PART) && - verifier.VerifyVector(firmware_part()) && - verifier.VerifyVectorOfTables(firmware_part()) && + VerifyField(verifier, VT_LEGACY_MODE_OK, 1) && + VerifyField(verifier, VT_SHOULDER_TRACKING_OK, 1) && + VerifyField(verifier, VT_USER_HEIGHT_OK, 1) && + VerifyField(verifier, VT_CALIBRATION_RANGE_OK, 1) && + VerifyField(verifier, VT_CALIBRATION_VISUALS_OK, 1) && + VerifyField(verifier, VT_TRACKER_MODEL_OK, 1) && + VerifyField(verifier, VT_SPINE_MODE_OK, 1) && + VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE_OK, 1) && + VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION_OK, 1) && verifier.EndTable(); } }; -struct SerialFirmwareUpdateBuilder { - typedef SerialFirmwareUpdate Table; +struct VRCConfigValidityBuilder { + typedef VRCConfigValidity Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_device_id(flatbuffers::Offset device_id) { - fbb_.AddOffset(SerialFirmwareUpdate::VT_DEVICE_ID, device_id); + void add_legacy_mode_ok(bool legacy_mode_ok) { + fbb_.AddElement(VRCConfigValidity::VT_LEGACY_MODE_OK, static_cast(legacy_mode_ok), 0); } - void add_needManualReboot(bool needManualReboot) { - fbb_.AddElement(SerialFirmwareUpdate::VT_NEEDMANUALREBOOT, static_cast(needManualReboot), 0); + void add_shoulder_tracking_ok(bool shoulder_tracking_ok) { + fbb_.AddElement(VRCConfigValidity::VT_SHOULDER_TRACKING_OK, static_cast(shoulder_tracking_ok), 0); } - void add_ssid(flatbuffers::Offset ssid) { - fbb_.AddOffset(SerialFirmwareUpdate::VT_SSID, ssid); + void add_user_height_ok(bool user_height_ok) { + fbb_.AddElement(VRCConfigValidity::VT_USER_HEIGHT_OK, static_cast(user_height_ok), 0); } - void add_password(flatbuffers::Offset password) { - fbb_.AddOffset(SerialFirmwareUpdate::VT_PASSWORD, password); + void add_calibration_range_ok(bool calibration_range_ok) { + fbb_.AddElement(VRCConfigValidity::VT_CALIBRATION_RANGE_OK, static_cast(calibration_range_ok), 0); } - void add_firmware_part(flatbuffers::Offset>> firmware_part) { - fbb_.AddOffset(SerialFirmwareUpdate::VT_FIRMWARE_PART, firmware_part); + void add_calibration_visuals_ok(bool calibration_visuals_ok) { + fbb_.AddElement(VRCConfigValidity::VT_CALIBRATION_VISUALS_OK, static_cast(calibration_visuals_ok), 0); } - explicit SerialFirmwareUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_tracker_model_ok(bool tracker_model_ok) { + fbb_.AddElement(VRCConfigValidity::VT_TRACKER_MODEL_OK, static_cast(tracker_model_ok), 0); + } + void add_spine_mode_ok(bool spine_mode_ok) { + fbb_.AddElement(VRCConfigValidity::VT_SPINE_MODE_OK, static_cast(spine_mode_ok), 0); + } + void add_avatar_measurement_type_ok(bool avatar_measurement_type_ok) { + fbb_.AddElement(VRCConfigValidity::VT_AVATAR_MEASUREMENT_TYPE_OK, static_cast(avatar_measurement_type_ok), 0); + } + void add_shoulder_width_compensation_ok(bool shoulder_width_compensation_ok) { + fbb_.AddElement(VRCConfigValidity::VT_SHOULDER_WIDTH_COMPENSATION_OK, static_cast(shoulder_width_compensation_ok), 0); + } + explicit VRCConfigValidityBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialFirmwareUpdate( +inline flatbuffers::Offset CreateVRCConfigValidity( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset device_id = 0, - bool needManualReboot = false, - flatbuffers::Offset ssid = 0, - flatbuffers::Offset password = 0, - flatbuffers::Offset>> firmware_part = 0) { - SerialFirmwareUpdateBuilder builder_(_fbb); - builder_.add_firmware_part(firmware_part); - builder_.add_password(password); - builder_.add_ssid(ssid); - builder_.add_device_id(device_id); - builder_.add_needManualReboot(needManualReboot); + bool legacy_mode_ok = false, + bool shoulder_tracking_ok = false, + bool user_height_ok = false, + bool calibration_range_ok = false, + bool calibration_visuals_ok = false, + bool tracker_model_ok = false, + bool spine_mode_ok = false, + bool avatar_measurement_type_ok = false, + bool shoulder_width_compensation_ok = false) { + VRCConfigValidityBuilder builder_(_fbb); + builder_.add_shoulder_width_compensation_ok(shoulder_width_compensation_ok); + builder_.add_avatar_measurement_type_ok(avatar_measurement_type_ok); + builder_.add_spine_mode_ok(spine_mode_ok); + builder_.add_tracker_model_ok(tracker_model_ok); + builder_.add_calibration_visuals_ok(calibration_visuals_ok); + builder_.add_calibration_range_ok(calibration_range_ok); + builder_.add_user_height_ok(user_height_ok); + builder_.add_shoulder_tracking_ok(shoulder_tracking_ok); + builder_.add_legacy_mode_ok(legacy_mode_ok); return builder_.Finish(); } -inline flatbuffers::Offset CreateSerialFirmwareUpdateDirect( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset device_id = 0, - bool needManualReboot = false, - const char *ssid = nullptr, - const char *password = nullptr, - const std::vector> *firmware_part = nullptr) { - auto ssid__ = ssid ? _fbb.CreateString(ssid) : 0; - auto password__ = password ? _fbb.CreateString(password) : 0; - auto firmware_part__ = firmware_part ? _fbb.CreateVector>(*firmware_part) : 0; - return solarxr_protocol::rpc::CreateSerialFirmwareUpdate( - _fbb, - device_id, - needManualReboot, - ssid__, - password__, - firmware_part__); -} - -struct FirmwareUpdateStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef FirmwareUpdateStatusResponseBuilder Builder; +struct VRCConfigValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigValuesBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_DEVICE_ID_TYPE = 4, - VT_DEVICE_ID = 6, - VT_STATUS = 8, - VT_PROGRESS = 10 + VT_LEGACY_MODE = 4, + VT_SHOULDER_TRACKING_DISABLED = 6, + VT_USER_HEIGHT = 8, + VT_CALIBRATION_RANGE = 10, + VT_CALIBRATION_VISUALS = 12, + VT_TRACKER_MODEL = 14, + VT_SPINE_MODE = 16, + VT_AVATAR_MEASUREMENT_TYPE = 18, + VT_SHOULDER_WIDTH_COMPENSATION = 20 }; - solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type() const { - return static_cast(GetField(VT_DEVICE_ID_TYPE, 0)); + bool legacy_mode() const { + return GetField(VT_LEGACY_MODE, 0) != 0; } - const void *device_id() const { - return GetPointer(VT_DEVICE_ID); + bool shoulder_tracking_disabled() const { + return GetField(VT_SHOULDER_TRACKING_DISABLED, 0) != 0; } - template const T *device_id_as() const; - const solarxr_protocol::datatypes::DeviceIdTable *device_id_as_solarxr_protocol_datatypes_DeviceIdTable() const { - return device_id_type() == solarxr_protocol::rpc::FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable ? static_cast(device_id()) : nullptr; + float user_height() const { + return GetField(VT_USER_HEIGHT, 0.0f); } - const solarxr_protocol::rpc::SerialDevicePort *device_id_as_SerialDevicePort() const { - return device_id_type() == solarxr_protocol::rpc::FirmwareUpdateDeviceId::SerialDevicePort ? static_cast(device_id()) : nullptr; + float calibration_range() const { + return GetField(VT_CALIBRATION_RANGE, 0.0f); } - solarxr_protocol::rpc::FirmwareUpdateStatus status() const { - return static_cast(GetField(VT_STATUS, 0)); + bool calibration_visuals() const { + return GetField(VT_CALIBRATION_VISUALS, 0) != 0; } - /// from 0 to 100 - int8_t progress() const { - return GetField(VT_PROGRESS, 0); + solarxr_protocol::rpc::VRCTrackerModel tracker_model() const { + return static_cast(GetField(VT_TRACKER_MODEL, 0)); + } + solarxr_protocol::rpc::VRCSpineMode spine_mode() const { + return static_cast(GetField(VT_SPINE_MODE, 0)); + } + solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type() const { + return static_cast(GetField(VT_AVATAR_MEASUREMENT_TYPE, 0)); + } + bool shoulder_width_compensation() const { + return GetField(VT_SHOULDER_WIDTH_COMPENSATION, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_DEVICE_ID_TYPE, 1) && - VerifyOffset(verifier, VT_DEVICE_ID) && - VerifyFirmwareUpdateDeviceId(verifier, device_id(), device_id_type()) && - VerifyField(verifier, VT_STATUS, 1) && - VerifyField(verifier, VT_PROGRESS, 1) && + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_LEGACY_MODE, 1) && + VerifyField(verifier, VT_SHOULDER_TRACKING_DISABLED, 1) && + VerifyField(verifier, VT_USER_HEIGHT, 4) && + VerifyField(verifier, VT_CALIBRATION_RANGE, 4) && + VerifyField(verifier, VT_CALIBRATION_VISUALS, 1) && + VerifyField(verifier, VT_TRACKER_MODEL, 1) && + VerifyField(verifier, VT_SPINE_MODE, 1) && + VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE, 1) && + VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION, 1) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::datatypes::DeviceIdTable *FirmwareUpdateStatusResponse::device_id_as() const { - return device_id_as_solarxr_protocol_datatypes_DeviceIdTable(); -} - -template<> inline const solarxr_protocol::rpc::SerialDevicePort *FirmwareUpdateStatusResponse::device_id_as() const { - return device_id_as_SerialDevicePort(); -} - -struct FirmwareUpdateStatusResponseBuilder { - typedef FirmwareUpdateStatusResponse Table; +struct VRCConfigValuesBuilder { + typedef VRCConfigValues Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_device_id_type(solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type) { - fbb_.AddElement(FirmwareUpdateStatusResponse::VT_DEVICE_ID_TYPE, static_cast(device_id_type), 0); + void add_legacy_mode(bool legacy_mode) { + fbb_.AddElement(VRCConfigValues::VT_LEGACY_MODE, static_cast(legacy_mode), 0); } - void add_device_id(flatbuffers::Offset device_id) { - fbb_.AddOffset(FirmwareUpdateStatusResponse::VT_DEVICE_ID, device_id); + void add_shoulder_tracking_disabled(bool shoulder_tracking_disabled) { + fbb_.AddElement(VRCConfigValues::VT_SHOULDER_TRACKING_DISABLED, static_cast(shoulder_tracking_disabled), 0); } - void add_status(solarxr_protocol::rpc::FirmwareUpdateStatus status) { - fbb_.AddElement(FirmwareUpdateStatusResponse::VT_STATUS, static_cast(status), 0); + void add_user_height(float user_height) { + fbb_.AddElement(VRCConfigValues::VT_USER_HEIGHT, user_height, 0.0f); } - void add_progress(int8_t progress) { - fbb_.AddElement(FirmwareUpdateStatusResponse::VT_PROGRESS, progress, 0); + void add_calibration_range(float calibration_range) { + fbb_.AddElement(VRCConfigValues::VT_CALIBRATION_RANGE, calibration_range, 0.0f); } - explicit FirmwareUpdateStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_calibration_visuals(bool calibration_visuals) { + fbb_.AddElement(VRCConfigValues::VT_CALIBRATION_VISUALS, static_cast(calibration_visuals), 0); + } + void add_tracker_model(solarxr_protocol::rpc::VRCTrackerModel tracker_model) { + fbb_.AddElement(VRCConfigValues::VT_TRACKER_MODEL, static_cast(tracker_model), 0); + } + void add_spine_mode(solarxr_protocol::rpc::VRCSpineMode spine_mode) { + fbb_.AddElement(VRCConfigValues::VT_SPINE_MODE, static_cast(spine_mode), 0); + } + void add_avatar_measurement_type(solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type) { + fbb_.AddElement(VRCConfigValues::VT_AVATAR_MEASUREMENT_TYPE, static_cast(avatar_measurement_type), 0); + } + void add_shoulder_width_compensation(bool shoulder_width_compensation) { + fbb_.AddElement(VRCConfigValues::VT_SHOULDER_WIDTH_COMPENSATION, static_cast(shoulder_width_compensation), 0); + } + explicit VRCConfigValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateFirmwareUpdateStatusResponse( +inline flatbuffers::Offset CreateVRCConfigValues( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::FirmwareUpdateDeviceId device_id_type = solarxr_protocol::rpc::FirmwareUpdateDeviceId::NONE, - flatbuffers::Offset device_id = 0, - solarxr_protocol::rpc::FirmwareUpdateStatus status = solarxr_protocol::rpc::FirmwareUpdateStatus::DOWNLOADING, - int8_t progress = 0) { - FirmwareUpdateStatusResponseBuilder builder_(_fbb); - builder_.add_device_id(device_id); - builder_.add_progress(progress); - builder_.add_status(status); - builder_.add_device_id_type(device_id_type); + bool legacy_mode = false, + bool shoulder_tracking_disabled = false, + float user_height = 0.0f, + float calibration_range = 0.0f, + bool calibration_visuals = false, + solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, + solarxr_protocol::rpc::VRCSpineMode spine_mode = solarxr_protocol::rpc::VRCSpineMode::UNKNOWN, + solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, + bool shoulder_width_compensation = false) { + VRCConfigValuesBuilder builder_(_fbb); + builder_.add_calibration_range(calibration_range); + builder_.add_user_height(user_height); + builder_.add_shoulder_width_compensation(shoulder_width_compensation); + builder_.add_avatar_measurement_type(avatar_measurement_type); + builder_.add_spine_mode(spine_mode); + builder_.add_tracker_model(tracker_model); + builder_.add_calibration_visuals(calibration_visuals); + builder_.add_shoulder_tracking_disabled(shoulder_tracking_disabled); + builder_.add_legacy_mode(legacy_mode); return builder_.Finish(); } -struct FirmwareUpdateStopQueuesRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef FirmwareUpdateStopQueuesRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); +struct VRCConfigRecommendedValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigRecommendedValuesBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LEGACY_MODE = 4, + VT_SHOULDER_TRACKING_DISABLED = 6, + VT_USER_HEIGHT = 8, + VT_CALIBRATION_RANGE = 10, + VT_CALIBRATION_VISUALS = 12, + VT_TRACKER_MODEL = 14, + VT_SPINE_MODE = 16, + VT_AVATAR_MEASUREMENT_TYPE = 18, + VT_SHOULDER_WIDTH_COMPENSATION = 20 + }; + bool legacy_mode() const { + return GetField(VT_LEGACY_MODE, 0) != 0; } -}; - -struct FirmwareUpdateStopQueuesRequestBuilder { - typedef FirmwareUpdateStopQueuesRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit FirmwareUpdateStopQueuesRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + bool shoulder_tracking_disabled() const { + return GetField(VT_SHOULDER_TRACKING_DISABLED, 0) != 0; } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + float user_height() const { + return GetField(VT_USER_HEIGHT, 0.0f); + } + float calibration_range() const { + return GetField(VT_CALIBRATION_RANGE, 0.0f); + } + bool calibration_visuals() const { + return GetField(VT_CALIBRATION_VISUALS, 0) != 0; + } + solarxr_protocol::rpc::VRCTrackerModel tracker_model() const { + return static_cast(GetField(VT_TRACKER_MODEL, 0)); + } + const flatbuffers::Vector *spine_mode() const { + return GetPointer *>(VT_SPINE_MODE); + } + solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type() const { + return static_cast(GetField(VT_AVATAR_MEASUREMENT_TYPE, 0)); + } + bool shoulder_width_compensation() const { + return GetField(VT_SHOULDER_WIDTH_COMPENSATION, 0) != 0; } -}; - -inline flatbuffers::Offset CreateFirmwareUpdateStopQueuesRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - FirmwareUpdateStopQueuesRequestBuilder builder_(_fbb); - return builder_.Finish(); -} - -/// Requests the current state of tracking pause -struct TrackingPauseStateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingPauseStateRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_LEGACY_MODE, 1) && + VerifyField(verifier, VT_SHOULDER_TRACKING_DISABLED, 1) && + VerifyField(verifier, VT_USER_HEIGHT, 4) && + VerifyField(verifier, VT_CALIBRATION_RANGE, 4) && + VerifyField(verifier, VT_CALIBRATION_VISUALS, 1) && + VerifyField(verifier, VT_TRACKER_MODEL, 1) && + VerifyOffset(verifier, VT_SPINE_MODE) && + verifier.VerifyVector(spine_mode()) && + VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE, 1) && + VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION, 1) && verifier.EndTable(); } }; -struct TrackingPauseStateRequestBuilder { - typedef TrackingPauseStateRequest Table; +struct VRCConfigRecommendedValuesBuilder { + typedef VRCConfigRecommendedValues Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit TrackingPauseStateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_legacy_mode(bool legacy_mode) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_LEGACY_MODE, static_cast(legacy_mode), 0); + } + void add_shoulder_tracking_disabled(bool shoulder_tracking_disabled) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_SHOULDER_TRACKING_DISABLED, static_cast(shoulder_tracking_disabled), 0); + } + void add_user_height(float user_height) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_USER_HEIGHT, user_height, 0.0f); + } + void add_calibration_range(float calibration_range) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_CALIBRATION_RANGE, calibration_range, 0.0f); + } + void add_calibration_visuals(bool calibration_visuals) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_CALIBRATION_VISUALS, static_cast(calibration_visuals), 0); + } + void add_tracker_model(solarxr_protocol::rpc::VRCTrackerModel tracker_model) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_TRACKER_MODEL, static_cast(tracker_model), 0); + } + void add_spine_mode(flatbuffers::Offset> spine_mode) { + fbb_.AddOffset(VRCConfigRecommendedValues::VT_SPINE_MODE, spine_mode); + } + void add_avatar_measurement_type(solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_AVATAR_MEASUREMENT_TYPE, static_cast(avatar_measurement_type), 0); + } + void add_shoulder_width_compensation(bool shoulder_width_compensation) { + fbb_.AddElement(VRCConfigRecommendedValues::VT_SHOULDER_WIDTH_COMPENSATION, static_cast(shoulder_width_compensation), 0); + } + explicit VRCConfigRecommendedValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTrackingPauseStateRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - TrackingPauseStateRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateVRCConfigRecommendedValues( + flatbuffers::FlatBufferBuilder &_fbb, + bool legacy_mode = false, + bool shoulder_tracking_disabled = false, + float user_height = 0.0f, + float calibration_range = 0.0f, + bool calibration_visuals = false, + solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, + flatbuffers::Offset> spine_mode = 0, + solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, + bool shoulder_width_compensation = false) { + VRCConfigRecommendedValuesBuilder builder_(_fbb); + builder_.add_spine_mode(spine_mode); + builder_.add_calibration_range(calibration_range); + builder_.add_user_height(user_height); + builder_.add_shoulder_width_compensation(shoulder_width_compensation); + builder_.add_avatar_measurement_type(avatar_measurement_type); + builder_.add_tracker_model(tracker_model); + builder_.add_calibration_visuals(calibration_visuals); + builder_.add_shoulder_tracking_disabled(shoulder_tracking_disabled); + builder_.add_legacy_mode(legacy_mode); return builder_.Finish(); } -struct TrackingPauseStateResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingPauseStateResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKINGPAUSED = 4 - }; - /// Skeleton tracking is paused if true, skeleton tracking is unpaused if false. - bool trackingPaused() const { - return GetField(VT_TRACKINGPAUSED, 0) != 0; - } +inline flatbuffers::Offset CreateVRCConfigRecommendedValuesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool legacy_mode = false, + bool shoulder_tracking_disabled = false, + float user_height = 0.0f, + float calibration_range = 0.0f, + bool calibration_visuals = false, + solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, + const std::vector *spine_mode = nullptr, + solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, + bool shoulder_width_compensation = false) { + auto spine_mode__ = spine_mode ? _fbb.CreateVector(*spine_mode) : 0; + return solarxr_protocol::rpc::CreateVRCConfigRecommendedValues( + _fbb, + legacy_mode, + shoulder_tracking_disabled, + user_height, + calibration_range, + calibration_visuals, + tracker_model, + spine_mode__, + avatar_measurement_type, + shoulder_width_compensation); +} + +struct VRCConfigStateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigStateRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_TRACKINGPAUSED, 1) && verifier.EndTable(); } }; -struct TrackingPauseStateResponseBuilder { - typedef TrackingPauseStateResponse Table; +struct VRCConfigStateRequestBuilder { + typedef VRCConfigStateRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_trackingPaused(bool trackingPaused) { - fbb_.AddElement(TrackingPauseStateResponse::VT_TRACKINGPAUSED, static_cast(trackingPaused), 0); - } - explicit TrackingPauseStateResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCConfigStateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTrackingPauseStateResponse( - flatbuffers::FlatBufferBuilder &_fbb, - bool trackingPaused = false) { - TrackingPauseStateResponseBuilder builder_(_fbb); - builder_.add_trackingPaused(trackingPaused); +inline flatbuffers::Offset CreateVRCConfigStateRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + VRCConfigStateRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Sends the GET WIFISCAN cmd to the current tracker on the serial monitor -struct SerialTrackerGetWifiScanRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SerialTrackerGetWifiScanRequestBuilder Builder; +/// Sent every time the vrchat config state gets updated +/// used to display vrchat missconfig settings to the user +struct VRCConfigStateChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigStateChangeResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IS_SUPPORTED = 4, + VT_VALIDITY = 6, + VT_STATE = 8, + VT_RECOMMENDED = 10, + VT_MUTED = 12 + }; + bool is_supported() const { + return GetField(VT_IS_SUPPORTED, 0) != 0; + } + const solarxr_protocol::rpc::VRCConfigValidity *validity() const { + return GetPointer(VT_VALIDITY); + } + const solarxr_protocol::rpc::VRCConfigValues *state() const { + return GetPointer(VT_STATE); + } + const solarxr_protocol::rpc::VRCConfigRecommendedValues *recommended() const { + return GetPointer(VT_RECOMMENDED); + } + /// Just a list of keys from the VRCConfigValidity table. + const flatbuffers::Vector> *muted() const { + return GetPointer> *>(VT_MUTED); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && + VerifyField(verifier, VT_IS_SUPPORTED, 1) && + VerifyOffset(verifier, VT_VALIDITY) && + verifier.VerifyTable(validity()) && + VerifyOffset(verifier, VT_STATE) && + verifier.VerifyTable(state()) && + VerifyOffset(verifier, VT_RECOMMENDED) && + verifier.VerifyTable(recommended()) && + VerifyOffset(verifier, VT_MUTED) && + verifier.VerifyVector(muted()) && + verifier.VerifyVectorOfStrings(muted()) && verifier.EndTable(); } }; -struct SerialTrackerGetWifiScanRequestBuilder { - typedef SerialTrackerGetWifiScanRequest Table; +struct VRCConfigStateChangeResponseBuilder { + typedef VRCConfigStateChangeResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SerialTrackerGetWifiScanRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_is_supported(bool is_supported) { + fbb_.AddElement(VRCConfigStateChangeResponse::VT_IS_SUPPORTED, static_cast(is_supported), 0); + } + void add_validity(flatbuffers::Offset validity) { + fbb_.AddOffset(VRCConfigStateChangeResponse::VT_VALIDITY, validity); + } + void add_state(flatbuffers::Offset state) { + fbb_.AddOffset(VRCConfigStateChangeResponse::VT_STATE, state); + } + void add_recommended(flatbuffers::Offset recommended) { + fbb_.AddOffset(VRCConfigStateChangeResponse::VT_RECOMMENDED, recommended); + } + void add_muted(flatbuffers::Offset>> muted) { + fbb_.AddOffset(VRCConfigStateChangeResponse::VT_MUTED, muted); + } + explicit VRCConfigStateChangeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSerialTrackerGetWifiScanRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - SerialTrackerGetWifiScanRequestBuilder builder_(_fbb); +inline flatbuffers::Offset CreateVRCConfigStateChangeResponse( + flatbuffers::FlatBufferBuilder &_fbb, + bool is_supported = false, + flatbuffers::Offset validity = 0, + flatbuffers::Offset state = 0, + flatbuffers::Offset recommended = 0, + flatbuffers::Offset>> muted = 0) { + VRCConfigStateChangeResponseBuilder builder_(_fbb); + builder_.add_muted(muted); + builder_.add_recommended(recommended); + builder_.add_state(state); + builder_.add_validity(validity); + builder_.add_is_supported(is_supported); return builder_.Finish(); } -/// Server notifies connection of an unknown device. -/// If the notification is no longer sent, it means the device connected to another -/// server, got connected to this server or it was turned off. -struct UnknownDeviceHandshakeNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UnknownDeviceHandshakeNotificationBuilder Builder; +inline flatbuffers::Offset CreateVRCConfigStateChangeResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool is_supported = false, + flatbuffers::Offset validity = 0, + flatbuffers::Offset state = 0, + flatbuffers::Offset recommended = 0, + const std::vector> *muted = nullptr) { + auto muted__ = muted ? _fbb.CreateVector>(*muted) : 0; + return solarxr_protocol::rpc::CreateVRCConfigStateChangeResponse( + _fbb, + is_supported, + validity, + state, + recommended, + muted__); +} + +struct VRCConfigSettingToggleMute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigSettingToggleMuteBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MAC_ADDRESS = 4 + VT_KEY = 4 }; - const flatbuffers::String *mac_address() const { - return GetPointer(VT_MAC_ADDRESS); + /// Key from VRCConfigValidity + const flatbuffers::String *key() const { + return GetPointer(VT_KEY); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_MAC_ADDRESS) && - verifier.VerifyString(mac_address()) && + VerifyOffset(verifier, VT_KEY) && + verifier.VerifyString(key()) && verifier.EndTable(); } }; -struct UnknownDeviceHandshakeNotificationBuilder { - typedef UnknownDeviceHandshakeNotification Table; +struct VRCConfigSettingToggleMuteBuilder { + typedef VRCConfigSettingToggleMute Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_mac_address(flatbuffers::Offset mac_address) { - fbb_.AddOffset(UnknownDeviceHandshakeNotification::VT_MAC_ADDRESS, mac_address); + void add_key(flatbuffers::Offset key) { + fbb_.AddOffset(VRCConfigSettingToggleMute::VT_KEY, key); } - explicit UnknownDeviceHandshakeNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCConfigSettingToggleMuteBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUnknownDeviceHandshakeNotification( +inline flatbuffers::Offset CreateVRCConfigSettingToggleMute( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset mac_address = 0) { - UnknownDeviceHandshakeNotificationBuilder builder_(_fbb); - builder_.add_mac_address(mac_address); + flatbuffers::Offset key = 0) { + VRCConfigSettingToggleMuteBuilder builder_(_fbb); + builder_.add_key(key); return builder_.Finish(); } -inline flatbuffers::Offset CreateUnknownDeviceHandshakeNotificationDirect( +inline flatbuffers::Offset CreateVRCConfigSettingToggleMuteDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *mac_address = nullptr) { - auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; - return solarxr_protocol::rpc::CreateUnknownDeviceHandshakeNotification( + const char *key = nullptr) { + auto key__ = key ? _fbb.CreateString(key) : 0; + return solarxr_protocol::rpc::CreateVRCConfigSettingToggleMute( _fbb, - mac_address__); + key__); } -struct AddUnknownDeviceRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef AddUnknownDeviceRequestBuilder Builder; +struct VRCOSCNetworkSettings FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCNetworkSettingsBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MAC_ADDRESS = 4 + VT_PORT_IN = 4, + VT_PORT_OUT = 6, + VT_ADDRESS = 8 }; - const flatbuffers::String *mac_address() const { - return GetPointer(VT_MAC_ADDRESS); + uint16_t port_in() const { + return GetField(VT_PORT_IN, 0); + } + uint16_t port_out() const { + return GetField(VT_PORT_OUT, 0); + } + const flatbuffers::String *address() const { + return GetPointer(VT_ADDRESS); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_MAC_ADDRESS) && - verifier.VerifyString(mac_address()) && + VerifyField(verifier, VT_PORT_IN, 2) && + VerifyField(verifier, VT_PORT_OUT, 2) && + VerifyOffset(verifier, VT_ADDRESS) && + verifier.VerifyString(address()) && verifier.EndTable(); } }; -struct AddUnknownDeviceRequestBuilder { - typedef AddUnknownDeviceRequest Table; +struct VRCOSCNetworkSettingsBuilder { + typedef VRCOSCNetworkSettings Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_mac_address(flatbuffers::Offset mac_address) { - fbb_.AddOffset(AddUnknownDeviceRequest::VT_MAC_ADDRESS, mac_address); + void add_port_in(uint16_t port_in) { + fbb_.AddElement(VRCOSCNetworkSettings::VT_PORT_IN, port_in, 0); } - explicit AddUnknownDeviceRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_port_out(uint16_t port_out) { + fbb_.AddElement(VRCOSCNetworkSettings::VT_PORT_OUT, port_out, 0); + } + void add_address(flatbuffers::Offset address) { + fbb_.AddOffset(VRCOSCNetworkSettings::VT_ADDRESS, address); + } + explicit VRCOSCNetworkSettingsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateAddUnknownDeviceRequest( +inline flatbuffers::Offset CreateVRCOSCNetworkSettings( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset mac_address = 0) { - AddUnknownDeviceRequestBuilder builder_(_fbb); - builder_.add_mac_address(mac_address); + uint16_t port_in = 0, + uint16_t port_out = 0, + flatbuffers::Offset address = 0) { + VRCOSCNetworkSettingsBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_port_out(port_out); + builder_.add_port_in(port_in); return builder_.Finish(); } -inline flatbuffers::Offset CreateAddUnknownDeviceRequestDirect( +inline flatbuffers::Offset CreateVRCOSCNetworkSettingsDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *mac_address = nullptr) { - auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; - return solarxr_protocol::rpc::CreateAddUnknownDeviceRequest( + uint16_t port_in = 0, + uint16_t port_out = 0, + const char *address = nullptr) { + auto address__ = address ? _fbb.CreateString(address) : 0; + return solarxr_protocol::rpc::CreateVRCOSCNetworkSettings( _fbb, - mac_address__); + port_in, + port_out, + address__); } -struct ForgetDeviceRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ForgetDeviceRequestBuilder Builder; +struct VRCOSCDiscoveredTarget FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCDiscoveredTargetBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_MAC_ADDRESS = 4 + VT_NAME = 4, + VT_ADDRESS = 6, + VT_PORT_OUT = 8 }; - const flatbuffers::String *mac_address() const { - return GetPointer(VT_MAC_ADDRESS); + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const flatbuffers::String *address() const { + return GetPointer(VT_ADDRESS); + } + uint16_t port_out() const { + return GetField(VT_PORT_OUT, 0); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_MAC_ADDRESS) && - verifier.VerifyString(mac_address()) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_ADDRESS) && + verifier.VerifyString(address()) && + VerifyField(verifier, VT_PORT_OUT, 2) && verifier.EndTable(); } }; -struct ForgetDeviceRequestBuilder { - typedef ForgetDeviceRequest Table; +struct VRCOSCDiscoveredTargetBuilder { + typedef VRCOSCDiscoveredTarget Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_mac_address(flatbuffers::Offset mac_address) { - fbb_.AddOffset(ForgetDeviceRequest::VT_MAC_ADDRESS, mac_address); + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(VRCOSCDiscoveredTarget::VT_NAME, name); } - explicit ForgetDeviceRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_address(flatbuffers::Offset address) { + fbb_.AddOffset(VRCOSCDiscoveredTarget::VT_ADDRESS, address); + } + void add_port_out(uint16_t port_out) { + fbb_.AddElement(VRCOSCDiscoveredTarget::VT_PORT_OUT, port_out, 0); + } + explicit VRCOSCDiscoveredTargetBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateForgetDeviceRequest( +inline flatbuffers::Offset CreateVRCOSCDiscoveredTarget( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset mac_address = 0) { - ForgetDeviceRequestBuilder builder_(_fbb); - builder_.add_mac_address(mac_address); + flatbuffers::Offset name = 0, + flatbuffers::Offset address = 0, + uint16_t port_out = 0) { + VRCOSCDiscoveredTargetBuilder builder_(_fbb); + builder_.add_address(address); + builder_.add_name(name); + builder_.add_port_out(port_out); return builder_.Finish(); } -inline flatbuffers::Offset CreateForgetDeviceRequestDirect( +inline flatbuffers::Offset CreateVRCOSCDiscoveredTargetDirect( flatbuffers::FlatBufferBuilder &_fbb, - const char *mac_address = nullptr) { - auto mac_address__ = mac_address ? _fbb.CreateString(mac_address) : 0; - return solarxr_protocol::rpc::CreateForgetDeviceRequest( + const char *name = nullptr, + const char *address = nullptr, + uint16_t port_out = 0) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto address__ = address ? _fbb.CreateString(address) : 0; + return solarxr_protocol::rpc::CreateVRCOSCDiscoveredTarget( _fbb, - mac_address__); + name__, + address__, + port_out); } -struct SettingsResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SettingsResetRequestBuilder Builder; +struct VRCOSCStatusRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCStatusRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct SettingsResetRequestBuilder { - typedef SettingsResetRequest Table; +struct VRCOSCStatusRequestBuilder { + typedef VRCOSCStatusRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit SettingsResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCOSCStatusRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSettingsResetRequest( +inline flatbuffers::Offset CreateVRCOSCStatusRequest( flatbuffers::FlatBufferBuilder &_fbb) { - SettingsResetRequestBuilder builder_(_fbb); + VRCOSCStatusRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// If no tracker ID is given, it's the setting for every tracker/device -struct MagToggleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef MagToggleRequestBuilder Builder; +struct VRCOSCStatusChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCStatusChangeResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 + VT_ENABLED = 4, + VT_INPUT_STATE = 6, + VT_INPUT_PORT = 8, + VT_INPUT_ERROR = 10, + VT_LAST_RECEIVED_INPUT_MILLIS = 12, + VT_OUTPUT_STATE = 14, + VT_OUTPUT_ERROR = 16, + VT_TARGET_ADDRESS = 18, + VT_TARGET_PORT = 20, + VT_TARGET_SOURCE = 22, + VT_LAST_FRAME_SENT_MILLIS = 24, + VT_OSCQUERY_STATE = 26, + VT_OSCQUERY_ADVERTISED_PORT = 28, + VT_OSCQUERY_ERROR = 30, + VT_DISCOVERED_TARGETS = 32 }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + solarxr_protocol::rpc::VRCOSCInputState input_state() const { + return static_cast(GetField(VT_INPUT_STATE, 0)); + } + flatbuffers::Optional input_port() const { + return GetOptional(VT_INPUT_PORT); + } + const flatbuffers::String *input_error() const { + return GetPointer(VT_INPUT_ERROR); + } + flatbuffers::Optional last_received_input_millis() const { + return GetOptional(VT_LAST_RECEIVED_INPUT_MILLIS); + } + solarxr_protocol::rpc::VRCOSCOutputState output_state() const { + return static_cast(GetField(VT_OUTPUT_STATE, 0)); + } + const flatbuffers::String *output_error() const { + return GetPointer(VT_OUTPUT_ERROR); + } + const flatbuffers::String *target_address() const { + return GetPointer(VT_TARGET_ADDRESS); + } + flatbuffers::Optional target_port() const { + return GetOptional(VT_TARGET_PORT); + } + solarxr_protocol::rpc::VRCOSCTargetSource target_source() const { + return static_cast(GetField(VT_TARGET_SOURCE, 0)); + } + flatbuffers::Optional last_frame_sent_millis() const { + return GetOptional(VT_LAST_FRAME_SENT_MILLIS); + } + solarxr_protocol::rpc::VRCOSCOscQueryState oscquery_state() const { + return static_cast(GetField(VT_OSCQUERY_STATE, 0)); + } + flatbuffers::Optional oscquery_advertised_port() const { + return GetOptional(VT_OSCQUERY_ADVERTISED_PORT); + } + const flatbuffers::String *oscquery_error() const { + return GetPointer(VT_OSCQUERY_ERROR); + } + const flatbuffers::Vector> *discovered_targets() const { + return GetPointer> *>(VT_DISCOVERED_TARGETS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_INPUT_STATE, 1) && + VerifyField(verifier, VT_INPUT_PORT, 2) && + VerifyOffset(verifier, VT_INPUT_ERROR) && + verifier.VerifyString(input_error()) && + VerifyField(verifier, VT_LAST_RECEIVED_INPUT_MILLIS, 8) && + VerifyField(verifier, VT_OUTPUT_STATE, 1) && + VerifyOffset(verifier, VT_OUTPUT_ERROR) && + verifier.VerifyString(output_error()) && + VerifyOffset(verifier, VT_TARGET_ADDRESS) && + verifier.VerifyString(target_address()) && + VerifyField(verifier, VT_TARGET_PORT, 2) && + VerifyField(verifier, VT_TARGET_SOURCE, 1) && + VerifyField(verifier, VT_LAST_FRAME_SENT_MILLIS, 8) && + VerifyField(verifier, VT_OSCQUERY_STATE, 1) && + VerifyField(verifier, VT_OSCQUERY_ADVERTISED_PORT, 2) && + VerifyOffset(verifier, VT_OSCQUERY_ERROR) && + verifier.VerifyString(oscquery_error()) && + VerifyOffset(verifier, VT_DISCOVERED_TARGETS) && + verifier.VerifyVector(discovered_targets()) && + verifier.VerifyVectorOfTables(discovered_targets()) && + verifier.EndTable(); + } +}; + +struct VRCOSCStatusChangeResponseBuilder { + typedef VRCOSCStatusChangeResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_enabled(bool enabled) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_ENABLED, static_cast(enabled), 0); + } + void add_input_state(solarxr_protocol::rpc::VRCOSCInputState input_state) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_INPUT_STATE, static_cast(input_state), 0); + } + void add_input_port(uint16_t input_port) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_INPUT_PORT, input_port); + } + void add_input_error(flatbuffers::Offset input_error) { + fbb_.AddOffset(VRCOSCStatusChangeResponse::VT_INPUT_ERROR, input_error); + } + void add_last_received_input_millis(uint64_t last_received_input_millis) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_LAST_RECEIVED_INPUT_MILLIS, last_received_input_millis); + } + void add_output_state(solarxr_protocol::rpc::VRCOSCOutputState output_state) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_OUTPUT_STATE, static_cast(output_state), 0); + } + void add_output_error(flatbuffers::Offset output_error) { + fbb_.AddOffset(VRCOSCStatusChangeResponse::VT_OUTPUT_ERROR, output_error); + } + void add_target_address(flatbuffers::Offset target_address) { + fbb_.AddOffset(VRCOSCStatusChangeResponse::VT_TARGET_ADDRESS, target_address); + } + void add_target_port(uint16_t target_port) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_TARGET_PORT, target_port); + } + void add_target_source(solarxr_protocol::rpc::VRCOSCTargetSource target_source) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_TARGET_SOURCE, static_cast(target_source), 0); + } + void add_last_frame_sent_millis(uint64_t last_frame_sent_millis) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_LAST_FRAME_SENT_MILLIS, last_frame_sent_millis); + } + void add_oscquery_state(solarxr_protocol::rpc::VRCOSCOscQueryState oscquery_state) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_OSCQUERY_STATE, static_cast(oscquery_state), 0); + } + void add_oscquery_advertised_port(uint16_t oscquery_advertised_port) { + fbb_.AddElement(VRCOSCStatusChangeResponse::VT_OSCQUERY_ADVERTISED_PORT, oscquery_advertised_port); + } + void add_oscquery_error(flatbuffers::Offset oscquery_error) { + fbb_.AddOffset(VRCOSCStatusChangeResponse::VT_OSCQUERY_ERROR, oscquery_error); + } + void add_discovered_targets(flatbuffers::Offset>> discovered_targets) { + fbb_.AddOffset(VRCOSCStatusChangeResponse::VT_DISCOVERED_TARGETS, discovered_targets); + } + explicit VRCOSCStatusChangeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateVRCOSCStatusChangeResponse( + flatbuffers::FlatBufferBuilder &_fbb, + bool enabled = false, + solarxr_protocol::rpc::VRCOSCInputState input_state = solarxr_protocol::rpc::VRCOSCInputState::IDLE, + flatbuffers::Optional input_port = flatbuffers::nullopt, + flatbuffers::Offset input_error = 0, + flatbuffers::Optional last_received_input_millis = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCOutputState output_state = solarxr_protocol::rpc::VRCOSCOutputState::IDLE, + flatbuffers::Offset output_error = 0, + flatbuffers::Offset target_address = 0, + flatbuffers::Optional target_port = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCTargetSource target_source = solarxr_protocol::rpc::VRCOSCTargetSource::NONE, + flatbuffers::Optional last_frame_sent_millis = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCOscQueryState oscquery_state = solarxr_protocol::rpc::VRCOSCOscQueryState::DISABLED, + flatbuffers::Optional oscquery_advertised_port = flatbuffers::nullopt, + flatbuffers::Offset oscquery_error = 0, + flatbuffers::Offset>> discovered_targets = 0) { + VRCOSCStatusChangeResponseBuilder builder_(_fbb); + if(last_frame_sent_millis) { builder_.add_last_frame_sent_millis(*last_frame_sent_millis); } + if(last_received_input_millis) { builder_.add_last_received_input_millis(*last_received_input_millis); } + builder_.add_discovered_targets(discovered_targets); + builder_.add_oscquery_error(oscquery_error); + builder_.add_target_address(target_address); + builder_.add_output_error(output_error); + builder_.add_input_error(input_error); + if(oscquery_advertised_port) { builder_.add_oscquery_advertised_port(*oscquery_advertised_port); } + if(target_port) { builder_.add_target_port(*target_port); } + if(input_port) { builder_.add_input_port(*input_port); } + builder_.add_oscquery_state(oscquery_state); + builder_.add_target_source(target_source); + builder_.add_output_state(output_state); + builder_.add_input_state(input_state); + builder_.add_enabled(enabled); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateVRCOSCStatusChangeResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool enabled = false, + solarxr_protocol::rpc::VRCOSCInputState input_state = solarxr_protocol::rpc::VRCOSCInputState::IDLE, + flatbuffers::Optional input_port = flatbuffers::nullopt, + const char *input_error = nullptr, + flatbuffers::Optional last_received_input_millis = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCOutputState output_state = solarxr_protocol::rpc::VRCOSCOutputState::IDLE, + const char *output_error = nullptr, + const char *target_address = nullptr, + flatbuffers::Optional target_port = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCTargetSource target_source = solarxr_protocol::rpc::VRCOSCTargetSource::NONE, + flatbuffers::Optional last_frame_sent_millis = flatbuffers::nullopt, + solarxr_protocol::rpc::VRCOSCOscQueryState oscquery_state = solarxr_protocol::rpc::VRCOSCOscQueryState::DISABLED, + flatbuffers::Optional oscquery_advertised_port = flatbuffers::nullopt, + const char *oscquery_error = nullptr, + const std::vector> *discovered_targets = nullptr) { + auto input_error__ = input_error ? _fbb.CreateString(input_error) : 0; + auto output_error__ = output_error ? _fbb.CreateString(output_error) : 0; + auto target_address__ = target_address ? _fbb.CreateString(target_address) : 0; + auto oscquery_error__ = oscquery_error ? _fbb.CreateString(oscquery_error) : 0; + auto discovered_targets__ = discovered_targets ? _fbb.CreateVector>(*discovered_targets) : 0; + return solarxr_protocol::rpc::CreateVRCOSCStatusChangeResponse( + _fbb, + enabled, + input_state, + input_port, + input_error__, + last_received_input_millis, + output_state, + output_error__, + target_address__, + target_port, + target_source, + last_frame_sent_millis, + oscquery_state, + oscquery_advertised_port, + oscquery_error__, + discovered_targets__); +} + +struct VRCOSCSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCSettingsRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && verifier.EndTable(); } }; -struct MagToggleRequestBuilder { - typedef MagToggleRequest Table; +struct VRCOSCSettingsRequestBuilder { + typedef VRCOSCSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(MagToggleRequest::VT_TRACKER_ID, tracker_id); - } - explicit MagToggleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCOSCSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMagToggleRequest( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { - MagToggleRequestBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); +inline flatbuffers::Offset CreateVRCOSCSettingsRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + VRCOSCSettingsRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// If no tracker ID is given, it's the setting for every tracker/device -struct MagToggleResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef MagToggleResponseBuilder Builder; +struct VRCOSCSettingsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCOSCSettingsResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4, - VT_ENABLE = 6 + VT_ENABLED = 4, + VT_MANUAL_NETWORK = 6 }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; } - bool enable() const { - return GetField(VT_ENABLE, 0) != 0; + const solarxr_protocol::rpc::VRCOSCNetworkSettings *manual_network() const { + return GetPointer(VT_MANUAL_NETWORK); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && - VerifyField(verifier, VT_ENABLE, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyOffset(verifier, VT_MANUAL_NETWORK) && + verifier.VerifyTable(manual_network()) && verifier.EndTable(); } }; -struct MagToggleResponseBuilder { - typedef MagToggleResponse Table; +struct VRCOSCSettingsResponseBuilder { + typedef VRCOSCSettingsResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(MagToggleResponse::VT_TRACKER_ID, tracker_id); + void add_enabled(bool enabled) { + fbb_.AddElement(VRCOSCSettingsResponse::VT_ENABLED, static_cast(enabled), 0); } - void add_enable(bool enable) { - fbb_.AddElement(MagToggleResponse::VT_ENABLE, static_cast(enable), 0); + void add_manual_network(flatbuffers::Offset manual_network) { + fbb_.AddOffset(VRCOSCSettingsResponse::VT_MANUAL_NETWORK, manual_network); } - explicit MagToggleResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCOSCSettingsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMagToggleResponse( +inline flatbuffers::Offset CreateVRCOSCSettingsResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0, - bool enable = false) { - MagToggleResponseBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); - builder_.add_enable(enable); + bool enabled = false, + flatbuffers::Offset manual_network = 0) { + VRCOSCSettingsResponseBuilder builder_(_fbb); + builder_.add_manual_network(manual_network); + builder_.add_enabled(enabled); return builder_.Finish(); } -/// If no tracker ID is given, it's the setting for every tracker/device -struct ChangeMagToggleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ChangeMagToggleRequestBuilder Builder; +struct ChangeVRCOSCSettingsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeVRCOSCSettingsRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4, - VT_ENABLE = 6 + VT_ENABLED = 4, + VT_MANUAL_NETWORK = 6 }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; } - bool enable() const { - return GetField(VT_ENABLE, 0) != 0; + const solarxr_protocol::rpc::VRCOSCNetworkSettings *manual_network() const { + return GetPointer(VT_MANUAL_NETWORK); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && - VerifyField(verifier, VT_ENABLE, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyOffset(verifier, VT_MANUAL_NETWORK) && + verifier.VerifyTable(manual_network()) && verifier.EndTable(); } }; -struct ChangeMagToggleRequestBuilder { - typedef ChangeMagToggleRequest Table; +struct ChangeVRCOSCSettingsRequestBuilder { + typedef ChangeVRCOSCSettingsRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(ChangeMagToggleRequest::VT_TRACKER_ID, tracker_id); + void add_enabled(bool enabled) { + fbb_.AddElement(ChangeVRCOSCSettingsRequest::VT_ENABLED, static_cast(enabled), 0); } - void add_enable(bool enable) { - fbb_.AddElement(ChangeMagToggleRequest::VT_ENABLE, static_cast(enable), 0); + void add_manual_network(flatbuffers::Offset manual_network) { + fbb_.AddOffset(ChangeVRCOSCSettingsRequest::VT_MANUAL_NETWORK, manual_network); } - explicit ChangeMagToggleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ChangeVRCOSCSettingsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateChangeMagToggleRequest( +inline flatbuffers::Offset CreateChangeVRCOSCSettingsRequest( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0, - bool enable = false) { - ChangeMagToggleRequestBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); - builder_.add_enable(enable); + bool enabled = false, + flatbuffers::Offset manual_network = 0) { + ChangeVRCOSCSettingsRequestBuilder builder_(_fbb); + builder_.add_manual_network(manual_network); + builder_.add_enabled(enabled); return builder_.Finish(); } -struct VRCConfigValidity FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigValidityBuilder Builder; +struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RpcMessageHeaderBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LEGACY_MODE_OK = 4, - VT_SHOULDER_TRACKING_OK = 6, - VT_USER_HEIGHT_OK = 8, - VT_CALIBRATION_RANGE_OK = 10, - VT_CALIBRATION_VISUALS_OK = 12, - VT_TRACKER_MODEL_OK = 14, - VT_SPINE_MODE_OK = 16, - VT_AVATAR_MEASUREMENT_TYPE_OK = 18, - VT_SHOULDER_WIDTH_COMPENSATION_OK = 20 + VT_TX_ID = 4, + VT_MESSAGE_TYPE = 6, + VT_MESSAGE = 8 }; - bool legacy_mode_ok() const { - return GetField(VT_LEGACY_MODE_OK, 0) != 0; + /// For a request, this identifies the request. + /// For a response, this corresponds to the request that it is responding to. + const solarxr_protocol::datatypes::TransactionId *tx_id() const { + return GetStruct(VT_TX_ID); } - bool shoulder_tracking_ok() const { - return GetField(VT_SHOULDER_TRACKING_OK, 0) != 0; + solarxr_protocol::rpc::RpcMessage message_type() const { + return static_cast(GetField(VT_MESSAGE_TYPE, 0)); } - bool user_height_ok() const { - return GetField(VT_USER_HEIGHT_OK, 0) != 0; + const void *message() const { + return GetPointer(VT_MESSAGE); } - bool calibration_range_ok() const { - return GetField(VT_CALIBRATION_RANGE_OK, 0) != 0; + template const T *message_as() const; + const solarxr_protocol::rpc::HeartbeatRequest *message_as_HeartbeatRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HeartbeatRequest ? static_cast(message()) : nullptr; } - bool calibration_visuals_ok() const { - return GetField(VT_CALIBRATION_VISUALS_OK, 0) != 0; + const solarxr_protocol::rpc::HeartbeatResponse *message_as_HeartbeatResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HeartbeatResponse ? static_cast(message()) : nullptr; } - bool tracker_model_ok() const { - return GetField(VT_TRACKER_MODEL_OK, 0) != 0; + const solarxr_protocol::rpc::ResetRequest *message_as_ResetRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ResetRequest ? static_cast(message()) : nullptr; } - bool spine_mode_ok() const { - return GetField(VT_SPINE_MODE_OK, 0) != 0; + const solarxr_protocol::rpc::ResetResponse *message_as_ResetResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ResetResponse ? static_cast(message()) : nullptr; } - bool avatar_measurement_type_ok() const { - return GetField(VT_AVATAR_MEASUREMENT_TYPE_OK, 0) != 0; + const solarxr_protocol::rpc::AssignTrackerRequest *message_as_AssignTrackerRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AssignTrackerRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OutputTrackersSettingsRequest *message_as_OutputTrackersSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OutputTrackersSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OutputTrackersSettingsResponse *message_as_OutputTrackersSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OutputTrackersSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeOutputTrackersSettingsRequest *message_as_ChangeOutputTrackersSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeOutputTrackersSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::VMCOSCSettingsRequest *message_as_VMCOSCSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VMCOSCSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::VMCOSCSettingsResponse *message_as_VMCOSCSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VMCOSCSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeVMCOSCSettingsRequest *message_as_ChangeVMCOSCSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeVMCOSCSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::VRMSettingsRequest *message_as_VRMSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRMSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::VRMSettingsResponse *message_as_VRMSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRMSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeVRMSettingsRequest *message_as_ChangeVRMSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeVRMSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SkeletonSettingsRequest *message_as_SkeletonSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SkeletonSettingsResponse *message_as_SkeletonSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeSkeletonSettingsRequest *message_as_ChangeSkeletonSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeSkeletonSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::TapDetectionSettingsRequest *message_as_TapDetectionSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TapDetectionSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::TapDetectionSettingsResponse *message_as_TapDetectionSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TapDetectionSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeTapDetectionSettingsRequest *message_as_ChangeTapDetectionSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeTapDetectionSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::TapDetectionSetupModeRequest *message_as_TapDetectionSetupModeRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TapDetectionSetupModeRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ResetsSettingsRequest *message_as_ResetsSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ResetsSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ResetsSettingsResponse *message_as_ResetsSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ResetsSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeResetsSettingsRequest *message_as_ChangeResetsSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeResetsSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::StayAlignedSettingsRequest *message_as_StayAlignedSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StayAlignedSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::StayAlignedSettingsResponse *message_as_StayAlignedSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StayAlignedSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeStayAlignedSettingsRequest *message_as_ChangeStayAlignedSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeStayAlignedSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::CompleteStayAlignedResponse *message_as_CompleteStayAlignedResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::CompleteStayAlignedResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::StayAlignedHideCorrectionRequest *message_as_StayAlignedHideCorrectionRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StayAlignedHideCorrectionRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::HIDSettingsRequest *message_as_HIDSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HIDSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::HIDSettingsResponse *message_as_HIDSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HIDSettingsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeHIDSettingsRequest *message_as_ChangeHIDSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeHIDSettingsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::RecordBVHRequest *message_as_RecordBVHRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::RecordBVHStatus *message_as_RecordBVHStatus() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHStatus ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SkeletonProportionsRequest *message_as_SkeletonProportionsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonProportionsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeSkeletonProportionsRequest *message_as_ChangeSkeletonProportionsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeSkeletonProportionsRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SkeletonProportionsResetAllRequest *message_as_SkeletonProportionsResetAllRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonProportionsResetAllRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SkeletonProportionsResponse *message_as_SkeletonProportionsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SkeletonProportionsResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OpenSerialRequest *message_as_OpenSerialRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OpenSerialRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::CloseSerialRequest *message_as_CloseSerialRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::CloseSerialRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::SerialUpdateResponse *message_as_SerialUpdateResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialUpdateResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::AutoBoneProcessRequest *message_as_AutoBoneProcessRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneProcessRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::AutoBoneProcessStatusResponse *message_as_AutoBoneProcessStatusResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneProcessStatusResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::AutoBoneEpochResponse *message_as_AutoBoneEpochResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneEpochResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OverlayDisplayModeRequest *message_as_OverlayDisplayModeRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OverlayDisplayModeChangeRequest *message_as_OverlayDisplayModeChangeRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeChangeRequest ? static_cast(message()) : nullptr; } - bool shoulder_width_compensation_ok() const { - return GetField(VT_SHOULDER_WIDTH_COMPENSATION_OK, 0) != 0; + const solarxr_protocol::rpc::OverlayDisplayModeResponse *message_as_OverlayDisplayModeResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OverlayDisplayModeResponse ? static_cast(message()) : nullptr; } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_LEGACY_MODE_OK, 1) && - VerifyField(verifier, VT_SHOULDER_TRACKING_OK, 1) && - VerifyField(verifier, VT_USER_HEIGHT_OK, 1) && - VerifyField(verifier, VT_CALIBRATION_RANGE_OK, 1) && - VerifyField(verifier, VT_CALIBRATION_VISUALS_OK, 1) && - VerifyField(verifier, VT_TRACKER_MODEL_OK, 1) && - VerifyField(verifier, VT_SPINE_MODE_OK, 1) && - VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE_OK, 1) && - VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION_OK, 1) && - verifier.EndTable(); + const solarxr_protocol::rpc::SerialTrackerRebootRequest *message_as_SerialTrackerRebootRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerRebootRequest ? static_cast(message()) : nullptr; } -}; - -struct VRCConfigValidityBuilder { - typedef VRCConfigValidity Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_legacy_mode_ok(bool legacy_mode_ok) { - fbb_.AddElement(VRCConfigValidity::VT_LEGACY_MODE_OK, static_cast(legacy_mode_ok), 0); + const solarxr_protocol::rpc::SerialTrackerGetInfoRequest *message_as_SerialTrackerGetInfoRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerGetInfoRequest ? static_cast(message()) : nullptr; } - void add_shoulder_tracking_ok(bool shoulder_tracking_ok) { - fbb_.AddElement(VRCConfigValidity::VT_SHOULDER_TRACKING_OK, static_cast(shoulder_tracking_ok), 0); + const solarxr_protocol::rpc::SerialTrackerFactoryResetRequest *message_as_SerialTrackerFactoryResetRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerFactoryResetRequest ? static_cast(message()) : nullptr; } - void add_user_height_ok(bool user_height_ok) { - fbb_.AddElement(VRCConfigValidity::VT_USER_HEIGHT_OK, static_cast(user_height_ok), 0); + const solarxr_protocol::rpc::SerialDevicesRequest *message_as_SerialDevicesRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialDevicesRequest ? static_cast(message()) : nullptr; } - void add_calibration_range_ok(bool calibration_range_ok) { - fbb_.AddElement(VRCConfigValidity::VT_CALIBRATION_RANGE_OK, static_cast(calibration_range_ok), 0); + const solarxr_protocol::rpc::SerialDevicesResponse *message_as_SerialDevicesResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialDevicesResponse ? static_cast(message()) : nullptr; } - void add_calibration_visuals_ok(bool calibration_visuals_ok) { - fbb_.AddElement(VRCConfigValidity::VT_CALIBRATION_VISUALS_OK, static_cast(calibration_visuals_ok), 0); + const solarxr_protocol::rpc::NewSerialDeviceResponse *message_as_NewSerialDeviceResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::NewSerialDeviceResponse ? static_cast(message()) : nullptr; } - void add_tracker_model_ok(bool tracker_model_ok) { - fbb_.AddElement(VRCConfigValidity::VT_TRACKER_MODEL_OK, static_cast(tracker_model_ok), 0); + const solarxr_protocol::rpc::StartWifiProvisioningRequest *message_as_StartWifiProvisioningRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StartWifiProvisioningRequest ? static_cast(message()) : nullptr; } - void add_spine_mode_ok(bool spine_mode_ok) { - fbb_.AddElement(VRCConfigValidity::VT_SPINE_MODE_OK, static_cast(spine_mode_ok), 0); + const solarxr_protocol::rpc::StopWifiProvisioningRequest *message_as_StopWifiProvisioningRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StopWifiProvisioningRequest ? static_cast(message()) : nullptr; } - void add_avatar_measurement_type_ok(bool avatar_measurement_type_ok) { - fbb_.AddElement(VRCConfigValidity::VT_AVATAR_MEASUREMENT_TYPE_OK, static_cast(avatar_measurement_type_ok), 0); + const solarxr_protocol::rpc::WifiProvisioningStatusResponse *message_as_WifiProvisioningStatusResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::WifiProvisioningStatusResponse ? static_cast(message()) : nullptr; } - void add_shoulder_width_compensation_ok(bool shoulder_width_compensation_ok) { - fbb_.AddElement(VRCConfigValidity::VT_SHOULDER_WIDTH_COMPENSATION_OK, static_cast(shoulder_width_compensation_ok), 0); + const solarxr_protocol::rpc::ServerInfosRequest *message_as_ServerInfosRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ServerInfosRequest ? static_cast(message()) : nullptr; } - explicit VRCConfigValidityBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + const solarxr_protocol::rpc::ServerInfosResponse *message_as_ServerInfosResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ServerInfosResponse ? static_cast(message()) : nullptr; } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + const solarxr_protocol::rpc::LegTweaksTmpChange *message_as_LegTweaksTmpChange() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::LegTweaksTmpChange ? static_cast(message()) : nullptr; } -}; - -inline flatbuffers::Offset CreateVRCConfigValidity( - flatbuffers::FlatBufferBuilder &_fbb, - bool legacy_mode_ok = false, - bool shoulder_tracking_ok = false, - bool user_height_ok = false, - bool calibration_range_ok = false, - bool calibration_visuals_ok = false, - bool tracker_model_ok = false, - bool spine_mode_ok = false, - bool avatar_measurement_type_ok = false, - bool shoulder_width_compensation_ok = false) { - VRCConfigValidityBuilder builder_(_fbb); - builder_.add_shoulder_width_compensation_ok(shoulder_width_compensation_ok); - builder_.add_avatar_measurement_type_ok(avatar_measurement_type_ok); - builder_.add_spine_mode_ok(spine_mode_ok); - builder_.add_tracker_model_ok(tracker_model_ok); - builder_.add_calibration_visuals_ok(calibration_visuals_ok); - builder_.add_calibration_range_ok(calibration_range_ok); - builder_.add_user_height_ok(user_height_ok); - builder_.add_shoulder_tracking_ok(shoulder_tracking_ok); - builder_.add_legacy_mode_ok(legacy_mode_ok); - return builder_.Finish(); -} - -struct VRCConfigValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigValuesBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LEGACY_MODE = 4, - VT_SHOULDER_TRACKING_DISABLED = 6, - VT_USER_HEIGHT = 8, - VT_CALIBRATION_RANGE = 10, - VT_CALIBRATION_VISUALS = 12, - VT_TRACKER_MODEL = 14, - VT_SPINE_MODE = 16, - VT_AVATAR_MEASUREMENT_TYPE = 18, - VT_SHOULDER_WIDTH_COMPENSATION = 20 - }; - bool legacy_mode() const { - return GetField(VT_LEGACY_MODE, 0) != 0; + const solarxr_protocol::rpc::LegTweaksTmpClear *message_as_LegTweaksTmpClear() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::LegTweaksTmpClear ? static_cast(message()) : nullptr; } - bool shoulder_tracking_disabled() const { - return GetField(VT_SHOULDER_TRACKING_DISABLED, 0) != 0; + const solarxr_protocol::rpc::TapDetectionSetupNotification *message_as_TapDetectionSetupNotification() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TapDetectionSetupNotification ? static_cast(message()) : nullptr; } - float user_height() const { - return GetField(VT_USER_HEIGHT, 0.0f); + const solarxr_protocol::rpc::SetPauseTrackingRequest *message_as_SetPauseTrackingRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SetPauseTrackingRequest ? static_cast(message()) : nullptr; } - float calibration_range() const { - return GetField(VT_CALIBRATION_RANGE, 0.0f); + const solarxr_protocol::rpc::ClearMountingResetRequest *message_as_ClearMountingResetRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ClearMountingResetRequest ? static_cast(message()) : nullptr; } - bool calibration_visuals() const { - return GetField(VT_CALIBRATION_VISUALS, 0) != 0; + const solarxr_protocol::rpc::AutoBoneApplyRequest *message_as_AutoBoneApplyRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneApplyRequest ? static_cast(message()) : nullptr; } - solarxr_protocol::rpc::VRCTrackerModel tracker_model() const { - return static_cast(GetField(VT_TRACKER_MODEL, 0)); + const solarxr_protocol::rpc::AutoBoneStopRecordingRequest *message_as_AutoBoneStopRecordingRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneStopRecordingRequest ? static_cast(message()) : nullptr; } - solarxr_protocol::rpc::VRCSpineMode spine_mode() const { - return static_cast(GetField(VT_SPINE_MODE, 0)); + const solarxr_protocol::rpc::AutoBoneCancelRecordingRequest *message_as_AutoBoneCancelRecordingRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AutoBoneCancelRecordingRequest ? static_cast(message()) : nullptr; } - solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type() const { - return static_cast(GetField(VT_AVATAR_MEASUREMENT_TYPE, 0)); + const solarxr_protocol::rpc::SaveFileNotification *message_as_SaveFileNotification() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SaveFileNotification ? static_cast(message()) : nullptr; } - bool shoulder_width_compensation() const { - return GetField(VT_SHOULDER_WIDTH_COMPENSATION, 0) != 0; + const solarxr_protocol::rpc::TrackingPauseStateRequest *message_as_TrackingPauseStateRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingPauseStateRequest ? static_cast(message()) : nullptr; } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_LEGACY_MODE, 1) && - VerifyField(verifier, VT_SHOULDER_TRACKING_DISABLED, 1) && - VerifyField(verifier, VT_USER_HEIGHT, 4) && - VerifyField(verifier, VT_CALIBRATION_RANGE, 4) && - VerifyField(verifier, VT_CALIBRATION_VISUALS, 1) && - VerifyField(verifier, VT_TRACKER_MODEL, 1) && - VerifyField(verifier, VT_SPINE_MODE, 1) && - VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE, 1) && - VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION, 1) && - verifier.EndTable(); + const solarxr_protocol::rpc::TrackingPauseStateResponse *message_as_TrackingPauseStateResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingPauseStateResponse ? static_cast(message()) : nullptr; } -}; - -struct VRCConfigValuesBuilder { - typedef VRCConfigValues Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_legacy_mode(bool legacy_mode) { - fbb_.AddElement(VRCConfigValues::VT_LEGACY_MODE, static_cast(legacy_mode), 0); + const solarxr_protocol::rpc::SerialTrackerGetWifiScanRequest *message_as_SerialTrackerGetWifiScanRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerGetWifiScanRequest ? static_cast(message()) : nullptr; } - void add_shoulder_tracking_disabled(bool shoulder_tracking_disabled) { - fbb_.AddElement(VRCConfigValues::VT_SHOULDER_TRACKING_DISABLED, static_cast(shoulder_tracking_disabled), 0); + const solarxr_protocol::rpc::UnknownDeviceHandshakeNotification *message_as_UnknownDeviceHandshakeNotification() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UnknownDeviceHandshakeNotification ? static_cast(message()) : nullptr; } - void add_user_height(float user_height) { - fbb_.AddElement(VRCConfigValues::VT_USER_HEIGHT, user_height, 0.0f); + const solarxr_protocol::rpc::AddUnknownDeviceRequest *message_as_AddUnknownDeviceRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AddUnknownDeviceRequest ? static_cast(message()) : nullptr; } - void add_calibration_range(float calibration_range) { - fbb_.AddElement(VRCConfigValues::VT_CALIBRATION_RANGE, calibration_range, 0.0f); + const solarxr_protocol::rpc::ForgetDeviceRequest *message_as_ForgetDeviceRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ForgetDeviceRequest ? static_cast(message()) : nullptr; } - void add_calibration_visuals(bool calibration_visuals) { - fbb_.AddElement(VRCConfigValues::VT_CALIBRATION_VISUALS, static_cast(calibration_visuals), 0); + const solarxr_protocol::rpc::FirmwareUpdateRequest *message_as_FirmwareUpdateRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateRequest ? static_cast(message()) : nullptr; } - void add_tracker_model(solarxr_protocol::rpc::VRCTrackerModel tracker_model) { - fbb_.AddElement(VRCConfigValues::VT_TRACKER_MODEL, static_cast(tracker_model), 0); + const solarxr_protocol::rpc::FirmwareUpdateStatusResponse *message_as_FirmwareUpdateStatusResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateStatusResponse ? static_cast(message()) : nullptr; } - void add_spine_mode(solarxr_protocol::rpc::VRCSpineMode spine_mode) { - fbb_.AddElement(VRCConfigValues::VT_SPINE_MODE, static_cast(spine_mode), 0); + const solarxr_protocol::rpc::FirmwareUpdateStopQueuesRequest *message_as_FirmwareUpdateStopQueuesRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::FirmwareUpdateStopQueuesRequest ? static_cast(message()) : nullptr; } - void add_avatar_measurement_type(solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type) { - fbb_.AddElement(VRCConfigValues::VT_AVATAR_MEASUREMENT_TYPE, static_cast(avatar_measurement_type), 0); + const solarxr_protocol::rpc::SettingsResetRequest *message_as_SettingsResetRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SettingsResetRequest ? static_cast(message()) : nullptr; } - void add_shoulder_width_compensation(bool shoulder_width_compensation) { - fbb_.AddElement(VRCConfigValues::VT_SHOULDER_WIDTH_COMPENSATION, static_cast(shoulder_width_compensation), 0); + const solarxr_protocol::rpc::MagToggleRequest *message_as_MagToggleRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::MagToggleRequest ? static_cast(message()) : nullptr; } - explicit VRCConfigValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + const solarxr_protocol::rpc::MagToggleResponse *message_as_MagToggleResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::MagToggleResponse ? static_cast(message()) : nullptr; } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + const solarxr_protocol::rpc::ChangeMagToggleRequest *message_as_ChangeMagToggleRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeMagToggleRequest ? static_cast(message()) : nullptr; } -}; - -inline flatbuffers::Offset CreateVRCConfigValues( - flatbuffers::FlatBufferBuilder &_fbb, - bool legacy_mode = false, - bool shoulder_tracking_disabled = false, - float user_height = 0.0f, - float calibration_range = 0.0f, - bool calibration_visuals = false, - solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, - solarxr_protocol::rpc::VRCSpineMode spine_mode = solarxr_protocol::rpc::VRCSpineMode::UNKNOWN, - solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, - bool shoulder_width_compensation = false) { - VRCConfigValuesBuilder builder_(_fbb); - builder_.add_calibration_range(calibration_range); - builder_.add_user_height(user_height); - builder_.add_shoulder_width_compensation(shoulder_width_compensation); - builder_.add_avatar_measurement_type(avatar_measurement_type); - builder_.add_spine_mode(spine_mode); - builder_.add_tracker_model(tracker_model); - builder_.add_calibration_visuals(calibration_visuals); - builder_.add_shoulder_tracking_disabled(shoulder_tracking_disabled); - builder_.add_legacy_mode(legacy_mode); - return builder_.Finish(); -} - -struct VRCConfigRecommendedValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigRecommendedValuesBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_LEGACY_MODE = 4, - VT_SHOULDER_TRACKING_DISABLED = 6, - VT_USER_HEIGHT = 8, - VT_CALIBRATION_RANGE = 10, - VT_CALIBRATION_VISUALS = 12, - VT_TRACKER_MODEL = 14, - VT_SPINE_MODE = 16, - VT_AVATAR_MEASUREMENT_TYPE = 18, - VT_SHOULDER_WIDTH_COMPENSATION = 20 - }; - bool legacy_mode() const { - return GetField(VT_LEGACY_MODE, 0) != 0; + const solarxr_protocol::rpc::RecordBVHStatusRequest *message_as_RecordBVHStatusRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::RecordBVHStatusRequest ? static_cast(message()) : nullptr; } - bool shoulder_tracking_disabled() const { - return GetField(VT_SHOULDER_TRACKING_DISABLED, 0) != 0; + const solarxr_protocol::rpc::VRCConfigStateRequest *message_as_VRCConfigStateRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigStateRequest ? static_cast(message()) : nullptr; } - float user_height() const { - return GetField(VT_USER_HEIGHT, 0.0f); + const solarxr_protocol::rpc::VRCConfigStateChangeResponse *message_as_VRCConfigStateChangeResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigStateChangeResponse ? static_cast(message()) : nullptr; } - float calibration_range() const { - return GetField(VT_CALIBRATION_RANGE, 0.0f); + const solarxr_protocol::rpc::EnableStayAlignedRequest *message_as_EnableStayAlignedRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::EnableStayAlignedRequest ? static_cast(message()) : nullptr; } - bool calibration_visuals() const { - return GetField(VT_CALIBRATION_VISUALS, 0) != 0; + const solarxr_protocol::rpc::DetectStayAlignedRelaxedPoseRequest *message_as_DetectStayAlignedRelaxedPoseRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::DetectStayAlignedRelaxedPoseRequest ? static_cast(message()) : nullptr; } - solarxr_protocol::rpc::VRCTrackerModel tracker_model() const { - return static_cast(GetField(VT_TRACKER_MODEL, 0)); + const solarxr_protocol::rpc::ResetStayAlignedRelaxedPoseRequest *message_as_ResetStayAlignedRelaxedPoseRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ResetStayAlignedRelaxedPoseRequest ? static_cast(message()) : nullptr; } - const flatbuffers::Vector *spine_mode() const { - return GetPointer *>(VT_SPINE_MODE); + const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest *message_as_SerialTrackerCustomCommandRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerCustomCommandRequest ? static_cast(message()) : nullptr; } - solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type() const { - return static_cast(GetField(VT_AVATAR_MEASUREMENT_TYPE, 0)); + const solarxr_protocol::rpc::VRCConfigSettingToggleMute *message_as_VRCConfigSettingToggleMute() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigSettingToggleMute ? static_cast(message()) : nullptr; } - bool shoulder_width_compensation() const { - return GetField(VT_SHOULDER_WIDTH_COMPENSATION, 0) != 0; + const solarxr_protocol::rpc::TrackingChecklistRequest *message_as_TrackingChecklistRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistRequest ? static_cast(message()) : nullptr; } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_LEGACY_MODE, 1) && - VerifyField(verifier, VT_SHOULDER_TRACKING_DISABLED, 1) && - VerifyField(verifier, VT_USER_HEIGHT, 4) && - VerifyField(verifier, VT_CALIBRATION_RANGE, 4) && - VerifyField(verifier, VT_CALIBRATION_VISUALS, 1) && - VerifyField(verifier, VT_TRACKER_MODEL, 1) && - VerifyOffset(verifier, VT_SPINE_MODE) && - verifier.VerifyVector(spine_mode()) && - VerifyField(verifier, VT_AVATAR_MEASUREMENT_TYPE, 1) && - VerifyField(verifier, VT_SHOULDER_WIDTH_COMPENSATION, 1) && - verifier.EndTable(); + const solarxr_protocol::rpc::TrackingChecklistResponse *message_as_TrackingChecklistResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistResponse ? static_cast(message()) : nullptr; } -}; - -struct VRCConfigRecommendedValuesBuilder { - typedef VRCConfigRecommendedValues Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_legacy_mode(bool legacy_mode) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_LEGACY_MODE, static_cast(legacy_mode), 0); + const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *message_as_IgnoreTrackingChecklistStepRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::IgnoreTrackingChecklistStepRequest ? static_cast(message()) : nullptr; } - void add_shoulder_tracking_disabled(bool shoulder_tracking_disabled) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_SHOULDER_TRACKING_DISABLED, static_cast(shoulder_tracking_disabled), 0); + const solarxr_protocol::rpc::StartUserHeightCalibration *message_as_StartUserHeightCalibration() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StartUserHeightCalibration ? static_cast(message()) : nullptr; } - void add_user_height(float user_height) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_USER_HEIGHT, user_height, 0.0f); + const solarxr_protocol::rpc::CancelUserHeightCalibration *message_as_CancelUserHeightCalibration() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::CancelUserHeightCalibration ? static_cast(message()) : nullptr; } - void add_calibration_range(float calibration_range) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_CALIBRATION_RANGE, calibration_range, 0.0f); + const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *message_as_UserHeightRecordingStatusResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UserHeightRecordingStatusResponse ? static_cast(message()) : nullptr; } - void add_calibration_visuals(bool calibration_visuals) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_CALIBRATION_VISUALS, static_cast(calibration_visuals), 0); + const solarxr_protocol::rpc::VRCOSCSettingsRequest *message_as_VRCOSCSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCOSCSettingsRequest ? static_cast(message()) : nullptr; } - void add_tracker_model(solarxr_protocol::rpc::VRCTrackerModel tracker_model) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_TRACKER_MODEL, static_cast(tracker_model), 0); + const solarxr_protocol::rpc::VRCOSCSettingsResponse *message_as_VRCOSCSettingsResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCOSCSettingsResponse ? static_cast(message()) : nullptr; } - void add_spine_mode(flatbuffers::Offset> spine_mode) { - fbb_.AddOffset(VRCConfigRecommendedValues::VT_SPINE_MODE, spine_mode); + const solarxr_protocol::rpc::ChangeVRCOSCSettingsRequest *message_as_ChangeVRCOSCSettingsRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeVRCOSCSettingsRequest ? static_cast(message()) : nullptr; } - void add_avatar_measurement_type(solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_AVATAR_MEASUREMENT_TYPE, static_cast(avatar_measurement_type), 0); + const solarxr_protocol::rpc::VRCOSCStatusRequest *message_as_VRCOSCStatusRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCOSCStatusRequest ? static_cast(message()) : nullptr; } - void add_shoulder_width_compensation(bool shoulder_width_compensation) { - fbb_.AddElement(VRCConfigRecommendedValues::VT_SHOULDER_WIDTH_COMPENSATION, static_cast(shoulder_width_compensation), 0); + const solarxr_protocol::rpc::VRCOSCStatusChangeResponse *message_as_VRCOSCStatusChangeResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCOSCStatusChangeResponse ? static_cast(message()) : nullptr; } - explicit VRCConfigRecommendedValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); + const solarxr_protocol::rpc::KeybindRequest *message_as_KeybindRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindRequest ? static_cast(message()) : nullptr; } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; + const solarxr_protocol::rpc::ChangeKeybindRequest *message_as_ChangeKeybindRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeKeybindRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::KeybindResponse *message_as_KeybindResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::InstalledInfoRequest *message_as_InstalledInfoRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::InstalledInfoRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::InstalledInfoResponse *message_as_InstalledInfoResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::InstalledInfoResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OpenUriRequest *message_as_OpenUriRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OpenUriRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::OpenUriResponse *message_as_OpenUriResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::OpenUriResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::EnableSteamVRDriverRequest *message_as_EnableSteamVRDriverRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::EnableSteamVRDriverRequest ? static_cast(message()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_TX_ID, 4) && + VerifyField(verifier, VT_MESSAGE_TYPE, 1) && + VerifyOffset(verifier, VT_MESSAGE) && + VerifyRpcMessage(verifier, message(), message_type()) && + verifier.EndTable(); } }; -inline flatbuffers::Offset CreateVRCConfigRecommendedValues( - flatbuffers::FlatBufferBuilder &_fbb, - bool legacy_mode = false, - bool shoulder_tracking_disabled = false, - float user_height = 0.0f, - float calibration_range = 0.0f, - bool calibration_visuals = false, - solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, - flatbuffers::Offset> spine_mode = 0, - solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, - bool shoulder_width_compensation = false) { - VRCConfigRecommendedValuesBuilder builder_(_fbb); - builder_.add_spine_mode(spine_mode); - builder_.add_calibration_range(calibration_range); - builder_.add_user_height(user_height); - builder_.add_shoulder_width_compensation(shoulder_width_compensation); - builder_.add_avatar_measurement_type(avatar_measurement_type); - builder_.add_tracker_model(tracker_model); - builder_.add_calibration_visuals(calibration_visuals); - builder_.add_shoulder_tracking_disabled(shoulder_tracking_disabled); - builder_.add_legacy_mode(legacy_mode); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::HeartbeatRequest *RpcMessageHeader::message_as() const { + return message_as_HeartbeatRequest(); } -inline flatbuffers::Offset CreateVRCConfigRecommendedValuesDirect( - flatbuffers::FlatBufferBuilder &_fbb, - bool legacy_mode = false, - bool shoulder_tracking_disabled = false, - float user_height = 0.0f, - float calibration_range = 0.0f, - bool calibration_visuals = false, - solarxr_protocol::rpc::VRCTrackerModel tracker_model = solarxr_protocol::rpc::VRCTrackerModel::UNKNOWN, - const std::vector *spine_mode = nullptr, - solarxr_protocol::rpc::VRCAvatarMeasurementType avatar_measurement_type = solarxr_protocol::rpc::VRCAvatarMeasurementType::UNKNOWN, - bool shoulder_width_compensation = false) { - auto spine_mode__ = spine_mode ? _fbb.CreateVector(*spine_mode) : 0; - return solarxr_protocol::rpc::CreateVRCConfigRecommendedValues( - _fbb, - legacy_mode, - shoulder_tracking_disabled, - user_height, - calibration_range, - calibration_visuals, - tracker_model, - spine_mode__, - avatar_measurement_type, - shoulder_width_compensation); +template<> inline const solarxr_protocol::rpc::HeartbeatResponse *RpcMessageHeader::message_as() const { + return message_as_HeartbeatResponse(); } -struct VRCConfigStateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigStateRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::ResetRequest *RpcMessageHeader::message_as() const { + return message_as_ResetRequest(); +} -struct VRCConfigStateRequestBuilder { - typedef VRCConfigStateRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit VRCConfigStateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::ResetResponse *RpcMessageHeader::message_as() const { + return message_as_ResetResponse(); +} + +template<> inline const solarxr_protocol::rpc::AssignTrackerRequest *RpcMessageHeader::message_as() const { + return message_as_AssignTrackerRequest(); +} + +template<> inline const solarxr_protocol::rpc::OutputTrackersSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_OutputTrackersSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::OutputTrackersSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_OutputTrackersSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeOutputTrackersSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeOutputTrackersSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::VMCOSCSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_VMCOSCSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::VMCOSCSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_VMCOSCSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeVMCOSCSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeVMCOSCSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::VRMSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_VRMSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::VRMSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_VRMSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeVRMSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeVRMSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::SkeletonSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_SkeletonSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::SkeletonSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_SkeletonSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeSkeletonSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeSkeletonSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::TapDetectionSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_TapDetectionSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::TapDetectionSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_TapDetectionSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeTapDetectionSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeTapDetectionSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::TapDetectionSetupModeRequest *RpcMessageHeader::message_as() const { + return message_as_TapDetectionSetupModeRequest(); +} + +template<> inline const solarxr_protocol::rpc::ResetsSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ResetsSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::ResetsSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_ResetsSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeResetsSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeResetsSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::StayAlignedSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_StayAlignedSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::StayAlignedSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_StayAlignedSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeStayAlignedSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeStayAlignedSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::CompleteStayAlignedResponse *RpcMessageHeader::message_as() const { + return message_as_CompleteStayAlignedResponse(); +} + +template<> inline const solarxr_protocol::rpc::StayAlignedHideCorrectionRequest *RpcMessageHeader::message_as() const { + return message_as_StayAlignedHideCorrectionRequest(); +} + +template<> inline const solarxr_protocol::rpc::HIDSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_HIDSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::HIDSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_HIDSettingsResponse(); +} + +template<> inline const solarxr_protocol::rpc::ChangeHIDSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeHIDSettingsRequest(); +} + +template<> inline const solarxr_protocol::rpc::RecordBVHRequest *RpcMessageHeader::message_as() const { + return message_as_RecordBVHRequest(); +} + +template<> inline const solarxr_protocol::rpc::RecordBVHStatus *RpcMessageHeader::message_as() const { + return message_as_RecordBVHStatus(); +} -inline flatbuffers::Offset CreateVRCConfigStateRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - VRCConfigStateRequestBuilder builder_(_fbb); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::SkeletonProportionsRequest *RpcMessageHeader::message_as() const { + return message_as_SkeletonProportionsRequest(); } -/// Sent every time the vrchat config state gets updated -/// used to display vrchat missconfig settings to the user -struct VRCConfigStateChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigStateChangeResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_IS_SUPPORTED = 4, - VT_VALIDITY = 6, - VT_STATE = 8, - VT_RECOMMENDED = 10, - VT_MUTED = 12 - }; - bool is_supported() const { - return GetField(VT_IS_SUPPORTED, 0) != 0; - } - const solarxr_protocol::rpc::VRCConfigValidity *validity() const { - return GetPointer(VT_VALIDITY); - } - const solarxr_protocol::rpc::VRCConfigValues *state() const { - return GetPointer(VT_STATE); - } - const solarxr_protocol::rpc::VRCConfigRecommendedValues *recommended() const { - return GetPointer(VT_RECOMMENDED); - } - const flatbuffers::Vector> *muted() const { - return GetPointer> *>(VT_MUTED); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_IS_SUPPORTED, 1) && - VerifyOffset(verifier, VT_VALIDITY) && - verifier.VerifyTable(validity()) && - VerifyOffset(verifier, VT_STATE) && - verifier.VerifyTable(state()) && - VerifyOffset(verifier, VT_RECOMMENDED) && - verifier.VerifyTable(recommended()) && - VerifyOffset(verifier, VT_MUTED) && - verifier.VerifyVector(muted()) && - verifier.VerifyVectorOfStrings(muted()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::ChangeSkeletonProportionsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeSkeletonProportionsRequest(); +} -struct VRCConfigStateChangeResponseBuilder { - typedef VRCConfigStateChangeResponse Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_is_supported(bool is_supported) { - fbb_.AddElement(VRCConfigStateChangeResponse::VT_IS_SUPPORTED, static_cast(is_supported), 0); - } - void add_validity(flatbuffers::Offset validity) { - fbb_.AddOffset(VRCConfigStateChangeResponse::VT_VALIDITY, validity); - } - void add_state(flatbuffers::Offset state) { - fbb_.AddOffset(VRCConfigStateChangeResponse::VT_STATE, state); - } - void add_recommended(flatbuffers::Offset recommended) { - fbb_.AddOffset(VRCConfigStateChangeResponse::VT_RECOMMENDED, recommended); - } - void add_muted(flatbuffers::Offset>> muted) { - fbb_.AddOffset(VRCConfigStateChangeResponse::VT_MUTED, muted); - } - explicit VRCConfigStateChangeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::SkeletonProportionsResetAllRequest *RpcMessageHeader::message_as() const { + return message_as_SkeletonProportionsResetAllRequest(); +} -inline flatbuffers::Offset CreateVRCConfigStateChangeResponse( - flatbuffers::FlatBufferBuilder &_fbb, - bool is_supported = false, - flatbuffers::Offset validity = 0, - flatbuffers::Offset state = 0, - flatbuffers::Offset recommended = 0, - flatbuffers::Offset>> muted = 0) { - VRCConfigStateChangeResponseBuilder builder_(_fbb); - builder_.add_muted(muted); - builder_.add_recommended(recommended); - builder_.add_state(state); - builder_.add_validity(validity); - builder_.add_is_supported(is_supported); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::SkeletonProportionsResponse *RpcMessageHeader::message_as() const { + return message_as_SkeletonProportionsResponse(); } -inline flatbuffers::Offset CreateVRCConfigStateChangeResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - bool is_supported = false, - flatbuffers::Offset validity = 0, - flatbuffers::Offset state = 0, - flatbuffers::Offset recommended = 0, - const std::vector> *muted = nullptr) { - auto muted__ = muted ? _fbb.CreateVector>(*muted) : 0; - return solarxr_protocol::rpc::CreateVRCConfigStateChangeResponse( - _fbb, - is_supported, - validity, - state, - recommended, - muted__); +template<> inline const solarxr_protocol::rpc::OpenSerialRequest *RpcMessageHeader::message_as() const { + return message_as_OpenSerialRequest(); } -struct VRCConfigSettingToggleMute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef VRCConfigSettingToggleMuteBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEY = 4 - }; - const flatbuffers::String *key() const { - return GetPointer(VT_KEY); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_KEY) && - verifier.VerifyString(key()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::CloseSerialRequest *RpcMessageHeader::message_as() const { + return message_as_CloseSerialRequest(); +} -struct VRCConfigSettingToggleMuteBuilder { - typedef VRCConfigSettingToggleMute Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_key(flatbuffers::Offset key) { - fbb_.AddOffset(VRCConfigSettingToggleMute::VT_KEY, key); - } - explicit VRCConfigSettingToggleMuteBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::SerialUpdateResponse *RpcMessageHeader::message_as() const { + return message_as_SerialUpdateResponse(); +} -inline flatbuffers::Offset CreateVRCConfigSettingToggleMute( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset key = 0) { - VRCConfigSettingToggleMuteBuilder builder_(_fbb); - builder_.add_key(key); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::AutoBoneProcessRequest *RpcMessageHeader::message_as() const { + return message_as_AutoBoneProcessRequest(); } -inline flatbuffers::Offset CreateVRCConfigSettingToggleMuteDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *key = nullptr) { - auto key__ = key ? _fbb.CreateString(key) : 0; - return solarxr_protocol::rpc::CreateVRCConfigSettingToggleMute( - _fbb, - key__); +template<> inline const solarxr_protocol::rpc::AutoBoneProcessStatusResponse *RpcMessageHeader::message_as() const { + return message_as_AutoBoneProcessStatusResponse(); } -/// Trackers that need a reset -struct TrackingChecklistTrackerReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistTrackerResetBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKERS_ID = 4 - }; - const flatbuffers::Vector> *trackers_id() const { - return GetPointer> *>(VT_TRACKERS_ID); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKERS_ID) && - verifier.VerifyVector(trackers_id()) && - verifier.VerifyVectorOfTables(trackers_id()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::AutoBoneEpochResponse *RpcMessageHeader::message_as() const { + return message_as_AutoBoneEpochResponse(); +} -struct TrackingChecklistTrackerResetBuilder { - typedef TrackingChecklistTrackerReset Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_trackers_id(flatbuffers::Offset>> trackers_id) { - fbb_.AddOffset(TrackingChecklistTrackerReset::VT_TRACKERS_ID, trackers_id); - } - explicit TrackingChecklistTrackerResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::OverlayDisplayModeRequest *RpcMessageHeader::message_as() const { + return message_as_OverlayDisplayModeRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistTrackerReset( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> trackers_id = 0) { - TrackingChecklistTrackerResetBuilder builder_(_fbb); - builder_.add_trackers_id(trackers_id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::OverlayDisplayModeChangeRequest *RpcMessageHeader::message_as() const { + return message_as_OverlayDisplayModeChangeRequest(); } -inline flatbuffers::Offset CreateTrackingChecklistTrackerResetDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *trackers_id = nullptr) { - auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistTrackerReset( - _fbb, - trackers_id__); +template<> inline const solarxr_protocol::rpc::OverlayDisplayModeResponse *RpcMessageHeader::message_as() const { + return message_as_OverlayDisplayModeResponse(); } -/// Trackers with error state -struct TrackingChecklistTrackerError FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistTrackerErrorBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKERS_ID = 4 - }; - const flatbuffers::Vector> *trackers_id() const { - return GetPointer> *>(VT_TRACKERS_ID); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKERS_ID) && - verifier.VerifyVector(trackers_id()) && - verifier.VerifyVectorOfTables(trackers_id()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::SerialTrackerRebootRequest *RpcMessageHeader::message_as() const { + return message_as_SerialTrackerRebootRequest(); +} -struct TrackingChecklistTrackerErrorBuilder { - typedef TrackingChecklistTrackerError Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_trackers_id(flatbuffers::Offset>> trackers_id) { - fbb_.AddOffset(TrackingChecklistTrackerError::VT_TRACKERS_ID, trackers_id); - } - explicit TrackingChecklistTrackerErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::SerialTrackerGetInfoRequest *RpcMessageHeader::message_as() const { + return message_as_SerialTrackerGetInfoRequest(); +} + +template<> inline const solarxr_protocol::rpc::SerialTrackerFactoryResetRequest *RpcMessageHeader::message_as() const { + return message_as_SerialTrackerFactoryResetRequest(); +} + +template<> inline const solarxr_protocol::rpc::SerialDevicesRequest *RpcMessageHeader::message_as() const { + return message_as_SerialDevicesRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistTrackerError( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> trackers_id = 0) { - TrackingChecklistTrackerErrorBuilder builder_(_fbb); - builder_.add_trackers_id(trackers_id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::SerialDevicesResponse *RpcMessageHeader::message_as() const { + return message_as_SerialDevicesResponse(); } -inline flatbuffers::Offset CreateTrackingChecklistTrackerErrorDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *trackers_id = nullptr) { - auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistTrackerError( - _fbb, - trackers_id__); +template<> inline const solarxr_protocol::rpc::NewSerialDeviceResponse *RpcMessageHeader::message_as() const { + return message_as_NewSerialDeviceResponse(); } -struct TrackingChecklistNeedCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistNeedCalibrationBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKERS_ID = 4 - }; - const flatbuffers::Vector> *trackers_id() const { - return GetPointer> *>(VT_TRACKERS_ID); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKERS_ID) && - verifier.VerifyVector(trackers_id()) && - verifier.VerifyVectorOfTables(trackers_id()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::StartWifiProvisioningRequest *RpcMessageHeader::message_as() const { + return message_as_StartWifiProvisioningRequest(); +} -struct TrackingChecklistNeedCalibrationBuilder { - typedef TrackingChecklistNeedCalibration Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_trackers_id(flatbuffers::Offset>> trackers_id) { - fbb_.AddOffset(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, trackers_id); - } - explicit TrackingChecklistNeedCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::StopWifiProvisioningRequest *RpcMessageHeader::message_as() const { + return message_as_StopWifiProvisioningRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistNeedCalibration( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> trackers_id = 0) { - TrackingChecklistNeedCalibrationBuilder builder_(_fbb); - builder_.add_trackers_id(trackers_id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::WifiProvisioningStatusResponse *RpcMessageHeader::message_as() const { + return message_as_WifiProvisioningStatusResponse(); } -inline flatbuffers::Offset CreateTrackingChecklistNeedCalibrationDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *trackers_id = nullptr) { - auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistNeedCalibration( - _fbb, - trackers_id__); +template<> inline const solarxr_protocol::rpc::ServerInfosRequest *RpcMessageHeader::message_as() const { + return message_as_ServerInfosRequest(); } -struct TrackingChecklistSteamVRDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistSteamVRDisconnectedBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_BRIDGE_SETTINGS_NAME = 4, - VT_DRIVER_INSTALLED = 6, - VT_DRIVER_BLOCKED_BY_SAFE_MODE = 8, - VT_DRIVER_ENABLED = 10 - }; - /// Name of bridge in the server's config - const flatbuffers::String *bridge_settings_name() const { - return GetPointer(VT_BRIDGE_SETTINGS_NAME); - } - /// Is the driver installed? - bool driver_installed() const { - return GetField(VT_DRIVER_INSTALLED, 0) != 0; - } - /// Has the driver been blocked due to SteamVR's "safe mode"? - bool driver_blocked_by_safe_mode() const { - return GetField(VT_DRIVER_BLOCKED_BY_SAFE_MODE, 0) != 0; - } - /// Is the driver enabled in SteamVR settings? - bool driver_enabled() const { - return GetField(VT_DRIVER_ENABLED, 0) != 0; - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_BRIDGE_SETTINGS_NAME) && - verifier.VerifyString(bridge_settings_name()) && - VerifyField(verifier, VT_DRIVER_INSTALLED, 1) && - VerifyField(verifier, VT_DRIVER_BLOCKED_BY_SAFE_MODE, 1) && - VerifyField(verifier, VT_DRIVER_ENABLED, 1) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::ServerInfosResponse *RpcMessageHeader::message_as() const { + return message_as_ServerInfosResponse(); +} -struct TrackingChecklistSteamVRDisconnectedBuilder { - typedef TrackingChecklistSteamVRDisconnected Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_bridge_settings_name(flatbuffers::Offset bridge_settings_name) { - fbb_.AddOffset(TrackingChecklistSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); - } - void add_driver_installed(bool driver_installed) { - fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_INSTALLED, static_cast(driver_installed), 0); - } - void add_driver_blocked_by_safe_mode(bool driver_blocked_by_safe_mode) { - fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_BLOCKED_BY_SAFE_MODE, static_cast(driver_blocked_by_safe_mode), 0); - } - void add_driver_enabled(bool driver_enabled) { - fbb_.AddElement(TrackingChecklistSteamVRDisconnected::VT_DRIVER_ENABLED, static_cast(driver_enabled), 0); - } - explicit TrackingChecklistSteamVRDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::LegTweaksTmpChange *RpcMessageHeader::message_as() const { + return message_as_LegTweaksTmpChange(); +} -inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnected( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset bridge_settings_name = 0, - bool driver_installed = false, - bool driver_blocked_by_safe_mode = false, - bool driver_enabled = false) { - TrackingChecklistSteamVRDisconnectedBuilder builder_(_fbb); - builder_.add_bridge_settings_name(bridge_settings_name); - builder_.add_driver_enabled(driver_enabled); - builder_.add_driver_blocked_by_safe_mode(driver_blocked_by_safe_mode); - builder_.add_driver_installed(driver_installed); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::LegTweaksTmpClear *RpcMessageHeader::message_as() const { + return message_as_LegTweaksTmpClear(); } -inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnectedDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *bridge_settings_name = nullptr, - bool driver_installed = false, - bool driver_blocked_by_safe_mode = false, - bool driver_enabled = false) { - auto bridge_settings_name__ = bridge_settings_name ? _fbb.CreateString(bridge_settings_name) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistSteamVRDisconnected( - _fbb, - bridge_settings_name__, - driver_installed, - driver_blocked_by_safe_mode, - driver_enabled); +template<> inline const solarxr_protocol::rpc::TapDetectionSetupNotification *RpcMessageHeader::message_as() const { + return message_as_TapDetectionSetupNotification(); } -struct EnableSteamVRDriverRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef EnableSteamVRDriverRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::SetPauseTrackingRequest *RpcMessageHeader::message_as() const { + return message_as_SetPauseTrackingRequest(); +} -struct EnableSteamVRDriverRequestBuilder { - typedef EnableSteamVRDriverRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit EnableSteamVRDriverRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::ClearMountingResetRequest *RpcMessageHeader::message_as() const { + return message_as_ClearMountingResetRequest(); +} -inline flatbuffers::Offset CreateEnableSteamVRDriverRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - EnableSteamVRDriverRequestBuilder builder_(_fbb); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::AutoBoneApplyRequest *RpcMessageHeader::message_as() const { + return message_as_AutoBoneApplyRequest(); } -struct TrackingChecklistUnassignedHMD FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistUnassignedHMDBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TRACKER_ID = 4 - }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_TRACKER_ID) && - verifier.VerifyTable(tracker_id()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::AutoBoneStopRecordingRequest *RpcMessageHeader::message_as() const { + return message_as_AutoBoneStopRecordingRequest(); +} -struct TrackingChecklistUnassignedHMDBuilder { - typedef TrackingChecklistUnassignedHMD Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { - fbb_.AddOffset(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id); - } - explicit TrackingChecklistUnassignedHMDBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::AutoBoneCancelRecordingRequest *RpcMessageHeader::message_as() const { + return message_as_AutoBoneCancelRecordingRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistUnassignedHMD( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { - TrackingChecklistUnassignedHMDBuilder builder_(_fbb); - builder_.add_tracker_id(tracker_id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::SaveFileNotification *RpcMessageHeader::message_as() const { + return message_as_SaveFileNotification(); } -struct TrackingChecklistPublicNetworks FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistPublicNetworksBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ADAPTERS = 4 - }; - const flatbuffers::Vector> *adapters() const { - return GetPointer> *>(VT_ADAPTERS); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ADAPTERS) && - verifier.VerifyVector(adapters()) && - verifier.VerifyVectorOfStrings(adapters()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::TrackingPauseStateRequest *RpcMessageHeader::message_as() const { + return message_as_TrackingPauseStateRequest(); +} + +template<> inline const solarxr_protocol::rpc::TrackingPauseStateResponse *RpcMessageHeader::message_as() const { + return message_as_TrackingPauseStateResponse(); +} + +template<> inline const solarxr_protocol::rpc::SerialTrackerGetWifiScanRequest *RpcMessageHeader::message_as() const { + return message_as_SerialTrackerGetWifiScanRequest(); +} -struct TrackingChecklistPublicNetworksBuilder { - typedef TrackingChecklistPublicNetworks Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_adapters(flatbuffers::Offset>> adapters) { - fbb_.AddOffset(TrackingChecklistPublicNetworks::VT_ADAPTERS, adapters); - } - explicit TrackingChecklistPublicNetworksBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::UnknownDeviceHandshakeNotification *RpcMessageHeader::message_as() const { + return message_as_UnknownDeviceHandshakeNotification(); +} -inline flatbuffers::Offset CreateTrackingChecklistPublicNetworks( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> adapters = 0) { - TrackingChecklistPublicNetworksBuilder builder_(_fbb); - builder_.add_adapters(adapters); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::AddUnknownDeviceRequest *RpcMessageHeader::message_as() const { + return message_as_AddUnknownDeviceRequest(); } -inline flatbuffers::Offset CreateTrackingChecklistPublicNetworksDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *adapters = nullptr) { - auto adapters__ = adapters ? _fbb.CreateVector>(*adapters) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistPublicNetworks( - _fbb, - adapters__); +template<> inline const solarxr_protocol::rpc::ForgetDeviceRequest *RpcMessageHeader::message_as() const { + return message_as_ForgetDeviceRequest(); } -struct TrackingChecklistStep FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistStepBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4, - VT_VALID = 6, - VT_ENABLED = 8, - VT_VISIBILITY = 10, - VT_OPTIONAL = 12, - VT_IGNORABLE = 14, - VT_EXTRA_DATA_TYPE = 16, - VT_EXTRA_DATA = 18 - }; - solarxr_protocol::rpc::TrackingChecklistStepId id() const { - return static_cast(GetField(VT_ID, 0)); - } - bool valid() const { - return GetField(VT_VALID, 0) != 0; - } - bool enabled() const { - return GetField(VT_ENABLED, 0) != 0; - } - solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility() const { - return static_cast(GetField(VT_VISIBILITY, 0)); - } - bool optional() const { - return GetField(VT_OPTIONAL, 0) != 0; - } - bool ignorable() const { - return GetField(VT_IGNORABLE, 0) != 0; - } - solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type() const { - return static_cast(GetField(VT_EXTRA_DATA_TYPE, 0)); - } - const void *extra_data() const { - return GetPointer(VT_EXTRA_DATA); - } - template const T *extra_data_as() const; - const solarxr_protocol::rpc::TrackingChecklistTrackerReset *extra_data_as_TrackingChecklistTrackerReset() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerReset ? static_cast(extra_data()) : nullptr; - } - const solarxr_protocol::rpc::TrackingChecklistTrackerError *extra_data_as_TrackingChecklistTrackerError() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerError ? static_cast(extra_data()) : nullptr; - } - const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *extra_data_as_TrackingChecklistSteamVRDisconnected() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected ? static_cast(extra_data()) : nullptr; - } - const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *extra_data_as_TrackingChecklistUnassignedHMD() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistUnassignedHMD ? static_cast(extra_data()) : nullptr; - } - const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *extra_data_as_TrackingChecklistNeedCalibration() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistNeedCalibration ? static_cast(extra_data()) : nullptr; - } - const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *extra_data_as_TrackingChecklistPublicNetworks() const { - return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistPublicNetworks ? static_cast(extra_data()) : nullptr; - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ID, 1) && - VerifyField(verifier, VT_VALID, 1) && - VerifyField(verifier, VT_ENABLED, 1) && - VerifyField(verifier, VT_VISIBILITY, 1) && - VerifyField(verifier, VT_OPTIONAL, 1) && - VerifyField(verifier, VT_IGNORABLE, 1) && - VerifyField(verifier, VT_EXTRA_DATA_TYPE, 1) && - VerifyOffset(verifier, VT_EXTRA_DATA) && - VerifyTrackingChecklistExtraData(verifier, extra_data(), extra_data_type()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::FirmwareUpdateRequest *RpcMessageHeader::message_as() const { + return message_as_FirmwareUpdateRequest(); +} -template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerReset *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistTrackerReset(); +template<> inline const solarxr_protocol::rpc::FirmwareUpdateStatusResponse *RpcMessageHeader::message_as() const { + return message_as_FirmwareUpdateStatusResponse(); } -template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerError *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistTrackerError(); +template<> inline const solarxr_protocol::rpc::FirmwareUpdateStopQueuesRequest *RpcMessageHeader::message_as() const { + return message_as_FirmwareUpdateStopQueuesRequest(); } -template<> inline const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistSteamVRDisconnected(); +template<> inline const solarxr_protocol::rpc::SettingsResetRequest *RpcMessageHeader::message_as() const { + return message_as_SettingsResetRequest(); } -template<> inline const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistUnassignedHMD(); +template<> inline const solarxr_protocol::rpc::MagToggleRequest *RpcMessageHeader::message_as() const { + return message_as_MagToggleRequest(); } -template<> inline const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistNeedCalibration(); +template<> inline const solarxr_protocol::rpc::MagToggleResponse *RpcMessageHeader::message_as() const { + return message_as_MagToggleResponse(); } -template<> inline const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *TrackingChecklistStep::extra_data_as() const { - return extra_data_as_TrackingChecklistPublicNetworks(); +template<> inline const solarxr_protocol::rpc::ChangeMagToggleRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeMagToggleRequest(); } -struct TrackingChecklistStepBuilder { - typedef TrackingChecklistStep Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_id(solarxr_protocol::rpc::TrackingChecklistStepId id) { - fbb_.AddElement(TrackingChecklistStep::VT_ID, static_cast(id), 0); - } - void add_valid(bool valid) { - fbb_.AddElement(TrackingChecklistStep::VT_VALID, static_cast(valid), 0); - } - void add_enabled(bool enabled) { - fbb_.AddElement(TrackingChecklistStep::VT_ENABLED, static_cast(enabled), 0); - } - void add_visibility(solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility) { - fbb_.AddElement(TrackingChecklistStep::VT_VISIBILITY, static_cast(visibility), 0); - } - void add_optional(bool optional) { - fbb_.AddElement(TrackingChecklistStep::VT_OPTIONAL, static_cast(optional), 0); - } - void add_ignorable(bool ignorable) { - fbb_.AddElement(TrackingChecklistStep::VT_IGNORABLE, static_cast(ignorable), 0); - } - void add_extra_data_type(solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type) { - fbb_.AddElement(TrackingChecklistStep::VT_EXTRA_DATA_TYPE, static_cast(extra_data_type), 0); - } - void add_extra_data(flatbuffers::Offset extra_data) { - fbb_.AddOffset(TrackingChecklistStep::VT_EXTRA_DATA, extra_data); - } - explicit TrackingChecklistStepBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::RecordBVHStatusRequest *RpcMessageHeader::message_as() const { + return message_as_RecordBVHStatusRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistStep( - flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::TrackingChecklistStepId id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, - bool valid = false, - bool enabled = false, - solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility = solarxr_protocol::rpc::TrackingChecklistStepVisibility::ALWAYS, - bool optional = false, - bool ignorable = false, - solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type = solarxr_protocol::rpc::TrackingChecklistExtraData::NONE, - flatbuffers::Offset extra_data = 0) { - TrackingChecklistStepBuilder builder_(_fbb); - builder_.add_extra_data(extra_data); - builder_.add_extra_data_type(extra_data_type); - builder_.add_ignorable(ignorable); - builder_.add_optional(optional); - builder_.add_visibility(visibility); - builder_.add_enabled(enabled); - builder_.add_valid(valid); - builder_.add_id(id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::VRCConfigStateRequest *RpcMessageHeader::message_as() const { + return message_as_VRCConfigStateRequest(); } -struct TrackingChecklistRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistRequestBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::VRCConfigStateChangeResponse *RpcMessageHeader::message_as() const { + return message_as_VRCConfigStateChangeResponse(); +} -struct TrackingChecklistRequestBuilder { - typedef TrackingChecklistRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - explicit TrackingChecklistRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::EnableStayAlignedRequest *RpcMessageHeader::message_as() const { + return message_as_EnableStayAlignedRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistRequest( - flatbuffers::FlatBufferBuilder &_fbb) { - TrackingChecklistRequestBuilder builder_(_fbb); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::DetectStayAlignedRelaxedPoseRequest *RpcMessageHeader::message_as() const { + return message_as_DetectStayAlignedRelaxedPoseRequest(); } -struct TrackingChecklistResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TrackingChecklistResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STEPS = 4, - VT_IGNORED_STEPS = 6 - }; - const flatbuffers::Vector> *steps() const { - return GetPointer> *>(VT_STEPS); - } - const flatbuffers::Vector *ignored_steps() const { - return GetPointer *>(VT_IGNORED_STEPS); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_STEPS) && - verifier.VerifyVector(steps()) && - verifier.VerifyVectorOfTables(steps()) && - VerifyOffset(verifier, VT_IGNORED_STEPS) && - verifier.VerifyVector(ignored_steps()) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::ResetStayAlignedRelaxedPoseRequest *RpcMessageHeader::message_as() const { + return message_as_ResetStayAlignedRelaxedPoseRequest(); +} -struct TrackingChecklistResponseBuilder { - typedef TrackingChecklistResponse Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_steps(flatbuffers::Offset>> steps) { - fbb_.AddOffset(TrackingChecklistResponse::VT_STEPS, steps); - } - void add_ignored_steps(flatbuffers::Offset> ignored_steps) { - fbb_.AddOffset(TrackingChecklistResponse::VT_IGNORED_STEPS, ignored_steps); - } - explicit TrackingChecklistResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest *RpcMessageHeader::message_as() const { + return message_as_SerialTrackerCustomCommandRequest(); +} -inline flatbuffers::Offset CreateTrackingChecklistResponse( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> steps = 0, - flatbuffers::Offset> ignored_steps = 0) { - TrackingChecklistResponseBuilder builder_(_fbb); - builder_.add_ignored_steps(ignored_steps); - builder_.add_steps(steps); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::VRCConfigSettingToggleMute *RpcMessageHeader::message_as() const { + return message_as_VRCConfigSettingToggleMute(); } -inline flatbuffers::Offset CreateTrackingChecklistResponseDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *steps = nullptr, - const std::vector *ignored_steps = nullptr) { - auto steps__ = steps ? _fbb.CreateVector>(*steps) : 0; - auto ignored_steps__ = ignored_steps ? _fbb.CreateVector(*ignored_steps) : 0; - return solarxr_protocol::rpc::CreateTrackingChecklistResponse( - _fbb, - steps__, - ignored_steps__); +template<> inline const solarxr_protocol::rpc::TrackingChecklistRequest *RpcMessageHeader::message_as() const { + return message_as_TrackingChecklistRequest(); } -struct IgnoreTrackingChecklistStepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef IgnoreTrackingChecklistStepRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_STEP_ID = 4, - VT_IGNORE = 6 - }; - solarxr_protocol::rpc::TrackingChecklistStepId step_id() const { - return static_cast(GetField(VT_STEP_ID, 0)); - } - bool ignore() const { - return GetField(VT_IGNORE, 0) != 0; - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_STEP_ID, 1) && - VerifyField(verifier, VT_IGNORE, 1) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::TrackingChecklistResponse *RpcMessageHeader::message_as() const { + return message_as_TrackingChecklistResponse(); +} -struct IgnoreTrackingChecklistStepRequestBuilder { - typedef IgnoreTrackingChecklistStepRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_step_id(solarxr_protocol::rpc::TrackingChecklistStepId step_id) { - fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_STEP_ID, static_cast(step_id), 0); - } - void add_ignore(bool ignore) { - fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_IGNORE, static_cast(ignore), 0); - } - explicit IgnoreTrackingChecklistStepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *RpcMessageHeader::message_as() const { + return message_as_IgnoreTrackingChecklistStepRequest(); +} -inline flatbuffers::Offset CreateIgnoreTrackingChecklistStepRequest( - flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::TrackingChecklistStepId step_id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, - bool ignore = false) { - IgnoreTrackingChecklistStepRequestBuilder builder_(_fbb); - builder_.add_ignore(ignore); - builder_.add_step_id(step_id); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::StartUserHeightCalibration *RpcMessageHeader::message_as() const { + return message_as_StartUserHeightCalibration(); } -struct EnableStayAlignedRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef EnableStayAlignedRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENABLE = 4 - }; - bool enable() const { - return GetField(VT_ENABLE, 0) != 0; - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ENABLE, 1) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::CancelUserHeightCalibration *RpcMessageHeader::message_as() const { + return message_as_CancelUserHeightCalibration(); +} -struct EnableStayAlignedRequestBuilder { - typedef EnableStayAlignedRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_enable(bool enable) { - fbb_.AddElement(EnableStayAlignedRequest::VT_ENABLE, static_cast(enable), 0); - } - explicit EnableStayAlignedRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *RpcMessageHeader::message_as() const { + return message_as_UserHeightRecordingStatusResponse(); +} -inline flatbuffers::Offset CreateEnableStayAlignedRequest( - flatbuffers::FlatBufferBuilder &_fbb, - bool enable = false) { - EnableStayAlignedRequestBuilder builder_(_fbb); - builder_.add_enable(enable); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::VRCOSCSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_VRCOSCSettingsRequest(); } -struct DetectStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef DetectStayAlignedRelaxedPoseRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_POSE = 4 - }; - solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { - return static_cast(GetField(VT_POSE, 0)); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_POSE, 1) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::VRCOSCSettingsResponse *RpcMessageHeader::message_as() const { + return message_as_VRCOSCSettingsResponse(); +} -struct DetectStayAlignedRelaxedPoseRequestBuilder { - typedef DetectStayAlignedRelaxedPoseRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { - fbb_.AddElement(DetectStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); - } - explicit DetectStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::ChangeVRCOSCSettingsRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeVRCOSCSettingsRequest(); +} -inline flatbuffers::Offset CreateDetectStayAlignedRelaxedPoseRequest( - flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { - DetectStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); - builder_.add_pose(pose); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::VRCOSCStatusRequest *RpcMessageHeader::message_as() const { + return message_as_VRCOSCStatusRequest(); } -struct ResetStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ResetStayAlignedRelaxedPoseRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_POSE = 4 - }; - solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { - return static_cast(GetField(VT_POSE, 0)); - } - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - VerifyField(verifier, VT_POSE, 1) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::VRCOSCStatusChangeResponse *RpcMessageHeader::message_as() const { + return message_as_VRCOSCStatusChangeResponse(); +} -struct ResetStayAlignedRelaxedPoseRequestBuilder { - typedef ResetStayAlignedRelaxedPoseRequest Table; - flatbuffers::FlatBufferBuilder &fbb_; - flatbuffers::uoffset_t start_; - void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { - fbb_.AddElement(ResetStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); - } - explicit ResetStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) - : fbb_(_fbb) { - start_ = fbb_.StartTable(); - } - flatbuffers::Offset Finish() { - const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); - return o; - } -}; +template<> inline const solarxr_protocol::rpc::KeybindRequest *RpcMessageHeader::message_as() const { + return message_as_KeybindRequest(); +} -inline flatbuffers::Offset CreateResetStayAlignedRelaxedPoseRequest( - flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { - ResetStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); - builder_.add_pose(pose); - return builder_.Finish(); +template<> inline const solarxr_protocol::rpc::ChangeKeybindRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeKeybindRequest(); } -struct StartUserHeightCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef StartUserHeightCalibrationBuilder Builder; - bool Verify(flatbuffers::Verifier &verifier) const { - return VerifyTableStart(verifier) && - verifier.EndTable(); - } -}; +template<> inline const solarxr_protocol::rpc::KeybindResponse *RpcMessageHeader::message_as() const { + return message_as_KeybindResponse(); +} + +template<> inline const solarxr_protocol::rpc::InstalledInfoRequest *RpcMessageHeader::message_as() const { + return message_as_InstalledInfoRequest(); +} + +template<> inline const solarxr_protocol::rpc::InstalledInfoResponse *RpcMessageHeader::message_as() const { + return message_as_InstalledInfoResponse(); +} + +template<> inline const solarxr_protocol::rpc::OpenUriRequest *RpcMessageHeader::message_as() const { + return message_as_OpenUriRequest(); +} + +template<> inline const solarxr_protocol::rpc::OpenUriResponse *RpcMessageHeader::message_as() const { + return message_as_OpenUriResponse(); +} + +template<> inline const solarxr_protocol::rpc::EnableSteamVRDriverRequest *RpcMessageHeader::message_as() const { + return message_as_EnableSteamVRDriverRequest(); +} -struct StartUserHeightCalibrationBuilder { - typedef StartUserHeightCalibration Table; +struct RpcMessageHeaderBuilder { + typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit StartUserHeightCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + void add_tx_id(const solarxr_protocol::datatypes::TransactionId *tx_id) { + fbb_.AddStruct(RpcMessageHeader::VT_TX_ID, tx_id); + } + void add_message_type(solarxr_protocol::rpc::RpcMessage message_type) { + fbb_.AddElement(RpcMessageHeader::VT_MESSAGE_TYPE, static_cast(message_type), 0); + } + void add_message(flatbuffers::Offset message) { + fbb_.AddOffset(RpcMessageHeader::VT_MESSAGE, message); + } + explicit RpcMessageHeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateStartUserHeightCalibration( - flatbuffers::FlatBufferBuilder &_fbb) { - StartUserHeightCalibrationBuilder builder_(_fbb); +inline flatbuffers::Offset CreateRpcMessageHeader( + flatbuffers::FlatBufferBuilder &_fbb, + const solarxr_protocol::datatypes::TransactionId *tx_id = nullptr, + solarxr_protocol::rpc::RpcMessage message_type = solarxr_protocol::rpc::RpcMessage::NONE, + flatbuffers::Offset message = 0) { + RpcMessageHeaderBuilder builder_(_fbb); + builder_.add_message(message); + builder_.add_tx_id(tx_id); + builder_.add_message_type(message_type); return builder_.Finish(); } -struct CancelUserHeightCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef CancelUserHeightCalibrationBuilder Builder; +struct HeartbeatRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HeartbeatRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } }; -struct CancelUserHeightCalibrationBuilder { - typedef CancelUserHeightCalibration Table; +struct HeartbeatRequestBuilder { + typedef HeartbeatRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - explicit CancelUserHeightCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit HeartbeatRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateCancelUserHeightCalibration( +inline flatbuffers::Offset CreateHeartbeatRequest( flatbuffers::FlatBufferBuilder &_fbb) { - CancelUserHeightCalibrationBuilder builder_(_fbb); + HeartbeatRequestBuilder builder_(_fbb); return builder_.Finish(); } -struct UserHeightRecordingStatusResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef UserHeightRecordingStatusResponseBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_HMDHEIGHT = 4, - VT_STATUS = 6 - }; - float hmdHeight() const { - return GetField(VT_HMDHEIGHT, 0.0f); - } - solarxr_protocol::rpc::UserHeightCalibrationStatus status() const { - return static_cast(GetField(VT_STATUS, 0)); - } +struct HeartbeatResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HeartbeatResponseBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_HMDHEIGHT, 4) && - VerifyField(verifier, VT_STATUS, 1) && verifier.EndTable(); } }; -struct UserHeightRecordingStatusResponseBuilder { - typedef UserHeightRecordingStatusResponse Table; +struct HeartbeatResponseBuilder { + typedef HeartbeatResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_hmdHeight(float hmdHeight) { - fbb_.AddElement(UserHeightRecordingStatusResponse::VT_HMDHEIGHT, hmdHeight, 0.0f); - } - void add_status(solarxr_protocol::rpc::UserHeightCalibrationStatus status) { - fbb_.AddElement(UserHeightRecordingStatusResponse::VT_STATUS, static_cast(status), 0); - } - explicit UserHeightRecordingStatusResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit HeartbeatResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateUserHeightRecordingStatusResponse( - flatbuffers::FlatBufferBuilder &_fbb, - float hmdHeight = 0.0f, - solarxr_protocol::rpc::UserHeightCalibrationStatus status = solarxr_protocol::rpc::UserHeightCalibrationStatus::NONE) { - UserHeightRecordingStatusResponseBuilder builder_(_fbb); - builder_.add_hmdHeight(hmdHeight); - builder_.add_status(status); +inline flatbuffers::Offset CreateHeartbeatResponse( + flatbuffers::FlatBufferBuilder &_fbb) { + HeartbeatResponseBuilder builder_(_fbb); return builder_.Finish(); } -} // namespace rpc - -namespace pub_sub { - -/// A `TopicId` identifies an application-specific category of data. Because it -/// is application-specific, it is up to the application within the specified -/// organization to define its semantics/meaning. -/// -/// For example, "bob" may have an "overlay" app with a "settings" topic for controlling -/// the overlay visibility and other settings, as well as a "video feed" topic for -/// allowing other applications to display video data in a wrist mounted window in VR. -struct TopicId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TopicIdBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ORGANIZATION = 4, - VT_APP_NAME = 6, - VT_TOPIC = 8 - }; - /// The organization/developer that defines the meaning of this feature. Avoids name - /// clashes. Should be something unique - same idea as java package identifier. - const flatbuffers::String *organization() const { - return GetPointer(VT_ORGANIZATION); - } - /// The name of the application/device. Should be unique within the organization. - const flatbuffers::String *app_name() const { - return GetPointer(VT_APP_NAME); - } - /// The name of the topic. Should be unique within the application. - const flatbuffers::String *topic() const { - return GetPointer(VT_TOPIC); - } +/// Resets the server settings +struct SettingsResetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SettingsResetRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ORGANIZATION) && - verifier.VerifyString(organization()) && - VerifyOffset(verifier, VT_APP_NAME) && - verifier.VerifyString(app_name()) && - VerifyOffset(verifier, VT_TOPIC) && - verifier.VerifyString(topic()) && verifier.EndTable(); } }; -struct TopicIdBuilder { - typedef TopicId Table; +struct SettingsResetRequestBuilder { + typedef SettingsResetRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_organization(flatbuffers::Offset organization) { - fbb_.AddOffset(TopicId::VT_ORGANIZATION, organization); - } - void add_app_name(flatbuffers::Offset app_name) { - fbb_.AddOffset(TopicId::VT_APP_NAME, app_name); - } - void add_topic(flatbuffers::Offset topic) { - fbb_.AddOffset(TopicId::VT_TOPIC, topic); - } - explicit TopicIdBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SettingsResetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTopicId( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset organization = 0, - flatbuffers::Offset app_name = 0, - flatbuffers::Offset topic = 0) { - TopicIdBuilder builder_(_fbb); - builder_.add_topic(topic); - builder_.add_app_name(app_name); - builder_.add_organization(organization); +inline flatbuffers::Offset CreateSettingsResetRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + SettingsResetRequestBuilder builder_(_fbb); return builder_.Finish(); } -inline flatbuffers::Offset CreateTopicIdDirect( - flatbuffers::FlatBufferBuilder &_fbb, - const char *organization = nullptr, - const char *app_name = nullptr, - const char *topic = nullptr) { - auto organization__ = organization ? _fbb.CreateString(organization) : 0; - auto app_name__ = app_name ? _fbb.CreateString(app_name) : 0; - auto topic__ = topic ? _fbb.CreateString(topic) : 0; - return solarxr_protocol::pub_sub::CreateTopicId( - _fbb, - organization__, - app_name__, - topic__); -} - -/// A handle for the topic, allows referencing a topic without sending a huge -/// `TopicId`. -struct TopicHandle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TopicHandleBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4 - }; - uint16_t id() const { - return GetField(VT_ID, 0); - } +struct OpenUriRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OpenUriRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ID, 2) && verifier.EndTable(); } }; -struct TopicHandleBuilder { - typedef TopicHandle Table; +struct OpenUriRequestBuilder { + typedef OpenUriRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_id(uint16_t id) { - fbb_.AddElement(TopicHandle::VT_ID, id, 0); - } - explicit TopicHandleBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OpenUriRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTopicHandle( - flatbuffers::FlatBufferBuilder &_fbb, - uint16_t id = 0) { - TopicHandleBuilder builder_(_fbb); - builder_.add_id(id); +inline flatbuffers::Offset CreateOpenUriRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + OpenUriRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Response for `TopicHandleRequest` or `SubscriptionRequest`. -struct TopicMapping FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TopicMappingBuilder Builder; +struct OpenUriResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef OpenUriResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4, - VT_HANDLE = 6 + VT_SUCCESS = 4 }; - const solarxr_protocol::pub_sub::TopicId *id() const { - return GetPointer(VT_ID); - } - const solarxr_protocol::pub_sub::TopicHandle *handle() const { - return GetPointer(VT_HANDLE); + bool success() const { + return GetField(VT_SUCCESS, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ID) && - verifier.VerifyTable(id()) && - VerifyOffset(verifier, VT_HANDLE) && - verifier.VerifyTable(handle()) && + VerifyField(verifier, VT_SUCCESS, 1) && verifier.EndTable(); } }; -struct TopicMappingBuilder { - typedef TopicMapping Table; +struct OpenUriResponseBuilder { + typedef OpenUriResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_id(flatbuffers::Offset id) { - fbb_.AddOffset(TopicMapping::VT_ID, id); - } - void add_handle(flatbuffers::Offset handle) { - fbb_.AddOffset(TopicMapping::VT_HANDLE, handle); + void add_success(bool success) { + fbb_.AddElement(OpenUriResponse::VT_SUCCESS, static_cast(success), 0); } - explicit TopicMappingBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit OpenUriResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTopicMapping( +inline flatbuffers::Offset CreateOpenUriResponse( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset id = 0, - flatbuffers::Offset handle = 0) { - TopicMappingBuilder builder_(_fbb); - builder_.add_handle(handle); - builder_.add_id(id); + bool success = false) { + OpenUriResponseBuilder builder_(_fbb); + builder_.add_success(success); return builder_.Finish(); } -/// Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing -/// bandwidth, since `FeatureId` can be large. -struct TopicHandleRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TopicHandleRequestBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ID = 4 - }; - const solarxr_protocol::pub_sub::TopicId *id() const { - return GetPointer(VT_ID); - } +struct InstalledInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InstalledInfoRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_ID) && - verifier.VerifyTable(id()) && verifier.EndTable(); } }; -struct TopicHandleRequestBuilder { - typedef TopicHandleRequest Table; +struct InstalledInfoRequestBuilder { + typedef InstalledInfoRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_id(flatbuffers::Offset id) { - fbb_.AddOffset(TopicHandleRequest::VT_ID, id); - } - explicit TopicHandleRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit InstalledInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateTopicHandleRequest( - flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset id = 0) { - TopicHandleRequestBuilder builder_(_fbb); - builder_.add_id(id); +inline flatbuffers::Offset CreateInstalledInfoRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + InstalledInfoRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Requests a subscription to `topic`. Replies with a `TopicMapping`. -struct SubscriptionRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef SubscriptionRequestBuilder Builder; +struct InstalledInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InstalledInfoResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TOPIC_TYPE = 4, - VT_TOPIC = 6 + VT_IS_UDEV_INSTALLED = 4, + VT_IS_WAYLAND = 6 }; - solarxr_protocol::pub_sub::Topic topic_type() const { - return static_cast(GetField(VT_TOPIC_TYPE, 0)); + bool is_udev_installed() const { + return GetField(VT_IS_UDEV_INSTALLED, 0) != 0; } - const void *topic() const { - return GetPointer(VT_TOPIC); - } - template const T *topic_as() const; - const solarxr_protocol::pub_sub::TopicHandle *topic_as_TopicHandle() const { - return topic_type() == solarxr_protocol::pub_sub::Topic::TopicHandle ? static_cast(topic()) : nullptr; - } - const solarxr_protocol::pub_sub::TopicId *topic_as_TopicId() const { - return topic_type() == solarxr_protocol::pub_sub::Topic::TopicId ? static_cast(topic()) : nullptr; + bool is_wayland() const { + return GetField(VT_IS_WAYLAND, 0) != 0; } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_TOPIC_TYPE, 1) && - VerifyOffset(verifier, VT_TOPIC) && - VerifyTopic(verifier, topic(), topic_type()) && + VerifyField(verifier, VT_IS_UDEV_INSTALLED, 1) && + VerifyField(verifier, VT_IS_WAYLAND, 1) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::pub_sub::TopicHandle *SubscriptionRequest::topic_as() const { - return topic_as_TopicHandle(); -} - -template<> inline const solarxr_protocol::pub_sub::TopicId *SubscriptionRequest::topic_as() const { - return topic_as_TopicId(); -} - -struct SubscriptionRequestBuilder { - typedef SubscriptionRequest Table; +struct InstalledInfoResponseBuilder { + typedef InstalledInfoResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_topic_type(solarxr_protocol::pub_sub::Topic topic_type) { - fbb_.AddElement(SubscriptionRequest::VT_TOPIC_TYPE, static_cast(topic_type), 0); + void add_is_udev_installed(bool is_udev_installed) { + fbb_.AddElement(InstalledInfoResponse::VT_IS_UDEV_INSTALLED, static_cast(is_udev_installed), 0); } - void add_topic(flatbuffers::Offset topic) { - fbb_.AddOffset(SubscriptionRequest::VT_TOPIC, topic); + void add_is_wayland(bool is_wayland) { + fbb_.AddElement(InstalledInfoResponse::VT_IS_WAYLAND, static_cast(is_wayland), 0); } - explicit SubscriptionRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit InstalledInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateSubscriptionRequest( +inline flatbuffers::Offset CreateInstalledInfoResponse( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::pub_sub::Topic topic_type = solarxr_protocol::pub_sub::Topic::NONE, - flatbuffers::Offset topic = 0) { - SubscriptionRequestBuilder builder_(_fbb); - builder_.add_topic(topic); - builder_.add_topic_type(topic_type); + bool is_udev_installed = false, + bool is_wayland = false) { + InstalledInfoResponseBuilder builder_(_fbb); + builder_.add_is_wayland(is_wayland); + builder_.add_is_udev_installed(is_udev_installed); return builder_.Finish(); } -struct PubSubHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef PubSubHeaderBuilder Builder; - enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_U_TYPE = 4, - VT_U = 6 - }; - solarxr_protocol::pub_sub::PubSubUnion u_type() const { - return static_cast(GetField(VT_U_TYPE, 0)); - } - const void *u() const { - return GetPointer(VT_U); - } - template const T *u_as() const; - const solarxr_protocol::pub_sub::Message *u_as_Message() const { - return u_type() == solarxr_protocol::pub_sub::PubSubUnion::Message ? static_cast(u()) : nullptr; - } - const solarxr_protocol::pub_sub::SubscriptionRequest *u_as_SubscriptionRequest() const { - return u_type() == solarxr_protocol::pub_sub::PubSubUnion::SubscriptionRequest ? static_cast(u()) : nullptr; - } - const solarxr_protocol::pub_sub::TopicHandleRequest *u_as_TopicHandleRequest() const { - return u_type() == solarxr_protocol::pub_sub::PubSubUnion::TopicHandleRequest ? static_cast(u()) : nullptr; - } - const solarxr_protocol::pub_sub::TopicMapping *u_as_TopicMapping() const { - return u_type() == solarxr_protocol::pub_sub::PubSubUnion::TopicMapping ? static_cast(u()) : nullptr; - } +/// Allows to ask generic infos about the server, +/// like the local ip address, the version of the server, the java version, +/// the current working dir and other information we might want to show in the gui +/// for information/debug purposes +struct ServerInfosRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ServerInfosRequestBuilder Builder; bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_U_TYPE, 1) && - VerifyOffset(verifier, VT_U) && - VerifyPubSubUnion(verifier, u(), u_type()) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::pub_sub::Message *PubSubHeader::u_as() const { - return u_as_Message(); -} - -template<> inline const solarxr_protocol::pub_sub::SubscriptionRequest *PubSubHeader::u_as() const { - return u_as_SubscriptionRequest(); -} - -template<> inline const solarxr_protocol::pub_sub::TopicHandleRequest *PubSubHeader::u_as() const { - return u_as_TopicHandleRequest(); -} - -template<> inline const solarxr_protocol::pub_sub::TopicMapping *PubSubHeader::u_as() const { - return u_as_TopicMapping(); -} - -struct PubSubHeaderBuilder { - typedef PubSubHeader Table; +struct ServerInfosRequestBuilder { + typedef ServerInfosRequest Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_u_type(solarxr_protocol::pub_sub::PubSubUnion u_type) { - fbb_.AddElement(PubSubHeader::VT_U_TYPE, static_cast(u_type), 0); - } - void add_u(flatbuffers::Offset u) { - fbb_.AddOffset(PubSubHeader::VT_U, u); - } - explicit PubSubHeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ServerInfosRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreatePubSubHeader( - flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::pub_sub::PubSubUnion u_type = solarxr_protocol::pub_sub::PubSubUnion::NONE, - flatbuffers::Offset u = 0) { - PubSubHeaderBuilder builder_(_fbb); - builder_.add_u(u); - builder_.add_u_type(u_type); +inline flatbuffers::Offset CreateServerInfosRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + ServerInfosRequestBuilder builder_(_fbb); return builder_.Finish(); } -/// Data that is sent from publishers to subscribers -struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef MessageBuilder Builder; +/// Holds the Server information, this is a basic table holding various information about the currently running server +/// like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more +/// infos we might want to add in the future. (like java version, working dir, server version ....) +/// This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance +struct ServerInfosResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ServerInfosResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_TOPIC_TYPE = 4, - VT_TOPIC = 6, - VT_PAYLOAD_TYPE = 8, - VT_PAYLOAD = 10 + VT_LOCAL_IP = 4 }; - solarxr_protocol::pub_sub::Topic topic_type() const { - return static_cast(GetField(VT_TOPIC_TYPE, 0)); - } - const void *topic() const { - return GetPointer(VT_TOPIC); - } - template const T *topic_as() const; - const solarxr_protocol::pub_sub::TopicHandle *topic_as_TopicHandle() const { - return topic_type() == solarxr_protocol::pub_sub::Topic::TopicHandle ? static_cast(topic()) : nullptr; - } - const solarxr_protocol::pub_sub::TopicId *topic_as_TopicId() const { - return topic_type() == solarxr_protocol::pub_sub::Topic::TopicId ? static_cast(topic()) : nullptr; - } - solarxr_protocol::pub_sub::Payload payload_type() const { - return static_cast(GetField(VT_PAYLOAD_TYPE, 0)); - } - const void *payload() const { - return GetPointer(VT_PAYLOAD); - } - template const T *payload_as() const; - const solarxr_protocol::datatypes::StringTable *payload_as_solarxr_protocol_datatypes_StringTable() const { - return payload_type() == solarxr_protocol::pub_sub::Payload::solarxr_protocol_datatypes_StringTable ? static_cast(payload()) : nullptr; - } - const solarxr_protocol::datatypes::Bytes *payload_as_solarxr_protocol_datatypes_Bytes() const { - return payload_type() == solarxr_protocol::pub_sub::Payload::solarxr_protocol_datatypes_Bytes ? static_cast(payload()) : nullptr; - } - const solarxr_protocol::pub_sub::KeyValues *payload_as_KeyValues() const { - return payload_type() == solarxr_protocol::pub_sub::Payload::KeyValues ? static_cast(payload()) : nullptr; + const flatbuffers::String *local_ip() const { + return GetPointer(VT_LOCAL_IP); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_TOPIC_TYPE, 1) && - VerifyOffset(verifier, VT_TOPIC) && - VerifyTopic(verifier, topic(), topic_type()) && - VerifyField(verifier, VT_PAYLOAD_TYPE, 1) && - VerifyOffset(verifier, VT_PAYLOAD) && - VerifyPayload(verifier, payload(), payload_type()) && + VerifyOffset(verifier, VT_LOCAL_IP) && + verifier.VerifyString(local_ip()) && verifier.EndTable(); } }; -template<> inline const solarxr_protocol::pub_sub::TopicHandle *Message::topic_as() const { - return topic_as_TopicHandle(); -} - -template<> inline const solarxr_protocol::pub_sub::TopicId *Message::topic_as() const { - return topic_as_TopicId(); -} - -template<> inline const solarxr_protocol::datatypes::StringTable *Message::payload_as() const { - return payload_as_solarxr_protocol_datatypes_StringTable(); -} - -template<> inline const solarxr_protocol::datatypes::Bytes *Message::payload_as() const { - return payload_as_solarxr_protocol_datatypes_Bytes(); -} - -template<> inline const solarxr_protocol::pub_sub::KeyValues *Message::payload_as() const { - return payload_as_KeyValues(); -} - -struct MessageBuilder { - typedef Message Table; +struct ServerInfosResponseBuilder { + typedef ServerInfosResponse Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_topic_type(solarxr_protocol::pub_sub::Topic topic_type) { - fbb_.AddElement(Message::VT_TOPIC_TYPE, static_cast(topic_type), 0); + void add_local_ip(flatbuffers::Offset local_ip) { + fbb_.AddOffset(ServerInfosResponse::VT_LOCAL_IP, local_ip); } - void add_topic(flatbuffers::Offset topic) { - fbb_.AddOffset(Message::VT_TOPIC, topic); - } - void add_payload_type(solarxr_protocol::pub_sub::Payload payload_type) { - fbb_.AddElement(Message::VT_PAYLOAD_TYPE, static_cast(payload_type), 0); - } - void add_payload(flatbuffers::Offset payload) { - fbb_.AddOffset(Message::VT_PAYLOAD, payload); - } - explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit ServerInfosResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateMessage( +inline flatbuffers::Offset CreateServerInfosResponse( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::pub_sub::Topic topic_type = solarxr_protocol::pub_sub::Topic::NONE, - flatbuffers::Offset topic = 0, - solarxr_protocol::pub_sub::Payload payload_type = solarxr_protocol::pub_sub::Payload::NONE, - flatbuffers::Offset payload = 0) { - MessageBuilder builder_(_fbb); - builder_.add_payload(payload); - builder_.add_topic(topic); - builder_.add_payload_type(payload_type); - builder_.add_topic_type(topic_type); + flatbuffers::Offset local_ip = 0) { + ServerInfosResponseBuilder builder_(_fbb); + builder_.add_local_ip(local_ip); return builder_.Finish(); } -struct KeyValues FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef KeyValuesBuilder Builder; +inline flatbuffers::Offset CreateServerInfosResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *local_ip = nullptr) { + auto local_ip__ = local_ip ? _fbb.CreateString(local_ip) : 0; + return solarxr_protocol::rpc::CreateServerInfosResponse( + _fbb, + local_ip__); +} + +/// Used for the server to save a file and have it prompt in the user side +struct SaveFileNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SaveFileNotificationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_KEYS = 4, - VT_VALUES = 6 + VT_DATA = 4, + VT_MIME_TYPE = 6, + VT_EXTENSION = 8, + VT_EXPECTED_DIR = 10, + VT_EXPECTED_FILENAME = 12 }; - const flatbuffers::Vector> *keys() const { - return GetPointer> *>(VT_KEYS); + /// Binary data of the file + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + /// MIME type of file if one exists, use `extension` otherwise + const flatbuffers::String *mime_type() const { + return GetPointer(VT_MIME_TYPE); + } + /// Use MIME type preferably if one exists + const flatbuffers::String *extension() const { + return GetPointer(VT_EXTENSION); + } + /// Directory recommended to save the file on + flatbuffers::Optional expected_dir() const { + return GetOptional(VT_EXPECTED_DIR); } - const flatbuffers::Vector> *values() const { - return GetPointer> *>(VT_VALUES); + /// Recommended filename + const flatbuffers::String *expected_filename() const { + return GetPointer(VT_EXPECTED_FILENAME); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_KEYS) && - verifier.VerifyVector(keys()) && - verifier.VerifyVectorOfStrings(keys()) && - VerifyOffset(verifier, VT_VALUES) && - verifier.VerifyVector(values()) && - verifier.VerifyVectorOfStrings(values()) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + VerifyOffset(verifier, VT_MIME_TYPE) && + verifier.VerifyString(mime_type()) && + VerifyOffset(verifier, VT_EXTENSION) && + verifier.VerifyString(extension()) && + VerifyField(verifier, VT_EXPECTED_DIR, 1) && + VerifyOffset(verifier, VT_EXPECTED_FILENAME) && + verifier.VerifyString(expected_filename()) && verifier.EndTable(); } }; -struct KeyValuesBuilder { - typedef KeyValues Table; +struct SaveFileNotificationBuilder { + typedef SaveFileNotification Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_keys(flatbuffers::Offset>> keys) { - fbb_.AddOffset(KeyValues::VT_KEYS, keys); + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(SaveFileNotification::VT_DATA, data); + } + void add_mime_type(flatbuffers::Offset mime_type) { + fbb_.AddOffset(SaveFileNotification::VT_MIME_TYPE, mime_type); + } + void add_extension(flatbuffers::Offset extension) { + fbb_.AddOffset(SaveFileNotification::VT_EXTENSION, extension); + } + void add_expected_dir(solarxr_protocol::rpc::ComputerDirectory expected_dir) { + fbb_.AddElement(SaveFileNotification::VT_EXPECTED_DIR, static_cast(expected_dir)); } - void add_values(flatbuffers::Offset>> values) { - fbb_.AddOffset(KeyValues::VT_VALUES, values); + void add_expected_filename(flatbuffers::Offset expected_filename) { + fbb_.AddOffset(SaveFileNotification::VT_EXPECTED_FILENAME, expected_filename); } - explicit KeyValuesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit SaveFileNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateKeyValues( +inline flatbuffers::Offset CreateSaveFileNotification( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset>> keys = 0, - flatbuffers::Offset>> values = 0) { - KeyValuesBuilder builder_(_fbb); - builder_.add_values(values); - builder_.add_keys(keys); + flatbuffers::Offset> data = 0, + flatbuffers::Offset mime_type = 0, + flatbuffers::Offset extension = 0, + flatbuffers::Optional expected_dir = flatbuffers::nullopt, + flatbuffers::Offset expected_filename = 0) { + SaveFileNotificationBuilder builder_(_fbb); + builder_.add_expected_filename(expected_filename); + builder_.add_extension(extension); + builder_.add_mime_type(mime_type); + builder_.add_data(data); + if(expected_dir) { builder_.add_expected_dir(*expected_dir); } return builder_.Finish(); } -inline flatbuffers::Offset CreateKeyValuesDirect( +inline flatbuffers::Offset CreateSaveFileNotificationDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector> *keys = nullptr, - const std::vector> *values = nullptr) { - auto keys__ = keys ? _fbb.CreateVector>(*keys) : 0; - auto values__ = values ? _fbb.CreateVector>(*values) : 0; - return solarxr_protocol::pub_sub::CreateKeyValues( + const std::vector *data = nullptr, + const char *mime_type = nullptr, + const char *extension = nullptr, + flatbuffers::Optional expected_dir = flatbuffers::nullopt, + const char *expected_filename = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + auto mime_type__ = mime_type ? _fbb.CreateString(mime_type) : 0; + auto extension__ = extension ? _fbb.CreateString(extension) : 0; + auto expected_filename__ = expected_filename ? _fbb.CreateString(expected_filename) : 0; + return solarxr_protocol::rpc::CreateSaveFileNotification( _fbb, - keys__, - values__); + data__, + mime_type__, + extension__, + expected_dir, + expected_filename__); } -} // namespace pub_sub +} // namespace rpc /// MessageBundle contains all of the messages for the data feed system and the /// rpc system that will be sent in one buffer. @@ -14902,8 +13961,7 @@ struct MessageBundle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef MessageBundleBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_DATA_FEED_MSGS = 4, - VT_RPC_MSGS = 6, - VT_PUB_SUB_MSGS = 8 + VT_RPC_MSGS = 6 }; const flatbuffers::Vector> *data_feed_msgs() const { return GetPointer> *>(VT_DATA_FEED_MSGS); @@ -14911,9 +13969,6 @@ struct MessageBundle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const flatbuffers::Vector> *rpc_msgs() const { return GetPointer> *>(VT_RPC_MSGS); } - const flatbuffers::Vector> *pub_sub_msgs() const { - return GetPointer> *>(VT_PUB_SUB_MSGS); - } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DATA_FEED_MSGS) && @@ -14922,9 +13977,6 @@ struct MessageBundle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyOffset(verifier, VT_RPC_MSGS) && verifier.VerifyVector(rpc_msgs()) && verifier.VerifyVectorOfTables(rpc_msgs()) && - VerifyOffset(verifier, VT_PUB_SUB_MSGS) && - verifier.VerifyVector(pub_sub_msgs()) && - verifier.VerifyVectorOfTables(pub_sub_msgs()) && verifier.EndTable(); } }; @@ -14939,9 +13991,6 @@ struct MessageBundleBuilder { void add_rpc_msgs(flatbuffers::Offset>> rpc_msgs) { fbb_.AddOffset(MessageBundle::VT_RPC_MSGS, rpc_msgs); } - void add_pub_sub_msgs(flatbuffers::Offset>> pub_sub_msgs) { - fbb_.AddOffset(MessageBundle::VT_PUB_SUB_MSGS, pub_sub_msgs); - } explicit MessageBundleBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -14956,10 +14005,8 @@ struct MessageBundleBuilder { inline flatbuffers::Offset CreateMessageBundle( flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset>> data_feed_msgs = 0, - flatbuffers::Offset>> rpc_msgs = 0, - flatbuffers::Offset>> pub_sub_msgs = 0) { + flatbuffers::Offset>> rpc_msgs = 0) { MessageBundleBuilder builder_(_fbb); - builder_.add_pub_sub_msgs(pub_sub_msgs); builder_.add_rpc_msgs(rpc_msgs); builder_.add_data_feed_msgs(data_feed_msgs); return builder_.Finish(); @@ -14968,16 +14015,13 @@ inline flatbuffers::Offset CreateMessageBundle( inline flatbuffers::Offset CreateMessageBundleDirect( flatbuffers::FlatBufferBuilder &_fbb, const std::vector> *data_feed_msgs = nullptr, - const std::vector> *rpc_msgs = nullptr, - const std::vector> *pub_sub_msgs = nullptr) { + const std::vector> *rpc_msgs = nullptr) { auto data_feed_msgs__ = data_feed_msgs ? _fbb.CreateVector>(*data_feed_msgs) : 0; auto rpc_msgs__ = rpc_msgs ? _fbb.CreateVector>(*rpc_msgs) : 0; - auto pub_sub_msgs__ = pub_sub_msgs ? _fbb.CreateVector>(*pub_sub_msgs) : 0; return solarxr_protocol::CreateMessageBundle( _fbb, data_feed_msgs__, - rpc_msgs__, - pub_sub_msgs__); + rpc_msgs__); } namespace datatypes { @@ -14992,9 +14036,9 @@ namespace stay_aligned { } // namespace stay_aligned -namespace tracker { +namespace tracker_data { -} // namespace tracker +} // namespace tracker_data namespace device_data { @@ -15007,16 +14051,9 @@ namespace server { } // namespace data_feed namespace rpc { -namespace settings { - -} // namespace settings } // namespace rpc -namespace pub_sub { - -} // namespace pub_sub - namespace data_feed { inline bool VerifyDataFeedMessage(flatbuffers::Verifier &verifier, const void *obj, DataFeedMessage type) { @@ -15036,69 +14073,264 @@ inline bool VerifyDataFeedMessage(flatbuffers::Verifier &verifier, const void *o auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case DataFeedMessage::DataFeedConfig: { - auto ptr = reinterpret_cast(obj); + case DataFeedMessage::DataFeedConfig: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyDataFeedMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyDataFeedMessage( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +} // namespace data_feed + +namespace rpc { + +inline bool VerifyFirmwareUpdateDeviceId(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateDeviceId type) { + switch (type) { + case FirmwareUpdateDeviceId::NONE: { + return true; + } + case FirmwareUpdateDeviceId::FirmwareDeviceIdTable: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case FirmwareUpdateDeviceId::SerialDevicePort: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyFirmwareUpdateDeviceIdVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyFirmwareUpdateDeviceId( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyFirmwareUpdateMethod(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateMethod type) { + switch (type) { + case FirmwareUpdateMethod::NONE: { + return true; + } + case FirmwareUpdateMethod::OTAFirmwareUpdate: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case FirmwareUpdateMethod::SerialFirmwareUpdate: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyFirmwareUpdateMethodVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyFirmwareUpdateMethod( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type) { + switch (type) { + case TrackingChecklistExtraData::NONE: { + return true; + } + case TrackingChecklistExtraData::TrackingChecklistTrackerReset: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistTrackerError: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistUnassignedHMD: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistNeedCalibration: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistPublicNetworks: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyTrackingChecklistExtraData( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type) { + switch (type) { + case RpcMessage::NONE: { + return true; + } + case RpcMessage::HeartbeatRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::HeartbeatResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ResetRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ResetResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::AssignTrackerRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::OutputTrackersSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::OutputTrackersSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeOutputTrackersSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VMCOSCSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VMCOSCSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeVMCOSCSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VRMSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VRMSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeVRMSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::SkeletonSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::SkeletonSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeSkeletonSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::TapDetectionSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::TapDetectionSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeTapDetectionSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::TapDetectionSetupModeRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - default: return true; - } -} - -inline bool VerifyDataFeedMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyDataFeedMessage( - verifier, values->Get(i), types->GetEnum(i))) { - return false; + case RpcMessage::ResetsSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); } - } - return true; -} - -} // namespace data_feed - -namespace rpc { - -inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type) { - switch (type) { - case RpcMessage::NONE: { - return true; + case RpcMessage::ResetsSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); } - case RpcMessage::HeartbeatRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::ChangeResetsSettingsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::HeartbeatResponse: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::StayAlignedSettingsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::ResetRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::StayAlignedSettingsResponse: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::ResetResponse: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::ChangeStayAlignedSettingsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::AssignTrackerRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::CompleteStayAlignedResponse: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SettingsRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::StayAlignedHideCorrectionRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SettingsResponse: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::HIDSettingsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::ChangeSettingsRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::HIDSettingsResponse: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::ClearDriftCompensationRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::ChangeHIDSettingsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case RpcMessage::RecordBVHRequest: { @@ -15109,20 +14341,20 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SkeletonConfigRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::SkeletonProportionsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::ChangeSkeletonConfigRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::ChangeSkeletonProportionsRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SkeletonResetAllRequest: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::SkeletonProportionsResetAllRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SkeletonConfigResponse: { - auto ptr = reinterpret_cast(obj); + case RpcMessage::SkeletonProportionsResponse: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case RpcMessage::OpenSerialRequest: { @@ -15133,10 +14365,6 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::SetWifiRequest: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } case RpcMessage::SerialUpdateResponse: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); @@ -15225,34 +14453,10 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::StatusSystemRequest: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case RpcMessage::StatusSystemResponse: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case RpcMessage::StatusSystemUpdate: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case RpcMessage::StatusSystemFixed: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } case RpcMessage::ClearMountingResetRequest: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case RpcMessage::HeightRequest: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case RpcMessage::HeightResponse: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } case RpcMessage::AutoBoneApplyRequest: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); @@ -15377,6 +14581,26 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::VRCOSCSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VRCOSCSettingsResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeVRCOSCSettingsRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VRCOSCStatusRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VRCOSCStatusChangeResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } case RpcMessage::KeybindRequest: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); @@ -15425,254 +14649,7 @@ inline bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbu return true; } -inline bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, StatusData type) { - switch (type) { - case StatusData::NONE: { - return true; - } - case StatusData::StatusTrackerReset: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case StatusData::StatusTrackerError: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case StatusData::StatusSteamVRDisconnected: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case StatusData::StatusUnassignedHMD: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case StatusData::StatusPublicNetwork: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyStatusDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyStatusData( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyFirmwareUpdateDeviceId(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateDeviceId type) { - switch (type) { - case FirmwareUpdateDeviceId::NONE: { - return true; - } - case FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case FirmwareUpdateDeviceId::SerialDevicePort: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyFirmwareUpdateDeviceIdVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyFirmwareUpdateDeviceId( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyFirmwareUpdateMethod(flatbuffers::Verifier &verifier, const void *obj, FirmwareUpdateMethod type) { - switch (type) { - case FirmwareUpdateMethod::NONE: { - return true; - } - case FirmwareUpdateMethod::OTAFirmwareUpdate: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case FirmwareUpdateMethod::SerialFirmwareUpdate: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyFirmwareUpdateMethodVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyFirmwareUpdateMethod( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type) { - switch (type) { - case TrackingChecklistExtraData::NONE: { - return true; - } - case TrackingChecklistExtraData::TrackingChecklistTrackerReset: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case TrackingChecklistExtraData::TrackingChecklistTrackerError: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case TrackingChecklistExtraData::TrackingChecklistUnassignedHMD: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case TrackingChecklistExtraData::TrackingChecklistNeedCalibration: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case TrackingChecklistExtraData::TrackingChecklistPublicNetworks: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyTrackingChecklistExtraData( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - } // namespace rpc - -namespace pub_sub { - -inline bool VerifyTopic(flatbuffers::Verifier &verifier, const void *obj, Topic type) { - switch (type) { - case Topic::NONE: { - return true; - } - case Topic::TopicHandle: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Topic::TopicId: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyTopicVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyTopic( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyPubSubUnion(flatbuffers::Verifier &verifier, const void *obj, PubSubUnion type) { - switch (type) { - case PubSubUnion::NONE: { - return true; - } - case PubSubUnion::Message: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case PubSubUnion::SubscriptionRequest: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case PubSubUnion::TopicHandleRequest: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case PubSubUnion::TopicMapping: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyPubSubUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyPubSubUnion( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -inline bool VerifyPayload(flatbuffers::Verifier &verifier, const void *obj, Payload type) { - switch (type) { - case Payload::NONE: { - return true; - } - case Payload::solarxr_protocol_datatypes_StringTable: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Payload::solarxr_protocol_datatypes_Bytes: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - case Payload::KeyValues: { - auto ptr = reinterpret_cast(obj); - return verifier.VerifyTable(ptr); - } - default: return true; - } -} - -inline bool VerifyPayloadVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { - if (!values || !types) return !values && !types; - if (values->size() != types->size()) return false; - for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { - if (!VerifyPayload( - verifier, values->Get(i), types->GetEnum(i))) { - return false; - } - } - return true; -} - -} // namespace pub_sub } // namespace solarxr_protocol #endif // FLATBUFFERS_GENERATED_ALL_SOLARXR_PROTOCOL_H_ diff --git a/protocol/java/src/solarxr_protocol/MessageBundle.java b/protocol/java/src/solarxr_protocol/MessageBundle.java index 052e1d866..27b5fe181 100644 --- a/protocol/java/src/solarxr_protocol/MessageBundle.java +++ b/protocol/java/src/solarxr_protocol/MessageBundle.java @@ -29,33 +29,23 @@ public final class MessageBundle extends Table { public int rpcMsgsLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } public solarxr_protocol.rpc.RpcMessageHeader.Vector rpcMsgsVector() { return rpcMsgsVector(new solarxr_protocol.rpc.RpcMessageHeader.Vector()); } public solarxr_protocol.rpc.RpcMessageHeader.Vector rpcMsgsVector(solarxr_protocol.rpc.RpcMessageHeader.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - public solarxr_protocol.pub_sub.PubSubHeader pubSubMsgs(int j) { return pubSubMsgs(new solarxr_protocol.pub_sub.PubSubHeader(), j); } - public solarxr_protocol.pub_sub.PubSubHeader pubSubMsgs(solarxr_protocol.pub_sub.PubSubHeader obj, int j) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } - public int pubSubMsgsLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.pub_sub.PubSubHeader.Vector pubSubMsgsVector() { return pubSubMsgsVector(new solarxr_protocol.pub_sub.PubSubHeader.Vector()); } - public solarxr_protocol.pub_sub.PubSubHeader.Vector pubSubMsgsVector(solarxr_protocol.pub_sub.PubSubHeader.Vector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public static int createMessageBundle(FlatBufferBuilder builder, int dataFeedMsgsOffset, - int rpcMsgsOffset, - int pubSubMsgsOffset) { - builder.startTable(3); - MessageBundle.addPubSubMsgs(builder, pubSubMsgsOffset); + int rpcMsgsOffset) { + builder.startTable(2); MessageBundle.addRpcMsgs(builder, rpcMsgsOffset); MessageBundle.addDataFeedMsgs(builder, dataFeedMsgsOffset); return MessageBundle.endMessageBundle(builder); } - public static void startMessageBundle(FlatBufferBuilder builder) { builder.startTable(3); } + public static void startMessageBundle(FlatBufferBuilder builder) { builder.startTable(2); } public static void addDataFeedMsgs(FlatBufferBuilder builder, int dataFeedMsgsOffset) { builder.addOffset(0, dataFeedMsgsOffset, 0); } public static int createDataFeedMsgsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } public static void startDataFeedMsgsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static void addRpcMsgs(FlatBufferBuilder builder, int rpcMsgsOffset) { builder.addOffset(1, rpcMsgsOffset, 0); } public static int createRpcMsgsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } public static void startRpcMsgsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static void addPubSubMsgs(FlatBufferBuilder builder, int pubSubMsgsOffset) { builder.addOffset(2, pubSubMsgsOffset, 0); } - public static int createPubSubMsgsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startPubSubMsgsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static int endMessageBundle(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -79,9 +69,6 @@ public void unpackTo(MessageBundleT _o) { solarxr_protocol.rpc.RpcMessageHeaderT[] _oRpcMsgs = new solarxr_protocol.rpc.RpcMessageHeaderT[rpcMsgsLength()]; for (int _j = 0; _j < rpcMsgsLength(); ++_j) {_oRpcMsgs[_j] = (rpcMsgs(_j) != null ? rpcMsgs(_j).unpack() : null);} _o.setRpcMsgs(_oRpcMsgs); - solarxr_protocol.pub_sub.PubSubHeaderT[] _oPubSubMsgs = new solarxr_protocol.pub_sub.PubSubHeaderT[pubSubMsgsLength()]; - for (int _j = 0; _j < pubSubMsgsLength(); ++_j) {_oPubSubMsgs[_j] = (pubSubMsgs(_j) != null ? pubSubMsgs(_j).unpack() : null);} - _o.setPubSubMsgs(_oPubSubMsgs); } public static int pack(FlatBufferBuilder builder, MessageBundleT _o) { if (_o == null) return 0; @@ -99,18 +86,10 @@ public static int pack(FlatBufferBuilder builder, MessageBundleT _o) { for (solarxr_protocol.rpc.RpcMessageHeaderT _e : _o.getRpcMsgs()) { __rpcMsgs[_j] = solarxr_protocol.rpc.RpcMessageHeader.pack(builder, _e); _j++;} _rpcMsgs = createRpcMsgsVector(builder, __rpcMsgs); } - int _pubSubMsgs = 0; - if (_o.getPubSubMsgs() != null) { - int[] __pubSubMsgs = new int[_o.getPubSubMsgs().length]; - int _j = 0; - for (solarxr_protocol.pub_sub.PubSubHeaderT _e : _o.getPubSubMsgs()) { __pubSubMsgs[_j] = solarxr_protocol.pub_sub.PubSubHeader.pack(builder, _e); _j++;} - _pubSubMsgs = createPubSubMsgsVector(builder, __pubSubMsgs); - } return createMessageBundle( builder, _dataFeedMsgs, - _rpcMsgs, - _pubSubMsgs); + _rpcMsgs); } } diff --git a/protocol/java/src/solarxr_protocol/MessageBundleT.java b/protocol/java/src/solarxr_protocol/MessageBundleT.java index 00805f509..e09cbf056 100644 --- a/protocol/java/src/solarxr_protocol/MessageBundleT.java +++ b/protocol/java/src/solarxr_protocol/MessageBundleT.java @@ -10,7 +10,6 @@ public class MessageBundleT { private solarxr_protocol.data_feed.DataFeedMessageHeaderT[] dataFeedMsgs; private solarxr_protocol.rpc.RpcMessageHeaderT[] rpcMsgs; - private solarxr_protocol.pub_sub.PubSubHeaderT[] pubSubMsgs; public solarxr_protocol.data_feed.DataFeedMessageHeaderT[] getDataFeedMsgs() { return dataFeedMsgs; } @@ -20,15 +19,10 @@ public class MessageBundleT { public void setRpcMsgs(solarxr_protocol.rpc.RpcMessageHeaderT[] rpcMsgs) { this.rpcMsgs = rpcMsgs; } - public solarxr_protocol.pub_sub.PubSubHeaderT[] getPubSubMsgs() { return pubSubMsgs; } - - public void setPubSubMsgs(solarxr_protocol.pub_sub.PubSubHeaderT[] pubSubMsgs) { this.pubSubMsgs = pubSubMsgs; } - public MessageBundleT() { this.dataFeedMsgs = null; this.rpcMsgs = null; - this.pubSubMsgs = null; } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java index fbb2cc16a..a1a8b4269 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java @@ -26,8 +26,8 @@ public final class DataFeedConfig extends Table { public int minimumTimeSinceLast() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public solarxr_protocol.data_feed.device_data.DeviceDataMask dataMask() { return dataMask(new solarxr_protocol.data_feed.device_data.DeviceDataMask()); } public solarxr_protocol.data_feed.device_data.DeviceDataMask dataMask(solarxr_protocol.data_feed.device_data.DeviceDataMask obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.data_feed.tracker.TrackerDataMask syntheticTrackersMask() { return syntheticTrackersMask(new solarxr_protocol.data_feed.tracker.TrackerDataMask()); } - public solarxr_protocol.data_feed.tracker.TrackerDataMask syntheticTrackersMask(solarxr_protocol.data_feed.tracker.TrackerDataMask obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMask syntheticTrackersMask() { return syntheticTrackersMask(new solarxr_protocol.data_feed.tracker_data.TrackerDataMask()); } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMask syntheticTrackersMask(solarxr_protocol.data_feed.tracker_data.TrackerDataMask obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public boolean boneMask() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean stayAlignedPoseMask() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean serverGuardsMask() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } @@ -89,7 +89,7 @@ public void unpackTo(DataFeedConfigT _o) { public static int pack(FlatBufferBuilder builder, DataFeedConfigT _o) { if (_o == null) return 0; int _dataMask = _o.getDataMask() == null ? 0 : solarxr_protocol.data_feed.device_data.DeviceDataMask.pack(builder, _o.getDataMask()); - int _syntheticTrackersMask = _o.getSyntheticTrackersMask() == null ? 0 : solarxr_protocol.data_feed.tracker.TrackerDataMask.pack(builder, _o.getSyntheticTrackersMask()); + int _syntheticTrackersMask = _o.getSyntheticTrackersMask() == null ? 0 : solarxr_protocol.data_feed.tracker_data.TrackerDataMask.pack(builder, _o.getSyntheticTrackersMask()); return createDataFeedConfig( builder, _o.getMinimumTimeSinceLast(), diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java index 918d3c85c..bc6bccab5 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java @@ -10,7 +10,7 @@ public class DataFeedConfigT { private int minimumTimeSinceLast; private solarxr_protocol.data_feed.device_data.DeviceDataMaskT dataMask; - private solarxr_protocol.data_feed.tracker.TrackerDataMaskT syntheticTrackersMask; + private solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT syntheticTrackersMask; private boolean boneMask; private boolean stayAlignedPoseMask; private boolean serverGuardsMask; @@ -23,9 +23,9 @@ public class DataFeedConfigT { public void setDataMask(solarxr_protocol.data_feed.device_data.DeviceDataMaskT dataMask) { this.dataMask = dataMask; } - public solarxr_protocol.data_feed.tracker.TrackerDataMaskT getSyntheticTrackersMask() { return syntheticTrackersMask; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT getSyntheticTrackersMask() { return syntheticTrackersMask; } - public void setSyntheticTrackersMask(solarxr_protocol.data_feed.tracker.TrackerDataMaskT syntheticTrackersMask) { this.syntheticTrackersMask = syntheticTrackersMask; } + public void setSyntheticTrackersMask(solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT syntheticTrackersMask) { this.syntheticTrackersMask = syntheticTrackersMask; } public boolean getBoneMask() { return boneMask; } diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java index 9d8a51b32..3e2edad51 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java @@ -29,11 +29,11 @@ public final class DataFeedUpdate extends Table { public int devicesLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } public solarxr_protocol.data_feed.device_data.DeviceData.Vector devicesVector() { return devicesVector(new solarxr_protocol.data_feed.device_data.DeviceData.Vector()); } public solarxr_protocol.data_feed.device_data.DeviceData.Vector devicesVector(solarxr_protocol.data_feed.device_data.DeviceData.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - public solarxr_protocol.data_feed.tracker.TrackerData syntheticTrackers(int j) { return syntheticTrackers(new solarxr_protocol.data_feed.tracker.TrackerData(), j); } - public solarxr_protocol.data_feed.tracker.TrackerData syntheticTrackers(solarxr_protocol.data_feed.tracker.TrackerData obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerData syntheticTrackers(int j) { return syntheticTrackers(new solarxr_protocol.data_feed.tracker_data.TrackerData(), j); } + public solarxr_protocol.data_feed.tracker_data.TrackerData syntheticTrackers(solarxr_protocol.data_feed.tracker_data.TrackerData obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } public int syntheticTrackersLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.data_feed.tracker.TrackerData.Vector syntheticTrackersVector() { return syntheticTrackersVector(new solarxr_protocol.data_feed.tracker.TrackerData.Vector()); } - public solarxr_protocol.data_feed.tracker.TrackerData.Vector syntheticTrackersVector(solarxr_protocol.data_feed.tracker.TrackerData.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerData.Vector syntheticTrackersVector() { return syntheticTrackersVector(new solarxr_protocol.data_feed.tracker_data.TrackerData.Vector()); } + public solarxr_protocol.data_feed.tracker_data.TrackerData.Vector syntheticTrackersVector(solarxr_protocol.data_feed.tracker_data.TrackerData.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } /** * This must represent a set, where there is no more than one bone for a `BodyPart`. */ @@ -44,6 +44,9 @@ public final class DataFeedUpdate extends Table { public solarxr_protocol.data_feed.Bone.Vector bonesVector(solarxr_protocol.data_feed.Bone.Vector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose() { return stayAlignedPose(new solarxr_protocol.data_feed.stay_aligned.StayAlignedPose()); } public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose(solarxr_protocol.data_feed.stay_aligned.StayAlignedPose obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + /** + * gives the index of the datafeed config that initiated the update + */ public int index() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public solarxr_protocol.data_feed.server.ServerGuards serverGuards() { return serverGuards(new solarxr_protocol.data_feed.server.ServerGuards()); } public solarxr_protocol.data_feed.server.ServerGuards serverGuards(solarxr_protocol.data_feed.server.ServerGuards obj) { int o = __offset(14); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } @@ -98,7 +101,7 @@ public void unpackTo(DataFeedUpdateT _o) { solarxr_protocol.data_feed.device_data.DeviceDataT[] _oDevices = new solarxr_protocol.data_feed.device_data.DeviceDataT[devicesLength()]; for (int _j = 0; _j < devicesLength(); ++_j) {_oDevices[_j] = (devices(_j) != null ? devices(_j).unpack() : null);} _o.setDevices(_oDevices); - solarxr_protocol.data_feed.tracker.TrackerDataT[] _oSyntheticTrackers = new solarxr_protocol.data_feed.tracker.TrackerDataT[syntheticTrackersLength()]; + solarxr_protocol.data_feed.tracker_data.TrackerDataT[] _oSyntheticTrackers = new solarxr_protocol.data_feed.tracker_data.TrackerDataT[syntheticTrackersLength()]; for (int _j = 0; _j < syntheticTrackersLength(); ++_j) {_oSyntheticTrackers[_j] = (syntheticTrackers(_j) != null ? syntheticTrackers(_j).unpack() : null);} _o.setSyntheticTrackers(_oSyntheticTrackers); solarxr_protocol.data_feed.BoneT[] _oBones = new solarxr_protocol.data_feed.BoneT[bonesLength()]; @@ -124,7 +127,7 @@ public static int pack(FlatBufferBuilder builder, DataFeedUpdateT _o) { if (_o.getSyntheticTrackers() != null) { int[] __syntheticTrackers = new int[_o.getSyntheticTrackers().length]; int _j = 0; - for (solarxr_protocol.data_feed.tracker.TrackerDataT _e : _o.getSyntheticTrackers()) { __syntheticTrackers[_j] = solarxr_protocol.data_feed.tracker.TrackerData.pack(builder, _e); _j++;} + for (solarxr_protocol.data_feed.tracker_data.TrackerDataT _e : _o.getSyntheticTrackers()) { __syntheticTrackers[_j] = solarxr_protocol.data_feed.tracker_data.TrackerData.pack(builder, _e); _j++;} _syntheticTrackers = createSyntheticTrackersVector(builder, __syntheticTrackers); } int _bones = 0; diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java index a80e0eb25..67c9f860d 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java @@ -9,7 +9,7 @@ public class DataFeedUpdateT { private solarxr_protocol.data_feed.device_data.DeviceDataT[] devices; - private solarxr_protocol.data_feed.tracker.TrackerDataT[] syntheticTrackers; + private solarxr_protocol.data_feed.tracker_data.TrackerDataT[] syntheticTrackers; private solarxr_protocol.data_feed.BoneT[] bones; private solarxr_protocol.data_feed.stay_aligned.StayAlignedPoseT stayAlignedPose; private int index; @@ -19,9 +19,9 @@ public class DataFeedUpdateT { public void setDevices(solarxr_protocol.data_feed.device_data.DeviceDataT[] devices) { this.devices = devices; } - public solarxr_protocol.data_feed.tracker.TrackerDataT[] getSyntheticTrackers() { return syntheticTrackers; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataT[] getSyntheticTrackers() { return syntheticTrackers; } - public void setSyntheticTrackers(solarxr_protocol.data_feed.tracker.TrackerDataT[] syntheticTrackers) { this.syntheticTrackers = syntheticTrackers; } + public void setSyntheticTrackers(solarxr_protocol.data_feed.tracker_data.TrackerDataT[] syntheticTrackers) { this.syntheticTrackers = syntheticTrackers; } public solarxr_protocol.data_feed.BoneT[] getBones() { return bones; } diff --git a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceData.java b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceData.java index bcdd6cef4..db1c87722 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceData.java +++ b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceData.java @@ -9,7 +9,7 @@ /** * Describes all possible information about a hardware device. For example, a - * vive tracker is a single hardware device, and a slime tracker with two + * vive tracker is a single hardware device, and a slime tracker with two * extensions is a single hardware device but two trackers. */ @SuppressWarnings("unused") @@ -20,8 +20,7 @@ public final class DeviceData extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public DeviceData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.DeviceId id() { return id(new solarxr_protocol.datatypes.DeviceId()); } - public solarxr_protocol.datatypes.DeviceId id(solarxr_protocol.datatypes.DeviceId obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public int id() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } /** * The dynamically changeable name of the device. This might be set by the * user to help them remember which tracker is which. @@ -42,14 +41,29 @@ public final class DeviceData extends Table { /** * Info about all trackers attached to this device */ - public solarxr_protocol.data_feed.tracker.TrackerData trackers(int j) { return trackers(new solarxr_protocol.data_feed.tracker.TrackerData(), j); } - public solarxr_protocol.data_feed.tracker.TrackerData trackers(solarxr_protocol.data_feed.tracker.TrackerData obj, int j) { int o = __offset(12); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerData trackers(int j) { return trackers(new solarxr_protocol.data_feed.tracker_data.TrackerData(), j); } + public solarxr_protocol.data_feed.tracker_data.TrackerData trackers(solarxr_protocol.data_feed.tracker_data.TrackerData obj, int j) { int o = __offset(12); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } public int trackersLength() { int o = __offset(12); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.data_feed.tracker.TrackerData.Vector trackersVector() { return trackersVector(new solarxr_protocol.data_feed.tracker.TrackerData.Vector()); } - public solarxr_protocol.data_feed.tracker.TrackerData.Vector trackersVector(solarxr_protocol.data_feed.tracker.TrackerData.Vector obj) { int o = __offset(12); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerData.Vector trackersVector() { return trackersVector(new solarxr_protocol.data_feed.tracker_data.TrackerData.Vector()); } + public solarxr_protocol.data_feed.tracker_data.TrackerData.Vector trackersVector(solarxr_protocol.data_feed.tracker_data.TrackerData.Vector obj) { int o = __offset(12); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createDeviceData(FlatBufferBuilder builder, + int id, + int customNameOffset, + int hardwareInfoOffset, + int hardwareStatusOffset, + int trackersOffset) { + builder.startTable(5); + DeviceData.addTrackers(builder, trackersOffset); + DeviceData.addHardwareStatus(builder, hardwareStatusOffset); + DeviceData.addHardwareInfo(builder, hardwareInfoOffset); + DeviceData.addCustomName(builder, customNameOffset); + DeviceData.addId(builder, id); + return DeviceData.endDeviceData(builder); + } public static void startDeviceData(FlatBufferBuilder builder) { builder.startTable(5); } - public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); } + public static void addId(FlatBufferBuilder builder, int id) { builder.addShort(0, (short) id, (short) 0); } public static void addCustomName(FlatBufferBuilder builder, int customNameOffset) { builder.addOffset(1, customNameOffset, 0); } public static void addHardwareInfo(FlatBufferBuilder builder, int hardwareInfoOffset) { builder.addOffset(2, hardwareInfoOffset, 0); } public static void addHardwareStatus(FlatBufferBuilder builder, int hardwareStatusOffset) { builder.addOffset(3, hardwareStatusOffset, 0); } @@ -73,15 +87,15 @@ public DeviceDataT unpack() { return _o; } public void unpackTo(DeviceDataT _o) { - if (id() != null) id().unpackTo(_o.getId()); - else _o.setId(null); + int _oId = id(); + _o.setId(_oId); String _oCustomName = customName(); _o.setCustomName(_oCustomName); if (hardwareInfo() != null) _o.setHardwareInfo(hardwareInfo().unpack()); else _o.setHardwareInfo(null); if (hardwareStatus() != null) _o.setHardwareStatus(hardwareStatus().unpack()); else _o.setHardwareStatus(null); - solarxr_protocol.data_feed.tracker.TrackerDataT[] _oTrackers = new solarxr_protocol.data_feed.tracker.TrackerDataT[trackersLength()]; + solarxr_protocol.data_feed.tracker_data.TrackerDataT[] _oTrackers = new solarxr_protocol.data_feed.tracker_data.TrackerDataT[trackersLength()]; for (int _j = 0; _j < trackersLength(); ++_j) {_oTrackers[_j] = (trackers(_j) != null ? trackers(_j).unpack() : null);} _o.setTrackers(_oTrackers); } @@ -94,16 +108,16 @@ public static int pack(FlatBufferBuilder builder, DeviceDataT _o) { if (_o.getTrackers() != null) { int[] __trackers = new int[_o.getTrackers().length]; int _j = 0; - for (solarxr_protocol.data_feed.tracker.TrackerDataT _e : _o.getTrackers()) { __trackers[_j] = solarxr_protocol.data_feed.tracker.TrackerData.pack(builder, _e); _j++;} + for (solarxr_protocol.data_feed.tracker_data.TrackerDataT _e : _o.getTrackers()) { __trackers[_j] = solarxr_protocol.data_feed.tracker_data.TrackerData.pack(builder, _e); _j++;} _trackers = createTrackersVector(builder, __trackers); } - startDeviceData(builder); - addId(builder, solarxr_protocol.datatypes.DeviceId.pack(builder, _o.getId())); - addCustomName(builder, _customName); - addHardwareInfo(builder, _hardwareInfo); - addHardwareStatus(builder, _hardwareStatus); - addTrackers(builder, _trackers); - return endDeviceData(builder); + return createDeviceData( + builder, + _o.getId(), + _customName, + _hardwareInfo, + _hardwareStatus, + _trackers); } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.java b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.java index 637c0be27..8d649b760 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.java +++ b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.java @@ -26,8 +26,8 @@ public final class DeviceDataMask extends Table { /** * Which tracker data should be sent in this data feed */ - public solarxr_protocol.data_feed.tracker.TrackerDataMask trackerData() { return trackerData(new solarxr_protocol.data_feed.tracker.TrackerDataMask()); } - public solarxr_protocol.data_feed.tracker.TrackerDataMask trackerData(solarxr_protocol.data_feed.tracker.TrackerDataMask obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMask trackerData() { return trackerData(new solarxr_protocol.data_feed.tracker_data.TrackerDataMask()); } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMask trackerData(solarxr_protocol.data_feed.tracker_data.TrackerDataMask obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } /** * true if device data should be sent in this data feed */ @@ -69,7 +69,7 @@ public void unpackTo(DeviceDataMaskT _o) { } public static int pack(FlatBufferBuilder builder, DeviceDataMaskT _o) { if (_o == null) return 0; - int _trackerData = _o.getTrackerData() == null ? 0 : solarxr_protocol.data_feed.tracker.TrackerDataMask.pack(builder, _o.getTrackerData()); + int _trackerData = _o.getTrackerData() == null ? 0 : solarxr_protocol.data_feed.tracker_data.TrackerDataMask.pack(builder, _o.getTrackerData()); return createDeviceDataMask( builder, _trackerData, diff --git a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMaskT.java b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMaskT.java index 3e8f8e68f..d2f3f7c58 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMaskT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataMaskT.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; public class DeviceDataMaskT { - private solarxr_protocol.data_feed.tracker.TrackerDataMaskT trackerData; + private solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT trackerData; private boolean deviceData; - public solarxr_protocol.data_feed.tracker.TrackerDataMaskT getTrackerData() { return trackerData; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT getTrackerData() { return trackerData; } - public void setTrackerData(solarxr_protocol.data_feed.tracker.TrackerDataMaskT trackerData) { this.trackerData = trackerData; } + public void setTrackerData(solarxr_protocol.data_feed.tracker_data.TrackerDataMaskT trackerData) { this.trackerData = trackerData; } public boolean getDeviceData() { return deviceData; } diff --git a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataT.java b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataT.java index 071bc66a3..e8e9bd4b8 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/device_data/DeviceDataT.java @@ -8,15 +8,15 @@ import com.google.flatbuffers.*; public class DeviceDataT { - private solarxr_protocol.datatypes.DeviceIdT id; + private int id; private String customName; private solarxr_protocol.datatypes.hardware_info.HardwareInfoT hardwareInfo; private solarxr_protocol.datatypes.hardware_info.HardwareStatusT hardwareStatus; - private solarxr_protocol.data_feed.tracker.TrackerDataT[] trackers; + private solarxr_protocol.data_feed.tracker_data.TrackerDataT[] trackers; - public solarxr_protocol.datatypes.DeviceIdT getId() { return id; } + public int getId() { return id; } - public void setId(solarxr_protocol.datatypes.DeviceIdT id) { this.id = id; } + public void setId(int id) { this.id = id; } public String getCustomName() { return customName; } @@ -30,13 +30,13 @@ public class DeviceDataT { public void setHardwareStatus(solarxr_protocol.datatypes.hardware_info.HardwareStatusT hardwareStatus) { this.hardwareStatus = hardwareStatus; } - public solarxr_protocol.data_feed.tracker.TrackerDataT[] getTrackers() { return trackers; } + public solarxr_protocol.data_feed.tracker_data.TrackerDataT[] getTrackers() { return trackers; } - public void setTrackers(solarxr_protocol.data_feed.tracker.TrackerDataT[] trackers) { this.trackers = trackers; } + public void setTrackers(solarxr_protocol.data_feed.tracker_data.TrackerDataT[] trackers) { this.trackers = trackers; } public DeviceDataT() { - this.id = new solarxr_protocol.datatypes.DeviceIdT(); + this.id = 0; this.customName = null; this.hardwareInfo = null; this.hardwareStatus = null; diff --git a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java index 5d405728a..6b3ec5438 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java +++ b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java @@ -7,6 +7,12 @@ import java.util.*; import com.google.flatbuffers.*; +/** + * Contains various of flags / guards that inform the GUI + * about possible actions or blocked states. + * The idea is to have one source of truth for all these rules + * that are spread accross the GUI. + */ @SuppressWarnings("unused") public final class ServerGuards extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } @@ -15,23 +21,23 @@ public final class ServerGuards extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public ServerGuards __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public boolean canDoMounting() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean canDoMountingReset() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean canDoYawReset() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean canDoUserHeightCalibration() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public static int createServerGuards(FlatBufferBuilder builder, - boolean canDoMounting, + boolean canDoMountingReset, boolean canDoYawReset, boolean canDoUserHeightCalibration) { builder.startTable(3); ServerGuards.addCanDoUserHeightCalibration(builder, canDoUserHeightCalibration); ServerGuards.addCanDoYawReset(builder, canDoYawReset); - ServerGuards.addCanDoMounting(builder, canDoMounting); + ServerGuards.addCanDoMountingReset(builder, canDoMountingReset); return ServerGuards.endServerGuards(builder); } public static void startServerGuards(FlatBufferBuilder builder) { builder.startTable(3); } - public static void addCanDoMounting(FlatBufferBuilder builder, boolean canDoMounting) { builder.addBoolean(0, canDoMounting, false); } + public static void addCanDoMountingReset(FlatBufferBuilder builder, boolean canDoMountingReset) { builder.addBoolean(0, canDoMountingReset, false); } public static void addCanDoYawReset(FlatBufferBuilder builder, boolean canDoYawReset) { builder.addBoolean(1, canDoYawReset, false); } public static void addCanDoUserHeightCalibration(FlatBufferBuilder builder, boolean canDoUserHeightCalibration) { builder.addBoolean(2, canDoUserHeightCalibration, false); } public static int endServerGuards(FlatBufferBuilder builder) { @@ -51,8 +57,8 @@ public ServerGuardsT unpack() { return _o; } public void unpackTo(ServerGuardsT _o) { - boolean _oCanDoMounting = canDoMounting(); - _o.setCanDoMounting(_oCanDoMounting); + boolean _oCanDoMountingReset = canDoMountingReset(); + _o.setCanDoMountingReset(_oCanDoMountingReset); boolean _oCanDoYawReset = canDoYawReset(); _o.setCanDoYawReset(_oCanDoYawReset); boolean _oCanDoUserHeightCalibration = canDoUserHeightCalibration(); @@ -62,7 +68,7 @@ public static int pack(FlatBufferBuilder builder, ServerGuardsT _o) { if (_o == null) return 0; return createServerGuards( builder, - _o.getCanDoMounting(), + _o.getCanDoMountingReset(), _o.getCanDoYawReset(), _o.getCanDoUserHeightCalibration()); } diff --git a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java index 261135bbe..2f126c770 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java @@ -8,13 +8,13 @@ import com.google.flatbuffers.*; public class ServerGuardsT { - private boolean canDoMounting; + private boolean canDoMountingReset; private boolean canDoYawReset; private boolean canDoUserHeightCalibration; - public boolean getCanDoMounting() { return canDoMounting; } + public boolean getCanDoMountingReset() { return canDoMountingReset; } - public void setCanDoMounting(boolean canDoMounting) { this.canDoMounting = canDoMounting; } + public void setCanDoMountingReset(boolean canDoMountingReset) { this.canDoMountingReset = canDoMountingReset; } public boolean getCanDoYawReset() { return canDoYawReset; } @@ -26,7 +26,7 @@ public class ServerGuardsT { public ServerGuardsT() { - this.canDoMounting = false; + this.canDoMountingReset = false; this.canDoYawReset = false; this.canDoUserHeightCalibration = false; } diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerData.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerData.java similarity index 77% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerData.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerData.java index f7b59f344..87fe5a07d 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerData.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerData.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; @@ -22,92 +22,93 @@ public final class TrackerData extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TrackerData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.data_feed.tracker.TrackerInfo info() { return info(new solarxr_protocol.data_feed.tracker.TrackerInfo()); } - public solarxr_protocol.data_feed.tracker.TrackerInfo info(solarxr_protocol.data_feed.tracker.TrackerInfo obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public int status() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public int deviceId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public int trackerId() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public solarxr_protocol.data_feed.tracker_data.TrackerInfo info() { return info(new solarxr_protocol.data_feed.tracker_data.TrackerInfo()); } + public solarxr_protocol.data_feed.tracker_data.TrackerInfo info(solarxr_protocol.data_feed.tracker_data.TrackerInfo obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int status() { int o = __offset(10); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } /** * Sensor rotation after fusion */ public solarxr_protocol.datatypes.math.Quat rotation() { return rotation(new solarxr_protocol.datatypes.math.Quat()); } - public solarxr_protocol.datatypes.math.Quat rotation(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(10); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Quat rotation(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(12); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** - * Position, in meters + * Position in meters in OpenVR's space (left-handed, X+ Right, Y+ Up, Z- Forward) */ public solarxr_protocol.datatypes.math.Vec3f position() { return position(new solarxr_protocol.datatypes.math.Vec3f()); } - public solarxr_protocol.datatypes.math.Vec3f position(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(12); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f position(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(14); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Raw angular velocity, in euler angles, rad/s */ public solarxr_protocol.datatypes.math.Vec3f rawAngularVelocity() { return rawAngularVelocity(new solarxr_protocol.datatypes.math.Vec3f()); } - public solarxr_protocol.datatypes.math.Vec3f rawAngularVelocity(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(14); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f rawAngularVelocity(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(16); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Raw acceleration, in m/s^2 */ public solarxr_protocol.datatypes.math.Vec3f rawAcceleration() { return rawAcceleration(new solarxr_protocol.datatypes.math.Vec3f()); } - public solarxr_protocol.datatypes.math.Vec3f rawAcceleration(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(16); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f rawAcceleration(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(18); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Temperature, in degrees celsius */ public solarxr_protocol.datatypes.Temperature temp() { return temp(new solarxr_protocol.datatypes.Temperature()); } - public solarxr_protocol.datatypes.Temperature temp(solarxr_protocol.datatypes.Temperature obj) { int o = __offset(18); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.Temperature temp(solarxr_protocol.datatypes.Temperature obj) { int o = __offset(20); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Acceleration without gravity, in m/s^2 */ public solarxr_protocol.datatypes.math.Vec3f linearAcceleration() { return linearAcceleration(new solarxr_protocol.datatypes.math.Vec3f()); } - public solarxr_protocol.datatypes.math.Vec3f linearAcceleration(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(20); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f linearAcceleration(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(22); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - * In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), + * In other words, a rotation that is aligned to a reliable source of rotation (0, HMD YAW, 0), * triggered after user input (using reset buttons). * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. * Includes: mounting orientation, full, quick and mounting reset adjustments. * This rotation can be used to reconstruct a skeleton pose using forward kinematics. */ public solarxr_protocol.datatypes.math.Quat rotationReferenceAdjusted() { return rotationReferenceAdjusted(new solarxr_protocol.datatypes.math.Quat()); } - public solarxr_protocol.datatypes.math.Quat rotationReferenceAdjusted(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(22); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Quat rotationReferenceAdjusted(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(24); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - * In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by + * In other words, a rotation that is aligned to a zero vector (0, 0, 0) by * inverting the current rotation, triggered after user input (using reset buttons). * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. * Includes: only full and quick reset adjustments. * This rotation can be used in visualizations for IMU debugging. */ public solarxr_protocol.datatypes.math.Quat rotationIdentityAdjusted() { return rotationIdentityAdjusted(new solarxr_protocol.datatypes.math.Quat()); } - public solarxr_protocol.datatypes.math.Quat rotationIdentityAdjusted(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(24); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Quat rotationIdentityAdjusted(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(26); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Data ticks per second, processed by SlimeVR server */ - public boolean hasTps() { return 0 != __offset(26); } - public int tps() { int o = __offset(26); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public boolean hasTps() { return 0 != __offset(28); } + public int tps() { int o = __offset(28); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } /** * Magnetic field vector, in mGauss */ public solarxr_protocol.datatypes.math.Vec3f rawMagneticVector() { return rawMagneticVector(new solarxr_protocol.datatypes.math.Vec3f()); } - public solarxr_protocol.datatypes.math.Vec3f rawMagneticVector(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(28); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f rawMagneticVector(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(30); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** * Stay Aligned */ public solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker stayAligned() { return stayAligned(new solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker()); } - public solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker stayAligned(solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker obj) { int o = __offset(30); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker stayAligned(solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker obj) { int o = __offset(32); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public static void startTrackerData(FlatBufferBuilder builder) { builder.startTable(14); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } - public static void addInfo(FlatBufferBuilder builder, int infoOffset) { builder.addOffset(1, infoOffset, 0); } - public static void addStatus(FlatBufferBuilder builder, int status) { builder.addByte(2, (byte) status, (byte) 0); } - public static void addRotation(FlatBufferBuilder builder, int rotationOffset) { builder.addStruct(3, rotationOffset, 0); } - public static void addPosition(FlatBufferBuilder builder, int positionOffset) { builder.addStruct(4, positionOffset, 0); } - public static void addRawAngularVelocity(FlatBufferBuilder builder, int rawAngularVelocityOffset) { builder.addStruct(5, rawAngularVelocityOffset, 0); } - public static void addRawAcceleration(FlatBufferBuilder builder, int rawAccelerationOffset) { builder.addStruct(6, rawAccelerationOffset, 0); } - public static void addTemp(FlatBufferBuilder builder, int tempOffset) { builder.addStruct(7, tempOffset, 0); } - public static void addLinearAcceleration(FlatBufferBuilder builder, int linearAccelerationOffset) { builder.addStruct(8, linearAccelerationOffset, 0); } - public static void addRotationReferenceAdjusted(FlatBufferBuilder builder, int rotationReferenceAdjustedOffset) { builder.addStruct(9, rotationReferenceAdjustedOffset, 0); } - public static void addRotationIdentityAdjusted(FlatBufferBuilder builder, int rotationIdentityAdjustedOffset) { builder.addStruct(10, rotationIdentityAdjustedOffset, 0); } - public static void addTps(FlatBufferBuilder builder, int tps) { builder.addShort(11, (short) tps, (short) 0); } - public static void addRawMagneticVector(FlatBufferBuilder builder, int rawMagneticVectorOffset) { builder.addStruct(12, rawMagneticVectorOffset, 0); } - public static void addStayAligned(FlatBufferBuilder builder, int stayAlignedOffset) { builder.addOffset(13, stayAlignedOffset, 0); } + public static void startTrackerData(FlatBufferBuilder builder) { builder.startTable(15); } + public static void addDeviceId(FlatBufferBuilder builder, int deviceId) { builder.addShort(0, (short) deviceId, (short) 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(1, (short) trackerId, (short) 0); } + public static void addInfo(FlatBufferBuilder builder, int infoOffset) { builder.addOffset(2, infoOffset, 0); } + public static void addStatus(FlatBufferBuilder builder, int status) { builder.addByte(3, (byte) status, (byte) 0); } + public static void addRotation(FlatBufferBuilder builder, int rotationOffset) { builder.addStruct(4, rotationOffset, 0); } + public static void addPosition(FlatBufferBuilder builder, int positionOffset) { builder.addStruct(5, positionOffset, 0); } + public static void addRawAngularVelocity(FlatBufferBuilder builder, int rawAngularVelocityOffset) { builder.addStruct(6, rawAngularVelocityOffset, 0); } + public static void addRawAcceleration(FlatBufferBuilder builder, int rawAccelerationOffset) { builder.addStruct(7, rawAccelerationOffset, 0); } + public static void addTemp(FlatBufferBuilder builder, int tempOffset) { builder.addStruct(8, tempOffset, 0); } + public static void addLinearAcceleration(FlatBufferBuilder builder, int linearAccelerationOffset) { builder.addStruct(9, linearAccelerationOffset, 0); } + public static void addRotationReferenceAdjusted(FlatBufferBuilder builder, int rotationReferenceAdjustedOffset) { builder.addStruct(10, rotationReferenceAdjustedOffset, 0); } + public static void addRotationIdentityAdjusted(FlatBufferBuilder builder, int rotationIdentityAdjustedOffset) { builder.addStruct(11, rotationIdentityAdjustedOffset, 0); } + public static void addTps(FlatBufferBuilder builder, int tps) { builder.addShort(12, (short) tps, (short) 0); } + public static void addRawMagneticVector(FlatBufferBuilder builder, int rawMagneticVectorOffset) { builder.addStruct(13, rawMagneticVectorOffset, 0); } + public static void addStayAligned(FlatBufferBuilder builder, int stayAlignedOffset) { builder.addOffset(14, stayAlignedOffset, 0); } public static int endTrackerData(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -125,8 +126,10 @@ public TrackerDataT unpack() { return _o; } public void unpackTo(TrackerDataT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oDeviceId = deviceId(); + _o.setDeviceId(_oDeviceId); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); if (info() != null) _o.setInfo(info().unpack()); else _o.setInfo(null); int _oStatus = status(); @@ -156,11 +159,11 @@ public void unpackTo(TrackerDataT _o) { } public static int pack(FlatBufferBuilder builder, TrackerDataT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); - int _info = _o.getInfo() == null ? 0 : solarxr_protocol.data_feed.tracker.TrackerInfo.pack(builder, _o.getInfo()); + int _info = _o.getInfo() == null ? 0 : solarxr_protocol.data_feed.tracker_data.TrackerInfo.pack(builder, _o.getInfo()); int _stayAligned = _o.getStayAligned() == null ? 0 : solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker.pack(builder, _o.getStayAligned()); startTrackerData(builder); - addTrackerId(builder, _trackerId); + addDeviceId(builder, _o.getDeviceId()); + addTrackerId(builder, _o.getTrackerId()); addInfo(builder, _info); addStatus(builder, _o.getStatus()); addRotation(builder, solarxr_protocol.datatypes.math.Quat.pack(builder, _o.getRotation())); diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMask.java similarity index 99% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMask.java index 605891912..da1720704 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMask.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMaskT.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMaskT.java similarity index 98% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMaskT.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMaskT.java index c7abdbca0..bbd1cbb9f 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataMaskT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataMaskT.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataT.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataT.java similarity index 86% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataT.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataT.java index 82d9e9467..a4cc080d3 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerDataT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerDataT.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; @@ -8,8 +8,9 @@ import com.google.flatbuffers.*; public class TrackerDataT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; - private solarxr_protocol.data_feed.tracker.TrackerInfoT info; + private int deviceId; + private int trackerId; + private solarxr_protocol.data_feed.tracker_data.TrackerInfoT info; private int status; private solarxr_protocol.datatypes.math.QuatT rotation; private solarxr_protocol.datatypes.math.Vec3fT position; @@ -23,13 +24,17 @@ public class TrackerDataT { private solarxr_protocol.datatypes.math.Vec3fT rawMagneticVector; private solarxr_protocol.data_feed.stay_aligned.StayAlignedTrackerT stayAligned; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getDeviceId() { return deviceId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setDeviceId(int deviceId) { this.deviceId = deviceId; } - public solarxr_protocol.data_feed.tracker.TrackerInfoT getInfo() { return info; } + public int getTrackerId() { return trackerId; } - public void setInfo(solarxr_protocol.data_feed.tracker.TrackerInfoT info) { this.info = info; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } + + public solarxr_protocol.data_feed.tracker_data.TrackerInfoT getInfo() { return info; } + + public void setInfo(solarxr_protocol.data_feed.tracker_data.TrackerInfoT info) { this.info = info; } public int getStatus() { return status; } @@ -81,7 +86,8 @@ public class TrackerDataT { public TrackerDataT() { - this.trackerId = null; + this.deviceId = 0; + this.trackerId = 0; this.info = null; this.status = 0; this.rotation = new solarxr_protocol.datatypes.math.QuatT(); diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfo.java similarity index 86% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfo.java index b2de63828..f3befdc24 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfo.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; @@ -24,7 +24,7 @@ public final class TrackerInfo extends Table { */ public int bodyPart() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } /** - * average samples per second + * Average samples per second */ public solarxr_protocol.datatypes.HzF32 pollRate() { return pollRate(new solarxr_protocol.datatypes.HzF32()); } public solarxr_protocol.datatypes.HzF32 pollRate(solarxr_protocol.datatypes.HzF32 obj) { int o = __offset(8); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } @@ -57,28 +57,24 @@ public final class TrackerInfo extends Table { public String customName() { int o = __offset(20); return o != 0 ? __string(o + bb_pos) : null; } public ByteBuffer customNameAsByteBuffer() { return __vector_as_bytebuffer(20, 1); } public ByteBuffer customNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 20, 1); } - /** - * Whether to allow yaw drift compensation for this tracker or not. - */ - public boolean allowDriftCompensation() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } /** * Mounting Reset orientation overrides the current `mounting_orientation` of * the tracker, this orientation is not saved and needs to be calculated * each time the server is ran */ public solarxr_protocol.datatypes.math.Quat mountingResetOrientation() { return mountingResetOrientation(new solarxr_protocol.datatypes.math.Quat()); } - public solarxr_protocol.datatypes.math.Quat mountingResetOrientation(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(24); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Quat mountingResetOrientation(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(22); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } /** - * Indicates if the tracker is actually an HMD + * Indicates if the tracker is actually a VR headset */ - public boolean isHmd() { int o = __offset(26); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public int magnetometer() { int o = __offset(28); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean isHmd() { int o = __offset(24); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int magnetometer() { int o = __offset(26); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } /** - * Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) + * Indicates what type of data the tracker sends (that gets transformed into a rotation) */ - public int dataSupport() { int o = __offset(30); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public int dataSupport() { int o = __offset(28); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(14); } + public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(13); } public static void addImuType(FlatBufferBuilder builder, int imuType) { builder.addShort(0, (short) imuType, (short) 0); } public static void addBodyPart(FlatBufferBuilder builder, int bodyPart) { builder.addByte(1, (byte) bodyPart, (byte) 0); } public static void addPollRate(FlatBufferBuilder builder, int pollRateOffset) { builder.addStruct(2, pollRateOffset, 0); } @@ -88,11 +84,10 @@ public final class TrackerInfo extends Table { public static void addIsImu(FlatBufferBuilder builder, boolean isImu) { builder.addBoolean(6, isImu, false); } public static void addDisplayName(FlatBufferBuilder builder, int displayNameOffset) { builder.addOffset(7, displayNameOffset, 0); } public static void addCustomName(FlatBufferBuilder builder, int customNameOffset) { builder.addOffset(8, customNameOffset, 0); } - public static void addAllowDriftCompensation(FlatBufferBuilder builder, boolean allowDriftCompensation) { builder.addBoolean(9, allowDriftCompensation, false); } - public static void addMountingResetOrientation(FlatBufferBuilder builder, int mountingResetOrientationOffset) { builder.addStruct(10, mountingResetOrientationOffset, 0); } - public static void addIsHmd(FlatBufferBuilder builder, boolean isHmd) { builder.addBoolean(11, isHmd, false); } - public static void addMagnetometer(FlatBufferBuilder builder, int magnetometer) { builder.addByte(12, (byte) magnetometer, (byte) 0); } - public static void addDataSupport(FlatBufferBuilder builder, int dataSupport) { builder.addByte(13, (byte) dataSupport, (byte) 0); } + public static void addMountingResetOrientation(FlatBufferBuilder builder, int mountingResetOrientationOffset) { builder.addStruct(9, mountingResetOrientationOffset, 0); } + public static void addIsHmd(FlatBufferBuilder builder, boolean isHmd) { builder.addBoolean(10, isHmd, false); } + public static void addMagnetometer(FlatBufferBuilder builder, int magnetometer) { builder.addByte(11, (byte) magnetometer, (byte) 0); } + public static void addDataSupport(FlatBufferBuilder builder, int dataSupport) { builder.addByte(12, (byte) dataSupport, (byte) 0); } public static int endTrackerInfo(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -128,8 +123,6 @@ public void unpackTo(TrackerInfoT _o) { _o.setDisplayName(_oDisplayName); String _oCustomName = customName(); _o.setCustomName(_oCustomName); - boolean _oAllowDriftCompensation = allowDriftCompensation(); - _o.setAllowDriftCompensation(_oAllowDriftCompensation); if (mountingResetOrientation() != null) mountingResetOrientation().unpackTo(_o.getMountingResetOrientation()); else _o.setMountingResetOrientation(null); boolean _oIsHmd = isHmd(); @@ -153,7 +146,6 @@ public static int pack(FlatBufferBuilder builder, TrackerInfoT _o) { addIsImu(builder, _o.getIsImu()); addDisplayName(builder, _displayName); addCustomName(builder, _customName); - addAllowDriftCompensation(builder, _o.getAllowDriftCompensation()); addMountingResetOrientation(builder, solarxr_protocol.datatypes.math.Quat.pack(builder, _o.getMountingResetOrientation())); addIsHmd(builder, _o.getIsHmd()); addMagnetometer(builder, _o.getMagnetometer()); diff --git a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfoT.java similarity index 90% rename from protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java rename to protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfoT.java index dd51fdd06..c9d4bb1d7 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/tracker_data/TrackerInfoT.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.data_feed.tracker; +package solarxr_protocol.data_feed.tracker_data; import java.nio.*; import java.lang.*; @@ -17,7 +17,6 @@ public class TrackerInfoT { private boolean isImu; private String displayName; private String customName; - private boolean allowDriftCompensation; private solarxr_protocol.datatypes.math.QuatT mountingResetOrientation; private boolean isHmd; private int magnetometer; @@ -59,10 +58,6 @@ public class TrackerInfoT { public void setCustomName(String customName) { this.customName = customName; } - public boolean getAllowDriftCompensation() { return allowDriftCompensation; } - - public void setAllowDriftCompensation(boolean allowDriftCompensation) { this.allowDriftCompensation = allowDriftCompensation; } - public solarxr_protocol.datatypes.math.QuatT getMountingResetOrientation() { return mountingResetOrientation; } public void setMountingResetOrientation(solarxr_protocol.datatypes.math.QuatT mountingResetOrientation) { this.mountingResetOrientation = mountingResetOrientation; } @@ -90,7 +85,6 @@ public TrackerInfoT() { this.isImu = false; this.displayName = null; this.customName = null; - this.allowDriftCompensation = false; this.mountingResetOrientation = new solarxr_protocol.datatypes.math.QuatT(); this.isHmd = false; this.magnetometer = 0; diff --git a/protocol/java/src/solarxr_protocol/datatypes/Bytes.java b/protocol/java/src/solarxr_protocol/datatypes/Bytes.java deleted file mode 100644 index 6129209f3..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/Bytes.java +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class Bytes extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static Bytes getRootAsBytes(ByteBuffer _bb) { return getRootAsBytes(_bb, new Bytes()); } - public static Bytes getRootAsBytes(ByteBuffer _bb, Bytes obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public Bytes __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public int b(int j) { int o = __offset(4); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } - public int bLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public ByteVector bVector() { return bVector(new ByteVector()); } - public ByteVector bVector(ByteVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), bb) : null; } - public ByteBuffer bAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer bInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - - public static int createBytes(FlatBufferBuilder builder, - int bOffset) { - builder.startTable(1); - Bytes.addB(builder, bOffset); - return Bytes.endBytes(builder); - } - - public static void startBytes(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addB(FlatBufferBuilder builder, int bOffset) { builder.addOffset(0, bOffset, 0); } - public static int createBVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } - public static int createBVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } - public static void startBVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } - public static int endBytes(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public Bytes get(int j) { return get(new Bytes(), j); } - public Bytes get(Bytes obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public BytesT unpack() { - BytesT _o = new BytesT(); - unpackTo(_o); - return _o; - } - public void unpackTo(BytesT _o) { - int[] _oB = new int[bLength()]; - for (int _j = 0; _j < bLength(); ++_j) {_oB[_j] = b(_j);} - _o.setB(_oB); - } - public static int pack(FlatBufferBuilder builder, BytesT _o) { - if (_o == null) return 0; - int _b = 0; - if (_o.getB() != null) { - byte[] __b = new byte[_o.getB().length]; - int _j = 0; - for (int _e : _o.getB()) { __b[_j] = (byte) _e; _j++;} - _b = createBVector(builder, __b); - } - return createBytes( - builder, - _b); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/BytesT.java b/protocol/java/src/solarxr_protocol/datatypes/BytesT.java deleted file mode 100644 index 5d757e8f8..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/BytesT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class BytesT { - private int[] b; - - public int[] getB() { return b; } - - public void setB(int[] b) { this.b = b; } - - - public BytesT() { - this.b = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/DeviceId.java b/protocol/java/src/solarxr_protocol/datatypes/DeviceId.java deleted file mode 100644 index 3a0f7b187..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/DeviceId.java +++ /dev/null @@ -1,49 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * A unique ID for the device. IDs are not guaranteed to be the same after - * the connection is terminated. - */ -@SuppressWarnings("unused") -public final class DeviceId extends Struct { - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public DeviceId __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public int id() { return bb.get(bb_pos + 0) & 0xFF; } - - public static int createDeviceId(FlatBufferBuilder builder, int id) { - builder.prep(1, 1); - builder.putByte((byte) id); - return builder.offset(); - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public DeviceId get(int j) { return get(new DeviceId(), j); } - public DeviceId get(DeviceId obj, int j) { return obj.__assign(__element(j), bb); } - } - public DeviceIdT unpack() { - DeviceIdT _o = new DeviceIdT(); - unpackTo(_o); - return _o; - } - public void unpackTo(DeviceIdT _o) { - int _oId = id(); - _o.setId(_oId); - } - public static int pack(FlatBufferBuilder builder, DeviceIdT _o) { - if (_o == null) return 0; - return createDeviceId( - builder, - _o.getId()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdT.java b/protocol/java/src/solarxr_protocol/datatypes/DeviceIdT.java deleted file mode 100644 index 2901e01ed..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class DeviceIdT { - private int id; - - public int getId() { return id; } - - public void setId(int id) { this.id = id; } - - - public DeviceIdT() { - this.id = 0; - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTable.java b/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTable.java deleted file mode 100644 index 430d2cfb4..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTable.java +++ /dev/null @@ -1,53 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * To be used inside unions - */ -@SuppressWarnings("unused") -public final class DeviceIdTable extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static DeviceIdTable getRootAsDeviceIdTable(ByteBuffer _bb) { return getRootAsDeviceIdTable(_bb, new DeviceIdTable()); } - public static DeviceIdTable getRootAsDeviceIdTable(ByteBuffer _bb, DeviceIdTable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public DeviceIdTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.datatypes.DeviceId id() { return id(new solarxr_protocol.datatypes.DeviceId()); } - public solarxr_protocol.datatypes.DeviceId id(solarxr_protocol.datatypes.DeviceId obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } - - public static void startDeviceIdTable(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); } - public static int endDeviceIdTable(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public DeviceIdTable get(int j) { return get(new DeviceIdTable(), j); } - public DeviceIdTable get(DeviceIdTable obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public DeviceIdTableT unpack() { - DeviceIdTableT _o = new DeviceIdTableT(); - unpackTo(_o); - return _o; - } - public void unpackTo(DeviceIdTableT _o) { - if (id() != null) id().unpackTo(_o.getId()); - else _o.setId(null); - } - public static int pack(FlatBufferBuilder builder, DeviceIdTableT _o) { - if (_o == null) return 0; - startDeviceIdTable(builder); - addId(builder, solarxr_protocol.datatypes.DeviceId.pack(builder, _o.getId())); - return endDeviceIdTable(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTableT.java b/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTableT.java deleted file mode 100644 index bb158295a..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/DeviceIdTableT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class DeviceIdTableT { - private solarxr_protocol.datatypes.DeviceIdT id; - - public solarxr_protocol.datatypes.DeviceIdT getId() { return id; } - - public void setId(solarxr_protocol.datatypes.DeviceIdT id) { this.id = id; } - - - public DeviceIdTableT() { - this.id = new solarxr_protocol.datatypes.DeviceIdT(); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/StringTable.java b/protocol/java/src/solarxr_protocol/datatypes/StringTable.java deleted file mode 100644 index 764517d38..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/StringTable.java +++ /dev/null @@ -1,59 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class StringTable extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StringTable getRootAsStringTable(ByteBuffer _bb) { return getRootAsStringTable(_bb, new StringTable()); } - public static StringTable getRootAsStringTable(ByteBuffer _bb, StringTable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StringTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public String s() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer sAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer sInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - - public static int createStringTable(FlatBufferBuilder builder, - int sOffset) { - builder.startTable(1); - StringTable.addS(builder, sOffset); - return StringTable.endStringTable(builder); - } - - public static void startStringTable(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addS(FlatBufferBuilder builder, int sOffset) { builder.addOffset(0, sOffset, 0); } - public static int endStringTable(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StringTable get(int j) { return get(new StringTable(), j); } - public StringTable get(StringTable obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StringTableT unpack() { - StringTableT _o = new StringTableT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StringTableT _o) { - String _oS = s(); - _o.setS(_oS); - } - public static int pack(FlatBufferBuilder builder, StringTableT _o) { - if (_o == null) return 0; - int _s = _o.getS() == null ? 0 : builder.createString(_o.getS()); - return createStringTable( - builder, - _s); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/StringTableT.java b/protocol/java/src/solarxr_protocol/datatypes/StringTableT.java deleted file mode 100644 index 193f556d5..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/StringTableT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StringTableT { - private String s; - - public String getS() { return s; } - - public void setS(String s) { this.s = s; } - - - public StringTableT() { - this.s = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/TrackerId.java b/protocol/java/src/solarxr_protocol/datatypes/TrackerId.java deleted file mode 100644 index 252e7b436..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/TrackerId.java +++ /dev/null @@ -1,62 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class TrackerId extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TrackerId getRootAsTrackerId(ByteBuffer _bb) { return getRootAsTrackerId(_bb, new TrackerId()); } - public static TrackerId getRootAsTrackerId(ByteBuffer _bb, TrackerId obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TrackerId __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - /** - * The device the tracker is associated with. If there is no hardware device it is - * associated with, this should be `null`. - */ - public solarxr_protocol.datatypes.DeviceId deviceId() { return deviceId(new solarxr_protocol.datatypes.DeviceId()); } - public solarxr_protocol.datatypes.DeviceId deviceId(solarxr_protocol.datatypes.DeviceId obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } - /** - * There are possibly multiple trackers per device. This identifies which one. - */ - public int trackerNum() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - - public static void startTrackerId(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addDeviceId(FlatBufferBuilder builder, int deviceIdOffset) { builder.addStruct(0, deviceIdOffset, 0); } - public static void addTrackerNum(FlatBufferBuilder builder, int trackerNum) { builder.addByte(1, (byte) trackerNum, (byte) 0); } - public static int endTrackerId(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TrackerId get(int j) { return get(new TrackerId(), j); } - public TrackerId get(TrackerId obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TrackerIdT unpack() { - TrackerIdT _o = new TrackerIdT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TrackerIdT _o) { - if (deviceId() != null) deviceId().unpackTo(_o.getDeviceId()); - else _o.setDeviceId(null); - int _oTrackerNum = trackerNum(); - _o.setTrackerNum(_oTrackerNum); - } - public static int pack(FlatBufferBuilder builder, TrackerIdT _o) { - if (_o == null) return 0; - startTrackerId(builder); - addDeviceId(builder, solarxr_protocol.datatypes.DeviceId.pack(builder, _o.getDeviceId())); - addTrackerNum(builder, _o.getTrackerNum()); - return endTrackerId(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/TrackerIdT.java b/protocol/java/src/solarxr_protocol/datatypes/TrackerIdT.java deleted file mode 100644 index 35ad561ee..000000000 --- a/protocol/java/src/solarxr_protocol/datatypes/TrackerIdT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class TrackerIdT { - private solarxr_protocol.datatypes.DeviceIdT deviceId; - private int trackerNum; - - public solarxr_protocol.datatypes.DeviceIdT getDeviceId() { return deviceId; } - - public void setDeviceId(solarxr_protocol.datatypes.DeviceIdT deviceId) { this.deviceId = deviceId; } - - public int getTrackerNum() { return trackerNum; } - - public void setTrackerNum(int trackerNum) { this.trackerNum = trackerNum; } - - - public TrackerIdT() { - this.deviceId = new solarxr_protocol.datatypes.DeviceIdT(); - this.trackerNum = 0; - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java index e578bb5b4..d55e7adf7 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.java @@ -20,35 +20,35 @@ public final class HardwareStatus extends Table { public boolean hasErrorStatus() { return 0 != __offset(4); } public int errorStatus() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public boolean hasPing() { return 0 != __offset(8); } - public int ping() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public boolean hasPing() { return 0 != __offset(6); } + public int ping() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } /** * "Received Signal Strength Indicator" between device and wifi adapter in dBm */ - public boolean hasRssi() { return 0 != __offset(10); } - public short rssi() { int o = __offset(10); return o != 0 ? bb.getShort(o + bb_pos) : 0; } + public boolean hasRssi() { return 0 != __offset(8); } + public short rssi() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) : 0; } /** * Temperature in degrees celsius */ - public boolean hasMcuTemp() { return 0 != __offset(12); } - public float mcuTemp() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasBatteryVoltage() { return 0 != __offset(14); } - public float batteryVoltage() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasBatteryPctEstimate() { return 0 != __offset(16); } - public int batteryPctEstimate() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasMcuTemp() { return 0 != __offset(10); } + public float mcuTemp() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasBatteryVoltage() { return 0 != __offset(12); } + public float batteryVoltage() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasBatteryPctEstimate() { return 0 != __offset(14); } + public int batteryPctEstimate() { int o = __offset(14); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public solarxr_protocol.datatypes.LogData logData() { return logData(new solarxr_protocol.datatypes.LogData()); } - public solarxr_protocol.datatypes.LogData logData(solarxr_protocol.datatypes.LogData obj) { int o = __offset(18); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public boolean hasPacketLoss() { return 0 != __offset(20); } - public float packetLoss() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasPacketsLost() { return 0 != __offset(22); } - public int packetsLost() { int o = __offset(22); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasPacketsReceived() { return 0 != __offset(24); } - public int packetsReceived() { int o = __offset(24); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public solarxr_protocol.datatypes.LogData logData(solarxr_protocol.datatypes.LogData obj) { int o = __offset(16); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public boolean hasPacketLoss() { return 0 != __offset(18); } + public float packetLoss() { int o = __offset(18); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasPacketsLost() { return 0 != __offset(20); } + public int packetsLost() { int o = __offset(20); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public boolean hasPacketsReceived() { return 0 != __offset(22); } + public int packetsReceived() { int o = __offset(22); return o != 0 ? bb.getInt(o + bb_pos) : 0; } /** * Runtime estimate in microseconds */ - public boolean hasBatteryRuntimeEstimate() { return 0 != __offset(26); } - public long batteryRuntimeEstimate() { int o = __offset(26); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + public boolean hasBatteryRuntimeEstimate() { return 0 != __offset(24); } + public long batteryRuntimeEstimate() { int o = __offset(24); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } public static int createHardwareStatus(FlatBufferBuilder builder, int errorStatus, @@ -62,7 +62,7 @@ public static int createHardwareStatus(FlatBufferBuilder builder, int packetsLost, int packetsReceived, long batteryRuntimeEstimate) { - builder.startTable(12); + builder.startTable(11); HardwareStatus.addBatteryRuntimeEstimate(builder, batteryRuntimeEstimate); HardwareStatus.addPacketsReceived(builder, packetsReceived); HardwareStatus.addPacketsLost(builder, packetsLost); @@ -77,18 +77,18 @@ public static int createHardwareStatus(FlatBufferBuilder builder, return HardwareStatus.endHardwareStatus(builder); } - public static void startHardwareStatus(FlatBufferBuilder builder) { builder.startTable(12); } + public static void startHardwareStatus(FlatBufferBuilder builder) { builder.startTable(11); } public static void addErrorStatus(FlatBufferBuilder builder, int errorStatus) { builder.addByte(0, (byte) errorStatus, (byte) 0); } - public static void addPing(FlatBufferBuilder builder, int ping) { builder.addShort(2, (short) ping, (short) 0); } - public static void addRssi(FlatBufferBuilder builder, short rssi) { builder.addShort(3, rssi, 0); } - public static void addMcuTemp(FlatBufferBuilder builder, float mcuTemp) { builder.addFloat(4, mcuTemp, 0f); } - public static void addBatteryVoltage(FlatBufferBuilder builder, float batteryVoltage) { builder.addFloat(5, batteryVoltage, 0f); } - public static void addBatteryPctEstimate(FlatBufferBuilder builder, int batteryPctEstimate) { builder.addByte(6, (byte) batteryPctEstimate, (byte) 0); } - public static void addLogData(FlatBufferBuilder builder, int logDataOffset) { builder.addOffset(7, logDataOffset, 0); } - public static void addPacketLoss(FlatBufferBuilder builder, float packetLoss) { builder.addFloat(8, packetLoss, 0f); } - public static void addPacketsLost(FlatBufferBuilder builder, int packetsLost) { builder.addInt(9, packetsLost, 0); } - public static void addPacketsReceived(FlatBufferBuilder builder, int packetsReceived) { builder.addInt(10, packetsReceived, 0); } - public static void addBatteryRuntimeEstimate(FlatBufferBuilder builder, long batteryRuntimeEstimate) { builder.addLong(11, batteryRuntimeEstimate, 0L); } + public static void addPing(FlatBufferBuilder builder, int ping) { builder.addShort(1, (short) ping, (short) 0); } + public static void addRssi(FlatBufferBuilder builder, short rssi) { builder.addShort(2, rssi, 0); } + public static void addMcuTemp(FlatBufferBuilder builder, float mcuTemp) { builder.addFloat(3, mcuTemp, 0f); } + public static void addBatteryVoltage(FlatBufferBuilder builder, float batteryVoltage) { builder.addFloat(4, batteryVoltage, 0f); } + public static void addBatteryPctEstimate(FlatBufferBuilder builder, int batteryPctEstimate) { builder.addByte(5, (byte) batteryPctEstimate, (byte) 0); } + public static void addLogData(FlatBufferBuilder builder, int logDataOffset) { builder.addOffset(6, logDataOffset, 0); } + public static void addPacketLoss(FlatBufferBuilder builder, float packetLoss) { builder.addFloat(7, packetLoss, 0f); } + public static void addPacketsLost(FlatBufferBuilder builder, int packetsLost) { builder.addInt(8, packetsLost, 0); } + public static void addPacketsReceived(FlatBufferBuilder builder, int packetsReceived) { builder.addInt(9, packetsReceived, 0); } + public static void addBatteryRuntimeEstimate(FlatBufferBuilder builder, long batteryRuntimeEstimate) { builder.addLong(10, batteryRuntimeEstimate, 0L); } public static int endHardwareStatus(FlatBufferBuilder builder) { int o = builder.endTable(); return o; diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/ImuType.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/ImuType.java index 51ab8e264..fa6128ff5 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/ImuType.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/ImuType.java @@ -5,7 +5,7 @@ @SuppressWarnings("unused") public final class ImuType { private ImuType() { } - public static final int Other = 0; + public static final int UNKNOWN = 0; public static final int MPU9250 = 1; public static final int MPU6500 = 2; public static final int BNO080 = 3; diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/McuType.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/McuType.java index 05b810d6f..a020d794c 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/McuType.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/McuType.java @@ -5,7 +5,7 @@ @SuppressWarnings("unused") public final class McuType { private McuType() { } - public static final int Other = 0; + public static final int UNKNOWN = 0; public static final int ESP8266 = 1; public static final int ESP32 = 2; public static final int OWOTRACK_ANDROID = 3; diff --git a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.java b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.java index 12372c268..0e473f48e 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.java +++ b/protocol/java/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.java @@ -3,7 +3,7 @@ package solarxr_protocol.datatypes.hardware_info; /** - * What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. + * What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. */ @SuppressWarnings("unused") public final class TrackerDataType { diff --git a/protocol/java/src/solarxr_protocol/pub_sub/KeyValues.java b/protocol/java/src/solarxr_protocol/pub_sub/KeyValues.java deleted file mode 100644 index f5a4c6b85..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/KeyValues.java +++ /dev/null @@ -1,89 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class KeyValues extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static KeyValues getRootAsKeyValues(ByteBuffer _bb) { return getRootAsKeyValues(_bb, new KeyValues()); } - public static KeyValues getRootAsKeyValues(ByteBuffer _bb, KeyValues obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public KeyValues __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public String keys(int j) { int o = __offset(4); return o != 0 ? __string(__vector(o) + j * 4) : null; } - public int keysLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public StringVector keysVector() { return keysVector(new StringVector()); } - public StringVector keysVector(StringVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - public String values(int j) { int o = __offset(6); return o != 0 ? __string(__vector(o) + j * 4) : null; } - public int valuesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } - public StringVector valuesVector() { return valuesVector(new StringVector()); } - public StringVector valuesVector(StringVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - - public static int createKeyValues(FlatBufferBuilder builder, - int keysOffset, - int valuesOffset) { - builder.startTable(2); - KeyValues.addValues(builder, valuesOffset); - KeyValues.addKeys(builder, keysOffset); - return KeyValues.endKeyValues(builder); - } - - public static void startKeyValues(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addKeys(FlatBufferBuilder builder, int keysOffset) { builder.addOffset(0, keysOffset, 0); } - public static int createKeysVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startKeysVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static void addValues(FlatBufferBuilder builder, int valuesOffset) { builder.addOffset(1, valuesOffset, 0); } - public static int createValuesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startValuesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static int endKeyValues(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public KeyValues get(int j) { return get(new KeyValues(), j); } - public KeyValues get(KeyValues obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public KeyValuesT unpack() { - KeyValuesT _o = new KeyValuesT(); - unpackTo(_o); - return _o; - } - public void unpackTo(KeyValuesT _o) { - String[] _oKeys = new String[keysLength()]; - for (int _j = 0; _j < keysLength(); ++_j) {_oKeys[_j] = keys(_j);} - _o.setKeys(_oKeys); - String[] _oValues = new String[valuesLength()]; - for (int _j = 0; _j < valuesLength(); ++_j) {_oValues[_j] = values(_j);} - _o.setValues(_oValues); - } - public static int pack(FlatBufferBuilder builder, KeyValuesT _o) { - if (_o == null) return 0; - int _keys = 0; - if (_o.getKeys() != null) { - int[] __keys = new int[_o.getKeys().length]; - int _j = 0; - for (String _e : _o.getKeys()) { __keys[_j] = builder.createString(_e); _j++;} - _keys = createKeysVector(builder, __keys); - } - int _values = 0; - if (_o.getValues() != null) { - int[] __values = new int[_o.getValues().length]; - int _j = 0; - for (String _e : _o.getValues()) { __values[_j] = builder.createString(_e); _j++;} - _values = createValuesVector(builder, __values); - } - return createKeyValues( - builder, - _keys, - _values); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/KeyValuesT.java b/protocol/java/src/solarxr_protocol/pub_sub/KeyValuesT.java deleted file mode 100644 index 7616240da..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/KeyValuesT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class KeyValuesT { - private String[] keys; - private String[] values; - - public String[] getKeys() { return keys; } - - public void setKeys(String[] keys) { this.keys = keys; } - - public String[] getValues() { return values; } - - public void setValues(String[] values) { this.values = values; } - - - public KeyValuesT() { - this.keys = null; - this.values = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/Message.java b/protocol/java/src/solarxr_protocol/pub_sub/Message.java deleted file mode 100644 index 8989e5eea..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/Message.java +++ /dev/null @@ -1,112 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Data that is sent from publishers to subscribers - */ -@SuppressWarnings("unused") -public final class Message extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static Message getRootAsMessage(ByteBuffer _bb) { return getRootAsMessage(_bb, new Message()); } - public static Message getRootAsMessage(ByteBuffer _bb, Message obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public Message __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public byte topicType() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; } - public Table topic(Table obj) { int o = __offset(6); return o != 0 ? __union(obj, o + bb_pos) : null; } - public byte payloadType() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) : 0; } - public Table payload(Table obj) { int o = __offset(10); return o != 0 ? __union(obj, o + bb_pos) : null; } - - public static int createMessage(FlatBufferBuilder builder, - byte topicType, - int topicOffset, - byte payloadType, - int payloadOffset) { - builder.startTable(4); - Message.addPayload(builder, payloadOffset); - Message.addTopic(builder, topicOffset); - Message.addPayloadType(builder, payloadType); - Message.addTopicType(builder, topicType); - return Message.endMessage(builder); - } - - public static void startMessage(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addTopicType(FlatBufferBuilder builder, byte topicType) { builder.addByte(0, topicType, 0); } - public static void addTopic(FlatBufferBuilder builder, int topicOffset) { builder.addOffset(1, topicOffset, 0); } - public static void addPayloadType(FlatBufferBuilder builder, byte payloadType) { builder.addByte(2, payloadType, 0); } - public static void addPayload(FlatBufferBuilder builder, int payloadOffset) { builder.addOffset(3, payloadOffset, 0); } - public static int endMessage(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public Message get(int j) { return get(new Message(), j); } - public Message get(Message obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public MessageT unpack() { - MessageT _o = new MessageT(); - unpackTo(_o); - return _o; - } - public void unpackTo(MessageT _o) { - solarxr_protocol.pub_sub.TopicUnion _oTopic = new solarxr_protocol.pub_sub.TopicUnion(); - byte _oTopicType = topicType(); - _oTopic.setType(_oTopicType); - Table _oTopicValue; - switch (_oTopicType) { - case solarxr_protocol.pub_sub.Topic.TopicHandle: - _oTopicValue = topic(new solarxr_protocol.pub_sub.TopicHandle()); - _oTopic.setValue(_oTopicValue != null ? ((solarxr_protocol.pub_sub.TopicHandle) _oTopicValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.Topic.TopicId: - _oTopicValue = topic(new solarxr_protocol.pub_sub.TopicId()); - _oTopic.setValue(_oTopicValue != null ? ((solarxr_protocol.pub_sub.TopicId) _oTopicValue).unpack() : null); - break; - default: break; - } - _o.setTopic(_oTopic); - solarxr_protocol.pub_sub.PayloadUnion _oPayload = new solarxr_protocol.pub_sub.PayloadUnion(); - byte _oPayloadType = payloadType(); - _oPayload.setType(_oPayloadType); - Table _oPayloadValue; - switch (_oPayloadType) { - case solarxr_protocol.pub_sub.Payload.solarxr_protocol_datatypes_StringTable: - _oPayloadValue = payload(new solarxr_protocol.datatypes.StringTable()); - _oPayload.setValue(_oPayloadValue != null ? ((solarxr_protocol.datatypes.StringTable) _oPayloadValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.Payload.solarxr_protocol_datatypes_Bytes: - _oPayloadValue = payload(new solarxr_protocol.datatypes.Bytes()); - _oPayload.setValue(_oPayloadValue != null ? ((solarxr_protocol.datatypes.Bytes) _oPayloadValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.Payload.KeyValues: - _oPayloadValue = payload(new solarxr_protocol.pub_sub.KeyValues()); - _oPayload.setValue(_oPayloadValue != null ? ((solarxr_protocol.pub_sub.KeyValues) _oPayloadValue).unpack() : null); - break; - default: break; - } - _o.setPayload(_oPayload); - } - public static int pack(FlatBufferBuilder builder, MessageT _o) { - if (_o == null) return 0; - byte _topicType = _o.getTopic() == null ? solarxr_protocol.pub_sub.Topic.NONE : _o.getTopic().getType(); - int _topic = _o.getTopic() == null ? 0 : solarxr_protocol.pub_sub.TopicUnion.pack(builder, _o.getTopic()); - byte _payloadType = _o.getPayload() == null ? solarxr_protocol.pub_sub.Payload.NONE : _o.getPayload().getType(); - int _payload = _o.getPayload() == null ? 0 : solarxr_protocol.pub_sub.PayloadUnion.pack(builder, _o.getPayload()); - return createMessage( - builder, - _topicType, - _topic, - _payloadType, - _payload); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/MessageT.java b/protocol/java/src/solarxr_protocol/pub_sub/MessageT.java deleted file mode 100644 index 87b3aa5d5..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/MessageT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class MessageT { - private solarxr_protocol.pub_sub.TopicUnion topic; - private solarxr_protocol.pub_sub.PayloadUnion payload; - - public solarxr_protocol.pub_sub.TopicUnion getTopic() { return topic; } - - public void setTopic(solarxr_protocol.pub_sub.TopicUnion topic) { this.topic = topic; } - - public solarxr_protocol.pub_sub.PayloadUnion getPayload() { return payload; } - - public void setPayload(solarxr_protocol.pub_sub.PayloadUnion payload) { this.payload = payload; } - - - public MessageT() { - this.topic = null; - this.payload = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/Payload.java b/protocol/java/src/solarxr_protocol/pub_sub/Payload.java deleted file mode 100644 index a6c5bba70..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/Payload.java +++ /dev/null @@ -1,17 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -@SuppressWarnings("unused") -public final class Payload { - private Payload() { } - public static final byte NONE = 0; - public static final byte solarxr_protocol_datatypes_StringTable = 1; - public static final byte solarxr_protocol_datatypes_Bytes = 2; - public static final byte KeyValues = 3; - - public static final String[] names = { "NONE", "solarxr_protocol_datatypes_StringTable", "solarxr_protocol_datatypes_Bytes", "KeyValues", }; - - public static String name(int e) { return names[e]; } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/PayloadUnion.java b/protocol/java/src/solarxr_protocol/pub_sub/PayloadUnion.java deleted file mode 100644 index a54ee59fb..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/PayloadUnion.java +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import com.google.flatbuffers.FlatBufferBuilder; - -public class PayloadUnion { - private byte type; - private Object value; - - public byte getType() { return type; } - - public void setType(byte type) { this.type = type; } - - public Object getValue() { return value; } - - public void setValue(Object value) { this.value = value; } - - public PayloadUnion() { - this.type = Payload.NONE; - this.value = null; - } - - public solarxr_protocol.datatypes.StringTableT assolarxr_protocol_datatypes_StringTable() { return (solarxr_protocol.datatypes.StringTableT) value; } - public solarxr_protocol.datatypes.BytesT assolarxr_protocol_datatypes_Bytes() { return (solarxr_protocol.datatypes.BytesT) value; } - public solarxr_protocol.pub_sub.KeyValuesT asKeyValues() { return (solarxr_protocol.pub_sub.KeyValuesT) value; } - - public static int pack(FlatBufferBuilder builder, PayloadUnion _o) { - switch (_o.type) { - case Payload.solarxr_protocol_datatypes_StringTable: return solarxr_protocol.datatypes.StringTable.pack(builder, _o.assolarxr_protocol_datatypes_StringTable()); - case Payload.solarxr_protocol_datatypes_Bytes: return solarxr_protocol.datatypes.Bytes.pack(builder, _o.assolarxr_protocol_datatypes_Bytes()); - case Payload.KeyValues: return solarxr_protocol.pub_sub.KeyValues.pack(builder, _o.asKeyValues()); - default: return 0; - } - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeader.java b/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeader.java deleted file mode 100644 index e64ffd836..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeader.java +++ /dev/null @@ -1,85 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class PubSubHeader extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static PubSubHeader getRootAsPubSubHeader(ByteBuffer _bb) { return getRootAsPubSubHeader(_bb, new PubSubHeader()); } - public static PubSubHeader getRootAsPubSubHeader(ByteBuffer _bb, PubSubHeader obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public PubSubHeader __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public byte uType() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; } - public Table u(Table obj) { int o = __offset(6); return o != 0 ? __union(obj, o + bb_pos) : null; } - - public static int createPubSubHeader(FlatBufferBuilder builder, - byte uType, - int uOffset) { - builder.startTable(2); - PubSubHeader.addU(builder, uOffset); - PubSubHeader.addUType(builder, uType); - return PubSubHeader.endPubSubHeader(builder); - } - - public static void startPubSubHeader(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addUType(FlatBufferBuilder builder, byte uType) { builder.addByte(0, uType, 0); } - public static void addU(FlatBufferBuilder builder, int uOffset) { builder.addOffset(1, uOffset, 0); } - public static int endPubSubHeader(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public PubSubHeader get(int j) { return get(new PubSubHeader(), j); } - public PubSubHeader get(PubSubHeader obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public PubSubHeaderT unpack() { - PubSubHeaderT _o = new PubSubHeaderT(); - unpackTo(_o); - return _o; - } - public void unpackTo(PubSubHeaderT _o) { - solarxr_protocol.pub_sub.PubSubUnionUnion _oU = new solarxr_protocol.pub_sub.PubSubUnionUnion(); - byte _oUType = uType(); - _oU.setType(_oUType); - Table _oUValue; - switch (_oUType) { - case solarxr_protocol.pub_sub.PubSubUnion.Message: - _oUValue = u(new solarxr_protocol.pub_sub.Message()); - _oU.setValue(_oUValue != null ? ((solarxr_protocol.pub_sub.Message) _oUValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.PubSubUnion.SubscriptionRequest: - _oUValue = u(new solarxr_protocol.pub_sub.SubscriptionRequest()); - _oU.setValue(_oUValue != null ? ((solarxr_protocol.pub_sub.SubscriptionRequest) _oUValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.PubSubUnion.TopicHandleRequest: - _oUValue = u(new solarxr_protocol.pub_sub.TopicHandleRequest()); - _oU.setValue(_oUValue != null ? ((solarxr_protocol.pub_sub.TopicHandleRequest) _oUValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.PubSubUnion.TopicMapping: - _oUValue = u(new solarxr_protocol.pub_sub.TopicMapping()); - _oU.setValue(_oUValue != null ? ((solarxr_protocol.pub_sub.TopicMapping) _oUValue).unpack() : null); - break; - default: break; - } - _o.setU(_oU); - } - public static int pack(FlatBufferBuilder builder, PubSubHeaderT _o) { - if (_o == null) return 0; - byte _uType = _o.getU() == null ? solarxr_protocol.pub_sub.PubSubUnion.NONE : _o.getU().getType(); - int _u = _o.getU() == null ? 0 : solarxr_protocol.pub_sub.PubSubUnionUnion.pack(builder, _o.getU()); - return createPubSubHeader( - builder, - _uType, - _u); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeaderT.java b/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeaderT.java deleted file mode 100644 index 7098f81b2..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/PubSubHeaderT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class PubSubHeaderT { - private solarxr_protocol.pub_sub.PubSubUnionUnion u; - - public solarxr_protocol.pub_sub.PubSubUnionUnion getU() { return u; } - - public void setU(solarxr_protocol.pub_sub.PubSubUnionUnion u) { this.u = u; } - - - public PubSubHeaderT() { - this.u = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnion.java b/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnion.java deleted file mode 100644 index 698b203a9..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnion.java +++ /dev/null @@ -1,18 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -@SuppressWarnings("unused") -public final class PubSubUnion { - private PubSubUnion() { } - public static final byte NONE = 0; - public static final byte Message = 1; - public static final byte SubscriptionRequest = 2; - public static final byte TopicHandleRequest = 3; - public static final byte TopicMapping = 4; - - public static final String[] names = { "NONE", "Message", "SubscriptionRequest", "TopicHandleRequest", "TopicMapping", }; - - public static String name(int e) { return names[e]; } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnionUnion.java b/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnionUnion.java deleted file mode 100644 index f413196f0..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/PubSubUnionUnion.java +++ /dev/null @@ -1,39 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import com.google.flatbuffers.FlatBufferBuilder; - -public class PubSubUnionUnion { - private byte type; - private Object value; - - public byte getType() { return type; } - - public void setType(byte type) { this.type = type; } - - public Object getValue() { return value; } - - public void setValue(Object value) { this.value = value; } - - public PubSubUnionUnion() { - this.type = PubSubUnion.NONE; - this.value = null; - } - - public solarxr_protocol.pub_sub.MessageT asMessage() { return (solarxr_protocol.pub_sub.MessageT) value; } - public solarxr_protocol.pub_sub.SubscriptionRequestT asSubscriptionRequest() { return (solarxr_protocol.pub_sub.SubscriptionRequestT) value; } - public solarxr_protocol.pub_sub.TopicHandleRequestT asTopicHandleRequest() { return (solarxr_protocol.pub_sub.TopicHandleRequestT) value; } - public solarxr_protocol.pub_sub.TopicMappingT asTopicMapping() { return (solarxr_protocol.pub_sub.TopicMappingT) value; } - - public static int pack(FlatBufferBuilder builder, PubSubUnionUnion _o) { - switch (_o.type) { - case PubSubUnion.Message: return solarxr_protocol.pub_sub.Message.pack(builder, _o.asMessage()); - case PubSubUnion.SubscriptionRequest: return solarxr_protocol.pub_sub.SubscriptionRequest.pack(builder, _o.asSubscriptionRequest()); - case PubSubUnion.TopicHandleRequest: return solarxr_protocol.pub_sub.TopicHandleRequest.pack(builder, _o.asTopicHandleRequest()); - case PubSubUnion.TopicMapping: return solarxr_protocol.pub_sub.TopicMapping.pack(builder, _o.asTopicMapping()); - default: return 0; - } - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequest.java b/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequest.java deleted file mode 100644 index cd05f42ac..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequest.java +++ /dev/null @@ -1,80 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Requests a subscription to `topic`. Replies with a `TopicMapping`. - */ -@SuppressWarnings("unused") -public final class SubscriptionRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SubscriptionRequest getRootAsSubscriptionRequest(ByteBuffer _bb) { return getRootAsSubscriptionRequest(_bb, new SubscriptionRequest()); } - public static SubscriptionRequest getRootAsSubscriptionRequest(ByteBuffer _bb, SubscriptionRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SubscriptionRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public byte topicType() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; } - public Table topic(Table obj) { int o = __offset(6); return o != 0 ? __union(obj, o + bb_pos) : null; } - - public static int createSubscriptionRequest(FlatBufferBuilder builder, - byte topicType, - int topicOffset) { - builder.startTable(2); - SubscriptionRequest.addTopic(builder, topicOffset); - SubscriptionRequest.addTopicType(builder, topicType); - return SubscriptionRequest.endSubscriptionRequest(builder); - } - - public static void startSubscriptionRequest(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addTopicType(FlatBufferBuilder builder, byte topicType) { builder.addByte(0, topicType, 0); } - public static void addTopic(FlatBufferBuilder builder, int topicOffset) { builder.addOffset(1, topicOffset, 0); } - public static int endSubscriptionRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SubscriptionRequest get(int j) { return get(new SubscriptionRequest(), j); } - public SubscriptionRequest get(SubscriptionRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SubscriptionRequestT unpack() { - SubscriptionRequestT _o = new SubscriptionRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SubscriptionRequestT _o) { - solarxr_protocol.pub_sub.TopicUnion _oTopic = new solarxr_protocol.pub_sub.TopicUnion(); - byte _oTopicType = topicType(); - _oTopic.setType(_oTopicType); - Table _oTopicValue; - switch (_oTopicType) { - case solarxr_protocol.pub_sub.Topic.TopicHandle: - _oTopicValue = topic(new solarxr_protocol.pub_sub.TopicHandle()); - _oTopic.setValue(_oTopicValue != null ? ((solarxr_protocol.pub_sub.TopicHandle) _oTopicValue).unpack() : null); - break; - case solarxr_protocol.pub_sub.Topic.TopicId: - _oTopicValue = topic(new solarxr_protocol.pub_sub.TopicId()); - _oTopic.setValue(_oTopicValue != null ? ((solarxr_protocol.pub_sub.TopicId) _oTopicValue).unpack() : null); - break; - default: break; - } - _o.setTopic(_oTopic); - } - public static int pack(FlatBufferBuilder builder, SubscriptionRequestT _o) { - if (_o == null) return 0; - byte _topicType = _o.getTopic() == null ? solarxr_protocol.pub_sub.Topic.NONE : _o.getTopic().getType(); - int _topic = _o.getTopic() == null ? 0 : solarxr_protocol.pub_sub.TopicUnion.pack(builder, _o.getTopic()); - return createSubscriptionRequest( - builder, - _topicType, - _topic); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequestT.java b/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequestT.java deleted file mode 100644 index f17a8e0b8..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/SubscriptionRequestT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class SubscriptionRequestT { - private solarxr_protocol.pub_sub.TopicUnion topic; - - public solarxr_protocol.pub_sub.TopicUnion getTopic() { return topic; } - - public void setTopic(solarxr_protocol.pub_sub.TopicUnion topic) { this.topic = topic; } - - - public SubscriptionRequestT() { - this.topic = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/Topic.java b/protocol/java/src/solarxr_protocol/pub_sub/Topic.java deleted file mode 100644 index e368064ce..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/Topic.java +++ /dev/null @@ -1,16 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -@SuppressWarnings("unused") -public final class Topic { - private Topic() { } - public static final byte NONE = 0; - public static final byte TopicHandle = 1; - public static final byte TopicId = 2; - - public static final String[] names = { "NONE", "TopicHandle", "TopicId", }; - - public static String name(int e) { return names[e]; } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandle.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicHandle.java deleted file mode 100644 index 0f91d6c56..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandle.java +++ /dev/null @@ -1,60 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * A handle for the topic, allows referencing a topic without sending a huge - * `TopicId`. - */ -@SuppressWarnings("unused") -public final class TopicHandle extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TopicHandle getRootAsTopicHandle(ByteBuffer _bb) { return getRootAsTopicHandle(_bb, new TopicHandle()); } - public static TopicHandle getRootAsTopicHandle(ByteBuffer _bb, TopicHandle obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TopicHandle __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public int id() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } - - public static int createTopicHandle(FlatBufferBuilder builder, - int id) { - builder.startTable(1); - TopicHandle.addId(builder, id); - return TopicHandle.endTopicHandle(builder); - } - - public static void startTopicHandle(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addId(FlatBufferBuilder builder, int id) { builder.addShort(0, (short) id, (short) 0); } - public static int endTopicHandle(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TopicHandle get(int j) { return get(new TopicHandle(), j); } - public TopicHandle get(TopicHandle obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TopicHandleT unpack() { - TopicHandleT _o = new TopicHandleT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TopicHandleT _o) { - int _oId = id(); - _o.setId(_oId); - } - public static int pack(FlatBufferBuilder builder, TopicHandleT _o) { - if (_o == null) return 0; - return createTopicHandle( - builder, - _o.getId()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequest.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequest.java deleted file mode 100644 index 5333e9541..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequest.java +++ /dev/null @@ -1,62 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing - * bandwidth, since `FeatureId` can be large. - */ -@SuppressWarnings("unused") -public final class TopicHandleRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TopicHandleRequest getRootAsTopicHandleRequest(ByteBuffer _bb) { return getRootAsTopicHandleRequest(_bb, new TopicHandleRequest()); } - public static TopicHandleRequest getRootAsTopicHandleRequest(ByteBuffer _bb, TopicHandleRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TopicHandleRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.pub_sub.TopicId id() { return id(new solarxr_protocol.pub_sub.TopicId()); } - public solarxr_protocol.pub_sub.TopicId id(solarxr_protocol.pub_sub.TopicId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createTopicHandleRequest(FlatBufferBuilder builder, - int idOffset) { - builder.startTable(1); - TopicHandleRequest.addId(builder, idOffset); - return TopicHandleRequest.endTopicHandleRequest(builder); - } - - public static void startTopicHandleRequest(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addOffset(0, idOffset, 0); } - public static int endTopicHandleRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TopicHandleRequest get(int j) { return get(new TopicHandleRequest(), j); } - public TopicHandleRequest get(TopicHandleRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TopicHandleRequestT unpack() { - TopicHandleRequestT _o = new TopicHandleRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TopicHandleRequestT _o) { - if (id() != null) _o.setId(id().unpack()); - else _o.setId(null); - } - public static int pack(FlatBufferBuilder builder, TopicHandleRequestT _o) { - if (_o == null) return 0; - int _id = _o.getId() == null ? 0 : solarxr_protocol.pub_sub.TopicId.pack(builder, _o.getId()); - return createTopicHandleRequest( - builder, - _id); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequestT.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequestT.java deleted file mode 100644 index acf0811fe..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleRequestT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class TopicHandleRequestT { - private solarxr_protocol.pub_sub.TopicIdT id; - - public solarxr_protocol.pub_sub.TopicIdT getId() { return id; } - - public void setId(solarxr_protocol.pub_sub.TopicIdT id) { this.id = id; } - - - public TopicHandleRequestT() { - this.id = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicId.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicId.java deleted file mode 100644 index 8a43f7f7d..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicId.java +++ /dev/null @@ -1,98 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * A `TopicId` identifies an application-specific category of data. Because it - * is application-specific, it is up to the application within the specified - * organization to define its semantics/meaning. - * - * For example, "bob" may have an "overlay" app with a "settings" topic for controlling - * the overlay visibility and other settings, as well as a "video feed" topic for - * allowing other applications to display video data in a wrist mounted window in VR. - */ -@SuppressWarnings("unused") -public final class TopicId extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TopicId getRootAsTopicId(ByteBuffer _bb) { return getRootAsTopicId(_bb, new TopicId()); } - public static TopicId getRootAsTopicId(ByteBuffer _bb, TopicId obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TopicId __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - /** - * The organization/developer that defines the meaning of this feature. Avoids name - * clashes. Should be something unique - same idea as java package identifier. - */ - public String organization() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer organizationAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer organizationInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - /** - * The name of the application/device. Should be unique within the organization. - */ - public String appName() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer appNameAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } - public ByteBuffer appNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } - /** - * The name of the topic. Should be unique within the application. - */ - public String topic() { int o = __offset(8); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer topicAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } - public ByteBuffer topicInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } - - public static int createTopicId(FlatBufferBuilder builder, - int organizationOffset, - int appNameOffset, - int topicOffset) { - builder.startTable(3); - TopicId.addTopic(builder, topicOffset); - TopicId.addAppName(builder, appNameOffset); - TopicId.addOrganization(builder, organizationOffset); - return TopicId.endTopicId(builder); - } - - public static void startTopicId(FlatBufferBuilder builder) { builder.startTable(3); } - public static void addOrganization(FlatBufferBuilder builder, int organizationOffset) { builder.addOffset(0, organizationOffset, 0); } - public static void addAppName(FlatBufferBuilder builder, int appNameOffset) { builder.addOffset(1, appNameOffset, 0); } - public static void addTopic(FlatBufferBuilder builder, int topicOffset) { builder.addOffset(2, topicOffset, 0); } - public static int endTopicId(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TopicId get(int j) { return get(new TopicId(), j); } - public TopicId get(TopicId obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TopicIdT unpack() { - TopicIdT _o = new TopicIdT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TopicIdT _o) { - String _oOrganization = organization(); - _o.setOrganization(_oOrganization); - String _oAppName = appName(); - _o.setAppName(_oAppName); - String _oTopic = topic(); - _o.setTopic(_oTopic); - } - public static int pack(FlatBufferBuilder builder, TopicIdT _o) { - if (_o == null) return 0; - int _organization = _o.getOrganization() == null ? 0 : builder.createString(_o.getOrganization()); - int _appName = _o.getAppName() == null ? 0 : builder.createString(_o.getAppName()); - int _topic = _o.getTopic() == null ? 0 : builder.createString(_o.getTopic()); - return createTopicId( - builder, - _organization, - _appName, - _topic); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicIdT.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicIdT.java deleted file mode 100644 index 8359c9646..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicIdT.java +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class TopicIdT { - private String organization; - private String appName; - private String topic; - - public String getOrganization() { return organization; } - - public void setOrganization(String organization) { this.organization = organization; } - - public String getAppName() { return appName; } - - public void setAppName(String appName) { this.appName = appName; } - - public String getTopic() { return topic; } - - public void setTopic(String topic) { this.topic = topic; } - - - public TopicIdT() { - this.organization = null; - this.appName = null; - this.topic = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicMapping.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicMapping.java deleted file mode 100644 index 2672edd6f..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicMapping.java +++ /dev/null @@ -1,70 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Response for `TopicHandleRequest` or `SubscriptionRequest`. - */ -@SuppressWarnings("unused") -public final class TopicMapping extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TopicMapping getRootAsTopicMapping(ByteBuffer _bb) { return getRootAsTopicMapping(_bb, new TopicMapping()); } - public static TopicMapping getRootAsTopicMapping(ByteBuffer _bb, TopicMapping obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TopicMapping __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.pub_sub.TopicId id() { return id(new solarxr_protocol.pub_sub.TopicId()); } - public solarxr_protocol.pub_sub.TopicId id(solarxr_protocol.pub_sub.TopicId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.pub_sub.TopicHandle handle() { return handle(new solarxr_protocol.pub_sub.TopicHandle()); } - public solarxr_protocol.pub_sub.TopicHandle handle(solarxr_protocol.pub_sub.TopicHandle obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createTopicMapping(FlatBufferBuilder builder, - int idOffset, - int handleOffset) { - builder.startTable(2); - TopicMapping.addHandle(builder, handleOffset); - TopicMapping.addId(builder, idOffset); - return TopicMapping.endTopicMapping(builder); - } - - public static void startTopicMapping(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addOffset(0, idOffset, 0); } - public static void addHandle(FlatBufferBuilder builder, int handleOffset) { builder.addOffset(1, handleOffset, 0); } - public static int endTopicMapping(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TopicMapping get(int j) { return get(new TopicMapping(), j); } - public TopicMapping get(TopicMapping obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TopicMappingT unpack() { - TopicMappingT _o = new TopicMappingT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TopicMappingT _o) { - if (id() != null) _o.setId(id().unpack()); - else _o.setId(null); - if (handle() != null) _o.setHandle(handle().unpack()); - else _o.setHandle(null); - } - public static int pack(FlatBufferBuilder builder, TopicMappingT _o) { - if (_o == null) return 0; - int _id = _o.getId() == null ? 0 : solarxr_protocol.pub_sub.TopicId.pack(builder, _o.getId()); - int _handle = _o.getHandle() == null ? 0 : solarxr_protocol.pub_sub.TopicHandle.pack(builder, _o.getHandle()); - return createTopicMapping( - builder, - _id, - _handle); - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicMappingT.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicMappingT.java deleted file mode 100644 index 8429afa42..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicMappingT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class TopicMappingT { - private solarxr_protocol.pub_sub.TopicIdT id; - private solarxr_protocol.pub_sub.TopicHandleT handle; - - public solarxr_protocol.pub_sub.TopicIdT getId() { return id; } - - public void setId(solarxr_protocol.pub_sub.TopicIdT id) { this.id = id; } - - public solarxr_protocol.pub_sub.TopicHandleT getHandle() { return handle; } - - public void setHandle(solarxr_protocol.pub_sub.TopicHandleT handle) { this.handle = handle; } - - - public TopicMappingT() { - this.id = null; - this.handle = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicUnion.java b/protocol/java/src/solarxr_protocol/pub_sub/TopicUnion.java deleted file mode 100644 index 02b964404..000000000 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicUnion.java +++ /dev/null @@ -1,35 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub; - -import com.google.flatbuffers.FlatBufferBuilder; - -public class TopicUnion { - private byte type; - private Object value; - - public byte getType() { return type; } - - public void setType(byte type) { this.type = type; } - - public Object getValue() { return value; } - - public void setValue(Object value) { this.value = value; } - - public TopicUnion() { - this.type = Topic.NONE; - this.value = null; - } - - public solarxr_protocol.pub_sub.TopicHandleT asTopicHandle() { return (solarxr_protocol.pub_sub.TopicHandleT) value; } - public solarxr_protocol.pub_sub.TopicIdT asTopicId() { return (solarxr_protocol.pub_sub.TopicIdT) value; } - - public static int pack(FlatBufferBuilder builder, TopicUnion _o) { - switch (_o.type) { - case Topic.TopicHandle: return solarxr_protocol.pub_sub.TopicHandle.pack(builder, _o.asTopicHandle()); - case Topic.TopicId: return solarxr_protocol.pub_sub.TopicId.pack(builder, _o.asTopicId()); - default: return 0; - } - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ArmsMountingResetMode.java b/protocol/java/src/solarxr_protocol/rpc/ArmsMountingResetMode.java deleted file mode 100644 index 2a8bf5dce..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/ArmsMountingResetMode.java +++ /dev/null @@ -1,29 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -@SuppressWarnings("unused") -public final class ArmsMountingResetMode { - private ArmsMountingResetMode() { } - /** - * Upper arm going back and forearm going forward - */ - public static final int BACK = 0; - /** - * Arms going forward - */ - public static final int FORWARD = 1; - /** - * Arms going up to the sides into a tpose - */ - public static final int TPOSE_UP = 2; - /** - * Arms going down to the sides from a tpose - */ - public static final int TPOSE_DOWN = 3; - - public static final String[] names = { "BACK", "FORWARD", "TPOSE_UP", "TPOSE_DOWN", }; - - public static String name(int e) { return names[e]; } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ArmsResetMode.java b/protocol/java/src/solarxr_protocol/rpc/ArmsResetMode.java new file mode 100644 index 000000000..ff56d077e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ArmsResetMode.java @@ -0,0 +1,29 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class ArmsResetMode { + private ArmsResetMode() { } + /** + * Down to the sides for full. Upper arm going back and forearm going forward for mounting. + */ + public static final int BACK = 0; + /** + * Down to the sides for full. Arms going forward for mounting. + */ + public static final int FORWARD = 1; + /** + * Down to the sides for full. T-pose for mounting. + */ + public static final int T_POSE_UP = 2; + /** + * T-pose for full. Down to the sides for mounting. + */ + public static final int T_POSE_DOWN = 3; + + public static final String[] names = { "BACK", "FORWARD", "T_POSE_UP", "T_POSE_DOWN", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequest.java b/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequest.java index 466465ca4..075927a74 100644 --- a/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequest.java +++ b/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequest.java @@ -15,22 +15,19 @@ public final class AssignTrackerRequest extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public AssignTrackerRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public int bodyPosition() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public solarxr_protocol.datatypes.math.Quat mountingOrientation() { return mountingOrientation(new solarxr_protocol.datatypes.math.Quat()); } public solarxr_protocol.datatypes.math.Quat mountingOrientation(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(8); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } public String displayName() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; } public ByteBuffer displayNameAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } public ByteBuffer displayNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } - public boolean allowDriftCompensation() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public static void startAssignTrackerRequest(FlatBufferBuilder builder) { builder.startTable(5); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void startAssignTrackerRequest(FlatBufferBuilder builder) { builder.startTable(4); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static void addBodyPosition(FlatBufferBuilder builder, int bodyPosition) { builder.addByte(1, (byte) bodyPosition, (byte) 0); } public static void addMountingOrientation(FlatBufferBuilder builder, int mountingOrientationOffset) { builder.addStruct(2, mountingOrientationOffset, 0); } public static void addDisplayName(FlatBufferBuilder builder, int displayNameOffset) { builder.addOffset(3, displayNameOffset, 0); } - public static void addAllowDriftCompensation(FlatBufferBuilder builder, boolean allowDriftCompensation) { builder.addBoolean(4, allowDriftCompensation, false); } public static int endAssignTrackerRequest(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -48,27 +45,23 @@ public AssignTrackerRequestT unpack() { return _o; } public void unpackTo(AssignTrackerRequestT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); int _oBodyPosition = bodyPosition(); _o.setBodyPosition(_oBodyPosition); if (mountingOrientation() != null) mountingOrientation().unpackTo(_o.getMountingOrientation()); else _o.setMountingOrientation(null); String _oDisplayName = displayName(); _o.setDisplayName(_oDisplayName); - boolean _oAllowDriftCompensation = allowDriftCompensation(); - _o.setAllowDriftCompensation(_oAllowDriftCompensation); } public static int pack(FlatBufferBuilder builder, AssignTrackerRequestT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); int _displayName = _o.getDisplayName() == null ? 0 : builder.createString(_o.getDisplayName()); startAssignTrackerRequest(builder); - addTrackerId(builder, _trackerId); + addTrackerId(builder, _o.getTrackerId()); addBodyPosition(builder, _o.getBodyPosition()); addMountingOrientation(builder, solarxr_protocol.datatypes.math.Quat.pack(builder, _o.getMountingOrientation())); addDisplayName(builder, _displayName); - addAllowDriftCompensation(builder, _o.getAllowDriftCompensation()); return endAssignTrackerRequest(builder); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequestT.java b/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequestT.java index 3b2257504..fbeb9cc51 100644 --- a/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/AssignTrackerRequestT.java @@ -8,15 +8,14 @@ import com.google.flatbuffers.*; public class AssignTrackerRequestT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; private int bodyPosition; private solarxr_protocol.datatypes.math.QuatT mountingOrientation; private String displayName; - private boolean allowDriftCompensation; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public int getBodyPosition() { return bodyPosition; } @@ -30,17 +29,12 @@ public class AssignTrackerRequestT { public void setDisplayName(String displayName) { this.displayName = displayName; } - public boolean getAllowDriftCompensation() { return allowDriftCompensation; } - - public void setAllowDriftCompensation(boolean allowDriftCompensation) { this.allowDriftCompensation = allowDriftCompensation; } - public AssignTrackerRequestT() { - this.trackerId = null; + this.trackerId = 0; this.bodyPosition = 0; this.mountingOrientation = new solarxr_protocol.datatypes.math.QuatT(); this.displayName = null; - this.allowDriftCompensation = false; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.java b/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.java index eb121a3b2..95d74caf2 100644 --- a/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.java @@ -19,23 +19,23 @@ public final class AutoBoneProcessStatusResponse extends Table { /** * The current count. This value is -1 if there is nothing to report. */ - public long current() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } + public long current() { int o = __offset(6); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } /** * The total count. This value is -1 if there is nothing to report. */ - public long total() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } + public long total() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } /** * True if the operation has completed with any result, successful or not. */ - public boolean completed() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean completed() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } /** * True if the completed operation was successful, only observe if `completed` is true. */ - public boolean success() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean success() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } /** * The time remaining in seconds. This value is -1 if there is nothing to report. */ - public float eta() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float eta() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } public static int createAutoBoneProcessStatusResponse(FlatBufferBuilder builder, int processType, @@ -44,7 +44,7 @@ public static int createAutoBoneProcessStatusResponse(FlatBufferBuilder builder, boolean completed, boolean success, float eta) { - builder.startTable(7); + builder.startTable(6); AutoBoneProcessStatusResponse.addEta(builder, eta); AutoBoneProcessStatusResponse.addTotal(builder, total); AutoBoneProcessStatusResponse.addCurrent(builder, current); @@ -54,13 +54,13 @@ public static int createAutoBoneProcessStatusResponse(FlatBufferBuilder builder, return AutoBoneProcessStatusResponse.endAutoBoneProcessStatusResponse(builder); } - public static void startAutoBoneProcessStatusResponse(FlatBufferBuilder builder) { builder.startTable(7); } + public static void startAutoBoneProcessStatusResponse(FlatBufferBuilder builder) { builder.startTable(6); } public static void addProcessType(FlatBufferBuilder builder, int processType) { builder.addByte(0, (byte) processType, (byte) 0); } - public static void addCurrent(FlatBufferBuilder builder, long current) { builder.addInt(2, (int) current, (int) 0L); } - public static void addTotal(FlatBufferBuilder builder, long total) { builder.addInt(3, (int) total, (int) 0L); } - public static void addCompleted(FlatBufferBuilder builder, boolean completed) { builder.addBoolean(4, completed, false); } - public static void addSuccess(FlatBufferBuilder builder, boolean success) { builder.addBoolean(5, success, false); } - public static void addEta(FlatBufferBuilder builder, float eta) { builder.addFloat(6, eta, 0.0f); } + public static void addCurrent(FlatBufferBuilder builder, long current) { builder.addInt(1, (int) current, (int) 0L); } + public static void addTotal(FlatBufferBuilder builder, long total) { builder.addInt(2, (int) total, (int) 0L); } + public static void addCompleted(FlatBufferBuilder builder, boolean completed) { builder.addBoolean(3, completed, false); } + public static void addSuccess(FlatBufferBuilder builder, boolean success) { builder.addBoolean(4, success, false); } + public static void addEta(FlatBufferBuilder builder, float eta) { builder.addFloat(5, eta, 0.0f); } public static int endAutoBoneProcessStatusResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; diff --git a/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessType.java b/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessType.java index a90a98d8b..7ca506188 100644 --- a/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessType.java +++ b/protocol/java/src/solarxr_protocol/rpc/AutoBoneProcessType.java @@ -9,13 +9,8 @@ private AutoBoneProcessType() { } public static final int RECORD = 1; public static final int SAVE = 2; public static final int PROCESS = 3; - /** - * @deprecated - * Use AutoBoneApplyRequest instead - */ - public static final int APPLY = 4; - public static final String[] names = { "NONE", "RECORD", "SAVE", "PROCESS", "APPLY", }; + public static final String[] names = { "NONE", "RECORD", "SAVE", "PROCESS", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettings.java b/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettings.java deleted file mode 100644 index 15659d01a..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettings.java +++ /dev/null @@ -1,228 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt - */ -@SuppressWarnings("unused") -public final class AutoBoneSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static AutoBoneSettings getRootAsAutoBoneSettings(ByteBuffer _bb) { return getRootAsAutoBoneSettings(_bb, new AutoBoneSettings()); } - public static AutoBoneSettings getRootAsAutoBoneSettings(ByteBuffer _bb, AutoBoneSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public AutoBoneSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean hasCursorIncrement() { return 0 != __offset(4); } - public int cursorIncrement() { int o = __offset(4); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasMinDataDistance() { return 0 != __offset(6); } - public int minDataDistance() { int o = __offset(6); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasMaxDataDistance() { return 0 != __offset(8); } - public int maxDataDistance() { int o = __offset(8); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasNumEpochs() { return 0 != __offset(10); } - public int numEpochs() { int o = __offset(10); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasPrintEveryNumEpochs() { return 0 != __offset(12); } - public int printEveryNumEpochs() { int o = __offset(12); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasInitialAdjustRate() { return 0 != __offset(14); } - public float initialAdjustRate() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasAdjustRateDecay() { return 0 != __offset(16); } - public float adjustRateDecay() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasSlideErrorFactor() { return 0 != __offset(18); } - public float slideErrorFactor() { int o = __offset(18); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasOffsetSlideErrorFactor() { return 0 != __offset(20); } - public float offsetSlideErrorFactor() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasFootHeightOffsetErrorFactor() { return 0 != __offset(22); } - public float footHeightOffsetErrorFactor() { int o = __offset(22); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasBodyProportionErrorFactor() { return 0 != __offset(24); } - public float bodyProportionErrorFactor() { int o = __offset(24); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasHeightErrorFactor() { return 0 != __offset(26); } - public float heightErrorFactor() { int o = __offset(26); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasPositionErrorFactor() { return 0 != __offset(28); } - public float positionErrorFactor() { int o = __offset(28); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasPositionOffsetErrorFactor() { return 0 != __offset(30); } - public float positionOffsetErrorFactor() { int o = __offset(30); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasCalcInitError() { return 0 != __offset(32); } - public boolean calcInitError() { int o = __offset(32); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasRandomizeFrameOrder() { return 0 != __offset(34); } - public boolean randomizeFrameOrder() { int o = __offset(34); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasScaleEachStep() { return 0 != __offset(36); } - public boolean scaleEachStep() { int o = __offset(36); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasSampleCount() { return 0 != __offset(38); } - public int sampleCount() { int o = __offset(38); return o != 0 ? bb.getInt(o + bb_pos) : 0; } - public boolean hasSampleRateMs() { return 0 != __offset(40); } - public long sampleRateMs() { int o = __offset(40); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } - public boolean hasSaveRecordings() { return 0 != __offset(42); } - public boolean saveRecordings() { int o = __offset(42); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasUseSkeletonHeight() { return 0 != __offset(44); } - public boolean useSkeletonHeight() { int o = __offset(44); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasRandSeed() { return 0 != __offset(46); } - public long randSeed() { int o = __offset(46); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } - - public static int createAutoBoneSettings(FlatBufferBuilder builder, - int cursorIncrement, - int minDataDistance, - int maxDataDistance, - int numEpochs, - int printEveryNumEpochs, - float initialAdjustRate, - float adjustRateDecay, - float slideErrorFactor, - float offsetSlideErrorFactor, - float footHeightOffsetErrorFactor, - float bodyProportionErrorFactor, - float heightErrorFactor, - float positionErrorFactor, - float positionOffsetErrorFactor, - boolean calcInitError, - boolean randomizeFrameOrder, - boolean scaleEachStep, - int sampleCount, - long sampleRateMs, - boolean saveRecordings, - boolean useSkeletonHeight, - long randSeed) { - builder.startTable(22); - AutoBoneSettings.addRandSeed(builder, randSeed); - AutoBoneSettings.addSampleRateMs(builder, sampleRateMs); - AutoBoneSettings.addSampleCount(builder, sampleCount); - AutoBoneSettings.addPositionOffsetErrorFactor(builder, positionOffsetErrorFactor); - AutoBoneSettings.addPositionErrorFactor(builder, positionErrorFactor); - AutoBoneSettings.addHeightErrorFactor(builder, heightErrorFactor); - AutoBoneSettings.addBodyProportionErrorFactor(builder, bodyProportionErrorFactor); - AutoBoneSettings.addFootHeightOffsetErrorFactor(builder, footHeightOffsetErrorFactor); - AutoBoneSettings.addOffsetSlideErrorFactor(builder, offsetSlideErrorFactor); - AutoBoneSettings.addSlideErrorFactor(builder, slideErrorFactor); - AutoBoneSettings.addAdjustRateDecay(builder, adjustRateDecay); - AutoBoneSettings.addInitialAdjustRate(builder, initialAdjustRate); - AutoBoneSettings.addPrintEveryNumEpochs(builder, printEveryNumEpochs); - AutoBoneSettings.addNumEpochs(builder, numEpochs); - AutoBoneSettings.addMaxDataDistance(builder, maxDataDistance); - AutoBoneSettings.addMinDataDistance(builder, minDataDistance); - AutoBoneSettings.addCursorIncrement(builder, cursorIncrement); - AutoBoneSettings.addUseSkeletonHeight(builder, useSkeletonHeight); - AutoBoneSettings.addSaveRecordings(builder, saveRecordings); - AutoBoneSettings.addScaleEachStep(builder, scaleEachStep); - AutoBoneSettings.addRandomizeFrameOrder(builder, randomizeFrameOrder); - AutoBoneSettings.addCalcInitError(builder, calcInitError); - return AutoBoneSettings.endAutoBoneSettings(builder); - } - - public static void startAutoBoneSettings(FlatBufferBuilder builder) { builder.startTable(22); } - public static void addCursorIncrement(FlatBufferBuilder builder, int cursorIncrement) { builder.addInt(0, cursorIncrement, 0); } - public static void addMinDataDistance(FlatBufferBuilder builder, int minDataDistance) { builder.addInt(1, minDataDistance, 0); } - public static void addMaxDataDistance(FlatBufferBuilder builder, int maxDataDistance) { builder.addInt(2, maxDataDistance, 0); } - public static void addNumEpochs(FlatBufferBuilder builder, int numEpochs) { builder.addInt(3, numEpochs, 0); } - public static void addPrintEveryNumEpochs(FlatBufferBuilder builder, int printEveryNumEpochs) { builder.addInt(4, printEveryNumEpochs, 0); } - public static void addInitialAdjustRate(FlatBufferBuilder builder, float initialAdjustRate) { builder.addFloat(5, initialAdjustRate, 0f); } - public static void addAdjustRateDecay(FlatBufferBuilder builder, float adjustRateDecay) { builder.addFloat(6, adjustRateDecay, 0f); } - public static void addSlideErrorFactor(FlatBufferBuilder builder, float slideErrorFactor) { builder.addFloat(7, slideErrorFactor, 0f); } - public static void addOffsetSlideErrorFactor(FlatBufferBuilder builder, float offsetSlideErrorFactor) { builder.addFloat(8, offsetSlideErrorFactor, 0f); } - public static void addFootHeightOffsetErrorFactor(FlatBufferBuilder builder, float footHeightOffsetErrorFactor) { builder.addFloat(9, footHeightOffsetErrorFactor, 0f); } - public static void addBodyProportionErrorFactor(FlatBufferBuilder builder, float bodyProportionErrorFactor) { builder.addFloat(10, bodyProportionErrorFactor, 0f); } - public static void addHeightErrorFactor(FlatBufferBuilder builder, float heightErrorFactor) { builder.addFloat(11, heightErrorFactor, 0f); } - public static void addPositionErrorFactor(FlatBufferBuilder builder, float positionErrorFactor) { builder.addFloat(12, positionErrorFactor, 0f); } - public static void addPositionOffsetErrorFactor(FlatBufferBuilder builder, float positionOffsetErrorFactor) { builder.addFloat(13, positionOffsetErrorFactor, 0f); } - public static void addCalcInitError(FlatBufferBuilder builder, boolean calcInitError) { builder.addBoolean(14, calcInitError, false); } - public static void addRandomizeFrameOrder(FlatBufferBuilder builder, boolean randomizeFrameOrder) { builder.addBoolean(15, randomizeFrameOrder, false); } - public static void addScaleEachStep(FlatBufferBuilder builder, boolean scaleEachStep) { builder.addBoolean(16, scaleEachStep, false); } - public static void addSampleCount(FlatBufferBuilder builder, int sampleCount) { builder.addInt(17, sampleCount, 0); } - public static void addSampleRateMs(FlatBufferBuilder builder, long sampleRateMs) { builder.addLong(18, sampleRateMs, 0L); } - public static void addSaveRecordings(FlatBufferBuilder builder, boolean saveRecordings) { builder.addBoolean(19, saveRecordings, false); } - public static void addUseSkeletonHeight(FlatBufferBuilder builder, boolean useSkeletonHeight) { builder.addBoolean(20, useSkeletonHeight, false); } - public static void addRandSeed(FlatBufferBuilder builder, long randSeed) { builder.addLong(21, randSeed, 0L); } - public static int endAutoBoneSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public AutoBoneSettings get(int j) { return get(new AutoBoneSettings(), j); } - public AutoBoneSettings get(AutoBoneSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public AutoBoneSettingsT unpack() { - AutoBoneSettingsT _o = new AutoBoneSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(AutoBoneSettingsT _o) { - Integer _oCursorIncrement = hasCursorIncrement() ? cursorIncrement() : null; - _o.setCursorIncrement(_oCursorIncrement); - Integer _oMinDataDistance = hasMinDataDistance() ? minDataDistance() : null; - _o.setMinDataDistance(_oMinDataDistance); - Integer _oMaxDataDistance = hasMaxDataDistance() ? maxDataDistance() : null; - _o.setMaxDataDistance(_oMaxDataDistance); - Integer _oNumEpochs = hasNumEpochs() ? numEpochs() : null; - _o.setNumEpochs(_oNumEpochs); - Integer _oPrintEveryNumEpochs = hasPrintEveryNumEpochs() ? printEveryNumEpochs() : null; - _o.setPrintEveryNumEpochs(_oPrintEveryNumEpochs); - Float _oInitialAdjustRate = hasInitialAdjustRate() ? initialAdjustRate() : null; - _o.setInitialAdjustRate(_oInitialAdjustRate); - Float _oAdjustRateDecay = hasAdjustRateDecay() ? adjustRateDecay() : null; - _o.setAdjustRateDecay(_oAdjustRateDecay); - Float _oSlideErrorFactor = hasSlideErrorFactor() ? slideErrorFactor() : null; - _o.setSlideErrorFactor(_oSlideErrorFactor); - Float _oOffsetSlideErrorFactor = hasOffsetSlideErrorFactor() ? offsetSlideErrorFactor() : null; - _o.setOffsetSlideErrorFactor(_oOffsetSlideErrorFactor); - Float _oFootHeightOffsetErrorFactor = hasFootHeightOffsetErrorFactor() ? footHeightOffsetErrorFactor() : null; - _o.setFootHeightOffsetErrorFactor(_oFootHeightOffsetErrorFactor); - Float _oBodyProportionErrorFactor = hasBodyProportionErrorFactor() ? bodyProportionErrorFactor() : null; - _o.setBodyProportionErrorFactor(_oBodyProportionErrorFactor); - Float _oHeightErrorFactor = hasHeightErrorFactor() ? heightErrorFactor() : null; - _o.setHeightErrorFactor(_oHeightErrorFactor); - Float _oPositionErrorFactor = hasPositionErrorFactor() ? positionErrorFactor() : null; - _o.setPositionErrorFactor(_oPositionErrorFactor); - Float _oPositionOffsetErrorFactor = hasPositionOffsetErrorFactor() ? positionOffsetErrorFactor() : null; - _o.setPositionOffsetErrorFactor(_oPositionOffsetErrorFactor); - Boolean _oCalcInitError = hasCalcInitError() ? calcInitError() : null; - _o.setCalcInitError(_oCalcInitError); - Boolean _oRandomizeFrameOrder = hasRandomizeFrameOrder() ? randomizeFrameOrder() : null; - _o.setRandomizeFrameOrder(_oRandomizeFrameOrder); - Boolean _oScaleEachStep = hasScaleEachStep() ? scaleEachStep() : null; - _o.setScaleEachStep(_oScaleEachStep); - Integer _oSampleCount = hasSampleCount() ? sampleCount() : null; - _o.setSampleCount(_oSampleCount); - Long _oSampleRateMs = hasSampleRateMs() ? sampleRateMs() : null; - _o.setSampleRateMs(_oSampleRateMs); - Boolean _oSaveRecordings = hasSaveRecordings() ? saveRecordings() : null; - _o.setSaveRecordings(_oSaveRecordings); - Boolean _oUseSkeletonHeight = hasUseSkeletonHeight() ? useSkeletonHeight() : null; - _o.setUseSkeletonHeight(_oUseSkeletonHeight); - Long _oRandSeed = hasRandSeed() ? randSeed() : null; - _o.setRandSeed(_oRandSeed); - } - public static int pack(FlatBufferBuilder builder, AutoBoneSettingsT _o) { - if (_o == null) return 0; - return createAutoBoneSettings( - builder, - _o.getCursorIncrement(), - _o.getMinDataDistance(), - _o.getMaxDataDistance(), - _o.getNumEpochs(), - _o.getPrintEveryNumEpochs(), - _o.getInitialAdjustRate(), - _o.getAdjustRateDecay(), - _o.getSlideErrorFactor(), - _o.getOffsetSlideErrorFactor(), - _o.getFootHeightOffsetErrorFactor(), - _o.getBodyProportionErrorFactor(), - _o.getHeightErrorFactor(), - _o.getPositionErrorFactor(), - _o.getPositionOffsetErrorFactor(), - _o.getCalcInitError(), - _o.getRandomizeFrameOrder(), - _o.getScaleEachStep(), - _o.getSampleCount(), - _o.getSampleRateMs(), - _o.getSaveRecordings(), - _o.getUseSkeletonHeight(), - _o.getRandSeed()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettingsT.java deleted file mode 100644 index 0d62b83e6..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/AutoBoneSettingsT.java +++ /dev/null @@ -1,148 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class AutoBoneSettingsT { - private Integer cursorIncrement; - private Integer minDataDistance; - private Integer maxDataDistance; - private Integer numEpochs; - private Integer printEveryNumEpochs; - private Float initialAdjustRate; - private Float adjustRateDecay; - private Float slideErrorFactor; - private Float offsetSlideErrorFactor; - private Float footHeightOffsetErrorFactor; - private Float bodyProportionErrorFactor; - private Float heightErrorFactor; - private Float positionErrorFactor; - private Float positionOffsetErrorFactor; - private Boolean calcInitError; - private Boolean randomizeFrameOrder; - private Boolean scaleEachStep; - private Integer sampleCount; - private Long sampleRateMs; - private Boolean saveRecordings; - private Boolean useSkeletonHeight; - private Long randSeed; - - public Integer getCursorIncrement() { return cursorIncrement; } - - public void setCursorIncrement(Integer cursorIncrement) { this.cursorIncrement = cursorIncrement; } - - public Integer getMinDataDistance() { return minDataDistance; } - - public void setMinDataDistance(Integer minDataDistance) { this.minDataDistance = minDataDistance; } - - public Integer getMaxDataDistance() { return maxDataDistance; } - - public void setMaxDataDistance(Integer maxDataDistance) { this.maxDataDistance = maxDataDistance; } - - public Integer getNumEpochs() { return numEpochs; } - - public void setNumEpochs(Integer numEpochs) { this.numEpochs = numEpochs; } - - public Integer getPrintEveryNumEpochs() { return printEveryNumEpochs; } - - public void setPrintEveryNumEpochs(Integer printEveryNumEpochs) { this.printEveryNumEpochs = printEveryNumEpochs; } - - public Float getInitialAdjustRate() { return initialAdjustRate; } - - public void setInitialAdjustRate(Float initialAdjustRate) { this.initialAdjustRate = initialAdjustRate; } - - public Float getAdjustRateDecay() { return adjustRateDecay; } - - public void setAdjustRateDecay(Float adjustRateDecay) { this.adjustRateDecay = adjustRateDecay; } - - public Float getSlideErrorFactor() { return slideErrorFactor; } - - public void setSlideErrorFactor(Float slideErrorFactor) { this.slideErrorFactor = slideErrorFactor; } - - public Float getOffsetSlideErrorFactor() { return offsetSlideErrorFactor; } - - public void setOffsetSlideErrorFactor(Float offsetSlideErrorFactor) { this.offsetSlideErrorFactor = offsetSlideErrorFactor; } - - public Float getFootHeightOffsetErrorFactor() { return footHeightOffsetErrorFactor; } - - public void setFootHeightOffsetErrorFactor(Float footHeightOffsetErrorFactor) { this.footHeightOffsetErrorFactor = footHeightOffsetErrorFactor; } - - public Float getBodyProportionErrorFactor() { return bodyProportionErrorFactor; } - - public void setBodyProportionErrorFactor(Float bodyProportionErrorFactor) { this.bodyProportionErrorFactor = bodyProportionErrorFactor; } - - public Float getHeightErrorFactor() { return heightErrorFactor; } - - public void setHeightErrorFactor(Float heightErrorFactor) { this.heightErrorFactor = heightErrorFactor; } - - public Float getPositionErrorFactor() { return positionErrorFactor; } - - public void setPositionErrorFactor(Float positionErrorFactor) { this.positionErrorFactor = positionErrorFactor; } - - public Float getPositionOffsetErrorFactor() { return positionOffsetErrorFactor; } - - public void setPositionOffsetErrorFactor(Float positionOffsetErrorFactor) { this.positionOffsetErrorFactor = positionOffsetErrorFactor; } - - public Boolean getCalcInitError() { return calcInitError; } - - public void setCalcInitError(Boolean calcInitError) { this.calcInitError = calcInitError; } - - public Boolean getRandomizeFrameOrder() { return randomizeFrameOrder; } - - public void setRandomizeFrameOrder(Boolean randomizeFrameOrder) { this.randomizeFrameOrder = randomizeFrameOrder; } - - public Boolean getScaleEachStep() { return scaleEachStep; } - - public void setScaleEachStep(Boolean scaleEachStep) { this.scaleEachStep = scaleEachStep; } - - public Integer getSampleCount() { return sampleCount; } - - public void setSampleCount(Integer sampleCount) { this.sampleCount = sampleCount; } - - public Long getSampleRateMs() { return sampleRateMs; } - - public void setSampleRateMs(Long sampleRateMs) { this.sampleRateMs = sampleRateMs; } - - public Boolean getSaveRecordings() { return saveRecordings; } - - public void setSaveRecordings(Boolean saveRecordings) { this.saveRecordings = saveRecordings; } - - public Boolean getUseSkeletonHeight() { return useSkeletonHeight; } - - public void setUseSkeletonHeight(Boolean useSkeletonHeight) { this.useSkeletonHeight = useSkeletonHeight; } - - public Long getRandSeed() { return randSeed; } - - public void setRandSeed(Long randSeed) { this.randSeed = randSeed; } - - - public AutoBoneSettingsT() { - this.cursorIncrement = null; - this.minDataDistance = null; - this.maxDataDistance = null; - this.numEpochs = null; - this.printEveryNumEpochs = null; - this.initialAdjustRate = null; - this.adjustRateDecay = null; - this.slideErrorFactor = null; - this.offsetSlideErrorFactor = null; - this.footHeightOffsetErrorFactor = null; - this.bodyProportionErrorFactor = null; - this.heightErrorFactor = null; - this.positionErrorFactor = null; - this.positionOffsetErrorFactor = null; - this.calcInitError = null; - this.randomizeFrameOrder = null; - this.scaleEachStep = null; - this.sampleCount = null; - this.sampleRateMs = null; - this.saveRecordings = null; - this.useSkeletonHeight = null; - this.randSeed = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequest.java new file mode 100644 index 000000000..b84e4f2a5 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequest.java @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeHIDSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeHIDSettingsRequest getRootAsChangeHIDSettingsRequest(ByteBuffer _bb) { return getRootAsChangeHIDSettingsRequest(_bb, new ChangeHIDSettingsRequest()); } + public static ChangeHIDSettingsRequest getRootAsChangeHIDSettingsRequest(ByteBuffer _bb, ChangeHIDSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeHIDSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean trackersOverHid() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createChangeHIDSettingsRequest(FlatBufferBuilder builder, + boolean trackersOverHid) { + builder.startTable(1); + ChangeHIDSettingsRequest.addTrackersOverHid(builder, trackersOverHid); + return ChangeHIDSettingsRequest.endChangeHIDSettingsRequest(builder); + } + + public static void startChangeHIDSettingsRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackersOverHid(FlatBufferBuilder builder, boolean trackersOverHid) { builder.addBoolean(0, trackersOverHid, false); } + public static int endChangeHIDSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeHIDSettingsRequest get(int j) { return get(new ChangeHIDSettingsRequest(), j); } + public ChangeHIDSettingsRequest get(ChangeHIDSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeHIDSettingsRequestT unpack() { + ChangeHIDSettingsRequestT _o = new ChangeHIDSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeHIDSettingsRequestT _o) { + boolean _oTrackersOverHid = trackersOverHid(); + _o.setTrackersOverHid(_oTrackersOverHid); + } + public static int pack(FlatBufferBuilder builder, ChangeHIDSettingsRequestT _o) { + if (_o == null) return 0; + return createChangeHIDSettingsRequest( + builder, + _o.getTrackersOverHid()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequestT.java new file mode 100644 index 000000000..930e401b3 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeHIDSettingsRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeHIDSettingsRequestT { + private boolean trackersOverHid; + + public boolean getTrackersOverHid() { return trackersOverHid; } + + public void setTrackersOverHid(boolean trackersOverHid) { this.trackersOverHid = trackersOverHid; } + + + public ChangeHIDSettingsRequestT() { + this.trackersOverHid = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequest.java index 7aca1c1f4..b3f450cec 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequest.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequest.java @@ -18,21 +18,20 @@ public final class ChangeMagToggleRequest extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public ChangeMagToggleRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public boolean enable() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public static int createChangeMagToggleRequest(FlatBufferBuilder builder, - int trackerIdOffset, + int trackerId, boolean enable) { builder.startTable(2); - ChangeMagToggleRequest.addTrackerId(builder, trackerIdOffset); + ChangeMagToggleRequest.addTrackerId(builder, trackerId); ChangeMagToggleRequest.addEnable(builder, enable); return ChangeMagToggleRequest.endChangeMagToggleRequest(builder); } public static void startChangeMagToggleRequest(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static void addEnable(FlatBufferBuilder builder, boolean enable) { builder.addBoolean(1, enable, false); } public static int endChangeMagToggleRequest(FlatBufferBuilder builder) { int o = builder.endTable(); @@ -51,17 +50,16 @@ public ChangeMagToggleRequestT unpack() { return _o; } public void unpackTo(ChangeMagToggleRequestT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); boolean _oEnable = enable(); _o.setEnable(_oEnable); } public static int pack(FlatBufferBuilder builder, ChangeMagToggleRequestT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); return createChangeMagToggleRequest( builder, - _trackerId, + _o.getTrackerId(), _o.getEnable()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequestT.java index 599965666..fc8ef2aa8 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeMagToggleRequestT.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; public class ChangeMagToggleRequestT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; private boolean enable; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public boolean getEnable() { return enable; } @@ -21,7 +21,7 @@ public class ChangeMagToggleRequestT { public ChangeMagToggleRequestT() { - this.trackerId = null; + this.trackerId = 0; this.enable = false; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequest.java new file mode 100644 index 000000000..eb5700670 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequest.java @@ -0,0 +1,86 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeOutputTrackersSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeOutputTrackersSettingsRequest getRootAsChangeOutputTrackersSettingsRequest(ByteBuffer _bb) { return getRootAsChangeOutputTrackersSettingsRequest(_bb, new ChangeOutputTrackersSettingsRequest()); } + public static ChangeOutputTrackersSettingsRequest getRootAsChangeOutputTrackersSettingsRequest(ByteBuffer _bb, ChangeOutputTrackersSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeOutputTrackersSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean automaticTrackerToggle() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int trackers(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int trackersLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } + public ByteVector trackersVector() { return trackersVector(new ByteVector()); } + public ByteVector trackersVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer trackersInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + public boolean sendDerivedVelocity() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createChangeOutputTrackersSettingsRequest(FlatBufferBuilder builder, + boolean automaticTrackerToggle, + int trackersOffset, + boolean sendDerivedVelocity) { + builder.startTable(3); + ChangeOutputTrackersSettingsRequest.addTrackers(builder, trackersOffset); + ChangeOutputTrackersSettingsRequest.addSendDerivedVelocity(builder, sendDerivedVelocity); + ChangeOutputTrackersSettingsRequest.addAutomaticTrackerToggle(builder, automaticTrackerToggle); + return ChangeOutputTrackersSettingsRequest.endChangeOutputTrackersSettingsRequest(builder); + } + + public static void startChangeOutputTrackersSettingsRequest(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addAutomaticTrackerToggle(FlatBufferBuilder builder, boolean automaticTrackerToggle) { builder.addBoolean(0, automaticTrackerToggle, false); } + public static void addTrackers(FlatBufferBuilder builder, int trackersOffset) { builder.addOffset(1, trackersOffset, 0); } + public static int createTrackersVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createTrackersVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startTrackersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addSendDerivedVelocity(FlatBufferBuilder builder, boolean sendDerivedVelocity) { builder.addBoolean(2, sendDerivedVelocity, false); } + public static int endChangeOutputTrackersSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeOutputTrackersSettingsRequest get(int j) { return get(new ChangeOutputTrackersSettingsRequest(), j); } + public ChangeOutputTrackersSettingsRequest get(ChangeOutputTrackersSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeOutputTrackersSettingsRequestT unpack() { + ChangeOutputTrackersSettingsRequestT _o = new ChangeOutputTrackersSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeOutputTrackersSettingsRequestT _o) { + boolean _oAutomaticTrackerToggle = automaticTrackerToggle(); + _o.setAutomaticTrackerToggle(_oAutomaticTrackerToggle); + int[] _oTrackers = new int[trackersLength()]; + for (int _j = 0; _j < trackersLength(); ++_j) {_oTrackers[_j] = trackers(_j);} + _o.setTrackers(_oTrackers); + boolean _oSendDerivedVelocity = sendDerivedVelocity(); + _o.setSendDerivedVelocity(_oSendDerivedVelocity); + } + public static int pack(FlatBufferBuilder builder, ChangeOutputTrackersSettingsRequestT _o) { + if (_o == null) return 0; + int _trackers = 0; + if (_o.getTrackers() != null) { + byte[] __trackers = new byte[_o.getTrackers().length]; + int _j = 0; + for (int _e : _o.getTrackers()) { __trackers[_j] = (byte) _e; _j++;} + _trackers = createTrackersVector(builder, __trackers); + } + return createChangeOutputTrackersSettingsRequest( + builder, + _o.getAutomaticTrackerToggle(), + _trackers, + _o.getSendDerivedVelocity()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequestT.java new file mode 100644 index 000000000..2e87b0440 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeOutputTrackersSettingsRequestT.java @@ -0,0 +1,34 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeOutputTrackersSettingsRequestT { + private boolean automaticTrackerToggle; + private int[] trackers; + private boolean sendDerivedVelocity; + + public boolean getAutomaticTrackerToggle() { return automaticTrackerToggle; } + + public void setAutomaticTrackerToggle(boolean automaticTrackerToggle) { this.automaticTrackerToggle = automaticTrackerToggle; } + + public int[] getTrackers() { return trackers; } + + public void setTrackers(int[] trackers) { this.trackers = trackers; } + + public boolean getSendDerivedVelocity() { return sendDerivedVelocity; } + + public void setSendDerivedVelocity(boolean sendDerivedVelocity) { this.sendDerivedVelocity = sendDerivedVelocity; } + + + public ChangeOutputTrackersSettingsRequestT() { + this.automaticTrackerToggle = false; + this.trackers = null; + this.sendDerivedVelocity = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequest.java new file mode 100644 index 000000000..12d6a60ff --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequest.java @@ -0,0 +1,87 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeResetsSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeResetsSettingsRequest getRootAsChangeResetsSettingsRequest(ByteBuffer _bb) { return getRootAsChangeResetsSettingsRequest(_bb, new ChangeResetsSettingsRequest()); } + public static ChangeResetsSettingsRequest getRootAsChangeResetsSettingsRequest(ByteBuffer _bb, ChangeResetsSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeResetsSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + /** + * Makes it so feet will be mounting reset when passing no BodyPart + */ + public boolean resetMountingFeet() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int armsResetMode() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public float yawResetSmoothTime() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean saveMountingReset() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean resetHmdPitch() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createChangeResetsSettingsRequest(FlatBufferBuilder builder, + boolean resetMountingFeet, + int armsResetMode, + float yawResetSmoothTime, + boolean saveMountingReset, + boolean resetHmdPitch) { + builder.startTable(5); + ChangeResetsSettingsRequest.addYawResetSmoothTime(builder, yawResetSmoothTime); + ChangeResetsSettingsRequest.addResetHmdPitch(builder, resetHmdPitch); + ChangeResetsSettingsRequest.addSaveMountingReset(builder, saveMountingReset); + ChangeResetsSettingsRequest.addArmsResetMode(builder, armsResetMode); + ChangeResetsSettingsRequest.addResetMountingFeet(builder, resetMountingFeet); + return ChangeResetsSettingsRequest.endChangeResetsSettingsRequest(builder); + } + + public static void startChangeResetsSettingsRequest(FlatBufferBuilder builder) { builder.startTable(5); } + public static void addResetMountingFeet(FlatBufferBuilder builder, boolean resetMountingFeet) { builder.addBoolean(0, resetMountingFeet, false); } + public static void addArmsResetMode(FlatBufferBuilder builder, int armsResetMode) { builder.addByte(1, (byte) armsResetMode, (byte) 0); } + public static void addYawResetSmoothTime(FlatBufferBuilder builder, float yawResetSmoothTime) { builder.addFloat(2, yawResetSmoothTime, 0.0f); } + public static void addSaveMountingReset(FlatBufferBuilder builder, boolean saveMountingReset) { builder.addBoolean(3, saveMountingReset, false); } + public static void addResetHmdPitch(FlatBufferBuilder builder, boolean resetHmdPitch) { builder.addBoolean(4, resetHmdPitch, false); } + public static int endChangeResetsSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeResetsSettingsRequest get(int j) { return get(new ChangeResetsSettingsRequest(), j); } + public ChangeResetsSettingsRequest get(ChangeResetsSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeResetsSettingsRequestT unpack() { + ChangeResetsSettingsRequestT _o = new ChangeResetsSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeResetsSettingsRequestT _o) { + boolean _oResetMountingFeet = resetMountingFeet(); + _o.setResetMountingFeet(_oResetMountingFeet); + int _oArmsResetMode = armsResetMode(); + _o.setArmsResetMode(_oArmsResetMode); + float _oYawResetSmoothTime = yawResetSmoothTime(); + _o.setYawResetSmoothTime(_oYawResetSmoothTime); + boolean _oSaveMountingReset = saveMountingReset(); + _o.setSaveMountingReset(_oSaveMountingReset); + boolean _oResetHmdPitch = resetHmdPitch(); + _o.setResetHmdPitch(_oResetHmdPitch); + } + public static int pack(FlatBufferBuilder builder, ChangeResetsSettingsRequestT _o) { + if (_o == null) return 0; + return createChangeResetsSettingsRequest( + builder, + _o.getResetMountingFeet(), + _o.getArmsResetMode(), + _o.getYawResetSmoothTime(), + _o.getSaveMountingReset(), + _o.getResetHmdPitch()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequestT.java similarity index 78% rename from protocol/java/src/solarxr_protocol/rpc/ResetsSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequestT.java index 0fe0addf5..808745726 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeResetsSettingsRequestT.java @@ -7,9 +7,9 @@ import java.util.*; import com.google.flatbuffers.*; -public class ResetsSettingsT { +public class ChangeResetsSettingsRequestT { private boolean resetMountingFeet; - private int armsMountingResetMode; + private int armsResetMode; private float yawResetSmoothTime; private boolean saveMountingReset; private boolean resetHmdPitch; @@ -18,9 +18,9 @@ public class ResetsSettingsT { public void setResetMountingFeet(boolean resetMountingFeet) { this.resetMountingFeet = resetMountingFeet; } - public int getArmsMountingResetMode() { return armsMountingResetMode; } + public int getArmsResetMode() { return armsResetMode; } - public void setArmsMountingResetMode(int armsMountingResetMode) { this.armsMountingResetMode = armsMountingResetMode; } + public void setArmsResetMode(int armsResetMode) { this.armsResetMode = armsResetMode; } public float getYawResetSmoothTime() { return yawResetSmoothTime; } @@ -35,9 +35,9 @@ public class ResetsSettingsT { public void setResetHmdPitch(boolean resetHmdPitch) { this.resetHmdPitch = resetHmdPitch; } - public ResetsSettingsT() { + public ChangeResetsSettingsRequestT() { this.resetMountingFeet = false; - this.armsMountingResetMode = 0; + this.armsResetMode = 0; this.yawResetSmoothTime = 0.0f; this.saveMountingReset = false; this.resetHmdPitch = false; diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequest.java deleted file mode 100644 index 2b2e3dc31..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequest.java +++ /dev/null @@ -1,184 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class ChangeSettingsRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ChangeSettingsRequest getRootAsChangeSettingsRequest(ByteBuffer _bb) { return getRootAsChangeSettingsRequest(_bb, new ChangeSettingsRequest()); } - public static ChangeSettingsRequest getRootAsChangeSettingsRequest(ByteBuffer _bb, ChangeSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ChangeSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.SteamVRTrackersSetting steamVrTrackers() { return steamVrTrackers(new solarxr_protocol.rpc.SteamVRTrackersSetting()); } - public solarxr_protocol.rpc.SteamVRTrackersSetting steamVrTrackers(solarxr_protocol.rpc.SteamVRTrackersSetting obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.FilteringSettings filtering() { return filtering(new solarxr_protocol.rpc.FilteringSettings()); } - public solarxr_protocol.rpc.FilteringSettings filtering(solarxr_protocol.rpc.FilteringSettings obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.DriftCompensationSettings driftCompensation() { return driftCompensation(new solarxr_protocol.rpc.DriftCompensationSettings()); } - public solarxr_protocol.rpc.DriftCompensationSettings driftCompensation(solarxr_protocol.rpc.DriftCompensationSettings obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.OSCRouterSettings oscRouter() { return oscRouter(new solarxr_protocol.rpc.OSCRouterSettings()); } - public solarxr_protocol.rpc.OSCRouterSettings oscRouter(solarxr_protocol.rpc.OSCRouterSettings obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VRCOSCSettings vrcOsc() { return vrcOsc(new solarxr_protocol.rpc.VRCOSCSettings()); } - public solarxr_protocol.rpc.VRCOSCSettings vrcOsc(solarxr_protocol.rpc.VRCOSCSettings obj) { int o = __offset(12); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VMCOSCSettings vmcOsc() { return vmcOsc(new solarxr_protocol.rpc.VMCOSCSettings()); } - public solarxr_protocol.rpc.VMCOSCSettings vmcOsc(solarxr_protocol.rpc.VMCOSCSettings obj) { int o = __offset(14); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.settings.ModelSettings modelSettings() { return modelSettings(new solarxr_protocol.rpc.settings.ModelSettings()); } - public solarxr_protocol.rpc.settings.ModelSettings modelSettings(solarxr_protocol.rpc.settings.ModelSettings obj) { int o = __offset(16); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.TapDetectionSettings tapDetectionSettings() { return tapDetectionSettings(new solarxr_protocol.rpc.TapDetectionSettings()); } - public solarxr_protocol.rpc.TapDetectionSettings tapDetectionSettings(solarxr_protocol.rpc.TapDetectionSettings obj) { int o = __offset(18); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.AutoBoneSettings autoBoneSettings() { return autoBoneSettings(new solarxr_protocol.rpc.AutoBoneSettings()); } - public solarxr_protocol.rpc.AutoBoneSettings autoBoneSettings(solarxr_protocol.rpc.AutoBoneSettings obj) { int o = __offset(20); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.ResetsSettings resetsSettings() { return resetsSettings(new solarxr_protocol.rpc.ResetsSettings()); } - public solarxr_protocol.rpc.ResetsSettings resetsSettings(solarxr_protocol.rpc.ResetsSettings obj) { int o = __offset(22); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.StayAlignedSettings stayAligned() { return stayAligned(new solarxr_protocol.rpc.StayAlignedSettings()); } - public solarxr_protocol.rpc.StayAlignedSettings stayAligned(solarxr_protocol.rpc.StayAlignedSettings obj) { int o = __offset(24); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.HIDSettings hidSettings() { return hidSettings(new solarxr_protocol.rpc.HIDSettings()); } - public solarxr_protocol.rpc.HIDSettings hidSettings(solarxr_protocol.rpc.HIDSettings obj) { int o = __offset(26); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.TimeoutSettings timeout() { return timeout(new solarxr_protocol.rpc.TimeoutSettings()); } - public solarxr_protocol.rpc.TimeoutSettings timeout(solarxr_protocol.rpc.TimeoutSettings obj) { int o = __offset(28); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VelocitySettings velocitySettings() { return velocitySettings(new solarxr_protocol.rpc.VelocitySettings()); } - public solarxr_protocol.rpc.VelocitySettings velocitySettings(solarxr_protocol.rpc.VelocitySettings obj) { int o = __offset(30); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VRMSettings vrm() { return vrm(new solarxr_protocol.rpc.VRMSettings()); } - public solarxr_protocol.rpc.VRMSettings vrm(solarxr_protocol.rpc.VRMSettings obj) { int o = __offset(32); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createChangeSettingsRequest(FlatBufferBuilder builder, - int steamVrTrackersOffset, - int filteringOffset, - int driftCompensationOffset, - int oscRouterOffset, - int vrcOscOffset, - int vmcOscOffset, - int modelSettingsOffset, - int tapDetectionSettingsOffset, - int autoBoneSettingsOffset, - int resetsSettingsOffset, - int stayAlignedOffset, - int hidSettingsOffset, - int timeoutOffset, - int velocitySettingsOffset, - int vrmOffset) { - builder.startTable(15); - ChangeSettingsRequest.addVrm(builder, vrmOffset); - ChangeSettingsRequest.addVelocitySettings(builder, velocitySettingsOffset); - ChangeSettingsRequest.addTimeout(builder, timeoutOffset); - ChangeSettingsRequest.addHidSettings(builder, hidSettingsOffset); - ChangeSettingsRequest.addStayAligned(builder, stayAlignedOffset); - ChangeSettingsRequest.addResetsSettings(builder, resetsSettingsOffset); - ChangeSettingsRequest.addAutoBoneSettings(builder, autoBoneSettingsOffset); - ChangeSettingsRequest.addTapDetectionSettings(builder, tapDetectionSettingsOffset); - ChangeSettingsRequest.addModelSettings(builder, modelSettingsOffset); - ChangeSettingsRequest.addVmcOsc(builder, vmcOscOffset); - ChangeSettingsRequest.addVrcOsc(builder, vrcOscOffset); - ChangeSettingsRequest.addOscRouter(builder, oscRouterOffset); - ChangeSettingsRequest.addDriftCompensation(builder, driftCompensationOffset); - ChangeSettingsRequest.addFiltering(builder, filteringOffset); - ChangeSettingsRequest.addSteamVrTrackers(builder, steamVrTrackersOffset); - return ChangeSettingsRequest.endChangeSettingsRequest(builder); - } - - public static void startChangeSettingsRequest(FlatBufferBuilder builder) { builder.startTable(15); } - public static void addSteamVrTrackers(FlatBufferBuilder builder, int steamVrTrackersOffset) { builder.addOffset(0, steamVrTrackersOffset, 0); } - public static void addFiltering(FlatBufferBuilder builder, int filteringOffset) { builder.addOffset(1, filteringOffset, 0); } - public static void addDriftCompensation(FlatBufferBuilder builder, int driftCompensationOffset) { builder.addOffset(2, driftCompensationOffset, 0); } - public static void addOscRouter(FlatBufferBuilder builder, int oscRouterOffset) { builder.addOffset(3, oscRouterOffset, 0); } - public static void addVrcOsc(FlatBufferBuilder builder, int vrcOscOffset) { builder.addOffset(4, vrcOscOffset, 0); } - public static void addVmcOsc(FlatBufferBuilder builder, int vmcOscOffset) { builder.addOffset(5, vmcOscOffset, 0); } - public static void addModelSettings(FlatBufferBuilder builder, int modelSettingsOffset) { builder.addOffset(6, modelSettingsOffset, 0); } - public static void addTapDetectionSettings(FlatBufferBuilder builder, int tapDetectionSettingsOffset) { builder.addOffset(7, tapDetectionSettingsOffset, 0); } - public static void addAutoBoneSettings(FlatBufferBuilder builder, int autoBoneSettingsOffset) { builder.addOffset(8, autoBoneSettingsOffset, 0); } - public static void addResetsSettings(FlatBufferBuilder builder, int resetsSettingsOffset) { builder.addOffset(9, resetsSettingsOffset, 0); } - public static void addStayAligned(FlatBufferBuilder builder, int stayAlignedOffset) { builder.addOffset(10, stayAlignedOffset, 0); } - public static void addHidSettings(FlatBufferBuilder builder, int hidSettingsOffset) { builder.addOffset(11, hidSettingsOffset, 0); } - public static void addTimeout(FlatBufferBuilder builder, int timeoutOffset) { builder.addOffset(12, timeoutOffset, 0); } - public static void addVelocitySettings(FlatBufferBuilder builder, int velocitySettingsOffset) { builder.addOffset(13, velocitySettingsOffset, 0); } - public static void addVrm(FlatBufferBuilder builder, int vrmOffset) { builder.addOffset(14, vrmOffset, 0); } - public static int endChangeSettingsRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ChangeSettingsRequest get(int j) { return get(new ChangeSettingsRequest(), j); } - public ChangeSettingsRequest get(ChangeSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ChangeSettingsRequestT unpack() { - ChangeSettingsRequestT _o = new ChangeSettingsRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ChangeSettingsRequestT _o) { - if (steamVrTrackers() != null) _o.setSteamVrTrackers(steamVrTrackers().unpack()); - else _o.setSteamVrTrackers(null); - if (filtering() != null) _o.setFiltering(filtering().unpack()); - else _o.setFiltering(null); - if (driftCompensation() != null) _o.setDriftCompensation(driftCompensation().unpack()); - else _o.setDriftCompensation(null); - if (oscRouter() != null) _o.setOscRouter(oscRouter().unpack()); - else _o.setOscRouter(null); - if (vrcOsc() != null) _o.setVrcOsc(vrcOsc().unpack()); - else _o.setVrcOsc(null); - if (vmcOsc() != null) _o.setVmcOsc(vmcOsc().unpack()); - else _o.setVmcOsc(null); - if (modelSettings() != null) _o.setModelSettings(modelSettings().unpack()); - else _o.setModelSettings(null); - if (tapDetectionSettings() != null) _o.setTapDetectionSettings(tapDetectionSettings().unpack()); - else _o.setTapDetectionSettings(null); - if (autoBoneSettings() != null) _o.setAutoBoneSettings(autoBoneSettings().unpack()); - else _o.setAutoBoneSettings(null); - if (resetsSettings() != null) _o.setResetsSettings(resetsSettings().unpack()); - else _o.setResetsSettings(null); - if (stayAligned() != null) _o.setStayAligned(stayAligned().unpack()); - else _o.setStayAligned(null); - if (hidSettings() != null) _o.setHidSettings(hidSettings().unpack()); - else _o.setHidSettings(null); - if (timeout() != null) _o.setTimeout(timeout().unpack()); - else _o.setTimeout(null); - if (velocitySettings() != null) _o.setVelocitySettings(velocitySettings().unpack()); - else _o.setVelocitySettings(null); - if (vrm() != null) _o.setVrm(vrm().unpack()); - else _o.setVrm(null); - } - public static int pack(FlatBufferBuilder builder, ChangeSettingsRequestT _o) { - if (_o == null) return 0; - int _steamVrTrackers = _o.getSteamVrTrackers() == null ? 0 : solarxr_protocol.rpc.SteamVRTrackersSetting.pack(builder, _o.getSteamVrTrackers()); - int _filtering = _o.getFiltering() == null ? 0 : solarxr_protocol.rpc.FilteringSettings.pack(builder, _o.getFiltering()); - int _driftCompensation = _o.getDriftCompensation() == null ? 0 : solarxr_protocol.rpc.DriftCompensationSettings.pack(builder, _o.getDriftCompensation()); - int _oscRouter = _o.getOscRouter() == null ? 0 : solarxr_protocol.rpc.OSCRouterSettings.pack(builder, _o.getOscRouter()); - int _vrcOsc = _o.getVrcOsc() == null ? 0 : solarxr_protocol.rpc.VRCOSCSettings.pack(builder, _o.getVrcOsc()); - int _vmcOsc = _o.getVmcOsc() == null ? 0 : solarxr_protocol.rpc.VMCOSCSettings.pack(builder, _o.getVmcOsc()); - int _modelSettings = _o.getModelSettings() == null ? 0 : solarxr_protocol.rpc.settings.ModelSettings.pack(builder, _o.getModelSettings()); - int _tapDetectionSettings = _o.getTapDetectionSettings() == null ? 0 : solarxr_protocol.rpc.TapDetectionSettings.pack(builder, _o.getTapDetectionSettings()); - int _autoBoneSettings = _o.getAutoBoneSettings() == null ? 0 : solarxr_protocol.rpc.AutoBoneSettings.pack(builder, _o.getAutoBoneSettings()); - int _resetsSettings = _o.getResetsSettings() == null ? 0 : solarxr_protocol.rpc.ResetsSettings.pack(builder, _o.getResetsSettings()); - int _stayAligned = _o.getStayAligned() == null ? 0 : solarxr_protocol.rpc.StayAlignedSettings.pack(builder, _o.getStayAligned()); - int _hidSettings = _o.getHidSettings() == null ? 0 : solarxr_protocol.rpc.HIDSettings.pack(builder, _o.getHidSettings()); - int _timeout = _o.getTimeout() == null ? 0 : solarxr_protocol.rpc.TimeoutSettings.pack(builder, _o.getTimeout()); - int _velocitySettings = _o.getVelocitySettings() == null ? 0 : solarxr_protocol.rpc.VelocitySettings.pack(builder, _o.getVelocitySettings()); - int _vrm = _o.getVrm() == null ? 0 : solarxr_protocol.rpc.VRMSettings.pack(builder, _o.getVrm()); - return createChangeSettingsRequest( - builder, - _steamVrTrackers, - _filtering, - _driftCompensation, - _oscRouter, - _vrcOsc, - _vmcOsc, - _modelSettings, - _tapDetectionSettings, - _autoBoneSettings, - _resetsSettings, - _stayAligned, - _hidSettings, - _timeout, - _velocitySettings, - _vrm); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequestT.java deleted file mode 100644 index b083c40cd..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeSettingsRequestT.java +++ /dev/null @@ -1,106 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class ChangeSettingsRequestT { - private solarxr_protocol.rpc.SteamVRTrackersSettingT steamVrTrackers; - private solarxr_protocol.rpc.FilteringSettingsT filtering; - private solarxr_protocol.rpc.DriftCompensationSettingsT driftCompensation; - private solarxr_protocol.rpc.OSCRouterSettingsT oscRouter; - private solarxr_protocol.rpc.VRCOSCSettingsT vrcOsc; - private solarxr_protocol.rpc.VMCOSCSettingsT vmcOsc; - private solarxr_protocol.rpc.settings.ModelSettingsT modelSettings; - private solarxr_protocol.rpc.TapDetectionSettingsT tapDetectionSettings; - private solarxr_protocol.rpc.AutoBoneSettingsT autoBoneSettings; - private solarxr_protocol.rpc.ResetsSettingsT resetsSettings; - private solarxr_protocol.rpc.StayAlignedSettingsT stayAligned; - private solarxr_protocol.rpc.HIDSettingsT hidSettings; - private solarxr_protocol.rpc.TimeoutSettingsT timeout; - private solarxr_protocol.rpc.VelocitySettingsT velocitySettings; - private solarxr_protocol.rpc.VRMSettingsT vrm; - - public solarxr_protocol.rpc.SteamVRTrackersSettingT getSteamVrTrackers() { return steamVrTrackers; } - - public void setSteamVrTrackers(solarxr_protocol.rpc.SteamVRTrackersSettingT steamVrTrackers) { this.steamVrTrackers = steamVrTrackers; } - - public solarxr_protocol.rpc.FilteringSettingsT getFiltering() { return filtering; } - - public void setFiltering(solarxr_protocol.rpc.FilteringSettingsT filtering) { this.filtering = filtering; } - - public solarxr_protocol.rpc.DriftCompensationSettingsT getDriftCompensation() { return driftCompensation; } - - public void setDriftCompensation(solarxr_protocol.rpc.DriftCompensationSettingsT driftCompensation) { this.driftCompensation = driftCompensation; } - - public solarxr_protocol.rpc.OSCRouterSettingsT getOscRouter() { return oscRouter; } - - public void setOscRouter(solarxr_protocol.rpc.OSCRouterSettingsT oscRouter) { this.oscRouter = oscRouter; } - - public solarxr_protocol.rpc.VRCOSCSettingsT getVrcOsc() { return vrcOsc; } - - public void setVrcOsc(solarxr_protocol.rpc.VRCOSCSettingsT vrcOsc) { this.vrcOsc = vrcOsc; } - - public solarxr_protocol.rpc.VMCOSCSettingsT getVmcOsc() { return vmcOsc; } - - public void setVmcOsc(solarxr_protocol.rpc.VMCOSCSettingsT vmcOsc) { this.vmcOsc = vmcOsc; } - - public solarxr_protocol.rpc.settings.ModelSettingsT getModelSettings() { return modelSettings; } - - public void setModelSettings(solarxr_protocol.rpc.settings.ModelSettingsT modelSettings) { this.modelSettings = modelSettings; } - - public solarxr_protocol.rpc.TapDetectionSettingsT getTapDetectionSettings() { return tapDetectionSettings; } - - public void setTapDetectionSettings(solarxr_protocol.rpc.TapDetectionSettingsT tapDetectionSettings) { this.tapDetectionSettings = tapDetectionSettings; } - - public solarxr_protocol.rpc.AutoBoneSettingsT getAutoBoneSettings() { return autoBoneSettings; } - - public void setAutoBoneSettings(solarxr_protocol.rpc.AutoBoneSettingsT autoBoneSettings) { this.autoBoneSettings = autoBoneSettings; } - - public solarxr_protocol.rpc.ResetsSettingsT getResetsSettings() { return resetsSettings; } - - public void setResetsSettings(solarxr_protocol.rpc.ResetsSettingsT resetsSettings) { this.resetsSettings = resetsSettings; } - - public solarxr_protocol.rpc.StayAlignedSettingsT getStayAligned() { return stayAligned; } - - public void setStayAligned(solarxr_protocol.rpc.StayAlignedSettingsT stayAligned) { this.stayAligned = stayAligned; } - - public solarxr_protocol.rpc.HIDSettingsT getHidSettings() { return hidSettings; } - - public void setHidSettings(solarxr_protocol.rpc.HIDSettingsT hidSettings) { this.hidSettings = hidSettings; } - - public solarxr_protocol.rpc.TimeoutSettingsT getTimeout() { return timeout; } - - public void setTimeout(solarxr_protocol.rpc.TimeoutSettingsT timeout) { this.timeout = timeout; } - - public solarxr_protocol.rpc.VelocitySettingsT getVelocitySettings() { return velocitySettings; } - - public void setVelocitySettings(solarxr_protocol.rpc.VelocitySettingsT velocitySettings) { this.velocitySettings = velocitySettings; } - - public solarxr_protocol.rpc.VRMSettingsT getVrm() { return vrm; } - - public void setVrm(solarxr_protocol.rpc.VRMSettingsT vrm) { this.vrm = vrm; } - - - public ChangeSettingsRequestT() { - this.steamVrTrackers = null; - this.filtering = null; - this.driftCompensation = null; - this.oscRouter = null; - this.vrcOsc = null; - this.vmcOsc = null; - this.modelSettings = null; - this.tapDetectionSettings = null; - this.autoBoneSettings = null; - this.resetsSettings = null; - this.stayAligned = null; - this.hidSettings = null; - this.timeout = null; - this.velocitySettings = null; - this.vrm = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.java deleted file mode 100644 index 9c29761a6..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.java +++ /dev/null @@ -1,63 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class ChangeSkeletonConfigRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ChangeSkeletonConfigRequest getRootAsChangeSkeletonConfigRequest(ByteBuffer _bb) { return getRootAsChangeSkeletonConfigRequest(_bb, new ChangeSkeletonConfigRequest()); } - public static ChangeSkeletonConfigRequest getRootAsChangeSkeletonConfigRequest(ByteBuffer _bb, ChangeSkeletonConfigRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ChangeSkeletonConfigRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public int bone() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public float value() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - - public static int createChangeSkeletonConfigRequest(FlatBufferBuilder builder, - int bone, - float value) { - builder.startTable(2); - ChangeSkeletonConfigRequest.addValue(builder, value); - ChangeSkeletonConfigRequest.addBone(builder, bone); - return ChangeSkeletonConfigRequest.endChangeSkeletonConfigRequest(builder); - } - - public static void startChangeSkeletonConfigRequest(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addBone(FlatBufferBuilder builder, int bone) { builder.addByte(0, (byte) bone, (byte) 0); } - public static void addValue(FlatBufferBuilder builder, float value) { builder.addFloat(1, value, 0.0f); } - public static int endChangeSkeletonConfigRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ChangeSkeletonConfigRequest get(int j) { return get(new ChangeSkeletonConfigRequest(), j); } - public ChangeSkeletonConfigRequest get(ChangeSkeletonConfigRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ChangeSkeletonConfigRequestT unpack() { - ChangeSkeletonConfigRequestT _o = new ChangeSkeletonConfigRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ChangeSkeletonConfigRequestT _o) { - int _oBone = bone(); - _o.setBone(_oBone); - float _oValue = value(); - _o.setValue(_oValue); - } - public static int pack(FlatBufferBuilder builder, ChangeSkeletonConfigRequestT _o) { - if (_o == null) return 0; - return createChangeSkeletonConfigRequest( - builder, - _o.getBone(), - _o.getValue()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequest.java new file mode 100644 index 000000000..842d117a0 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequest.java @@ -0,0 +1,63 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeSkeletonProportionsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeSkeletonProportionsRequest getRootAsChangeSkeletonProportionsRequest(ByteBuffer _bb) { return getRootAsChangeSkeletonProportionsRequest(_bb, new ChangeSkeletonProportionsRequest()); } + public static ChangeSkeletonProportionsRequest getRootAsChangeSkeletonProportionsRequest(ByteBuffer _bb, ChangeSkeletonProportionsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeSkeletonProportionsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int bone() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public float value() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + + public static int createChangeSkeletonProportionsRequest(FlatBufferBuilder builder, + int bone, + float value) { + builder.startTable(2); + ChangeSkeletonProportionsRequest.addValue(builder, value); + ChangeSkeletonProportionsRequest.addBone(builder, bone); + return ChangeSkeletonProportionsRequest.endChangeSkeletonProportionsRequest(builder); + } + + public static void startChangeSkeletonProportionsRequest(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addBone(FlatBufferBuilder builder, int bone) { builder.addByte(0, (byte) bone, (byte) 0); } + public static void addValue(FlatBufferBuilder builder, float value) { builder.addFloat(1, value, 0.0f); } + public static int endChangeSkeletonProportionsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeSkeletonProportionsRequest get(int j) { return get(new ChangeSkeletonProportionsRequest(), j); } + public ChangeSkeletonProportionsRequest get(ChangeSkeletonProportionsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeSkeletonProportionsRequestT unpack() { + ChangeSkeletonProportionsRequestT _o = new ChangeSkeletonProportionsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeSkeletonProportionsRequestT _o) { + int _oBone = bone(); + _o.setBone(_oBone); + float _oValue = value(); + _o.setValue(_oValue); + } + public static int pack(FlatBufferBuilder builder, ChangeSkeletonProportionsRequestT _o) { + if (_o == null) return 0; + return createChangeSkeletonProportionsRequest( + builder, + _o.getBone(), + _o.getValue()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequestT.java similarity index 83% rename from protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequestT.java index c24c572a4..59d0ffc01 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonProportionsRequestT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class ChangeSkeletonConfigRequestT { +public class ChangeSkeletonProportionsRequestT { private int bone; private float value; @@ -20,7 +20,7 @@ public class ChangeSkeletonConfigRequestT { public void setValue(float value) { this.value = value; } - public ChangeSkeletonConfigRequestT() { + public ChangeSkeletonProportionsRequestT() { this.bone = 0; this.value = 0.0f; } diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequest.java new file mode 100644 index 000000000..eb165290f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequest.java @@ -0,0 +1,85 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeSkeletonSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeSkeletonSettingsRequest getRootAsChangeSkeletonSettingsRequest(ByteBuffer _bb) { return getRootAsChangeSkeletonSettingsRequest(_bb, new ChangeSkeletonSettingsRequest()); } + public static ChangeSkeletonSettingsRequest getRootAsChangeSkeletonSettingsRequest(ByteBuffer _bb, ChangeSkeletonSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeSkeletonSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.rpc.SkeletonToggles toggles() { return toggles(new solarxr_protocol.rpc.SkeletonToggles()); } + public solarxr_protocol.rpc.SkeletonToggles toggles(solarxr_protocol.rpc.SkeletonToggles obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonRatios ratios() { return ratios(new solarxr_protocol.rpc.SkeletonRatios()); } + public solarxr_protocol.rpc.SkeletonRatios ratios(solarxr_protocol.rpc.SkeletonRatios obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonFiltering filtering() { return filtering(new solarxr_protocol.rpc.SkeletonFiltering()); } + public solarxr_protocol.rpc.SkeletonFiltering filtering(solarxr_protocol.rpc.SkeletonFiltering obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonHeight skeletonHeight() { return skeletonHeight(new solarxr_protocol.rpc.SkeletonHeight()); } + public solarxr_protocol.rpc.SkeletonHeight skeletonHeight(solarxr_protocol.rpc.SkeletonHeight obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + + public static int createChangeSkeletonSettingsRequest(FlatBufferBuilder builder, + int togglesOffset, + int ratiosOffset, + int filteringOffset, + int skeletonHeightOffset) { + builder.startTable(4); + ChangeSkeletonSettingsRequest.addSkeletonHeight(builder, skeletonHeightOffset); + ChangeSkeletonSettingsRequest.addFiltering(builder, filteringOffset); + ChangeSkeletonSettingsRequest.addRatios(builder, ratiosOffset); + ChangeSkeletonSettingsRequest.addToggles(builder, togglesOffset); + return ChangeSkeletonSettingsRequest.endChangeSkeletonSettingsRequest(builder); + } + + public static void startChangeSkeletonSettingsRequest(FlatBufferBuilder builder) { builder.startTable(4); } + public static void addToggles(FlatBufferBuilder builder, int togglesOffset) { builder.addOffset(0, togglesOffset, 0); } + public static void addRatios(FlatBufferBuilder builder, int ratiosOffset) { builder.addOffset(1, ratiosOffset, 0); } + public static void addFiltering(FlatBufferBuilder builder, int filteringOffset) { builder.addOffset(2, filteringOffset, 0); } + public static void addSkeletonHeight(FlatBufferBuilder builder, int skeletonHeightOffset) { builder.addOffset(3, skeletonHeightOffset, 0); } + public static int endChangeSkeletonSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeSkeletonSettingsRequest get(int j) { return get(new ChangeSkeletonSettingsRequest(), j); } + public ChangeSkeletonSettingsRequest get(ChangeSkeletonSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeSkeletonSettingsRequestT unpack() { + ChangeSkeletonSettingsRequestT _o = new ChangeSkeletonSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeSkeletonSettingsRequestT _o) { + if (toggles() != null) _o.setToggles(toggles().unpack()); + else _o.setToggles(null); + if (ratios() != null) _o.setRatios(ratios().unpack()); + else _o.setRatios(null); + if (filtering() != null) _o.setFiltering(filtering().unpack()); + else _o.setFiltering(null); + if (skeletonHeight() != null) _o.setSkeletonHeight(skeletonHeight().unpack()); + else _o.setSkeletonHeight(null); + } + public static int pack(FlatBufferBuilder builder, ChangeSkeletonSettingsRequestT _o) { + if (_o == null) return 0; + int _toggles = _o.getToggles() == null ? 0 : solarxr_protocol.rpc.SkeletonToggles.pack(builder, _o.getToggles()); + int _ratios = _o.getRatios() == null ? 0 : solarxr_protocol.rpc.SkeletonRatios.pack(builder, _o.getRatios()); + int _filtering = _o.getFiltering() == null ? 0 : solarxr_protocol.rpc.SkeletonFiltering.pack(builder, _o.getFiltering()); + int _skeletonHeight = _o.getSkeletonHeight() == null ? 0 : solarxr_protocol.rpc.SkeletonHeight.pack(builder, _o.getSkeletonHeight()); + return createChangeSkeletonSettingsRequest( + builder, + _toggles, + _ratios, + _filtering, + _skeletonHeight); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequestT.java new file mode 100644 index 000000000..b9c3d7eec --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeSkeletonSettingsRequestT.java @@ -0,0 +1,40 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeSkeletonSettingsRequestT { + private solarxr_protocol.rpc.SkeletonTogglesT toggles; + private solarxr_protocol.rpc.SkeletonRatiosT ratios; + private solarxr_protocol.rpc.SkeletonFilteringT filtering; + private solarxr_protocol.rpc.SkeletonHeightT skeletonHeight; + + public solarxr_protocol.rpc.SkeletonTogglesT getToggles() { return toggles; } + + public void setToggles(solarxr_protocol.rpc.SkeletonTogglesT toggles) { this.toggles = toggles; } + + public solarxr_protocol.rpc.SkeletonRatiosT getRatios() { return ratios; } + + public void setRatios(solarxr_protocol.rpc.SkeletonRatiosT ratios) { this.ratios = ratios; } + + public solarxr_protocol.rpc.SkeletonFilteringT getFiltering() { return filtering; } + + public void setFiltering(solarxr_protocol.rpc.SkeletonFilteringT filtering) { this.filtering = filtering; } + + public solarxr_protocol.rpc.SkeletonHeightT getSkeletonHeight() { return skeletonHeight; } + + public void setSkeletonHeight(solarxr_protocol.rpc.SkeletonHeightT skeletonHeight) { this.skeletonHeight = skeletonHeight; } + + + public ChangeSkeletonSettingsRequestT() { + this.toggles = null; + this.ratios = null; + this.filtering = null; + this.skeletonHeight = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequest.java new file mode 100644 index 000000000..ea1295021 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequest.java @@ -0,0 +1,140 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeStayAlignedSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeStayAlignedSettingsRequest getRootAsChangeStayAlignedSettingsRequest(ByteBuffer _bb) { return getRootAsChangeStayAlignedSettingsRequest(_bb, new ChangeStayAlignedSettingsRequest()); } + public static ChangeStayAlignedSettingsRequest getRootAsChangeStayAlignedSettingsRequest(ByteBuffer _bb, ChangeStayAlignedSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeStayAlignedSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean standingEnabled() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float standingUpperLegAngle() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float standingLowerLegAngle() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float standingFootAngle() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean sittingEnabled() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float sittingUpperLegAngle() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float sittingLowerLegAngle() { int o = __offset(18); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float sittingFootAngle() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean flatEnabled() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float flatUpperLegAngle() { int o = __offset(24); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float flatLowerLegAngle() { int o = __offset(26); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float flatFootAngle() { int o = __offset(28); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + + public static int createChangeStayAlignedSettingsRequest(FlatBufferBuilder builder, + boolean enabled, + boolean standingEnabled, + float standingUpperLegAngle, + float standingLowerLegAngle, + float standingFootAngle, + boolean sittingEnabled, + float sittingUpperLegAngle, + float sittingLowerLegAngle, + float sittingFootAngle, + boolean flatEnabled, + float flatUpperLegAngle, + float flatLowerLegAngle, + float flatFootAngle) { + builder.startTable(13); + ChangeStayAlignedSettingsRequest.addFlatFootAngle(builder, flatFootAngle); + ChangeStayAlignedSettingsRequest.addFlatLowerLegAngle(builder, flatLowerLegAngle); + ChangeStayAlignedSettingsRequest.addFlatUpperLegAngle(builder, flatUpperLegAngle); + ChangeStayAlignedSettingsRequest.addSittingFootAngle(builder, sittingFootAngle); + ChangeStayAlignedSettingsRequest.addSittingLowerLegAngle(builder, sittingLowerLegAngle); + ChangeStayAlignedSettingsRequest.addSittingUpperLegAngle(builder, sittingUpperLegAngle); + ChangeStayAlignedSettingsRequest.addStandingFootAngle(builder, standingFootAngle); + ChangeStayAlignedSettingsRequest.addStandingLowerLegAngle(builder, standingLowerLegAngle); + ChangeStayAlignedSettingsRequest.addStandingUpperLegAngle(builder, standingUpperLegAngle); + ChangeStayAlignedSettingsRequest.addFlatEnabled(builder, flatEnabled); + ChangeStayAlignedSettingsRequest.addSittingEnabled(builder, sittingEnabled); + ChangeStayAlignedSettingsRequest.addStandingEnabled(builder, standingEnabled); + ChangeStayAlignedSettingsRequest.addEnabled(builder, enabled); + return ChangeStayAlignedSettingsRequest.endChangeStayAlignedSettingsRequest(builder); + } + + public static void startChangeStayAlignedSettingsRequest(FlatBufferBuilder builder) { builder.startTable(13); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addStandingEnabled(FlatBufferBuilder builder, boolean standingEnabled) { builder.addBoolean(1, standingEnabled, false); } + public static void addStandingUpperLegAngle(FlatBufferBuilder builder, float standingUpperLegAngle) { builder.addFloat(2, standingUpperLegAngle, 0.0f); } + public static void addStandingLowerLegAngle(FlatBufferBuilder builder, float standingLowerLegAngle) { builder.addFloat(3, standingLowerLegAngle, 0.0f); } + public static void addStandingFootAngle(FlatBufferBuilder builder, float standingFootAngle) { builder.addFloat(4, standingFootAngle, 0.0f); } + public static void addSittingEnabled(FlatBufferBuilder builder, boolean sittingEnabled) { builder.addBoolean(5, sittingEnabled, false); } + public static void addSittingUpperLegAngle(FlatBufferBuilder builder, float sittingUpperLegAngle) { builder.addFloat(6, sittingUpperLegAngle, 0.0f); } + public static void addSittingLowerLegAngle(FlatBufferBuilder builder, float sittingLowerLegAngle) { builder.addFloat(7, sittingLowerLegAngle, 0.0f); } + public static void addSittingFootAngle(FlatBufferBuilder builder, float sittingFootAngle) { builder.addFloat(8, sittingFootAngle, 0.0f); } + public static void addFlatEnabled(FlatBufferBuilder builder, boolean flatEnabled) { builder.addBoolean(9, flatEnabled, false); } + public static void addFlatUpperLegAngle(FlatBufferBuilder builder, float flatUpperLegAngle) { builder.addFloat(10, flatUpperLegAngle, 0.0f); } + public static void addFlatLowerLegAngle(FlatBufferBuilder builder, float flatLowerLegAngle) { builder.addFloat(11, flatLowerLegAngle, 0.0f); } + public static void addFlatFootAngle(FlatBufferBuilder builder, float flatFootAngle) { builder.addFloat(12, flatFootAngle, 0.0f); } + public static int endChangeStayAlignedSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeStayAlignedSettingsRequest get(int j) { return get(new ChangeStayAlignedSettingsRequest(), j); } + public ChangeStayAlignedSettingsRequest get(ChangeStayAlignedSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeStayAlignedSettingsRequestT unpack() { + ChangeStayAlignedSettingsRequestT _o = new ChangeStayAlignedSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeStayAlignedSettingsRequestT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + boolean _oStandingEnabled = standingEnabled(); + _o.setStandingEnabled(_oStandingEnabled); + float _oStandingUpperLegAngle = standingUpperLegAngle(); + _o.setStandingUpperLegAngle(_oStandingUpperLegAngle); + float _oStandingLowerLegAngle = standingLowerLegAngle(); + _o.setStandingLowerLegAngle(_oStandingLowerLegAngle); + float _oStandingFootAngle = standingFootAngle(); + _o.setStandingFootAngle(_oStandingFootAngle); + boolean _oSittingEnabled = sittingEnabled(); + _o.setSittingEnabled(_oSittingEnabled); + float _oSittingUpperLegAngle = sittingUpperLegAngle(); + _o.setSittingUpperLegAngle(_oSittingUpperLegAngle); + float _oSittingLowerLegAngle = sittingLowerLegAngle(); + _o.setSittingLowerLegAngle(_oSittingLowerLegAngle); + float _oSittingFootAngle = sittingFootAngle(); + _o.setSittingFootAngle(_oSittingFootAngle); + boolean _oFlatEnabled = flatEnabled(); + _o.setFlatEnabled(_oFlatEnabled); + float _oFlatUpperLegAngle = flatUpperLegAngle(); + _o.setFlatUpperLegAngle(_oFlatUpperLegAngle); + float _oFlatLowerLegAngle = flatLowerLegAngle(); + _o.setFlatLowerLegAngle(_oFlatLowerLegAngle); + float _oFlatFootAngle = flatFootAngle(); + _o.setFlatFootAngle(_oFlatFootAngle); + } + public static int pack(FlatBufferBuilder builder, ChangeStayAlignedSettingsRequestT _o) { + if (_o == null) return 0; + return createChangeStayAlignedSettingsRequest( + builder, + _o.getEnabled(), + _o.getStandingEnabled(), + _o.getStandingUpperLegAngle(), + _o.getStandingLowerLegAngle(), + _o.getStandingFootAngle(), + _o.getSittingEnabled(), + _o.getSittingUpperLegAngle(), + _o.getSittingLowerLegAngle(), + _o.getSittingFootAngle(), + _o.getFlatEnabled(), + _o.getFlatUpperLegAngle(), + _o.getFlatLowerLegAngle(), + _o.getFlatFootAngle()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequestT.java similarity index 80% rename from protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequestT.java index 49bad8e50..be92e5525 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeStayAlignedSettingsRequestT.java @@ -7,10 +7,8 @@ import java.util.*; import com.google.flatbuffers.*; -public class StayAlignedSettingsT { +public class ChangeStayAlignedSettingsRequestT { private boolean enabled; - private boolean extraYawCorrection; - private boolean hideYawCorrection; private boolean standingEnabled; private float standingUpperLegAngle; private float standingLowerLegAngle; @@ -23,20 +21,11 @@ public class StayAlignedSettingsT { private float flatUpperLegAngle; private float flatLowerLegAngle; private float flatFootAngle; - private boolean setupComplete; public boolean getEnabled() { return enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; } - public boolean getExtraYawCorrection() { return extraYawCorrection; } - - public void setExtraYawCorrection(boolean extraYawCorrection) { this.extraYawCorrection = extraYawCorrection; } - - public boolean getHideYawCorrection() { return hideYawCorrection; } - - public void setHideYawCorrection(boolean hideYawCorrection) { this.hideYawCorrection = hideYawCorrection; } - public boolean getStandingEnabled() { return standingEnabled; } public void setStandingEnabled(boolean standingEnabled) { this.standingEnabled = standingEnabled; } @@ -85,15 +74,9 @@ public class StayAlignedSettingsT { public void setFlatFootAngle(float flatFootAngle) { this.flatFootAngle = flatFootAngle; } - public boolean getSetupComplete() { return setupComplete; } - - public void setSetupComplete(boolean setupComplete) { this.setupComplete = setupComplete; } - - public StayAlignedSettingsT() { + public ChangeStayAlignedSettingsRequestT() { this.enabled = false; - this.extraYawCorrection = false; - this.hideYawCorrection = false; this.standingEnabled = false; this.standingUpperLegAngle = 0.0f; this.standingLowerLegAngle = 0.0f; @@ -106,7 +89,6 @@ public StayAlignedSettingsT() { this.flatUpperLegAngle = 0.0f; this.flatLowerLegAngle = 0.0f; this.flatFootAngle = 0.0f; - this.setupComplete = false; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequest.java new file mode 100644 index 000000000..0b2c04fcc --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequest.java @@ -0,0 +1,153 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeTapDetectionSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeTapDetectionSettingsRequest getRootAsChangeTapDetectionSettingsRequest(ByteBuffer _bb) { return getRootAsChangeTapDetectionSettingsRequest(_bb, new ChangeTapDetectionSettingsRequest()); } + public static ChangeTapDetectionSettingsRequest getRootAsChangeTapDetectionSettingsRequest(ByteBuffer _bb, ChangeTapDetectionSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeTapDetectionSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean hasFullResetDelay() { return 0 != __offset(4); } + public float fullResetDelay() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasFullResetEnabled() { return 0 != __offset(6); } + public boolean fullResetEnabled() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasFullResetTaps() { return 0 != __offset(8); } + public int fullResetTaps() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasYawResetDelay() { return 0 != __offset(10); } + public float yawResetDelay() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasYawResetEnabled() { return 0 != __offset(12); } + public boolean yawResetEnabled() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasYawResetTaps() { return 0 != __offset(14); } + public int yawResetTaps() { int o = __offset(14); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasMountingResetDelay() { return 0 != __offset(16); } + public float mountingResetDelay() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + public boolean hasMountingResetEnabled() { return 0 != __offset(18); } + public boolean mountingResetEnabled() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasMountingResetTaps() { return 0 != __offset(20); } + public int mountingResetTaps() { int o = __offset(20); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasNumberTrackersOverThreshold() { return 0 != __offset(22); } + public int numberTrackersOverThreshold() { int o = __offset(22); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasYawResetTracker() { return 0 != __offset(24); } + public int yawResetTracker() { int o = __offset(24); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasFullResetTracker() { return 0 != __offset(26); } + public int fullResetTracker() { int o = __offset(26); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasMountingResetTracker() { return 0 != __offset(28); } + public int mountingResetTracker() { int o = __offset(28); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + + public static int createChangeTapDetectionSettingsRequest(FlatBufferBuilder builder, + float fullResetDelay, + boolean fullResetEnabled, + int fullResetTaps, + float yawResetDelay, + boolean yawResetEnabled, + int yawResetTaps, + float mountingResetDelay, + boolean mountingResetEnabled, + int mountingResetTaps, + int numberTrackersOverThreshold, + int yawResetTracker, + int fullResetTracker, + int mountingResetTracker) { + builder.startTable(13); + ChangeTapDetectionSettingsRequest.addMountingResetDelay(builder, mountingResetDelay); + ChangeTapDetectionSettingsRequest.addYawResetDelay(builder, yawResetDelay); + ChangeTapDetectionSettingsRequest.addFullResetDelay(builder, fullResetDelay); + ChangeTapDetectionSettingsRequest.addMountingResetTracker(builder, mountingResetTracker); + ChangeTapDetectionSettingsRequest.addFullResetTracker(builder, fullResetTracker); + ChangeTapDetectionSettingsRequest.addYawResetTracker(builder, yawResetTracker); + ChangeTapDetectionSettingsRequest.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); + ChangeTapDetectionSettingsRequest.addMountingResetTaps(builder, mountingResetTaps); + ChangeTapDetectionSettingsRequest.addMountingResetEnabled(builder, mountingResetEnabled); + ChangeTapDetectionSettingsRequest.addYawResetTaps(builder, yawResetTaps); + ChangeTapDetectionSettingsRequest.addYawResetEnabled(builder, yawResetEnabled); + ChangeTapDetectionSettingsRequest.addFullResetTaps(builder, fullResetTaps); + ChangeTapDetectionSettingsRequest.addFullResetEnabled(builder, fullResetEnabled); + return ChangeTapDetectionSettingsRequest.endChangeTapDetectionSettingsRequest(builder); + } + + public static void startChangeTapDetectionSettingsRequest(FlatBufferBuilder builder) { builder.startTable(13); } + public static void addFullResetDelay(FlatBufferBuilder builder, float fullResetDelay) { builder.addFloat(0, fullResetDelay, 0f); } + public static void addFullResetEnabled(FlatBufferBuilder builder, boolean fullResetEnabled) { builder.addBoolean(1, fullResetEnabled, false); } + public static void addFullResetTaps(FlatBufferBuilder builder, int fullResetTaps) { builder.addByte(2, (byte) fullResetTaps, (byte) 0); } + public static void addYawResetDelay(FlatBufferBuilder builder, float yawResetDelay) { builder.addFloat(3, yawResetDelay, 0f); } + public static void addYawResetEnabled(FlatBufferBuilder builder, boolean yawResetEnabled) { builder.addBoolean(4, yawResetEnabled, false); } + public static void addYawResetTaps(FlatBufferBuilder builder, int yawResetTaps) { builder.addByte(5, (byte) yawResetTaps, (byte) 0); } + public static void addMountingResetDelay(FlatBufferBuilder builder, float mountingResetDelay) { builder.addFloat(6, mountingResetDelay, 0f); } + public static void addMountingResetEnabled(FlatBufferBuilder builder, boolean mountingResetEnabled) { builder.addBoolean(7, mountingResetEnabled, false); } + public static void addMountingResetTaps(FlatBufferBuilder builder, int mountingResetTaps) { builder.addByte(8, (byte) mountingResetTaps, (byte) 0); } + public static void addNumberTrackersOverThreshold(FlatBufferBuilder builder, int numberTrackersOverThreshold) { builder.addByte(9, (byte) numberTrackersOverThreshold, (byte) 0); } + public static void addYawResetTracker(FlatBufferBuilder builder, int yawResetTracker) { builder.addByte(10, (byte) yawResetTracker, (byte) 0); } + public static void addFullResetTracker(FlatBufferBuilder builder, int fullResetTracker) { builder.addByte(11, (byte) fullResetTracker, (byte) 0); } + public static void addMountingResetTracker(FlatBufferBuilder builder, int mountingResetTracker) { builder.addByte(12, (byte) mountingResetTracker, (byte) 0); } + public static int endChangeTapDetectionSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeTapDetectionSettingsRequest get(int j) { return get(new ChangeTapDetectionSettingsRequest(), j); } + public ChangeTapDetectionSettingsRequest get(ChangeTapDetectionSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeTapDetectionSettingsRequestT unpack() { + ChangeTapDetectionSettingsRequestT _o = new ChangeTapDetectionSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeTapDetectionSettingsRequestT _o) { + Float _oFullResetDelay = hasFullResetDelay() ? fullResetDelay() : null; + _o.setFullResetDelay(_oFullResetDelay); + Boolean _oFullResetEnabled = hasFullResetEnabled() ? fullResetEnabled() : null; + _o.setFullResetEnabled(_oFullResetEnabled); + Integer _oFullResetTaps = hasFullResetTaps() ? fullResetTaps() : null; + _o.setFullResetTaps(_oFullResetTaps); + Float _oYawResetDelay = hasYawResetDelay() ? yawResetDelay() : null; + _o.setYawResetDelay(_oYawResetDelay); + Boolean _oYawResetEnabled = hasYawResetEnabled() ? yawResetEnabled() : null; + _o.setYawResetEnabled(_oYawResetEnabled); + Integer _oYawResetTaps = hasYawResetTaps() ? yawResetTaps() : null; + _o.setYawResetTaps(_oYawResetTaps); + Float _oMountingResetDelay = hasMountingResetDelay() ? mountingResetDelay() : null; + _o.setMountingResetDelay(_oMountingResetDelay); + Boolean _oMountingResetEnabled = hasMountingResetEnabled() ? mountingResetEnabled() : null; + _o.setMountingResetEnabled(_oMountingResetEnabled); + Integer _oMountingResetTaps = hasMountingResetTaps() ? mountingResetTaps() : null; + _o.setMountingResetTaps(_oMountingResetTaps); + Integer _oNumberTrackersOverThreshold = hasNumberTrackersOverThreshold() ? numberTrackersOverThreshold() : null; + _o.setNumberTrackersOverThreshold(_oNumberTrackersOverThreshold); + Integer _oYawResetTracker = hasYawResetTracker() ? yawResetTracker() : null; + _o.setYawResetTracker(_oYawResetTracker); + Integer _oFullResetTracker = hasFullResetTracker() ? fullResetTracker() : null; + _o.setFullResetTracker(_oFullResetTracker); + Integer _oMountingResetTracker = hasMountingResetTracker() ? mountingResetTracker() : null; + _o.setMountingResetTracker(_oMountingResetTracker); + } + public static int pack(FlatBufferBuilder builder, ChangeTapDetectionSettingsRequestT _o) { + if (_o == null) return 0; + return createChangeTapDetectionSettingsRequest( + builder, + _o.getFullResetDelay(), + _o.getFullResetEnabled(), + _o.getFullResetTaps(), + _o.getYawResetDelay(), + _o.getYawResetEnabled(), + _o.getYawResetTaps(), + _o.getMountingResetDelay(), + _o.getMountingResetEnabled(), + _o.getMountingResetTaps(), + _o.getNumberTrackersOverThreshold(), + _o.getYawResetTracker(), + _o.getFullResetTracker(), + _o.getMountingResetTracker()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequestT.java similarity index 92% rename from protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequestT.java index 8a8e9ba59..2926841f8 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeTapDetectionSettingsRequestT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class TapDetectionSettingsT { +public class ChangeTapDetectionSettingsRequestT { private Float fullResetDelay; private Boolean fullResetEnabled; private Integer fullResetTaps; @@ -17,7 +17,6 @@ public class TapDetectionSettingsT { private Float mountingResetDelay; private Boolean mountingResetEnabled; private Integer mountingResetTaps; - private Boolean setupMode; private Integer numberTrackersOverThreshold; private Integer yawResetTracker; private Integer fullResetTracker; @@ -59,10 +58,6 @@ public class TapDetectionSettingsT { public void setMountingResetTaps(Integer mountingResetTaps) { this.mountingResetTaps = mountingResetTaps; } - public Boolean getSetupMode() { return setupMode; } - - public void setSetupMode(Boolean setupMode) { this.setupMode = setupMode; } - public Integer getNumberTrackersOverThreshold() { return numberTrackersOverThreshold; } public void setNumberTrackersOverThreshold(Integer numberTrackersOverThreshold) { this.numberTrackersOverThreshold = numberTrackersOverThreshold; } @@ -80,7 +75,7 @@ public class TapDetectionSettingsT { public void setMountingResetTracker(Integer mountingResetTracker) { this.mountingResetTracker = mountingResetTracker; } - public TapDetectionSettingsT() { + public ChangeTapDetectionSettingsRequestT() { this.fullResetDelay = null; this.fullResetEnabled = null; this.fullResetTaps = null; @@ -90,7 +85,6 @@ public TapDetectionSettingsT() { this.mountingResetDelay = null; this.mountingResetEnabled = null; this.mountingResetTaps = null; - this.setupMode = null; this.numberTrackersOverThreshold = null; this.yawResetTracker = null; this.fullResetTracker = null; diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequest.java new file mode 100644 index 000000000..b1b068e85 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequest.java @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeVMCOSCSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeVMCOSCSettingsRequest getRootAsChangeVMCOSCSettingsRequest(ByteBuffer _bb) { return getRootAsChangeVMCOSCSettingsRequest(_bb, new ChangeVMCOSCSettingsRequest()); } + public static ChangeVMCOSCSettingsRequest getRootAsChangeVMCOSCSettingsRequest(ByteBuffer _bb, ChangeVMCOSCSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeVMCOSCSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int portIn() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public int portOut() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public String address() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer addressAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } + public ByteBuffer addressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } + public boolean anchorHip() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean mirrorTracking() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createChangeVMCOSCSettingsRequest(FlatBufferBuilder builder, + boolean enabled, + int portIn, + int portOut, + int addressOffset, + boolean anchorHip, + boolean mirrorTracking) { + builder.startTable(6); + ChangeVMCOSCSettingsRequest.addAddress(builder, addressOffset); + ChangeVMCOSCSettingsRequest.addPortOut(builder, portOut); + ChangeVMCOSCSettingsRequest.addPortIn(builder, portIn); + ChangeVMCOSCSettingsRequest.addMirrorTracking(builder, mirrorTracking); + ChangeVMCOSCSettingsRequest.addAnchorHip(builder, anchorHip); + ChangeVMCOSCSettingsRequest.addEnabled(builder, enabled); + return ChangeVMCOSCSettingsRequest.endChangeVMCOSCSettingsRequest(builder); + } + + public static void startChangeVMCOSCSettingsRequest(FlatBufferBuilder builder) { builder.startTable(6); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addPortIn(FlatBufferBuilder builder, int portIn) { builder.addShort(1, (short) portIn, (short) 0); } + public static void addPortOut(FlatBufferBuilder builder, int portOut) { builder.addShort(2, (short) portOut, (short) 0); } + public static void addAddress(FlatBufferBuilder builder, int addressOffset) { builder.addOffset(3, addressOffset, 0); } + public static void addAnchorHip(FlatBufferBuilder builder, boolean anchorHip) { builder.addBoolean(4, anchorHip, false); } + public static void addMirrorTracking(FlatBufferBuilder builder, boolean mirrorTracking) { builder.addBoolean(5, mirrorTracking, false); } + public static int endChangeVMCOSCSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeVMCOSCSettingsRequest get(int j) { return get(new ChangeVMCOSCSettingsRequest(), j); } + public ChangeVMCOSCSettingsRequest get(ChangeVMCOSCSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeVMCOSCSettingsRequestT unpack() { + ChangeVMCOSCSettingsRequestT _o = new ChangeVMCOSCSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeVMCOSCSettingsRequestT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + int _oPortIn = portIn(); + _o.setPortIn(_oPortIn); + int _oPortOut = portOut(); + _o.setPortOut(_oPortOut); + String _oAddress = address(); + _o.setAddress(_oAddress); + boolean _oAnchorHip = anchorHip(); + _o.setAnchorHip(_oAnchorHip); + boolean _oMirrorTracking = mirrorTracking(); + _o.setMirrorTracking(_oMirrorTracking); + } + public static int pack(FlatBufferBuilder builder, ChangeVMCOSCSettingsRequestT _o) { + if (_o == null) return 0; + int _address = _o.getAddress() == null ? 0 : builder.createString(_o.getAddress()); + return createChangeVMCOSCSettingsRequest( + builder, + _o.getEnabled(), + _o.getPortIn(), + _o.getPortOut(), + _address, + _o.getAnchorHip(), + _o.getMirrorTracking()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequestT.java new file mode 100644 index 000000000..84c8885af --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVMCOSCSettingsRequestT.java @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeVMCOSCSettingsRequestT { + private boolean enabled; + private int portIn; + private int portOut; + private String address; + private boolean anchorHip; + private boolean mirrorTracking; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public int getPortIn() { return portIn; } + + public void setPortIn(int portIn) { this.portIn = portIn; } + + public int getPortOut() { return portOut; } + + public void setPortOut(int portOut) { this.portOut = portOut; } + + public String getAddress() { return address; } + + public void setAddress(String address) { this.address = address; } + + public boolean getAnchorHip() { return anchorHip; } + + public void setAnchorHip(boolean anchorHip) { this.anchorHip = anchorHip; } + + public boolean getMirrorTracking() { return mirrorTracking; } + + public void setMirrorTracking(boolean mirrorTracking) { this.mirrorTracking = mirrorTracking; } + + + public ChangeVMCOSCSettingsRequestT() { + this.enabled = false; + this.portIn = 0; + this.portOut = 0; + this.address = null; + this.anchorHip = false; + this.mirrorTracking = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequest.java new file mode 100644 index 000000000..014491b7f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequest.java @@ -0,0 +1,65 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeVRCOSCSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeVRCOSCSettingsRequest getRootAsChangeVRCOSCSettingsRequest(ByteBuffer _bb) { return getRootAsChangeVRCOSCSettingsRequest(_bb, new ChangeVRCOSCSettingsRequest()); } + public static ChangeVRCOSCSettingsRequest getRootAsChangeVRCOSCSettingsRequest(ByteBuffer _bb, ChangeVRCOSCSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeVRCOSCSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public solarxr_protocol.rpc.VRCOSCNetworkSettings manualNetwork() { return manualNetwork(new solarxr_protocol.rpc.VRCOSCNetworkSettings()); } + public solarxr_protocol.rpc.VRCOSCNetworkSettings manualNetwork(solarxr_protocol.rpc.VRCOSCNetworkSettings obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + + public static int createChangeVRCOSCSettingsRequest(FlatBufferBuilder builder, + boolean enabled, + int manualNetworkOffset) { + builder.startTable(2); + ChangeVRCOSCSettingsRequest.addManualNetwork(builder, manualNetworkOffset); + ChangeVRCOSCSettingsRequest.addEnabled(builder, enabled); + return ChangeVRCOSCSettingsRequest.endChangeVRCOSCSettingsRequest(builder); + } + + public static void startChangeVRCOSCSettingsRequest(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addManualNetwork(FlatBufferBuilder builder, int manualNetworkOffset) { builder.addOffset(1, manualNetworkOffset, 0); } + public static int endChangeVRCOSCSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeVRCOSCSettingsRequest get(int j) { return get(new ChangeVRCOSCSettingsRequest(), j); } + public ChangeVRCOSCSettingsRequest get(ChangeVRCOSCSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeVRCOSCSettingsRequestT unpack() { + ChangeVRCOSCSettingsRequestT _o = new ChangeVRCOSCSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeVRCOSCSettingsRequestT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + if (manualNetwork() != null) _o.setManualNetwork(manualNetwork().unpack()); + else _o.setManualNetwork(null); + } + public static int pack(FlatBufferBuilder builder, ChangeVRCOSCSettingsRequestT _o) { + if (_o == null) return 0; + int _manualNetwork = _o.getManualNetwork() == null ? 0 : solarxr_protocol.rpc.VRCOSCNetworkSettings.pack(builder, _o.getManualNetwork()); + return createChangeVRCOSCSettingsRequest( + builder, + _o.getEnabled(), + _manualNetwork); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequestT.java new file mode 100644 index 000000000..e1c51e899 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVRCOSCSettingsRequestT.java @@ -0,0 +1,28 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeVRCOSCSettingsRequestT { + private boolean enabled; + private solarxr_protocol.rpc.VRCOSCNetworkSettingsT manualNetwork; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public solarxr_protocol.rpc.VRCOSCNetworkSettingsT getManualNetwork() { return manualNetwork; } + + public void setManualNetwork(solarxr_protocol.rpc.VRCOSCNetworkSettingsT manualNetwork) { this.manualNetwork = manualNetwork; } + + + public ChangeVRCOSCSettingsRequestT() { + this.enabled = false; + this.manualNetwork = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequest.java new file mode 100644 index 000000000..5d2a7308e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequest.java @@ -0,0 +1,59 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeVRMSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeVRMSettingsRequest getRootAsChangeVRMSettingsRequest(ByteBuffer _bb) { return getRootAsChangeVRMSettingsRequest(_bb, new ChangeVRMSettingsRequest()); } + public static ChangeVRMSettingsRequest getRootAsChangeVRMSettingsRequest(ByteBuffer _bb, ChangeVRMSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ChangeVRMSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String vrmJson() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer vrmJsonAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer vrmJsonInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + + public static int createChangeVRMSettingsRequest(FlatBufferBuilder builder, + int vrmJsonOffset) { + builder.startTable(1); + ChangeVRMSettingsRequest.addVrmJson(builder, vrmJsonOffset); + return ChangeVRMSettingsRequest.endChangeVRMSettingsRequest(builder); + } + + public static void startChangeVRMSettingsRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addVrmJson(FlatBufferBuilder builder, int vrmJsonOffset) { builder.addOffset(0, vrmJsonOffset, 0); } + public static int endChangeVRMSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ChangeVRMSettingsRequest get(int j) { return get(new ChangeVRMSettingsRequest(), j); } + public ChangeVRMSettingsRequest get(ChangeVRMSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeVRMSettingsRequestT unpack() { + ChangeVRMSettingsRequestT _o = new ChangeVRMSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeVRMSettingsRequestT _o) { + String _oVrmJson = vrmJson(); + _o.setVrmJson(_oVrmJson); + } + public static int pack(FlatBufferBuilder builder, ChangeVRMSettingsRequestT _o) { + if (_o == null) return 0; + int _vrmJson = _o.getVrmJson() == null ? 0 : builder.createString(_o.getVrmJson()); + return createChangeVRMSettingsRequest( + builder, + _vrmJson); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequestT.java new file mode 100644 index 000000000..d5081657b --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeVRMSettingsRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeVRMSettingsRequestT { + private String vrmJson; + + public String getVrmJson() { return vrmJson; } + + public void setVrmJson(String vrmJson) { this.vrmJson = vrmJson; } + + + public ChangeVRMSettingsRequestT() { + this.vrmJson = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.java b/protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.java deleted file mode 100644 index 4a7160c2f..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.java +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class ClearDriftCompensationRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ClearDriftCompensationRequest getRootAsClearDriftCompensationRequest(ByteBuffer _bb) { return getRootAsClearDriftCompensationRequest(_bb, new ClearDriftCompensationRequest()); } - public static ClearDriftCompensationRequest getRootAsClearDriftCompensationRequest(ByteBuffer _bb, ClearDriftCompensationRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ClearDriftCompensationRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startClearDriftCompensationRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endClearDriftCompensationRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ClearDriftCompensationRequest get(int j) { return get(new ClearDriftCompensationRequest(), j); } - public ClearDriftCompensationRequest get(ClearDriftCompensationRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ClearDriftCompensationRequestT unpack() { - ClearDriftCompensationRequestT _o = new ClearDriftCompensationRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ClearDriftCompensationRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, ClearDriftCompensationRequestT _o) { - if (_o == null) return 0; - startClearDriftCompensationRequest(builder); - return endClearDriftCompensationRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponse.java b/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponse.java new file mode 100644 index 000000000..bce3110ca --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponse.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class CompleteStayAlignedResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static CompleteStayAlignedResponse getRootAsCompleteStayAlignedResponse(ByteBuffer _bb) { return getRootAsCompleteStayAlignedResponse(_bb, new CompleteStayAlignedResponse()); } + public static CompleteStayAlignedResponse getRootAsCompleteStayAlignedResponse(ByteBuffer _bb, CompleteStayAlignedResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public CompleteStayAlignedResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startCompleteStayAlignedResponse(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endCompleteStayAlignedResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public CompleteStayAlignedResponse get(int j) { return get(new CompleteStayAlignedResponse(), j); } + public CompleteStayAlignedResponse get(CompleteStayAlignedResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public CompleteStayAlignedResponseT unpack() { + CompleteStayAlignedResponseT _o = new CompleteStayAlignedResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(CompleteStayAlignedResponseT _o) { + } + public static int pack(FlatBufferBuilder builder, CompleteStayAlignedResponseT _o) { + if (_o == null) return 0; + startCompleteStayAlignedResponse(builder); + return endCompleteStayAlignedResponse(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponseT.java b/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponseT.java new file mode 100644 index 000000000..19012435b --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/CompleteStayAlignedResponseT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class CompleteStayAlignedResponseT { + + + public CompleteStayAlignedResponseT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ComputerDirectory.java b/protocol/java/src/solarxr_protocol/rpc/ComputerDirectory.java index b5a5e8205..ea9aea740 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ComputerDirectory.java +++ b/protocol/java/src/solarxr_protocol/rpc/ComputerDirectory.java @@ -8,9 +8,9 @@ @SuppressWarnings("unused") public final class ComputerDirectory { private ComputerDirectory() { } - public static final int Documents = 0; + public static final int DOCUMENTS = 0; - public static final String[] names = { "Documents", }; + public static final String[] names = { "DOCUMENTS", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettings.java b/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettings.java deleted file mode 100644 index 60cd70b09..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettings.java +++ /dev/null @@ -1,86 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Settings related to IMU yaw drift compensation - */ -@SuppressWarnings("unused") -public final class DriftCompensationSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static DriftCompensationSettings getRootAsDriftCompensationSettings(ByteBuffer _bb) { return getRootAsDriftCompensationSettings(_bb, new DriftCompensationSettings()); } - public static DriftCompensationSettings getRootAsDriftCompensationSettings(ByteBuffer _bb, DriftCompensationSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public DriftCompensationSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean prediction() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - /** - * 0 to 1. A higher value results in more yaw drift compensation - */ - public float amount() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - /** - * Number of previous resets to take into account when calculating yaw drift - */ - public int maxResets() { int o = __offset(10); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } - - public static int createDriftCompensationSettings(FlatBufferBuilder builder, - boolean enabled, - boolean prediction, - float amount, - int maxResets) { - builder.startTable(4); - DriftCompensationSettings.addAmount(builder, amount); - DriftCompensationSettings.addMaxResets(builder, maxResets); - DriftCompensationSettings.addPrediction(builder, prediction); - DriftCompensationSettings.addEnabled(builder, enabled); - return DriftCompensationSettings.endDriftCompensationSettings(builder); - } - - public static void startDriftCompensationSettings(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } - public static void addPrediction(FlatBufferBuilder builder, boolean prediction) { builder.addBoolean(1, prediction, false); } - public static void addAmount(FlatBufferBuilder builder, float amount) { builder.addFloat(2, amount, 0.0f); } - public static void addMaxResets(FlatBufferBuilder builder, int maxResets) { builder.addShort(3, (short) maxResets, (short) 0); } - public static int endDriftCompensationSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public DriftCompensationSettings get(int j) { return get(new DriftCompensationSettings(), j); } - public DriftCompensationSettings get(DriftCompensationSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public DriftCompensationSettingsT unpack() { - DriftCompensationSettingsT _o = new DriftCompensationSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(DriftCompensationSettingsT _o) { - boolean _oEnabled = enabled(); - _o.setEnabled(_oEnabled); - boolean _oPrediction = prediction(); - _o.setPrediction(_oPrediction); - float _oAmount = amount(); - _o.setAmount(_oAmount); - int _oMaxResets = maxResets(); - _o.setMaxResets(_oMaxResets); - } - public static int pack(FlatBufferBuilder builder, DriftCompensationSettingsT _o) { - if (_o == null) return 0; - return createDriftCompensationSettings( - builder, - _o.getEnabled(), - _o.getPrediction(), - _o.getAmount(), - _o.getMaxResets()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettingsT.java deleted file mode 100644 index 790fe9d07..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/DriftCompensationSettingsT.java +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class DriftCompensationSettingsT { - private boolean enabled; - private boolean prediction; - private float amount; - private int maxResets; - - public boolean getEnabled() { return enabled; } - - public void setEnabled(boolean enabled) { this.enabled = enabled; } - - public boolean getPrediction() { return prediction; } - - public void setPrediction(boolean prediction) { this.prediction = prediction; } - - public float getAmount() { return amount; } - - public void setAmount(float amount) { this.amount = amount; } - - public int getMaxResets() { return maxResets; } - - public void setMaxResets(int maxResets) { this.maxResets = maxResets; } - - - public DriftCompensationSettingsT() { - this.enabled = false; - this.prediction = false; - this.amount = 0.0f; - this.maxResets = 0; - } -} - diff --git a/protocol/java/src/solarxr_protocol/datatypes/FilteringType.java b/protocol/java/src/solarxr_protocol/rpc/FilteringType.java similarity index 81% rename from protocol/java/src/solarxr_protocol/datatypes/FilteringType.java rename to protocol/java/src/solarxr_protocol/rpc/FilteringType.java index e7975baee..59ff05c2b 100644 --- a/protocol/java/src/solarxr_protocol/datatypes/FilteringType.java +++ b/protocol/java/src/solarxr_protocol/rpc/FilteringType.java @@ -1,10 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.datatypes; +package solarxr_protocol.rpc; -/** - * Used for filtering tracker rotations in software - */ @SuppressWarnings("unused") public final class FilteringType { private FilteringType() { } diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTable.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTable.java new file mode 100644 index 000000000..e212aa14e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTable.java @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class FirmwareDeviceIdTable extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static FirmwareDeviceIdTable getRootAsFirmwareDeviceIdTable(ByteBuffer _bb) { return getRootAsFirmwareDeviceIdTable(_bb, new FirmwareDeviceIdTable()); } + public static FirmwareDeviceIdTable getRootAsFirmwareDeviceIdTable(ByteBuffer _bb, FirmwareDeviceIdTable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public FirmwareDeviceIdTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int id() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + + public static int createFirmwareDeviceIdTable(FlatBufferBuilder builder, + int id) { + builder.startTable(1); + FirmwareDeviceIdTable.addId(builder, id); + return FirmwareDeviceIdTable.endFirmwareDeviceIdTable(builder); + } + + public static void startFirmwareDeviceIdTable(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addId(FlatBufferBuilder builder, int id) { builder.addShort(0, (short) id, (short) 0); } + public static int endFirmwareDeviceIdTable(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public FirmwareDeviceIdTable get(int j) { return get(new FirmwareDeviceIdTable(), j); } + public FirmwareDeviceIdTable get(FirmwareDeviceIdTable obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public FirmwareDeviceIdTableT unpack() { + FirmwareDeviceIdTableT _o = new FirmwareDeviceIdTableT(); + unpackTo(_o); + return _o; + } + public void unpackTo(FirmwareDeviceIdTableT _o) { + int _oId = id(); + _o.setId(_oId); + } + public static int pack(FlatBufferBuilder builder, FirmwareDeviceIdTableT _o) { + if (_o == null) return 0; + return createFirmwareDeviceIdTable( + builder, + _o.getId()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleT.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTableT.java similarity index 73% rename from protocol/java/src/solarxr_protocol/pub_sub/TopicHandleT.java rename to protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTableT.java index deaa0d322..e33361275 100644 --- a/protocol/java/src/solarxr_protocol/pub_sub/TopicHandleT.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareDeviceIdTableT.java @@ -1,13 +1,13 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.pub_sub; +package solarxr_protocol.rpc; import java.nio.*; import java.lang.*; import java.util.*; import com.google.flatbuffers.*; -public class TopicHandleT { +public class FirmwareDeviceIdTableT { private int id; public int getId() { return id; } @@ -15,7 +15,7 @@ public class TopicHandleT { public void setId(int id) { this.id = id; } - public TopicHandleT() { + public FirmwareDeviceIdTableT() { this.id = 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.java index d5fc06d6d..5940f00cf 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.java @@ -6,10 +6,10 @@ public final class FirmwareUpdateDeviceId { private FirmwareUpdateDeviceId() { } public static final byte NONE = 0; - public static final byte solarxr_protocol_datatypes_DeviceIdTable = 1; + public static final byte FirmwareDeviceIdTable = 1; public static final byte SerialDevicePort = 2; - public static final String[] names = { "NONE", "solarxr_protocol_datatypes_DeviceIdTable", "SerialDevicePort", }; + public static final String[] names = { "NONE", "FirmwareDeviceIdTable", "SerialDevicePort", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceIdUnion.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceIdUnion.java index 4f1206022..7e4fd2e5c 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceIdUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateDeviceIdUnion.java @@ -21,12 +21,12 @@ public FirmwareUpdateDeviceIdUnion() { this.value = null; } - public solarxr_protocol.datatypes.DeviceIdTableT assolarxr_protocol_datatypes_DeviceIdTable() { return (solarxr_protocol.datatypes.DeviceIdTableT) value; } + public solarxr_protocol.rpc.FirmwareDeviceIdTableT asFirmwareDeviceIdTable() { return (solarxr_protocol.rpc.FirmwareDeviceIdTableT) value; } public solarxr_protocol.rpc.SerialDevicePortT asSerialDevicePort() { return (solarxr_protocol.rpc.SerialDevicePortT) value; } public static int pack(FlatBufferBuilder builder, FirmwareUpdateDeviceIdUnion _o) { switch (_o.type) { - case FirmwareUpdateDeviceId.solarxr_protocol_datatypes_DeviceIdTable: return solarxr_protocol.datatypes.DeviceIdTable.pack(builder, _o.assolarxr_protocol_datatypes_DeviceIdTable()); + case FirmwareUpdateDeviceId.FirmwareDeviceIdTable: return solarxr_protocol.rpc.FirmwareDeviceIdTable.pack(builder, _o.asFirmwareDeviceIdTable()); case FirmwareUpdateDeviceId.SerialDevicePort: return solarxr_protocol.rpc.SerialDevicePort.pack(builder, _o.asSerialDevicePort()); default: return 0; } diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java index 84e657391..fe32f9f53 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java @@ -35,6 +35,9 @@ private FirmwareUpdateStatus() { } * The server is provisioning the tracker */ public static final int PROVISIONING = 6; + /** + * The update process completed with success + */ public static final int DONE = 7; /** * Could not find the device diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.java index 9cd14b8c6..2456a283c 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.java @@ -63,9 +63,9 @@ public void unpackTo(FirmwareUpdateStatusResponseT _o) { _oDeviceId.setType(_oDeviceIdType); Table _oDeviceIdValue; switch (_oDeviceIdType) { - case solarxr_protocol.rpc.FirmwareUpdateDeviceId.solarxr_protocol_datatypes_DeviceIdTable: - _oDeviceIdValue = deviceId(new solarxr_protocol.datatypes.DeviceIdTable()); - _oDeviceId.setValue(_oDeviceIdValue != null ? ((solarxr_protocol.datatypes.DeviceIdTable) _oDeviceIdValue).unpack() : null); + case solarxr_protocol.rpc.FirmwareUpdateDeviceId.FirmwareDeviceIdTable: + _oDeviceIdValue = deviceId(new solarxr_protocol.rpc.FirmwareDeviceIdTable()); + _oDeviceId.setValue(_oDeviceIdValue != null ? ((solarxr_protocol.rpc.FirmwareDeviceIdTable) _oDeviceIdValue).unpack() : null); break; case solarxr_protocol.rpc.FirmwareUpdateDeviceId.SerialDevicePort: _oDeviceIdValue = deviceId(new solarxr_protocol.rpc.SerialDevicePort()); diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDSettings.java b/protocol/java/src/solarxr_protocol/rpc/HIDSettings.java deleted file mode 100644 index feeb1e615..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/HIDSettings.java +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class HIDSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static HIDSettings getRootAsHIDSettings(ByteBuffer _bb) { return getRootAsHIDSettings(_bb, new HIDSettings()); } - public static HIDSettings getRootAsHIDSettings(ByteBuffer _bb, HIDSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public HIDSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean trackersOverHid() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createHIDSettings(FlatBufferBuilder builder, - boolean trackersOverHid) { - builder.startTable(1); - HIDSettings.addTrackersOverHid(builder, trackersOverHid); - return HIDSettings.endHIDSettings(builder); - } - - public static void startHIDSettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackersOverHid(FlatBufferBuilder builder, boolean trackersOverHid) { builder.addBoolean(0, trackersOverHid, false); } - public static int endHIDSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public HIDSettings get(int j) { return get(new HIDSettings(), j); } - public HIDSettings get(HIDSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public HIDSettingsT unpack() { - HIDSettingsT _o = new HIDSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(HIDSettingsT _o) { - boolean _oTrackersOverHid = trackersOverHid(); - _o.setTrackersOverHid(_oTrackersOverHid); - } - public static int pack(FlatBufferBuilder builder, HIDSettingsT _o) { - if (_o == null) return 0; - return createHIDSettings( - builder, - _o.getTrackersOverHid()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequest.java new file mode 100644 index 000000000..c8ef31d37 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class HIDSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static HIDSettingsRequest getRootAsHIDSettingsRequest(ByteBuffer _bb) { return getRootAsHIDSettingsRequest(_bb, new HIDSettingsRequest()); } + public static HIDSettingsRequest getRootAsHIDSettingsRequest(ByteBuffer _bb, HIDSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public HIDSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startHIDSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endHIDSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public HIDSettingsRequest get(int j) { return get(new HIDSettingsRequest(), j); } + public HIDSettingsRequest get(HIDSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public HIDSettingsRequestT unpack() { + HIDSettingsRequestT _o = new HIDSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(HIDSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, HIDSettingsRequestT _o) { + if (_o == null) return 0; + startHIDSettingsRequest(builder); + return endHIDSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/HeightRequestT.java b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequestT.java similarity index 75% rename from protocol/java/src/solarxr_protocol/rpc/HeightRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequestT.java index f7d336695..25e6f5ea0 100644 --- a/protocol/java/src/solarxr_protocol/rpc/HeightRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class HeightRequestT { +public class HIDSettingsRequestT { - public HeightRequestT() { + public HIDSettingsRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponse.java new file mode 100644 index 000000000..1b84671bf --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponse.java @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class HIDSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static HIDSettingsResponse getRootAsHIDSettingsResponse(ByteBuffer _bb) { return getRootAsHIDSettingsResponse(_bb, new HIDSettingsResponse()); } + public static HIDSettingsResponse getRootAsHIDSettingsResponse(ByteBuffer _bb, HIDSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public HIDSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean trackersOverHid() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createHIDSettingsResponse(FlatBufferBuilder builder, + boolean trackersOverHid) { + builder.startTable(1); + HIDSettingsResponse.addTrackersOverHid(builder, trackersOverHid); + return HIDSettingsResponse.endHIDSettingsResponse(builder); + } + + public static void startHIDSettingsResponse(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackersOverHid(FlatBufferBuilder builder, boolean trackersOverHid) { builder.addBoolean(0, trackersOverHid, false); } + public static int endHIDSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public HIDSettingsResponse get(int j) { return get(new HIDSettingsResponse(), j); } + public HIDSettingsResponse get(HIDSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public HIDSettingsResponseT unpack() { + HIDSettingsResponseT _o = new HIDSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(HIDSettingsResponseT _o) { + boolean _oTrackersOverHid = trackersOverHid(); + _o.setTrackersOverHid(_oTrackersOverHid); + } + public static int pack(FlatBufferBuilder builder, HIDSettingsResponseT _o) { + if (_o == null) return 0; + return createHIDSettingsResponse( + builder, + _o.getTrackersOverHid()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponseT.java similarity index 86% rename from protocol/java/src/solarxr_protocol/rpc/HIDSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponseT.java index 207be6552..76f7d5cee 100644 --- a/protocol/java/src/solarxr_protocol/rpc/HIDSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/HIDSettingsResponseT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class HIDSettingsT { +public class HIDSettingsResponseT { private boolean trackersOverHid; public boolean getTrackersOverHid() { return trackersOverHid; } @@ -15,7 +15,7 @@ public class HIDSettingsT { public void setTrackersOverHid(boolean trackersOverHid) { this.trackersOverHid = trackersOverHid; } - public HIDSettingsT() { + public HIDSettingsResponseT() { this.trackersOverHid = false; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/HeightRequest.java b/protocol/java/src/solarxr_protocol/rpc/HeightRequest.java deleted file mode 100644 index fcff11979..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/HeightRequest.java +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class HeightRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static HeightRequest getRootAsHeightRequest(ByteBuffer _bb) { return getRootAsHeightRequest(_bb, new HeightRequest()); } - public static HeightRequest getRootAsHeightRequest(ByteBuffer _bb, HeightRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public HeightRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startHeightRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endHeightRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public HeightRequest get(int j) { return get(new HeightRequest(), j); } - public HeightRequest get(HeightRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public HeightRequestT unpack() { - HeightRequestT _o = new HeightRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(HeightRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, HeightRequestT _o) { - if (_o == null) return 0; - startHeightRequest(builder); - return endHeightRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/HeightResponse.java b/protocol/java/src/solarxr_protocol/rpc/HeightResponse.java deleted file mode 100644 index 4fd08d2dd..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/HeightResponse.java +++ /dev/null @@ -1,66 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Returns the current min and max positional tracker heights - */ -@SuppressWarnings("unused") -public final class HeightResponse extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static HeightResponse getRootAsHeightResponse(ByteBuffer _bb) { return getRootAsHeightResponse(_bb, new HeightResponse()); } - public static HeightResponse getRootAsHeightResponse(ByteBuffer _bb, HeightResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public HeightResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public float minHeight() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float maxHeight() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - - public static int createHeightResponse(FlatBufferBuilder builder, - float minHeight, - float maxHeight) { - builder.startTable(2); - HeightResponse.addMaxHeight(builder, maxHeight); - HeightResponse.addMinHeight(builder, minHeight); - return HeightResponse.endHeightResponse(builder); - } - - public static void startHeightResponse(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addMinHeight(FlatBufferBuilder builder, float minHeight) { builder.addFloat(0, minHeight, 0.0f); } - public static void addMaxHeight(FlatBufferBuilder builder, float maxHeight) { builder.addFloat(1, maxHeight, 0.0f); } - public static int endHeightResponse(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public HeightResponse get(int j) { return get(new HeightResponse(), j); } - public HeightResponse get(HeightResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public HeightResponseT unpack() { - HeightResponseT _o = new HeightResponseT(); - unpackTo(_o); - return _o; - } - public void unpackTo(HeightResponseT _o) { - float _oMinHeight = minHeight(); - _o.setMinHeight(_oMinHeight); - float _oMaxHeight = maxHeight(); - _o.setMaxHeight(_oMaxHeight); - } - public static int pack(FlatBufferBuilder builder, HeightResponseT _o) { - if (_o == null) return 0; - return createHeightResponse( - builder, - _o.getMinHeight(), - _o.getMaxHeight()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/HeightResponseT.java b/protocol/java/src/solarxr_protocol/rpc/HeightResponseT.java deleted file mode 100644 index fe840f6b0..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/HeightResponseT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class HeightResponseT { - private float minHeight; - private float maxHeight; - - public float getMinHeight() { return minHeight; } - - public void setMinHeight(float minHeight) { this.minHeight = minHeight; } - - public float getMaxHeight() { return maxHeight; } - - public void setMaxHeight(float maxHeight) { this.maxHeight = maxHeight; } - - - public HeightResponseT() { - this.minHeight = 0.0f; - this.maxHeight = 0.0f; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java b/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java index f4528fb8b..6a88d612d 100644 --- a/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java @@ -7,6 +7,9 @@ import java.util.*; import com.google.flatbuffers.*; +/** + * Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui + */ @SuppressWarnings("unused") public final class KeybindRequest extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java b/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java index aa7dd30fb..2badf6ad4 100644 --- a/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java @@ -7,6 +7,9 @@ import java.util.*; import com.google.flatbuffers.*; +/** + * Returns keybinds for displaying in gui + */ @SuppressWarnings("unused") public final class KeybindResponse extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } diff --git a/protocol/java/src/solarxr_protocol/rpc/MagToggleRequest.java b/protocol/java/src/solarxr_protocol/rpc/MagToggleRequest.java index bc5ac6e88..de017b5b4 100644 --- a/protocol/java/src/solarxr_protocol/rpc/MagToggleRequest.java +++ b/protocol/java/src/solarxr_protocol/rpc/MagToggleRequest.java @@ -18,18 +18,17 @@ public final class MagToggleRequest extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public MagToggleRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public static int createMagToggleRequest(FlatBufferBuilder builder, - int trackerIdOffset) { + int trackerId) { builder.startTable(1); - MagToggleRequest.addTrackerId(builder, trackerIdOffset); + MagToggleRequest.addTrackerId(builder, trackerId); return MagToggleRequest.endMagToggleRequest(builder); } public static void startMagToggleRequest(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static int endMagToggleRequest(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -47,15 +46,14 @@ public MagToggleRequestT unpack() { return _o; } public void unpackTo(MagToggleRequestT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); } public static int pack(FlatBufferBuilder builder, MagToggleRequestT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); return createMagToggleRequest( builder, - _trackerId); + _o.getTrackerId()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/MagToggleRequestT.java b/protocol/java/src/solarxr_protocol/rpc/MagToggleRequestT.java index 943773789..90d0b4128 100644 --- a/protocol/java/src/solarxr_protocol/rpc/MagToggleRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/MagToggleRequestT.java @@ -8,15 +8,15 @@ import com.google.flatbuffers.*; public class MagToggleRequestT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public MagToggleRequestT() { - this.trackerId = null; + this.trackerId = 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/MagToggleResponse.java b/protocol/java/src/solarxr_protocol/rpc/MagToggleResponse.java index 18be18a5b..a16a7f780 100644 --- a/protocol/java/src/solarxr_protocol/rpc/MagToggleResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/MagToggleResponse.java @@ -18,21 +18,20 @@ public final class MagToggleResponse extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public MagToggleResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public boolean enable() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public static int createMagToggleResponse(FlatBufferBuilder builder, - int trackerIdOffset, + int trackerId, boolean enable) { builder.startTable(2); - MagToggleResponse.addTrackerId(builder, trackerIdOffset); + MagToggleResponse.addTrackerId(builder, trackerId); MagToggleResponse.addEnable(builder, enable); return MagToggleResponse.endMagToggleResponse(builder); } public static void startMagToggleResponse(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static void addEnable(FlatBufferBuilder builder, boolean enable) { builder.addBoolean(1, enable, false); } public static int endMagToggleResponse(FlatBufferBuilder builder) { int o = builder.endTable(); @@ -51,17 +50,16 @@ public MagToggleResponseT unpack() { return _o; } public void unpackTo(MagToggleResponseT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); boolean _oEnable = enable(); _o.setEnable(_oEnable); } public static int pack(FlatBufferBuilder builder, MagToggleResponseT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); return createMagToggleResponse( builder, - _trackerId, + _o.getTrackerId(), _o.getEnable()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/MagToggleResponseT.java b/protocol/java/src/solarxr_protocol/rpc/MagToggleResponseT.java index 2bda259a1..6098b1e36 100644 --- a/protocol/java/src/solarxr_protocol/rpc/MagToggleResponseT.java +++ b/protocol/java/src/solarxr_protocol/rpc/MagToggleResponseT.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; public class MagToggleResponseT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; private boolean enable; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public boolean getEnable() { return enable; } @@ -21,7 +21,7 @@ public class MagToggleResponseT { public MagToggleResponseT() { - this.trackerId = null; + this.trackerId = 0; this.enable = false; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettings.java b/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettings.java deleted file mode 100644 index 4b7e2bd40..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettings.java +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. - */ -@SuppressWarnings("unused") -public final class OSCRouterSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static OSCRouterSettings getRootAsOSCRouterSettings(ByteBuffer _bb) { return getRootAsOSCRouterSettings(_bb, new OSCRouterSettings()); } - public static OSCRouterSettings getRootAsOSCRouterSettings(ByteBuffer _bb, OSCRouterSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public OSCRouterSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.OSCSettings oscSettings() { return oscSettings(new solarxr_protocol.rpc.OSCSettings()); } - public solarxr_protocol.rpc.OSCSettings oscSettings(solarxr_protocol.rpc.OSCSettings obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createOSCRouterSettings(FlatBufferBuilder builder, - int oscSettingsOffset) { - builder.startTable(1); - OSCRouterSettings.addOscSettings(builder, oscSettingsOffset); - return OSCRouterSettings.endOSCRouterSettings(builder); - } - - public static void startOSCRouterSettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addOscSettings(FlatBufferBuilder builder, int oscSettingsOffset) { builder.addOffset(0, oscSettingsOffset, 0); } - public static int endOSCRouterSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public OSCRouterSettings get(int j) { return get(new OSCRouterSettings(), j); } - public OSCRouterSettings get(OSCRouterSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public OSCRouterSettingsT unpack() { - OSCRouterSettingsT _o = new OSCRouterSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(OSCRouterSettingsT _o) { - if (oscSettings() != null) _o.setOscSettings(oscSettings().unpack()); - else _o.setOscSettings(null); - } - public static int pack(FlatBufferBuilder builder, OSCRouterSettingsT _o) { - if (_o == null) return 0; - int _oscSettings = _o.getOscSettings() == null ? 0 : solarxr_protocol.rpc.OSCSettings.pack(builder, _o.getOscSettings()); - return createOSCRouterSettings( - builder, - _oscSettings); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettingsT.java deleted file mode 100644 index a0a2c79f6..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/OSCRouterSettingsT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class OSCRouterSettingsT { - private solarxr_protocol.rpc.OSCSettingsT oscSettings; - - public solarxr_protocol.rpc.OSCSettingsT getOscSettings() { return oscSettings; } - - public void setOscSettings(solarxr_protocol.rpc.OSCSettingsT oscSettings) { this.oscSettings = oscSettings; } - - - public OSCRouterSettingsT() { - this.oscSettings = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCSettings.java b/protocol/java/src/solarxr_protocol/rpc/OSCSettings.java deleted file mode 100644 index 6392815d8..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/OSCSettings.java +++ /dev/null @@ -1,83 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * OSC Settings that are used in *any* osc application. - */ -@SuppressWarnings("unused") -public final class OSCSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static OSCSettings getRootAsOSCSettings(ByteBuffer _bb) { return getRootAsOSCSettings(_bb, new OSCSettings()); } - public static OSCSettings getRootAsOSCSettings(ByteBuffer _bb, OSCSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public OSCSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public int portIn() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } - public int portOut() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } - public String address() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer addressAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } - public ByteBuffer addressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } - - public static int createOSCSettings(FlatBufferBuilder builder, - boolean enabled, - int portIn, - int portOut, - int addressOffset) { - builder.startTable(4); - OSCSettings.addAddress(builder, addressOffset); - OSCSettings.addPortOut(builder, portOut); - OSCSettings.addPortIn(builder, portIn); - OSCSettings.addEnabled(builder, enabled); - return OSCSettings.endOSCSettings(builder); - } - - public static void startOSCSettings(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } - public static void addPortIn(FlatBufferBuilder builder, int portIn) { builder.addShort(1, (short) portIn, (short) 0); } - public static void addPortOut(FlatBufferBuilder builder, int portOut) { builder.addShort(2, (short) portOut, (short) 0); } - public static void addAddress(FlatBufferBuilder builder, int addressOffset) { builder.addOffset(3, addressOffset, 0); } - public static int endOSCSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public OSCSettings get(int j) { return get(new OSCSettings(), j); } - public OSCSettings get(OSCSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public OSCSettingsT unpack() { - OSCSettingsT _o = new OSCSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(OSCSettingsT _o) { - boolean _oEnabled = enabled(); - _o.setEnabled(_oEnabled); - int _oPortIn = portIn(); - _o.setPortIn(_oPortIn); - int _oPortOut = portOut(); - _o.setPortOut(_oPortOut); - String _oAddress = address(); - _o.setAddress(_oAddress); - } - public static int pack(FlatBufferBuilder builder, OSCSettingsT _o) { - if (_o == null) return 0; - int _address = _o.getAddress() == null ? 0 : builder.createString(_o.getAddress()); - return createOSCSettings( - builder, - _o.getEnabled(), - _o.getPortIn(), - _o.getPortOut(), - _address); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSetting.java b/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSetting.java deleted file mode 100644 index cbb00418a..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSetting.java +++ /dev/null @@ -1,98 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class OSCTrackersSetting extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static OSCTrackersSetting getRootAsOSCTrackersSetting(ByteBuffer _bb) { return getRootAsOSCTrackersSetting(_bb, new OSCTrackersSetting()); } - public static OSCTrackersSetting getRootAsOSCTrackersSetting(ByteBuffer _bb, OSCTrackersSetting obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public OSCTrackersSetting __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean head() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean chest() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean waist() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean knees() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean feet() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean elbows() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hands() { int o = __offset(16); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createOSCTrackersSetting(FlatBufferBuilder builder, - boolean head, - boolean chest, - boolean waist, - boolean knees, - boolean feet, - boolean elbows, - boolean hands) { - builder.startTable(7); - OSCTrackersSetting.addHands(builder, hands); - OSCTrackersSetting.addElbows(builder, elbows); - OSCTrackersSetting.addFeet(builder, feet); - OSCTrackersSetting.addKnees(builder, knees); - OSCTrackersSetting.addWaist(builder, waist); - OSCTrackersSetting.addChest(builder, chest); - OSCTrackersSetting.addHead(builder, head); - return OSCTrackersSetting.endOSCTrackersSetting(builder); - } - - public static void startOSCTrackersSetting(FlatBufferBuilder builder) { builder.startTable(7); } - public static void addHead(FlatBufferBuilder builder, boolean head) { builder.addBoolean(0, head, false); } - public static void addChest(FlatBufferBuilder builder, boolean chest) { builder.addBoolean(1, chest, false); } - public static void addWaist(FlatBufferBuilder builder, boolean waist) { builder.addBoolean(2, waist, false); } - public static void addKnees(FlatBufferBuilder builder, boolean knees) { builder.addBoolean(3, knees, false); } - public static void addFeet(FlatBufferBuilder builder, boolean feet) { builder.addBoolean(4, feet, false); } - public static void addElbows(FlatBufferBuilder builder, boolean elbows) { builder.addBoolean(5, elbows, false); } - public static void addHands(FlatBufferBuilder builder, boolean hands) { builder.addBoolean(6, hands, false); } - public static int endOSCTrackersSetting(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public OSCTrackersSetting get(int j) { return get(new OSCTrackersSetting(), j); } - public OSCTrackersSetting get(OSCTrackersSetting obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public OSCTrackersSettingT unpack() { - OSCTrackersSettingT _o = new OSCTrackersSettingT(); - unpackTo(_o); - return _o; - } - public void unpackTo(OSCTrackersSettingT _o) { - boolean _oHead = head(); - _o.setHead(_oHead); - boolean _oChest = chest(); - _o.setChest(_oChest); - boolean _oWaist = waist(); - _o.setWaist(_oWaist); - boolean _oKnees = knees(); - _o.setKnees(_oKnees); - boolean _oFeet = feet(); - _o.setFeet(_oFeet); - boolean _oElbows = elbows(); - _o.setElbows(_oElbows); - boolean _oHands = hands(); - _o.setHands(_oHands); - } - public static int pack(FlatBufferBuilder builder, OSCTrackersSettingT _o) { - if (_o == null) return 0; - return createOSCTrackersSetting( - builder, - _o.getHead(), - _o.getChest(), - _o.getWaist(), - _o.getKnees(), - _o.getFeet(), - _o.getElbows(), - _o.getHands()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSettingT.java b/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSettingT.java deleted file mode 100644 index c23627a36..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/OSCTrackersSettingT.java +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class OSCTrackersSettingT { - private boolean head; - private boolean chest; - private boolean waist; - private boolean knees; - private boolean feet; - private boolean elbows; - private boolean hands; - - public boolean getHead() { return head; } - - public void setHead(boolean head) { this.head = head; } - - public boolean getChest() { return chest; } - - public void setChest(boolean chest) { this.chest = chest; } - - public boolean getWaist() { return waist; } - - public void setWaist(boolean waist) { this.waist = waist; } - - public boolean getKnees() { return knees; } - - public void setKnees(boolean knees) { this.knees = knees; } - - public boolean getFeet() { return feet; } - - public void setFeet(boolean feet) { this.feet = feet; } - - public boolean getElbows() { return elbows; } - - public void setElbows(boolean elbows) { this.elbows = elbows; } - - public boolean getHands() { return hands; } - - public void setHands(boolean hands) { this.hands = hands; } - - - public OSCTrackersSettingT() { - this.head = false; - this.chest = false; - this.waist = false; - this.knees = false; - this.feet = false; - this.elbows = false; - this.hands = false; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdate.java b/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdate.java index 8c8ee77f7..c813d500e 100644 --- a/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdate.java +++ b/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdate.java @@ -16,18 +16,26 @@ public final class OTAFirmwareUpdate extends Table { public OTAFirmwareUpdate __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } /** - * id of the device, this refer to the actual DeviceId from the protocol + * Id of the device */ - public solarxr_protocol.datatypes.DeviceId deviceId() { return deviceId(new solarxr_protocol.datatypes.DeviceId()); } - public solarxr_protocol.datatypes.DeviceId deviceId(solarxr_protocol.datatypes.DeviceId obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public int deviceId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } /** * A table containing the url and offset of the firmware bin file */ public solarxr_protocol.rpc.FirmwarePart firmwarePart() { return firmwarePart(new solarxr_protocol.rpc.FirmwarePart()); } public solarxr_protocol.rpc.FirmwarePart firmwarePart(solarxr_protocol.rpc.FirmwarePart obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public static int createOTAFirmwareUpdate(FlatBufferBuilder builder, + int deviceId, + int firmwarePartOffset) { + builder.startTable(2); + OTAFirmwareUpdate.addFirmwarePart(builder, firmwarePartOffset); + OTAFirmwareUpdate.addDeviceId(builder, deviceId); + return OTAFirmwareUpdate.endOTAFirmwareUpdate(builder); + } + public static void startOTAFirmwareUpdate(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addDeviceId(FlatBufferBuilder builder, int deviceIdOffset) { builder.addStruct(0, deviceIdOffset, 0); } + public static void addDeviceId(FlatBufferBuilder builder, int deviceId) { builder.addShort(0, (short) deviceId, (short) 0); } public static void addFirmwarePart(FlatBufferBuilder builder, int firmwarePartOffset) { builder.addOffset(1, firmwarePartOffset, 0); } public static int endOTAFirmwareUpdate(FlatBufferBuilder builder) { int o = builder.endTable(); @@ -46,18 +54,18 @@ public OTAFirmwareUpdateT unpack() { return _o; } public void unpackTo(OTAFirmwareUpdateT _o) { - if (deviceId() != null) deviceId().unpackTo(_o.getDeviceId()); - else _o.setDeviceId(null); + int _oDeviceId = deviceId(); + _o.setDeviceId(_oDeviceId); if (firmwarePart() != null) _o.setFirmwarePart(firmwarePart().unpack()); else _o.setFirmwarePart(null); } public static int pack(FlatBufferBuilder builder, OTAFirmwareUpdateT _o) { if (_o == null) return 0; int _firmwarePart = _o.getFirmwarePart() == null ? 0 : solarxr_protocol.rpc.FirmwarePart.pack(builder, _o.getFirmwarePart()); - startOTAFirmwareUpdate(builder); - addDeviceId(builder, solarxr_protocol.datatypes.DeviceId.pack(builder, _o.getDeviceId())); - addFirmwarePart(builder, _firmwarePart); - return endOTAFirmwareUpdate(builder); + return createOTAFirmwareUpdate( + builder, + _o.getDeviceId(), + _firmwarePart); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdateT.java b/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdateT.java index f19b78657..bfa7b45c5 100644 --- a/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdateT.java +++ b/protocol/java/src/solarxr_protocol/rpc/OTAFirmwareUpdateT.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; public class OTAFirmwareUpdateT { - private solarxr_protocol.datatypes.DeviceIdT deviceId; + private int deviceId; private solarxr_protocol.rpc.FirmwarePartT firmwarePart; - public solarxr_protocol.datatypes.DeviceIdT getDeviceId() { return deviceId; } + public int getDeviceId() { return deviceId; } - public void setDeviceId(solarxr_protocol.datatypes.DeviceIdT deviceId) { this.deviceId = deviceId; } + public void setDeviceId(int deviceId) { this.deviceId = deviceId; } public solarxr_protocol.rpc.FirmwarePartT getFirmwarePart() { return firmwarePart; } @@ -21,7 +21,7 @@ public class OTAFirmwareUpdateT { public OTAFirmwareUpdateT() { - this.deviceId = new solarxr_protocol.datatypes.DeviceIdT(); + this.deviceId = 0; this.firmwarePart = null; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequest.java new file mode 100644 index 000000000..d6b2d4140 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class OutputTrackersSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static OutputTrackersSettingsRequest getRootAsOutputTrackersSettingsRequest(ByteBuffer _bb) { return getRootAsOutputTrackersSettingsRequest(_bb, new OutputTrackersSettingsRequest()); } + public static OutputTrackersSettingsRequest getRootAsOutputTrackersSettingsRequest(ByteBuffer _bb, OutputTrackersSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public OutputTrackersSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startOutputTrackersSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endOutputTrackersSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public OutputTrackersSettingsRequest get(int j) { return get(new OutputTrackersSettingsRequest(), j); } + public OutputTrackersSettingsRequest get(OutputTrackersSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public OutputTrackersSettingsRequestT unpack() { + OutputTrackersSettingsRequestT _o = new OutputTrackersSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(OutputTrackersSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, OutputTrackersSettingsRequestT _o) { + if (_o == null) return 0; + startOutputTrackersSettingsRequest(builder); + return endOutputTrackersSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequestT.java b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequestT.java similarity index 69% rename from protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequestT.java index df8a4de5e..e4cf733f6 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ClearDriftCompensationRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class ClearDriftCompensationRequestT { +public class OutputTrackersSettingsRequestT { - public ClearDriftCompensationRequestT() { + public OutputTrackersSettingsRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponse.java new file mode 100644 index 000000000..eb7f13f5a --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponse.java @@ -0,0 +1,86 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class OutputTrackersSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static OutputTrackersSettingsResponse getRootAsOutputTrackersSettingsResponse(ByteBuffer _bb) { return getRootAsOutputTrackersSettingsResponse(_bb, new OutputTrackersSettingsResponse()); } + public static OutputTrackersSettingsResponse getRootAsOutputTrackersSettingsResponse(ByteBuffer _bb, OutputTrackersSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public OutputTrackersSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean automaticTrackerToggle() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int trackers(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int trackersLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } + public ByteVector trackersVector() { return trackersVector(new ByteVector()); } + public ByteVector trackersVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer trackersInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + public boolean sendDerivedVelocity() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createOutputTrackersSettingsResponse(FlatBufferBuilder builder, + boolean automaticTrackerToggle, + int trackersOffset, + boolean sendDerivedVelocity) { + builder.startTable(3); + OutputTrackersSettingsResponse.addTrackers(builder, trackersOffset); + OutputTrackersSettingsResponse.addSendDerivedVelocity(builder, sendDerivedVelocity); + OutputTrackersSettingsResponse.addAutomaticTrackerToggle(builder, automaticTrackerToggle); + return OutputTrackersSettingsResponse.endOutputTrackersSettingsResponse(builder); + } + + public static void startOutputTrackersSettingsResponse(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addAutomaticTrackerToggle(FlatBufferBuilder builder, boolean automaticTrackerToggle) { builder.addBoolean(0, automaticTrackerToggle, false); } + public static void addTrackers(FlatBufferBuilder builder, int trackersOffset) { builder.addOffset(1, trackersOffset, 0); } + public static int createTrackersVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createTrackersVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startTrackersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addSendDerivedVelocity(FlatBufferBuilder builder, boolean sendDerivedVelocity) { builder.addBoolean(2, sendDerivedVelocity, false); } + public static int endOutputTrackersSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public OutputTrackersSettingsResponse get(int j) { return get(new OutputTrackersSettingsResponse(), j); } + public OutputTrackersSettingsResponse get(OutputTrackersSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public OutputTrackersSettingsResponseT unpack() { + OutputTrackersSettingsResponseT _o = new OutputTrackersSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(OutputTrackersSettingsResponseT _o) { + boolean _oAutomaticTrackerToggle = automaticTrackerToggle(); + _o.setAutomaticTrackerToggle(_oAutomaticTrackerToggle); + int[] _oTrackers = new int[trackersLength()]; + for (int _j = 0; _j < trackersLength(); ++_j) {_oTrackers[_j] = trackers(_j);} + _o.setTrackers(_oTrackers); + boolean _oSendDerivedVelocity = sendDerivedVelocity(); + _o.setSendDerivedVelocity(_oSendDerivedVelocity); + } + public static int pack(FlatBufferBuilder builder, OutputTrackersSettingsResponseT _o) { + if (_o == null) return 0; + int _trackers = 0; + if (_o.getTrackers() != null) { + byte[] __trackers = new byte[_o.getTrackers().length]; + int _j = 0; + for (int _e : _o.getTrackers()) { __trackers[_j] = (byte) _e; _j++;} + _trackers = createTrackersVector(builder, __trackers); + } + return createOutputTrackersSettingsResponse( + builder, + _o.getAutomaticTrackerToggle(), + _trackers, + _o.getSendDerivedVelocity()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponseT.java new file mode 100644 index 000000000..b15aad4c7 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/OutputTrackersSettingsResponseT.java @@ -0,0 +1,34 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class OutputTrackersSettingsResponseT { + private boolean automaticTrackerToggle; + private int[] trackers; + private boolean sendDerivedVelocity; + + public boolean getAutomaticTrackerToggle() { return automaticTrackerToggle; } + + public void setAutomaticTrackerToggle(boolean automaticTrackerToggle) { this.automaticTrackerToggle = automaticTrackerToggle; } + + public int[] getTrackers() { return trackers; } + + public void setTrackers(int[] trackers) { this.trackers = trackers; } + + public boolean getSendDerivedVelocity() { return sendDerivedVelocity; } + + public void setSendDerivedVelocity(boolean sendDerivedVelocity) { this.sendDerivedVelocity = sendDerivedVelocity; } + + + public OutputTrackersSettingsResponseT() { + this.automaticTrackerToggle = false; + this.trackers = null; + this.sendDerivedVelocity = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java b/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java index 646621048..9d2345d9c 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java @@ -18,7 +18,7 @@ public final class ResetResponse extends Table { public int resetType() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public int status() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } /** - * Should return the body parts reseted / being reset + * Should return the body parts reset / being reset */ public int bodyParts(int j) { int o = __offset(8); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } public int bodyPartsLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; } @@ -28,8 +28,7 @@ public final class ResetResponse extends Table { public ByteBuffer bodyPartsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } /** * gives the time in seconds passed since the start of the reset - * is 0 when status == FINISHED - * starts at 0 + * Starts at 0. Should be equal to 'duration' when status == FINISHED */ public int progress() { int o = __offset(10); return o != 0 ? bb.getInt(o + bb_pos) : 0; } public int duration() { int o = __offset(12); return o != 0 ? bb.getInt(o + bb_pos) : 0; } diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetType.java b/protocol/java/src/solarxr_protocol/rpc/ResetType.java index cf510b0b4..8cf99b526 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetType.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetType.java @@ -5,14 +5,20 @@ @SuppressWarnings("unused") public final class ResetType { private ResetType() { } - public static final int Yaw = 0; - public static final int Full = 1; + /** + * Resets the yaw (horizontal) axis + */ + public static final int YAW = 0; + /** + * Resets all axes + */ + public static final int FULL = 1; /** * Second pose for calibrating mounting rotation */ - public static final int Mounting = 2; + public static final int MOUNTING = 2; - public static final String[] names = { "Yaw", "Full", "Mounting", }; + public static final String[] names = { "YAW", "FULL", "MOUNTING", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequest.java new file mode 100644 index 000000000..b7a76f952 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ResetsSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ResetsSettingsRequest getRootAsResetsSettingsRequest(ByteBuffer _bb) { return getRootAsResetsSettingsRequest(_bb, new ResetsSettingsRequest()); } + public static ResetsSettingsRequest getRootAsResetsSettingsRequest(ByteBuffer _bb, ResetsSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public ResetsSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startResetsSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endResetsSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public ResetsSettingsRequest get(int j) { return get(new ResetsSettingsRequest(), j); } + public ResetsSettingsRequest get(ResetsSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ResetsSettingsRequestT unpack() { + ResetsSettingsRequestT _o = new ResetsSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ResetsSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, ResetsSettingsRequestT _o) { + if (_o == null) return 0; + startResetsSettingsRequest(builder); + return endResetsSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequestT.java similarity index 73% rename from protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequestT.java index 2ea638d6d..2e16c782b 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class SkeletonConfigRequestT { +public class ResetsSettingsRequestT { - public SkeletonConfigRequestT() { + public ResetsSettingsRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetsSettings.java b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponse.java similarity index 53% rename from protocol/java/src/solarxr_protocol/rpc/ResetsSettings.java rename to protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponse.java index 75ff71c29..c89eda59c 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetsSettings.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponse.java @@ -8,41 +8,44 @@ import com.google.flatbuffers.*; @SuppressWarnings("unused") -public final class ResetsSettings extends Table { +public final class ResetsSettingsResponse extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ResetsSettings getRootAsResetsSettings(ByteBuffer _bb) { return getRootAsResetsSettings(_bb, new ResetsSettings()); } - public static ResetsSettings getRootAsResetsSettings(ByteBuffer _bb, ResetsSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public static ResetsSettingsResponse getRootAsResetsSettingsResponse(ByteBuffer _bb) { return getRootAsResetsSettingsResponse(_bb, new ResetsSettingsResponse()); } + public static ResetsSettingsResponse getRootAsResetsSettingsResponse(ByteBuffer _bb, ResetsSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ResetsSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + public ResetsSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + /** + * Makes it so feet will be mounting reset when passing no BodyPart + */ public boolean resetMountingFeet() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public int armsMountingResetMode() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public int armsResetMode() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public float yawResetSmoothTime() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } public boolean saveMountingReset() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean resetHmdPitch() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public static int createResetsSettings(FlatBufferBuilder builder, + public static int createResetsSettingsResponse(FlatBufferBuilder builder, boolean resetMountingFeet, - int armsMountingResetMode, + int armsResetMode, float yawResetSmoothTime, boolean saveMountingReset, boolean resetHmdPitch) { builder.startTable(5); - ResetsSettings.addYawResetSmoothTime(builder, yawResetSmoothTime); - ResetsSettings.addResetHmdPitch(builder, resetHmdPitch); - ResetsSettings.addSaveMountingReset(builder, saveMountingReset); - ResetsSettings.addArmsMountingResetMode(builder, armsMountingResetMode); - ResetsSettings.addResetMountingFeet(builder, resetMountingFeet); - return ResetsSettings.endResetsSettings(builder); + ResetsSettingsResponse.addYawResetSmoothTime(builder, yawResetSmoothTime); + ResetsSettingsResponse.addResetHmdPitch(builder, resetHmdPitch); + ResetsSettingsResponse.addSaveMountingReset(builder, saveMountingReset); + ResetsSettingsResponse.addArmsResetMode(builder, armsResetMode); + ResetsSettingsResponse.addResetMountingFeet(builder, resetMountingFeet); + return ResetsSettingsResponse.endResetsSettingsResponse(builder); } - public static void startResetsSettings(FlatBufferBuilder builder) { builder.startTable(5); } + public static void startResetsSettingsResponse(FlatBufferBuilder builder) { builder.startTable(5); } public static void addResetMountingFeet(FlatBufferBuilder builder, boolean resetMountingFeet) { builder.addBoolean(0, resetMountingFeet, false); } - public static void addArmsMountingResetMode(FlatBufferBuilder builder, int armsMountingResetMode) { builder.addByte(1, (byte) armsMountingResetMode, (byte) 0); } + public static void addArmsResetMode(FlatBufferBuilder builder, int armsResetMode) { builder.addByte(1, (byte) armsResetMode, (byte) 0); } public static void addYawResetSmoothTime(FlatBufferBuilder builder, float yawResetSmoothTime) { builder.addFloat(2, yawResetSmoothTime, 0.0f); } public static void addSaveMountingReset(FlatBufferBuilder builder, boolean saveMountingReset) { builder.addBoolean(3, saveMountingReset, false); } public static void addResetHmdPitch(FlatBufferBuilder builder, boolean resetHmdPitch) { builder.addBoolean(4, resetHmdPitch, false); } - public static int endResetsSettings(FlatBufferBuilder builder) { + public static int endResetsSettingsResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; } @@ -50,19 +53,19 @@ public static int endResetsSettings(FlatBufferBuilder builder) { public static final class Vector extends BaseVector { public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - public ResetsSettings get(int j) { return get(new ResetsSettings(), j); } - public ResetsSettings get(ResetsSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + public ResetsSettingsResponse get(int j) { return get(new ResetsSettingsResponse(), j); } + public ResetsSettingsResponse get(ResetsSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } } - public ResetsSettingsT unpack() { - ResetsSettingsT _o = new ResetsSettingsT(); + public ResetsSettingsResponseT unpack() { + ResetsSettingsResponseT _o = new ResetsSettingsResponseT(); unpackTo(_o); return _o; } - public void unpackTo(ResetsSettingsT _o) { + public void unpackTo(ResetsSettingsResponseT _o) { boolean _oResetMountingFeet = resetMountingFeet(); _o.setResetMountingFeet(_oResetMountingFeet); - int _oArmsMountingResetMode = armsMountingResetMode(); - _o.setArmsMountingResetMode(_oArmsMountingResetMode); + int _oArmsResetMode = armsResetMode(); + _o.setArmsResetMode(_oArmsResetMode); float _oYawResetSmoothTime = yawResetSmoothTime(); _o.setYawResetSmoothTime(_oYawResetSmoothTime); boolean _oSaveMountingReset = saveMountingReset(); @@ -70,12 +73,12 @@ public void unpackTo(ResetsSettingsT _o) { boolean _oResetHmdPitch = resetHmdPitch(); _o.setResetHmdPitch(_oResetHmdPitch); } - public static int pack(FlatBufferBuilder builder, ResetsSettingsT _o) { + public static int pack(FlatBufferBuilder builder, ResetsSettingsResponseT _o) { if (_o == null) return 0; - return createResetsSettings( + return createResetsSettingsResponse( builder, _o.getResetMountingFeet(), - _o.getArmsMountingResetMode(), + _o.getArmsResetMode(), _o.getYawResetSmoothTime(), _o.getSaveMountingReset(), _o.getResetHmdPitch()); diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponseT.java new file mode 100644 index 000000000..f86956519 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ResetsSettingsResponseT.java @@ -0,0 +1,46 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ResetsSettingsResponseT { + private boolean resetMountingFeet; + private int armsResetMode; + private float yawResetSmoothTime; + private boolean saveMountingReset; + private boolean resetHmdPitch; + + public boolean getResetMountingFeet() { return resetMountingFeet; } + + public void setResetMountingFeet(boolean resetMountingFeet) { this.resetMountingFeet = resetMountingFeet; } + + public int getArmsResetMode() { return armsResetMode; } + + public void setArmsResetMode(int armsResetMode) { this.armsResetMode = armsResetMode; } + + public float getYawResetSmoothTime() { return yawResetSmoothTime; } + + public void setYawResetSmoothTime(float yawResetSmoothTime) { this.yawResetSmoothTime = yawResetSmoothTime; } + + public boolean getSaveMountingReset() { return saveMountingReset; } + + public void setSaveMountingReset(boolean saveMountingReset) { this.saveMountingReset = saveMountingReset; } + + public boolean getResetHmdPitch() { return resetHmdPitch; } + + public void setResetHmdPitch(boolean resetHmdPitch) { this.resetHmdPitch = resetHmdPitch; } + + + public ResetsSettingsResponseT() { + this.resetMountingFeet = false; + this.armsResetMode = 0; + this.yawResetSmoothTime = 0.0f; + this.saveMountingReset = false; + this.resetHmdPitch = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index 5a8bc48fd..7ae9ba6ba 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -11,89 +11,110 @@ private RpcMessage() { } public static final byte ResetRequest = 3; public static final byte ResetResponse = 4; public static final byte AssignTrackerRequest = 5; - public static final byte SettingsRequest = 6; - public static final byte SettingsResponse = 7; - public static final byte ChangeSettingsRequest = 8; - public static final byte ClearDriftCompensationRequest = 9; - public static final byte RecordBVHRequest = 10; - public static final byte RecordBVHStatus = 11; - public static final byte SkeletonConfigRequest = 12; - public static final byte ChangeSkeletonConfigRequest = 13; - public static final byte SkeletonResetAllRequest = 14; - public static final byte SkeletonConfigResponse = 15; - public static final byte OpenSerialRequest = 16; - public static final byte CloseSerialRequest = 17; - public static final byte SetWifiRequest = 18; - public static final byte SerialUpdateResponse = 19; - public static final byte AutoBoneProcessRequest = 20; - public static final byte AutoBoneProcessStatusResponse = 21; - public static final byte AutoBoneEpochResponse = 22; - public static final byte OverlayDisplayModeRequest = 23; - public static final byte OverlayDisplayModeChangeRequest = 24; - public static final byte OverlayDisplayModeResponse = 25; - public static final byte SerialTrackerRebootRequest = 26; - public static final byte SerialTrackerGetInfoRequest = 27; - public static final byte SerialTrackerFactoryResetRequest = 28; - public static final byte SerialDevicesRequest = 29; - public static final byte SerialDevicesResponse = 30; - public static final byte NewSerialDeviceResponse = 31; - public static final byte StartWifiProvisioningRequest = 32; - public static final byte StopWifiProvisioningRequest = 33; - public static final byte WifiProvisioningStatusResponse = 34; - public static final byte ServerInfosRequest = 35; - public static final byte ServerInfosResponse = 36; - public static final byte LegTweaksTmpChange = 37; - public static final byte LegTweaksTmpClear = 38; - public static final byte TapDetectionSetupNotification = 39; - public static final byte SetPauseTrackingRequest = 40; - public static final byte StatusSystemRequest = 41; - public static final byte StatusSystemResponse = 42; - public static final byte StatusSystemUpdate = 43; - public static final byte StatusSystemFixed = 44; - public static final byte ClearMountingResetRequest = 45; - public static final byte HeightRequest = 46; - public static final byte HeightResponse = 47; - public static final byte AutoBoneApplyRequest = 48; - public static final byte AutoBoneStopRecordingRequest = 49; - public static final byte AutoBoneCancelRecordingRequest = 50; - public static final byte SaveFileNotification = 51; - public static final byte TrackingPauseStateRequest = 52; - public static final byte TrackingPauseStateResponse = 53; - public static final byte SerialTrackerGetWifiScanRequest = 54; - public static final byte UnknownDeviceHandshakeNotification = 55; - public static final byte AddUnknownDeviceRequest = 56; - public static final byte ForgetDeviceRequest = 57; - public static final byte FirmwareUpdateRequest = 58; - public static final byte FirmwareUpdateStatusResponse = 59; - public static final byte FirmwareUpdateStopQueuesRequest = 60; - public static final byte SettingsResetRequest = 61; - public static final byte MagToggleRequest = 62; - public static final byte MagToggleResponse = 63; - public static final byte ChangeMagToggleRequest = 64; - public static final byte RecordBVHStatusRequest = 65; - public static final byte VRCConfigStateRequest = 66; - public static final byte VRCConfigStateChangeResponse = 67; - public static final byte EnableStayAlignedRequest = 68; - public static final byte DetectStayAlignedRelaxedPoseRequest = 69; - public static final byte ResetStayAlignedRelaxedPoseRequest = 70; - public static final byte SerialTrackerCustomCommandRequest = 71; - public static final byte VRCConfigSettingToggleMute = 72; - public static final byte TrackingChecklistRequest = 73; - public static final byte TrackingChecklistResponse = 74; - public static final byte IgnoreTrackingChecklistStepRequest = 75; - public static final byte StartUserHeightCalibration = 76; - public static final byte CancelUserHeightCalibration = 77; - public static final byte UserHeightRecordingStatusResponse = 78; - public static final byte KeybindRequest = 79; - public static final byte ChangeKeybindRequest = 80; - public static final byte KeybindResponse = 81; - public static final byte InstalledInfoRequest = 82; - public static final byte InstalledInfoResponse = 83; - public static final byte OpenUriRequest = 84; - public static final byte OpenUriResponse = 85; - public static final byte EnableSteamVRDriverRequest = 86; + public static final byte OutputTrackersSettingsRequest = 6; + public static final byte OutputTrackersSettingsResponse = 7; + public static final byte ChangeOutputTrackersSettingsRequest = 8; + public static final byte VMCOSCSettingsRequest = 9; + public static final byte VMCOSCSettingsResponse = 10; + public static final byte ChangeVMCOSCSettingsRequest = 11; + public static final byte VRMSettingsRequest = 12; + public static final byte VRMSettingsResponse = 13; + public static final byte ChangeVRMSettingsRequest = 14; + public static final byte SkeletonSettingsRequest = 15; + public static final byte SkeletonSettingsResponse = 16; + public static final byte ChangeSkeletonSettingsRequest = 17; + public static final byte TapDetectionSettingsRequest = 18; + public static final byte TapDetectionSettingsResponse = 19; + public static final byte ChangeTapDetectionSettingsRequest = 20; + public static final byte TapDetectionSetupModeRequest = 21; + public static final byte ResetsSettingsRequest = 22; + public static final byte ResetsSettingsResponse = 23; + public static final byte ChangeResetsSettingsRequest = 24; + public static final byte StayAlignedSettingsRequest = 25; + public static final byte StayAlignedSettingsResponse = 26; + public static final byte ChangeStayAlignedSettingsRequest = 27; + public static final byte CompleteStayAlignedResponse = 28; + public static final byte StayAlignedHideCorrectionRequest = 29; + public static final byte HIDSettingsRequest = 30; + public static final byte HIDSettingsResponse = 31; + public static final byte ChangeHIDSettingsRequest = 32; + public static final byte RecordBVHRequest = 33; + public static final byte RecordBVHStatus = 34; + public static final byte SkeletonProportionsRequest = 35; + public static final byte ChangeSkeletonProportionsRequest = 36; + public static final byte SkeletonProportionsResetAllRequest = 37; + public static final byte SkeletonProportionsResponse = 38; + public static final byte OpenSerialRequest = 39; + public static final byte CloseSerialRequest = 40; + public static final byte SerialUpdateResponse = 41; + public static final byte AutoBoneProcessRequest = 42; + public static final byte AutoBoneProcessStatusResponse = 43; + public static final byte AutoBoneEpochResponse = 44; + public static final byte OverlayDisplayModeRequest = 45; + public static final byte OverlayDisplayModeChangeRequest = 46; + public static final byte OverlayDisplayModeResponse = 47; + public static final byte SerialTrackerRebootRequest = 48; + public static final byte SerialTrackerGetInfoRequest = 49; + public static final byte SerialTrackerFactoryResetRequest = 50; + public static final byte SerialDevicesRequest = 51; + public static final byte SerialDevicesResponse = 52; + public static final byte NewSerialDeviceResponse = 53; + public static final byte StartWifiProvisioningRequest = 54; + public static final byte StopWifiProvisioningRequest = 55; + public static final byte WifiProvisioningStatusResponse = 56; + public static final byte ServerInfosRequest = 57; + public static final byte ServerInfosResponse = 58; + public static final byte LegTweaksTmpChange = 59; + public static final byte LegTweaksTmpClear = 60; + public static final byte TapDetectionSetupNotification = 61; + public static final byte SetPauseTrackingRequest = 62; + public static final byte ClearMountingResetRequest = 63; + public static final byte AutoBoneApplyRequest = 64; + public static final byte AutoBoneStopRecordingRequest = 65; + public static final byte AutoBoneCancelRecordingRequest = 66; + public static final byte SaveFileNotification = 67; + public static final byte TrackingPauseStateRequest = 68; + public static final byte TrackingPauseStateResponse = 69; + public static final byte SerialTrackerGetWifiScanRequest = 70; + public static final byte UnknownDeviceHandshakeNotification = 71; + public static final byte AddUnknownDeviceRequest = 72; + public static final byte ForgetDeviceRequest = 73; + public static final byte FirmwareUpdateRequest = 74; + public static final byte FirmwareUpdateStatusResponse = 75; + public static final byte FirmwareUpdateStopQueuesRequest = 76; + public static final byte SettingsResetRequest = 77; + public static final byte MagToggleRequest = 78; + public static final byte MagToggleResponse = 79; + public static final byte ChangeMagToggleRequest = 80; + public static final byte RecordBVHStatusRequest = 81; + public static final byte VRCConfigStateRequest = 82; + public static final byte VRCConfigStateChangeResponse = 83; + public static final byte EnableStayAlignedRequest = 84; + public static final byte DetectStayAlignedRelaxedPoseRequest = 85; + public static final byte ResetStayAlignedRelaxedPoseRequest = 86; + public static final byte SerialTrackerCustomCommandRequest = 87; + public static final byte VRCConfigSettingToggleMute = 88; + public static final byte TrackingChecklistRequest = 89; + public static final byte TrackingChecklistResponse = 90; + public static final byte IgnoreTrackingChecklistStepRequest = 91; + public static final byte StartUserHeightCalibration = 92; + public static final byte CancelUserHeightCalibration = 93; + public static final byte UserHeightRecordingStatusResponse = 94; + public static final byte VRCOSCSettingsRequest = 95; + public static final byte VRCOSCSettingsResponse = 96; + public static final byte ChangeVRCOSCSettingsRequest = 97; + public static final byte VRCOSCStatusRequest = 98; + public static final byte VRCOSCStatusChangeResponse = 99; + public static final byte KeybindRequest = 100; + public static final byte ChangeKeybindRequest = 101; + public static final byte KeybindResponse = 102; + public static final byte InstalledInfoRequest = 103; + public static final byte InstalledInfoResponse = 104; + public static final byte OpenUriRequest = 105; + public static final byte OpenUriResponse = 106; + public static final byte EnableSteamVRDriverRequest = 107; - public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "KeybindRequest", "ChangeKeybindRequest", "KeybindResponse", "InstalledInfoRequest", "InstalledInfoResponse", "OpenUriRequest", "OpenUriResponse", "EnableSteamVRDriverRequest", }; + public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "OutputTrackersSettingsRequest", "OutputTrackersSettingsResponse", "ChangeOutputTrackersSettingsRequest", "VMCOSCSettingsRequest", "VMCOSCSettingsResponse", "ChangeVMCOSCSettingsRequest", "VRMSettingsRequest", "VRMSettingsResponse", "ChangeVRMSettingsRequest", "SkeletonSettingsRequest", "SkeletonSettingsResponse", "ChangeSkeletonSettingsRequest", "TapDetectionSettingsRequest", "TapDetectionSettingsResponse", "ChangeTapDetectionSettingsRequest", "TapDetectionSetupModeRequest", "ResetsSettingsRequest", "ResetsSettingsResponse", "ChangeResetsSettingsRequest", "StayAlignedSettingsRequest", "StayAlignedSettingsResponse", "ChangeStayAlignedSettingsRequest", "CompleteStayAlignedResponse", "StayAlignedHideCorrectionRequest", "HIDSettingsRequest", "HIDSettingsResponse", "ChangeHIDSettingsRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonProportionsRequest", "ChangeSkeletonProportionsRequest", "SkeletonProportionsResetAllRequest", "SkeletonProportionsResponse", "OpenSerialRequest", "CloseSerialRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "ClearMountingResetRequest", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "VRCOSCSettingsRequest", "VRCOSCSettingsResponse", "ChangeVRCOSCSettingsRequest", "VRCOSCStatusRequest", "VRCOSCStatusChangeResponse", "KeybindRequest", "ChangeKeybindRequest", "KeybindResponse", "InstalledInfoRequest", "InstalledInfoResponse", "OpenUriRequest", "OpenUriResponse", "EnableSteamVRDriverRequest", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java index 619cf4610..dd47988a7 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -16,8 +16,8 @@ public final class RpcMessageHeader extends Table { public RpcMessageHeader __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } /** - * For a request, this identifies the request. For a response, this corresponds - * to the request that it is responding to. + * For a request, this identifies the request. + * For a response, this corresponds to the request that it is responding to. */ public solarxr_protocol.datatypes.TransactionId txId() { return txId(new solarxr_protocol.datatypes.TransactionId()); } public solarxr_protocol.datatypes.TransactionId txId(solarxr_protocol.datatypes.TransactionId obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } @@ -72,21 +72,113 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.AssignTrackerRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.AssignTrackerRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SettingsRequest: - _oMessageValue = message(new solarxr_protocol.rpc.SettingsRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SettingsRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.OutputTrackersSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.OutputTrackersSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.OutputTrackersSettingsRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SettingsResponse: - _oMessageValue = message(new solarxr_protocol.rpc.SettingsResponse()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SettingsResponse) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.OutputTrackersSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.OutputTrackersSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.OutputTrackersSettingsResponse) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.ChangeSettingsRequest: - _oMessageValue = message(new solarxr_protocol.rpc.ChangeSettingsRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeSettingsRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.ChangeOutputTrackersSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.ClearDriftCompensationRequest: - _oMessageValue = message(new solarxr_protocol.rpc.ClearDriftCompensationRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ClearDriftCompensationRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.VMCOSCSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.VMCOSCSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VMCOSCSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VMCOSCSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.VMCOSCSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VMCOSCSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeVMCOSCSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeVMCOSCSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeVMCOSCSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VRMSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.VRMSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRMSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VRMSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.VRMSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRMSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeVRMSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeVRMSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeVRMSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.SkeletonSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.SkeletonSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.SkeletonSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.SkeletonSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeSkeletonSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeSkeletonSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeSkeletonSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.TapDetectionSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.TapDetectionSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.TapDetectionSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.TapDetectionSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.TapDetectionSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.TapDetectionSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeTapDetectionSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeTapDetectionSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeTapDetectionSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.TapDetectionSetupModeRequest: + _oMessageValue = message(new solarxr_protocol.rpc.TapDetectionSetupModeRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.TapDetectionSetupModeRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ResetsSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ResetsSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ResetsSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ResetsSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.ResetsSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ResetsSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeResetsSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeResetsSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeResetsSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.StayAlignedSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.StayAlignedSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StayAlignedSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.StayAlignedSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.StayAlignedSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StayAlignedSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeStayAlignedSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeStayAlignedSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeStayAlignedSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.CompleteStayAlignedResponse: + _oMessageValue = message(new solarxr_protocol.rpc.CompleteStayAlignedResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.CompleteStayAlignedResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.StayAlignedHideCorrectionRequest: + _oMessageValue = message(new solarxr_protocol.rpc.StayAlignedHideCorrectionRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StayAlignedHideCorrectionRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.HIDSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.HIDSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HIDSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.HIDSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.HIDSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HIDSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeHIDSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeHIDSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeHIDSettingsRequest) _oMessageValue).unpack() : null); break; case solarxr_protocol.rpc.RpcMessage.RecordBVHRequest: _oMessageValue = message(new solarxr_protocol.rpc.RecordBVHRequest()); @@ -96,21 +188,21 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.RecordBVHStatus()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.RecordBVHStatus) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SkeletonConfigRequest: - _oMessageValue = message(new solarxr_protocol.rpc.SkeletonConfigRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonConfigRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.SkeletonProportionsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.SkeletonProportionsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonProportionsRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.ChangeSkeletonConfigRequest: - _oMessageValue = message(new solarxr_protocol.rpc.ChangeSkeletonConfigRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeSkeletonConfigRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.ChangeSkeletonProportionsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeSkeletonProportionsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeSkeletonProportionsRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SkeletonResetAllRequest: - _oMessageValue = message(new solarxr_protocol.rpc.SkeletonResetAllRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonResetAllRequest) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.SkeletonProportionsResetAllRequest: + _oMessageValue = message(new solarxr_protocol.rpc.SkeletonProportionsResetAllRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonProportionsResetAllRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SkeletonConfigResponse: - _oMessageValue = message(new solarxr_protocol.rpc.SkeletonConfigResponse()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonConfigResponse) _oMessageValue).unpack() : null); + case solarxr_protocol.rpc.RpcMessage.SkeletonProportionsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.SkeletonProportionsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SkeletonProportionsResponse) _oMessageValue).unpack() : null); break; case solarxr_protocol.rpc.RpcMessage.OpenSerialRequest: _oMessageValue = message(new solarxr_protocol.rpc.OpenSerialRequest()); @@ -120,10 +212,6 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.CloseSerialRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.CloseSerialRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.SetWifiRequest: - _oMessageValue = message(new solarxr_protocol.rpc.SetWifiRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SetWifiRequest) _oMessageValue).unpack() : null); - break; case solarxr_protocol.rpc.RpcMessage.SerialUpdateResponse: _oMessageValue = message(new solarxr_protocol.rpc.SerialUpdateResponse()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SerialUpdateResponse) _oMessageValue).unpack() : null); @@ -212,34 +300,10 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.SetPauseTrackingRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SetPauseTrackingRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.StatusSystemRequest: - _oMessageValue = message(new solarxr_protocol.rpc.StatusSystemRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StatusSystemRequest) _oMessageValue).unpack() : null); - break; - case solarxr_protocol.rpc.RpcMessage.StatusSystemResponse: - _oMessageValue = message(new solarxr_protocol.rpc.StatusSystemResponse()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StatusSystemResponse) _oMessageValue).unpack() : null); - break; - case solarxr_protocol.rpc.RpcMessage.StatusSystemUpdate: - _oMessageValue = message(new solarxr_protocol.rpc.StatusSystemUpdate()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StatusSystemUpdate) _oMessageValue).unpack() : null); - break; - case solarxr_protocol.rpc.RpcMessage.StatusSystemFixed: - _oMessageValue = message(new solarxr_protocol.rpc.StatusSystemFixed()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StatusSystemFixed) _oMessageValue).unpack() : null); - break; case solarxr_protocol.rpc.RpcMessage.ClearMountingResetRequest: _oMessageValue = message(new solarxr_protocol.rpc.ClearMountingResetRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ClearMountingResetRequest) _oMessageValue).unpack() : null); break; - case solarxr_protocol.rpc.RpcMessage.HeightRequest: - _oMessageValue = message(new solarxr_protocol.rpc.HeightRequest()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HeightRequest) _oMessageValue).unpack() : null); - break; - case solarxr_protocol.rpc.RpcMessage.HeightResponse: - _oMessageValue = message(new solarxr_protocol.rpc.HeightResponse()); - _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HeightResponse) _oMessageValue).unpack() : null); - break; case solarxr_protocol.rpc.RpcMessage.AutoBoneApplyRequest: _oMessageValue = message(new solarxr_protocol.rpc.AutoBoneApplyRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.AutoBoneApplyRequest) _oMessageValue).unpack() : null); @@ -364,6 +428,26 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.UserHeightRecordingStatusResponse()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UserHeightRecordingStatusResponse) _oMessageValue).unpack() : null); break; + case solarxr_protocol.rpc.RpcMessage.VRCOSCSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.VRCOSCSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRCOSCSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VRCOSCSettingsResponse: + _oMessageValue = message(new solarxr_protocol.rpc.VRCOSCSettingsResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRCOSCSettingsResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeVRCOSCSettingsRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeVRCOSCSettingsRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeVRCOSCSettingsRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VRCOSCStatusRequest: + _oMessageValue = message(new solarxr_protocol.rpc.VRCOSCStatusRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRCOSCStatusRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VRCOSCStatusChangeResponse: + _oMessageValue = message(new solarxr_protocol.rpc.VRCOSCStatusChangeResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRCOSCStatusChangeResponse) _oMessageValue).unpack() : null); + break; case solarxr_protocol.rpc.RpcMessage.KeybindRequest: _oMessageValue = message(new solarxr_protocol.rpc.KeybindRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.KeybindRequest) _oMessageValue).unpack() : null); diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java index 58617afbd..7971a4d01 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -26,19 +26,41 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.ResetRequestT asResetRequest() { return (solarxr_protocol.rpc.ResetRequestT) value; } public solarxr_protocol.rpc.ResetResponseT asResetResponse() { return (solarxr_protocol.rpc.ResetResponseT) value; } public solarxr_protocol.rpc.AssignTrackerRequestT asAssignTrackerRequest() { return (solarxr_protocol.rpc.AssignTrackerRequestT) value; } - public solarxr_protocol.rpc.SettingsRequestT asSettingsRequest() { return (solarxr_protocol.rpc.SettingsRequestT) value; } - public solarxr_protocol.rpc.SettingsResponseT asSettingsResponse() { return (solarxr_protocol.rpc.SettingsResponseT) value; } - public solarxr_protocol.rpc.ChangeSettingsRequestT asChangeSettingsRequest() { return (solarxr_protocol.rpc.ChangeSettingsRequestT) value; } - public solarxr_protocol.rpc.ClearDriftCompensationRequestT asClearDriftCompensationRequest() { return (solarxr_protocol.rpc.ClearDriftCompensationRequestT) value; } + public solarxr_protocol.rpc.OutputTrackersSettingsRequestT asOutputTrackersSettingsRequest() { return (solarxr_protocol.rpc.OutputTrackersSettingsRequestT) value; } + public solarxr_protocol.rpc.OutputTrackersSettingsResponseT asOutputTrackersSettingsResponse() { return (solarxr_protocol.rpc.OutputTrackersSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequestT asChangeOutputTrackersSettingsRequest() { return (solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequestT) value; } + public solarxr_protocol.rpc.VMCOSCSettingsRequestT asVMCOSCSettingsRequest() { return (solarxr_protocol.rpc.VMCOSCSettingsRequestT) value; } + public solarxr_protocol.rpc.VMCOSCSettingsResponseT asVMCOSCSettingsResponse() { return (solarxr_protocol.rpc.VMCOSCSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeVMCOSCSettingsRequestT asChangeVMCOSCSettingsRequest() { return (solarxr_protocol.rpc.ChangeVMCOSCSettingsRequestT) value; } + public solarxr_protocol.rpc.VRMSettingsRequestT asVRMSettingsRequest() { return (solarxr_protocol.rpc.VRMSettingsRequestT) value; } + public solarxr_protocol.rpc.VRMSettingsResponseT asVRMSettingsResponse() { return (solarxr_protocol.rpc.VRMSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeVRMSettingsRequestT asChangeVRMSettingsRequest() { return (solarxr_protocol.rpc.ChangeVRMSettingsRequestT) value; } + public solarxr_protocol.rpc.SkeletonSettingsRequestT asSkeletonSettingsRequest() { return (solarxr_protocol.rpc.SkeletonSettingsRequestT) value; } + public solarxr_protocol.rpc.SkeletonSettingsResponseT asSkeletonSettingsResponse() { return (solarxr_protocol.rpc.SkeletonSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeSkeletonSettingsRequestT asChangeSkeletonSettingsRequest() { return (solarxr_protocol.rpc.ChangeSkeletonSettingsRequestT) value; } + public solarxr_protocol.rpc.TapDetectionSettingsRequestT asTapDetectionSettingsRequest() { return (solarxr_protocol.rpc.TapDetectionSettingsRequestT) value; } + public solarxr_protocol.rpc.TapDetectionSettingsResponseT asTapDetectionSettingsResponse() { return (solarxr_protocol.rpc.TapDetectionSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeTapDetectionSettingsRequestT asChangeTapDetectionSettingsRequest() { return (solarxr_protocol.rpc.ChangeTapDetectionSettingsRequestT) value; } + public solarxr_protocol.rpc.TapDetectionSetupModeRequestT asTapDetectionSetupModeRequest() { return (solarxr_protocol.rpc.TapDetectionSetupModeRequestT) value; } + public solarxr_protocol.rpc.ResetsSettingsRequestT asResetsSettingsRequest() { return (solarxr_protocol.rpc.ResetsSettingsRequestT) value; } + public solarxr_protocol.rpc.ResetsSettingsResponseT asResetsSettingsResponse() { return (solarxr_protocol.rpc.ResetsSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeResetsSettingsRequestT asChangeResetsSettingsRequest() { return (solarxr_protocol.rpc.ChangeResetsSettingsRequestT) value; } + public solarxr_protocol.rpc.StayAlignedSettingsRequestT asStayAlignedSettingsRequest() { return (solarxr_protocol.rpc.StayAlignedSettingsRequestT) value; } + public solarxr_protocol.rpc.StayAlignedSettingsResponseT asStayAlignedSettingsResponse() { return (solarxr_protocol.rpc.StayAlignedSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeStayAlignedSettingsRequestT asChangeStayAlignedSettingsRequest() { return (solarxr_protocol.rpc.ChangeStayAlignedSettingsRequestT) value; } + public solarxr_protocol.rpc.CompleteStayAlignedResponseT asCompleteStayAlignedResponse() { return (solarxr_protocol.rpc.CompleteStayAlignedResponseT) value; } + public solarxr_protocol.rpc.StayAlignedHideCorrectionRequestT asStayAlignedHideCorrectionRequest() { return (solarxr_protocol.rpc.StayAlignedHideCorrectionRequestT) value; } + public solarxr_protocol.rpc.HIDSettingsRequestT asHIDSettingsRequest() { return (solarxr_protocol.rpc.HIDSettingsRequestT) value; } + public solarxr_protocol.rpc.HIDSettingsResponseT asHIDSettingsResponse() { return (solarxr_protocol.rpc.HIDSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeHIDSettingsRequestT asChangeHIDSettingsRequest() { return (solarxr_protocol.rpc.ChangeHIDSettingsRequestT) value; } public solarxr_protocol.rpc.RecordBVHRequestT asRecordBVHRequest() { return (solarxr_protocol.rpc.RecordBVHRequestT) value; } public solarxr_protocol.rpc.RecordBVHStatusT asRecordBVHStatus() { return (solarxr_protocol.rpc.RecordBVHStatusT) value; } - public solarxr_protocol.rpc.SkeletonConfigRequestT asSkeletonConfigRequest() { return (solarxr_protocol.rpc.SkeletonConfigRequestT) value; } - public solarxr_protocol.rpc.ChangeSkeletonConfigRequestT asChangeSkeletonConfigRequest() { return (solarxr_protocol.rpc.ChangeSkeletonConfigRequestT) value; } - public solarxr_protocol.rpc.SkeletonResetAllRequestT asSkeletonResetAllRequest() { return (solarxr_protocol.rpc.SkeletonResetAllRequestT) value; } - public solarxr_protocol.rpc.SkeletonConfigResponseT asSkeletonConfigResponse() { return (solarxr_protocol.rpc.SkeletonConfigResponseT) value; } + public solarxr_protocol.rpc.SkeletonProportionsRequestT asSkeletonProportionsRequest() { return (solarxr_protocol.rpc.SkeletonProportionsRequestT) value; } + public solarxr_protocol.rpc.ChangeSkeletonProportionsRequestT asChangeSkeletonProportionsRequest() { return (solarxr_protocol.rpc.ChangeSkeletonProportionsRequestT) value; } + public solarxr_protocol.rpc.SkeletonProportionsResetAllRequestT asSkeletonProportionsResetAllRequest() { return (solarxr_protocol.rpc.SkeletonProportionsResetAllRequestT) value; } + public solarxr_protocol.rpc.SkeletonProportionsResponseT asSkeletonProportionsResponse() { return (solarxr_protocol.rpc.SkeletonProportionsResponseT) value; } public solarxr_protocol.rpc.OpenSerialRequestT asOpenSerialRequest() { return (solarxr_protocol.rpc.OpenSerialRequestT) value; } public solarxr_protocol.rpc.CloseSerialRequestT asCloseSerialRequest() { return (solarxr_protocol.rpc.CloseSerialRequestT) value; } - public solarxr_protocol.rpc.SetWifiRequestT asSetWifiRequest() { return (solarxr_protocol.rpc.SetWifiRequestT) value; } public solarxr_protocol.rpc.SerialUpdateResponseT asSerialUpdateResponse() { return (solarxr_protocol.rpc.SerialUpdateResponseT) value; } public solarxr_protocol.rpc.AutoBoneProcessRequestT asAutoBoneProcessRequest() { return (solarxr_protocol.rpc.AutoBoneProcessRequestT) value; } public solarxr_protocol.rpc.AutoBoneProcessStatusResponseT asAutoBoneProcessStatusResponse() { return (solarxr_protocol.rpc.AutoBoneProcessStatusResponseT) value; } @@ -61,13 +83,7 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.LegTweaksTmpClearT asLegTweaksTmpClear() { return (solarxr_protocol.rpc.LegTweaksTmpClearT) value; } public solarxr_protocol.rpc.TapDetectionSetupNotificationT asTapDetectionSetupNotification() { return (solarxr_protocol.rpc.TapDetectionSetupNotificationT) value; } public solarxr_protocol.rpc.SetPauseTrackingRequestT asSetPauseTrackingRequest() { return (solarxr_protocol.rpc.SetPauseTrackingRequestT) value; } - public solarxr_protocol.rpc.StatusSystemRequestT asStatusSystemRequest() { return (solarxr_protocol.rpc.StatusSystemRequestT) value; } - public solarxr_protocol.rpc.StatusSystemResponseT asStatusSystemResponse() { return (solarxr_protocol.rpc.StatusSystemResponseT) value; } - public solarxr_protocol.rpc.StatusSystemUpdateT asStatusSystemUpdate() { return (solarxr_protocol.rpc.StatusSystemUpdateT) value; } - public solarxr_protocol.rpc.StatusSystemFixedT asStatusSystemFixed() { return (solarxr_protocol.rpc.StatusSystemFixedT) value; } public solarxr_protocol.rpc.ClearMountingResetRequestT asClearMountingResetRequest() { return (solarxr_protocol.rpc.ClearMountingResetRequestT) value; } - public solarxr_protocol.rpc.HeightRequestT asHeightRequest() { return (solarxr_protocol.rpc.HeightRequestT) value; } - public solarxr_protocol.rpc.HeightResponseT asHeightResponse() { return (solarxr_protocol.rpc.HeightResponseT) value; } public solarxr_protocol.rpc.AutoBoneApplyRequestT asAutoBoneApplyRequest() { return (solarxr_protocol.rpc.AutoBoneApplyRequestT) value; } public solarxr_protocol.rpc.AutoBoneStopRecordingRequestT asAutoBoneStopRecordingRequest() { return (solarxr_protocol.rpc.AutoBoneStopRecordingRequestT) value; } public solarxr_protocol.rpc.AutoBoneCancelRecordingRequestT asAutoBoneCancelRecordingRequest() { return (solarxr_protocol.rpc.AutoBoneCancelRecordingRequestT) value; } @@ -99,6 +115,11 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.StartUserHeightCalibrationT asStartUserHeightCalibration() { return (solarxr_protocol.rpc.StartUserHeightCalibrationT) value; } public solarxr_protocol.rpc.CancelUserHeightCalibrationT asCancelUserHeightCalibration() { return (solarxr_protocol.rpc.CancelUserHeightCalibrationT) value; } public solarxr_protocol.rpc.UserHeightRecordingStatusResponseT asUserHeightRecordingStatusResponse() { return (solarxr_protocol.rpc.UserHeightRecordingStatusResponseT) value; } + public solarxr_protocol.rpc.VRCOSCSettingsRequestT asVRCOSCSettingsRequest() { return (solarxr_protocol.rpc.VRCOSCSettingsRequestT) value; } + public solarxr_protocol.rpc.VRCOSCSettingsResponseT asVRCOSCSettingsResponse() { return (solarxr_protocol.rpc.VRCOSCSettingsResponseT) value; } + public solarxr_protocol.rpc.ChangeVRCOSCSettingsRequestT asChangeVRCOSCSettingsRequest() { return (solarxr_protocol.rpc.ChangeVRCOSCSettingsRequestT) value; } + public solarxr_protocol.rpc.VRCOSCStatusRequestT asVRCOSCStatusRequest() { return (solarxr_protocol.rpc.VRCOSCStatusRequestT) value; } + public solarxr_protocol.rpc.VRCOSCStatusChangeResponseT asVRCOSCStatusChangeResponse() { return (solarxr_protocol.rpc.VRCOSCStatusChangeResponseT) value; } public solarxr_protocol.rpc.KeybindRequestT asKeybindRequest() { return (solarxr_protocol.rpc.KeybindRequestT) value; } public solarxr_protocol.rpc.ChangeKeybindRequestT asChangeKeybindRequest() { return (solarxr_protocol.rpc.ChangeKeybindRequestT) value; } public solarxr_protocol.rpc.KeybindResponseT asKeybindResponse() { return (solarxr_protocol.rpc.KeybindResponseT) value; } @@ -115,19 +136,41 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.ResetRequest: return solarxr_protocol.rpc.ResetRequest.pack(builder, _o.asResetRequest()); case RpcMessage.ResetResponse: return solarxr_protocol.rpc.ResetResponse.pack(builder, _o.asResetResponse()); case RpcMessage.AssignTrackerRequest: return solarxr_protocol.rpc.AssignTrackerRequest.pack(builder, _o.asAssignTrackerRequest()); - case RpcMessage.SettingsRequest: return solarxr_protocol.rpc.SettingsRequest.pack(builder, _o.asSettingsRequest()); - case RpcMessage.SettingsResponse: return solarxr_protocol.rpc.SettingsResponse.pack(builder, _o.asSettingsResponse()); - case RpcMessage.ChangeSettingsRequest: return solarxr_protocol.rpc.ChangeSettingsRequest.pack(builder, _o.asChangeSettingsRequest()); - case RpcMessage.ClearDriftCompensationRequest: return solarxr_protocol.rpc.ClearDriftCompensationRequest.pack(builder, _o.asClearDriftCompensationRequest()); + case RpcMessage.OutputTrackersSettingsRequest: return solarxr_protocol.rpc.OutputTrackersSettingsRequest.pack(builder, _o.asOutputTrackersSettingsRequest()); + case RpcMessage.OutputTrackersSettingsResponse: return solarxr_protocol.rpc.OutputTrackersSettingsResponse.pack(builder, _o.asOutputTrackersSettingsResponse()); + case RpcMessage.ChangeOutputTrackersSettingsRequest: return solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequest.pack(builder, _o.asChangeOutputTrackersSettingsRequest()); + case RpcMessage.VMCOSCSettingsRequest: return solarxr_protocol.rpc.VMCOSCSettingsRequest.pack(builder, _o.asVMCOSCSettingsRequest()); + case RpcMessage.VMCOSCSettingsResponse: return solarxr_protocol.rpc.VMCOSCSettingsResponse.pack(builder, _o.asVMCOSCSettingsResponse()); + case RpcMessage.ChangeVMCOSCSettingsRequest: return solarxr_protocol.rpc.ChangeVMCOSCSettingsRequest.pack(builder, _o.asChangeVMCOSCSettingsRequest()); + case RpcMessage.VRMSettingsRequest: return solarxr_protocol.rpc.VRMSettingsRequest.pack(builder, _o.asVRMSettingsRequest()); + case RpcMessage.VRMSettingsResponse: return solarxr_protocol.rpc.VRMSettingsResponse.pack(builder, _o.asVRMSettingsResponse()); + case RpcMessage.ChangeVRMSettingsRequest: return solarxr_protocol.rpc.ChangeVRMSettingsRequest.pack(builder, _o.asChangeVRMSettingsRequest()); + case RpcMessage.SkeletonSettingsRequest: return solarxr_protocol.rpc.SkeletonSettingsRequest.pack(builder, _o.asSkeletonSettingsRequest()); + case RpcMessage.SkeletonSettingsResponse: return solarxr_protocol.rpc.SkeletonSettingsResponse.pack(builder, _o.asSkeletonSettingsResponse()); + case RpcMessage.ChangeSkeletonSettingsRequest: return solarxr_protocol.rpc.ChangeSkeletonSettingsRequest.pack(builder, _o.asChangeSkeletonSettingsRequest()); + case RpcMessage.TapDetectionSettingsRequest: return solarxr_protocol.rpc.TapDetectionSettingsRequest.pack(builder, _o.asTapDetectionSettingsRequest()); + case RpcMessage.TapDetectionSettingsResponse: return solarxr_protocol.rpc.TapDetectionSettingsResponse.pack(builder, _o.asTapDetectionSettingsResponse()); + case RpcMessage.ChangeTapDetectionSettingsRequest: return solarxr_protocol.rpc.ChangeTapDetectionSettingsRequest.pack(builder, _o.asChangeTapDetectionSettingsRequest()); + case RpcMessage.TapDetectionSetupModeRequest: return solarxr_protocol.rpc.TapDetectionSetupModeRequest.pack(builder, _o.asTapDetectionSetupModeRequest()); + case RpcMessage.ResetsSettingsRequest: return solarxr_protocol.rpc.ResetsSettingsRequest.pack(builder, _o.asResetsSettingsRequest()); + case RpcMessage.ResetsSettingsResponse: return solarxr_protocol.rpc.ResetsSettingsResponse.pack(builder, _o.asResetsSettingsResponse()); + case RpcMessage.ChangeResetsSettingsRequest: return solarxr_protocol.rpc.ChangeResetsSettingsRequest.pack(builder, _o.asChangeResetsSettingsRequest()); + case RpcMessage.StayAlignedSettingsRequest: return solarxr_protocol.rpc.StayAlignedSettingsRequest.pack(builder, _o.asStayAlignedSettingsRequest()); + case RpcMessage.StayAlignedSettingsResponse: return solarxr_protocol.rpc.StayAlignedSettingsResponse.pack(builder, _o.asStayAlignedSettingsResponse()); + case RpcMessage.ChangeStayAlignedSettingsRequest: return solarxr_protocol.rpc.ChangeStayAlignedSettingsRequest.pack(builder, _o.asChangeStayAlignedSettingsRequest()); + case RpcMessage.CompleteStayAlignedResponse: return solarxr_protocol.rpc.CompleteStayAlignedResponse.pack(builder, _o.asCompleteStayAlignedResponse()); + case RpcMessage.StayAlignedHideCorrectionRequest: return solarxr_protocol.rpc.StayAlignedHideCorrectionRequest.pack(builder, _o.asStayAlignedHideCorrectionRequest()); + case RpcMessage.HIDSettingsRequest: return solarxr_protocol.rpc.HIDSettingsRequest.pack(builder, _o.asHIDSettingsRequest()); + case RpcMessage.HIDSettingsResponse: return solarxr_protocol.rpc.HIDSettingsResponse.pack(builder, _o.asHIDSettingsResponse()); + case RpcMessage.ChangeHIDSettingsRequest: return solarxr_protocol.rpc.ChangeHIDSettingsRequest.pack(builder, _o.asChangeHIDSettingsRequest()); case RpcMessage.RecordBVHRequest: return solarxr_protocol.rpc.RecordBVHRequest.pack(builder, _o.asRecordBVHRequest()); case RpcMessage.RecordBVHStatus: return solarxr_protocol.rpc.RecordBVHStatus.pack(builder, _o.asRecordBVHStatus()); - case RpcMessage.SkeletonConfigRequest: return solarxr_protocol.rpc.SkeletonConfigRequest.pack(builder, _o.asSkeletonConfigRequest()); - case RpcMessage.ChangeSkeletonConfigRequest: return solarxr_protocol.rpc.ChangeSkeletonConfigRequest.pack(builder, _o.asChangeSkeletonConfigRequest()); - case RpcMessage.SkeletonResetAllRequest: return solarxr_protocol.rpc.SkeletonResetAllRequest.pack(builder, _o.asSkeletonResetAllRequest()); - case RpcMessage.SkeletonConfigResponse: return solarxr_protocol.rpc.SkeletonConfigResponse.pack(builder, _o.asSkeletonConfigResponse()); + case RpcMessage.SkeletonProportionsRequest: return solarxr_protocol.rpc.SkeletonProportionsRequest.pack(builder, _o.asSkeletonProportionsRequest()); + case RpcMessage.ChangeSkeletonProportionsRequest: return solarxr_protocol.rpc.ChangeSkeletonProportionsRequest.pack(builder, _o.asChangeSkeletonProportionsRequest()); + case RpcMessage.SkeletonProportionsResetAllRequest: return solarxr_protocol.rpc.SkeletonProportionsResetAllRequest.pack(builder, _o.asSkeletonProportionsResetAllRequest()); + case RpcMessage.SkeletonProportionsResponse: return solarxr_protocol.rpc.SkeletonProportionsResponse.pack(builder, _o.asSkeletonProportionsResponse()); case RpcMessage.OpenSerialRequest: return solarxr_protocol.rpc.OpenSerialRequest.pack(builder, _o.asOpenSerialRequest()); case RpcMessage.CloseSerialRequest: return solarxr_protocol.rpc.CloseSerialRequest.pack(builder, _o.asCloseSerialRequest()); - case RpcMessage.SetWifiRequest: return solarxr_protocol.rpc.SetWifiRequest.pack(builder, _o.asSetWifiRequest()); case RpcMessage.SerialUpdateResponse: return solarxr_protocol.rpc.SerialUpdateResponse.pack(builder, _o.asSerialUpdateResponse()); case RpcMessage.AutoBoneProcessRequest: return solarxr_protocol.rpc.AutoBoneProcessRequest.pack(builder, _o.asAutoBoneProcessRequest()); case RpcMessage.AutoBoneProcessStatusResponse: return solarxr_protocol.rpc.AutoBoneProcessStatusResponse.pack(builder, _o.asAutoBoneProcessStatusResponse()); @@ -150,13 +193,7 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.LegTweaksTmpClear: return solarxr_protocol.rpc.LegTweaksTmpClear.pack(builder, _o.asLegTweaksTmpClear()); case RpcMessage.TapDetectionSetupNotification: return solarxr_protocol.rpc.TapDetectionSetupNotification.pack(builder, _o.asTapDetectionSetupNotification()); case RpcMessage.SetPauseTrackingRequest: return solarxr_protocol.rpc.SetPauseTrackingRequest.pack(builder, _o.asSetPauseTrackingRequest()); - case RpcMessage.StatusSystemRequest: return solarxr_protocol.rpc.StatusSystemRequest.pack(builder, _o.asStatusSystemRequest()); - case RpcMessage.StatusSystemResponse: return solarxr_protocol.rpc.StatusSystemResponse.pack(builder, _o.asStatusSystemResponse()); - case RpcMessage.StatusSystemUpdate: return solarxr_protocol.rpc.StatusSystemUpdate.pack(builder, _o.asStatusSystemUpdate()); - case RpcMessage.StatusSystemFixed: return solarxr_protocol.rpc.StatusSystemFixed.pack(builder, _o.asStatusSystemFixed()); case RpcMessage.ClearMountingResetRequest: return solarxr_protocol.rpc.ClearMountingResetRequest.pack(builder, _o.asClearMountingResetRequest()); - case RpcMessage.HeightRequest: return solarxr_protocol.rpc.HeightRequest.pack(builder, _o.asHeightRequest()); - case RpcMessage.HeightResponse: return solarxr_protocol.rpc.HeightResponse.pack(builder, _o.asHeightResponse()); case RpcMessage.AutoBoneApplyRequest: return solarxr_protocol.rpc.AutoBoneApplyRequest.pack(builder, _o.asAutoBoneApplyRequest()); case RpcMessage.AutoBoneStopRecordingRequest: return solarxr_protocol.rpc.AutoBoneStopRecordingRequest.pack(builder, _o.asAutoBoneStopRecordingRequest()); case RpcMessage.AutoBoneCancelRecordingRequest: return solarxr_protocol.rpc.AutoBoneCancelRecordingRequest.pack(builder, _o.asAutoBoneCancelRecordingRequest()); @@ -188,6 +225,11 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.StartUserHeightCalibration: return solarxr_protocol.rpc.StartUserHeightCalibration.pack(builder, _o.asStartUserHeightCalibration()); case RpcMessage.CancelUserHeightCalibration: return solarxr_protocol.rpc.CancelUserHeightCalibration.pack(builder, _o.asCancelUserHeightCalibration()); case RpcMessage.UserHeightRecordingStatusResponse: return solarxr_protocol.rpc.UserHeightRecordingStatusResponse.pack(builder, _o.asUserHeightRecordingStatusResponse()); + case RpcMessage.VRCOSCSettingsRequest: return solarxr_protocol.rpc.VRCOSCSettingsRequest.pack(builder, _o.asVRCOSCSettingsRequest()); + case RpcMessage.VRCOSCSettingsResponse: return solarxr_protocol.rpc.VRCOSCSettingsResponse.pack(builder, _o.asVRCOSCSettingsResponse()); + case RpcMessage.ChangeVRCOSCSettingsRequest: return solarxr_protocol.rpc.ChangeVRCOSCSettingsRequest.pack(builder, _o.asChangeVRCOSCSettingsRequest()); + case RpcMessage.VRCOSCStatusRequest: return solarxr_protocol.rpc.VRCOSCStatusRequest.pack(builder, _o.asVRCOSCStatusRequest()); + case RpcMessage.VRCOSCStatusChangeResponse: return solarxr_protocol.rpc.VRCOSCStatusChangeResponse.pack(builder, _o.asVRCOSCStatusChangeResponse()); case RpcMessage.KeybindRequest: return solarxr_protocol.rpc.KeybindRequest.pack(builder, _o.asKeybindRequest()); case RpcMessage.ChangeKeybindRequest: return solarxr_protocol.rpc.ChangeKeybindRequest.pack(builder, _o.asChangeKeybindRequest()); case RpcMessage.KeybindResponse: return solarxr_protocol.rpc.KeybindResponse.pack(builder, _o.asKeybindResponse()); diff --git a/protocol/java/src/solarxr_protocol/rpc/SaveFileNotification.java b/protocol/java/src/solarxr_protocol/rpc/SaveFileNotification.java index 09806c28d..a40be3b51 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SaveFileNotification.java +++ b/protocol/java/src/solarxr_protocol/rpc/SaveFileNotification.java @@ -28,7 +28,7 @@ public final class SaveFileNotification extends Table { public ByteBuffer dataAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } public ByteBuffer dataInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } /** - * MIME type of file if one exists, use `file_extension` otherwise + * MIME type of file if one exists, use `extension` otherwise */ public String mimeType() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } public ByteBuffer mimeTypeAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } @@ -36,9 +36,9 @@ public final class SaveFileNotification extends Table { /** * Use MIME type preferably if one exists */ - public String fileExtension() { int o = __offset(8); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer fileExtensionAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } - public ByteBuffer fileExtensionInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } + public String extension() { int o = __offset(8); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer extensionAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } + public ByteBuffer extensionInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } /** * Directory recommended to save the file on */ @@ -54,12 +54,12 @@ public final class SaveFileNotification extends Table { public static int createSaveFileNotification(FlatBufferBuilder builder, int dataOffset, int mimeTypeOffset, - int fileExtensionOffset, + int extensionOffset, int expectedDir, int expectedFilenameOffset) { builder.startTable(5); SaveFileNotification.addExpectedFilename(builder, expectedFilenameOffset); - SaveFileNotification.addFileExtension(builder, fileExtensionOffset); + SaveFileNotification.addExtension(builder, extensionOffset); SaveFileNotification.addMimeType(builder, mimeTypeOffset); SaveFileNotification.addData(builder, dataOffset); SaveFileNotification.addExpectedDir(builder, expectedDir); @@ -72,7 +72,7 @@ public static int createSaveFileNotification(FlatBufferBuilder builder, public static int createDataVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } public static void startDataVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } public static void addMimeType(FlatBufferBuilder builder, int mimeTypeOffset) { builder.addOffset(1, mimeTypeOffset, 0); } - public static void addFileExtension(FlatBufferBuilder builder, int fileExtensionOffset) { builder.addOffset(2, fileExtensionOffset, 0); } + public static void addExtension(FlatBufferBuilder builder, int extensionOffset) { builder.addOffset(2, extensionOffset, 0); } public static void addExpectedDir(FlatBufferBuilder builder, int expectedDir) { builder.addByte(3, (byte) expectedDir, (byte) 0); } public static void addExpectedFilename(FlatBufferBuilder builder, int expectedFilenameOffset) { builder.addOffset(4, expectedFilenameOffset, 0); } public static int endSaveFileNotification(FlatBufferBuilder builder) { @@ -97,8 +97,8 @@ public void unpackTo(SaveFileNotificationT _o) { _o.setData(_oData); String _oMimeType = mimeType(); _o.setMimeType(_oMimeType); - String _oFileExtension = fileExtension(); - _o.setFileExtension(_oFileExtension); + String _oExtension = extension(); + _o.setExtension(_oExtension); Integer _oExpectedDir = hasExpectedDir() ? expectedDir() : null; _o.setExpectedDir(_oExpectedDir); String _oExpectedFilename = expectedFilename(); @@ -114,13 +114,13 @@ public static int pack(FlatBufferBuilder builder, SaveFileNotificationT _o) { _data = createDataVector(builder, __data); } int _mimeType = _o.getMimeType() == null ? 0 : builder.createString(_o.getMimeType()); - int _fileExtension = _o.getFileExtension() == null ? 0 : builder.createString(_o.getFileExtension()); + int _extension = _o.getExtension() == null ? 0 : builder.createString(_o.getExtension()); int _expectedFilename = _o.getExpectedFilename() == null ? 0 : builder.createString(_o.getExpectedFilename()); return createSaveFileNotification( builder, _data, _mimeType, - _fileExtension, + _extension, _o.getExpectedDir(), _expectedFilename); } diff --git a/protocol/java/src/solarxr_protocol/rpc/SaveFileNotificationT.java b/protocol/java/src/solarxr_protocol/rpc/SaveFileNotificationT.java index a517e5441..4bb82d94b 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SaveFileNotificationT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SaveFileNotificationT.java @@ -10,7 +10,7 @@ public class SaveFileNotificationT { private int[] data; private String mimeType; - private String fileExtension; + private String extension; private Integer expectedDir; private String expectedFilename; @@ -22,9 +22,9 @@ public class SaveFileNotificationT { public void setMimeType(String mimeType) { this.mimeType = mimeType; } - public String getFileExtension() { return fileExtension; } + public String getExtension() { return extension; } - public void setFileExtension(String fileExtension) { this.fileExtension = fileExtension; } + public void setExtension(String extension) { this.extension = extension; } public Integer getExpectedDir() { return expectedDir; } @@ -38,7 +38,7 @@ public class SaveFileNotificationT { public SaveFileNotificationT() { this.data = null; this.mimeType = null; - this.fileExtension = null; + this.extension = null; this.expectedDir = null; this.expectedFilename = null; } diff --git a/protocol/java/src/solarxr_protocol/rpc/SetWifiRequest.java b/protocol/java/src/solarxr_protocol/rpc/SetWifiRequest.java deleted file mode 100644 index 012c38121..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SetWifiRequest.java +++ /dev/null @@ -1,69 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SetWifiRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SetWifiRequest getRootAsSetWifiRequest(ByteBuffer _bb) { return getRootAsSetWifiRequest(_bb, new SetWifiRequest()); } - public static SetWifiRequest getRootAsSetWifiRequest(ByteBuffer _bb, SetWifiRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SetWifiRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public String ssid() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer ssidAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer ssidInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - public String password() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer passwordAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } - public ByteBuffer passwordInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } - - public static int createSetWifiRequest(FlatBufferBuilder builder, - int ssidOffset, - int passwordOffset) { - builder.startTable(2); - SetWifiRequest.addPassword(builder, passwordOffset); - SetWifiRequest.addSsid(builder, ssidOffset); - return SetWifiRequest.endSetWifiRequest(builder); - } - - public static void startSetWifiRequest(FlatBufferBuilder builder) { builder.startTable(2); } - public static void addSsid(FlatBufferBuilder builder, int ssidOffset) { builder.addOffset(0, ssidOffset, 0); } - public static void addPassword(FlatBufferBuilder builder, int passwordOffset) { builder.addOffset(1, passwordOffset, 0); } - public static int endSetWifiRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SetWifiRequest get(int j) { return get(new SetWifiRequest(), j); } - public SetWifiRequest get(SetWifiRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SetWifiRequestT unpack() { - SetWifiRequestT _o = new SetWifiRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SetWifiRequestT _o) { - String _oSsid = ssid(); - _o.setSsid(_oSsid); - String _oPassword = password(); - _o.setPassword(_oPassword); - } - public static int pack(FlatBufferBuilder builder, SetWifiRequestT _o) { - if (_o == null) return 0; - int _ssid = _o.getSsid() == null ? 0 : builder.createString(_o.getSsid()); - int _password = _o.getPassword() == null ? 0 : builder.createString(_o.getPassword()); - return createSetWifiRequest( - builder, - _ssid, - _password); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SetWifiRequestT.java b/protocol/java/src/solarxr_protocol/rpc/SetWifiRequestT.java deleted file mode 100644 index 31ea985af..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SetWifiRequestT.java +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class SetWifiRequestT { - private String ssid; - private String password; - - public String getSsid() { return ssid; } - - public void setSsid(String ssid) { this.ssid = ssid; } - - public String getPassword() { return password; } - - public void setPassword(String password) { this.password = password; } - - - public SetWifiRequestT() { - this.ssid = null; - this.password = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/SettingsRequest.java deleted file mode 100644 index 123871cac..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SettingsRequest.java +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SettingsRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SettingsRequest getRootAsSettingsRequest(ByteBuffer _bb) { return getRootAsSettingsRequest(_bb, new SettingsRequest()); } - public static SettingsRequest getRootAsSettingsRequest(ByteBuffer _bb, SettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endSettingsRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SettingsRequest get(int j) { return get(new SettingsRequest(), j); } - public SettingsRequest get(SettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SettingsRequestT unpack() { - SettingsRequestT _o = new SettingsRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SettingsRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, SettingsRequestT _o) { - if (_o == null) return 0; - startSettingsRequest(builder); - return endSettingsRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SettingsResetRequest.java b/protocol/java/src/solarxr_protocol/rpc/SettingsResetRequest.java index da31195a3..f682420a3 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SettingsResetRequest.java +++ b/protocol/java/src/solarxr_protocol/rpc/SettingsResetRequest.java @@ -7,6 +7,9 @@ import java.util.*; import com.google.flatbuffers.*; +/** + * Resets the server settings + */ @SuppressWarnings("unused") public final class SettingsResetRequest extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } diff --git a/protocol/java/src/solarxr_protocol/rpc/SettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/SettingsResponse.java deleted file mode 100644 index 5b714f07c..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SettingsResponse.java +++ /dev/null @@ -1,184 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SettingsResponse extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SettingsResponse getRootAsSettingsResponse(ByteBuffer _bb) { return getRootAsSettingsResponse(_bb, new SettingsResponse()); } - public static SettingsResponse getRootAsSettingsResponse(ByteBuffer _bb, SettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.SteamVRTrackersSetting steamVrTrackers() { return steamVrTrackers(new solarxr_protocol.rpc.SteamVRTrackersSetting()); } - public solarxr_protocol.rpc.SteamVRTrackersSetting steamVrTrackers(solarxr_protocol.rpc.SteamVRTrackersSetting obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.FilteringSettings filtering() { return filtering(new solarxr_protocol.rpc.FilteringSettings()); } - public solarxr_protocol.rpc.FilteringSettings filtering(solarxr_protocol.rpc.FilteringSettings obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.DriftCompensationSettings driftCompensation() { return driftCompensation(new solarxr_protocol.rpc.DriftCompensationSettings()); } - public solarxr_protocol.rpc.DriftCompensationSettings driftCompensation(solarxr_protocol.rpc.DriftCompensationSettings obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.OSCRouterSettings oscRouter() { return oscRouter(new solarxr_protocol.rpc.OSCRouterSettings()); } - public solarxr_protocol.rpc.OSCRouterSettings oscRouter(solarxr_protocol.rpc.OSCRouterSettings obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VRCOSCSettings vrcOsc() { return vrcOsc(new solarxr_protocol.rpc.VRCOSCSettings()); } - public solarxr_protocol.rpc.VRCOSCSettings vrcOsc(solarxr_protocol.rpc.VRCOSCSettings obj) { int o = __offset(12); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VMCOSCSettings vmcOsc() { return vmcOsc(new solarxr_protocol.rpc.VMCOSCSettings()); } - public solarxr_protocol.rpc.VMCOSCSettings vmcOsc(solarxr_protocol.rpc.VMCOSCSettings obj) { int o = __offset(14); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.settings.ModelSettings modelSettings() { return modelSettings(new solarxr_protocol.rpc.settings.ModelSettings()); } - public solarxr_protocol.rpc.settings.ModelSettings modelSettings(solarxr_protocol.rpc.settings.ModelSettings obj) { int o = __offset(16); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.TapDetectionSettings tapDetectionSettings() { return tapDetectionSettings(new solarxr_protocol.rpc.TapDetectionSettings()); } - public solarxr_protocol.rpc.TapDetectionSettings tapDetectionSettings(solarxr_protocol.rpc.TapDetectionSettings obj) { int o = __offset(18); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.AutoBoneSettings autoBoneSettings() { return autoBoneSettings(new solarxr_protocol.rpc.AutoBoneSettings()); } - public solarxr_protocol.rpc.AutoBoneSettings autoBoneSettings(solarxr_protocol.rpc.AutoBoneSettings obj) { int o = __offset(20); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.ResetsSettings resetsSettings() { return resetsSettings(new solarxr_protocol.rpc.ResetsSettings()); } - public solarxr_protocol.rpc.ResetsSettings resetsSettings(solarxr_protocol.rpc.ResetsSettings obj) { int o = __offset(22); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.StayAlignedSettings stayAligned() { return stayAligned(new solarxr_protocol.rpc.StayAlignedSettings()); } - public solarxr_protocol.rpc.StayAlignedSettings stayAligned(solarxr_protocol.rpc.StayAlignedSettings obj) { int o = __offset(24); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.HIDSettings hidSettings() { return hidSettings(new solarxr_protocol.rpc.HIDSettings()); } - public solarxr_protocol.rpc.HIDSettings hidSettings(solarxr_protocol.rpc.HIDSettings obj) { int o = __offset(26); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.TimeoutSettings timeout() { return timeout(new solarxr_protocol.rpc.TimeoutSettings()); } - public solarxr_protocol.rpc.TimeoutSettings timeout(solarxr_protocol.rpc.TimeoutSettings obj) { int o = __offset(28); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VelocitySettings velocitySettings() { return velocitySettings(new solarxr_protocol.rpc.VelocitySettings()); } - public solarxr_protocol.rpc.VelocitySettings velocitySettings(solarxr_protocol.rpc.VelocitySettings obj) { int o = __offset(30); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.VRMSettings vrm() { return vrm(new solarxr_protocol.rpc.VRMSettings()); } - public solarxr_protocol.rpc.VRMSettings vrm(solarxr_protocol.rpc.VRMSettings obj) { int o = __offset(32); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createSettingsResponse(FlatBufferBuilder builder, - int steamVrTrackersOffset, - int filteringOffset, - int driftCompensationOffset, - int oscRouterOffset, - int vrcOscOffset, - int vmcOscOffset, - int modelSettingsOffset, - int tapDetectionSettingsOffset, - int autoBoneSettingsOffset, - int resetsSettingsOffset, - int stayAlignedOffset, - int hidSettingsOffset, - int timeoutOffset, - int velocitySettingsOffset, - int vrmOffset) { - builder.startTable(15); - SettingsResponse.addVrm(builder, vrmOffset); - SettingsResponse.addVelocitySettings(builder, velocitySettingsOffset); - SettingsResponse.addTimeout(builder, timeoutOffset); - SettingsResponse.addHidSettings(builder, hidSettingsOffset); - SettingsResponse.addStayAligned(builder, stayAlignedOffset); - SettingsResponse.addResetsSettings(builder, resetsSettingsOffset); - SettingsResponse.addAutoBoneSettings(builder, autoBoneSettingsOffset); - SettingsResponse.addTapDetectionSettings(builder, tapDetectionSettingsOffset); - SettingsResponse.addModelSettings(builder, modelSettingsOffset); - SettingsResponse.addVmcOsc(builder, vmcOscOffset); - SettingsResponse.addVrcOsc(builder, vrcOscOffset); - SettingsResponse.addOscRouter(builder, oscRouterOffset); - SettingsResponse.addDriftCompensation(builder, driftCompensationOffset); - SettingsResponse.addFiltering(builder, filteringOffset); - SettingsResponse.addSteamVrTrackers(builder, steamVrTrackersOffset); - return SettingsResponse.endSettingsResponse(builder); - } - - public static void startSettingsResponse(FlatBufferBuilder builder) { builder.startTable(15); } - public static void addSteamVrTrackers(FlatBufferBuilder builder, int steamVrTrackersOffset) { builder.addOffset(0, steamVrTrackersOffset, 0); } - public static void addFiltering(FlatBufferBuilder builder, int filteringOffset) { builder.addOffset(1, filteringOffset, 0); } - public static void addDriftCompensation(FlatBufferBuilder builder, int driftCompensationOffset) { builder.addOffset(2, driftCompensationOffset, 0); } - public static void addOscRouter(FlatBufferBuilder builder, int oscRouterOffset) { builder.addOffset(3, oscRouterOffset, 0); } - public static void addVrcOsc(FlatBufferBuilder builder, int vrcOscOffset) { builder.addOffset(4, vrcOscOffset, 0); } - public static void addVmcOsc(FlatBufferBuilder builder, int vmcOscOffset) { builder.addOffset(5, vmcOscOffset, 0); } - public static void addModelSettings(FlatBufferBuilder builder, int modelSettingsOffset) { builder.addOffset(6, modelSettingsOffset, 0); } - public static void addTapDetectionSettings(FlatBufferBuilder builder, int tapDetectionSettingsOffset) { builder.addOffset(7, tapDetectionSettingsOffset, 0); } - public static void addAutoBoneSettings(FlatBufferBuilder builder, int autoBoneSettingsOffset) { builder.addOffset(8, autoBoneSettingsOffset, 0); } - public static void addResetsSettings(FlatBufferBuilder builder, int resetsSettingsOffset) { builder.addOffset(9, resetsSettingsOffset, 0); } - public static void addStayAligned(FlatBufferBuilder builder, int stayAlignedOffset) { builder.addOffset(10, stayAlignedOffset, 0); } - public static void addHidSettings(FlatBufferBuilder builder, int hidSettingsOffset) { builder.addOffset(11, hidSettingsOffset, 0); } - public static void addTimeout(FlatBufferBuilder builder, int timeoutOffset) { builder.addOffset(12, timeoutOffset, 0); } - public static void addVelocitySettings(FlatBufferBuilder builder, int velocitySettingsOffset) { builder.addOffset(13, velocitySettingsOffset, 0); } - public static void addVrm(FlatBufferBuilder builder, int vrmOffset) { builder.addOffset(14, vrmOffset, 0); } - public static int endSettingsResponse(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SettingsResponse get(int j) { return get(new SettingsResponse(), j); } - public SettingsResponse get(SettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SettingsResponseT unpack() { - SettingsResponseT _o = new SettingsResponseT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SettingsResponseT _o) { - if (steamVrTrackers() != null) _o.setSteamVrTrackers(steamVrTrackers().unpack()); - else _o.setSteamVrTrackers(null); - if (filtering() != null) _o.setFiltering(filtering().unpack()); - else _o.setFiltering(null); - if (driftCompensation() != null) _o.setDriftCompensation(driftCompensation().unpack()); - else _o.setDriftCompensation(null); - if (oscRouter() != null) _o.setOscRouter(oscRouter().unpack()); - else _o.setOscRouter(null); - if (vrcOsc() != null) _o.setVrcOsc(vrcOsc().unpack()); - else _o.setVrcOsc(null); - if (vmcOsc() != null) _o.setVmcOsc(vmcOsc().unpack()); - else _o.setVmcOsc(null); - if (modelSettings() != null) _o.setModelSettings(modelSettings().unpack()); - else _o.setModelSettings(null); - if (tapDetectionSettings() != null) _o.setTapDetectionSettings(tapDetectionSettings().unpack()); - else _o.setTapDetectionSettings(null); - if (autoBoneSettings() != null) _o.setAutoBoneSettings(autoBoneSettings().unpack()); - else _o.setAutoBoneSettings(null); - if (resetsSettings() != null) _o.setResetsSettings(resetsSettings().unpack()); - else _o.setResetsSettings(null); - if (stayAligned() != null) _o.setStayAligned(stayAligned().unpack()); - else _o.setStayAligned(null); - if (hidSettings() != null) _o.setHidSettings(hidSettings().unpack()); - else _o.setHidSettings(null); - if (timeout() != null) _o.setTimeout(timeout().unpack()); - else _o.setTimeout(null); - if (velocitySettings() != null) _o.setVelocitySettings(velocitySettings().unpack()); - else _o.setVelocitySettings(null); - if (vrm() != null) _o.setVrm(vrm().unpack()); - else _o.setVrm(null); - } - public static int pack(FlatBufferBuilder builder, SettingsResponseT _o) { - if (_o == null) return 0; - int _steamVrTrackers = _o.getSteamVrTrackers() == null ? 0 : solarxr_protocol.rpc.SteamVRTrackersSetting.pack(builder, _o.getSteamVrTrackers()); - int _filtering = _o.getFiltering() == null ? 0 : solarxr_protocol.rpc.FilteringSettings.pack(builder, _o.getFiltering()); - int _driftCompensation = _o.getDriftCompensation() == null ? 0 : solarxr_protocol.rpc.DriftCompensationSettings.pack(builder, _o.getDriftCompensation()); - int _oscRouter = _o.getOscRouter() == null ? 0 : solarxr_protocol.rpc.OSCRouterSettings.pack(builder, _o.getOscRouter()); - int _vrcOsc = _o.getVrcOsc() == null ? 0 : solarxr_protocol.rpc.VRCOSCSettings.pack(builder, _o.getVrcOsc()); - int _vmcOsc = _o.getVmcOsc() == null ? 0 : solarxr_protocol.rpc.VMCOSCSettings.pack(builder, _o.getVmcOsc()); - int _modelSettings = _o.getModelSettings() == null ? 0 : solarxr_protocol.rpc.settings.ModelSettings.pack(builder, _o.getModelSettings()); - int _tapDetectionSettings = _o.getTapDetectionSettings() == null ? 0 : solarxr_protocol.rpc.TapDetectionSettings.pack(builder, _o.getTapDetectionSettings()); - int _autoBoneSettings = _o.getAutoBoneSettings() == null ? 0 : solarxr_protocol.rpc.AutoBoneSettings.pack(builder, _o.getAutoBoneSettings()); - int _resetsSettings = _o.getResetsSettings() == null ? 0 : solarxr_protocol.rpc.ResetsSettings.pack(builder, _o.getResetsSettings()); - int _stayAligned = _o.getStayAligned() == null ? 0 : solarxr_protocol.rpc.StayAlignedSettings.pack(builder, _o.getStayAligned()); - int _hidSettings = _o.getHidSettings() == null ? 0 : solarxr_protocol.rpc.HIDSettings.pack(builder, _o.getHidSettings()); - int _timeout = _o.getTimeout() == null ? 0 : solarxr_protocol.rpc.TimeoutSettings.pack(builder, _o.getTimeout()); - int _velocitySettings = _o.getVelocitySettings() == null ? 0 : solarxr_protocol.rpc.VelocitySettings.pack(builder, _o.getVelocitySettings()); - int _vrm = _o.getVrm() == null ? 0 : solarxr_protocol.rpc.VRMSettings.pack(builder, _o.getVrm()); - return createSettingsResponse( - builder, - _steamVrTrackers, - _filtering, - _driftCompensation, - _oscRouter, - _vrcOsc, - _vmcOsc, - _modelSettings, - _tapDetectionSettings, - _autoBoneSettings, - _resetsSettings, - _stayAligned, - _hidSettings, - _timeout, - _velocitySettings, - _vrm); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/SettingsResponseT.java deleted file mode 100644 index c6af2f0ca..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SettingsResponseT.java +++ /dev/null @@ -1,106 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class SettingsResponseT { - private solarxr_protocol.rpc.SteamVRTrackersSettingT steamVrTrackers; - private solarxr_protocol.rpc.FilteringSettingsT filtering; - private solarxr_protocol.rpc.DriftCompensationSettingsT driftCompensation; - private solarxr_protocol.rpc.OSCRouterSettingsT oscRouter; - private solarxr_protocol.rpc.VRCOSCSettingsT vrcOsc; - private solarxr_protocol.rpc.VMCOSCSettingsT vmcOsc; - private solarxr_protocol.rpc.settings.ModelSettingsT modelSettings; - private solarxr_protocol.rpc.TapDetectionSettingsT tapDetectionSettings; - private solarxr_protocol.rpc.AutoBoneSettingsT autoBoneSettings; - private solarxr_protocol.rpc.ResetsSettingsT resetsSettings; - private solarxr_protocol.rpc.StayAlignedSettingsT stayAligned; - private solarxr_protocol.rpc.HIDSettingsT hidSettings; - private solarxr_protocol.rpc.TimeoutSettingsT timeout; - private solarxr_protocol.rpc.VelocitySettingsT velocitySettings; - private solarxr_protocol.rpc.VRMSettingsT vrm; - - public solarxr_protocol.rpc.SteamVRTrackersSettingT getSteamVrTrackers() { return steamVrTrackers; } - - public void setSteamVrTrackers(solarxr_protocol.rpc.SteamVRTrackersSettingT steamVrTrackers) { this.steamVrTrackers = steamVrTrackers; } - - public solarxr_protocol.rpc.FilteringSettingsT getFiltering() { return filtering; } - - public void setFiltering(solarxr_protocol.rpc.FilteringSettingsT filtering) { this.filtering = filtering; } - - public solarxr_protocol.rpc.DriftCompensationSettingsT getDriftCompensation() { return driftCompensation; } - - public void setDriftCompensation(solarxr_protocol.rpc.DriftCompensationSettingsT driftCompensation) { this.driftCompensation = driftCompensation; } - - public solarxr_protocol.rpc.OSCRouterSettingsT getOscRouter() { return oscRouter; } - - public void setOscRouter(solarxr_protocol.rpc.OSCRouterSettingsT oscRouter) { this.oscRouter = oscRouter; } - - public solarxr_protocol.rpc.VRCOSCSettingsT getVrcOsc() { return vrcOsc; } - - public void setVrcOsc(solarxr_protocol.rpc.VRCOSCSettingsT vrcOsc) { this.vrcOsc = vrcOsc; } - - public solarxr_protocol.rpc.VMCOSCSettingsT getVmcOsc() { return vmcOsc; } - - public void setVmcOsc(solarxr_protocol.rpc.VMCOSCSettingsT vmcOsc) { this.vmcOsc = vmcOsc; } - - public solarxr_protocol.rpc.settings.ModelSettingsT getModelSettings() { return modelSettings; } - - public void setModelSettings(solarxr_protocol.rpc.settings.ModelSettingsT modelSettings) { this.modelSettings = modelSettings; } - - public solarxr_protocol.rpc.TapDetectionSettingsT getTapDetectionSettings() { return tapDetectionSettings; } - - public void setTapDetectionSettings(solarxr_protocol.rpc.TapDetectionSettingsT tapDetectionSettings) { this.tapDetectionSettings = tapDetectionSettings; } - - public solarxr_protocol.rpc.AutoBoneSettingsT getAutoBoneSettings() { return autoBoneSettings; } - - public void setAutoBoneSettings(solarxr_protocol.rpc.AutoBoneSettingsT autoBoneSettings) { this.autoBoneSettings = autoBoneSettings; } - - public solarxr_protocol.rpc.ResetsSettingsT getResetsSettings() { return resetsSettings; } - - public void setResetsSettings(solarxr_protocol.rpc.ResetsSettingsT resetsSettings) { this.resetsSettings = resetsSettings; } - - public solarxr_protocol.rpc.StayAlignedSettingsT getStayAligned() { return stayAligned; } - - public void setStayAligned(solarxr_protocol.rpc.StayAlignedSettingsT stayAligned) { this.stayAligned = stayAligned; } - - public solarxr_protocol.rpc.HIDSettingsT getHidSettings() { return hidSettings; } - - public void setHidSettings(solarxr_protocol.rpc.HIDSettingsT hidSettings) { this.hidSettings = hidSettings; } - - public solarxr_protocol.rpc.TimeoutSettingsT getTimeout() { return timeout; } - - public void setTimeout(solarxr_protocol.rpc.TimeoutSettingsT timeout) { this.timeout = timeout; } - - public solarxr_protocol.rpc.VelocitySettingsT getVelocitySettings() { return velocitySettings; } - - public void setVelocitySettings(solarxr_protocol.rpc.VelocitySettingsT velocitySettings) { this.velocitySettings = velocitySettings; } - - public solarxr_protocol.rpc.VRMSettingsT getVrm() { return vrm; } - - public void setVrm(solarxr_protocol.rpc.VRMSettingsT vrm) { this.vrm = vrm; } - - - public SettingsResponseT() { - this.steamVrTrackers = null; - this.filtering = null; - this.driftCompensation = null; - this.oscRouter = null; - this.vrcOsc = null; - this.vmcOsc = null; - this.modelSettings = null; - this.tapDetectionSettings = null; - this.autoBoneSettings = null; - this.resetsSettings = null; - this.stayAligned = null; - this.hidSettings = null; - this.timeout = null; - this.velocitySettings = null; - this.vrm = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequest.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequest.java deleted file mode 100644 index bb11300e7..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigRequest.java +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SkeletonConfigRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SkeletonConfigRequest getRootAsSkeletonConfigRequest(ByteBuffer _bb) { return getRootAsSkeletonConfigRequest(_bb, new SkeletonConfigRequest()); } - public static SkeletonConfigRequest getRootAsSkeletonConfigRequest(ByteBuffer _bb, SkeletonConfigRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SkeletonConfigRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startSkeletonConfigRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endSkeletonConfigRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SkeletonConfigRequest get(int j) { return get(new SkeletonConfigRequest(), j); } - public SkeletonConfigRequest get(SkeletonConfigRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SkeletonConfigRequestT unpack() { - SkeletonConfigRequestT _o = new SkeletonConfigRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SkeletonConfigRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, SkeletonConfigRequestT _o) { - if (_o == null) return 0; - startSkeletonConfigRequest(builder); - return endSkeletonConfigRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/FilteringSettings.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonFiltering.java similarity index 55% rename from protocol/java/src/solarxr_protocol/rpc/FilteringSettings.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonFiltering.java index ec01758a9..05077cb95 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FilteringSettings.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonFiltering.java @@ -7,33 +7,36 @@ import java.util.*; import com.google.flatbuffers.*; +/** + * Filtering (e.g smoothing) applied to the skeleton's movements + */ @SuppressWarnings("unused") -public final class FilteringSettings extends Table { +public final class SkeletonFiltering extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static FilteringSettings getRootAsFilteringSettings(ByteBuffer _bb) { return getRootAsFilteringSettings(_bb, new FilteringSettings()); } - public static FilteringSettings getRootAsFilteringSettings(ByteBuffer _bb, FilteringSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public static SkeletonFiltering getRootAsSkeletonFiltering(ByteBuffer _bb) { return getRootAsSkeletonFiltering(_bb, new SkeletonFiltering()); } + public static SkeletonFiltering getRootAsSkeletonFiltering(ByteBuffer _bb, SkeletonFiltering obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public FilteringSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + public SkeletonFiltering __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } public int type() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } /** - * 0 to 1. A higher value results in more smoothing or prediction + * A higher value results in more filtering (0 to 1). */ public float amount() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public static int createFilteringSettings(FlatBufferBuilder builder, + public static int createSkeletonFiltering(FlatBufferBuilder builder, int type, float amount) { builder.startTable(2); - FilteringSettings.addAmount(builder, amount); - FilteringSettings.addType(builder, type); - return FilteringSettings.endFilteringSettings(builder); + SkeletonFiltering.addAmount(builder, amount); + SkeletonFiltering.addType(builder, type); + return SkeletonFiltering.endSkeletonFiltering(builder); } - public static void startFilteringSettings(FlatBufferBuilder builder) { builder.startTable(2); } + public static void startSkeletonFiltering(FlatBufferBuilder builder) { builder.startTable(2); } public static void addType(FlatBufferBuilder builder, int type) { builder.addByte(0, (byte) type, (byte) 0); } public static void addAmount(FlatBufferBuilder builder, float amount) { builder.addFloat(1, amount, 0.0f); } - public static int endFilteringSettings(FlatBufferBuilder builder) { + public static int endSkeletonFiltering(FlatBufferBuilder builder) { int o = builder.endTable(); return o; } @@ -41,23 +44,23 @@ public static int endFilteringSettings(FlatBufferBuilder builder) { public static final class Vector extends BaseVector { public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - public FilteringSettings get(int j) { return get(new FilteringSettings(), j); } - public FilteringSettings get(FilteringSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + public SkeletonFiltering get(int j) { return get(new SkeletonFiltering(), j); } + public SkeletonFiltering get(SkeletonFiltering obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } } - public FilteringSettingsT unpack() { - FilteringSettingsT _o = new FilteringSettingsT(); + public SkeletonFilteringT unpack() { + SkeletonFilteringT _o = new SkeletonFilteringT(); unpackTo(_o); return _o; } - public void unpackTo(FilteringSettingsT _o) { + public void unpackTo(SkeletonFilteringT _o) { int _oType = type(); _o.setType(_oType); float _oAmount = amount(); _o.setAmount(_oAmount); } - public static int pack(FlatBufferBuilder builder, FilteringSettingsT _o) { + public static int pack(FlatBufferBuilder builder, SkeletonFilteringT _o) { if (_o == null) return 0; - return createFilteringSettings( + return createSkeletonFiltering( builder, _o.getType(), _o.getAmount()); diff --git a/protocol/java/src/solarxr_protocol/rpc/FilteringSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonFilteringT.java similarity index 88% rename from protocol/java/src/solarxr_protocol/rpc/FilteringSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonFilteringT.java index 880197faf..682444570 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FilteringSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonFilteringT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class FilteringSettingsT { +public class SkeletonFilteringT { private int type; private float amount; @@ -20,7 +20,7 @@ public class FilteringSettingsT { public void setAmount(float amount) { this.amount = amount; } - public FilteringSettingsT() { + public SkeletonFilteringT() { this.type = 0; this.amount = 0.0f; } diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeight.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonHeight.java similarity index 97% rename from protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeight.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonHeight.java index 3805aaebd..abdfb5c35 100644 --- a/protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeight.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonHeight.java @@ -1,12 +1,15 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.rpc.settings; +package solarxr_protocol.rpc; import java.nio.*; import java.lang.*; import java.util.*; import com.google.flatbuffers.*; +/** + * Data used to compute the skeleton's height. + */ @SuppressWarnings("unused") public final class SkeletonHeight extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeightT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonHeightT.java similarity index 94% rename from protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeightT.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonHeightT.java index 9799fe31d..1bd992d05 100644 --- a/protocol/java/src/solarxr_protocol/rpc/settings/SkeletonHeightT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonHeightT.java @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.rpc.settings; +package solarxr_protocol.rpc; import java.nio.*; import java.lang.*; diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequest.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequest.java new file mode 100644 index 000000000..ddba8be51 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class SkeletonProportionsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonProportionsRequest getRootAsSkeletonProportionsRequest(ByteBuffer _bb) { return getRootAsSkeletonProportionsRequest(_bb, new SkeletonProportionsRequest()); } + public static SkeletonProportionsRequest getRootAsSkeletonProportionsRequest(ByteBuffer _bb, SkeletonProportionsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonProportionsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startSkeletonProportionsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endSkeletonProportionsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonProportionsRequest get(int j) { return get(new SkeletonProportionsRequest(), j); } + public SkeletonProportionsRequest get(SkeletonProportionsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonProportionsRequestT unpack() { + SkeletonProportionsRequestT _o = new SkeletonProportionsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonProportionsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, SkeletonProportionsRequestT _o) { + if (_o == null) return 0; + startSkeletonProportionsRequest(builder); + return endSkeletonProportionsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequestT.java new file mode 100644 index 000000000..dab0ad757 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class SkeletonProportionsRequestT { + + + public SkeletonProportionsRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequest.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequest.java new file mode 100644 index 000000000..845abc82e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class SkeletonProportionsResetAllRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonProportionsResetAllRequest getRootAsSkeletonProportionsResetAllRequest(ByteBuffer _bb) { return getRootAsSkeletonProportionsResetAllRequest(_bb, new SkeletonProportionsResetAllRequest()); } + public static SkeletonProportionsResetAllRequest getRootAsSkeletonProportionsResetAllRequest(ByteBuffer _bb, SkeletonProportionsResetAllRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonProportionsResetAllRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startSkeletonProportionsResetAllRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endSkeletonProportionsResetAllRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonProportionsResetAllRequest get(int j) { return get(new SkeletonProportionsResetAllRequest(), j); } + public SkeletonProportionsResetAllRequest get(SkeletonProportionsResetAllRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonProportionsResetAllRequestT unpack() { + SkeletonProportionsResetAllRequestT _o = new SkeletonProportionsResetAllRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonProportionsResetAllRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, SkeletonProportionsResetAllRequestT _o) { + if (_o == null) return 0; + startSkeletonProportionsResetAllRequest(builder); + return endSkeletonProportionsResetAllRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequestT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequestT.java new file mode 100644 index 000000000..0750e25c6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResetAllRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class SkeletonProportionsResetAllRequestT { + + + public SkeletonProportionsResetAllRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponse.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponse.java similarity index 65% rename from protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponse.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponse.java index 9dc0607d6..08fb645a0 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponse.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; @SuppressWarnings("unused") -public final class SkeletonConfigResponse extends Table { +public final class SkeletonProportionsResponse extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SkeletonConfigResponse getRootAsSkeletonConfigResponse(ByteBuffer _bb) { return getRootAsSkeletonConfigResponse(_bb, new SkeletonConfigResponse()); } - public static SkeletonConfigResponse getRootAsSkeletonConfigResponse(ByteBuffer _bb, SkeletonConfigResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public static SkeletonProportionsResponse getRootAsSkeletonProportionsResponse(ByteBuffer _bb) { return getRootAsSkeletonProportionsResponse(_bb, new SkeletonProportionsResponse()); } + public static SkeletonProportionsResponse getRootAsSkeletonProportionsResponse(ByteBuffer _bb, SkeletonProportionsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SkeletonConfigResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + public SkeletonProportionsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } public solarxr_protocol.rpc.SkeletonPart skeletonParts(int j) { return skeletonParts(new solarxr_protocol.rpc.SkeletonPart(), j); } public solarxr_protocol.rpc.SkeletonPart skeletonParts(solarxr_protocol.rpc.SkeletonPart obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } @@ -22,21 +22,21 @@ public final class SkeletonConfigResponse extends Table { public solarxr_protocol.rpc.SkeletonPart.Vector skeletonPartsVector(solarxr_protocol.rpc.SkeletonPart.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public float userHeight() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public static int createSkeletonConfigResponse(FlatBufferBuilder builder, + public static int createSkeletonProportionsResponse(FlatBufferBuilder builder, int skeletonPartsOffset, float userHeight) { builder.startTable(2); - SkeletonConfigResponse.addUserHeight(builder, userHeight); - SkeletonConfigResponse.addSkeletonParts(builder, skeletonPartsOffset); - return SkeletonConfigResponse.endSkeletonConfigResponse(builder); + SkeletonProportionsResponse.addUserHeight(builder, userHeight); + SkeletonProportionsResponse.addSkeletonParts(builder, skeletonPartsOffset); + return SkeletonProportionsResponse.endSkeletonProportionsResponse(builder); } - public static void startSkeletonConfigResponse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void startSkeletonProportionsResponse(FlatBufferBuilder builder) { builder.startTable(2); } public static void addSkeletonParts(FlatBufferBuilder builder, int skeletonPartsOffset) { builder.addOffset(0, skeletonPartsOffset, 0); } public static int createSkeletonPartsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } public static void startSkeletonPartsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static void addUserHeight(FlatBufferBuilder builder, float userHeight) { builder.addFloat(1, userHeight, 0.0f); } - public static int endSkeletonConfigResponse(FlatBufferBuilder builder) { + public static int endSkeletonProportionsResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; } @@ -44,22 +44,22 @@ public static int endSkeletonConfigResponse(FlatBufferBuilder builder) { public static final class Vector extends BaseVector { public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - public SkeletonConfigResponse get(int j) { return get(new SkeletonConfigResponse(), j); } - public SkeletonConfigResponse get(SkeletonConfigResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + public SkeletonProportionsResponse get(int j) { return get(new SkeletonProportionsResponse(), j); } + public SkeletonProportionsResponse get(SkeletonProportionsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } } - public SkeletonConfigResponseT unpack() { - SkeletonConfigResponseT _o = new SkeletonConfigResponseT(); + public SkeletonProportionsResponseT unpack() { + SkeletonProportionsResponseT _o = new SkeletonProportionsResponseT(); unpackTo(_o); return _o; } - public void unpackTo(SkeletonConfigResponseT _o) { + public void unpackTo(SkeletonProportionsResponseT _o) { solarxr_protocol.rpc.SkeletonPartT[] _oSkeletonParts = new solarxr_protocol.rpc.SkeletonPartT[skeletonPartsLength()]; for (int _j = 0; _j < skeletonPartsLength(); ++_j) {_oSkeletonParts[_j] = (skeletonParts(_j) != null ? skeletonParts(_j).unpack() : null);} _o.setSkeletonParts(_oSkeletonParts); float _oUserHeight = userHeight(); _o.setUserHeight(_oUserHeight); } - public static int pack(FlatBufferBuilder builder, SkeletonConfigResponseT _o) { + public static int pack(FlatBufferBuilder builder, SkeletonProportionsResponseT _o) { if (_o == null) return 0; int _skeletonParts = 0; if (_o.getSkeletonParts() != null) { @@ -68,7 +68,7 @@ public static int pack(FlatBufferBuilder builder, SkeletonConfigResponseT _o) { for (solarxr_protocol.rpc.SkeletonPartT _e : _o.getSkeletonParts()) { __skeletonParts[_j] = solarxr_protocol.rpc.SkeletonPart.pack(builder, _e); _j++;} _skeletonParts = createSkeletonPartsVector(builder, __skeletonParts); } - return createSkeletonConfigResponse( + return createSkeletonProportionsResponse( builder, _skeletonParts, _o.getUserHeight()); diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponseT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponseT.java similarity index 89% rename from protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponseT.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponseT.java index 736033683..9ae201791 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonConfigResponseT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonProportionsResponseT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class SkeletonConfigResponseT { +public class SkeletonProportionsResponseT { private solarxr_protocol.rpc.SkeletonPartT[] skeletonParts; private float userHeight; @@ -20,7 +20,7 @@ public class SkeletonConfigResponseT { public void setUserHeight(float userHeight) { this.userHeight = userHeight; } - public SkeletonConfigResponseT() { + public SkeletonProportionsResponseT() { this.skeletonParts = null; this.userHeight = 0.0f; } diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonRatios.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonRatios.java new file mode 100644 index 000000000..89b5164f1 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonRatios.java @@ -0,0 +1,118 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Ratios for the skeletal model. Accepted values for them range from 0 to 1 + */ +@SuppressWarnings("unused") +public final class SkeletonRatios extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonRatios getRootAsSkeletonRatios(ByteBuffer _bb) { return getRootAsSkeletonRatios(_bb, new SkeletonRatios()); } + public static SkeletonRatios getRootAsSkeletonRatios(ByteBuffer _bb, SkeletonRatios obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonRatios __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + /** + * Compute missing spine bones as a ratio of the next available upper and lower bones. + */ + public boolean hasImputeSpineFromUpperLower() { return 0 != __offset(4); } + public float imputeSpineFromUpperLower() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + /** + * Computes the curvature between 2 adjacent missing spine bones. Higher = more curvature. + */ + public boolean hasImputeSpineCurvature() { return 0 != __offset(6); } + public float imputeSpineCurvature() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + /** + * How much to average the hip's yaw and roll with the upper legs'. + */ + public boolean hasInterpHipLegs() { return 0 != __offset(8); } + public float interpHipLegs() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + /** + * How much to average the knee trackers' yaw and roll with the lower legs'. + */ + public boolean hasInterpKneeTrackerAnkle() { return 0 != __offset(10); } + public float interpKneeTrackerAnkle() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + /** + * How much to average the upper leg's yaw and roll with the lower legs'. + */ + public boolean hasInterpKneeAnkle() { return 0 != __offset(12); } + public float interpKneeAnkle() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + /** + * Strength of skating correction. Enabled via SkeletonToggles.skating_correction + */ + public boolean hasSkatingCorrectionStrength() { return 0 != __offset(14); } + public float skatingCorrectionStrength() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } + + public static int createSkeletonRatios(FlatBufferBuilder builder, + float imputeSpineFromUpperLower, + float imputeSpineCurvature, + float interpHipLegs, + float interpKneeTrackerAnkle, + float interpKneeAnkle, + float skatingCorrectionStrength) { + builder.startTable(6); + SkeletonRatios.addSkatingCorrectionStrength(builder, skatingCorrectionStrength); + SkeletonRatios.addInterpKneeAnkle(builder, interpKneeAnkle); + SkeletonRatios.addInterpKneeTrackerAnkle(builder, interpKneeTrackerAnkle); + SkeletonRatios.addInterpHipLegs(builder, interpHipLegs); + SkeletonRatios.addImputeSpineCurvature(builder, imputeSpineCurvature); + SkeletonRatios.addImputeSpineFromUpperLower(builder, imputeSpineFromUpperLower); + return SkeletonRatios.endSkeletonRatios(builder); + } + + public static void startSkeletonRatios(FlatBufferBuilder builder) { builder.startTable(6); } + public static void addImputeSpineFromUpperLower(FlatBufferBuilder builder, float imputeSpineFromUpperLower) { builder.addFloat(0, imputeSpineFromUpperLower, 0f); } + public static void addImputeSpineCurvature(FlatBufferBuilder builder, float imputeSpineCurvature) { builder.addFloat(1, imputeSpineCurvature, 0f); } + public static void addInterpHipLegs(FlatBufferBuilder builder, float interpHipLegs) { builder.addFloat(2, interpHipLegs, 0f); } + public static void addInterpKneeTrackerAnkle(FlatBufferBuilder builder, float interpKneeTrackerAnkle) { builder.addFloat(3, interpKneeTrackerAnkle, 0f); } + public static void addInterpKneeAnkle(FlatBufferBuilder builder, float interpKneeAnkle) { builder.addFloat(4, interpKneeAnkle, 0f); } + public static void addSkatingCorrectionStrength(FlatBufferBuilder builder, float skatingCorrectionStrength) { builder.addFloat(5, skatingCorrectionStrength, 0f); } + public static int endSkeletonRatios(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonRatios get(int j) { return get(new SkeletonRatios(), j); } + public SkeletonRatios get(SkeletonRatios obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonRatiosT unpack() { + SkeletonRatiosT _o = new SkeletonRatiosT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonRatiosT _o) { + Float _oImputeSpineFromUpperLower = hasImputeSpineFromUpperLower() ? imputeSpineFromUpperLower() : null; + _o.setImputeSpineFromUpperLower(_oImputeSpineFromUpperLower); + Float _oImputeSpineCurvature = hasImputeSpineCurvature() ? imputeSpineCurvature() : null; + _o.setImputeSpineCurvature(_oImputeSpineCurvature); + Float _oInterpHipLegs = hasInterpHipLegs() ? interpHipLegs() : null; + _o.setInterpHipLegs(_oInterpHipLegs); + Float _oInterpKneeTrackerAnkle = hasInterpKneeTrackerAnkle() ? interpKneeTrackerAnkle() : null; + _o.setInterpKneeTrackerAnkle(_oInterpKneeTrackerAnkle); + Float _oInterpKneeAnkle = hasInterpKneeAnkle() ? interpKneeAnkle() : null; + _o.setInterpKneeAnkle(_oInterpKneeAnkle); + Float _oSkatingCorrectionStrength = hasSkatingCorrectionStrength() ? skatingCorrectionStrength() : null; + _o.setSkatingCorrectionStrength(_oSkatingCorrectionStrength); + } + public static int pack(FlatBufferBuilder builder, SkeletonRatiosT _o) { + if (_o == null) return 0; + return createSkeletonRatios( + builder, + _o.getImputeSpineFromUpperLower(), + _o.getImputeSpineCurvature(), + _o.getInterpHipLegs(), + _o.getInterpKneeTrackerAnkle(), + _o.getInterpKneeAnkle(), + _o.getSkatingCorrectionStrength()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonRatiosT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonRatiosT.java new file mode 100644 index 000000000..d84a4a6b1 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonRatiosT.java @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class SkeletonRatiosT { + private Float imputeSpineFromUpperLower; + private Float imputeSpineCurvature; + private Float interpHipLegs; + private Float interpKneeTrackerAnkle; + private Float interpKneeAnkle; + private Float skatingCorrectionStrength; + + public Float getImputeSpineFromUpperLower() { return imputeSpineFromUpperLower; } + + public void setImputeSpineFromUpperLower(Float imputeSpineFromUpperLower) { this.imputeSpineFromUpperLower = imputeSpineFromUpperLower; } + + public Float getImputeSpineCurvature() { return imputeSpineCurvature; } + + public void setImputeSpineCurvature(Float imputeSpineCurvature) { this.imputeSpineCurvature = imputeSpineCurvature; } + + public Float getInterpHipLegs() { return interpHipLegs; } + + public void setInterpHipLegs(Float interpHipLegs) { this.interpHipLegs = interpHipLegs; } + + public Float getInterpKneeTrackerAnkle() { return interpKneeTrackerAnkle; } + + public void setInterpKneeTrackerAnkle(Float interpKneeTrackerAnkle) { this.interpKneeTrackerAnkle = interpKneeTrackerAnkle; } + + public Float getInterpKneeAnkle() { return interpKneeAnkle; } + + public void setInterpKneeAnkle(Float interpKneeAnkle) { this.interpKneeAnkle = interpKneeAnkle; } + + public Float getSkatingCorrectionStrength() { return skatingCorrectionStrength; } + + public void setSkatingCorrectionStrength(Float skatingCorrectionStrength) { this.skatingCorrectionStrength = skatingCorrectionStrength; } + + + public SkeletonRatiosT() { + this.imputeSpineFromUpperLower = null; + this.imputeSpineCurvature = null; + this.interpHipLegs = null; + this.interpKneeTrackerAnkle = null; + this.interpKneeAnkle = null; + this.skatingCorrectionStrength = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequest.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequest.java deleted file mode 100644 index c81e6192d..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequest.java +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SkeletonResetAllRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SkeletonResetAllRequest getRootAsSkeletonResetAllRequest(ByteBuffer _bb) { return getRootAsSkeletonResetAllRequest(_bb, new SkeletonResetAllRequest()); } - public static SkeletonResetAllRequest getRootAsSkeletonResetAllRequest(ByteBuffer _bb, SkeletonResetAllRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SkeletonResetAllRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startSkeletonResetAllRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endSkeletonResetAllRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SkeletonResetAllRequest get(int j) { return get(new SkeletonResetAllRequest(), j); } - public SkeletonResetAllRequest get(SkeletonResetAllRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SkeletonResetAllRequestT unpack() { - SkeletonResetAllRequestT _o = new SkeletonResetAllRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SkeletonResetAllRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, SkeletonResetAllRequestT _o) { - if (_o == null) return 0; - startSkeletonResetAllRequest(builder); - return endSkeletonResetAllRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequest.java new file mode 100644 index 000000000..bb93d82b9 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class SkeletonSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonSettingsRequest getRootAsSkeletonSettingsRequest(ByteBuffer _bb) { return getRootAsSkeletonSettingsRequest(_bb, new SkeletonSettingsRequest()); } + public static SkeletonSettingsRequest getRootAsSkeletonSettingsRequest(ByteBuffer _bb, SkeletonSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startSkeletonSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endSkeletonSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonSettingsRequest get(int j) { return get(new SkeletonSettingsRequest(), j); } + public SkeletonSettingsRequest get(SkeletonSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonSettingsRequestT unpack() { + SkeletonSettingsRequestT _o = new SkeletonSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, SkeletonSettingsRequestT _o) { + if (_o == null) return 0; + startSkeletonSettingsRequest(builder); + return endSkeletonSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequestT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequestT.java similarity index 72% rename from protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequestT.java index d79a638a6..9492de480 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SkeletonResetAllRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class SkeletonResetAllRequestT { +public class SkeletonSettingsRequestT { - public SkeletonResetAllRequestT() { + public SkeletonSettingsRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponse.java new file mode 100644 index 000000000..f67561f65 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponse.java @@ -0,0 +1,85 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class SkeletonSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonSettingsResponse getRootAsSkeletonSettingsResponse(ByteBuffer _bb) { return getRootAsSkeletonSettingsResponse(_bb, new SkeletonSettingsResponse()); } + public static SkeletonSettingsResponse getRootAsSkeletonSettingsResponse(ByteBuffer _bb, SkeletonSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.rpc.SkeletonToggles toggles() { return toggles(new solarxr_protocol.rpc.SkeletonToggles()); } + public solarxr_protocol.rpc.SkeletonToggles toggles(solarxr_protocol.rpc.SkeletonToggles obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonRatios ratios() { return ratios(new solarxr_protocol.rpc.SkeletonRatios()); } + public solarxr_protocol.rpc.SkeletonRatios ratios(solarxr_protocol.rpc.SkeletonRatios obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonFiltering filtering() { return filtering(new solarxr_protocol.rpc.SkeletonFiltering()); } + public solarxr_protocol.rpc.SkeletonFiltering filtering(solarxr_protocol.rpc.SkeletonFiltering obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.rpc.SkeletonHeight skeletonHeight() { return skeletonHeight(new solarxr_protocol.rpc.SkeletonHeight()); } + public solarxr_protocol.rpc.SkeletonHeight skeletonHeight(solarxr_protocol.rpc.SkeletonHeight obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + + public static int createSkeletonSettingsResponse(FlatBufferBuilder builder, + int togglesOffset, + int ratiosOffset, + int filteringOffset, + int skeletonHeightOffset) { + builder.startTable(4); + SkeletonSettingsResponse.addSkeletonHeight(builder, skeletonHeightOffset); + SkeletonSettingsResponse.addFiltering(builder, filteringOffset); + SkeletonSettingsResponse.addRatios(builder, ratiosOffset); + SkeletonSettingsResponse.addToggles(builder, togglesOffset); + return SkeletonSettingsResponse.endSkeletonSettingsResponse(builder); + } + + public static void startSkeletonSettingsResponse(FlatBufferBuilder builder) { builder.startTable(4); } + public static void addToggles(FlatBufferBuilder builder, int togglesOffset) { builder.addOffset(0, togglesOffset, 0); } + public static void addRatios(FlatBufferBuilder builder, int ratiosOffset) { builder.addOffset(1, ratiosOffset, 0); } + public static void addFiltering(FlatBufferBuilder builder, int filteringOffset) { builder.addOffset(2, filteringOffset, 0); } + public static void addSkeletonHeight(FlatBufferBuilder builder, int skeletonHeightOffset) { builder.addOffset(3, skeletonHeightOffset, 0); } + public static int endSkeletonSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonSettingsResponse get(int j) { return get(new SkeletonSettingsResponse(), j); } + public SkeletonSettingsResponse get(SkeletonSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonSettingsResponseT unpack() { + SkeletonSettingsResponseT _o = new SkeletonSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonSettingsResponseT _o) { + if (toggles() != null) _o.setToggles(toggles().unpack()); + else _o.setToggles(null); + if (ratios() != null) _o.setRatios(ratios().unpack()); + else _o.setRatios(null); + if (filtering() != null) _o.setFiltering(filtering().unpack()); + else _o.setFiltering(null); + if (skeletonHeight() != null) _o.setSkeletonHeight(skeletonHeight().unpack()); + else _o.setSkeletonHeight(null); + } + public static int pack(FlatBufferBuilder builder, SkeletonSettingsResponseT _o) { + if (_o == null) return 0; + int _toggles = _o.getToggles() == null ? 0 : solarxr_protocol.rpc.SkeletonToggles.pack(builder, _o.getToggles()); + int _ratios = _o.getRatios() == null ? 0 : solarxr_protocol.rpc.SkeletonRatios.pack(builder, _o.getRatios()); + int _filtering = _o.getFiltering() == null ? 0 : solarxr_protocol.rpc.SkeletonFiltering.pack(builder, _o.getFiltering()); + int _skeletonHeight = _o.getSkeletonHeight() == null ? 0 : solarxr_protocol.rpc.SkeletonHeight.pack(builder, _o.getSkeletonHeight()); + return createSkeletonSettingsResponse( + builder, + _toggles, + _ratios, + _filtering, + _skeletonHeight); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponseT.java new file mode 100644 index 000000000..0e9782d6a --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonSettingsResponseT.java @@ -0,0 +1,40 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class SkeletonSettingsResponseT { + private solarxr_protocol.rpc.SkeletonTogglesT toggles; + private solarxr_protocol.rpc.SkeletonRatiosT ratios; + private solarxr_protocol.rpc.SkeletonFilteringT filtering; + private solarxr_protocol.rpc.SkeletonHeightT skeletonHeight; + + public solarxr_protocol.rpc.SkeletonTogglesT getToggles() { return toggles; } + + public void setToggles(solarxr_protocol.rpc.SkeletonTogglesT toggles) { this.toggles = toggles; } + + public solarxr_protocol.rpc.SkeletonRatiosT getRatios() { return ratios; } + + public void setRatios(solarxr_protocol.rpc.SkeletonRatiosT ratios) { this.ratios = ratios; } + + public solarxr_protocol.rpc.SkeletonFilteringT getFiltering() { return filtering; } + + public void setFiltering(solarxr_protocol.rpc.SkeletonFilteringT filtering) { this.filtering = filtering; } + + public solarxr_protocol.rpc.SkeletonHeightT getSkeletonHeight() { return skeletonHeight; } + + public void setSkeletonHeight(solarxr_protocol.rpc.SkeletonHeightT skeletonHeight) { this.skeletonHeight = skeletonHeight; } + + + public SkeletonSettingsResponseT() { + this.toggles = null; + this.ratios = null; + this.filtering = null; + this.skeletonHeight = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SkeletonToggles.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonToggles.java new file mode 100644 index 000000000..dd04a3779 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonToggles.java @@ -0,0 +1,124 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Toggles for the skeletal model. + */ +@SuppressWarnings("unused") +public final class SkeletonToggles extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static SkeletonToggles getRootAsSkeletonToggles(ByteBuffer _bb) { return getRootAsSkeletonToggles(_bb, new SkeletonToggles()); } + public static SkeletonToggles getRootAsSkeletonToggles(ByteBuffer _bb, SkeletonToggles obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public SkeletonToggles __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean hasForceArmsFromHmd() { return 0 != __offset(4); } + public boolean forceArmsFromHmd() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasFloorClip() { return 0 != __offset(6); } + public boolean floorClip() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasSkatingCorrection() { return 0 != __offset(8); } + public boolean skatingCorrection() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasToeSnap() { return 0 != __offset(10); } + public boolean toeSnap() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasFootPlant() { return 0 != __offset(12); } + public boolean footPlant() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasSelfLocalization() { return 0 != __offset(14); } + public boolean selfLocalization() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasUsePosition() { return 0 != __offset(16); } + public boolean usePosition() { int o = __offset(16); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasEnforceConstraints() { return 0 != __offset(18); } + public boolean enforceConstraints() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasCorrectConstraints() { return 0 != __offset(20); } + public boolean correctConstraints() { int o = __offset(20); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createSkeletonToggles(FlatBufferBuilder builder, + boolean forceArmsFromHmd, + boolean floorClip, + boolean skatingCorrection, + boolean toeSnap, + boolean footPlant, + boolean selfLocalization, + boolean usePosition, + boolean enforceConstraints, + boolean correctConstraints) { + builder.startTable(9); + SkeletonToggles.addCorrectConstraints(builder, correctConstraints); + SkeletonToggles.addEnforceConstraints(builder, enforceConstraints); + SkeletonToggles.addUsePosition(builder, usePosition); + SkeletonToggles.addSelfLocalization(builder, selfLocalization); + SkeletonToggles.addFootPlant(builder, footPlant); + SkeletonToggles.addToeSnap(builder, toeSnap); + SkeletonToggles.addSkatingCorrection(builder, skatingCorrection); + SkeletonToggles.addFloorClip(builder, floorClip); + SkeletonToggles.addForceArmsFromHmd(builder, forceArmsFromHmd); + return SkeletonToggles.endSkeletonToggles(builder); + } + + public static void startSkeletonToggles(FlatBufferBuilder builder) { builder.startTable(9); } + public static void addForceArmsFromHmd(FlatBufferBuilder builder, boolean forceArmsFromHmd) { builder.addBoolean(0, forceArmsFromHmd, false); } + public static void addFloorClip(FlatBufferBuilder builder, boolean floorClip) { builder.addBoolean(1, floorClip, false); } + public static void addSkatingCorrection(FlatBufferBuilder builder, boolean skatingCorrection) { builder.addBoolean(2, skatingCorrection, false); } + public static void addToeSnap(FlatBufferBuilder builder, boolean toeSnap) { builder.addBoolean(3, toeSnap, false); } + public static void addFootPlant(FlatBufferBuilder builder, boolean footPlant) { builder.addBoolean(4, footPlant, false); } + public static void addSelfLocalization(FlatBufferBuilder builder, boolean selfLocalization) { builder.addBoolean(5, selfLocalization, false); } + public static void addUsePosition(FlatBufferBuilder builder, boolean usePosition) { builder.addBoolean(6, usePosition, false); } + public static void addEnforceConstraints(FlatBufferBuilder builder, boolean enforceConstraints) { builder.addBoolean(7, enforceConstraints, false); } + public static void addCorrectConstraints(FlatBufferBuilder builder, boolean correctConstraints) { builder.addBoolean(8, correctConstraints, false); } + public static int endSkeletonToggles(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public SkeletonToggles get(int j) { return get(new SkeletonToggles(), j); } + public SkeletonToggles get(SkeletonToggles obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public SkeletonTogglesT unpack() { + SkeletonTogglesT _o = new SkeletonTogglesT(); + unpackTo(_o); + return _o; + } + public void unpackTo(SkeletonTogglesT _o) { + Boolean _oForceArmsFromHmd = hasForceArmsFromHmd() ? forceArmsFromHmd() : null; + _o.setForceArmsFromHmd(_oForceArmsFromHmd); + Boolean _oFloorClip = hasFloorClip() ? floorClip() : null; + _o.setFloorClip(_oFloorClip); + Boolean _oSkatingCorrection = hasSkatingCorrection() ? skatingCorrection() : null; + _o.setSkatingCorrection(_oSkatingCorrection); + Boolean _oToeSnap = hasToeSnap() ? toeSnap() : null; + _o.setToeSnap(_oToeSnap); + Boolean _oFootPlant = hasFootPlant() ? footPlant() : null; + _o.setFootPlant(_oFootPlant); + Boolean _oSelfLocalization = hasSelfLocalization() ? selfLocalization() : null; + _o.setSelfLocalization(_oSelfLocalization); + Boolean _oUsePosition = hasUsePosition() ? usePosition() : null; + _o.setUsePosition(_oUsePosition); + Boolean _oEnforceConstraints = hasEnforceConstraints() ? enforceConstraints() : null; + _o.setEnforceConstraints(_oEnforceConstraints); + Boolean _oCorrectConstraints = hasCorrectConstraints() ? correctConstraints() : null; + _o.setCorrectConstraints(_oCorrectConstraints); + } + public static int pack(FlatBufferBuilder builder, SkeletonTogglesT _o) { + if (_o == null) return 0; + return createSkeletonToggles( + builder, + _o.getForceArmsFromHmd(), + _o.getFloorClip(), + _o.getSkatingCorrection(), + _o.getToeSnap(), + _o.getFootPlant(), + _o.getSelfLocalization(), + _o.getUsePosition(), + _o.getEnforceConstraints(), + _o.getCorrectConstraints()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelTogglesT.java b/protocol/java/src/solarxr_protocol/rpc/SkeletonTogglesT.java similarity index 74% rename from protocol/java/src/solarxr_protocol/rpc/settings/ModelTogglesT.java rename to protocol/java/src/solarxr_protocol/rpc/SkeletonTogglesT.java index 10e29ef31..31e0d55b0 100644 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelTogglesT.java +++ b/protocol/java/src/solarxr_protocol/rpc/SkeletonTogglesT.java @@ -1,16 +1,13 @@ // automatically generated by the FlatBuffers compiler, do not modify -package solarxr_protocol.rpc.settings; +package solarxr_protocol.rpc; import java.nio.*; import java.lang.*; import java.util.*; import com.google.flatbuffers.*; -public class ModelTogglesT { - private Boolean extendedSpine; - private Boolean extendedPelvis; - private Boolean extendedKnee; +public class SkeletonTogglesT { private Boolean forceArmsFromHmd; private Boolean floorClip; private Boolean skatingCorrection; @@ -21,18 +18,6 @@ public class ModelTogglesT { private Boolean enforceConstraints; private Boolean correctConstraints; - public Boolean getExtendedSpine() { return extendedSpine; } - - public void setExtendedSpine(Boolean extendedSpine) { this.extendedSpine = extendedSpine; } - - public Boolean getExtendedPelvis() { return extendedPelvis; } - - public void setExtendedPelvis(Boolean extendedPelvis) { this.extendedPelvis = extendedPelvis; } - - public Boolean getExtendedKnee() { return extendedKnee; } - - public void setExtendedKnee(Boolean extendedKnee) { this.extendedKnee = extendedKnee; } - public Boolean getForceArmsFromHmd() { return forceArmsFromHmd; } public void setForceArmsFromHmd(Boolean forceArmsFromHmd) { this.forceArmsFromHmd = forceArmsFromHmd; } @@ -70,10 +55,7 @@ public class ModelTogglesT { public void setCorrectConstraints(Boolean correctConstraints) { this.correctConstraints = correctConstraints; } - public ModelTogglesT() { - this.extendedSpine = null; - this.extendedPelvis = null; - this.extendedKnee = null; + public SkeletonTogglesT() { this.forceArmsFromHmd = null; this.floorClip = null; this.skatingCorrection = null; diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusData.java b/protocol/java/src/solarxr_protocol/rpc/StatusData.java deleted file mode 100644 index 62054626e..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusData.java +++ /dev/null @@ -1,19 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -@SuppressWarnings("unused") -public final class StatusData { - private StatusData() { } - public static final byte NONE = 0; - public static final byte StatusTrackerReset = 1; - public static final byte StatusTrackerError = 2; - public static final byte StatusSteamVRDisconnected = 3; - public static final byte StatusUnassignedHMD = 4; - public static final byte StatusPublicNetwork = 5; - - public static final String[] names = { "NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork", }; - - public static String name(int e) { return names[e]; } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java b/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java deleted file mode 100644 index dcdbb2322..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java +++ /dev/null @@ -1,41 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import com.google.flatbuffers.FlatBufferBuilder; - -public class StatusDataUnion { - private byte type; - private Object value; - - public byte getType() { return type; } - - public void setType(byte type) { this.type = type; } - - public Object getValue() { return value; } - - public void setValue(Object value) { this.value = value; } - - public StatusDataUnion() { - this.type = StatusData.NONE; - this.value = null; - } - - public solarxr_protocol.rpc.StatusTrackerResetT asStatusTrackerReset() { return (solarxr_protocol.rpc.StatusTrackerResetT) value; } - public solarxr_protocol.rpc.StatusTrackerErrorT asStatusTrackerError() { return (solarxr_protocol.rpc.StatusTrackerErrorT) value; } - public solarxr_protocol.rpc.StatusSteamVRDisconnectedT asStatusSteamVRDisconnected() { return (solarxr_protocol.rpc.StatusSteamVRDisconnectedT) value; } - public solarxr_protocol.rpc.StatusUnassignedHMDT asStatusUnassignedHMD() { return (solarxr_protocol.rpc.StatusUnassignedHMDT) value; } - public solarxr_protocol.rpc.StatusPublicNetworkT asStatusPublicNetwork() { return (solarxr_protocol.rpc.StatusPublicNetworkT) value; } - - public static int pack(FlatBufferBuilder builder, StatusDataUnion _o) { - switch (_o.type) { - case StatusData.StatusTrackerReset: return solarxr_protocol.rpc.StatusTrackerReset.pack(builder, _o.asStatusTrackerReset()); - case StatusData.StatusTrackerError: return solarxr_protocol.rpc.StatusTrackerError.pack(builder, _o.asStatusTrackerError()); - case StatusData.StatusSteamVRDisconnected: return solarxr_protocol.rpc.StatusSteamVRDisconnected.pack(builder, _o.asStatusSteamVRDisconnected()); - case StatusData.StatusUnassignedHMD: return solarxr_protocol.rpc.StatusUnassignedHMD.pack(builder, _o.asStatusUnassignedHMD()); - case StatusData.StatusPublicNetwork: return solarxr_protocol.rpc.StatusPublicNetwork.pack(builder, _o.asStatusPublicNetwork()); - default: return 0; - } - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java b/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java deleted file mode 100644 index 35f8889b9..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java +++ /dev/null @@ -1,113 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * An status is some kind of warning sent by the server, it's mainly made for - * showing problems with the server and need attention from the user. - */ -@SuppressWarnings("unused") -public final class StatusMessage extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusMessage getRootAsStatusMessage(ByteBuffer _bb) { return getRootAsStatusMessage(_bb, new StatusMessage()); } - public static StatusMessage getRootAsStatusMessage(ByteBuffer _bb, StatusMessage obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusMessage __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - /** - * The status ID - */ - public long id() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } - /** - * This should be prioritized in the GUI in some way if true - */ - public boolean prioritized() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public byte dataType() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) : 0; } - public Table data(Table obj) { int o = __offset(10); return o != 0 ? __union(obj, o + bb_pos) : null; } - - public static int createStatusMessage(FlatBufferBuilder builder, - long id, - boolean prioritized, - byte dataType, - int dataOffset) { - builder.startTable(4); - StatusMessage.addData(builder, dataOffset); - StatusMessage.addId(builder, id); - StatusMessage.addDataType(builder, dataType); - StatusMessage.addPrioritized(builder, prioritized); - return StatusMessage.endStatusMessage(builder); - } - - public static void startStatusMessage(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addId(FlatBufferBuilder builder, long id) { builder.addInt(0, (int) id, (int) 0L); } - public static void addPrioritized(FlatBufferBuilder builder, boolean prioritized) { builder.addBoolean(1, prioritized, false); } - public static void addDataType(FlatBufferBuilder builder, byte dataType) { builder.addByte(2, dataType, 0); } - public static void addData(FlatBufferBuilder builder, int dataOffset) { builder.addOffset(3, dataOffset, 0); } - public static int endStatusMessage(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusMessage get(int j) { return get(new StatusMessage(), j); } - public StatusMessage get(StatusMessage obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusMessageT unpack() { - StatusMessageT _o = new StatusMessageT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusMessageT _o) { - long _oId = id(); - _o.setId(_oId); - boolean _oPrioritized = prioritized(); - _o.setPrioritized(_oPrioritized); - solarxr_protocol.rpc.StatusDataUnion _oData = new solarxr_protocol.rpc.StatusDataUnion(); - byte _oDataType = dataType(); - _oData.setType(_oDataType); - Table _oDataValue; - switch (_oDataType) { - case solarxr_protocol.rpc.StatusData.StatusTrackerReset: - _oDataValue = data(new solarxr_protocol.rpc.StatusTrackerReset()); - _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusTrackerReset) _oDataValue).unpack() : null); - break; - case solarxr_protocol.rpc.StatusData.StatusTrackerError: - _oDataValue = data(new solarxr_protocol.rpc.StatusTrackerError()); - _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusTrackerError) _oDataValue).unpack() : null); - break; - case solarxr_protocol.rpc.StatusData.StatusSteamVRDisconnected: - _oDataValue = data(new solarxr_protocol.rpc.StatusSteamVRDisconnected()); - _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusSteamVRDisconnected) _oDataValue).unpack() : null); - break; - case solarxr_protocol.rpc.StatusData.StatusUnassignedHMD: - _oDataValue = data(new solarxr_protocol.rpc.StatusUnassignedHMD()); - _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusUnassignedHMD) _oDataValue).unpack() : null); - break; - case solarxr_protocol.rpc.StatusData.StatusPublicNetwork: - _oDataValue = data(new solarxr_protocol.rpc.StatusPublicNetwork()); - _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusPublicNetwork) _oDataValue).unpack() : null); - break; - default: break; - } - _o.setData(_oData); - } - public static int pack(FlatBufferBuilder builder, StatusMessageT _o) { - if (_o == null) return 0; - byte _dataType = _o.getData() == null ? solarxr_protocol.rpc.StatusData.NONE : _o.getData().getType(); - int _data = _o.getData() == null ? 0 : solarxr_protocol.rpc.StatusDataUnion.pack(builder, _o.getData()); - return createStatusMessage( - builder, - _o.getId(), - _o.getPrioritized(), - _dataType, - _data); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusMessageT.java b/protocol/java/src/solarxr_protocol/rpc/StatusMessageT.java deleted file mode 100644 index 5d2aa215a..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusMessageT.java +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusMessageT { - private long id; - private boolean prioritized; - private solarxr_protocol.rpc.StatusDataUnion data; - - public long getId() { return id; } - - public void setId(long id) { this.id = id; } - - public boolean getPrioritized() { return prioritized; } - - public void setPrioritized(boolean prioritized) { this.prioritized = prioritized; } - - public solarxr_protocol.rpc.StatusDataUnion getData() { return data; } - - public void setData(solarxr_protocol.rpc.StatusDataUnion data) { this.data = data; } - - - public StatusMessageT() { - this.id = 0L; - this.prioritized = false; - this.data = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java deleted file mode 100644 index e4aa5a5a7..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java +++ /dev/null @@ -1,75 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * When the server detects a public network profile - */ -@SuppressWarnings("unused") -public final class StatusPublicNetwork extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb) { return getRootAsStatusPublicNetwork(_bb, new StatusPublicNetwork()); } - public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb, StatusPublicNetwork obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusPublicNetwork __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - /** - * names of the adapters set to public - */ - public String adapters(int j) { int o = __offset(4); return o != 0 ? __string(__vector(o) + j * 4) : null; } - public int adaptersLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public StringVector adaptersVector() { return adaptersVector(new StringVector()); } - public StringVector adaptersVector(StringVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - - public static int createStatusPublicNetwork(FlatBufferBuilder builder, - int adaptersOffset) { - builder.startTable(1); - StatusPublicNetwork.addAdapters(builder, adaptersOffset); - return StatusPublicNetwork.endStatusPublicNetwork(builder); - } - - public static void startStatusPublicNetwork(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addAdapters(FlatBufferBuilder builder, int adaptersOffset) { builder.addOffset(0, adaptersOffset, 0); } - public static int createAdaptersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startAdaptersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static int endStatusPublicNetwork(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusPublicNetwork get(int j) { return get(new StatusPublicNetwork(), j); } - public StatusPublicNetwork get(StatusPublicNetwork obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusPublicNetworkT unpack() { - StatusPublicNetworkT _o = new StatusPublicNetworkT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusPublicNetworkT _o) { - String[] _oAdapters = new String[adaptersLength()]; - for (int _j = 0; _j < adaptersLength(); ++_j) {_oAdapters[_j] = adapters(_j);} - _o.setAdapters(_oAdapters); - } - public static int pack(FlatBufferBuilder builder, StatusPublicNetworkT _o) { - if (_o == null) return 0; - int _adapters = 0; - if (_o.getAdapters() != null) { - int[] __adapters = new int[_o.getAdapters().length]; - int _j = 0; - for (String _e : _o.getAdapters()) { __adapters[_j] = builder.createString(_e); _j++;} - _adapters = createAdaptersVector(builder, __adapters); - } - return createStatusPublicNetwork( - builder, - _adapters); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java deleted file mode 100644 index 6d5869ec0..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusPublicNetworkT { - private String[] adapters; - - public String[] getAdapters() { return adapters; } - - public void setAdapters(String[] adapters) { this.adapters = adapters; } - - - public StatusPublicNetworkT() { - this.adapters = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.java b/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.java deleted file mode 100644 index 51f65a638..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.java +++ /dev/null @@ -1,65 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * SteamVR bridge is disconnected - */ -@SuppressWarnings("unused") -public final class StatusSteamVRDisconnected extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusSteamVRDisconnected getRootAsStatusSteamVRDisconnected(ByteBuffer _bb) { return getRootAsStatusSteamVRDisconnected(_bb, new StatusSteamVRDisconnected()); } - public static StatusSteamVRDisconnected getRootAsStatusSteamVRDisconnected(ByteBuffer _bb, StatusSteamVRDisconnected obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusSteamVRDisconnected __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - /** - * Name of bridge in the server's config - */ - public String bridgeSettingsName() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer bridgeSettingsNameAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer bridgeSettingsNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - - public static int createStatusSteamVRDisconnected(FlatBufferBuilder builder, - int bridgeSettingsNameOffset) { - builder.startTable(1); - StatusSteamVRDisconnected.addBridgeSettingsName(builder, bridgeSettingsNameOffset); - return StatusSteamVRDisconnected.endStatusSteamVRDisconnected(builder); - } - - public static void startStatusSteamVRDisconnected(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addBridgeSettingsName(FlatBufferBuilder builder, int bridgeSettingsNameOffset) { builder.addOffset(0, bridgeSettingsNameOffset, 0); } - public static int endStatusSteamVRDisconnected(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusSteamVRDisconnected get(int j) { return get(new StatusSteamVRDisconnected(), j); } - public StatusSteamVRDisconnected get(StatusSteamVRDisconnected obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusSteamVRDisconnectedT unpack() { - StatusSteamVRDisconnectedT _o = new StatusSteamVRDisconnectedT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusSteamVRDisconnectedT _o) { - String _oBridgeSettingsName = bridgeSettingsName(); - _o.setBridgeSettingsName(_oBridgeSettingsName); - } - public static int pack(FlatBufferBuilder builder, StatusSteamVRDisconnectedT _o) { - if (_o == null) return 0; - int _bridgeSettingsName = _o.getBridgeSettingsName() == null ? 0 : builder.createString(_o.getBridgeSettingsName()); - return createStatusSteamVRDisconnected( - builder, - _bridgeSettingsName); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnectedT.java b/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnectedT.java deleted file mode 100644 index f6db5871d..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSteamVRDisconnectedT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusSteamVRDisconnectedT { - private String bridgeSettingsName; - - public String getBridgeSettingsName() { return bridgeSettingsName; } - - public void setBridgeSettingsName(String bridgeSettingsName) { this.bridgeSettingsName = bridgeSettingsName; } - - - public StatusSteamVRDisconnectedT() { - this.bridgeSettingsName = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixed.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixed.java deleted file mode 100644 index 7ada2e105..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixed.java +++ /dev/null @@ -1,59 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * When an status is fixed and it's removed, it's ID is sent - */ -@SuppressWarnings("unused") -public final class StatusSystemFixed extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusSystemFixed getRootAsStatusSystemFixed(ByteBuffer _bb) { return getRootAsStatusSystemFixed(_bb, new StatusSystemFixed()); } - public static StatusSystemFixed getRootAsStatusSystemFixed(ByteBuffer _bb, StatusSystemFixed obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusSystemFixed __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public long fixedStatusId() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } - - public static int createStatusSystemFixed(FlatBufferBuilder builder, - long fixedStatusId) { - builder.startTable(1); - StatusSystemFixed.addFixedStatusId(builder, fixedStatusId); - return StatusSystemFixed.endStatusSystemFixed(builder); - } - - public static void startStatusSystemFixed(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addFixedStatusId(FlatBufferBuilder builder, long fixedStatusId) { builder.addInt(0, (int) fixedStatusId, (int) 0L); } - public static int endStatusSystemFixed(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusSystemFixed get(int j) { return get(new StatusSystemFixed(), j); } - public StatusSystemFixed get(StatusSystemFixed obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusSystemFixedT unpack() { - StatusSystemFixedT _o = new StatusSystemFixedT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusSystemFixedT _o) { - long _oFixedStatusId = fixedStatusId(); - _o.setFixedStatusId(_oFixedStatusId); - } - public static int pack(FlatBufferBuilder builder, StatusSystemFixedT _o) { - if (_o == null) return 0; - return createStatusSystemFixed( - builder, - _o.getFixedStatusId()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixedT.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixedT.java deleted file mode 100644 index fe7811953..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemFixedT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusSystemFixedT { - private long fixedStatusId; - - public long getFixedStatusId() { return fixedStatusId; } - - public void setFixedStatusId(long fixedStatusId) { this.fixedStatusId = fixedStatusId; } - - - public StatusSystemFixedT() { - this.fixedStatusId = 0L; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemRequest.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemRequest.java deleted file mode 100644 index c2ba51211..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemRequest.java +++ /dev/null @@ -1,47 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Request current statuses that we have - */ -@SuppressWarnings("unused") -public final class StatusSystemRequest extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusSystemRequest getRootAsStatusSystemRequest(ByteBuffer _bb) { return getRootAsStatusSystemRequest(_bb, new StatusSystemRequest()); } - public static StatusSystemRequest getRootAsStatusSystemRequest(ByteBuffer _bb, StatusSystemRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusSystemRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - - public static void startStatusSystemRequest(FlatBufferBuilder builder) { builder.startTable(0); } - public static int endStatusSystemRequest(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusSystemRequest get(int j) { return get(new StatusSystemRequest(), j); } - public StatusSystemRequest get(StatusSystemRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusSystemRequestT unpack() { - StatusSystemRequestT _o = new StatusSystemRequestT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusSystemRequestT _o) { - } - public static int pack(FlatBufferBuilder builder, StatusSystemRequestT _o) { - if (_o == null) return 0; - startStatusSystemRequest(builder); - return endStatusSystemRequest(builder); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponse.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponse.java deleted file mode 100644 index 8d9b9183b..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponse.java +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Response containing all current valid statuses - */ -@SuppressWarnings("unused") -public final class StatusSystemResponse extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusSystemResponse getRootAsStatusSystemResponse(ByteBuffer _bb) { return getRootAsStatusSystemResponse(_bb, new StatusSystemResponse()); } - public static StatusSystemResponse getRootAsStatusSystemResponse(ByteBuffer _bb, StatusSystemResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusSystemResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.StatusMessage currentStatuses(int j) { return currentStatuses(new solarxr_protocol.rpc.StatusMessage(), j); } - public solarxr_protocol.rpc.StatusMessage currentStatuses(solarxr_protocol.rpc.StatusMessage obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } - public int currentStatusesLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.rpc.StatusMessage.Vector currentStatusesVector() { return currentStatusesVector(new solarxr_protocol.rpc.StatusMessage.Vector()); } - public solarxr_protocol.rpc.StatusMessage.Vector currentStatusesVector(solarxr_protocol.rpc.StatusMessage.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - - public static int createStatusSystemResponse(FlatBufferBuilder builder, - int currentStatusesOffset) { - builder.startTable(1); - StatusSystemResponse.addCurrentStatuses(builder, currentStatusesOffset); - return StatusSystemResponse.endStatusSystemResponse(builder); - } - - public static void startStatusSystemResponse(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addCurrentStatuses(FlatBufferBuilder builder, int currentStatusesOffset) { builder.addOffset(0, currentStatusesOffset, 0); } - public static int createCurrentStatusesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startCurrentStatusesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static int endStatusSystemResponse(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusSystemResponse get(int j) { return get(new StatusSystemResponse(), j); } - public StatusSystemResponse get(StatusSystemResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusSystemResponseT unpack() { - StatusSystemResponseT _o = new StatusSystemResponseT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusSystemResponseT _o) { - solarxr_protocol.rpc.StatusMessageT[] _oCurrentStatuses = new solarxr_protocol.rpc.StatusMessageT[currentStatusesLength()]; - for (int _j = 0; _j < currentStatusesLength(); ++_j) {_oCurrentStatuses[_j] = (currentStatuses(_j) != null ? currentStatuses(_j).unpack() : null);} - _o.setCurrentStatuses(_oCurrentStatuses); - } - public static int pack(FlatBufferBuilder builder, StatusSystemResponseT _o) { - if (_o == null) return 0; - int _currentStatuses = 0; - if (_o.getCurrentStatuses() != null) { - int[] __currentStatuses = new int[_o.getCurrentStatuses().length]; - int _j = 0; - for (solarxr_protocol.rpc.StatusMessageT _e : _o.getCurrentStatuses()) { __currentStatuses[_j] = solarxr_protocol.rpc.StatusMessage.pack(builder, _e); _j++;} - _currentStatuses = createCurrentStatusesVector(builder, __currentStatuses); - } - return createStatusSystemResponse( - builder, - _currentStatuses); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponseT.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponseT.java deleted file mode 100644 index d6ff1dce2..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemResponseT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusSystemResponseT { - private solarxr_protocol.rpc.StatusMessageT[] currentStatuses; - - public solarxr_protocol.rpc.StatusMessageT[] getCurrentStatuses() { return currentStatuses; } - - public void setCurrentStatuses(solarxr_protocol.rpc.StatusMessageT[] currentStatuses) { this.currentStatuses = currentStatuses; } - - - public StatusSystemResponseT() { - this.currentStatuses = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdate.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdate.java deleted file mode 100644 index dbcef354b..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdate.java +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * When a new status appears, it's sent alone - */ -@SuppressWarnings("unused") -public final class StatusSystemUpdate extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusSystemUpdate getRootAsStatusSystemUpdate(ByteBuffer _bb) { return getRootAsStatusSystemUpdate(_bb, new StatusSystemUpdate()); } - public static StatusSystemUpdate getRootAsStatusSystemUpdate(ByteBuffer _bb, StatusSystemUpdate obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusSystemUpdate __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.StatusMessage newStatus() { return newStatus(new solarxr_protocol.rpc.StatusMessage()); } - public solarxr_protocol.rpc.StatusMessage newStatus(solarxr_protocol.rpc.StatusMessage obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createStatusSystemUpdate(FlatBufferBuilder builder, - int newStatusOffset) { - builder.startTable(1); - StatusSystemUpdate.addNewStatus(builder, newStatusOffset); - return StatusSystemUpdate.endStatusSystemUpdate(builder); - } - - public static void startStatusSystemUpdate(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addNewStatus(FlatBufferBuilder builder, int newStatusOffset) { builder.addOffset(0, newStatusOffset, 0); } - public static int endStatusSystemUpdate(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusSystemUpdate get(int j) { return get(new StatusSystemUpdate(), j); } - public StatusSystemUpdate get(StatusSystemUpdate obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusSystemUpdateT unpack() { - StatusSystemUpdateT _o = new StatusSystemUpdateT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusSystemUpdateT _o) { - if (newStatus() != null) _o.setNewStatus(newStatus().unpack()); - else _o.setNewStatus(null); - } - public static int pack(FlatBufferBuilder builder, StatusSystemUpdateT _o) { - if (_o == null) return 0; - int _newStatus = _o.getNewStatus() == null ? 0 : solarxr_protocol.rpc.StatusMessage.pack(builder, _o.getNewStatus()); - return createStatusSystemUpdate( - builder, - _newStatus); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdateT.java b/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdateT.java deleted file mode 100644 index c3a98fea2..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemUpdateT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusSystemUpdateT { - private solarxr_protocol.rpc.StatusMessageT newStatus; - - public solarxr_protocol.rpc.StatusMessageT getNewStatus() { return newStatus; } - - public void setNewStatus(solarxr_protocol.rpc.StatusMessageT newStatus) { this.newStatus = newStatus; } - - - public StatusSystemUpdateT() { - this.newStatus = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java deleted file mode 100644 index 85e330b20..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Trackers with error state - */ -@SuppressWarnings("unused") -public final class StatusTrackerError extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusTrackerError getRootAsStatusTrackerError(ByteBuffer _bb) { return getRootAsStatusTrackerError(_bb, new StatusTrackerError()); } - public static StatusTrackerError getRootAsStatusTrackerError(ByteBuffer _bb, StatusTrackerError obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusTrackerError __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.datatypes.TrackerId trackerId(int j) { return trackerId(new solarxr_protocol.datatypes.TrackerId(), j); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } - public int trackerIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector() { return trackerIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } - public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - - public static int createStatusTrackerError(FlatBufferBuilder builder, - int trackerIdOffset) { - builder.startTable(1); - StatusTrackerError.addTrackerId(builder, trackerIdOffset); - return StatusTrackerError.endStatusTrackerError(builder); - } - - public static void startStatusTrackerError(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } - public static int createTrackerIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startTrackerIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static int endStatusTrackerError(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusTrackerError get(int j) { return get(new StatusTrackerError(), j); } - public StatusTrackerError get(StatusTrackerError obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusTrackerErrorT unpack() { - StatusTrackerErrorT _o = new StatusTrackerErrorT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusTrackerErrorT _o) { - solarxr_protocol.datatypes.TrackerIdT[] _oTrackerId = new solarxr_protocol.datatypes.TrackerIdT[trackerIdLength()]; - for (int _j = 0; _j < trackerIdLength(); ++_j) {_oTrackerId[_j] = (trackerId(_j) != null ? trackerId(_j).unpack() : null);} - _o.setTrackerId(_oTrackerId); - } - public static int pack(FlatBufferBuilder builder, StatusTrackerErrorT _o) { - if (_o == null) return 0; - int _trackerId = 0; - if (_o.getTrackerId() != null) { - int[] __trackerId = new int[_o.getTrackerId().length]; - int _j = 0; - for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackerId()) { __trackerId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} - _trackerId = createTrackerIdVector(builder, __trackerId); - } - return createStatusTrackerError( - builder, - _trackerId); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java deleted file mode 100644 index b682e9afe..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusTrackerErrorT { - private solarxr_protocol.datatypes.TrackerIdT[] trackerId; - - public solarxr_protocol.datatypes.TrackerIdT[] getTrackerId() { return trackerId; } - - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT[] trackerId) { this.trackerId = trackerId; } - - - public StatusTrackerErrorT() { - this.trackerId = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java deleted file mode 100644 index 299cd5abc..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Tracker requires full reset - */ -@SuppressWarnings("unused") -public final class StatusTrackerReset extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusTrackerReset getRootAsStatusTrackerReset(ByteBuffer _bb) { return getRootAsStatusTrackerReset(_bb, new StatusTrackerReset()); } - public static StatusTrackerReset getRootAsStatusTrackerReset(ByteBuffer _bb, StatusTrackerReset obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusTrackerReset __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.datatypes.TrackerId trackerId(int j) { return trackerId(new solarxr_protocol.datatypes.TrackerId(), j); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } - public int trackerIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector() { return trackerIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } - public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } - - public static int createStatusTrackerReset(FlatBufferBuilder builder, - int trackerIdOffset) { - builder.startTable(1); - StatusTrackerReset.addTrackerId(builder, trackerIdOffset); - return StatusTrackerReset.endStatusTrackerReset(builder); - } - - public static void startStatusTrackerReset(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } - public static int createTrackerIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startTrackerIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } - public static int endStatusTrackerReset(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusTrackerReset get(int j) { return get(new StatusTrackerReset(), j); } - public StatusTrackerReset get(StatusTrackerReset obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusTrackerResetT unpack() { - StatusTrackerResetT _o = new StatusTrackerResetT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusTrackerResetT _o) { - solarxr_protocol.datatypes.TrackerIdT[] _oTrackerId = new solarxr_protocol.datatypes.TrackerIdT[trackerIdLength()]; - for (int _j = 0; _j < trackerIdLength(); ++_j) {_oTrackerId[_j] = (trackerId(_j) != null ? trackerId(_j).unpack() : null);} - _o.setTrackerId(_oTrackerId); - } - public static int pack(FlatBufferBuilder builder, StatusTrackerResetT _o) { - if (_o == null) return 0; - int _trackerId = 0; - if (_o.getTrackerId() != null) { - int[] __trackerId = new int[_o.getTrackerId().length]; - int _j = 0; - for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackerId()) { __trackerId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} - _trackerId = createTrackerIdVector(builder, __trackerId); - } - return createStatusTrackerReset( - builder, - _trackerId); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java deleted file mode 100644 index 35c5d98bb..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusTrackerResetT { - private solarxr_protocol.datatypes.TrackerIdT[] trackerId; - - public solarxr_protocol.datatypes.TrackerIdT[] getTrackerId() { return trackerId; } - - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT[] trackerId) { this.trackerId = trackerId; } - - - public StatusTrackerResetT() { - this.trackerId = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMD.java b/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMD.java deleted file mode 100644 index a52e648b5..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMD.java +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * There is an available HMD tracker and it's not assigned to head - */ -@SuppressWarnings("unused") -public final class StatusUnassignedHMD extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StatusUnassignedHMD getRootAsStatusUnassignedHMD(ByteBuffer _bb) { return getRootAsStatusUnassignedHMD(_bb, new StatusUnassignedHMD()); } - public static StatusUnassignedHMD getRootAsStatusUnassignedHMD(ByteBuffer _bb, StatusUnassignedHMD obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StatusUnassignedHMD __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createStatusUnassignedHMD(FlatBufferBuilder builder, - int trackerIdOffset) { - builder.startTable(1); - StatusUnassignedHMD.addTrackerId(builder, trackerIdOffset); - return StatusUnassignedHMD.endStatusUnassignedHMD(builder); - } - - public static void startStatusUnassignedHMD(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } - public static int endStatusUnassignedHMD(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StatusUnassignedHMD get(int j) { return get(new StatusUnassignedHMD(), j); } - public StatusUnassignedHMD get(StatusUnassignedHMD obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StatusUnassignedHMDT unpack() { - StatusUnassignedHMDT _o = new StatusUnassignedHMDT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StatusUnassignedHMDT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); - } - public static int pack(FlatBufferBuilder builder, StatusUnassignedHMDT _o) { - if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); - return createStatusUnassignedHMD( - builder, - _trackerId); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMDT.java b/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMDT.java deleted file mode 100644 index ba80aa420..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StatusUnassignedHMDT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class StatusUnassignedHMDT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; - - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } - - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } - - - public StatusUnassignedHMDT() { - this.trackerId = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequest.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequest.java new file mode 100644 index 000000000..079d3a7ff --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequest.java @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class StayAlignedHideCorrectionRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static StayAlignedHideCorrectionRequest getRootAsStayAlignedHideCorrectionRequest(ByteBuffer _bb) { return getRootAsStayAlignedHideCorrectionRequest(_bb, new StayAlignedHideCorrectionRequest()); } + public static StayAlignedHideCorrectionRequest getRootAsStayAlignedHideCorrectionRequest(ByteBuffer _bb, StayAlignedHideCorrectionRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public StayAlignedHideCorrectionRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean hideCorrection() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createStayAlignedHideCorrectionRequest(FlatBufferBuilder builder, + boolean hideCorrection) { + builder.startTable(1); + StayAlignedHideCorrectionRequest.addHideCorrection(builder, hideCorrection); + return StayAlignedHideCorrectionRequest.endStayAlignedHideCorrectionRequest(builder); + } + + public static void startStayAlignedHideCorrectionRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addHideCorrection(FlatBufferBuilder builder, boolean hideCorrection) { builder.addBoolean(0, hideCorrection, false); } + public static int endStayAlignedHideCorrectionRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public StayAlignedHideCorrectionRequest get(int j) { return get(new StayAlignedHideCorrectionRequest(), j); } + public StayAlignedHideCorrectionRequest get(StayAlignedHideCorrectionRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public StayAlignedHideCorrectionRequestT unpack() { + StayAlignedHideCorrectionRequestT _o = new StayAlignedHideCorrectionRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(StayAlignedHideCorrectionRequestT _o) { + boolean _oHideCorrection = hideCorrection(); + _o.setHideCorrection(_oHideCorrection); + } + public static int pack(FlatBufferBuilder builder, StayAlignedHideCorrectionRequestT _o) { + if (_o == null) return 0; + return createStayAlignedHideCorrectionRequest( + builder, + _o.getHideCorrection()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequestT.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequestT.java new file mode 100644 index 000000000..e701f901b --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedHideCorrectionRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class StayAlignedHideCorrectionRequestT { + private boolean hideCorrection; + + public boolean getHideCorrection() { return hideCorrection; } + + public void setHideCorrection(boolean hideCorrection) { this.hideCorrection = hideCorrection; } + + + public StayAlignedHideCorrectionRequestT() { + this.hideCorrection = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettings.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettings.java deleted file mode 100644 index 95fe3f3b7..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettings.java +++ /dev/null @@ -1,161 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class StayAlignedSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static StayAlignedSettings getRootAsStayAlignedSettings(ByteBuffer _bb) { return getRootAsStayAlignedSettings(_bb, new StayAlignedSettings()); } - public static StayAlignedSettings getRootAsStayAlignedSettings(ByteBuffer _bb, StayAlignedSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public StayAlignedSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean extraYawCorrection() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hideYawCorrection() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean standingEnabled() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public float standingUpperLegAngle() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float standingLowerLegAngle() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float standingFootAngle() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public boolean sittingEnabled() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public float sittingUpperLegAngle() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float sittingLowerLegAngle() { int o = __offset(22); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float sittingFootAngle() { int o = __offset(24); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public boolean flatEnabled() { int o = __offset(26); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public float flatUpperLegAngle() { int o = __offset(28); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float flatLowerLegAngle() { int o = __offset(30); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public float flatFootAngle() { int o = __offset(32); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - public boolean setupComplete() { int o = __offset(34); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createStayAlignedSettings(FlatBufferBuilder builder, - boolean enabled, - boolean extraYawCorrection, - boolean hideYawCorrection, - boolean standingEnabled, - float standingUpperLegAngle, - float standingLowerLegAngle, - float standingFootAngle, - boolean sittingEnabled, - float sittingUpperLegAngle, - float sittingLowerLegAngle, - float sittingFootAngle, - boolean flatEnabled, - float flatUpperLegAngle, - float flatLowerLegAngle, - float flatFootAngle, - boolean setupComplete) { - builder.startTable(16); - StayAlignedSettings.addFlatFootAngle(builder, flatFootAngle); - StayAlignedSettings.addFlatLowerLegAngle(builder, flatLowerLegAngle); - StayAlignedSettings.addFlatUpperLegAngle(builder, flatUpperLegAngle); - StayAlignedSettings.addSittingFootAngle(builder, sittingFootAngle); - StayAlignedSettings.addSittingLowerLegAngle(builder, sittingLowerLegAngle); - StayAlignedSettings.addSittingUpperLegAngle(builder, sittingUpperLegAngle); - StayAlignedSettings.addStandingFootAngle(builder, standingFootAngle); - StayAlignedSettings.addStandingLowerLegAngle(builder, standingLowerLegAngle); - StayAlignedSettings.addStandingUpperLegAngle(builder, standingUpperLegAngle); - StayAlignedSettings.addSetupComplete(builder, setupComplete); - StayAlignedSettings.addFlatEnabled(builder, flatEnabled); - StayAlignedSettings.addSittingEnabled(builder, sittingEnabled); - StayAlignedSettings.addStandingEnabled(builder, standingEnabled); - StayAlignedSettings.addHideYawCorrection(builder, hideYawCorrection); - StayAlignedSettings.addExtraYawCorrection(builder, extraYawCorrection); - StayAlignedSettings.addEnabled(builder, enabled); - return StayAlignedSettings.endStayAlignedSettings(builder); - } - - public static void startStayAlignedSettings(FlatBufferBuilder builder) { builder.startTable(16); } - public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } - public static void addExtraYawCorrection(FlatBufferBuilder builder, boolean extraYawCorrection) { builder.addBoolean(1, extraYawCorrection, false); } - public static void addHideYawCorrection(FlatBufferBuilder builder, boolean hideYawCorrection) { builder.addBoolean(2, hideYawCorrection, false); } - public static void addStandingEnabled(FlatBufferBuilder builder, boolean standingEnabled) { builder.addBoolean(3, standingEnabled, false); } - public static void addStandingUpperLegAngle(FlatBufferBuilder builder, float standingUpperLegAngle) { builder.addFloat(4, standingUpperLegAngle, 0.0f); } - public static void addStandingLowerLegAngle(FlatBufferBuilder builder, float standingLowerLegAngle) { builder.addFloat(5, standingLowerLegAngle, 0.0f); } - public static void addStandingFootAngle(FlatBufferBuilder builder, float standingFootAngle) { builder.addFloat(6, standingFootAngle, 0.0f); } - public static void addSittingEnabled(FlatBufferBuilder builder, boolean sittingEnabled) { builder.addBoolean(7, sittingEnabled, false); } - public static void addSittingUpperLegAngle(FlatBufferBuilder builder, float sittingUpperLegAngle) { builder.addFloat(8, sittingUpperLegAngle, 0.0f); } - public static void addSittingLowerLegAngle(FlatBufferBuilder builder, float sittingLowerLegAngle) { builder.addFloat(9, sittingLowerLegAngle, 0.0f); } - public static void addSittingFootAngle(FlatBufferBuilder builder, float sittingFootAngle) { builder.addFloat(10, sittingFootAngle, 0.0f); } - public static void addFlatEnabled(FlatBufferBuilder builder, boolean flatEnabled) { builder.addBoolean(11, flatEnabled, false); } - public static void addFlatUpperLegAngle(FlatBufferBuilder builder, float flatUpperLegAngle) { builder.addFloat(12, flatUpperLegAngle, 0.0f); } - public static void addFlatLowerLegAngle(FlatBufferBuilder builder, float flatLowerLegAngle) { builder.addFloat(13, flatLowerLegAngle, 0.0f); } - public static void addFlatFootAngle(FlatBufferBuilder builder, float flatFootAngle) { builder.addFloat(14, flatFootAngle, 0.0f); } - public static void addSetupComplete(FlatBufferBuilder builder, boolean setupComplete) { builder.addBoolean(15, setupComplete, false); } - public static int endStayAlignedSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public StayAlignedSettings get(int j) { return get(new StayAlignedSettings(), j); } - public StayAlignedSettings get(StayAlignedSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public StayAlignedSettingsT unpack() { - StayAlignedSettingsT _o = new StayAlignedSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(StayAlignedSettingsT _o) { - boolean _oEnabled = enabled(); - _o.setEnabled(_oEnabled); - boolean _oExtraYawCorrection = extraYawCorrection(); - _o.setExtraYawCorrection(_oExtraYawCorrection); - boolean _oHideYawCorrection = hideYawCorrection(); - _o.setHideYawCorrection(_oHideYawCorrection); - boolean _oStandingEnabled = standingEnabled(); - _o.setStandingEnabled(_oStandingEnabled); - float _oStandingUpperLegAngle = standingUpperLegAngle(); - _o.setStandingUpperLegAngle(_oStandingUpperLegAngle); - float _oStandingLowerLegAngle = standingLowerLegAngle(); - _o.setStandingLowerLegAngle(_oStandingLowerLegAngle); - float _oStandingFootAngle = standingFootAngle(); - _o.setStandingFootAngle(_oStandingFootAngle); - boolean _oSittingEnabled = sittingEnabled(); - _o.setSittingEnabled(_oSittingEnabled); - float _oSittingUpperLegAngle = sittingUpperLegAngle(); - _o.setSittingUpperLegAngle(_oSittingUpperLegAngle); - float _oSittingLowerLegAngle = sittingLowerLegAngle(); - _o.setSittingLowerLegAngle(_oSittingLowerLegAngle); - float _oSittingFootAngle = sittingFootAngle(); - _o.setSittingFootAngle(_oSittingFootAngle); - boolean _oFlatEnabled = flatEnabled(); - _o.setFlatEnabled(_oFlatEnabled); - float _oFlatUpperLegAngle = flatUpperLegAngle(); - _o.setFlatUpperLegAngle(_oFlatUpperLegAngle); - float _oFlatLowerLegAngle = flatLowerLegAngle(); - _o.setFlatLowerLegAngle(_oFlatLowerLegAngle); - float _oFlatFootAngle = flatFootAngle(); - _o.setFlatFootAngle(_oFlatFootAngle); - boolean _oSetupComplete = setupComplete(); - _o.setSetupComplete(_oSetupComplete); - } - public static int pack(FlatBufferBuilder builder, StayAlignedSettingsT _o) { - if (_o == null) return 0; - return createStayAlignedSettings( - builder, - _o.getEnabled(), - _o.getExtraYawCorrection(), - _o.getHideYawCorrection(), - _o.getStandingEnabled(), - _o.getStandingUpperLegAngle(), - _o.getStandingLowerLegAngle(), - _o.getStandingFootAngle(), - _o.getSittingEnabled(), - _o.getSittingUpperLegAngle(), - _o.getSittingLowerLegAngle(), - _o.getSittingFootAngle(), - _o.getFlatEnabled(), - _o.getFlatUpperLegAngle(), - _o.getFlatLowerLegAngle(), - _o.getFlatFootAngle(), - _o.getSetupComplete()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequest.java new file mode 100644 index 000000000..3341f634f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class StayAlignedSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static StayAlignedSettingsRequest getRootAsStayAlignedSettingsRequest(ByteBuffer _bb) { return getRootAsStayAlignedSettingsRequest(_bb, new StayAlignedSettingsRequest()); } + public static StayAlignedSettingsRequest getRootAsStayAlignedSettingsRequest(ByteBuffer _bb, StayAlignedSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public StayAlignedSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startStayAlignedSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endStayAlignedSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public StayAlignedSettingsRequest get(int j) { return get(new StayAlignedSettingsRequest(), j); } + public StayAlignedSettingsRequest get(StayAlignedSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public StayAlignedSettingsRequestT unpack() { + StayAlignedSettingsRequestT _o = new StayAlignedSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(StayAlignedSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, StayAlignedSettingsRequestT _o) { + if (_o == null) return 0; + startStayAlignedSettingsRequest(builder); + return endStayAlignedSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequestT.java new file mode 100644 index 000000000..febfeeed6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class StayAlignedSettingsRequestT { + + + public StayAlignedSettingsRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponse.java new file mode 100644 index 000000000..56908b5ce --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponse.java @@ -0,0 +1,140 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class StayAlignedSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static StayAlignedSettingsResponse getRootAsStayAlignedSettingsResponse(ByteBuffer _bb) { return getRootAsStayAlignedSettingsResponse(_bb, new StayAlignedSettingsResponse()); } + public static StayAlignedSettingsResponse getRootAsStayAlignedSettingsResponse(ByteBuffer _bb, StayAlignedSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public StayAlignedSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean standingEnabled() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float standingUpperLegAngle() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float standingLowerLegAngle() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float standingFootAngle() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean sittingEnabled() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float sittingUpperLegAngle() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float sittingLowerLegAngle() { int o = __offset(18); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float sittingFootAngle() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean flatEnabled() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public float flatUpperLegAngle() { int o = __offset(24); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float flatLowerLegAngle() { int o = __offset(26); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float flatFootAngle() { int o = __offset(28); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + + public static int createStayAlignedSettingsResponse(FlatBufferBuilder builder, + boolean enabled, + boolean standingEnabled, + float standingUpperLegAngle, + float standingLowerLegAngle, + float standingFootAngle, + boolean sittingEnabled, + float sittingUpperLegAngle, + float sittingLowerLegAngle, + float sittingFootAngle, + boolean flatEnabled, + float flatUpperLegAngle, + float flatLowerLegAngle, + float flatFootAngle) { + builder.startTable(13); + StayAlignedSettingsResponse.addFlatFootAngle(builder, flatFootAngle); + StayAlignedSettingsResponse.addFlatLowerLegAngle(builder, flatLowerLegAngle); + StayAlignedSettingsResponse.addFlatUpperLegAngle(builder, flatUpperLegAngle); + StayAlignedSettingsResponse.addSittingFootAngle(builder, sittingFootAngle); + StayAlignedSettingsResponse.addSittingLowerLegAngle(builder, sittingLowerLegAngle); + StayAlignedSettingsResponse.addSittingUpperLegAngle(builder, sittingUpperLegAngle); + StayAlignedSettingsResponse.addStandingFootAngle(builder, standingFootAngle); + StayAlignedSettingsResponse.addStandingLowerLegAngle(builder, standingLowerLegAngle); + StayAlignedSettingsResponse.addStandingUpperLegAngle(builder, standingUpperLegAngle); + StayAlignedSettingsResponse.addFlatEnabled(builder, flatEnabled); + StayAlignedSettingsResponse.addSittingEnabled(builder, sittingEnabled); + StayAlignedSettingsResponse.addStandingEnabled(builder, standingEnabled); + StayAlignedSettingsResponse.addEnabled(builder, enabled); + return StayAlignedSettingsResponse.endStayAlignedSettingsResponse(builder); + } + + public static void startStayAlignedSettingsResponse(FlatBufferBuilder builder) { builder.startTable(13); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addStandingEnabled(FlatBufferBuilder builder, boolean standingEnabled) { builder.addBoolean(1, standingEnabled, false); } + public static void addStandingUpperLegAngle(FlatBufferBuilder builder, float standingUpperLegAngle) { builder.addFloat(2, standingUpperLegAngle, 0.0f); } + public static void addStandingLowerLegAngle(FlatBufferBuilder builder, float standingLowerLegAngle) { builder.addFloat(3, standingLowerLegAngle, 0.0f); } + public static void addStandingFootAngle(FlatBufferBuilder builder, float standingFootAngle) { builder.addFloat(4, standingFootAngle, 0.0f); } + public static void addSittingEnabled(FlatBufferBuilder builder, boolean sittingEnabled) { builder.addBoolean(5, sittingEnabled, false); } + public static void addSittingUpperLegAngle(FlatBufferBuilder builder, float sittingUpperLegAngle) { builder.addFloat(6, sittingUpperLegAngle, 0.0f); } + public static void addSittingLowerLegAngle(FlatBufferBuilder builder, float sittingLowerLegAngle) { builder.addFloat(7, sittingLowerLegAngle, 0.0f); } + public static void addSittingFootAngle(FlatBufferBuilder builder, float sittingFootAngle) { builder.addFloat(8, sittingFootAngle, 0.0f); } + public static void addFlatEnabled(FlatBufferBuilder builder, boolean flatEnabled) { builder.addBoolean(9, flatEnabled, false); } + public static void addFlatUpperLegAngle(FlatBufferBuilder builder, float flatUpperLegAngle) { builder.addFloat(10, flatUpperLegAngle, 0.0f); } + public static void addFlatLowerLegAngle(FlatBufferBuilder builder, float flatLowerLegAngle) { builder.addFloat(11, flatLowerLegAngle, 0.0f); } + public static void addFlatFootAngle(FlatBufferBuilder builder, float flatFootAngle) { builder.addFloat(12, flatFootAngle, 0.0f); } + public static int endStayAlignedSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public StayAlignedSettingsResponse get(int j) { return get(new StayAlignedSettingsResponse(), j); } + public StayAlignedSettingsResponse get(StayAlignedSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public StayAlignedSettingsResponseT unpack() { + StayAlignedSettingsResponseT _o = new StayAlignedSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(StayAlignedSettingsResponseT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + boolean _oStandingEnabled = standingEnabled(); + _o.setStandingEnabled(_oStandingEnabled); + float _oStandingUpperLegAngle = standingUpperLegAngle(); + _o.setStandingUpperLegAngle(_oStandingUpperLegAngle); + float _oStandingLowerLegAngle = standingLowerLegAngle(); + _o.setStandingLowerLegAngle(_oStandingLowerLegAngle); + float _oStandingFootAngle = standingFootAngle(); + _o.setStandingFootAngle(_oStandingFootAngle); + boolean _oSittingEnabled = sittingEnabled(); + _o.setSittingEnabled(_oSittingEnabled); + float _oSittingUpperLegAngle = sittingUpperLegAngle(); + _o.setSittingUpperLegAngle(_oSittingUpperLegAngle); + float _oSittingLowerLegAngle = sittingLowerLegAngle(); + _o.setSittingLowerLegAngle(_oSittingLowerLegAngle); + float _oSittingFootAngle = sittingFootAngle(); + _o.setSittingFootAngle(_oSittingFootAngle); + boolean _oFlatEnabled = flatEnabled(); + _o.setFlatEnabled(_oFlatEnabled); + float _oFlatUpperLegAngle = flatUpperLegAngle(); + _o.setFlatUpperLegAngle(_oFlatUpperLegAngle); + float _oFlatLowerLegAngle = flatLowerLegAngle(); + _o.setFlatLowerLegAngle(_oFlatLowerLegAngle); + float _oFlatFootAngle = flatFootAngle(); + _o.setFlatFootAngle(_oFlatFootAngle); + } + public static int pack(FlatBufferBuilder builder, StayAlignedSettingsResponseT _o) { + if (_o == null) return 0; + return createStayAlignedSettingsResponse( + builder, + _o.getEnabled(), + _o.getStandingEnabled(), + _o.getStandingUpperLegAngle(), + _o.getStandingLowerLegAngle(), + _o.getStandingFootAngle(), + _o.getSittingEnabled(), + _o.getSittingUpperLegAngle(), + _o.getSittingLowerLegAngle(), + _o.getSittingFootAngle(), + _o.getFlatEnabled(), + _o.getFlatUpperLegAngle(), + _o.getFlatLowerLegAngle(), + _o.getFlatFootAngle()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponseT.java new file mode 100644 index 000000000..dd768315a --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StayAlignedSettingsResponseT.java @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class StayAlignedSettingsResponseT { + private boolean enabled; + private boolean standingEnabled; + private float standingUpperLegAngle; + private float standingLowerLegAngle; + private float standingFootAngle; + private boolean sittingEnabled; + private float sittingUpperLegAngle; + private float sittingLowerLegAngle; + private float sittingFootAngle; + private boolean flatEnabled; + private float flatUpperLegAngle; + private float flatLowerLegAngle; + private float flatFootAngle; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public boolean getStandingEnabled() { return standingEnabled; } + + public void setStandingEnabled(boolean standingEnabled) { this.standingEnabled = standingEnabled; } + + public float getStandingUpperLegAngle() { return standingUpperLegAngle; } + + public void setStandingUpperLegAngle(float standingUpperLegAngle) { this.standingUpperLegAngle = standingUpperLegAngle; } + + public float getStandingLowerLegAngle() { return standingLowerLegAngle; } + + public void setStandingLowerLegAngle(float standingLowerLegAngle) { this.standingLowerLegAngle = standingLowerLegAngle; } + + public float getStandingFootAngle() { return standingFootAngle; } + + public void setStandingFootAngle(float standingFootAngle) { this.standingFootAngle = standingFootAngle; } + + public boolean getSittingEnabled() { return sittingEnabled; } + + public void setSittingEnabled(boolean sittingEnabled) { this.sittingEnabled = sittingEnabled; } + + public float getSittingUpperLegAngle() { return sittingUpperLegAngle; } + + public void setSittingUpperLegAngle(float sittingUpperLegAngle) { this.sittingUpperLegAngle = sittingUpperLegAngle; } + + public float getSittingLowerLegAngle() { return sittingLowerLegAngle; } + + public void setSittingLowerLegAngle(float sittingLowerLegAngle) { this.sittingLowerLegAngle = sittingLowerLegAngle; } + + public float getSittingFootAngle() { return sittingFootAngle; } + + public void setSittingFootAngle(float sittingFootAngle) { this.sittingFootAngle = sittingFootAngle; } + + public boolean getFlatEnabled() { return flatEnabled; } + + public void setFlatEnabled(boolean flatEnabled) { this.flatEnabled = flatEnabled; } + + public float getFlatUpperLegAngle() { return flatUpperLegAngle; } + + public void setFlatUpperLegAngle(float flatUpperLegAngle) { this.flatUpperLegAngle = flatUpperLegAngle; } + + public float getFlatLowerLegAngle() { return flatLowerLegAngle; } + + public void setFlatLowerLegAngle(float flatLowerLegAngle) { this.flatLowerLegAngle = flatLowerLegAngle; } + + public float getFlatFootAngle() { return flatFootAngle; } + + public void setFlatFootAngle(float flatFootAngle) { this.flatFootAngle = flatFootAngle; } + + + public StayAlignedSettingsResponseT() { + this.enabled = false; + this.standingEnabled = false; + this.standingUpperLegAngle = 0.0f; + this.standingLowerLegAngle = 0.0f; + this.standingFootAngle = 0.0f; + this.sittingEnabled = false; + this.sittingUpperLegAngle = 0.0f; + this.sittingLowerLegAngle = 0.0f; + this.sittingFootAngle = 0.0f; + this.flatEnabled = false; + this.flatUpperLegAngle = 0.0f; + this.flatLowerLegAngle = 0.0f; + this.flatFootAngle = 0.0f; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSetting.java b/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSetting.java deleted file mode 100644 index 385d530f7..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSetting.java +++ /dev/null @@ -1,126 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class SteamVRTrackersSetting extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static SteamVRTrackersSetting getRootAsSteamVRTrackersSetting(ByteBuffer _bb) { return getRootAsSteamVRTrackersSetting(_bb, new SteamVRTrackersSetting()); } - public static SteamVRTrackersSetting getRootAsSteamVRTrackersSetting(ByteBuffer _bb, SteamVRTrackersSetting obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public SteamVRTrackersSetting __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean waist() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean chest() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean automaticTrackerToggle() { int o = __offset(16); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean leftFoot() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean rightFoot() { int o = __offset(20); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean leftKnee() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean rightKnee() { int o = __offset(24); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean leftElbow() { int o = __offset(26); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean rightElbow() { int o = __offset(28); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean leftHand() { int o = __offset(30); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean rightHand() { int o = __offset(32); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createSteamVRTrackersSetting(FlatBufferBuilder builder, - boolean waist, - boolean chest, - boolean automaticTrackerToggle, - boolean leftFoot, - boolean rightFoot, - boolean leftKnee, - boolean rightKnee, - boolean leftElbow, - boolean rightElbow, - boolean leftHand, - boolean rightHand) { - builder.startTable(15); - SteamVRTrackersSetting.addRightHand(builder, rightHand); - SteamVRTrackersSetting.addLeftHand(builder, leftHand); - SteamVRTrackersSetting.addRightElbow(builder, rightElbow); - SteamVRTrackersSetting.addLeftElbow(builder, leftElbow); - SteamVRTrackersSetting.addRightKnee(builder, rightKnee); - SteamVRTrackersSetting.addLeftKnee(builder, leftKnee); - SteamVRTrackersSetting.addRightFoot(builder, rightFoot); - SteamVRTrackersSetting.addLeftFoot(builder, leftFoot); - SteamVRTrackersSetting.addAutomaticTrackerToggle(builder, automaticTrackerToggle); - SteamVRTrackersSetting.addChest(builder, chest); - SteamVRTrackersSetting.addWaist(builder, waist); - return SteamVRTrackersSetting.endSteamVRTrackersSetting(builder); - } - - public static void startSteamVRTrackersSetting(FlatBufferBuilder builder) { builder.startTable(15); } - public static void addWaist(FlatBufferBuilder builder, boolean waist) { builder.addBoolean(0, waist, false); } - public static void addChest(FlatBufferBuilder builder, boolean chest) { builder.addBoolean(1, chest, false); } - public static void addAutomaticTrackerToggle(FlatBufferBuilder builder, boolean automaticTrackerToggle) { builder.addBoolean(6, automaticTrackerToggle, false); } - public static void addLeftFoot(FlatBufferBuilder builder, boolean leftFoot) { builder.addBoolean(7, leftFoot, false); } - public static void addRightFoot(FlatBufferBuilder builder, boolean rightFoot) { builder.addBoolean(8, rightFoot, false); } - public static void addLeftKnee(FlatBufferBuilder builder, boolean leftKnee) { builder.addBoolean(9, leftKnee, false); } - public static void addRightKnee(FlatBufferBuilder builder, boolean rightKnee) { builder.addBoolean(10, rightKnee, false); } - public static void addLeftElbow(FlatBufferBuilder builder, boolean leftElbow) { builder.addBoolean(11, leftElbow, false); } - public static void addRightElbow(FlatBufferBuilder builder, boolean rightElbow) { builder.addBoolean(12, rightElbow, false); } - public static void addLeftHand(FlatBufferBuilder builder, boolean leftHand) { builder.addBoolean(13, leftHand, false); } - public static void addRightHand(FlatBufferBuilder builder, boolean rightHand) { builder.addBoolean(14, rightHand, false); } - public static int endSteamVRTrackersSetting(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public SteamVRTrackersSetting get(int j) { return get(new SteamVRTrackersSetting(), j); } - public SteamVRTrackersSetting get(SteamVRTrackersSetting obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public SteamVRTrackersSettingT unpack() { - SteamVRTrackersSettingT _o = new SteamVRTrackersSettingT(); - unpackTo(_o); - return _o; - } - public void unpackTo(SteamVRTrackersSettingT _o) { - boolean _oWaist = waist(); - _o.setWaist(_oWaist); - boolean _oChest = chest(); - _o.setChest(_oChest); - boolean _oAutomaticTrackerToggle = automaticTrackerToggle(); - _o.setAutomaticTrackerToggle(_oAutomaticTrackerToggle); - boolean _oLeftFoot = leftFoot(); - _o.setLeftFoot(_oLeftFoot); - boolean _oRightFoot = rightFoot(); - _o.setRightFoot(_oRightFoot); - boolean _oLeftKnee = leftKnee(); - _o.setLeftKnee(_oLeftKnee); - boolean _oRightKnee = rightKnee(); - _o.setRightKnee(_oRightKnee); - boolean _oLeftElbow = leftElbow(); - _o.setLeftElbow(_oLeftElbow); - boolean _oRightElbow = rightElbow(); - _o.setRightElbow(_oRightElbow); - boolean _oLeftHand = leftHand(); - _o.setLeftHand(_oLeftHand); - boolean _oRightHand = rightHand(); - _o.setRightHand(_oRightHand); - } - public static int pack(FlatBufferBuilder builder, SteamVRTrackersSettingT _o) { - if (_o == null) return 0; - return createSteamVRTrackersSetting( - builder, - _o.getWaist(), - _o.getChest(), - _o.getAutomaticTrackerToggle(), - _o.getLeftFoot(), - _o.getRightFoot(), - _o.getLeftKnee(), - _o.getRightKnee(), - _o.getLeftElbow(), - _o.getRightElbow(), - _o.getLeftHand(), - _o.getRightHand()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSettingT.java b/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSettingT.java deleted file mode 100644 index ba1155a21..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/SteamVRTrackersSettingT.java +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class SteamVRTrackersSettingT { - private boolean waist; - private boolean chest; - private boolean automaticTrackerToggle; - private boolean leftFoot; - private boolean rightFoot; - private boolean leftKnee; - private boolean rightKnee; - private boolean leftElbow; - private boolean rightElbow; - private boolean leftHand; - private boolean rightHand; - - public boolean getWaist() { return waist; } - - public void setWaist(boolean waist) { this.waist = waist; } - - public boolean getChest() { return chest; } - - public void setChest(boolean chest) { this.chest = chest; } - - public boolean getAutomaticTrackerToggle() { return automaticTrackerToggle; } - - public void setAutomaticTrackerToggle(boolean automaticTrackerToggle) { this.automaticTrackerToggle = automaticTrackerToggle; } - - public boolean getLeftFoot() { return leftFoot; } - - public void setLeftFoot(boolean leftFoot) { this.leftFoot = leftFoot; } - - public boolean getRightFoot() { return rightFoot; } - - public void setRightFoot(boolean rightFoot) { this.rightFoot = rightFoot; } - - public boolean getLeftKnee() { return leftKnee; } - - public void setLeftKnee(boolean leftKnee) { this.leftKnee = leftKnee; } - - public boolean getRightKnee() { return rightKnee; } - - public void setRightKnee(boolean rightKnee) { this.rightKnee = rightKnee; } - - public boolean getLeftElbow() { return leftElbow; } - - public void setLeftElbow(boolean leftElbow) { this.leftElbow = leftElbow; } - - public boolean getRightElbow() { return rightElbow; } - - public void setRightElbow(boolean rightElbow) { this.rightElbow = rightElbow; } - - public boolean getLeftHand() { return leftHand; } - - public void setLeftHand(boolean leftHand) { this.leftHand = leftHand; } - - public boolean getRightHand() { return rightHand; } - - public void setRightHand(boolean rightHand) { this.rightHand = rightHand; } - - - public SteamVRTrackersSettingT() { - this.waist = false; - this.chest = false; - this.automaticTrackerToggle = false; - this.leftFoot = false; - this.rightFoot = false; - this.leftKnee = false; - this.rightKnee = false; - this.leftElbow = false; - this.rightElbow = false; - this.leftHand = false; - this.rightHand = false; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequest.java new file mode 100644 index 000000000..d500d56f5 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TapDetectionSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TapDetectionSettingsRequest getRootAsTapDetectionSettingsRequest(ByteBuffer _bb) { return getRootAsTapDetectionSettingsRequest(_bb, new TapDetectionSettingsRequest()); } + public static TapDetectionSettingsRequest getRootAsTapDetectionSettingsRequest(ByteBuffer _bb, TapDetectionSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public TapDetectionSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startTapDetectionSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endTapDetectionSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public TapDetectionSettingsRequest get(int j) { return get(new TapDetectionSettingsRequest(), j); } + public TapDetectionSettingsRequest get(TapDetectionSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TapDetectionSettingsRequestT unpack() { + TapDetectionSettingsRequestT _o = new TapDetectionSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TapDetectionSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, TapDetectionSettingsRequestT _o) { + if (_o == null) return 0; + startTapDetectionSettingsRequest(builder); + return endTapDetectionSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequestT.java new file mode 100644 index 000000000..47567f3f4 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class TapDetectionSettingsRequestT { + + + public TapDetectionSettingsRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettings.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponse.java similarity index 66% rename from protocol/java/src/solarxr_protocol/rpc/TapDetectionSettings.java rename to protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponse.java index 041b30682..aeb4bc6f7 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettings.java +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponse.java @@ -8,12 +8,12 @@ import com.google.flatbuffers.*; @SuppressWarnings("unused") -public final class TapDetectionSettings extends Table { +public final class TapDetectionSettingsResponse extends Table { public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TapDetectionSettings getRootAsTapDetectionSettings(ByteBuffer _bb) { return getRootAsTapDetectionSettings(_bb, new TapDetectionSettings()); } - public static TapDetectionSettings getRootAsTapDetectionSettings(ByteBuffer _bb, TapDetectionSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public static TapDetectionSettingsResponse getRootAsTapDetectionSettingsResponse(ByteBuffer _bb) { return getRootAsTapDetectionSettingsResponse(_bb, new TapDetectionSettingsResponse()); } + public static TapDetectionSettingsResponse getRootAsTapDetectionSettingsResponse(ByteBuffer _bb, TapDetectionSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TapDetectionSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + public TapDetectionSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } public boolean hasFullResetDelay() { return 0 != __offset(4); } public float fullResetDelay() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } @@ -33,22 +33,16 @@ public final class TapDetectionSettings extends Table { public boolean mountingResetEnabled() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean hasMountingResetTaps() { return 0 != __offset(20); } public int mountingResetTaps() { int o = __offset(20); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - /** - * If true, disables reset behavior of tap detection and sends a - * TapDetectionSetupNotification, each time 2 taps are detected on any tracker - */ - public boolean hasSetupMode() { return 0 != __offset(22); } - public boolean setupMode() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasNumberTrackersOverThreshold() { return 0 != __offset(24); } - public int numberTrackersOverThreshold() { int o = __offset(24); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public boolean hasYawResetTracker() { return 0 != __offset(26); } - public int yawResetTracker() { int o = __offset(26); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public boolean hasFullResetTracker() { return 0 != __offset(28); } - public int fullResetTracker() { int o = __offset(28); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public boolean hasMountingResetTracker() { return 0 != __offset(30); } - public int mountingResetTracker() { int o = __offset(30); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasNumberTrackersOverThreshold() { return 0 != __offset(22); } + public int numberTrackersOverThreshold() { int o = __offset(22); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasYawResetTracker() { return 0 != __offset(24); } + public int yawResetTracker() { int o = __offset(24); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasFullResetTracker() { return 0 != __offset(26); } + public int fullResetTracker() { int o = __offset(26); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasMountingResetTracker() { return 0 != __offset(28); } + public int mountingResetTracker() { int o = __offset(28); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } - public static int createTapDetectionSettings(FlatBufferBuilder builder, + public static int createTapDetectionSettingsResponse(FlatBufferBuilder builder, float fullResetDelay, boolean fullResetEnabled, int fullResetTaps, @@ -58,30 +52,28 @@ public static int createTapDetectionSettings(FlatBufferBuilder builder, float mountingResetDelay, boolean mountingResetEnabled, int mountingResetTaps, - boolean setupMode, int numberTrackersOverThreshold, int yawResetTracker, int fullResetTracker, int mountingResetTracker) { - builder.startTable(14); - TapDetectionSettings.addMountingResetDelay(builder, mountingResetDelay); - TapDetectionSettings.addYawResetDelay(builder, yawResetDelay); - TapDetectionSettings.addFullResetDelay(builder, fullResetDelay); - TapDetectionSettings.addMountingResetTracker(builder, mountingResetTracker); - TapDetectionSettings.addFullResetTracker(builder, fullResetTracker); - TapDetectionSettings.addYawResetTracker(builder, yawResetTracker); - TapDetectionSettings.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); - TapDetectionSettings.addSetupMode(builder, setupMode); - TapDetectionSettings.addMountingResetTaps(builder, mountingResetTaps); - TapDetectionSettings.addMountingResetEnabled(builder, mountingResetEnabled); - TapDetectionSettings.addYawResetTaps(builder, yawResetTaps); - TapDetectionSettings.addYawResetEnabled(builder, yawResetEnabled); - TapDetectionSettings.addFullResetTaps(builder, fullResetTaps); - TapDetectionSettings.addFullResetEnabled(builder, fullResetEnabled); - return TapDetectionSettings.endTapDetectionSettings(builder); + builder.startTable(13); + TapDetectionSettingsResponse.addMountingResetDelay(builder, mountingResetDelay); + TapDetectionSettingsResponse.addYawResetDelay(builder, yawResetDelay); + TapDetectionSettingsResponse.addFullResetDelay(builder, fullResetDelay); + TapDetectionSettingsResponse.addMountingResetTracker(builder, mountingResetTracker); + TapDetectionSettingsResponse.addFullResetTracker(builder, fullResetTracker); + TapDetectionSettingsResponse.addYawResetTracker(builder, yawResetTracker); + TapDetectionSettingsResponse.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); + TapDetectionSettingsResponse.addMountingResetTaps(builder, mountingResetTaps); + TapDetectionSettingsResponse.addMountingResetEnabled(builder, mountingResetEnabled); + TapDetectionSettingsResponse.addYawResetTaps(builder, yawResetTaps); + TapDetectionSettingsResponse.addYawResetEnabled(builder, yawResetEnabled); + TapDetectionSettingsResponse.addFullResetTaps(builder, fullResetTaps); + TapDetectionSettingsResponse.addFullResetEnabled(builder, fullResetEnabled); + return TapDetectionSettingsResponse.endTapDetectionSettingsResponse(builder); } - public static void startTapDetectionSettings(FlatBufferBuilder builder) { builder.startTable(14); } + public static void startTapDetectionSettingsResponse(FlatBufferBuilder builder) { builder.startTable(13); } public static void addFullResetDelay(FlatBufferBuilder builder, float fullResetDelay) { builder.addFloat(0, fullResetDelay, 0f); } public static void addFullResetEnabled(FlatBufferBuilder builder, boolean fullResetEnabled) { builder.addBoolean(1, fullResetEnabled, false); } public static void addFullResetTaps(FlatBufferBuilder builder, int fullResetTaps) { builder.addByte(2, (byte) fullResetTaps, (byte) 0); } @@ -91,12 +83,11 @@ public static int createTapDetectionSettings(FlatBufferBuilder builder, public static void addMountingResetDelay(FlatBufferBuilder builder, float mountingResetDelay) { builder.addFloat(6, mountingResetDelay, 0f); } public static void addMountingResetEnabled(FlatBufferBuilder builder, boolean mountingResetEnabled) { builder.addBoolean(7, mountingResetEnabled, false); } public static void addMountingResetTaps(FlatBufferBuilder builder, int mountingResetTaps) { builder.addByte(8, (byte) mountingResetTaps, (byte) 0); } - public static void addSetupMode(FlatBufferBuilder builder, boolean setupMode) { builder.addBoolean(9, setupMode, false); } - public static void addNumberTrackersOverThreshold(FlatBufferBuilder builder, int numberTrackersOverThreshold) { builder.addByte(10, (byte) numberTrackersOverThreshold, (byte) 0); } - public static void addYawResetTracker(FlatBufferBuilder builder, int yawResetTracker) { builder.addByte(11, (byte) yawResetTracker, (byte) 0); } - public static void addFullResetTracker(FlatBufferBuilder builder, int fullResetTracker) { builder.addByte(12, (byte) fullResetTracker, (byte) 0); } - public static void addMountingResetTracker(FlatBufferBuilder builder, int mountingResetTracker) { builder.addByte(13, (byte) mountingResetTracker, (byte) 0); } - public static int endTapDetectionSettings(FlatBufferBuilder builder) { + public static void addNumberTrackersOverThreshold(FlatBufferBuilder builder, int numberTrackersOverThreshold) { builder.addByte(9, (byte) numberTrackersOverThreshold, (byte) 0); } + public static void addYawResetTracker(FlatBufferBuilder builder, int yawResetTracker) { builder.addByte(10, (byte) yawResetTracker, (byte) 0); } + public static void addFullResetTracker(FlatBufferBuilder builder, int fullResetTracker) { builder.addByte(11, (byte) fullResetTracker, (byte) 0); } + public static void addMountingResetTracker(FlatBufferBuilder builder, int mountingResetTracker) { builder.addByte(12, (byte) mountingResetTracker, (byte) 0); } + public static int endTapDetectionSettingsResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; } @@ -104,15 +95,15 @@ public static int endTapDetectionSettings(FlatBufferBuilder builder) { public static final class Vector extends BaseVector { public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - public TapDetectionSettings get(int j) { return get(new TapDetectionSettings(), j); } - public TapDetectionSettings get(TapDetectionSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + public TapDetectionSettingsResponse get(int j) { return get(new TapDetectionSettingsResponse(), j); } + public TapDetectionSettingsResponse get(TapDetectionSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } } - public TapDetectionSettingsT unpack() { - TapDetectionSettingsT _o = new TapDetectionSettingsT(); + public TapDetectionSettingsResponseT unpack() { + TapDetectionSettingsResponseT _o = new TapDetectionSettingsResponseT(); unpackTo(_o); return _o; } - public void unpackTo(TapDetectionSettingsT _o) { + public void unpackTo(TapDetectionSettingsResponseT _o) { Float _oFullResetDelay = hasFullResetDelay() ? fullResetDelay() : null; _o.setFullResetDelay(_oFullResetDelay); Boolean _oFullResetEnabled = hasFullResetEnabled() ? fullResetEnabled() : null; @@ -131,8 +122,6 @@ public void unpackTo(TapDetectionSettingsT _o) { _o.setMountingResetEnabled(_oMountingResetEnabled); Integer _oMountingResetTaps = hasMountingResetTaps() ? mountingResetTaps() : null; _o.setMountingResetTaps(_oMountingResetTaps); - Boolean _oSetupMode = hasSetupMode() ? setupMode() : null; - _o.setSetupMode(_oSetupMode); Integer _oNumberTrackersOverThreshold = hasNumberTrackersOverThreshold() ? numberTrackersOverThreshold() : null; _o.setNumberTrackersOverThreshold(_oNumberTrackersOverThreshold); Integer _oYawResetTracker = hasYawResetTracker() ? yawResetTracker() : null; @@ -142,9 +131,9 @@ public void unpackTo(TapDetectionSettingsT _o) { Integer _oMountingResetTracker = hasMountingResetTracker() ? mountingResetTracker() : null; _o.setMountingResetTracker(_oMountingResetTracker); } - public static int pack(FlatBufferBuilder builder, TapDetectionSettingsT _o) { + public static int pack(FlatBufferBuilder builder, TapDetectionSettingsResponseT _o) { if (_o == null) return 0; - return createTapDetectionSettings( + return createTapDetectionSettingsResponse( builder, _o.getFullResetDelay(), _o.getFullResetEnabled(), @@ -155,7 +144,6 @@ public static int pack(FlatBufferBuilder builder, TapDetectionSettingsT _o) { _o.getMountingResetDelay(), _o.getMountingResetEnabled(), _o.getMountingResetTaps(), - _o.getSetupMode(), _o.getNumberTrackersOverThreshold(), _o.getYawResetTracker(), _o.getFullResetTracker(), diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponseT.java new file mode 100644 index 000000000..3afbc17e6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSettingsResponseT.java @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class TapDetectionSettingsResponseT { + private Float fullResetDelay; + private Boolean fullResetEnabled; + private Integer fullResetTaps; + private Float yawResetDelay; + private Boolean yawResetEnabled; + private Integer yawResetTaps; + private Float mountingResetDelay; + private Boolean mountingResetEnabled; + private Integer mountingResetTaps; + private Integer numberTrackersOverThreshold; + private Integer yawResetTracker; + private Integer fullResetTracker; + private Integer mountingResetTracker; + + public Float getFullResetDelay() { return fullResetDelay; } + + public void setFullResetDelay(Float fullResetDelay) { this.fullResetDelay = fullResetDelay; } + + public Boolean getFullResetEnabled() { return fullResetEnabled; } + + public void setFullResetEnabled(Boolean fullResetEnabled) { this.fullResetEnabled = fullResetEnabled; } + + public Integer getFullResetTaps() { return fullResetTaps; } + + public void setFullResetTaps(Integer fullResetTaps) { this.fullResetTaps = fullResetTaps; } + + public Float getYawResetDelay() { return yawResetDelay; } + + public void setYawResetDelay(Float yawResetDelay) { this.yawResetDelay = yawResetDelay; } + + public Boolean getYawResetEnabled() { return yawResetEnabled; } + + public void setYawResetEnabled(Boolean yawResetEnabled) { this.yawResetEnabled = yawResetEnabled; } + + public Integer getYawResetTaps() { return yawResetTaps; } + + public void setYawResetTaps(Integer yawResetTaps) { this.yawResetTaps = yawResetTaps; } + + public Float getMountingResetDelay() { return mountingResetDelay; } + + public void setMountingResetDelay(Float mountingResetDelay) { this.mountingResetDelay = mountingResetDelay; } + + public Boolean getMountingResetEnabled() { return mountingResetEnabled; } + + public void setMountingResetEnabled(Boolean mountingResetEnabled) { this.mountingResetEnabled = mountingResetEnabled; } + + public Integer getMountingResetTaps() { return mountingResetTaps; } + + public void setMountingResetTaps(Integer mountingResetTaps) { this.mountingResetTaps = mountingResetTaps; } + + public Integer getNumberTrackersOverThreshold() { return numberTrackersOverThreshold; } + + public void setNumberTrackersOverThreshold(Integer numberTrackersOverThreshold) { this.numberTrackersOverThreshold = numberTrackersOverThreshold; } + + public Integer getYawResetTracker() { return yawResetTracker; } + + public void setYawResetTracker(Integer yawResetTracker) { this.yawResetTracker = yawResetTracker; } + + public Integer getFullResetTracker() { return fullResetTracker; } + + public void setFullResetTracker(Integer fullResetTracker) { this.fullResetTracker = fullResetTracker; } + + public Integer getMountingResetTracker() { return mountingResetTracker; } + + public void setMountingResetTracker(Integer mountingResetTracker) { this.mountingResetTracker = mountingResetTracker; } + + + public TapDetectionSettingsResponseT() { + this.fullResetDelay = null; + this.fullResetEnabled = null; + this.fullResetTaps = null; + this.yawResetDelay = null; + this.yawResetEnabled = null; + this.yawResetTaps = null; + this.mountingResetDelay = null; + this.mountingResetEnabled = null; + this.mountingResetTaps = null; + this.numberTrackersOverThreshold = null; + this.yawResetTracker = null; + this.fullResetTracker = null; + this.mountingResetTracker = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequest.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequest.java new file mode 100644 index 000000000..731dad4a6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequest.java @@ -0,0 +1,63 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Sets the TapDetection setup mode. + */ +@SuppressWarnings("unused") +public final class TapDetectionSetupModeRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TapDetectionSetupModeRequest getRootAsTapDetectionSetupModeRequest(ByteBuffer _bb) { return getRootAsTapDetectionSetupModeRequest(_bb, new TapDetectionSetupModeRequest()); } + public static TapDetectionSetupModeRequest getRootAsTapDetectionSetupModeRequest(ByteBuffer _bb, TapDetectionSetupModeRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public TapDetectionSetupModeRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + /** + * When true, TapDetection triggering a tracker will assign it instead of doing a reset. + */ + public boolean hasSetupMode() { return 0 != __offset(4); } + public boolean setupMode() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createTapDetectionSetupModeRequest(FlatBufferBuilder builder, + boolean setupMode) { + builder.startTable(1); + TapDetectionSetupModeRequest.addSetupMode(builder, setupMode); + return TapDetectionSetupModeRequest.endTapDetectionSetupModeRequest(builder); + } + + public static void startTapDetectionSetupModeRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addSetupMode(FlatBufferBuilder builder, boolean setupMode) { builder.addBoolean(0, setupMode, false); } + public static int endTapDetectionSetupModeRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public TapDetectionSetupModeRequest get(int j) { return get(new TapDetectionSetupModeRequest(), j); } + public TapDetectionSetupModeRequest get(TapDetectionSetupModeRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TapDetectionSetupModeRequestT unpack() { + TapDetectionSetupModeRequestT _o = new TapDetectionSetupModeRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TapDetectionSetupModeRequestT _o) { + Boolean _oSetupMode = hasSetupMode() ? setupMode() : null; + _o.setSetupMode(_oSetupMode); + } + public static int pack(FlatBufferBuilder builder, TapDetectionSetupModeRequestT _o) { + if (_o == null) return 0; + return createTapDetectionSetupModeRequest( + builder, + _o.getSetupMode()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequestT.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequestT.java new file mode 100644 index 000000000..e76b0bd57 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupModeRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class TapDetectionSetupModeRequestT { + private Boolean setupMode; + + public Boolean getSetupMode() { return setupMode; } + + public void setSetupMode(Boolean setupMode) { this.setupMode = setupMode; } + + + public TapDetectionSetupModeRequestT() { + this.setupMode = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotification.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotification.java index 516a57da1..36912b732 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotification.java +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotification.java @@ -8,7 +8,7 @@ import com.google.flatbuffers.*; /** - * See TapDetectionSettings::setup_mode + * Indicates which tracker got triggered by TapDetection while setup mode is enabled */ @SuppressWarnings("unused") public final class TapDetectionSetupNotification extends Table { @@ -18,18 +18,17 @@ public final class TapDetectionSetupNotification extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TapDetectionSetupNotification __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public static int createTapDetectionSetupNotification(FlatBufferBuilder builder, - int trackerIdOffset) { + int trackerId) { builder.startTable(1); - TapDetectionSetupNotification.addTrackerId(builder, trackerIdOffset); + TapDetectionSetupNotification.addTrackerId(builder, trackerId); return TapDetectionSetupNotification.endTapDetectionSetupNotification(builder); } public static void startTapDetectionSetupNotification(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static int endTapDetectionSetupNotification(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -47,15 +46,14 @@ public TapDetectionSetupNotificationT unpack() { return _o; } public void unpackTo(TapDetectionSetupNotificationT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); } public static int pack(FlatBufferBuilder builder, TapDetectionSetupNotificationT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); return createTapDetectionSetupNotification( builder, - _trackerId); + _o.getTrackerId()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotificationT.java b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotificationT.java index 2742c1f92..b191a8d98 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotificationT.java +++ b/protocol/java/src/solarxr_protocol/rpc/TapDetectionSetupNotificationT.java @@ -8,15 +8,15 @@ import com.google.flatbuffers.*; public class TapDetectionSetupNotificationT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public TapDetectionSetupNotificationT() { - this.trackerId = null; + this.trackerId = 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/TimeoutSettings.java b/protocol/java/src/solarxr_protocol/rpc/TimeoutSettings.java deleted file mode 100644 index 3cd2ba88b..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/TimeoutSettings.java +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class TimeoutSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static TimeoutSettings getRootAsTimeoutSettings(ByteBuffer _bb) { return getRootAsTimeoutSettings(_bb, new TimeoutSettings()); } - public static TimeoutSettings getRootAsTimeoutSettings(ByteBuffer _bb, TimeoutSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public TimeoutSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public float duration() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } - - public static int createTimeoutSettings(FlatBufferBuilder builder, - float duration) { - builder.startTable(1); - TimeoutSettings.addDuration(builder, duration); - return TimeoutSettings.endTimeoutSettings(builder); - } - - public static void startTimeoutSettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addDuration(FlatBufferBuilder builder, float duration) { builder.addFloat(0, duration, 0.0f); } - public static int endTimeoutSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public TimeoutSettings get(int j) { return get(new TimeoutSettings(), j); } - public TimeoutSettings get(TimeoutSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public TimeoutSettingsT unpack() { - TimeoutSettingsT _o = new TimeoutSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(TimeoutSettingsT _o) { - float _oDuration = duration(); - _o.setDuration(_oDuration); - } - public static int pack(FlatBufferBuilder builder, TimeoutSettingsT _o) { - if (_o == null) return 0; - return createTimeoutSettings( - builder, - _o.getDuration()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/TimeoutSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/TimeoutSettingsT.java deleted file mode 100644 index 595c4347b..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/TimeoutSettingsT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class TimeoutSettingsT { - private float duration; - - public float getDuration() { return duration; } - - public void setDuration(float duration) { this.duration = duration; } - - - public TimeoutSettingsT() { - this.duration = 0.0f; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java index fc57351da..3c29364cb 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java @@ -15,11 +15,12 @@ public final class TrackingChecklistNeedCalibration extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TrackingChecklistNeedCalibration __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } - public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersId(int j) { int o = __offset(4); return o != 0 ? bb.getShort(__vector(o) + j * 2) & 0xFFFF : 0; } public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public ShortVector trackersIdVector() { return trackersIdVector(new ShortVector()); } + public ShortVector trackersIdVector(ShortVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersIdAsByteBuffer() { return __vector_as_bytebuffer(4, 2); } + public ByteBuffer trackersIdInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 2); } public static int createTrackingChecklistNeedCalibration(FlatBufferBuilder builder, int trackersIdOffset) { @@ -30,8 +31,8 @@ public static int createTrackingChecklistNeedCalibration(FlatBufferBuilder build public static void startTrackingChecklistNeedCalibration(FlatBufferBuilder builder) { builder.startTable(1); } public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } - public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(2, data.length, 2); for (int i = data.length - 1; i >= 0; i--) builder.addShort((short) data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(2, numElems, 2); } public static int endTrackingChecklistNeedCalibration(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -49,18 +50,15 @@ public TrackingChecklistNeedCalibrationT unpack() { return _o; } public void unpackTo(TrackingChecklistNeedCalibrationT _o) { - solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; - for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + int[] _oTrackersId = new int[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = trackersId(_j);} _o.setTrackersId(_oTrackersId); } public static int pack(FlatBufferBuilder builder, TrackingChecklistNeedCalibrationT _o) { if (_o == null) return 0; int _trackersId = 0; if (_o.getTrackersId() != null) { - int[] __trackersId = new int[_o.getTrackersId().length]; - int _j = 0; - for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} - _trackersId = createTrackersIdVector(builder, __trackersId); + _trackersId = createTrackersIdVector(builder, _o.getTrackersId()); } return createTrackingChecklistNeedCalibration( builder, diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java index e6a1fa7f7..81480d588 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java @@ -8,11 +8,11 @@ import com.google.flatbuffers.*; public class TrackingChecklistNeedCalibrationT { - private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + private int[] trackersId; - public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + public int[] getTrackersId() { return trackersId; } - public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + public void setTrackersId(int[] trackersId) { this.trackersId = trackersId; } public TrackingChecklistNeedCalibrationT() { diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java index c5060bf5f..c908c2d13 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java @@ -18,11 +18,12 @@ public final class TrackingChecklistTrackerError extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TrackingChecklistTrackerError __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } - public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersId(int j) { int o = __offset(4); return o != 0 ? bb.getShort(__vector(o) + j * 2) & 0xFFFF : 0; } public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public ShortVector trackersIdVector() { return trackersIdVector(new ShortVector()); } + public ShortVector trackersIdVector(ShortVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersIdAsByteBuffer() { return __vector_as_bytebuffer(4, 2); } + public ByteBuffer trackersIdInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 2); } public static int createTrackingChecklistTrackerError(FlatBufferBuilder builder, int trackersIdOffset) { @@ -33,8 +34,8 @@ public static int createTrackingChecklistTrackerError(FlatBufferBuilder builder, public static void startTrackingChecklistTrackerError(FlatBufferBuilder builder) { builder.startTable(1); } public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } - public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(2, data.length, 2); for (int i = data.length - 1; i >= 0; i--) builder.addShort((short) data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(2, numElems, 2); } public static int endTrackingChecklistTrackerError(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -52,18 +53,15 @@ public TrackingChecklistTrackerErrorT unpack() { return _o; } public void unpackTo(TrackingChecklistTrackerErrorT _o) { - solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; - for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + int[] _oTrackersId = new int[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = trackersId(_j);} _o.setTrackersId(_oTrackersId); } public static int pack(FlatBufferBuilder builder, TrackingChecklistTrackerErrorT _o) { if (_o == null) return 0; int _trackersId = 0; if (_o.getTrackersId() != null) { - int[] __trackersId = new int[_o.getTrackersId().length]; - int _j = 0; - for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} - _trackersId = createTrackersIdVector(builder, __trackersId); + _trackersId = createTrackersIdVector(builder, _o.getTrackersId()); } return createTrackingChecklistTrackerError( builder, diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java index 61f4f1a88..7ff912af1 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java @@ -8,11 +8,11 @@ import com.google.flatbuffers.*; public class TrackingChecklistTrackerErrorT { - private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + private int[] trackersId; - public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + public int[] getTrackersId() { return trackersId; } - public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + public void setTrackersId(int[] trackersId) { this.trackersId = trackersId; } public TrackingChecklistTrackerErrorT() { diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java index 836a99eac..f90112aa6 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java @@ -18,11 +18,12 @@ public final class TrackingChecklistTrackerReset extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TrackingChecklistTrackerReset __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } - public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersId(int j) { int o = __offset(4); return o != 0 ? bb.getShort(__vector(o) + j * 2) & 0xFFFF : 0; } public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } - public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public ShortVector trackersIdVector() { return trackersIdVector(new ShortVector()); } + public ShortVector trackersIdVector(ShortVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersIdAsByteBuffer() { return __vector_as_bytebuffer(4, 2); } + public ByteBuffer trackersIdInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 2); } public static int createTrackingChecklistTrackerReset(FlatBufferBuilder builder, int trackersIdOffset) { @@ -33,8 +34,8 @@ public static int createTrackingChecklistTrackerReset(FlatBufferBuilder builder, public static void startTrackingChecklistTrackerReset(FlatBufferBuilder builder) { builder.startTable(1); } public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } - public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } - public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(2, data.length, 2); for (int i = data.length - 1; i >= 0; i--) builder.addShort((short) data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(2, numElems, 2); } public static int endTrackingChecklistTrackerReset(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -52,18 +53,15 @@ public TrackingChecklistTrackerResetT unpack() { return _o; } public void unpackTo(TrackingChecklistTrackerResetT _o) { - solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; - for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + int[] _oTrackersId = new int[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = trackersId(_j);} _o.setTrackersId(_oTrackersId); } public static int pack(FlatBufferBuilder builder, TrackingChecklistTrackerResetT _o) { if (_o == null) return 0; int _trackersId = 0; if (_o.getTrackersId() != null) { - int[] __trackersId = new int[_o.getTrackersId().length]; - int _j = 0; - for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} - _trackersId = createTrackersIdVector(builder, __trackersId); + _trackersId = createTrackersIdVector(builder, _o.getTrackersId()); } return createTrackingChecklistTrackerReset( builder, diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java index 3f132a3f3..395fe9059 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java @@ -8,11 +8,11 @@ import com.google.flatbuffers.*; public class TrackingChecklistTrackerResetT { - private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + private int[] trackersId; - public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + public int[] getTrackersId() { return trackersId; } - public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + public void setTrackersId(int[] trackersId) { this.trackersId = trackersId; } public TrackingChecklistTrackerResetT() { diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java index 2510c4f30..4a5b80daa 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java @@ -15,18 +15,17 @@ public final class TrackingChecklistUnassignedHMD extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public TrackingChecklistUnassignedHMD __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackerId() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } public static int createTrackingChecklistUnassignedHMD(FlatBufferBuilder builder, - int trackerIdOffset) { + int trackerId) { builder.startTable(1); - TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerIdOffset); + TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerId); return TrackingChecklistUnassignedHMD.endTrackingChecklistUnassignedHMD(builder); } public static void startTrackingChecklistUnassignedHMD(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerId) { builder.addShort(0, (short) trackerId, (short) 0); } public static int endTrackingChecklistUnassignedHMD(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -44,15 +43,14 @@ public TrackingChecklistUnassignedHMDT unpack() { return _o; } public void unpackTo(TrackingChecklistUnassignedHMDT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + int _oTrackerId = trackerId(); + _o.setTrackerId(_oTrackerId); } public static int pack(FlatBufferBuilder builder, TrackingChecklistUnassignedHMDT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); return createTrackingChecklistUnassignedHMD( builder, - _trackerId); + _o.getTrackerId()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java index 6b2fd2323..261e3269e 100644 --- a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java @@ -8,15 +8,15 @@ import com.google.flatbuffers.*; public class TrackingChecklistUnassignedHMDT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int trackerId; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public int getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(int trackerId) { this.trackerId = trackerId; } public TrackingChecklistUnassignedHMDT() { - this.trackerId = null; + this.trackerId = 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettings.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettings.java deleted file mode 100644 index d938062b3..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettings.java +++ /dev/null @@ -1,75 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * OSC Settings specific to VMC - */ -@SuppressWarnings("unused") -public final class VMCOSCSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static VMCOSCSettings getRootAsVMCOSCSettings(ByteBuffer _bb) { return getRootAsVMCOSCSettings(_bb, new VMCOSCSettings()); } - public static VMCOSCSettings getRootAsVMCOSCSettings(ByteBuffer _bb, VMCOSCSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public VMCOSCSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.OSCSettings oscSettings() { return oscSettings(new solarxr_protocol.rpc.OSCSettings()); } - public solarxr_protocol.rpc.OSCSettings oscSettings(solarxr_protocol.rpc.OSCSettings obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public boolean anchorHip() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean mirrorTracking() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createVMCOSCSettings(FlatBufferBuilder builder, - int oscSettingsOffset, - boolean anchorHip, - boolean mirrorTracking) { - builder.startTable(4); - VMCOSCSettings.addOscSettings(builder, oscSettingsOffset); - VMCOSCSettings.addMirrorTracking(builder, mirrorTracking); - VMCOSCSettings.addAnchorHip(builder, anchorHip); - return VMCOSCSettings.endVMCOSCSettings(builder); - } - - public static void startVMCOSCSettings(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addOscSettings(FlatBufferBuilder builder, int oscSettingsOffset) { builder.addOffset(0, oscSettingsOffset, 0); } - public static void addAnchorHip(FlatBufferBuilder builder, boolean anchorHip) { builder.addBoolean(2, anchorHip, false); } - public static void addMirrorTracking(FlatBufferBuilder builder, boolean mirrorTracking) { builder.addBoolean(3, mirrorTracking, false); } - public static int endVMCOSCSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public VMCOSCSettings get(int j) { return get(new VMCOSCSettings(), j); } - public VMCOSCSettings get(VMCOSCSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public VMCOSCSettingsT unpack() { - VMCOSCSettingsT _o = new VMCOSCSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(VMCOSCSettingsT _o) { - if (oscSettings() != null) _o.setOscSettings(oscSettings().unpack()); - else _o.setOscSettings(null); - boolean _oAnchorHip = anchorHip(); - _o.setAnchorHip(_oAnchorHip); - boolean _oMirrorTracking = mirrorTracking(); - _o.setMirrorTracking(_oMirrorTracking); - } - public static int pack(FlatBufferBuilder builder, VMCOSCSettingsT _o) { - if (_o == null) return 0; - int _oscSettings = _o.getOscSettings() == null ? 0 : solarxr_protocol.rpc.OSCSettings.pack(builder, _o.getOscSettings()); - return createVMCOSCSettings( - builder, - _oscSettings, - _o.getAnchorHip(), - _o.getMirrorTracking()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequest.java new file mode 100644 index 000000000..1efaf1c98 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VMCOSCSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VMCOSCSettingsRequest getRootAsVMCOSCSettingsRequest(ByteBuffer _bb) { return getRootAsVMCOSCSettingsRequest(_bb, new VMCOSCSettingsRequest()); } + public static VMCOSCSettingsRequest getRootAsVMCOSCSettingsRequest(ByteBuffer _bb, VMCOSCSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VMCOSCSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startVMCOSCSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endVMCOSCSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VMCOSCSettingsRequest get(int j) { return get(new VMCOSCSettingsRequest(), j); } + public VMCOSCSettingsRequest get(VMCOSCSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VMCOSCSettingsRequestT unpack() { + VMCOSCSettingsRequestT _o = new VMCOSCSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VMCOSCSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, VMCOSCSettingsRequestT _o) { + if (_o == null) return 0; + startVMCOSCSettingsRequest(builder); + return endVMCOSCSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequestT.java new file mode 100644 index 000000000..27403a0b7 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VMCOSCSettingsRequestT { + + + public VMCOSCSettingsRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponse.java new file mode 100644 index 000000000..70b59a920 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponse.java @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VMCOSCSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VMCOSCSettingsResponse getRootAsVMCOSCSettingsResponse(ByteBuffer _bb) { return getRootAsVMCOSCSettingsResponse(_bb, new VMCOSCSettingsResponse()); } + public static VMCOSCSettingsResponse getRootAsVMCOSCSettingsResponse(ByteBuffer _bb, VMCOSCSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VMCOSCSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int portIn() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public int portOut() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public String address() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer addressAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } + public ByteBuffer addressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } + public boolean anchorHip() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean mirrorTracking() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createVMCOSCSettingsResponse(FlatBufferBuilder builder, + boolean enabled, + int portIn, + int portOut, + int addressOffset, + boolean anchorHip, + boolean mirrorTracking) { + builder.startTable(6); + VMCOSCSettingsResponse.addAddress(builder, addressOffset); + VMCOSCSettingsResponse.addPortOut(builder, portOut); + VMCOSCSettingsResponse.addPortIn(builder, portIn); + VMCOSCSettingsResponse.addMirrorTracking(builder, mirrorTracking); + VMCOSCSettingsResponse.addAnchorHip(builder, anchorHip); + VMCOSCSettingsResponse.addEnabled(builder, enabled); + return VMCOSCSettingsResponse.endVMCOSCSettingsResponse(builder); + } + + public static void startVMCOSCSettingsResponse(FlatBufferBuilder builder) { builder.startTable(6); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addPortIn(FlatBufferBuilder builder, int portIn) { builder.addShort(1, (short) portIn, (short) 0); } + public static void addPortOut(FlatBufferBuilder builder, int portOut) { builder.addShort(2, (short) portOut, (short) 0); } + public static void addAddress(FlatBufferBuilder builder, int addressOffset) { builder.addOffset(3, addressOffset, 0); } + public static void addAnchorHip(FlatBufferBuilder builder, boolean anchorHip) { builder.addBoolean(4, anchorHip, false); } + public static void addMirrorTracking(FlatBufferBuilder builder, boolean mirrorTracking) { builder.addBoolean(5, mirrorTracking, false); } + public static int endVMCOSCSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VMCOSCSettingsResponse get(int j) { return get(new VMCOSCSettingsResponse(), j); } + public VMCOSCSettingsResponse get(VMCOSCSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VMCOSCSettingsResponseT unpack() { + VMCOSCSettingsResponseT _o = new VMCOSCSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VMCOSCSettingsResponseT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + int _oPortIn = portIn(); + _o.setPortIn(_oPortIn); + int _oPortOut = portOut(); + _o.setPortOut(_oPortOut); + String _oAddress = address(); + _o.setAddress(_oAddress); + boolean _oAnchorHip = anchorHip(); + _o.setAnchorHip(_oAnchorHip); + boolean _oMirrorTracking = mirrorTracking(); + _o.setMirrorTracking(_oMirrorTracking); + } + public static int pack(FlatBufferBuilder builder, VMCOSCSettingsResponseT _o) { + if (_o == null) return 0; + int _address = _o.getAddress() == null ? 0 : builder.createString(_o.getAddress()); + return createVMCOSCSettingsResponse( + builder, + _o.getEnabled(), + _o.getPortIn(), + _o.getPortOut(), + _address, + _o.getAnchorHip(), + _o.getMirrorTracking()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponseT.java new file mode 100644 index 000000000..b4fa0ac32 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsResponseT.java @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VMCOSCSettingsResponseT { + private boolean enabled; + private int portIn; + private int portOut; + private String address; + private boolean anchorHip; + private boolean mirrorTracking; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public int getPortIn() { return portIn; } + + public void setPortIn(int portIn) { this.portIn = portIn; } + + public int getPortOut() { return portOut; } + + public void setPortOut(int portOut) { this.portOut = portOut; } + + public String getAddress() { return address; } + + public void setAddress(String address) { this.address = address; } + + public boolean getAnchorHip() { return anchorHip; } + + public void setAnchorHip(boolean anchorHip) { this.anchorHip = anchorHip; } + + public boolean getMirrorTracking() { return mirrorTracking; } + + public void setMirrorTracking(boolean mirrorTracking) { this.mirrorTracking = mirrorTracking; } + + + public VMCOSCSettingsResponseT() { + this.enabled = false; + this.portIn = 0; + this.portOut = 0; + this.address = null; + this.anchorHip = false; + this.mirrorTracking = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsT.java deleted file mode 100644 index 36ce4905b..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VMCOSCSettingsT.java +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class VMCOSCSettingsT { - private solarxr_protocol.rpc.OSCSettingsT oscSettings; - private boolean anchorHip; - private boolean mirrorTracking; - - public solarxr_protocol.rpc.OSCSettingsT getOscSettings() { return oscSettings; } - - public void setOscSettings(solarxr_protocol.rpc.OSCSettingsT oscSettings) { this.oscSettings = oscSettings; } - - public boolean getAnchorHip() { return anchorHip; } - - public void setAnchorHip(boolean anchorHip) { this.anchorHip = anchorHip; } - - public boolean getMirrorTracking() { return mirrorTracking; } - - public void setMirrorTracking(boolean mirrorTracking) { this.mirrorTracking = mirrorTracking; } - - - public VMCOSCSettingsT() { - this.oscSettings = null; - this.anchorHip = false; - this.mirrorTracking = false; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java index bbf861fe6..c026583ec 100644 --- a/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java @@ -15,6 +15,9 @@ public final class VRCConfigSettingToggleMute extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public VRCConfigSettingToggleMute __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + /** + * Key from VRCConfigValidity + */ public String key() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } public ByteBuffer keyAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } public ByteBuffer keyInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java index 7dd8a38b9..8b4dfbbf5 100644 --- a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java @@ -26,6 +26,9 @@ public final class VRCConfigStateChangeResponse extends Table { public solarxr_protocol.rpc.VRCConfigValues state(solarxr_protocol.rpc.VRCConfigValues obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public solarxr_protocol.rpc.VRCConfigRecommendedValues recommended() { return recommended(new solarxr_protocol.rpc.VRCConfigRecommendedValues()); } public solarxr_protocol.rpc.VRCConfigRecommendedValues recommended(solarxr_protocol.rpc.VRCConfigRecommendedValues obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + /** + * Just a list of keys from the VRCConfigValidity table. + */ public String muted(int j) { int o = __offset(12); return o != 0 ? __string(__vector(o) + j * 4) : null; } public int mutedLength() { int o = __offset(12); return o != 0 ? __vector_len(o) : 0; } public StringVector mutedVector() { return mutedVector(new StringVector()); } diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTarget.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTarget.java new file mode 100644 index 000000000..39ff1aafa --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTarget.java @@ -0,0 +1,76 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCDiscoveredTarget extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCDiscoveredTarget getRootAsVRCOSCDiscoveredTarget(ByteBuffer _bb) { return getRootAsVRCOSCDiscoveredTarget(_bb, new VRCOSCDiscoveredTarget()); } + public static VRCOSCDiscoveredTarget getRootAsVRCOSCDiscoveredTarget(ByteBuffer _bb, VRCOSCDiscoveredTarget obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCDiscoveredTarget __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String name() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer nameAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer nameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + public String address() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer addressAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer addressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + public int portOut() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + + public static int createVRCOSCDiscoveredTarget(FlatBufferBuilder builder, + int nameOffset, + int addressOffset, + int portOut) { + builder.startTable(3); + VRCOSCDiscoveredTarget.addAddress(builder, addressOffset); + VRCOSCDiscoveredTarget.addName(builder, nameOffset); + VRCOSCDiscoveredTarget.addPortOut(builder, portOut); + return VRCOSCDiscoveredTarget.endVRCOSCDiscoveredTarget(builder); + } + + public static void startVRCOSCDiscoveredTarget(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(0, nameOffset, 0); } + public static void addAddress(FlatBufferBuilder builder, int addressOffset) { builder.addOffset(1, addressOffset, 0); } + public static void addPortOut(FlatBufferBuilder builder, int portOut) { builder.addShort(2, (short) portOut, (short) 0); } + public static int endVRCOSCDiscoveredTarget(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCDiscoveredTarget get(int j) { return get(new VRCOSCDiscoveredTarget(), j); } + public VRCOSCDiscoveredTarget get(VRCOSCDiscoveredTarget obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCDiscoveredTargetT unpack() { + VRCOSCDiscoveredTargetT _o = new VRCOSCDiscoveredTargetT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCDiscoveredTargetT _o) { + String _oName = name(); + _o.setName(_oName); + String _oAddress = address(); + _o.setAddress(_oAddress); + int _oPortOut = portOut(); + _o.setPortOut(_oPortOut); + } + public static int pack(FlatBufferBuilder builder, VRCOSCDiscoveredTargetT _o) { + if (_o == null) return 0; + int _name = _o.getName() == null ? 0 : builder.createString(_o.getName()); + int _address = _o.getAddress() == null ? 0 : builder.createString(_o.getAddress()); + return createVRCOSCDiscoveredTarget( + builder, + _name, + _address, + _o.getPortOut()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTargetT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTargetT.java new file mode 100644 index 000000000..505d85768 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCDiscoveredTargetT.java @@ -0,0 +1,34 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VRCOSCDiscoveredTargetT { + private String name; + private String address; + private int portOut; + + public String getName() { return name; } + + public void setName(String name) { this.name = name; } + + public String getAddress() { return address; } + + public void setAddress(String address) { this.address = address; } + + public int getPortOut() { return portOut; } + + public void setPortOut(int portOut) { this.portOut = portOut; } + + + public VRCOSCDiscoveredTargetT() { + this.name = null; + this.address = null; + this.portOut = 0; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCInputState.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCInputState.java new file mode 100644 index 000000000..c824157b8 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCInputState.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class VRCOSCInputState { + private VRCOSCInputState() { } + public static final int IDLE = 0; + public static final int LISTENING = 1; + public static final int ERROR = 2; + + public static final String[] names = { "IDLE", "LISTENING", "ERROR", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettings.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettings.java new file mode 100644 index 000000000..d50e98661 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettings.java @@ -0,0 +1,73 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCNetworkSettings extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCNetworkSettings getRootAsVRCOSCNetworkSettings(ByteBuffer _bb) { return getRootAsVRCOSCNetworkSettings(_bb, new VRCOSCNetworkSettings()); } + public static VRCOSCNetworkSettings getRootAsVRCOSCNetworkSettings(ByteBuffer _bb, VRCOSCNetworkSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCNetworkSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int portIn() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public int portOut() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public String address() { int o = __offset(8); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer addressAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } + public ByteBuffer addressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } + + public static int createVRCOSCNetworkSettings(FlatBufferBuilder builder, + int portIn, + int portOut, + int addressOffset) { + builder.startTable(3); + VRCOSCNetworkSettings.addAddress(builder, addressOffset); + VRCOSCNetworkSettings.addPortOut(builder, portOut); + VRCOSCNetworkSettings.addPortIn(builder, portIn); + return VRCOSCNetworkSettings.endVRCOSCNetworkSettings(builder); + } + + public static void startVRCOSCNetworkSettings(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addPortIn(FlatBufferBuilder builder, int portIn) { builder.addShort(0, (short) portIn, (short) 0); } + public static void addPortOut(FlatBufferBuilder builder, int portOut) { builder.addShort(1, (short) portOut, (short) 0); } + public static void addAddress(FlatBufferBuilder builder, int addressOffset) { builder.addOffset(2, addressOffset, 0); } + public static int endVRCOSCNetworkSettings(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCNetworkSettings get(int j) { return get(new VRCOSCNetworkSettings(), j); } + public VRCOSCNetworkSettings get(VRCOSCNetworkSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCNetworkSettingsT unpack() { + VRCOSCNetworkSettingsT _o = new VRCOSCNetworkSettingsT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCNetworkSettingsT _o) { + int _oPortIn = portIn(); + _o.setPortIn(_oPortIn); + int _oPortOut = portOut(); + _o.setPortOut(_oPortOut); + String _oAddress = address(); + _o.setAddress(_oAddress); + } + public static int pack(FlatBufferBuilder builder, VRCOSCNetworkSettingsT _o) { + if (_o == null) return 0; + int _address = _o.getAddress() == null ? 0 : builder.createString(_o.getAddress()); + return createVRCOSCNetworkSettings( + builder, + _o.getPortIn(), + _o.getPortOut(), + _address); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/OSCSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettingsT.java similarity index 74% rename from protocol/java/src/solarxr_protocol/rpc/OSCSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettingsT.java index f9705bb30..f2dd7cce3 100644 --- a/protocol/java/src/solarxr_protocol/rpc/OSCSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCNetworkSettingsT.java @@ -7,16 +7,11 @@ import java.util.*; import com.google.flatbuffers.*; -public class OSCSettingsT { - private boolean enabled; +public class VRCOSCNetworkSettingsT { private int portIn; private int portOut; private String address; - public boolean getEnabled() { return enabled; } - - public void setEnabled(boolean enabled) { this.enabled = enabled; } - public int getPortIn() { return portIn; } public void setPortIn(int portIn) { this.portIn = portIn; } @@ -30,8 +25,7 @@ public class OSCSettingsT { public void setAddress(String address) { this.address = address; } - public OSCSettingsT() { - this.enabled = false; + public VRCOSCNetworkSettingsT() { this.portIn = 0; this.portOut = 0; this.address = null; diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCOscQueryState.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCOscQueryState.java new file mode 100644 index 000000000..e4857bed3 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCOscQueryState.java @@ -0,0 +1,17 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class VRCOSCOscQueryState { + private VRCOSCOscQueryState() { } + public static final int DISABLED = 0; + public static final int SEARCHING = 1; + public static final int FOUND = 2; + public static final int ERROR = 3; + + public static final String[] names = { "DISABLED", "SEARCHING", "FOUND", "ERROR", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCOutputState.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCOutputState.java new file mode 100644 index 000000000..b54ed84ca --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCOutputState.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class VRCOSCOutputState { + private VRCOSCOutputState() { } + public static final int IDLE = 0; + public static final int READY = 1; + public static final int ERROR = 2; + + public static final String[] names = { "IDLE", "READY", "ERROR", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettings.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettings.java deleted file mode 100644 index 2928e64ea..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettings.java +++ /dev/null @@ -1,77 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * OSC Settings specific to VRChat - */ -@SuppressWarnings("unused") -public final class VRCOSCSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static VRCOSCSettings getRootAsVRCOSCSettings(ByteBuffer _bb) { return getRootAsVRCOSCSettings(_bb, new VRCOSCSettings()); } - public static VRCOSCSettings getRootAsVRCOSCSettings(ByteBuffer _bb, VRCOSCSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public VRCOSCSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.OSCSettings oscSettings() { return oscSettings(new solarxr_protocol.rpc.OSCSettings()); } - public solarxr_protocol.rpc.OSCSettings oscSettings(solarxr_protocol.rpc.OSCSettings obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.OSCTrackersSetting trackers() { return trackers(new solarxr_protocol.rpc.OSCTrackersSetting()); } - public solarxr_protocol.rpc.OSCTrackersSetting trackers(solarxr_protocol.rpc.OSCTrackersSetting obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public boolean oscqueryEnabled() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createVRCOSCSettings(FlatBufferBuilder builder, - int oscSettingsOffset, - int trackersOffset, - boolean oscqueryEnabled) { - builder.startTable(3); - VRCOSCSettings.addTrackers(builder, trackersOffset); - VRCOSCSettings.addOscSettings(builder, oscSettingsOffset); - VRCOSCSettings.addOscqueryEnabled(builder, oscqueryEnabled); - return VRCOSCSettings.endVRCOSCSettings(builder); - } - - public static void startVRCOSCSettings(FlatBufferBuilder builder) { builder.startTable(3); } - public static void addOscSettings(FlatBufferBuilder builder, int oscSettingsOffset) { builder.addOffset(0, oscSettingsOffset, 0); } - public static void addTrackers(FlatBufferBuilder builder, int trackersOffset) { builder.addOffset(1, trackersOffset, 0); } - public static void addOscqueryEnabled(FlatBufferBuilder builder, boolean oscqueryEnabled) { builder.addBoolean(2, oscqueryEnabled, false); } - public static int endVRCOSCSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public VRCOSCSettings get(int j) { return get(new VRCOSCSettings(), j); } - public VRCOSCSettings get(VRCOSCSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public VRCOSCSettingsT unpack() { - VRCOSCSettingsT _o = new VRCOSCSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(VRCOSCSettingsT _o) { - if (oscSettings() != null) _o.setOscSettings(oscSettings().unpack()); - else _o.setOscSettings(null); - if (trackers() != null) _o.setTrackers(trackers().unpack()); - else _o.setTrackers(null); - boolean _oOscqueryEnabled = oscqueryEnabled(); - _o.setOscqueryEnabled(_oOscqueryEnabled); - } - public static int pack(FlatBufferBuilder builder, VRCOSCSettingsT _o) { - if (_o == null) return 0; - int _oscSettings = _o.getOscSettings() == null ? 0 : solarxr_protocol.rpc.OSCSettings.pack(builder, _o.getOscSettings()); - int _trackers = _o.getTrackers() == null ? 0 : solarxr_protocol.rpc.OSCTrackersSetting.pack(builder, _o.getTrackers()); - return createVRCOSCSettings( - builder, - _oscSettings, - _trackers, - _o.getOscqueryEnabled()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequest.java new file mode 100644 index 000000000..98291d150 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCSettingsRequest getRootAsVRCOSCSettingsRequest(ByteBuffer _bb) { return getRootAsVRCOSCSettingsRequest(_bb, new VRCOSCSettingsRequest()); } + public static VRCOSCSettingsRequest getRootAsVRCOSCSettingsRequest(ByteBuffer _bb, VRCOSCSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startVRCOSCSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endVRCOSCSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCSettingsRequest get(int j) { return get(new VRCOSCSettingsRequest(), j); } + public VRCOSCSettingsRequest get(VRCOSCSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCSettingsRequestT unpack() { + VRCOSCSettingsRequestT _o = new VRCOSCSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, VRCOSCSettingsRequestT _o) { + if (_o == null) return 0; + startVRCOSCSettingsRequest(builder); + return endVRCOSCSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequestT.java new file mode 100644 index 000000000..142370195 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VRCOSCSettingsRequestT { + + + public VRCOSCSettingsRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponse.java new file mode 100644 index 000000000..188ff86cb --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponse.java @@ -0,0 +1,65 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCSettingsResponse getRootAsVRCOSCSettingsResponse(ByteBuffer _bb) { return getRootAsVRCOSCSettingsResponse(_bb, new VRCOSCSettingsResponse()); } + public static VRCOSCSettingsResponse getRootAsVRCOSCSettingsResponse(ByteBuffer _bb, VRCOSCSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public solarxr_protocol.rpc.VRCOSCNetworkSettings manualNetwork() { return manualNetwork(new solarxr_protocol.rpc.VRCOSCNetworkSettings()); } + public solarxr_protocol.rpc.VRCOSCNetworkSettings manualNetwork(solarxr_protocol.rpc.VRCOSCNetworkSettings obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + + public static int createVRCOSCSettingsResponse(FlatBufferBuilder builder, + boolean enabled, + int manualNetworkOffset) { + builder.startTable(2); + VRCOSCSettingsResponse.addManualNetwork(builder, manualNetworkOffset); + VRCOSCSettingsResponse.addEnabled(builder, enabled); + return VRCOSCSettingsResponse.endVRCOSCSettingsResponse(builder); + } + + public static void startVRCOSCSettingsResponse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addManualNetwork(FlatBufferBuilder builder, int manualNetworkOffset) { builder.addOffset(1, manualNetworkOffset, 0); } + public static int endVRCOSCSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCSettingsResponse get(int j) { return get(new VRCOSCSettingsResponse(), j); } + public VRCOSCSettingsResponse get(VRCOSCSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCSettingsResponseT unpack() { + VRCOSCSettingsResponseT _o = new VRCOSCSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCSettingsResponseT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + if (manualNetwork() != null) _o.setManualNetwork(manualNetwork().unpack()); + else _o.setManualNetwork(null); + } + public static int pack(FlatBufferBuilder builder, VRCOSCSettingsResponseT _o) { + if (_o == null) return 0; + int _manualNetwork = _o.getManualNetwork() == null ? 0 : solarxr_protocol.rpc.VRCOSCNetworkSettings.pack(builder, _o.getManualNetwork()); + return createVRCOSCSettingsResponse( + builder, + _o.getEnabled(), + _manualNetwork); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponseT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponseT.java new file mode 100644 index 000000000..50b11e43e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsResponseT.java @@ -0,0 +1,28 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VRCOSCSettingsResponseT { + private boolean enabled; + private solarxr_protocol.rpc.VRCOSCNetworkSettingsT manualNetwork; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public solarxr_protocol.rpc.VRCOSCNetworkSettingsT getManualNetwork() { return manualNetwork; } + + public void setManualNetwork(solarxr_protocol.rpc.VRCOSCNetworkSettingsT manualNetwork) { this.manualNetwork = manualNetwork; } + + + public VRCOSCSettingsResponseT() { + this.enabled = false; + this.manualNetwork = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsT.java deleted file mode 100644 index 41d8ba2c0..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VRCOSCSettingsT.java +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class VRCOSCSettingsT { - private solarxr_protocol.rpc.OSCSettingsT oscSettings; - private solarxr_protocol.rpc.OSCTrackersSettingT trackers; - private boolean oscqueryEnabled; - - public solarxr_protocol.rpc.OSCSettingsT getOscSettings() { return oscSettings; } - - public void setOscSettings(solarxr_protocol.rpc.OSCSettingsT oscSettings) { this.oscSettings = oscSettings; } - - public solarxr_protocol.rpc.OSCTrackersSettingT getTrackers() { return trackers; } - - public void setTrackers(solarxr_protocol.rpc.OSCTrackersSettingT trackers) { this.trackers = trackers; } - - public boolean getOscqueryEnabled() { return oscqueryEnabled; } - - public void setOscqueryEnabled(boolean oscqueryEnabled) { this.oscqueryEnabled = oscqueryEnabled; } - - - public VRCOSCSettingsT() { - this.oscSettings = null; - this.trackers = null; - this.oscqueryEnabled = false; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponse.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponse.java new file mode 100644 index 000000000..7633d37d7 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponse.java @@ -0,0 +1,185 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCStatusChangeResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCStatusChangeResponse getRootAsVRCOSCStatusChangeResponse(ByteBuffer _bb) { return getRootAsVRCOSCStatusChangeResponse(_bb, new VRCOSCStatusChangeResponse()); } + public static VRCOSCStatusChangeResponse getRootAsVRCOSCStatusChangeResponse(ByteBuffer _bb, VRCOSCStatusChangeResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCStatusChangeResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean enabled() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int inputState() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasInputPort() { return 0 != __offset(8); } + public int inputPort() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public String inputError() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer inputErrorAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } + public ByteBuffer inputErrorInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } + public boolean hasLastReceivedInputMillis() { return 0 != __offset(12); } + public long lastReceivedInputMillis() { int o = __offset(12); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + public int outputState() { int o = __offset(14); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public String outputError() { int o = __offset(16); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer outputErrorAsByteBuffer() { return __vector_as_bytebuffer(16, 1); } + public ByteBuffer outputErrorInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 16, 1); } + public String targetAddress() { int o = __offset(18); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer targetAddressAsByteBuffer() { return __vector_as_bytebuffer(18, 1); } + public ByteBuffer targetAddressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 18, 1); } + public boolean hasTargetPort() { return 0 != __offset(20); } + public int targetPort() { int o = __offset(20); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public int targetSource() { int o = __offset(22); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasLastFrameSentMillis() { return 0 != __offset(24); } + public long lastFrameSentMillis() { int o = __offset(24); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + public int oscqueryState() { int o = __offset(26); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean hasOscqueryAdvertisedPort() { return 0 != __offset(28); } + public int oscqueryAdvertisedPort() { int o = __offset(28); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public String oscqueryError() { int o = __offset(30); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer oscqueryErrorAsByteBuffer() { return __vector_as_bytebuffer(30, 1); } + public ByteBuffer oscqueryErrorInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 30, 1); } + public solarxr_protocol.rpc.VRCOSCDiscoveredTarget discoveredTargets(int j) { return discoveredTargets(new solarxr_protocol.rpc.VRCOSCDiscoveredTarget(), j); } + public solarxr_protocol.rpc.VRCOSCDiscoveredTarget discoveredTargets(solarxr_protocol.rpc.VRCOSCDiscoveredTarget obj, int j) { int o = __offset(32); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int discoveredTargetsLength() { int o = __offset(32); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.rpc.VRCOSCDiscoveredTarget.Vector discoveredTargetsVector() { return discoveredTargetsVector(new solarxr_protocol.rpc.VRCOSCDiscoveredTarget.Vector()); } + public solarxr_protocol.rpc.VRCOSCDiscoveredTarget.Vector discoveredTargetsVector(solarxr_protocol.rpc.VRCOSCDiscoveredTarget.Vector obj) { int o = __offset(32); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createVRCOSCStatusChangeResponse(FlatBufferBuilder builder, + boolean enabled, + int inputState, + int inputPort, + int inputErrorOffset, + long lastReceivedInputMillis, + int outputState, + int outputErrorOffset, + int targetAddressOffset, + int targetPort, + int targetSource, + long lastFrameSentMillis, + int oscqueryState, + int oscqueryAdvertisedPort, + int oscqueryErrorOffset, + int discoveredTargetsOffset) { + builder.startTable(15); + VRCOSCStatusChangeResponse.addLastFrameSentMillis(builder, lastFrameSentMillis); + VRCOSCStatusChangeResponse.addLastReceivedInputMillis(builder, lastReceivedInputMillis); + VRCOSCStatusChangeResponse.addDiscoveredTargets(builder, discoveredTargetsOffset); + VRCOSCStatusChangeResponse.addOscqueryError(builder, oscqueryErrorOffset); + VRCOSCStatusChangeResponse.addTargetAddress(builder, targetAddressOffset); + VRCOSCStatusChangeResponse.addOutputError(builder, outputErrorOffset); + VRCOSCStatusChangeResponse.addInputError(builder, inputErrorOffset); + VRCOSCStatusChangeResponse.addOscqueryAdvertisedPort(builder, oscqueryAdvertisedPort); + VRCOSCStatusChangeResponse.addTargetPort(builder, targetPort); + VRCOSCStatusChangeResponse.addInputPort(builder, inputPort); + VRCOSCStatusChangeResponse.addOscqueryState(builder, oscqueryState); + VRCOSCStatusChangeResponse.addTargetSource(builder, targetSource); + VRCOSCStatusChangeResponse.addOutputState(builder, outputState); + VRCOSCStatusChangeResponse.addInputState(builder, inputState); + VRCOSCStatusChangeResponse.addEnabled(builder, enabled); + return VRCOSCStatusChangeResponse.endVRCOSCStatusChangeResponse(builder); + } + + public static void startVRCOSCStatusChangeResponse(FlatBufferBuilder builder) { builder.startTable(15); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(0, enabled, false); } + public static void addInputState(FlatBufferBuilder builder, int inputState) { builder.addByte(1, (byte) inputState, (byte) 0); } + public static void addInputPort(FlatBufferBuilder builder, int inputPort) { builder.addShort(2, (short) inputPort, (short) 0); } + public static void addInputError(FlatBufferBuilder builder, int inputErrorOffset) { builder.addOffset(3, inputErrorOffset, 0); } + public static void addLastReceivedInputMillis(FlatBufferBuilder builder, long lastReceivedInputMillis) { builder.addLong(4, lastReceivedInputMillis, 0L); } + public static void addOutputState(FlatBufferBuilder builder, int outputState) { builder.addByte(5, (byte) outputState, (byte) 0); } + public static void addOutputError(FlatBufferBuilder builder, int outputErrorOffset) { builder.addOffset(6, outputErrorOffset, 0); } + public static void addTargetAddress(FlatBufferBuilder builder, int targetAddressOffset) { builder.addOffset(7, targetAddressOffset, 0); } + public static void addTargetPort(FlatBufferBuilder builder, int targetPort) { builder.addShort(8, (short) targetPort, (short) 0); } + public static void addTargetSource(FlatBufferBuilder builder, int targetSource) { builder.addByte(9, (byte) targetSource, (byte) 0); } + public static void addLastFrameSentMillis(FlatBufferBuilder builder, long lastFrameSentMillis) { builder.addLong(10, lastFrameSentMillis, 0L); } + public static void addOscqueryState(FlatBufferBuilder builder, int oscqueryState) { builder.addByte(11, (byte) oscqueryState, (byte) 0); } + public static void addOscqueryAdvertisedPort(FlatBufferBuilder builder, int oscqueryAdvertisedPort) { builder.addShort(12, (short) oscqueryAdvertisedPort, (short) 0); } + public static void addOscqueryError(FlatBufferBuilder builder, int oscqueryErrorOffset) { builder.addOffset(13, oscqueryErrorOffset, 0); } + public static void addDiscoveredTargets(FlatBufferBuilder builder, int discoveredTargetsOffset) { builder.addOffset(14, discoveredTargetsOffset, 0); } + public static int createDiscoveredTargetsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startDiscoveredTargetsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endVRCOSCStatusChangeResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCStatusChangeResponse get(int j) { return get(new VRCOSCStatusChangeResponse(), j); } + public VRCOSCStatusChangeResponse get(VRCOSCStatusChangeResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCStatusChangeResponseT unpack() { + VRCOSCStatusChangeResponseT _o = new VRCOSCStatusChangeResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCStatusChangeResponseT _o) { + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + int _oInputState = inputState(); + _o.setInputState(_oInputState); + Integer _oInputPort = hasInputPort() ? inputPort() : null; + _o.setInputPort(_oInputPort); + String _oInputError = inputError(); + _o.setInputError(_oInputError); + Long _oLastReceivedInputMillis = hasLastReceivedInputMillis() ? lastReceivedInputMillis() : null; + _o.setLastReceivedInputMillis(_oLastReceivedInputMillis); + int _oOutputState = outputState(); + _o.setOutputState(_oOutputState); + String _oOutputError = outputError(); + _o.setOutputError(_oOutputError); + String _oTargetAddress = targetAddress(); + _o.setTargetAddress(_oTargetAddress); + Integer _oTargetPort = hasTargetPort() ? targetPort() : null; + _o.setTargetPort(_oTargetPort); + int _oTargetSource = targetSource(); + _o.setTargetSource(_oTargetSource); + Long _oLastFrameSentMillis = hasLastFrameSentMillis() ? lastFrameSentMillis() : null; + _o.setLastFrameSentMillis(_oLastFrameSentMillis); + int _oOscqueryState = oscqueryState(); + _o.setOscqueryState(_oOscqueryState); + Integer _oOscqueryAdvertisedPort = hasOscqueryAdvertisedPort() ? oscqueryAdvertisedPort() : null; + _o.setOscqueryAdvertisedPort(_oOscqueryAdvertisedPort); + String _oOscqueryError = oscqueryError(); + _o.setOscqueryError(_oOscqueryError); + solarxr_protocol.rpc.VRCOSCDiscoveredTargetT[] _oDiscoveredTargets = new solarxr_protocol.rpc.VRCOSCDiscoveredTargetT[discoveredTargetsLength()]; + for (int _j = 0; _j < discoveredTargetsLength(); ++_j) {_oDiscoveredTargets[_j] = (discoveredTargets(_j) != null ? discoveredTargets(_j).unpack() : null);} + _o.setDiscoveredTargets(_oDiscoveredTargets); + } + public static int pack(FlatBufferBuilder builder, VRCOSCStatusChangeResponseT _o) { + if (_o == null) return 0; + int _inputError = _o.getInputError() == null ? 0 : builder.createString(_o.getInputError()); + int _outputError = _o.getOutputError() == null ? 0 : builder.createString(_o.getOutputError()); + int _targetAddress = _o.getTargetAddress() == null ? 0 : builder.createString(_o.getTargetAddress()); + int _oscqueryError = _o.getOscqueryError() == null ? 0 : builder.createString(_o.getOscqueryError()); + int _discoveredTargets = 0; + if (_o.getDiscoveredTargets() != null) { + int[] __discoveredTargets = new int[_o.getDiscoveredTargets().length]; + int _j = 0; + for (solarxr_protocol.rpc.VRCOSCDiscoveredTargetT _e : _o.getDiscoveredTargets()) { __discoveredTargets[_j] = solarxr_protocol.rpc.VRCOSCDiscoveredTarget.pack(builder, _e); _j++;} + _discoveredTargets = createDiscoveredTargetsVector(builder, __discoveredTargets); + } + return createVRCOSCStatusChangeResponse( + builder, + _o.getEnabled(), + _o.getInputState(), + _o.getInputPort(), + _inputError, + _o.getLastReceivedInputMillis(), + _o.getOutputState(), + _outputError, + _targetAddress, + _o.getTargetPort(), + _o.getTargetSource(), + _o.getLastFrameSentMillis(), + _o.getOscqueryState(), + _o.getOscqueryAdvertisedPort(), + _oscqueryError, + _discoveredTargets); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponseT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponseT.java new file mode 100644 index 000000000..d37960b8f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusChangeResponseT.java @@ -0,0 +1,106 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VRCOSCStatusChangeResponseT { + private boolean enabled; + private int inputState; + private Integer inputPort; + private String inputError; + private Long lastReceivedInputMillis; + private int outputState; + private String outputError; + private String targetAddress; + private Integer targetPort; + private int targetSource; + private Long lastFrameSentMillis; + private int oscqueryState; + private Integer oscqueryAdvertisedPort; + private String oscqueryError; + private solarxr_protocol.rpc.VRCOSCDiscoveredTargetT[] discoveredTargets; + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public int getInputState() { return inputState; } + + public void setInputState(int inputState) { this.inputState = inputState; } + + public Integer getInputPort() { return inputPort; } + + public void setInputPort(Integer inputPort) { this.inputPort = inputPort; } + + public String getInputError() { return inputError; } + + public void setInputError(String inputError) { this.inputError = inputError; } + + public Long getLastReceivedInputMillis() { return lastReceivedInputMillis; } + + public void setLastReceivedInputMillis(Long lastReceivedInputMillis) { this.lastReceivedInputMillis = lastReceivedInputMillis; } + + public int getOutputState() { return outputState; } + + public void setOutputState(int outputState) { this.outputState = outputState; } + + public String getOutputError() { return outputError; } + + public void setOutputError(String outputError) { this.outputError = outputError; } + + public String getTargetAddress() { return targetAddress; } + + public void setTargetAddress(String targetAddress) { this.targetAddress = targetAddress; } + + public Integer getTargetPort() { return targetPort; } + + public void setTargetPort(Integer targetPort) { this.targetPort = targetPort; } + + public int getTargetSource() { return targetSource; } + + public void setTargetSource(int targetSource) { this.targetSource = targetSource; } + + public Long getLastFrameSentMillis() { return lastFrameSentMillis; } + + public void setLastFrameSentMillis(Long lastFrameSentMillis) { this.lastFrameSentMillis = lastFrameSentMillis; } + + public int getOscqueryState() { return oscqueryState; } + + public void setOscqueryState(int oscqueryState) { this.oscqueryState = oscqueryState; } + + public Integer getOscqueryAdvertisedPort() { return oscqueryAdvertisedPort; } + + public void setOscqueryAdvertisedPort(Integer oscqueryAdvertisedPort) { this.oscqueryAdvertisedPort = oscqueryAdvertisedPort; } + + public String getOscqueryError() { return oscqueryError; } + + public void setOscqueryError(String oscqueryError) { this.oscqueryError = oscqueryError; } + + public solarxr_protocol.rpc.VRCOSCDiscoveredTargetT[] getDiscoveredTargets() { return discoveredTargets; } + + public void setDiscoveredTargets(solarxr_protocol.rpc.VRCOSCDiscoveredTargetT[] discoveredTargets) { this.discoveredTargets = discoveredTargets; } + + + public VRCOSCStatusChangeResponseT() { + this.enabled = false; + this.inputState = 0; + this.inputPort = null; + this.inputError = null; + this.lastReceivedInputMillis = null; + this.outputState = 0; + this.outputError = null; + this.targetAddress = null; + this.targetPort = null; + this.targetSource = 0; + this.lastFrameSentMillis = null; + this.oscqueryState = 0; + this.oscqueryAdvertisedPort = null; + this.oscqueryError = null; + this.discoveredTargets = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequest.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequest.java new file mode 100644 index 000000000..ad074053f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCOSCStatusRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCOSCStatusRequest getRootAsVRCOSCStatusRequest(ByteBuffer _bb) { return getRootAsVRCOSCStatusRequest(_bb, new VRCOSCStatusRequest()); } + public static VRCOSCStatusRequest getRootAsVRCOSCStatusRequest(ByteBuffer _bb, VRCOSCStatusRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRCOSCStatusRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startVRCOSCStatusRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endVRCOSCStatusRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRCOSCStatusRequest get(int j) { return get(new VRCOSCStatusRequest(), j); } + public VRCOSCStatusRequest get(VRCOSCStatusRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCOSCStatusRequestT unpack() { + VRCOSCStatusRequestT _o = new VRCOSCStatusRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCOSCStatusRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, VRCOSCStatusRequestT _o) { + if (_o == null) return 0; + startVRCOSCStatusRequest(builder); + return endVRCOSCStatusRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusSystemRequestT.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequestT.java similarity index 74% rename from protocol/java/src/solarxr_protocol/rpc/StatusSystemRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequestT.java index 6564046f9..af246b196 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StatusSystemRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCStatusRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class StatusSystemRequestT { +public class VRCOSCStatusRequestT { - public StatusSystemRequestT() { + public VRCOSCStatusRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCOSCTargetSource.java b/protocol/java/src/solarxr_protocol/rpc/VRCOSCTargetSource.java new file mode 100644 index 000000000..4289520ab --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCOSCTargetSource.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class VRCOSCTargetSource { + private VRCOSCTargetSource() { } + public static final int NONE = 0; + public static final int MANUAL = 1; + public static final int DISCOVERED = 2; + + public static final String[] names = { "NONE", "MANUAL", "DISCOVERED", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRMSettings.java b/protocol/java/src/solarxr_protocol/rpc/VRMSettings.java deleted file mode 100644 index 8eb7f59ed..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VRMSettings.java +++ /dev/null @@ -1,62 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * VRM Settings for rescaling to avatar-scale - */ -@SuppressWarnings("unused") -public final class VRMSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static VRMSettings getRootAsVRMSettings(ByteBuffer _bb) { return getRootAsVRMSettings(_bb, new VRMSettings()); } - public static VRMSettings getRootAsVRMSettings(ByteBuffer _bb, VRMSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public VRMSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public String vrmJson() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } - public ByteBuffer vrmJsonAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } - public ByteBuffer vrmJsonInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } - - public static int createVRMSettings(FlatBufferBuilder builder, - int vrmJsonOffset) { - builder.startTable(1); - VRMSettings.addVrmJson(builder, vrmJsonOffset); - return VRMSettings.endVRMSettings(builder); - } - - public static void startVRMSettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addVrmJson(FlatBufferBuilder builder, int vrmJsonOffset) { builder.addOffset(0, vrmJsonOffset, 0); } - public static int endVRMSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public VRMSettings get(int j) { return get(new VRMSettings(), j); } - public VRMSettings get(VRMSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public VRMSettingsT unpack() { - VRMSettingsT _o = new VRMSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(VRMSettingsT _o) { - String _oVrmJson = vrmJson(); - _o.setVrmJson(_oVrmJson); - } - public static int pack(FlatBufferBuilder builder, VRMSettingsT _o) { - if (_o == null) return 0; - int _vrmJson = _o.getVrmJson() == null ? 0 : builder.createString(_o.getVrmJson()); - return createVRMSettings( - builder, - _vrmJson); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequest.java b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequest.java new file mode 100644 index 000000000..91a32736f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRMSettingsRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRMSettingsRequest getRootAsVRMSettingsRequest(ByteBuffer _bb) { return getRootAsVRMSettingsRequest(_bb, new VRMSettingsRequest()); } + public static VRMSettingsRequest getRootAsVRMSettingsRequest(ByteBuffer _bb, VRMSettingsRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRMSettingsRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startVRMSettingsRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endVRMSettingsRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRMSettingsRequest get(int j) { return get(new VRMSettingsRequest(), j); } + public VRMSettingsRequest get(VRMSettingsRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRMSettingsRequestT unpack() { + VRMSettingsRequestT _o = new VRMSettingsRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRMSettingsRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, VRMSettingsRequestT _o) { + if (_o == null) return 0; + startVRMSettingsRequest(builder); + return endVRMSettingsRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/SettingsRequestT.java b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequestT.java similarity index 75% rename from protocol/java/src/solarxr_protocol/rpc/SettingsRequestT.java rename to protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequestT.java index 3573f6554..cb5c188d2 100644 --- a/protocol/java/src/solarxr_protocol/rpc/SettingsRequestT.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsRequestT.java @@ -7,10 +7,10 @@ import java.util.*; import com.google.flatbuffers.*; -public class SettingsRequestT { +public class VRMSettingsRequestT { - public SettingsRequestT() { + public VRMSettingsRequestT() { } } diff --git a/protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponse.java b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponse.java new file mode 100644 index 000000000..4cc5cbaaa --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponse.java @@ -0,0 +1,59 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRMSettingsResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRMSettingsResponse getRootAsVRMSettingsResponse(ByteBuffer _bb) { return getRootAsVRMSettingsResponse(_bb, new VRMSettingsResponse()); } + public static VRMSettingsResponse getRootAsVRMSettingsResponse(ByteBuffer _bb, VRMSettingsResponse obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public VRMSettingsResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String vrmJson() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer vrmJsonAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer vrmJsonInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + + public static int createVRMSettingsResponse(FlatBufferBuilder builder, + int vrmJsonOffset) { + builder.startTable(1); + VRMSettingsResponse.addVrmJson(builder, vrmJsonOffset); + return VRMSettingsResponse.endVRMSettingsResponse(builder); + } + + public static void startVRMSettingsResponse(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addVrmJson(FlatBufferBuilder builder, int vrmJsonOffset) { builder.addOffset(0, vrmJsonOffset, 0); } + public static int endVRMSettingsResponse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public VRMSettingsResponse get(int j) { return get(new VRMSettingsResponse(), j); } + public VRMSettingsResponse get(VRMSettingsResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRMSettingsResponseT unpack() { + VRMSettingsResponseT _o = new VRMSettingsResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRMSettingsResponseT _o) { + String _oVrmJson = vrmJson(); + _o.setVrmJson(_oVrmJson); + } + public static int pack(FlatBufferBuilder builder, VRMSettingsResponseT _o) { + if (_o == null) return 0; + int _vrmJson = _o.getVrmJson() == null ? 0 : builder.createString(_o.getVrmJson()); + return createVRMSettingsResponse( + builder, + _vrmJson); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRMSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponseT.java similarity index 84% rename from protocol/java/src/solarxr_protocol/rpc/VRMSettingsT.java rename to protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponseT.java index a4648efc5..3b2ec0275 100644 --- a/protocol/java/src/solarxr_protocol/rpc/VRMSettingsT.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRMSettingsResponseT.java @@ -7,7 +7,7 @@ import java.util.*; import com.google.flatbuffers.*; -public class VRMSettingsT { +public class VRMSettingsResponseT { private String vrmJson; public String getVrmJson() { return vrmJson; } @@ -15,7 +15,7 @@ public class VRMSettingsT { public void setVrmJson(String vrmJson) { this.vrmJson = vrmJson; } - public VRMSettingsT() { + public VRMSettingsResponseT() { this.vrmJson = null; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/VelocitySettings.java b/protocol/java/src/solarxr_protocol/rpc/VelocitySettings.java deleted file mode 100644 index e58a77eec..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VelocitySettings.java +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class VelocitySettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static VelocitySettings getRootAsVelocitySettings(ByteBuffer _bb) { return getRootAsVelocitySettings(_bb, new VelocitySettings()); } - public static VelocitySettings getRootAsVelocitySettings(ByteBuffer _bb, VelocitySettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public VelocitySettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean sendDerivedVelocity() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createVelocitySettings(FlatBufferBuilder builder, - boolean sendDerivedVelocity) { - builder.startTable(1); - VelocitySettings.addSendDerivedVelocity(builder, sendDerivedVelocity); - return VelocitySettings.endVelocitySettings(builder); - } - - public static void startVelocitySettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addSendDerivedVelocity(FlatBufferBuilder builder, boolean sendDerivedVelocity) { builder.addBoolean(0, sendDerivedVelocity, false); } - public static int endVelocitySettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public VelocitySettings get(int j) { return get(new VelocitySettings(), j); } - public VelocitySettings get(VelocitySettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public VelocitySettingsT unpack() { - VelocitySettingsT _o = new VelocitySettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(VelocitySettingsT _o) { - boolean _oSendDerivedVelocity = sendDerivedVelocity(); - _o.setSendDerivedVelocity(_oSendDerivedVelocity); - } - public static int pack(FlatBufferBuilder builder, VelocitySettingsT _o) { - if (_o == null) return 0; - return createVelocitySettings( - builder, - _o.getSendDerivedVelocity()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/VelocitySettingsT.java b/protocol/java/src/solarxr_protocol/rpc/VelocitySettingsT.java deleted file mode 100644 index 6814df815..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/VelocitySettingsT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class VelocitySettingsT { - private boolean sendDerivedVelocity; - - public boolean getSendDerivedVelocity() { return sendDerivedVelocity; } - - public void setSendDerivedVelocity(boolean sendDerivedVelocity) { this.sendDerivedVelocity = sendDerivedVelocity; } - - - public VelocitySettingsT() { - this.sendDerivedVelocity = false; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettings.java b/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettings.java deleted file mode 100644 index 2752124c2..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettings.java +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -@SuppressWarnings("unused") -public final class LegTweaksSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static LegTweaksSettings getRootAsLegTweaksSettings(ByteBuffer _bb) { return getRootAsLegTweaksSettings(_bb, new LegTweaksSettings()); } - public static LegTweaksSettings getRootAsLegTweaksSettings(ByteBuffer _bb, LegTweaksSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public LegTweaksSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean hasCorrectionStrength() { return 0 != __offset(4); } - public float correctionStrength() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - - public static int createLegTweaksSettings(FlatBufferBuilder builder, - float correctionStrength) { - builder.startTable(1); - LegTweaksSettings.addCorrectionStrength(builder, correctionStrength); - return LegTweaksSettings.endLegTweaksSettings(builder); - } - - public static void startLegTweaksSettings(FlatBufferBuilder builder) { builder.startTable(1); } - public static void addCorrectionStrength(FlatBufferBuilder builder, float correctionStrength) { builder.addFloat(0, correctionStrength, 0f); } - public static int endLegTweaksSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public LegTweaksSettings get(int j) { return get(new LegTweaksSettings(), j); } - public LegTweaksSettings get(LegTweaksSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public LegTweaksSettingsT unpack() { - LegTweaksSettingsT _o = new LegTweaksSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(LegTweaksSettingsT _o) { - Float _oCorrectionStrength = hasCorrectionStrength() ? correctionStrength() : null; - _o.setCorrectionStrength(_oCorrectionStrength); - } - public static int pack(FlatBufferBuilder builder, LegTweaksSettingsT _o) { - if (_o == null) return 0; - return createLegTweaksSettings( - builder, - _o.getCorrectionStrength()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettingsT.java deleted file mode 100644 index 8074919d8..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/LegTweaksSettingsT.java +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class LegTweaksSettingsT { - private Float correctionStrength; - - public Float getCorrectionStrength() { return correctionStrength; } - - public void setCorrectionStrength(Float correctionStrength) { this.correctionStrength = correctionStrength; } - - - public LegTweaksSettingsT() { - this.correctionStrength = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatios.java b/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatios.java deleted file mode 100644 index 9617d3bc1..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatios.java +++ /dev/null @@ -1,118 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Settings for the skeletal model that are ratios. - * These values range from 0 to 1. - */ -@SuppressWarnings("unused") -public final class ModelRatios extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ModelRatios getRootAsModelRatios(ByteBuffer _bb) { return getRootAsModelRatios(_bb, new ModelRatios()); } - public static ModelRatios getRootAsModelRatios(ByteBuffer _bb, ModelRatios obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ModelRatios __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean hasImputeWaistFromChestHip() { return 0 != __offset(4); } - public float imputeWaistFromChestHip() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasImputeWaistFromChestLegs() { return 0 != __offset(6); } - public float imputeWaistFromChestLegs() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasImputeHipFromChestLegs() { return 0 != __offset(8); } - public float imputeHipFromChestLegs() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - public boolean hasImputeHipFromWaistLegs() { return 0 != __offset(10); } - public float imputeHipFromWaistLegs() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - /** - * Hip's yaw and roll is set to the average of legs when 1.0 - */ - public boolean hasInterpHipLegs() { return 0 != __offset(12); } - public float interpHipLegs() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - /** - * Knee trackers' yaw and roll is set to the lower leg's when 1.0 - */ - public boolean hasInterpKneeTrackerAnkle() { return 0 != __offset(14); } - public float interpKneeTrackerAnkle() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - /** - * Upper leg's yaw and roll is set to the lower leg's when 1.0 - */ - public boolean hasInterpKneeAnkle() { return 0 != __offset(16); } - public float interpKneeAnkle() { int o = __offset(16); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; } - - public static int createModelRatios(FlatBufferBuilder builder, - float imputeWaistFromChestHip, - float imputeWaistFromChestLegs, - float imputeHipFromChestLegs, - float imputeHipFromWaistLegs, - float interpHipLegs, - float interpKneeTrackerAnkle, - float interpKneeAnkle) { - builder.startTable(7); - ModelRatios.addInterpKneeAnkle(builder, interpKneeAnkle); - ModelRatios.addInterpKneeTrackerAnkle(builder, interpKneeTrackerAnkle); - ModelRatios.addInterpHipLegs(builder, interpHipLegs); - ModelRatios.addImputeHipFromWaistLegs(builder, imputeHipFromWaistLegs); - ModelRatios.addImputeHipFromChestLegs(builder, imputeHipFromChestLegs); - ModelRatios.addImputeWaistFromChestLegs(builder, imputeWaistFromChestLegs); - ModelRatios.addImputeWaistFromChestHip(builder, imputeWaistFromChestHip); - return ModelRatios.endModelRatios(builder); - } - - public static void startModelRatios(FlatBufferBuilder builder) { builder.startTable(7); } - public static void addImputeWaistFromChestHip(FlatBufferBuilder builder, float imputeWaistFromChestHip) { builder.addFloat(0, imputeWaistFromChestHip, 0f); } - public static void addImputeWaistFromChestLegs(FlatBufferBuilder builder, float imputeWaistFromChestLegs) { builder.addFloat(1, imputeWaistFromChestLegs, 0f); } - public static void addImputeHipFromChestLegs(FlatBufferBuilder builder, float imputeHipFromChestLegs) { builder.addFloat(2, imputeHipFromChestLegs, 0f); } - public static void addImputeHipFromWaistLegs(FlatBufferBuilder builder, float imputeHipFromWaistLegs) { builder.addFloat(3, imputeHipFromWaistLegs, 0f); } - public static void addInterpHipLegs(FlatBufferBuilder builder, float interpHipLegs) { builder.addFloat(4, interpHipLegs, 0f); } - public static void addInterpKneeTrackerAnkle(FlatBufferBuilder builder, float interpKneeTrackerAnkle) { builder.addFloat(5, interpKneeTrackerAnkle, 0f); } - public static void addInterpKneeAnkle(FlatBufferBuilder builder, float interpKneeAnkle) { builder.addFloat(6, interpKneeAnkle, 0f); } - public static int endModelRatios(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ModelRatios get(int j) { return get(new ModelRatios(), j); } - public ModelRatios get(ModelRatios obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ModelRatiosT unpack() { - ModelRatiosT _o = new ModelRatiosT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ModelRatiosT _o) { - Float _oImputeWaistFromChestHip = hasImputeWaistFromChestHip() ? imputeWaistFromChestHip() : null; - _o.setImputeWaistFromChestHip(_oImputeWaistFromChestHip); - Float _oImputeWaistFromChestLegs = hasImputeWaistFromChestLegs() ? imputeWaistFromChestLegs() : null; - _o.setImputeWaistFromChestLegs(_oImputeWaistFromChestLegs); - Float _oImputeHipFromChestLegs = hasImputeHipFromChestLegs() ? imputeHipFromChestLegs() : null; - _o.setImputeHipFromChestLegs(_oImputeHipFromChestLegs); - Float _oImputeHipFromWaistLegs = hasImputeHipFromWaistLegs() ? imputeHipFromWaistLegs() : null; - _o.setImputeHipFromWaistLegs(_oImputeHipFromWaistLegs); - Float _oInterpHipLegs = hasInterpHipLegs() ? interpHipLegs() : null; - _o.setInterpHipLegs(_oInterpHipLegs); - Float _oInterpKneeTrackerAnkle = hasInterpKneeTrackerAnkle() ? interpKneeTrackerAnkle() : null; - _o.setInterpKneeTrackerAnkle(_oInterpKneeTrackerAnkle); - Float _oInterpKneeAnkle = hasInterpKneeAnkle() ? interpKneeAnkle() : null; - _o.setInterpKneeAnkle(_oInterpKneeAnkle); - } - public static int pack(FlatBufferBuilder builder, ModelRatiosT _o) { - if (_o == null) return 0; - return createModelRatios( - builder, - _o.getImputeWaistFromChestHip(), - _o.getImputeWaistFromChestLegs(), - _o.getImputeHipFromChestLegs(), - _o.getImputeHipFromWaistLegs(), - _o.getInterpHipLegs(), - _o.getInterpKneeTrackerAnkle(), - _o.getInterpKneeAnkle()); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatiosT.java b/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatiosT.java deleted file mode 100644 index e5db3eb59..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelRatiosT.java +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class ModelRatiosT { - private Float imputeWaistFromChestHip; - private Float imputeWaistFromChestLegs; - private Float imputeHipFromChestLegs; - private Float imputeHipFromWaistLegs; - private Float interpHipLegs; - private Float interpKneeTrackerAnkle; - private Float interpKneeAnkle; - - public Float getImputeWaistFromChestHip() { return imputeWaistFromChestHip; } - - public void setImputeWaistFromChestHip(Float imputeWaistFromChestHip) { this.imputeWaistFromChestHip = imputeWaistFromChestHip; } - - public Float getImputeWaistFromChestLegs() { return imputeWaistFromChestLegs; } - - public void setImputeWaistFromChestLegs(Float imputeWaistFromChestLegs) { this.imputeWaistFromChestLegs = imputeWaistFromChestLegs; } - - public Float getImputeHipFromChestLegs() { return imputeHipFromChestLegs; } - - public void setImputeHipFromChestLegs(Float imputeHipFromChestLegs) { this.imputeHipFromChestLegs = imputeHipFromChestLegs; } - - public Float getImputeHipFromWaistLegs() { return imputeHipFromWaistLegs; } - - public void setImputeHipFromWaistLegs(Float imputeHipFromWaistLegs) { this.imputeHipFromWaistLegs = imputeHipFromWaistLegs; } - - public Float getInterpHipLegs() { return interpHipLegs; } - - public void setInterpHipLegs(Float interpHipLegs) { this.interpHipLegs = interpHipLegs; } - - public Float getInterpKneeTrackerAnkle() { return interpKneeTrackerAnkle; } - - public void setInterpKneeTrackerAnkle(Float interpKneeTrackerAnkle) { this.interpKneeTrackerAnkle = interpKneeTrackerAnkle; } - - public Float getInterpKneeAnkle() { return interpKneeAnkle; } - - public void setInterpKneeAnkle(Float interpKneeAnkle) { this.interpKneeAnkle = interpKneeAnkle; } - - - public ModelRatiosT() { - this.imputeWaistFromChestHip = null; - this.imputeWaistFromChestLegs = null; - this.imputeHipFromChestLegs = null; - this.imputeHipFromWaistLegs = null; - this.interpHipLegs = null; - this.interpKneeTrackerAnkle = null; - this.interpKneeAnkle = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettings.java b/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettings.java deleted file mode 100644 index 16905b5ba..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettings.java +++ /dev/null @@ -1,88 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Settings for the skeletal model. - */ -@SuppressWarnings("unused") -public final class ModelSettings extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ModelSettings getRootAsModelSettings(ByteBuffer _bb) { return getRootAsModelSettings(_bb, new ModelSettings()); } - public static ModelSettings getRootAsModelSettings(ByteBuffer _bb, ModelSettings obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ModelSettings __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public solarxr_protocol.rpc.settings.ModelToggles toggles() { return toggles(new solarxr_protocol.rpc.settings.ModelToggles()); } - public solarxr_protocol.rpc.settings.ModelToggles toggles(solarxr_protocol.rpc.settings.ModelToggles obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.settings.ModelRatios ratios() { return ratios(new solarxr_protocol.rpc.settings.ModelRatios()); } - public solarxr_protocol.rpc.settings.ModelRatios ratios(solarxr_protocol.rpc.settings.ModelRatios obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.settings.LegTweaksSettings legTweaks() { return legTweaks(new solarxr_protocol.rpc.settings.LegTweaksSettings()); } - public solarxr_protocol.rpc.settings.LegTweaksSettings legTweaks(solarxr_protocol.rpc.settings.LegTweaksSettings obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - public solarxr_protocol.rpc.settings.SkeletonHeight skeletonHeight() { return skeletonHeight(new solarxr_protocol.rpc.settings.SkeletonHeight()); } - public solarxr_protocol.rpc.settings.SkeletonHeight skeletonHeight(solarxr_protocol.rpc.settings.SkeletonHeight obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } - - public static int createModelSettings(FlatBufferBuilder builder, - int togglesOffset, - int ratiosOffset, - int legTweaksOffset, - int skeletonHeightOffset) { - builder.startTable(4); - ModelSettings.addSkeletonHeight(builder, skeletonHeightOffset); - ModelSettings.addLegTweaks(builder, legTweaksOffset); - ModelSettings.addRatios(builder, ratiosOffset); - ModelSettings.addToggles(builder, togglesOffset); - return ModelSettings.endModelSettings(builder); - } - - public static void startModelSettings(FlatBufferBuilder builder) { builder.startTable(4); } - public static void addToggles(FlatBufferBuilder builder, int togglesOffset) { builder.addOffset(0, togglesOffset, 0); } - public static void addRatios(FlatBufferBuilder builder, int ratiosOffset) { builder.addOffset(1, ratiosOffset, 0); } - public static void addLegTweaks(FlatBufferBuilder builder, int legTweaksOffset) { builder.addOffset(2, legTweaksOffset, 0); } - public static void addSkeletonHeight(FlatBufferBuilder builder, int skeletonHeightOffset) { builder.addOffset(3, skeletonHeightOffset, 0); } - public static int endModelSettings(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ModelSettings get(int j) { return get(new ModelSettings(), j); } - public ModelSettings get(ModelSettings obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ModelSettingsT unpack() { - ModelSettingsT _o = new ModelSettingsT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ModelSettingsT _o) { - if (toggles() != null) _o.setToggles(toggles().unpack()); - else _o.setToggles(null); - if (ratios() != null) _o.setRatios(ratios().unpack()); - else _o.setRatios(null); - if (legTweaks() != null) _o.setLegTweaks(legTweaks().unpack()); - else _o.setLegTweaks(null); - if (skeletonHeight() != null) _o.setSkeletonHeight(skeletonHeight().unpack()); - else _o.setSkeletonHeight(null); - } - public static int pack(FlatBufferBuilder builder, ModelSettingsT _o) { - if (_o == null) return 0; - int _toggles = _o.getToggles() == null ? 0 : solarxr_protocol.rpc.settings.ModelToggles.pack(builder, _o.getToggles()); - int _ratios = _o.getRatios() == null ? 0 : solarxr_protocol.rpc.settings.ModelRatios.pack(builder, _o.getRatios()); - int _legTweaks = _o.getLegTweaks() == null ? 0 : solarxr_protocol.rpc.settings.LegTweaksSettings.pack(builder, _o.getLegTweaks()); - int _skeletonHeight = _o.getSkeletonHeight() == null ? 0 : solarxr_protocol.rpc.settings.SkeletonHeight.pack(builder, _o.getSkeletonHeight()); - return createModelSettings( - builder, - _toggles, - _ratios, - _legTweaks, - _skeletonHeight); - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettingsT.java b/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettingsT.java deleted file mode 100644 index 59ff528e3..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelSettingsT.java +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -public class ModelSettingsT { - private solarxr_protocol.rpc.settings.ModelTogglesT toggles; - private solarxr_protocol.rpc.settings.ModelRatiosT ratios; - private solarxr_protocol.rpc.settings.LegTweaksSettingsT legTweaks; - private solarxr_protocol.rpc.settings.SkeletonHeightT skeletonHeight; - - public solarxr_protocol.rpc.settings.ModelTogglesT getToggles() { return toggles; } - - public void setToggles(solarxr_protocol.rpc.settings.ModelTogglesT toggles) { this.toggles = toggles; } - - public solarxr_protocol.rpc.settings.ModelRatiosT getRatios() { return ratios; } - - public void setRatios(solarxr_protocol.rpc.settings.ModelRatiosT ratios) { this.ratios = ratios; } - - public solarxr_protocol.rpc.settings.LegTweaksSettingsT getLegTweaks() { return legTweaks; } - - public void setLegTweaks(solarxr_protocol.rpc.settings.LegTweaksSettingsT legTweaks) { this.legTweaks = legTweaks; } - - public solarxr_protocol.rpc.settings.SkeletonHeightT getSkeletonHeight() { return skeletonHeight; } - - public void setSkeletonHeight(solarxr_protocol.rpc.settings.SkeletonHeightT skeletonHeight) { this.skeletonHeight = skeletonHeight; } - - - public ModelSettingsT() { - this.toggles = null; - this.ratios = null; - this.legTweaks = null; - this.skeletonHeight = null; - } -} - diff --git a/protocol/java/src/solarxr_protocol/rpc/settings/ModelToggles.java b/protocol/java/src/solarxr_protocol/rpc/settings/ModelToggles.java deleted file mode 100644 index 80fb77f54..000000000 --- a/protocol/java/src/solarxr_protocol/rpc/settings/ModelToggles.java +++ /dev/null @@ -1,148 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings; - -import java.nio.*; -import java.lang.*; -import java.util.*; -import com.google.flatbuffers.*; - -/** - * Settings for the skeletal model that are toggles. - */ -@SuppressWarnings("unused") -public final class ModelToggles extends Table { - public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } - public static ModelToggles getRootAsModelToggles(ByteBuffer _bb) { return getRootAsModelToggles(_bb, new ModelToggles()); } - public static ModelToggles getRootAsModelToggles(ByteBuffer _bb, ModelToggles obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } - public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } - public ModelToggles __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - - public boolean hasExtendedSpine() { return 0 != __offset(4); } - public boolean extendedSpine() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasExtendedPelvis() { return 0 != __offset(6); } - public boolean extendedPelvis() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasExtendedKnee() { return 0 != __offset(8); } - public boolean extendedKnee() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasForceArmsFromHmd() { return 0 != __offset(10); } - public boolean forceArmsFromHmd() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasFloorClip() { return 0 != __offset(12); } - public boolean floorClip() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasSkatingCorrection() { return 0 != __offset(14); } - public boolean skatingCorrection() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasToeSnap() { return 0 != __offset(18); } - public boolean toeSnap() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasFootPlant() { return 0 != __offset(20); } - public boolean footPlant() { int o = __offset(20); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasSelfLocalization() { return 0 != __offset(22); } - public boolean selfLocalization() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasUsePosition() { return 0 != __offset(24); } - public boolean usePosition() { int o = __offset(24); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasEnforceConstraints() { return 0 != __offset(26); } - public boolean enforceConstraints() { int o = __offset(26); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - public boolean hasCorrectConstraints() { return 0 != __offset(28); } - public boolean correctConstraints() { int o = __offset(28); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } - - public static int createModelToggles(FlatBufferBuilder builder, - boolean extendedSpine, - boolean extendedPelvis, - boolean extendedKnee, - boolean forceArmsFromHmd, - boolean floorClip, - boolean skatingCorrection, - boolean toeSnap, - boolean footPlant, - boolean selfLocalization, - boolean usePosition, - boolean enforceConstraints, - boolean correctConstraints) { - builder.startTable(13); - ModelToggles.addCorrectConstraints(builder, correctConstraints); - ModelToggles.addEnforceConstraints(builder, enforceConstraints); - ModelToggles.addUsePosition(builder, usePosition); - ModelToggles.addSelfLocalization(builder, selfLocalization); - ModelToggles.addFootPlant(builder, footPlant); - ModelToggles.addToeSnap(builder, toeSnap); - ModelToggles.addSkatingCorrection(builder, skatingCorrection); - ModelToggles.addFloorClip(builder, floorClip); - ModelToggles.addForceArmsFromHmd(builder, forceArmsFromHmd); - ModelToggles.addExtendedKnee(builder, extendedKnee); - ModelToggles.addExtendedPelvis(builder, extendedPelvis); - ModelToggles.addExtendedSpine(builder, extendedSpine); - return ModelToggles.endModelToggles(builder); - } - - public static void startModelToggles(FlatBufferBuilder builder) { builder.startTable(13); } - public static void addExtendedSpine(FlatBufferBuilder builder, boolean extendedSpine) { builder.addBoolean(0, extendedSpine, false); } - public static void addExtendedPelvis(FlatBufferBuilder builder, boolean extendedPelvis) { builder.addBoolean(1, extendedPelvis, false); } - public static void addExtendedKnee(FlatBufferBuilder builder, boolean extendedKnee) { builder.addBoolean(2, extendedKnee, false); } - public static void addForceArmsFromHmd(FlatBufferBuilder builder, boolean forceArmsFromHmd) { builder.addBoolean(3, forceArmsFromHmd, false); } - public static void addFloorClip(FlatBufferBuilder builder, boolean floorClip) { builder.addBoolean(4, floorClip, false); } - public static void addSkatingCorrection(FlatBufferBuilder builder, boolean skatingCorrection) { builder.addBoolean(5, skatingCorrection, false); } - public static void addToeSnap(FlatBufferBuilder builder, boolean toeSnap) { builder.addBoolean(7, toeSnap, false); } - public static void addFootPlant(FlatBufferBuilder builder, boolean footPlant) { builder.addBoolean(8, footPlant, false); } - public static void addSelfLocalization(FlatBufferBuilder builder, boolean selfLocalization) { builder.addBoolean(9, selfLocalization, false); } - public static void addUsePosition(FlatBufferBuilder builder, boolean usePosition) { builder.addBoolean(10, usePosition, false); } - public static void addEnforceConstraints(FlatBufferBuilder builder, boolean enforceConstraints) { builder.addBoolean(11, enforceConstraints, false); } - public static void addCorrectConstraints(FlatBufferBuilder builder, boolean correctConstraints) { builder.addBoolean(12, correctConstraints, false); } - public static int endModelToggles(FlatBufferBuilder builder) { - int o = builder.endTable(); - return o; - } - - public static final class Vector extends BaseVector { - public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } - - public ModelToggles get(int j) { return get(new ModelToggles(), j); } - public ModelToggles get(ModelToggles obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } - } - public ModelTogglesT unpack() { - ModelTogglesT _o = new ModelTogglesT(); - unpackTo(_o); - return _o; - } - public void unpackTo(ModelTogglesT _o) { - Boolean _oExtendedSpine = hasExtendedSpine() ? extendedSpine() : null; - _o.setExtendedSpine(_oExtendedSpine); - Boolean _oExtendedPelvis = hasExtendedPelvis() ? extendedPelvis() : null; - _o.setExtendedPelvis(_oExtendedPelvis); - Boolean _oExtendedKnee = hasExtendedKnee() ? extendedKnee() : null; - _o.setExtendedKnee(_oExtendedKnee); - Boolean _oForceArmsFromHmd = hasForceArmsFromHmd() ? forceArmsFromHmd() : null; - _o.setForceArmsFromHmd(_oForceArmsFromHmd); - Boolean _oFloorClip = hasFloorClip() ? floorClip() : null; - _o.setFloorClip(_oFloorClip); - Boolean _oSkatingCorrection = hasSkatingCorrection() ? skatingCorrection() : null; - _o.setSkatingCorrection(_oSkatingCorrection); - Boolean _oToeSnap = hasToeSnap() ? toeSnap() : null; - _o.setToeSnap(_oToeSnap); - Boolean _oFootPlant = hasFootPlant() ? footPlant() : null; - _o.setFootPlant(_oFootPlant); - Boolean _oSelfLocalization = hasSelfLocalization() ? selfLocalization() : null; - _o.setSelfLocalization(_oSelfLocalization); - Boolean _oUsePosition = hasUsePosition() ? usePosition() : null; - _o.setUsePosition(_oUsePosition); - Boolean _oEnforceConstraints = hasEnforceConstraints() ? enforceConstraints() : null; - _o.setEnforceConstraints(_oEnforceConstraints); - Boolean _oCorrectConstraints = hasCorrectConstraints() ? correctConstraints() : null; - _o.setCorrectConstraints(_oCorrectConstraints); - } - public static int pack(FlatBufferBuilder builder, ModelTogglesT _o) { - if (_o == null) return 0; - return createModelToggles( - builder, - _o.getExtendedSpine(), - _o.getExtendedPelvis(), - _o.getExtendedKnee(), - _o.getForceArmsFromHmd(), - _o.getFloorClip(), - _o.getSkatingCorrection(), - _o.getToeSnap(), - _o.getFootPlant(), - _o.getSelfLocalization(), - _o.getUsePosition(), - _o.getEnforceConstraints(), - _o.getCorrectConstraints()); - } -} - diff --git a/protocol/kotlin/.gitignore b/protocol/kotlin/.gitignore index 1b6985c00..472681f52 100644 --- a/protocol/kotlin/.gitignore +++ b/protocol/kotlin/.gitignore @@ -1,5 +1,5 @@ # Ignore Gradle project-specific cache directory .gradle - +.kotlin # Ignore Gradle build output directory build diff --git a/protocol/kotlin/build.gradle.kts b/protocol/kotlin/build.gradle.kts index 063088d84..053d7451d 100644 --- a/protocol/kotlin/build.gradle.kts +++ b/protocol/kotlin/build.gradle.kts @@ -5,52 +5,33 @@ * For more details take a look at the 'Building Java & JVM projects' chapter in the Gradle * User Manual available at https://docs.gradle.org/7.5.1/userguide/building_java_projects.html */ +import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.tasks.KotlinCompile plugins { - // Apply the org.jetbrains.kotlin.jvm Plugin to add support for Kotlin. - kotlin("jvm") - - // Apply the java-library plugin for API and implementation separation. - `java-library` + kotlin("multiplatform") } repositories { - // Use Maven Central for resolving dependencies. mavenCentral() } -java.sourceSets["main"].java { - srcDir("src") -} - -tasks.withType { - kotlinOptions.jvmTarget = "11" -} - -// Set compiler to use UTF-8 -tasks.withType { - options.encoding = "UTF-8" -} -tasks.withType { - systemProperty("file.encoding", "UTF-8") -} -tasks.withType { - options.encoding = "UTF-8" -} - -java { - sourceCompatibility = JavaVersion.VERSION_11 - targetCompatibility = JavaVersion.VERSION_11 -} - -dependencies { - // Align versions of all Kotlin components - implementation(platform("org.jetbrains.kotlin:kotlin-bom")) - - // Use the Kotlin JDK 8 standard library. - implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8") - - // Currently flatbuffers kotlin's version only works with the JVM (including Android) - implementation("com.google.flatbuffers:flatbuffers-java:22.10.26") +kotlin { + jvm { + compilerOptions { + jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_24) + } + } + jvmToolchain(24) + + sourceSets { + val commonMain by getting { + kotlin.srcDirs("src/commonMain/kotlin", "src/generated/kotlin") + } + val jvmMain by getting { + dependencies { + implementation("com.google.flatbuffers:flatbuffers-java:22.10.26") + } + } + } } diff --git a/protocol/kotlin/settings.gradle.kts b/protocol/kotlin/settings.gradle.kts deleted file mode 100644 index 191765345..000000000 --- a/protocol/kotlin/settings.gradle.kts +++ /dev/null @@ -1,10 +0,0 @@ -/* - * This file was generated by the Gradle 'init' task. - * - * The settings file is used to specify which projects to include in your build. - * - * Detailed information about configuring a multi-project build in Gradle can be found - * in the user manual at https://docs.gradle.org/7.5.1/userguide/multi_project_builds.html - */ - -rootProject.name = "solarxr-protocol" diff --git a/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/CommonRuntime.kt b/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/CommonRuntime.kt new file mode 100644 index 000000000..0b74bea06 --- /dev/null +++ b/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/CommonRuntime.kt @@ -0,0 +1,11 @@ +package dev.slimevr.fbscodegen.runtime + +fun readFlatBufferString(bb: FlatBufferReader, offset: Int): String { + val stringOffset = offset + bb.getInt(offset) + val length = bb.getInt(stringOffset) + val bytes = ByteArray(length) + for (i in 0 until length) { + bytes[i] = bb.get(stringOffset + 4 + i) + } + return bytes.decodeToString() +} diff --git a/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/Interfaces.kt b/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/Interfaces.kt new file mode 100644 index 000000000..062107f48 --- /dev/null +++ b/protocol/kotlin/src/commonMain/kotlin/dev/slimevr/fbscodegen/runtime/Interfaces.kt @@ -0,0 +1,51 @@ +package dev.slimevr.fbscodegen.runtime + +/** + * Common interface for reading from a FlatBuffer. + * This abstracts away platform-specific buffer types like java.nio.ByteBuffer. + */ +interface FlatBufferReader { + fun get(offset: Int): Byte + fun getShort(offset: Int): Short + fun getInt(offset: Int): Int + fun getLong(offset: Int): Long + fun getFloat(offset: Int): Float + fun getDouble(offset: Int): Double +} + +/** + * Common interface for writing to a FlatBuffer. + * This abstracts away the FlatBufferBuilder implementation. + */ +interface FlatBufferWriter { + fun startTable(numFields: Int) + fun endTable(): Int + fun finish(rootOffset: Int) + fun createString(s: String): Int + fun addOffset(slot: Int, offset: Int, default: Int) + fun addByte(slot: Int, value: Byte, default: Int) + fun addShort(slot: Int, value: Short, default: Int) + fun addInt(slot: Int, value: Int, default: Int) + fun addLong(slot: Int, value: Long, default: Long) + fun addFloat(slot: Int, value: Float, default: Double) + fun addDouble(slot: Int, value: Double, default: Double) + fun addBoolean(slot: Int, value: Boolean, default: Boolean) + fun addStruct(slot: Int, offset: Int, default: Int) + + fun prep(size: Int, additionalBytes: Int) + fun pad(count: Int) + fun putByte(value: Byte) + fun putShort(value: Short) + fun putInt(value: Int) + fun putLong(value: Long) + fun putFloat(value: Float) + fun putDouble(value: Double) + fun offset(): Int + + fun startVector(elemSize: Int, numElems: Int, alignment: Int) + fun endVector(): Int + fun createByteVector(bytes: ByteArray): Int + fun createVectorOfTables(offsets: IntArray): Int + + fun forceDefaults(force: Boolean) +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/All.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/All.kt new file mode 100644 index 000000000..f2c7979ad --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/All.kt @@ -0,0 +1,42 @@ +package solarxr_protocol + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Int +import kotlin.collections.List +import solarxr_protocol.data_feed.DataFeedMessageHeader +import solarxr_protocol.rpc.RpcMessageHeader + +/** + * MessageBundle contains all of the messages for the data feed system and the + * rpc system that will be sent in one buffer. + */ +public data class MessageBundle( + public val dataFeedMsgs: List? = null, + public val rpcMsgs: List? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_dataFeedMsgs = dataFeedMsgs?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_rpcMsgs = rpcMsgs?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(2) + __off_dataFeedMsgs?.let { builder.addOffset(0, it, 0) } + __off_rpcMsgs?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): MessageBundle { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_dataFeedMsgs = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_rpcMsgs = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return MessageBundle( + dataFeedMsgs = if (__offset_dataFeedMsgs != 0) { val vecOff = tableOffset + __offset_dataFeedMsgs + bb.getInt(tableOffset + __offset_dataFeedMsgs); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) DataFeedMessageHeader.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + rpcMsgs = if (__offset_rpcMsgs != 0) { val vecOff = tableOffset + __offset_rpcMsgs + bb.getInt(tableOffset + __offset_rpcMsgs); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) RpcMessageHeader.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/Bone.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/Bone.kt new file mode 100644 index 000000000..02f73edb7 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/Bone.kt @@ -0,0 +1,45 @@ +package solarxr_protocol.data_feed + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Float +import kotlin.Int +import solarxr_protocol.datatypes.BodyPart +import solarxr_protocol.datatypes.math.Quat +import solarxr_protocol.datatypes.math.Vec3f + +public data class Bone( + public val bodyPart: BodyPart? = null, + public val rotationG: Quat? = null, + public val boneLength: Float? = null, + public val headPositionG: Vec3f? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(4) + if (bodyPart != null) { builder.forceDefaults(true); builder.addByte(0, bodyPart.value.toByte(), 0); builder.forceDefaults(false) } + rotationG?.let { builder.addStruct(1, it.encode(builder), 0) } + if (boneLength != null) { builder.forceDefaults(true); builder.addFloat(2, boneLength, 0.0); builder.forceDefaults(false) } + headPositionG?.let { builder.addStruct(3, it.encode(builder), 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): Bone { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_bodyPart = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_rotationG = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_boneLength = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_headPositionG = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return Bone( + bodyPart = if (__offset_bodyPart != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_bodyPart).toUByte()) else null, + rotationG = if (__offset_rotationG != 0) Quat.decode(bb, tableOffset + __offset_rotationG) else null, + boneLength = if (__offset_boneLength != 0) bb.getFloat(tableOffset + __offset_boneLength) else null, + headPositionG = if (__offset_headPositionG != 0) Vec3f.decode(bb, tableOffset + __offset_headPositionG) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/DataFeed.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/DataFeed.kt new file mode 100644 index 000000000..79abed861 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/DataFeed.kt @@ -0,0 +1,246 @@ +package solarxr_protocol.data_feed + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Byte +import kotlin.Int +import kotlin.UByte +import kotlin.UShort +import kotlin.collections.List +import solarxr_protocol.data_feed.device_data.DeviceData +import solarxr_protocol.data_feed.device_data.DeviceDataMask +import solarxr_protocol.data_feed.server.ServerGuards +import solarxr_protocol.data_feed.stay_aligned.StayAlignedPose +import solarxr_protocol.data_feed.tracker_data.TrackerData +import solarxr_protocol.data_feed.tracker_data.TrackerDataMask + +public sealed interface DataFeedMessage { + public companion object { + public fun decode( + type: Byte, + bb: FlatBufferReader, + offset: Int, + ): DataFeedMessage? = when (type.toInt()) { + 1 -> PollDataFeed.decode(bb, offset) + 2 -> StartDataFeed.decode(bb, offset) + 3 -> DataFeedUpdate.decode(bb, offset) + 4 -> DataFeedConfig.decode(bb, offset) + else -> null + } + + public fun typeIndex(`value`: DataFeedMessage): Byte = when (value) { + is PollDataFeed -> 1 + is StartDataFeed -> 2 + is DataFeedUpdate -> 3 + is DataFeedConfig -> 4 + } + + public fun encode(`value`: DataFeedMessage, builder: FlatBufferWriter): Int = when (value) { + is PollDataFeed -> value.encode(builder) + is StartDataFeed -> value.encode(builder) + is DataFeedUpdate -> value.encode(builder) + is DataFeedConfig -> value.encode(builder) + } + } +} + +public data class DataFeedMessageHeader( + public val message: DataFeedMessage? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_message = message?.let { DataFeedMessage.encode(it, builder) } + val __type_message = message?.let { DataFeedMessage.typeIndex(it) } ?: 0.toByte() + + builder.startTable(2) + builder.addByte(0, __type_message, 0) + __off_message?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DataFeedMessageHeader { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __type_message = if (vtableSize > 4 && bb.getShort(vtableOffset + 4).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + 4).toInt()) else 0 + val __offset_message = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return DataFeedMessageHeader( + message = if (__offset_message != 0) DataFeedMessage.decode(__type_message, bb, tableOffset + __offset_message + bb.getInt(tableOffset + __offset_message)) else null + ) + } + } +} + +/** + * Requests for a single `Update` to be sent. This is helpful when getting + * initial info about the device. + */ +public data class PollDataFeed( + public val config: DataFeedConfig? = null, +) : DataFeedMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_config = config?.encode(builder) + + builder.startTable(1) + __off_config?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): PollDataFeed { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_config = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return PollDataFeed( + config = if (__offset_config != 0) DataFeedConfig.decode(bb, tableOffset + __offset_config + bb.getInt(tableOffset + __offset_config)) else null + ) + } + } +} + +/** + * Requests for the other party to send `data_feeds`. + * For example, GUI requests for position data to be sent from server. + * + * When sending a new `StartFeed`, the old data feeds should stop being sent. + * We still support multiple data feeds at the same time, because `data_feeds` + * is a list. + * + * Multiple data feeds are useful to get data at different frequencies. + */ +public data class StartDataFeed( + public val dataFeeds: List? = null, +) : DataFeedMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_dataFeeds = dataFeeds?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(1) + __off_dataFeeds?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StartDataFeed { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_dataFeeds = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return StartDataFeed( + dataFeeds = if (__offset_dataFeeds != 0) { val vecOff = tableOffset + __offset_dataFeeds + bb.getInt(tableOffset + __offset_dataFeeds); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) DataFeedConfig.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +/** + * All of the data components related to a single data feed. A data feed is comprised + * of device data, and tracker data. + * + * A data feed might send data only when it changes/updates, and we should make no + * assumptions that the data is actually delivered. If you want to guarantee + * delivery and avoid dropped observations of data (such as a user-initiated + * button press), it is better to use the RPC system. + */ +public data class DataFeedUpdate( + public val devices: List? = null, + public val syntheticTrackers: List? = null, + public val bones: List? = null, + public val stayAlignedPose: StayAlignedPose? = null, + public val index: UByte? = null, + public val serverGuards: ServerGuards? = null, +) : DataFeedMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_devices = devices?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_syntheticTrackers = syntheticTrackers?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_bones = bones?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_stayAlignedPose = stayAlignedPose?.encode(builder) + val __off_serverGuards = serverGuards?.encode(builder) + + builder.startTable(6) + __off_devices?.let { builder.addOffset(0, it, 0) } + __off_syntheticTrackers?.let { builder.addOffset(1, it, 0) } + __off_bones?.let { builder.addOffset(2, it, 0) } + __off_stayAlignedPose?.let { builder.addOffset(3, it, 0) } + if (index != null) { builder.forceDefaults(true); builder.addByte(4, index.toByte(), 0); builder.forceDefaults(false) } + __off_serverGuards?.let { builder.addOffset(5, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DataFeedUpdate { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_devices = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_syntheticTrackers = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_bones = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_stayAlignedPose = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_index = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_serverGuards = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return DataFeedUpdate( + devices = if (__offset_devices != 0) { val vecOff = tableOffset + __offset_devices + bb.getInt(tableOffset + __offset_devices); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) DeviceData.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + syntheticTrackers = if (__offset_syntheticTrackers != 0) { val vecOff = tableOffset + __offset_syntheticTrackers + bb.getInt(tableOffset + __offset_syntheticTrackers); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) TrackerData.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + bones = if (__offset_bones != 0) { val vecOff = tableOffset + __offset_bones + bb.getInt(tableOffset + __offset_bones); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) Bone.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + stayAlignedPose = if (__offset_stayAlignedPose != 0) StayAlignedPose.decode(bb, tableOffset + __offset_stayAlignedPose + bb.getInt(tableOffset + __offset_stayAlignedPose)) else null, + index = if (__offset_index != 0) bb.get(tableOffset + __offset_index).toUByte() else null, + serverGuards = if (__offset_serverGuards != 0) ServerGuards.decode(bb, tableOffset + __offset_serverGuards + bb.getInt(tableOffset + __offset_serverGuards)) else null + ) + } + } +} + +/** + * All information related to the configuration of a data feed. This may be sent + * as part of a `StartFeed`. + */ +public data class DataFeedConfig( + public val minimumTimeSinceLast: UShort = 0.toUShort(), + public val dataMask: DeviceDataMask? = null, + public val syntheticTrackersMask: TrackerDataMask? = null, + public val boneMask: Boolean? = null, + public val stayAlignedPoseMask: Boolean? = null, + public val serverGuardsMask: Boolean? = null, +) : DataFeedMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_dataMask = dataMask?.encode(builder) + val __off_syntheticTrackersMask = syntheticTrackersMask?.encode(builder) + + builder.startTable(6) + builder.addShort(0, minimumTimeSinceLast.toShort(), 0) + __off_dataMask?.let { builder.addOffset(1, it, 0) } + __off_syntheticTrackersMask?.let { builder.addOffset(2, it, 0) } + if (boneMask != null) { builder.forceDefaults(true); builder.addBoolean(3, boneMask, false); builder.forceDefaults(false) } + if (stayAlignedPoseMask != null) { builder.forceDefaults(true); builder.addBoolean(4, stayAlignedPoseMask, false); builder.forceDefaults(false) } + if (serverGuardsMask != null) { builder.forceDefaults(true); builder.addBoolean(5, serverGuardsMask, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DataFeedConfig { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_minimumTimeSinceLast = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_dataMask = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_syntheticTrackersMask = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_boneMask = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_stayAlignedPoseMask = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_serverGuardsMask = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return DataFeedConfig( + minimumTimeSinceLast = if (__offset_minimumTimeSinceLast != 0) bb.getShort(tableOffset + __offset_minimumTimeSinceLast).toUShort() else 0.toUShort(), + dataMask = if (__offset_dataMask != 0) DeviceDataMask.decode(bb, tableOffset + __offset_dataMask + bb.getInt(tableOffset + __offset_dataMask)) else null, + syntheticTrackersMask = if (__offset_syntheticTrackersMask != 0) TrackerDataMask.decode(bb, tableOffset + __offset_syntheticTrackersMask + bb.getInt(tableOffset + __offset_syntheticTrackersMask)) else null, + boneMask = if (__offset_boneMask != 0) bb.get(tableOffset + __offset_boneMask) != 0.toByte() else null, + stayAlignedPoseMask = if (__offset_stayAlignedPoseMask != 0) bb.get(tableOffset + __offset_stayAlignedPoseMask) != 0.toByte() else null, + serverGuardsMask = if (__offset_serverGuardsMask != 0) bb.get(tableOffset + __offset_serverGuardsMask) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/device_data/DeviceData.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/device_data/DeviceData.kt new file mode 100644 index 000000000..0b72102e6 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/device_data/DeviceData.kt @@ -0,0 +1,100 @@ +package solarxr_protocol.data_feed.device_data + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String +import kotlin.UShort +import kotlin.collections.List +import solarxr_protocol.data_feed.tracker_data.TrackerData +import solarxr_protocol.data_feed.tracker_data.TrackerDataMask +import solarxr_protocol.datatypes.hardware_info.HardwareInfo +import solarxr_protocol.datatypes.hardware_info.HardwareStatus + +/** + * A mask of values to be reported in subsequent DeviceStatus. Values set to `false` + * or `null` will not reported. By default, all fields are false/null. + * + * If you set a value to `true`, it is not guaranteed that the sender actually has + * such a value to send. In this case, they will probably send `null`, and the receiver + * has the choice to disconnect due to missing data. + */ +public data class DeviceDataMask( + public val trackerData: TrackerDataMask? = null, + public val deviceData: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackerData = trackerData?.encode(builder) + + builder.startTable(2) + __off_trackerData?.let { builder.addOffset(0, it, 0) } + if (deviceData != null) { builder.forceDefaults(true); builder.addBoolean(1, deviceData, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DeviceDataMask { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerData = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_deviceData = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return DeviceDataMask( + trackerData = if (__offset_trackerData != 0) TrackerDataMask.decode(bb, tableOffset + __offset_trackerData + bb.getInt(tableOffset + __offset_trackerData)) else null, + deviceData = if (__offset_deviceData != 0) bb.get(tableOffset + __offset_deviceData) != 0.toByte() else null + ) + } + } +} + +/** + * Describes all possible information about a hardware device. For example, a + * vive tracker is a single hardware device, and a slime tracker with two + * extensions is a single hardware device but two trackers. + */ +public data class DeviceData( + public val id: UShort? = null, + public val customName: String? = null, + public val hardwareInfo: HardwareInfo? = null, + public val hardwareStatus: HardwareStatus? = null, + public val trackers: List? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_customName = customName?.let { builder.createString(it) } + val __off_hardwareInfo = hardwareInfo?.encode(builder) + val __off_hardwareStatus = hardwareStatus?.encode(builder) + val __off_trackers = trackers?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(5) + if (id != null) { builder.forceDefaults(true); builder.addShort(0, id.toShort(), 0); builder.forceDefaults(false) } + __off_customName?.let { builder.addOffset(1, it, 0) } + __off_hardwareInfo?.let { builder.addOffset(2, it, 0) } + __off_hardwareStatus?.let { builder.addOffset(3, it, 0) } + __off_trackers?.let { builder.addOffset(4, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DeviceData { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_id = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_customName = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_hardwareInfo = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_hardwareStatus = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_trackers = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return DeviceData( + id = if (__offset_id != 0) bb.getShort(tableOffset + __offset_id).toUShort() else null, + customName = if (__offset_customName != 0) readFlatBufferString(bb, tableOffset + __offset_customName) else null, + hardwareInfo = if (__offset_hardwareInfo != 0) HardwareInfo.decode(bb, tableOffset + __offset_hardwareInfo + bb.getInt(tableOffset + __offset_hardwareInfo)) else null, + hardwareStatus = if (__offset_hardwareStatus != 0) HardwareStatus.decode(bb, tableOffset + __offset_hardwareStatus + bb.getInt(tableOffset + __offset_hardwareStatus)) else null, + trackers = if (__offset_trackers != 0) { val vecOff = tableOffset + __offset_trackers + bb.getInt(tableOffset + __offset_trackers); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) TrackerData.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/server/Server.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/server/Server.kt new file mode 100644 index 000000000..2ccfc7506 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/server/Server.kt @@ -0,0 +1,44 @@ +package solarxr_protocol.data_feed.server + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Int + +/** + * Contains various of flags / guards that inform the GUI + * about possible actions or blocked states. + * The idea is to have one source of truth for all these rules + * that are spread accross the GUI. + */ +public data class ServerGuards( + public val canDoMountingReset: Boolean? = null, + public val canDoYawReset: Boolean? = null, + public val canDoUserHeightCalibration: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(3) + if (canDoMountingReset != null) { builder.forceDefaults(true); builder.addBoolean(0, canDoMountingReset, false); builder.forceDefaults(false) } + if (canDoYawReset != null) { builder.forceDefaults(true); builder.addBoolean(1, canDoYawReset, false); builder.forceDefaults(false) } + if (canDoUserHeightCalibration != null) { builder.forceDefaults(true); builder.addBoolean(2, canDoUserHeightCalibration, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ServerGuards { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_canDoMountingReset = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_canDoYawReset = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_canDoUserHeightCalibration = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return ServerGuards( + canDoMountingReset = if (__offset_canDoMountingReset != 0) bb.get(tableOffset + __offset_canDoMountingReset) != 0.toByte() else null, + canDoYawReset = if (__offset_canDoYawReset != 0) bb.get(tableOffset + __offset_canDoYawReset) != 0.toByte() else null, + canDoUserHeightCalibration = if (__offset_canDoUserHeightCalibration != 0) bb.get(tableOffset + __offset_canDoUserHeightCalibration) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/stay_aligned/StayAligned.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/stay_aligned/StayAligned.kt new file mode 100644 index 000000000..3a450e4a8 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/stay_aligned/StayAligned.kt @@ -0,0 +1,79 @@ +package solarxr_protocol.data_feed.stay_aligned + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Float +import kotlin.Int + +public data class StayAlignedPose( + public val upperLegAngleInDeg: Float? = null, + public val lowerLegAngleInDeg: Float? = null, + public val footAngleInDeg: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(3) + if (upperLegAngleInDeg != null) { builder.forceDefaults(true); builder.addFloat(0, upperLegAngleInDeg, 0.0); builder.forceDefaults(false) } + if (lowerLegAngleInDeg != null) { builder.forceDefaults(true); builder.addFloat(1, lowerLegAngleInDeg, 0.0); builder.forceDefaults(false) } + if (footAngleInDeg != null) { builder.forceDefaults(true); builder.addFloat(2, footAngleInDeg, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StayAlignedPose { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_upperLegAngleInDeg = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_lowerLegAngleInDeg = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_footAngleInDeg = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return StayAlignedPose( + upperLegAngleInDeg = if (__offset_upperLegAngleInDeg != 0) bb.getFloat(tableOffset + __offset_upperLegAngleInDeg) else null, + lowerLegAngleInDeg = if (__offset_lowerLegAngleInDeg != 0) bb.getFloat(tableOffset + __offset_lowerLegAngleInDeg) else null, + footAngleInDeg = if (__offset_footAngleInDeg != 0) bb.getFloat(tableOffset + __offset_footAngleInDeg) else null + ) + } + } +} + +public data class StayAlignedTracker( + public val yawCorrectionInDeg: Float? = null, + public val lockedErrorInDeg: Float? = null, + public val centerErrorInDeg: Float? = null, + public val neighborErrorInDeg: Float? = null, + public val locked: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(5) + if (yawCorrectionInDeg != null) { builder.forceDefaults(true); builder.addFloat(0, yawCorrectionInDeg, 0.0); builder.forceDefaults(false) } + if (lockedErrorInDeg != null) { builder.forceDefaults(true); builder.addFloat(1, lockedErrorInDeg, 0.0); builder.forceDefaults(false) } + if (centerErrorInDeg != null) { builder.forceDefaults(true); builder.addFloat(2, centerErrorInDeg, 0.0); builder.forceDefaults(false) } + if (neighborErrorInDeg != null) { builder.forceDefaults(true); builder.addFloat(3, neighborErrorInDeg, 0.0); builder.forceDefaults(false) } + if (locked != null) { builder.forceDefaults(true); builder.addBoolean(4, locked, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StayAlignedTracker { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_yawCorrectionInDeg = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_lockedErrorInDeg = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_centerErrorInDeg = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_neighborErrorInDeg = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_locked = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return StayAlignedTracker( + yawCorrectionInDeg = if (__offset_yawCorrectionInDeg != 0) bb.getFloat(tableOffset + __offset_yawCorrectionInDeg) else null, + lockedErrorInDeg = if (__offset_lockedErrorInDeg != 0) bb.getFloat(tableOffset + __offset_lockedErrorInDeg) else null, + centerErrorInDeg = if (__offset_centerErrorInDeg != 0) bb.getFloat(tableOffset + __offset_centerErrorInDeg) else null, + neighborErrorInDeg = if (__offset_neighborErrorInDeg != 0) bb.getFloat(tableOffset + __offset_neighborErrorInDeg) else null, + locked = if (__offset_locked != 0) bb.get(tableOffset + __offset_locked) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/tracker_data/TrackerData.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/tracker_data/TrackerData.kt new file mode 100644 index 000000000..5dae14e91 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/data_feed/tracker_data/TrackerData.kt @@ -0,0 +1,260 @@ +package solarxr_protocol.data_feed.tracker_data + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String +import kotlin.UShort +import solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker +import solarxr_protocol.datatypes.BodyPart +import solarxr_protocol.datatypes.HzF32 +import solarxr_protocol.datatypes.MagnetometerStatus +import solarxr_protocol.datatypes.Temperature +import solarxr_protocol.datatypes.TrackerStatus +import solarxr_protocol.datatypes.hardware_info.ImuType +import solarxr_protocol.datatypes.hardware_info.TrackerDataType +import solarxr_protocol.datatypes.math.Quat +import solarxr_protocol.datatypes.math.Vec3f + +/** + * Describes all possible information about a tracker. A tracker is anything that + * provides kinematic data about a particular body part. + * + * Trackers may be synthetic/computed or instead part of an actual hardware device. + * There can be multiple trackers per hardware device. + */ +public data class TrackerData( + public val deviceId: UShort? = null, + public val trackerId: UShort? = null, + public val info: TrackerInfo? = null, + public val status: TrackerStatus? = null, + public val rotation: Quat? = null, + public val position: Vec3f? = null, + public val rawAngularVelocity: Vec3f? = null, + public val rawAcceleration: Vec3f? = null, + public val temp: Temperature? = null, + public val linearAcceleration: Vec3f? = null, + public val rotationReferenceAdjusted: Quat? = null, + public val rotationIdentityAdjusted: Quat? = null, + public val tps: UShort? = null, + public val rawMagneticVector: Vec3f? = null, + public val stayAligned: StayAlignedTracker? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_info = info?.encode(builder) + val __off_stayAligned = stayAligned?.encode(builder) + + builder.startTable(15) + if (deviceId != null) { builder.forceDefaults(true); builder.addShort(0, deviceId.toShort(), 0); builder.forceDefaults(false) } + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(1, trackerId.toShort(), 0); builder.forceDefaults(false) } + __off_info?.let { builder.addOffset(2, it, 0) } + if (status != null) { builder.forceDefaults(true); builder.addByte(3, status.value.toByte(), 0); builder.forceDefaults(false) } + rotation?.let { builder.addStruct(4, it.encode(builder), 0) } + position?.let { builder.addStruct(5, it.encode(builder), 0) } + rawAngularVelocity?.let { builder.addStruct(6, it.encode(builder), 0) } + rawAcceleration?.let { builder.addStruct(7, it.encode(builder), 0) } + temp?.let { builder.addStruct(8, it.encode(builder), 0) } + linearAcceleration?.let { builder.addStruct(9, it.encode(builder), 0) } + rotationReferenceAdjusted?.let { builder.addStruct(10, it.encode(builder), 0) } + rotationIdentityAdjusted?.let { builder.addStruct(11, it.encode(builder), 0) } + if (tps != null) { builder.forceDefaults(true); builder.addShort(12, tps.toShort(), 0); builder.forceDefaults(false) } + rawMagneticVector?.let { builder.addStruct(13, it.encode(builder), 0) } + __off_stayAligned?.let { builder.addOffset(14, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackerData { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_deviceId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_trackerId = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_info = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_status = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_rotation = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_position = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_rawAngularVelocity = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_rawAcceleration = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_temp = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_linearAcceleration = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_rotationReferenceAdjusted = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_rotationIdentityAdjusted = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_tps = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + val __offset_rawMagneticVector = if (vtableSize > 30) bb.getShort(vtableOffset + 30).toInt() else 0 + val __offset_stayAligned = if (vtableSize > 32) bb.getShort(vtableOffset + 32).toInt() else 0 + + return TrackerData( + deviceId = if (__offset_deviceId != 0) bb.getShort(tableOffset + __offset_deviceId).toUShort() else null, + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null, + info = if (__offset_info != 0) TrackerInfo.decode(bb, tableOffset + __offset_info + bb.getInt(tableOffset + __offset_info)) else null, + status = if (__offset_status != 0) TrackerStatus.fromValue(bb.get(tableOffset + __offset_status).toUByte()) else null, + rotation = if (__offset_rotation != 0) Quat.decode(bb, tableOffset + __offset_rotation) else null, + position = if (__offset_position != 0) Vec3f.decode(bb, tableOffset + __offset_position) else null, + rawAngularVelocity = if (__offset_rawAngularVelocity != 0) Vec3f.decode(bb, tableOffset + __offset_rawAngularVelocity) else null, + rawAcceleration = if (__offset_rawAcceleration != 0) Vec3f.decode(bb, tableOffset + __offset_rawAcceleration) else null, + temp = if (__offset_temp != 0) Temperature.decode(bb, tableOffset + __offset_temp) else null, + linearAcceleration = if (__offset_linearAcceleration != 0) Vec3f.decode(bb, tableOffset + __offset_linearAcceleration) else null, + rotationReferenceAdjusted = if (__offset_rotationReferenceAdjusted != 0) Quat.decode(bb, tableOffset + __offset_rotationReferenceAdjusted) else null, + rotationIdentityAdjusted = if (__offset_rotationIdentityAdjusted != 0) Quat.decode(bb, tableOffset + __offset_rotationIdentityAdjusted) else null, + tps = if (__offset_tps != 0) bb.getShort(tableOffset + __offset_tps).toUShort() else null, + rawMagneticVector = if (__offset_rawMagneticVector != 0) Vec3f.decode(bb, tableOffset + __offset_rawMagneticVector) else null, + stayAligned = if (__offset_stayAligned != 0) StayAlignedTracker.decode(bb, tableOffset + __offset_stayAligned + bb.getInt(tableOffset + __offset_stayAligned)) else null + ) + } + } +} + +/** + * A mask of the different components in `TrackerComponent` + */ +public data class TrackerDataMask( + public val info: Boolean? = null, + public val status: Boolean? = null, + public val rotation: Boolean? = null, + public val position: Boolean? = null, + public val rawAngularVelocity: Boolean? = null, + public val rawAcceleration: Boolean? = null, + public val temp: Boolean? = null, + public val linearAcceleration: Boolean? = null, + public val rotationReferenceAdjusted: Boolean? = null, + public val rotationIdentityAdjusted: Boolean? = null, + public val tps: Boolean? = null, + public val rawMagneticVector: Boolean? = null, + public val stayAligned: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(13) + if (info != null) { builder.forceDefaults(true); builder.addBoolean(0, info, false); builder.forceDefaults(false) } + if (status != null) { builder.forceDefaults(true); builder.addBoolean(1, status, false); builder.forceDefaults(false) } + if (rotation != null) { builder.forceDefaults(true); builder.addBoolean(2, rotation, false); builder.forceDefaults(false) } + if (position != null) { builder.forceDefaults(true); builder.addBoolean(3, position, false); builder.forceDefaults(false) } + if (rawAngularVelocity != null) { builder.forceDefaults(true); builder.addBoolean(4, rawAngularVelocity, false); builder.forceDefaults(false) } + if (rawAcceleration != null) { builder.forceDefaults(true); builder.addBoolean(5, rawAcceleration, false); builder.forceDefaults(false) } + if (temp != null) { builder.forceDefaults(true); builder.addBoolean(6, temp, false); builder.forceDefaults(false) } + if (linearAcceleration != null) { builder.forceDefaults(true); builder.addBoolean(7, linearAcceleration, false); builder.forceDefaults(false) } + if (rotationReferenceAdjusted != null) { builder.forceDefaults(true); builder.addBoolean(8, rotationReferenceAdjusted, false); builder.forceDefaults(false) } + if (rotationIdentityAdjusted != null) { builder.forceDefaults(true); builder.addBoolean(9, rotationIdentityAdjusted, false); builder.forceDefaults(false) } + if (tps != null) { builder.forceDefaults(true); builder.addBoolean(10, tps, false); builder.forceDefaults(false) } + if (rawMagneticVector != null) { builder.forceDefaults(true); builder.addBoolean(11, rawMagneticVector, false); builder.forceDefaults(false) } + if (stayAligned != null) { builder.forceDefaults(true); builder.addBoolean(12, stayAligned, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackerDataMask { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_info = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_status = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_rotation = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_position = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_rawAngularVelocity = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_rawAcceleration = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_temp = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_linearAcceleration = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_rotationReferenceAdjusted = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_rotationIdentityAdjusted = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_tps = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_rawMagneticVector = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_stayAligned = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return TrackerDataMask( + info = if (__offset_info != 0) bb.get(tableOffset + __offset_info) != 0.toByte() else null, + status = if (__offset_status != 0) bb.get(tableOffset + __offset_status) != 0.toByte() else null, + rotation = if (__offset_rotation != 0) bb.get(tableOffset + __offset_rotation) != 0.toByte() else null, + position = if (__offset_position != 0) bb.get(tableOffset + __offset_position) != 0.toByte() else null, + rawAngularVelocity = if (__offset_rawAngularVelocity != 0) bb.get(tableOffset + __offset_rawAngularVelocity) != 0.toByte() else null, + rawAcceleration = if (__offset_rawAcceleration != 0) bb.get(tableOffset + __offset_rawAcceleration) != 0.toByte() else null, + temp = if (__offset_temp != 0) bb.get(tableOffset + __offset_temp) != 0.toByte() else null, + linearAcceleration = if (__offset_linearAcceleration != 0) bb.get(tableOffset + __offset_linearAcceleration) != 0.toByte() else null, + rotationReferenceAdjusted = if (__offset_rotationReferenceAdjusted != 0) bb.get(tableOffset + __offset_rotationReferenceAdjusted) != 0.toByte() else null, + rotationIdentityAdjusted = if (__offset_rotationIdentityAdjusted != 0) bb.get(tableOffset + __offset_rotationIdentityAdjusted) != 0.toByte() else null, + tps = if (__offset_tps != 0) bb.get(tableOffset + __offset_tps) != 0.toByte() else null, + rawMagneticVector = if (__offset_rawMagneticVector != 0) bb.get(tableOffset + __offset_rawMagneticVector) != 0.toByte() else null, + stayAligned = if (__offset_stayAligned != 0) bb.get(tableOffset + __offset_stayAligned) != 0.toByte() else null + ) + } + } +} + +/** + * Static description of a tracker + */ +public data class TrackerInfo( + public val imuType: ImuType? = null, + public val bodyPart: BodyPart? = null, + public val pollRate: HzF32? = null, + public val mountingOrientation: Quat? = null, + public val editable: Boolean? = null, + public val isComputed: Boolean? = null, + public val isImu: Boolean? = null, + public val displayName: String? = null, + public val customName: String? = null, + public val mountingResetOrientation: Quat? = null, + public val isHmd: Boolean? = null, + public val magnetometer: MagnetometerStatus? = null, + public val dataSupport: TrackerDataType? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_displayName = displayName?.let { builder.createString(it) } + val __off_customName = customName?.let { builder.createString(it) } + + builder.startTable(13) + if (imuType != null) { builder.forceDefaults(true); builder.addShort(0, imuType.value.toShort(), 0); builder.forceDefaults(false) } + if (bodyPart != null) { builder.forceDefaults(true); builder.addByte(1, bodyPart.value.toByte(), 0); builder.forceDefaults(false) } + pollRate?.let { builder.addStruct(2, it.encode(builder), 0) } + mountingOrientation?.let { builder.addStruct(3, it.encode(builder), 0) } + if (editable != null) { builder.forceDefaults(true); builder.addBoolean(4, editable, false); builder.forceDefaults(false) } + if (isComputed != null) { builder.forceDefaults(true); builder.addBoolean(5, isComputed, false); builder.forceDefaults(false) } + if (isImu != null) { builder.forceDefaults(true); builder.addBoolean(6, isImu, false); builder.forceDefaults(false) } + __off_displayName?.let { builder.addOffset(7, it, 0) } + __off_customName?.let { builder.addOffset(8, it, 0) } + mountingResetOrientation?.let { builder.addStruct(9, it.encode(builder), 0) } + if (isHmd != null) { builder.forceDefaults(true); builder.addBoolean(10, isHmd, false); builder.forceDefaults(false) } + if (magnetometer != null) { builder.forceDefaults(true); builder.addByte(11, magnetometer.value.toByte(), 0); builder.forceDefaults(false) } + if (dataSupport != null) { builder.forceDefaults(true); builder.addByte(12, dataSupport.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackerInfo { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_imuType = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_bodyPart = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_pollRate = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_mountingOrientation = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_editable = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_isComputed = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_isImu = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_displayName = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_customName = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_mountingResetOrientation = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_isHmd = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_magnetometer = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_dataSupport = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return TrackerInfo( + imuType = if (__offset_imuType != 0) ImuType.fromValue(bb.getShort(tableOffset + __offset_imuType).toUShort()) else null, + bodyPart = if (__offset_bodyPart != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_bodyPart).toUByte()) else null, + pollRate = if (__offset_pollRate != 0) HzF32.decode(bb, tableOffset + __offset_pollRate) else null, + mountingOrientation = if (__offset_mountingOrientation != 0) Quat.decode(bb, tableOffset + __offset_mountingOrientation) else null, + editable = if (__offset_editable != 0) bb.get(tableOffset + __offset_editable) != 0.toByte() else null, + isComputed = if (__offset_isComputed != 0) bb.get(tableOffset + __offset_isComputed) != 0.toByte() else null, + isImu = if (__offset_isImu != 0) bb.get(tableOffset + __offset_isImu) != 0.toByte() else null, + displayName = if (__offset_displayName != 0) readFlatBufferString(bb, tableOffset + __offset_displayName) else null, + customName = if (__offset_customName != 0) readFlatBufferString(bb, tableOffset + __offset_customName) else null, + mountingResetOrientation = if (__offset_mountingResetOrientation != 0) Quat.decode(bb, tableOffset + __offset_mountingResetOrientation) else null, + isHmd = if (__offset_isHmd != 0) bb.get(tableOffset + __offset_isHmd) != 0.toByte() else null, + magnetometer = if (__offset_magnetometer != 0) MagnetometerStatus.fromValue(bb.get(tableOffset + __offset_magnetometer).toUByte()) else null, + dataSupport = if (__offset_dataSupport != 0) TrackerDataType.fromValue(bb.get(tableOffset + __offset_dataSupport).toUByte()) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/Datatypes.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/Datatypes.kt new file mode 100644 index 000000000..b1d9f95ef --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/Datatypes.kt @@ -0,0 +1,274 @@ +package solarxr_protocol.datatypes + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Float +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.UInt +import kotlin.collections.List + +/** + * Frequency as 32 bit float + */ +public data class HzF32( + public val f: Float, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 4) + var written = 0 + builder.pad(0 - written) + builder.putFloat(f) + written = 4 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): HzF32 = HzF32(f = bb.getFloat(offset + 0)) + } +} + +public data class TransactionId( + public val id: UInt, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 4) + var written = 0 + builder.pad(0 - written) + builder.putInt(id.toInt()) + written = 4 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): TransactionId = TransactionId(id = bb.getInt(offset + 0).toUInt()) + } +} + +/** + * General purpose logging datatype + */ +public data class LogData( + public val message: String? = null, + public val `data`: List? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_message = message?.let { builder.createString(it) } + val __off_data = data?.let { builder.createByteVector(it.map { b -> b.toByte() }.toByteArray()) } + + builder.startTable(2) + __off_message?.let { builder.addOffset(0, it, 0) } + __off_data?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): LogData { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_message = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_data = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return LogData( + message = if (__offset_message != 0) readFlatBufferString(bb, tableOffset + __offset_message) else null, + data = if (__offset_data != 0) { val vecOff = tableOffset + __offset_data + bb.getInt(tableOffset + __offset_data); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> bb.get(vecOff + 4 + i * 1).toUByte() } } else null + ) + } + } +} + +/** + * A list of error codes for error conditions on the device + */ +public enum class FirmwareErrorCode( + public val `value`: UByte, +) { + Other(0.toUByte()), + Disconnected(1.toUByte()), + Occluded(2.toUByte()), + ImuError(3.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): FirmwareErrorCode? = entries.firstOrNull { it.value == value } + } +} + +/** + * Possible tracker roles + * They're not perfect match for SteamVR tracker roles, + * because we support more possible roles. Host can + * chose how to map it to their supported role. + */ +public enum class TrackerRole( + public val `value`: UByte, +) { + NONE(0.toUByte()), + WAIST(1.toUByte()), + LEFT_FOOT(2.toUByte()), + RIGHT_FOOT(3.toUByte()), + CHEST(4.toUByte()), + LEFT_KNEE(5.toUByte()), + RIGHT_KNEE(6.toUByte()), + LEFT_ELBOW(7.toUByte()), + RIGHT_ELBOW(8.toUByte()), + LEFT_SHOULDER(9.toUByte()), + RIGHT_SHOULDER(10.toUByte()), + LEFT_HAND(11.toUByte()), + RIGHT_HAND(12.toUByte()), + LEFT_CONTROLLER(13.toUByte()), + RIGHT_CONTROLLER(14.toUByte()), + HEAD(15.toUByte()), + NECK(16.toUByte()), + CAMERA(17.toUByte()), + KEYBOARD(18.toUByte()), + HMD(19.toUByte()), + BEACON(20.toUByte()), + GENERIC_CONTROLLER(21.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): TrackerRole? = entries.firstOrNull { it.value == value } + } +} + +/** + * Different parts of the body. Maps to each possible non-tracker bone in the skeleton. + * These are *NOT* the trackers. + */ +public enum class BodyPart( + public val `value`: UByte, +) { + NONE(0.toUByte()), + HEAD(1.toUByte()), + NECK(2.toUByte()), + CHEST(3.toUByte()), + WAIST(4.toUByte()), + HIP(5.toUByte()), + LEFT_UPPER_LEG(6.toUByte()), + RIGHT_UPPER_LEG(7.toUByte()), + LEFT_LOWER_LEG(8.toUByte()), + RIGHT_LOWER_LEG(9.toUByte()), + LEFT_FOOT(10.toUByte()), + RIGHT_FOOT(11.toUByte()), + LEFT_LOWER_ARM(14.toUByte()), + RIGHT_LOWER_ARM(15.toUByte()), + LEFT_UPPER_ARM(16.toUByte()), + RIGHT_UPPER_ARM(17.toUByte()), + LEFT_HAND(18.toUByte()), + RIGHT_HAND(19.toUByte()), + LEFT_SHOULDER(20.toUByte()), + RIGHT_SHOULDER(21.toUByte()), + UPPER_CHEST(22.toUByte()), + LEFT_HIP(23.toUByte()), + RIGHT_HIP(24.toUByte()), + LEFT_THUMB_METACARPAL(25.toUByte()), + LEFT_THUMB_PROXIMAL(26.toUByte()), + LEFT_THUMB_DISTAL(27.toUByte()), + LEFT_INDEX_PROXIMAL(28.toUByte()), + LEFT_INDEX_INTERMEDIATE(29.toUByte()), + LEFT_INDEX_DISTAL(30.toUByte()), + LEFT_MIDDLE_PROXIMAL(31.toUByte()), + LEFT_MIDDLE_INTERMEDIATE(32.toUByte()), + LEFT_MIDDLE_DISTAL(33.toUByte()), + LEFT_RING_PROXIMAL(34.toUByte()), + LEFT_RING_INTERMEDIATE(35.toUByte()), + LEFT_RING_DISTAL(36.toUByte()), + LEFT_LITTLE_PROXIMAL(37.toUByte()), + LEFT_LITTLE_INTERMEDIATE(38.toUByte()), + LEFT_LITTLE_DISTAL(39.toUByte()), + RIGHT_THUMB_METACARPAL(40.toUByte()), + RIGHT_THUMB_PROXIMAL(41.toUByte()), + RIGHT_THUMB_DISTAL(42.toUByte()), + RIGHT_INDEX_PROXIMAL(43.toUByte()), + RIGHT_INDEX_INTERMEDIATE(44.toUByte()), + RIGHT_INDEX_DISTAL(45.toUByte()), + RIGHT_MIDDLE_PROXIMAL(46.toUByte()), + RIGHT_MIDDLE_INTERMEDIATE(47.toUByte()), + RIGHT_MIDDLE_DISTAL(48.toUByte()), + RIGHT_RING_PROXIMAL(49.toUByte()), + RIGHT_RING_INTERMEDIATE(50.toUByte()), + RIGHT_RING_DISTAL(51.toUByte()), + RIGHT_LITTLE_PROXIMAL(52.toUByte()), + RIGHT_LITTLE_INTERMEDIATE(53.toUByte()), + RIGHT_LITTLE_DISTAL(54.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): BodyPart? = entries.firstOrNull { it.value == value } + } +} + +public enum class TrackerStatus( + public val `value`: UByte, +) { + NONE(0.toUByte()), + DISCONNECTED(1.toUByte()), + OK(2.toUByte()), + BUSY(3.toUByte()), + ERROR(4.toUByte()), + OCCLUDED(5.toUByte()), + TIMED_OUT(6.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): TrackerStatus? = entries.firstOrNull { it.value == value } + } +} + +/** + * Temperature in degrees celsius + */ +public data class Temperature( + public val temp: Float, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 4) + var written = 0 + builder.pad(0 - written) + builder.putFloat(temp) + written = 4 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): Temperature = Temperature(temp = bb.getFloat(offset + 0)) + } +} + +/** + * The 4 bytes of an ip address are stored in 32 bits in big endian order. + * We will switch over to fixed size arrays when they are supported better. + */ +public data class Ipv4Address( + public val addr: UInt, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 4) + var written = 0 + builder.pad(0 - written) + builder.putInt(addr.toInt()) + written = 4 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): Ipv4Address = Ipv4Address(addr = bb.getInt(offset + 0).toUInt()) + } +} + +public enum class MagnetometerStatus( + public val `value`: UByte, +) { + NOT_SUPPORTED(0.toUByte()), + DISABLED(1.toUByte()), + ENABLED(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): MagnetometerStatus? = entries.firstOrNull { it.value == value } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt new file mode 100644 index 000000000..49d529189 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt @@ -0,0 +1,361 @@ +package solarxr_protocol.datatypes.hardware_info + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.Long +import kotlin.Short +import kotlin.String +import kotlin.UByte +import kotlin.ULong +import kotlin.UShort +import solarxr_protocol.datatypes.FirmwareErrorCode +import solarxr_protocol.datatypes.Ipv4Address +import solarxr_protocol.datatypes.LogData + +public enum class McuType( + public val `value`: UShort, +) { + UNKNOWN(0.toUShort()), + ESP8266(1.toUShort()), + ESP32(2.toUShort()), + OWOTRACK_ANDROID(3.toUShort()), + WRANGLER(4.toUShort()), + OWOTRACK_IOS(5.toUShort()), + ESP32_C3(6.toUShort()), + MOCOPI(7.toUShort()), + HARITORA(8.toUShort()), + NRF52(9.toUShort()), + NRF54L(10.toUShort()), + DEV_RESERVED(250.toUShort()), + ; + + public companion object { + public fun fromValue(`value`: UShort): McuType? = entries.firstOrNull { it.value == value } + } +} + +public enum class ImuType( + public val `value`: UShort, +) { + UNKNOWN(0.toUShort()), + MPU9250(1.toUShort()), + MPU6500(2.toUShort()), + BNO080(3.toUShort()), + BNO085(4.toUShort()), + BNO055(5.toUShort()), + MPU6050(6.toUShort()), + BNO086(7.toUShort()), + BMI160(8.toUShort()), + ICM20948(9.toUShort()), + ICM42688(10.toUShort()), + BMI270(11.toUShort()), + LSM6DS3TRC(12.toUShort()), + LSM6DSV(13.toUShort()), + LSM6DSO(14.toUShort()), + LSM6DSR(15.toUShort()), + ICM45686(16.toUShort()), + ICM45605(17.toUShort()), + ADC_RESISTANCE(18.toUShort()), + ICM55686(19.toUShort()), + DEV_RESERVED(250.toUShort()), + ; + + public companion object { + public fun fromValue(`value`: UShort): ImuType? = entries.firstOrNull { it.value == value } + } +} + +public enum class BoardType( + public val `value`: UShort, +) { + UNKNOWN(0.toUShort()), + SLIMEVR_LEGACY(1.toUShort()), + SLIMEVR_DEV(2.toUShort()), + NODEMCU(3.toUShort()), + CUSTOM(4.toUShort()), + WROOM32(5.toUShort()), + WEMOSD1MINI(6.toUShort()), + TTGO_TBASE(7.toUShort()), + ESP01(8.toUShort()), + SLIMEVR(9.toUShort()), + LOLIN_C3_MINI(10.toUShort()), + BEETLE32C3(11.toUShort()), + ESP32C3DEVKITM1(12.toUShort()), + OWOTRACK(13.toUShort()), + WRANGLER(14.toUShort()), + MOCOPI(15.toUShort()), + WEMOSWROOM02(16.toUShort()), + XIAO_ESP32C3(17.toUShort()), + HARITORA(18.toUShort()), + ESP32C6DEVKITC1(19.toUShort()), + GLOVE_IMU_SLIMEVR_DEV(20.toUShort()), + GESTURES(21.toUShort()), + SLIMEVR_V1_2(22.toUShort()), + ESP32S3_SUPERMINI(23.toUShort()), + GENERIC_NRF(24.toUShort()), + SLIMEVR_BUTTERFLY_DEV(25.toUShort()), + SLIMEVR_BUTTERFLY(26.toUShort()), + DEV_RESERVED(250.toUShort()), + ; + + public companion object { + public fun fromValue(`value`: UShort): BoardType? = entries.firstOrNull { it.value == value } + } +} + +/** + * What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. + */ +public enum class TrackerDataType( + public val `value`: UByte, +) { + /** + * Rotation (e.g: IMUs or computed rotations in firmware) + */ + ROTATION(0.toUByte()), + /** + * Flex resistance (e.g: raw data from flex sensors or unscaled angle on a single axis) + */ + FLEX_RESISTANCE(1.toUByte()), + /** + * Flex angle (e.g: computed angle from flex sensors or angle on a single axis) + */ + FLEX_ANGLE(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): TrackerDataType? = entries.firstOrNull { it.value == value } + } +} + +/** + * A MAC address or a bluetooth address, or some other uniquely identifying address + * associated with the endpoint that we are communicating with. If it doesn't take + * up the full set of bytes, it is aligned towards the least significant bits. + */ +public data class HardwareAddress( + public val addr: ULong, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(8, 8) + var written = 0 + builder.pad(0 - written) + builder.putLong(addr.toLong()) + written = 8 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): HardwareAddress = HardwareAddress(addr = bb.getLong(offset + 0).toULong()) + } +} + +/** + * Mostly static info about the device's hardware/firmware. + */ +public data class HardwareInfo( + public val mcuId: McuType? = null, + public val displayName: String? = null, + public val model: String? = null, + public val manufacturer: String? = null, + public val hardwareRevision: String? = null, + public val firmwareVersion: String? = null, + public val hardwareAddress: HardwareAddress? = null, + public val ipAddress: Ipv4Address? = null, + public val boardType: String? = null, + public val officialBoardType: BoardType? = null, + public val hardwareIdentifier: String? = null, + public val networkProtocolVersion: UShort? = null, + public val firmwareDate: String? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_displayName = displayName?.let { builder.createString(it) } + val __off_model = model?.let { builder.createString(it) } + val __off_manufacturer = manufacturer?.let { builder.createString(it) } + val __off_hardwareRevision = hardwareRevision?.let { builder.createString(it) } + val __off_firmwareVersion = firmwareVersion?.let { builder.createString(it) } + val __off_boardType = boardType?.let { builder.createString(it) } + val __off_hardwareIdentifier = hardwareIdentifier?.let { builder.createString(it) } + val __off_firmwareDate = firmwareDate?.let { builder.createString(it) } + + builder.startTable(13) + if (mcuId != null) { builder.forceDefaults(true); builder.addShort(0, mcuId.value.toShort(), 0); builder.forceDefaults(false) } + __off_displayName?.let { builder.addOffset(1, it, 0) } + __off_model?.let { builder.addOffset(2, it, 0) } + __off_manufacturer?.let { builder.addOffset(3, it, 0) } + __off_hardwareRevision?.let { builder.addOffset(4, it, 0) } + __off_firmwareVersion?.let { builder.addOffset(5, it, 0) } + hardwareAddress?.let { builder.addStruct(6, it.encode(builder), 0) } + ipAddress?.let { builder.addStruct(7, it.encode(builder), 0) } + __off_boardType?.let { builder.addOffset(8, it, 0) } + if (officialBoardType != null) { builder.forceDefaults(true); builder.addShort(9, officialBoardType.value.toShort(), 0); builder.forceDefaults(false) } + __off_hardwareIdentifier?.let { builder.addOffset(10, it, 0) } + if (networkProtocolVersion != null) { builder.forceDefaults(true); builder.addShort(11, networkProtocolVersion.toShort(), 0); builder.forceDefaults(false) } + __off_firmwareDate?.let { builder.addOffset(12, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HardwareInfo { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_mcuId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_displayName = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_model = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_manufacturer = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_hardwareRevision = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_firmwareVersion = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_hardwareAddress = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_ipAddress = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_boardType = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_officialBoardType = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_hardwareIdentifier = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_networkProtocolVersion = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_firmwareDate = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return HardwareInfo( + mcuId = if (__offset_mcuId != 0) McuType.fromValue(bb.getShort(tableOffset + __offset_mcuId).toUShort()) else null, + displayName = if (__offset_displayName != 0) readFlatBufferString(bb, tableOffset + __offset_displayName) else null, + model = if (__offset_model != 0) readFlatBufferString(bb, tableOffset + __offset_model) else null, + manufacturer = if (__offset_manufacturer != 0) readFlatBufferString(bb, tableOffset + __offset_manufacturer) else null, + hardwareRevision = if (__offset_hardwareRevision != 0) readFlatBufferString(bb, tableOffset + __offset_hardwareRevision) else null, + firmwareVersion = if (__offset_firmwareVersion != 0) readFlatBufferString(bb, tableOffset + __offset_firmwareVersion) else null, + hardwareAddress = if (__offset_hardwareAddress != 0) HardwareAddress.decode(bb, tableOffset + __offset_hardwareAddress) else null, + ipAddress = if (__offset_ipAddress != 0) Ipv4Address.decode(bb, tableOffset + __offset_ipAddress) else null, + boardType = if (__offset_boardType != 0) readFlatBufferString(bb, tableOffset + __offset_boardType) else null, + officialBoardType = if (__offset_officialBoardType != 0) BoardType.fromValue(bb.getShort(tableOffset + __offset_officialBoardType).toUShort()) else null, + hardwareIdentifier = if (__offset_hardwareIdentifier != 0) readFlatBufferString(bb, tableOffset + __offset_hardwareIdentifier) else null, + networkProtocolVersion = if (__offset_networkProtocolVersion != 0) bb.getShort(tableOffset + __offset_networkProtocolVersion).toUShort() else null, + firmwareDate = if (__offset_firmwareDate != 0) readFlatBufferString(bb, tableOffset + __offset_firmwareDate) else null + ) + } + } +} + +/** + * Mostly-dynamic status info about a tracked device's firmware + */ +public data class HardwareStatus( + public val errorStatus: FirmwareErrorCode? = null, + public val ping: UShort? = null, + public val rssi: Short? = null, + public val mcuTemp: Float? = null, + public val batteryVoltage: Float? = null, + public val batteryPctEstimate: UByte? = null, + public val logData: LogData? = null, + public val packetLoss: Float? = null, + public val packetsLost: Int? = null, + public val packetsReceived: Int? = null, + public val batteryRuntimeEstimate: Long? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_logData = logData?.encode(builder) + + builder.startTable(11) + if (errorStatus != null) { builder.forceDefaults(true); builder.addByte(0, errorStatus.value.toByte(), 0); builder.forceDefaults(false) } + if (ping != null) { builder.forceDefaults(true); builder.addShort(1, ping.toShort(), 0); builder.forceDefaults(false) } + if (rssi != null) { builder.forceDefaults(true); builder.addShort(2, rssi, 0); builder.forceDefaults(false) } + if (mcuTemp != null) { builder.forceDefaults(true); builder.addFloat(3, mcuTemp, 0.0); builder.forceDefaults(false) } + if (batteryVoltage != null) { builder.forceDefaults(true); builder.addFloat(4, batteryVoltage, 0.0); builder.forceDefaults(false) } + if (batteryPctEstimate != null) { builder.forceDefaults(true); builder.addByte(5, batteryPctEstimate.toByte(), 0); builder.forceDefaults(false) } + __off_logData?.let { builder.addOffset(6, it, 0) } + if (packetLoss != null) { builder.forceDefaults(true); builder.addFloat(7, packetLoss, 0.0); builder.forceDefaults(false) } + if (packetsLost != null) { builder.forceDefaults(true); builder.addInt(8, packetsLost, 0); builder.forceDefaults(false) } + if (packetsReceived != null) { builder.forceDefaults(true); builder.addInt(9, packetsReceived, 0); builder.forceDefaults(false) } + if (batteryRuntimeEstimate != null) { builder.forceDefaults(true); builder.addLong(10, batteryRuntimeEstimate, 0L); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HardwareStatus { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_errorStatus = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_ping = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_rssi = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_mcuTemp = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_batteryVoltage = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_batteryPctEstimate = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_logData = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_packetLoss = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_packetsLost = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_packetsReceived = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_batteryRuntimeEstimate = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + + return HardwareStatus( + errorStatus = if (__offset_errorStatus != 0) FirmwareErrorCode.fromValue(bb.get(tableOffset + __offset_errorStatus).toUByte()) else null, + ping = if (__offset_ping != 0) bb.getShort(tableOffset + __offset_ping).toUShort() else null, + rssi = if (__offset_rssi != 0) bb.getShort(tableOffset + __offset_rssi) else null, + mcuTemp = if (__offset_mcuTemp != 0) bb.getFloat(tableOffset + __offset_mcuTemp) else null, + batteryVoltage = if (__offset_batteryVoltage != 0) bb.getFloat(tableOffset + __offset_batteryVoltage) else null, + batteryPctEstimate = if (__offset_batteryPctEstimate != 0) bb.get(tableOffset + __offset_batteryPctEstimate).toUByte() else null, + logData = if (__offset_logData != 0) LogData.decode(bb, tableOffset + __offset_logData + bb.getInt(tableOffset + __offset_logData)) else null, + packetLoss = if (__offset_packetLoss != 0) bb.getFloat(tableOffset + __offset_packetLoss) else null, + packetsLost = if (__offset_packetsLost != 0) bb.getInt(tableOffset + __offset_packetsLost) else null, + packetsReceived = if (__offset_packetsReceived != 0) bb.getInt(tableOffset + __offset_packetsReceived) else null, + batteryRuntimeEstimate = if (__offset_batteryRuntimeEstimate != 0) bb.getLong(tableOffset + __offset_batteryRuntimeEstimate) else null + ) + } + } +} + +/** + * A mask of the data in `FirmwareStatus` + */ +public data class FirmwareStatusMask( + public val errorStatus: Boolean? = null, + public val tps: Boolean? = null, + public val ping: Boolean? = null, + public val rssi: Boolean? = null, + public val mcuTemp: Boolean? = null, + public val batteryVoltage: Boolean? = null, + public val batteryPctEstimate: Boolean? = null, + public val batteryRuntimeEstimate: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(8) + if (errorStatus != null) { builder.forceDefaults(true); builder.addBoolean(0, errorStatus, false); builder.forceDefaults(false) } + if (tps != null) { builder.forceDefaults(true); builder.addBoolean(1, tps, false); builder.forceDefaults(false) } + if (ping != null) { builder.forceDefaults(true); builder.addBoolean(2, ping, false); builder.forceDefaults(false) } + if (rssi != null) { builder.forceDefaults(true); builder.addBoolean(3, rssi, false); builder.forceDefaults(false) } + if (mcuTemp != null) { builder.forceDefaults(true); builder.addBoolean(4, mcuTemp, false); builder.forceDefaults(false) } + if (batteryVoltage != null) { builder.forceDefaults(true); builder.addBoolean(5, batteryVoltage, false); builder.forceDefaults(false) } + if (batteryPctEstimate != null) { builder.forceDefaults(true); builder.addBoolean(6, batteryPctEstimate, false); builder.forceDefaults(false) } + if (batteryRuntimeEstimate != null) { builder.forceDefaults(true); builder.addBoolean(7, batteryRuntimeEstimate, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwareStatusMask { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_errorStatus = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_tps = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_ping = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_rssi = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_mcuTemp = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_batteryVoltage = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_batteryPctEstimate = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_batteryRuntimeEstimate = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + + return FirmwareStatusMask( + errorStatus = if (__offset_errorStatus != 0) bb.get(tableOffset + __offset_errorStatus) != 0.toByte() else null, + tps = if (__offset_tps != 0) bb.get(tableOffset + __offset_tps) != 0.toByte() else null, + ping = if (__offset_ping != 0) bb.get(tableOffset + __offset_ping) != 0.toByte() else null, + rssi = if (__offset_rssi != 0) bb.get(tableOffset + __offset_rssi) != 0.toByte() else null, + mcuTemp = if (__offset_mcuTemp != 0) bb.get(tableOffset + __offset_mcuTemp) != 0.toByte() else null, + batteryVoltage = if (__offset_batteryVoltage != 0) bb.get(tableOffset + __offset_batteryVoltage) != 0.toByte() else null, + batteryPctEstimate = if (__offset_batteryPctEstimate != 0) bb.get(tableOffset + __offset_batteryPctEstimate) != 0.toByte() else null, + batteryRuntimeEstimate = if (__offset_batteryRuntimeEstimate != 0) bb.get(tableOffset + __offset_batteryRuntimeEstimate) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/math/Math.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/math/Math.kt new file mode 100644 index 000000000..4a56d75a1 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/datatypes/math/Math.kt @@ -0,0 +1,60 @@ +package solarxr_protocol.datatypes.math + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Float +import kotlin.Int + +public data class Quat( + public val x: Float, + public val y: Float, + public val z: Float, + public val w: Float, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 16) + var written = 0 + builder.pad(0 - written) + builder.putFloat(w) + written = 4 + builder.pad(4 - written) + builder.putFloat(z) + written = 8 + builder.pad(8 - written) + builder.putFloat(y) + written = 12 + builder.pad(12 - written) + builder.putFloat(x) + written = 16 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): Quat = Quat(x = bb.getFloat(offset + 0), y = bb.getFloat(offset + 4), z = bb.getFloat(offset + 8), w = bb.getFloat(offset + 12)) + } +} + +public data class Vec3f( + public val x: Float, + public val y: Float, + public val z: Float, +) { + public fun encode(builder: FlatBufferWriter): Int { + builder.prep(4, 12) + var written = 0 + builder.pad(0 - written) + builder.putFloat(z) + written = 4 + builder.pad(4 - written) + builder.putFloat(y) + written = 8 + builder.pad(8 - written) + builder.putFloat(x) + written = 12 + return builder.offset() + } + + public companion object { + public fun decode(bb: FlatBufferReader, offset: Int): Vec3f = Vec3f(x = bb.getFloat(offset + 0), y = bb.getFloat(offset + 4), z = bb.getFloat(offset + 8)) + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Autobone.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Autobone.kt new file mode 100644 index 000000000..17160a8ae --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Autobone.kt @@ -0,0 +1,171 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.UByte +import kotlin.UInt +import kotlin.collections.List + +public enum class AutoBoneProcessType( + public val `value`: UByte, +) { + NONE(0.toUByte()), + RECORD(1.toUByte()), + SAVE(2.toUByte()), + PROCESS(3.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): AutoBoneProcessType? = entries.firstOrNull { it.value == value } + } +} + +public data class AutoBoneProcessRequest( + public val processType: AutoBoneProcessType? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (processType != null) { builder.forceDefaults(true); builder.addByte(0, processType.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneProcessRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_processType = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return AutoBoneProcessRequest( + processType = if (__offset_processType != 0) AutoBoneProcessType.fromValue(bb.get(tableOffset + __offset_processType).toUByte()) else null + ) + } + } +} + +public data class AutoBoneProcessStatusResponse( + public val processType: AutoBoneProcessType? = null, + public val current: UInt? = null, + public val total: UInt? = null, + public val completed: Boolean? = null, + public val success: Boolean? = null, + public val eta: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(6) + if (processType != null) { builder.forceDefaults(true); builder.addByte(0, processType.value.toByte(), 0); builder.forceDefaults(false) } + if (current != null) { builder.forceDefaults(true); builder.addInt(1, current.toInt(), 0); builder.forceDefaults(false) } + if (total != null) { builder.forceDefaults(true); builder.addInt(2, total.toInt(), 0); builder.forceDefaults(false) } + if (completed != null) { builder.forceDefaults(true); builder.addBoolean(3, completed, false); builder.forceDefaults(false) } + if (success != null) { builder.forceDefaults(true); builder.addBoolean(4, success, false); builder.forceDefaults(false) } + if (eta != null) { builder.forceDefaults(true); builder.addFloat(5, eta, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneProcessStatusResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_processType = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_current = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_total = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_completed = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_success = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_eta = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return AutoBoneProcessStatusResponse( + processType = if (__offset_processType != 0) AutoBoneProcessType.fromValue(bb.get(tableOffset + __offset_processType).toUByte()) else null, + current = if (__offset_current != 0) bb.getInt(tableOffset + __offset_current).toUInt() else null, + total = if (__offset_total != 0) bb.getInt(tableOffset + __offset_total).toUInt() else null, + completed = if (__offset_completed != 0) bb.get(tableOffset + __offset_completed) != 0.toByte() else null, + success = if (__offset_success != 0) bb.get(tableOffset + __offset_success) != 0.toByte() else null, + eta = if (__offset_eta != 0) bb.getFloat(tableOffset + __offset_eta) else null + ) + } + } +} + +public data class AutoBoneEpochResponse( + public val currentEpoch: UInt? = null, + public val totalEpochs: UInt? = null, + public val epochError: Float? = null, + public val adjustedSkeletonParts: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_adjustedSkeletonParts = adjustedSkeletonParts?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(4) + if (currentEpoch != null) { builder.forceDefaults(true); builder.addInt(0, currentEpoch.toInt(), 0); builder.forceDefaults(false) } + if (totalEpochs != null) { builder.forceDefaults(true); builder.addInt(1, totalEpochs.toInt(), 0); builder.forceDefaults(false) } + if (epochError != null) { builder.forceDefaults(true); builder.addFloat(2, epochError, 0.0); builder.forceDefaults(false) } + __off_adjustedSkeletonParts?.let { builder.addOffset(3, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneEpochResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_currentEpoch = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_totalEpochs = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_epochError = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_adjustedSkeletonParts = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return AutoBoneEpochResponse( + currentEpoch = if (__offset_currentEpoch != 0) bb.getInt(tableOffset + __offset_currentEpoch).toUInt() else null, + totalEpochs = if (__offset_totalEpochs != 0) bb.getInt(tableOffset + __offset_totalEpochs).toUInt() else null, + epochError = if (__offset_epochError != 0) bb.getFloat(tableOffset + __offset_epochError) else null, + adjustedSkeletonParts = if (__offset_adjustedSkeletonParts != 0) { val vecOff = tableOffset + __offset_adjustedSkeletonParts + bb.getInt(tableOffset + __offset_adjustedSkeletonParts); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) SkeletonPart.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +/** + * Applies the estimated proportions + */ +public class AutoBoneApplyRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneApplyRequest = AutoBoneApplyRequest() + } +} + +/** + * Stops the current recording, using it as far as it has been recorded + */ +public class AutoBoneStopRecordingRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneStopRecordingRequest = AutoBoneStopRecordingRequest() + } +} + +/** + * Cancels the current recording, aborting the process and discarding the data + */ +public class AutoBoneCancelRecordingRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AutoBoneCancelRecordingRequest = AutoBoneCancelRecordingRequest() + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Bvh.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Bvh.kt new file mode 100644 index 000000000..970d2d9eb --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Bvh.kt @@ -0,0 +1,72 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String + +public data class RecordBVHRequest( + public val stop: Boolean? = null, + public val path: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_path = path?.let { builder.createString(it) } + + builder.startTable(2) + if (stop != null) { builder.forceDefaults(true); builder.addBoolean(0, stop, false); builder.forceDefaults(false) } + __off_path?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): RecordBVHRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_stop = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_path = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return RecordBVHRequest( + stop = if (__offset_stop != 0) bb.get(tableOffset + __offset_stop) != 0.toByte() else null, + path = if (__offset_path != 0) readFlatBufferString(bb, tableOffset + __offset_path) else null + ) + } + } +} + +public data class RecordBVHStatus( + public val recording: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (recording != null) { builder.forceDefaults(true); builder.addBoolean(0, recording, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): RecordBVHStatus { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_recording = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return RecordBVHStatus( + recording = if (__offset_recording != 0) bb.get(tableOffset + __offset_recording) != 0.toByte() else null + ) + } + } +} + +public class RecordBVHStatusRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): RecordBVHStatusRequest = RecordBVHStatusRequest() + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Device.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Device.kt new file mode 100644 index 000000000..62a43a36e --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Device.kt @@ -0,0 +1,87 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Int +import kotlin.String + +/** + * Server notifies connection of an unknown device. + * If the notification is no longer sent, it means the device connected to another + * server, got connected to this server or it was turned off. + */ +public data class UnknownDeviceHandshakeNotification( + public val macAddress: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_macAddress = macAddress?.let { builder.createString(it) } + + builder.startTable(1) + __off_macAddress?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): UnknownDeviceHandshakeNotification { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_macAddress = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return UnknownDeviceHandshakeNotification( + macAddress = if (__offset_macAddress != 0) readFlatBufferString(bb, tableOffset + __offset_macAddress) else null + ) + } + } +} + +public data class AddUnknownDeviceRequest( + public val macAddress: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_macAddress = macAddress?.let { builder.createString(it) } + + builder.startTable(1) + __off_macAddress?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AddUnknownDeviceRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_macAddress = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return AddUnknownDeviceRequest( + macAddress = if (__offset_macAddress != 0) readFlatBufferString(bb, tableOffset + __offset_macAddress) else null + ) + } + } +} + +public data class ForgetDeviceRequest( + public val macAddress: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_macAddress = macAddress?.let { builder.createString(it) } + + builder.startTable(1) + __off_macAddress?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ForgetDeviceRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_macAddress = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ForgetDeviceRequest( + macAddress = if (__offset_macAddress != 0) readFlatBufferString(bb, tableOffset + __offset_macAddress) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Firmware.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Firmware.kt new file mode 100644 index 000000000..939164640 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Firmware.kt @@ -0,0 +1,365 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Byte +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.UInt +import kotlin.UShort +import kotlin.collections.List + +public enum class FirmwareUpdateStatus( + public val `value`: UByte, +) { + /** + * The server is downloading the firmware + */ + DOWNLOADING(0.toUByte()), + /** + * The server is waiting for the tracker to be rebooted by the user + * Note that is is not the same as REBOOTING + */ + NEED_MANUAL_REBOOT(1.toUByte()), + /** + * The server tries to authenticate with the MCU + */ + AUTHENTICATING(2.toUByte()), + /** + * The server is uploading the firmware to the Device + */ + UPLOADING(3.toUByte()), + /** + * The serial flasher tries to sync with the MCU + * You can use this event to prompt the user to press the boot btn + */ + SYNCING_WITH_MCU(4.toUByte()), + /** + * The MCU is rebooting + */ + REBOOTING(5.toUByte()), + /** + * The server is provisioning the tracker + */ + PROVISIONING(6.toUByte()), + /** + * The update process completed with success + */ + DONE(7.toUByte()), + /** + * Could not find the device + */ + ERROR_DEVICE_NOT_FOUND(8.toUByte()), + /** + * The operation timed out, > 1min + */ + ERROR_TIMEOUT(9.toUByte()), + /** + * The firmware download failed + */ + ERROR_DOWNLOAD_FAILED(10.toUByte()), + /** + * The server could not authenticate with the MCU + */ + ERROR_AUTHENTICATION_FAILED(11.toUByte()), + /** + * Could not upload the firmware to the MCU + */ + ERROR_UPLOAD_FAILED(12.toUByte()), + /** + * The provision of the tracker failed, usually wifi credentials + */ + ERROR_PROVISIONING_FAILED(13.toUByte()), + /** + * An unsupported Flashing method was used + */ + ERROR_UNSUPPORTED_METHOD(14.toUByte()), + ERROR_UNKNOWN(15.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): FirmwareUpdateStatus? = entries.firstOrNull { it.value == value } + } +} + +public data class SerialDevicePort( + public val port: String? = null, +) : FirmwareUpdateDeviceId { + public fun encode(builder: FlatBufferWriter): Int { + val __off_port = port?.let { builder.createString(it) } + + builder.startTable(1) + __off_port?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialDevicePort { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_port = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return SerialDevicePort( + port = if (__offset_port != 0) readFlatBufferString(bb, tableOffset + __offset_port) else null + ) + } + } +} + +public data class FirmwareDeviceIdTable( + public val id: UShort? = null, +) : FirmwareUpdateDeviceId { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (id != null) { builder.forceDefaults(true); builder.addShort(0, id.toShort(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwareDeviceIdTable { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_id = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return FirmwareDeviceIdTable( + id = if (__offset_id != 0) bb.getShort(tableOffset + __offset_id).toUShort() else null + ) + } + } +} + +public sealed interface FirmwareUpdateDeviceId { + public companion object { + public fun decode( + type: Byte, + bb: FlatBufferReader, + offset: Int, + ): FirmwareUpdateDeviceId? = when (type.toInt()) { + 1 -> FirmwareDeviceIdTable.decode(bb, offset) + 2 -> SerialDevicePort.decode(bb, offset) + else -> null + } + + public fun typeIndex(`value`: FirmwareUpdateDeviceId): Byte = when (value) { + is FirmwareDeviceIdTable -> 1 + is SerialDevicePort -> 2 + } + + public fun encode(`value`: FirmwareUpdateDeviceId, builder: FlatBufferWriter): Int = when (value) { + is FirmwareDeviceIdTable -> value.encode(builder) + is SerialDevicePort -> value.encode(builder) + } + } +} + +public data class FirmwarePart( + public val url: String? = null, + public val offset: UInt? = null, + public val digest: String? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_url = url?.let { builder.createString(it) } + val __off_digest = digest?.let { builder.createString(it) } + + builder.startTable(3) + __off_url?.let { builder.addOffset(0, it, 0) } + if (offset != null) { builder.forceDefaults(true); builder.addInt(1, offset.toInt(), 0); builder.forceDefaults(false) } + __off_digest?.let { builder.addOffset(2, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwarePart { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_url = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_offset = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_digest = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return FirmwarePart( + url = if (__offset_url != 0) readFlatBufferString(bb, tableOffset + __offset_url) else null, + offset = if (__offset_offset != 0) bb.getInt(tableOffset + __offset_offset).toUInt() else null, + digest = if (__offset_digest != 0) readFlatBufferString(bb, tableOffset + __offset_digest) else null + ) + } + } +} + +public sealed interface FirmwareUpdateMethod { + public companion object { + public fun decode( + type: Byte, + bb: FlatBufferReader, + offset: Int, + ): FirmwareUpdateMethod? = when (type.toInt()) { + 1 -> OTAFirmwareUpdate.decode(bb, offset) + 2 -> SerialFirmwareUpdate.decode(bb, offset) + else -> null + } + + public fun typeIndex(`value`: FirmwareUpdateMethod): Byte = when (value) { + is OTAFirmwareUpdate -> 1 + is SerialFirmwareUpdate -> 2 + } + + public fun encode(`value`: FirmwareUpdateMethod, builder: FlatBufferWriter): Int = when (value) { + is OTAFirmwareUpdate -> value.encode(builder) + is SerialFirmwareUpdate -> value.encode(builder) + } + } +} + +public data class FirmwareUpdateRequest( + public val method: FirmwareUpdateMethod? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_method = method?.let { FirmwareUpdateMethod.encode(it, builder) } + val __type_method = method?.let { FirmwareUpdateMethod.typeIndex(it) } ?: 0.toByte() + + builder.startTable(2) + builder.addByte(0, __type_method, 0) + __off_method?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwareUpdateRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __type_method = if (vtableSize > 4 && bb.getShort(vtableOffset + 4).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + 4).toInt()) else 0 + val __offset_method = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return FirmwareUpdateRequest( + method = if (__offset_method != 0) FirmwareUpdateMethod.decode(__type_method, bb, tableOffset + __offset_method + bb.getInt(tableOffset + __offset_method)) else null + ) + } + } +} + +public data class OTAFirmwareUpdate( + public val deviceId: UShort? = null, + public val firmwarePart: FirmwarePart? = null, +) : FirmwareUpdateMethod { + public fun encode(builder: FlatBufferWriter): Int { + val __off_firmwarePart = firmwarePart?.encode(builder) + + builder.startTable(2) + if (deviceId != null) { builder.forceDefaults(true); builder.addShort(0, deviceId.toShort(), 0); builder.forceDefaults(false) } + __off_firmwarePart?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OTAFirmwareUpdate { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_deviceId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_firmwarePart = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return OTAFirmwareUpdate( + deviceId = if (__offset_deviceId != 0) bb.getShort(tableOffset + __offset_deviceId).toUShort() else null, + firmwarePart = if (__offset_firmwarePart != 0) FirmwarePart.decode(bb, tableOffset + __offset_firmwarePart + bb.getInt(tableOffset + __offset_firmwarePart)) else null + ) + } + } +} + +public data class SerialFirmwareUpdate( + public val deviceId: SerialDevicePort? = null, + public val needManualReboot: Boolean? = null, + public val ssid: String? = null, + public val password: String? = null, + public val firmwarePart: List? = null, +) : FirmwareUpdateMethod { + public fun encode(builder: FlatBufferWriter): Int { + val __off_deviceId = deviceId?.encode(builder) + val __off_ssid = ssid?.let { builder.createString(it) } + val __off_password = password?.let { builder.createString(it) } + val __off_firmwarePart = firmwarePart?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(5) + __off_deviceId?.let { builder.addOffset(0, it, 0) } + if (needManualReboot != null) { builder.forceDefaults(true); builder.addBoolean(1, needManualReboot, false); builder.forceDefaults(false) } + __off_ssid?.let { builder.addOffset(2, it, 0) } + __off_password?.let { builder.addOffset(3, it, 0) } + __off_firmwarePart?.let { builder.addOffset(4, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialFirmwareUpdate { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_deviceId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_needManualReboot = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_ssid = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_password = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_firmwarePart = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return SerialFirmwareUpdate( + deviceId = if (__offset_deviceId != 0) SerialDevicePort.decode(bb, tableOffset + __offset_deviceId + bb.getInt(tableOffset + __offset_deviceId)) else null, + needManualReboot = if (__offset_needManualReboot != 0) bb.get(tableOffset + __offset_needManualReboot) != 0.toByte() else null, + ssid = if (__offset_ssid != 0) readFlatBufferString(bb, tableOffset + __offset_ssid) else null, + password = if (__offset_password != 0) readFlatBufferString(bb, tableOffset + __offset_password) else null, + firmwarePart = if (__offset_firmwarePart != 0) { val vecOff = tableOffset + __offset_firmwarePart + bb.getInt(tableOffset + __offset_firmwarePart); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) FirmwarePart.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +public data class FirmwareUpdateStatusResponse( + public val deviceId: FirmwareUpdateDeviceId? = null, + public val status: FirmwareUpdateStatus? = null, + public val progress: Byte? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_deviceId = deviceId?.let { FirmwareUpdateDeviceId.encode(it, builder) } + val __type_deviceId = deviceId?.let { FirmwareUpdateDeviceId.typeIndex(it) } ?: 0.toByte() + + builder.startTable(4) + builder.addByte(0, __type_deviceId, 0) + __off_deviceId?.let { builder.addOffset(1, it, 0) } + if (status != null) { builder.forceDefaults(true); builder.addByte(2, status.value.toByte(), 0); builder.forceDefaults(false) } + if (progress != null) { builder.forceDefaults(true); builder.addByte(3, progress, 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwareUpdateStatusResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __type_deviceId = if (vtableSize > 4 && bb.getShort(vtableOffset + 4).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + 4).toInt()) else 0 + val __offset_deviceId = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_status = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_progress = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return FirmwareUpdateStatusResponse( + deviceId = if (__offset_deviceId != 0) FirmwareUpdateDeviceId.decode(__type_deviceId, bb, tableOffset + __offset_deviceId + bb.getInt(tableOffset + __offset_deviceId)) else null, + status = if (__offset_status != 0) FirmwareUpdateStatus.fromValue(bb.get(tableOffset + __offset_status).toUByte()) else null, + progress = if (__offset_progress != 0) bb.get(tableOffset + __offset_progress) else null + ) + } + } +} + +public class FirmwareUpdateStopQueuesRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): FirmwareUpdateStopQueuesRequest = FirmwareUpdateStopQueuesRequest() + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/HeightCalibration.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/HeightCalibration.kt new file mode 100644 index 000000000..8ff4ccf27 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/HeightCalibration.kt @@ -0,0 +1,77 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Float +import kotlin.Int +import kotlin.UByte + +public class StartUserHeightCalibration : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StartUserHeightCalibration = StartUserHeightCalibration() + } +} + +public class CancelUserHeightCalibration : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): CancelUserHeightCalibration = CancelUserHeightCalibration() + } +} + +public enum class UserHeightCalibrationStatus( + public val `value`: UByte, +) { + NONE(0.toUByte()), + RECORDING_FLOOR(1.toUByte()), + WAITING_FOR_CONTROLLER_PITCH(2.toUByte()), + WAITING_FOR_RISE(3.toUByte()), + WAITING_FOR_FW_LOOK(4.toUByte()), + RECORDING_HEIGHT(5.toUByte()), + DONE(6.toUByte()), + ERROR_TOO_HIGH(7.toUByte()), + ERROR_TOO_SMALL(8.toUByte()), + ERROR_TIMEOUT(9.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): UserHeightCalibrationStatus? = entries.firstOrNull { it.value == value } + } +} + +public data class UserHeightRecordingStatusResponse( + public val hmdHeight: Float? = null, + public val status: UserHeightCalibrationStatus? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (hmdHeight != null) { builder.forceDefaults(true); builder.addFloat(0, hmdHeight, 0.0); builder.forceDefaults(false) } + if (status != null) { builder.forceDefaults(true); builder.addByte(1, status.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): UserHeightRecordingStatusResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_hmdHeight = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_status = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return UserHeightRecordingStatusResponse( + hmdHeight = if (__offset_hmdHeight != 0) bb.getFloat(tableOffset + __offset_hmdHeight) else null, + status = if (__offset_status != 0) UserHeightCalibrationStatus.fromValue(bb.get(tableOffset + __offset_status).toUByte()) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Keybinding.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Keybinding.kt new file mode 100644 index 000000000..3c6064e22 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Keybinding.kt @@ -0,0 +1,148 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Float +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.collections.List + +public enum class KeybindId( + public val `value`: UByte, +) { + FULL_RESET(0.toUByte()), + YAW_RESET(1.toUByte()), + MOUNTING_RESET(2.toUByte()), + PAUSE_TRACKING(3.toUByte()), + FEET_MOUNTING_RESET(4.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): KeybindId? = entries.firstOrNull { it.value == value } + } +} + +public data class Keybind( + public val keybindId: KeybindId? = null, + public val keybindNameId: String? = null, + public val keybindValue: String? = null, + public val keybindDelay: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_keybindNameId = keybindNameId?.let { builder.createString(it) } + val __off_keybindValue = keybindValue?.let { builder.createString(it) } + + builder.startTable(4) + if (keybindId != null) { builder.forceDefaults(true); builder.addByte(0, keybindId.value.toByte(), 0); builder.forceDefaults(false) } + __off_keybindNameId?.let { builder.addOffset(1, it, 0) } + __off_keybindValue?.let { builder.addOffset(2, it, 0) } + if (keybindDelay != null) { builder.forceDefaults(true); builder.addFloat(3, keybindDelay, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): Keybind { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_keybindId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_keybindNameId = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_keybindValue = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_keybindDelay = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return Keybind( + keybindId = if (__offset_keybindId != 0) KeybindId.fromValue(bb.get(tableOffset + __offset_keybindId).toUByte()) else null, + keybindNameId = if (__offset_keybindNameId != 0) readFlatBufferString(bb, tableOffset + __offset_keybindNameId) else null, + keybindValue = if (__offset_keybindValue != 0) readFlatBufferString(bb, tableOffset + __offset_keybindValue) else null, + keybindDelay = if (__offset_keybindDelay != 0) bb.getFloat(tableOffset + __offset_keybindDelay) else null + ) + } + } +} + +/** + * Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui + */ +public data class KeybindRequest( + public val keybindId: KeybindId? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (keybindId != null) { builder.forceDefaults(true); builder.addByte(0, keybindId.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): KeybindRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_keybindId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return KeybindRequest( + keybindId = if (__offset_keybindId != 0) KeybindId.fromValue(bb.get(tableOffset + __offset_keybindId).toUByte()) else null + ) + } + } +} + +/** + * Returns keybinds for displaying in gui + */ +public data class KeybindResponse( + public val keybind: List? = null, + public val defaultKeybinds: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_keybind = keybind?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_defaultKeybinds = defaultKeybinds?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(2) + __off_keybind?.let { builder.addOffset(0, it, 0) } + __off_defaultKeybinds?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): KeybindResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_keybind = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_defaultKeybinds = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return KeybindResponse( + keybind = if (__offset_keybind != 0) { val vecOff = tableOffset + __offset_keybind + bb.getInt(tableOffset + __offset_keybind); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) Keybind.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + defaultKeybinds = if (__offset_defaultKeybinds != 0) { val vecOff = tableOffset + __offset_defaultKeybinds + bb.getInt(tableOffset + __offset_defaultKeybinds); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) Keybind.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +public data class ChangeKeybindRequest( + public val keybind: Keybind? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_keybind = keybind?.encode(builder) + + builder.startTable(1) + __off_keybind?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeKeybindRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_keybind = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ChangeKeybindRequest( + keybind = if (__offset_keybind != 0) Keybind.decode(bb, tableOffset + __offset_keybind + bb.getInt(tableOffset + __offset_keybind)) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Overlay.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Overlay.kt new file mode 100644 index 000000000..0360eabfa --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Overlay.kt @@ -0,0 +1,82 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Int + +/** + * Requests the current state of `OverlayDisplayModeResponse`. + */ +public class OverlayDisplayModeRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OverlayDisplayModeRequest = OverlayDisplayModeRequest() + } +} + +/** + * Changes the state of the overlay's display mode. + */ +public data class OverlayDisplayModeChangeRequest( + public val isVisible: Boolean? = null, + public val isMirrored: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (isVisible != null) { builder.forceDefaults(true); builder.addBoolean(0, isVisible, false); builder.forceDefaults(false) } + if (isMirrored != null) { builder.forceDefaults(true); builder.addBoolean(1, isMirrored, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OverlayDisplayModeChangeRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_isVisible = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_isMirrored = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return OverlayDisplayModeChangeRequest( + isVisible = if (__offset_isVisible != 0) bb.get(tableOffset + __offset_isVisible) != 0.toByte() else null, + isMirrored = if (__offset_isMirrored != 0) bb.get(tableOffset + __offset_isMirrored) != 0.toByte() else null + ) + } + } +} + +/** + * The current state of the overlay's display mode. + */ +public data class OverlayDisplayModeResponse( + public val isVisible: Boolean? = null, + public val isMirrored: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (isVisible != null) { builder.forceDefaults(true); builder.addBoolean(0, isVisible, false); builder.forceDefaults(false) } + if (isMirrored != null) { builder.forceDefaults(true); builder.addBoolean(1, isMirrored, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OverlayDisplayModeResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_isVisible = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_isMirrored = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return OverlayDisplayModeResponse( + isVisible = if (__offset_isVisible != 0) bb.get(tableOffset + __offset_isVisible) != 0.toByte() else null, + isMirrored = if (__offset_isMirrored != 0) bb.get(tableOffset + __offset_isMirrored) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Provisioning.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Provisioning.kt new file mode 100644 index 000000000..a1c186742 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Provisioning.kt @@ -0,0 +1,99 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Int +import kotlin.String +import kotlin.UByte + +public data class StartWifiProvisioningRequest( + public val ssid: String? = null, + public val password: String? = null, + public val port: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_ssid = ssid?.let { builder.createString(it) } + val __off_password = password?.let { builder.createString(it) } + val __off_port = port?.let { builder.createString(it) } + + builder.startTable(3) + __off_ssid?.let { builder.addOffset(0, it, 0) } + __off_password?.let { builder.addOffset(1, it, 0) } + __off_port?.let { builder.addOffset(2, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StartWifiProvisioningRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_ssid = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_password = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_port = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return StartWifiProvisioningRequest( + ssid = if (__offset_ssid != 0) readFlatBufferString(bb, tableOffset + __offset_ssid) else null, + password = if (__offset_password != 0) readFlatBufferString(bb, tableOffset + __offset_password) else null, + port = if (__offset_port != 0) readFlatBufferString(bb, tableOffset + __offset_port) else null + ) + } + } +} + +public class StopWifiProvisioningRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StopWifiProvisioningRequest = StopWifiProvisioningRequest() + } +} + +public enum class WifiProvisioningStatus( + public val `value`: UByte, +) { + NONE(0.toUByte()), + SERIAL_INIT(1.toUByte()), + PROVISIONING(2.toUByte()), + CONNECTING(3.toUByte()), + CONNECTION_ERROR(4.toUByte()), + LOOKING_FOR_SERVER(5.toUByte()), + COULD_NOT_FIND_SERVER(6.toUByte()), + DONE(7.toUByte()), + OBTAINING_MAC_ADDRESS(8.toUByte()), + NO_SERIAL_LOGS_ERROR(9.toUByte()), + NO_SERIAL_DEVICE_FOUND(10.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): WifiProvisioningStatus? = entries.firstOrNull { it.value == value } + } +} + +public data class WifiProvisioningStatusResponse( + public val status: WifiProvisioningStatus? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (status != null) { builder.forceDefaults(true); builder.addByte(0, status.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): WifiProvisioningStatusResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_status = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return WifiProvisioningStatusResponse( + status = if (__offset_status != 0) WifiProvisioningStatus.fromValue(bb.get(tableOffset + __offset_status).toUByte()) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Resets.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Resets.kt new file mode 100644 index 000000000..5676719d7 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Resets.kt @@ -0,0 +1,249 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.UByte +import kotlin.collections.List +import solarxr_protocol.datatypes.BodyPart + +public enum class ResetType( + public val `value`: UByte, +) { + /** + * Resets the yaw (horizontal) axis + */ + YAW(0.toUByte()), + /** + * Resets all axes + */ + FULL(1.toUByte()), + /** + * Second pose for calibrating mounting rotation + */ + MOUNTING(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): ResetType? = entries.firstOrNull { it.value == value } + } +} + +public enum class ResetStatus( + public val `value`: UByte, +) { + STARTED(0.toUByte()), + FINISHED(1.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): ResetStatus? = entries.firstOrNull { it.value == value } + } +} + +public data class ResetRequest( + public val resetType: ResetType? = null, + public val bodyParts: List? = null, + public val delay: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_bodyParts = bodyParts?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(3) + if (resetType != null) { builder.forceDefaults(true); builder.addByte(0, resetType.value.toByte(), 0); builder.forceDefaults(false) } + __off_bodyParts?.let { builder.addOffset(1, it, 0) } + if (delay != null) { builder.forceDefaults(true); builder.addFloat(2, delay, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ResetRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_resetType = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_bodyParts = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_delay = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return ResetRequest( + resetType = if (__offset_resetType != 0) ResetType.fromValue(bb.get(tableOffset + __offset_resetType).toUByte()) else null, + bodyParts = if (__offset_bodyParts != 0) { val vecOff = tableOffset + __offset_bodyParts + bb.getInt(tableOffset + __offset_bodyParts); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> BodyPart.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null, + delay = if (__offset_delay != 0) bb.getFloat(tableOffset + __offset_delay) else null + ) + } + } +} + +public data class ResetResponse( + public val resetType: ResetType? = null, + public val status: ResetStatus? = null, + public val bodyParts: List? = null, + public val progress: Int? = null, + public val duration: Int? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_bodyParts = bodyParts?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(5) + if (resetType != null) { builder.forceDefaults(true); builder.addByte(0, resetType.value.toByte(), 0); builder.forceDefaults(false) } + if (status != null) { builder.forceDefaults(true); builder.addByte(1, status.value.toByte(), 0); builder.forceDefaults(false) } + __off_bodyParts?.let { builder.addOffset(2, it, 0) } + if (progress != null) { builder.forceDefaults(true); builder.addInt(3, progress, 0); builder.forceDefaults(false) } + if (duration != null) { builder.forceDefaults(true); builder.addInt(4, duration, 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ResetResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_resetType = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_status = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_bodyParts = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_progress = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_duration = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return ResetResponse( + resetType = if (__offset_resetType != 0) ResetType.fromValue(bb.get(tableOffset + __offset_resetType).toUByte()) else null, + status = if (__offset_status != 0) ResetStatus.fromValue(bb.get(tableOffset + __offset_status).toUByte()) else null, + bodyParts = if (__offset_bodyParts != 0) { val vecOff = tableOffset + __offset_bodyParts + bb.getInt(tableOffset + __offset_bodyParts); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> BodyPart.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null, + progress = if (__offset_progress != 0) bb.getInt(tableOffset + __offset_progress) else null, + duration = if (__offset_duration != 0) bb.getInt(tableOffset + __offset_duration) else null + ) + } + } +} + +/** + * Clears mounting reset data, defaulting to the manually set mounting orientations + */ +public class ClearMountingResetRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ClearMountingResetRequest = ClearMountingResetRequest() + } +} + +public enum class ArmsResetMode( + public val `value`: UByte, +) { + /** + * Down to the sides for full. Upper arm going back and forearm going forward for mounting. + */ + BACK(0.toUByte()), + /** + * Down to the sides for full. Arms going forward for mounting. + */ + FORWARD(1.toUByte()), + /** + * Down to the sides for full. T-pose for mounting. + */ + T_POSE_UP(2.toUByte()), + /** + * T-pose for full. Down to the sides for mounting. + */ + T_POSE_DOWN(3.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): ArmsResetMode? = entries.firstOrNull { it.value == value } + } +} + +public class ResetsSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ResetsSettingsRequest = ResetsSettingsRequest() + } +} + +public data class ResetsSettingsResponse( + public val resetMountingFeet: Boolean? = null, + public val armsResetMode: ArmsResetMode? = null, + public val yawResetSmoothTime: Float? = null, + public val saveMountingReset: Boolean? = null, + public val resetHmdPitch: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(5) + if (resetMountingFeet != null) { builder.forceDefaults(true); builder.addBoolean(0, resetMountingFeet, false); builder.forceDefaults(false) } + if (armsResetMode != null) { builder.forceDefaults(true); builder.addByte(1, armsResetMode.value.toByte(), 0); builder.forceDefaults(false) } + if (yawResetSmoothTime != null) { builder.forceDefaults(true); builder.addFloat(2, yawResetSmoothTime, 0.0); builder.forceDefaults(false) } + if (saveMountingReset != null) { builder.forceDefaults(true); builder.addBoolean(3, saveMountingReset, false); builder.forceDefaults(false) } + if (resetHmdPitch != null) { builder.forceDefaults(true); builder.addBoolean(4, resetHmdPitch, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ResetsSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_resetMountingFeet = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_armsResetMode = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_yawResetSmoothTime = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_saveMountingReset = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_resetHmdPitch = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return ResetsSettingsResponse( + resetMountingFeet = if (__offset_resetMountingFeet != 0) bb.get(tableOffset + __offset_resetMountingFeet) != 0.toByte() else null, + armsResetMode = if (__offset_armsResetMode != 0) ArmsResetMode.fromValue(bb.get(tableOffset + __offset_armsResetMode).toUByte()) else null, + yawResetSmoothTime = if (__offset_yawResetSmoothTime != 0) bb.getFloat(tableOffset + __offset_yawResetSmoothTime) else null, + saveMountingReset = if (__offset_saveMountingReset != 0) bb.get(tableOffset + __offset_saveMountingReset) != 0.toByte() else null, + resetHmdPitch = if (__offset_resetHmdPitch != 0) bb.get(tableOffset + __offset_resetHmdPitch) != 0.toByte() else null + ) + } + } +} + +public data class ChangeResetsSettingsRequest( + public val resetMountingFeet: Boolean? = null, + public val armsResetMode: ArmsResetMode? = null, + public val yawResetSmoothTime: Float? = null, + public val saveMountingReset: Boolean? = null, + public val resetHmdPitch: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(5) + if (resetMountingFeet != null) { builder.forceDefaults(true); builder.addBoolean(0, resetMountingFeet, false); builder.forceDefaults(false) } + if (armsResetMode != null) { builder.forceDefaults(true); builder.addByte(1, armsResetMode.value.toByte(), 0); builder.forceDefaults(false) } + if (yawResetSmoothTime != null) { builder.forceDefaults(true); builder.addFloat(2, yawResetSmoothTime, 0.0); builder.forceDefaults(false) } + if (saveMountingReset != null) { builder.forceDefaults(true); builder.addBoolean(3, saveMountingReset, false); builder.forceDefaults(false) } + if (resetHmdPitch != null) { builder.forceDefaults(true); builder.addBoolean(4, resetHmdPitch, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeResetsSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_resetMountingFeet = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_armsResetMode = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_yawResetSmoothTime = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_saveMountingReset = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_resetHmdPitch = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return ChangeResetsSettingsRequest( + resetMountingFeet = if (__offset_resetMountingFeet != 0) bb.get(tableOffset + __offset_resetMountingFeet) != 0.toByte() else null, + armsResetMode = if (__offset_armsResetMode != 0) ArmsResetMode.fromValue(bb.get(tableOffset + __offset_armsResetMode).toUByte()) else null, + yawResetSmoothTime = if (__offset_yawResetSmoothTime != 0) bb.getFloat(tableOffset + __offset_yawResetSmoothTime) else null, + saveMountingReset = if (__offset_saveMountingReset != 0) bb.get(tableOffset + __offset_saveMountingReset) != 0.toByte() else null, + resetHmdPitch = if (__offset_resetHmdPitch != 0) bb.get(tableOffset + __offset_resetHmdPitch) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Rpc.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Rpc.kt new file mode 100644 index 000000000..71c861445 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Rpc.kt @@ -0,0 +1,602 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Byte +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.collections.List +import solarxr_protocol.datatypes.TransactionId + +public sealed interface RpcMessage { + public companion object { + public fun decode( + type: Byte, + bb: FlatBufferReader, + offset: Int, + ): RpcMessage? = when (type.toInt()) { + 1 -> HeartbeatRequest.decode(bb, offset) + 2 -> HeartbeatResponse.decode(bb, offset) + 3 -> ResetRequest.decode(bb, offset) + 4 -> ResetResponse.decode(bb, offset) + 5 -> AssignTrackerRequest.decode(bb, offset) + 6 -> OutputTrackersSettingsRequest.decode(bb, offset) + 7 -> OutputTrackersSettingsResponse.decode(bb, offset) + 8 -> ChangeOutputTrackersSettingsRequest.decode(bb, offset) + 9 -> VMCOSCSettingsRequest.decode(bb, offset) + 10 -> VMCOSCSettingsResponse.decode(bb, offset) + 11 -> ChangeVMCOSCSettingsRequest.decode(bb, offset) + 12 -> VRMSettingsRequest.decode(bb, offset) + 13 -> VRMSettingsResponse.decode(bb, offset) + 14 -> ChangeVRMSettingsRequest.decode(bb, offset) + 15 -> SkeletonSettingsRequest.decode(bb, offset) + 16 -> SkeletonSettingsResponse.decode(bb, offset) + 17 -> ChangeSkeletonSettingsRequest.decode(bb, offset) + 18 -> TapDetectionSettingsRequest.decode(bb, offset) + 19 -> TapDetectionSettingsResponse.decode(bb, offset) + 20 -> ChangeTapDetectionSettingsRequest.decode(bb, offset) + 21 -> TapDetectionSetupModeRequest.decode(bb, offset) + 22 -> ResetsSettingsRequest.decode(bb, offset) + 23 -> ResetsSettingsResponse.decode(bb, offset) + 24 -> ChangeResetsSettingsRequest.decode(bb, offset) + 25 -> StayAlignedSettingsRequest.decode(bb, offset) + 26 -> StayAlignedSettingsResponse.decode(bb, offset) + 27 -> ChangeStayAlignedSettingsRequest.decode(bb, offset) + 28 -> CompleteStayAlignedResponse.decode(bb, offset) + 29 -> StayAlignedHideCorrectionRequest.decode(bb, offset) + 30 -> HIDSettingsRequest.decode(bb, offset) + 31 -> HIDSettingsResponse.decode(bb, offset) + 32 -> ChangeHIDSettingsRequest.decode(bb, offset) + 33 -> RecordBVHRequest.decode(bb, offset) + 34 -> RecordBVHStatus.decode(bb, offset) + 35 -> SkeletonProportionsRequest.decode(bb, offset) + 36 -> ChangeSkeletonProportionsRequest.decode(bb, offset) + 37 -> SkeletonProportionsResetAllRequest.decode(bb, offset) + 38 -> SkeletonProportionsResponse.decode(bb, offset) + 39 -> OpenSerialRequest.decode(bb, offset) + 40 -> CloseSerialRequest.decode(bb, offset) + 41 -> SerialUpdateResponse.decode(bb, offset) + 42 -> AutoBoneProcessRequest.decode(bb, offset) + 43 -> AutoBoneProcessStatusResponse.decode(bb, offset) + 44 -> AutoBoneEpochResponse.decode(bb, offset) + 45 -> OverlayDisplayModeRequest.decode(bb, offset) + 46 -> OverlayDisplayModeChangeRequest.decode(bb, offset) + 47 -> OverlayDisplayModeResponse.decode(bb, offset) + 48 -> SerialTrackerRebootRequest.decode(bb, offset) + 49 -> SerialTrackerGetInfoRequest.decode(bb, offset) + 50 -> SerialTrackerFactoryResetRequest.decode(bb, offset) + 51 -> SerialDevicesRequest.decode(bb, offset) + 52 -> SerialDevicesResponse.decode(bb, offset) + 53 -> NewSerialDeviceResponse.decode(bb, offset) + 54 -> StartWifiProvisioningRequest.decode(bb, offset) + 55 -> StopWifiProvisioningRequest.decode(bb, offset) + 56 -> WifiProvisioningStatusResponse.decode(bb, offset) + 57 -> ServerInfosRequest.decode(bb, offset) + 58 -> ServerInfosResponse.decode(bb, offset) + 59 -> LegTweaksTmpChange.decode(bb, offset) + 60 -> LegTweaksTmpClear.decode(bb, offset) + 61 -> TapDetectionSetupNotification.decode(bb, offset) + 62 -> SetPauseTrackingRequest.decode(bb, offset) + 63 -> ClearMountingResetRequest.decode(bb, offset) + 64 -> AutoBoneApplyRequest.decode(bb, offset) + 65 -> AutoBoneStopRecordingRequest.decode(bb, offset) + 66 -> AutoBoneCancelRecordingRequest.decode(bb, offset) + 67 -> SaveFileNotification.decode(bb, offset) + 68 -> TrackingPauseStateRequest.decode(bb, offset) + 69 -> TrackingPauseStateResponse.decode(bb, offset) + 70 -> SerialTrackerGetWifiScanRequest.decode(bb, offset) + 71 -> UnknownDeviceHandshakeNotification.decode(bb, offset) + 72 -> AddUnknownDeviceRequest.decode(bb, offset) + 73 -> ForgetDeviceRequest.decode(bb, offset) + 74 -> FirmwareUpdateRequest.decode(bb, offset) + 75 -> FirmwareUpdateStatusResponse.decode(bb, offset) + 76 -> FirmwareUpdateStopQueuesRequest.decode(bb, offset) + 77 -> SettingsResetRequest.decode(bb, offset) + 78 -> MagToggleRequest.decode(bb, offset) + 79 -> MagToggleResponse.decode(bb, offset) + 80 -> ChangeMagToggleRequest.decode(bb, offset) + 81 -> RecordBVHStatusRequest.decode(bb, offset) + 82 -> VRCConfigStateRequest.decode(bb, offset) + 83 -> VRCConfigStateChangeResponse.decode(bb, offset) + 84 -> EnableStayAlignedRequest.decode(bb, offset) + 85 -> DetectStayAlignedRelaxedPoseRequest.decode(bb, offset) + 86 -> ResetStayAlignedRelaxedPoseRequest.decode(bb, offset) + 87 -> SerialTrackerCustomCommandRequest.decode(bb, offset) + 88 -> VRCConfigSettingToggleMute.decode(bb, offset) + 89 -> TrackingChecklistRequest.decode(bb, offset) + 90 -> TrackingChecklistResponse.decode(bb, offset) + 91 -> IgnoreTrackingChecklistStepRequest.decode(bb, offset) + 92 -> StartUserHeightCalibration.decode(bb, offset) + 93 -> CancelUserHeightCalibration.decode(bb, offset) + 94 -> UserHeightRecordingStatusResponse.decode(bb, offset) + 95 -> VRCOSCSettingsRequest.decode(bb, offset) + 96 -> VRCOSCSettingsResponse.decode(bb, offset) + 97 -> ChangeVRCOSCSettingsRequest.decode(bb, offset) + 98 -> VRCOSCStatusRequest.decode(bb, offset) + 99 -> VRCOSCStatusChangeResponse.decode(bb, offset) + 100 -> KeybindRequest.decode(bb, offset) + 101 -> ChangeKeybindRequest.decode(bb, offset) + 102 -> KeybindResponse.decode(bb, offset) + 103 -> InstalledInfoRequest.decode(bb, offset) + 104 -> InstalledInfoResponse.decode(bb, offset) + 105 -> OpenUriRequest.decode(bb, offset) + 106 -> OpenUriResponse.decode(bb, offset) + 107 -> EnableSteamVRDriverRequest.decode(bb, offset) + else -> null + } + + public fun typeIndex(`value`: RpcMessage): Byte = when (value) { + is HeartbeatRequest -> 1 + is HeartbeatResponse -> 2 + is ResetRequest -> 3 + is ResetResponse -> 4 + is AssignTrackerRequest -> 5 + is OutputTrackersSettingsRequest -> 6 + is OutputTrackersSettingsResponse -> 7 + is ChangeOutputTrackersSettingsRequest -> 8 + is VMCOSCSettingsRequest -> 9 + is VMCOSCSettingsResponse -> 10 + is ChangeVMCOSCSettingsRequest -> 11 + is VRMSettingsRequest -> 12 + is VRMSettingsResponse -> 13 + is ChangeVRMSettingsRequest -> 14 + is SkeletonSettingsRequest -> 15 + is SkeletonSettingsResponse -> 16 + is ChangeSkeletonSettingsRequest -> 17 + is TapDetectionSettingsRequest -> 18 + is TapDetectionSettingsResponse -> 19 + is ChangeTapDetectionSettingsRequest -> 20 + is TapDetectionSetupModeRequest -> 21 + is ResetsSettingsRequest -> 22 + is ResetsSettingsResponse -> 23 + is ChangeResetsSettingsRequest -> 24 + is StayAlignedSettingsRequest -> 25 + is StayAlignedSettingsResponse -> 26 + is ChangeStayAlignedSettingsRequest -> 27 + is CompleteStayAlignedResponse -> 28 + is StayAlignedHideCorrectionRequest -> 29 + is HIDSettingsRequest -> 30 + is HIDSettingsResponse -> 31 + is ChangeHIDSettingsRequest -> 32 + is RecordBVHRequest -> 33 + is RecordBVHStatus -> 34 + is SkeletonProportionsRequest -> 35 + is ChangeSkeletonProportionsRequest -> 36 + is SkeletonProportionsResetAllRequest -> 37 + is SkeletonProportionsResponse -> 38 + is OpenSerialRequest -> 39 + is CloseSerialRequest -> 40 + is SerialUpdateResponse -> 41 + is AutoBoneProcessRequest -> 42 + is AutoBoneProcessStatusResponse -> 43 + is AutoBoneEpochResponse -> 44 + is OverlayDisplayModeRequest -> 45 + is OverlayDisplayModeChangeRequest -> 46 + is OverlayDisplayModeResponse -> 47 + is SerialTrackerRebootRequest -> 48 + is SerialTrackerGetInfoRequest -> 49 + is SerialTrackerFactoryResetRequest -> 50 + is SerialDevicesRequest -> 51 + is SerialDevicesResponse -> 52 + is NewSerialDeviceResponse -> 53 + is StartWifiProvisioningRequest -> 54 + is StopWifiProvisioningRequest -> 55 + is WifiProvisioningStatusResponse -> 56 + is ServerInfosRequest -> 57 + is ServerInfosResponse -> 58 + is LegTweaksTmpChange -> 59 + is LegTweaksTmpClear -> 60 + is TapDetectionSetupNotification -> 61 + is SetPauseTrackingRequest -> 62 + is ClearMountingResetRequest -> 63 + is AutoBoneApplyRequest -> 64 + is AutoBoneStopRecordingRequest -> 65 + is AutoBoneCancelRecordingRequest -> 66 + is SaveFileNotification -> 67 + is TrackingPauseStateRequest -> 68 + is TrackingPauseStateResponse -> 69 + is SerialTrackerGetWifiScanRequest -> 70 + is UnknownDeviceHandshakeNotification -> 71 + is AddUnknownDeviceRequest -> 72 + is ForgetDeviceRequest -> 73 + is FirmwareUpdateRequest -> 74 + is FirmwareUpdateStatusResponse -> 75 + is FirmwareUpdateStopQueuesRequest -> 76 + is SettingsResetRequest -> 77 + is MagToggleRequest -> 78 + is MagToggleResponse -> 79 + is ChangeMagToggleRequest -> 80 + is RecordBVHStatusRequest -> 81 + is VRCConfigStateRequest -> 82 + is VRCConfigStateChangeResponse -> 83 + is EnableStayAlignedRequest -> 84 + is DetectStayAlignedRelaxedPoseRequest -> 85 + is ResetStayAlignedRelaxedPoseRequest -> 86 + is SerialTrackerCustomCommandRequest -> 87 + is VRCConfigSettingToggleMute -> 88 + is TrackingChecklistRequest -> 89 + is TrackingChecklistResponse -> 90 + is IgnoreTrackingChecklistStepRequest -> 91 + is StartUserHeightCalibration -> 92 + is CancelUserHeightCalibration -> 93 + is UserHeightRecordingStatusResponse -> 94 + is VRCOSCSettingsRequest -> 95 + is VRCOSCSettingsResponse -> 96 + is ChangeVRCOSCSettingsRequest -> 97 + is VRCOSCStatusRequest -> 98 + is VRCOSCStatusChangeResponse -> 99 + is KeybindRequest -> 100 + is ChangeKeybindRequest -> 101 + is KeybindResponse -> 102 + is InstalledInfoRequest -> 103 + is InstalledInfoResponse -> 104 + is OpenUriRequest -> 105 + is OpenUriResponse -> 106 + is EnableSteamVRDriverRequest -> 107 + } + + public fun encode(`value`: RpcMessage, builder: FlatBufferWriter): Int = when (value) { + is HeartbeatRequest -> value.encode(builder) + is HeartbeatResponse -> value.encode(builder) + is ResetRequest -> value.encode(builder) + is ResetResponse -> value.encode(builder) + is AssignTrackerRequest -> value.encode(builder) + is OutputTrackersSettingsRequest -> value.encode(builder) + is OutputTrackersSettingsResponse -> value.encode(builder) + is ChangeOutputTrackersSettingsRequest -> value.encode(builder) + is VMCOSCSettingsRequest -> value.encode(builder) + is VMCOSCSettingsResponse -> value.encode(builder) + is ChangeVMCOSCSettingsRequest -> value.encode(builder) + is VRMSettingsRequest -> value.encode(builder) + is VRMSettingsResponse -> value.encode(builder) + is ChangeVRMSettingsRequest -> value.encode(builder) + is SkeletonSettingsRequest -> value.encode(builder) + is SkeletonSettingsResponse -> value.encode(builder) + is ChangeSkeletonSettingsRequest -> value.encode(builder) + is TapDetectionSettingsRequest -> value.encode(builder) + is TapDetectionSettingsResponse -> value.encode(builder) + is ChangeTapDetectionSettingsRequest -> value.encode(builder) + is TapDetectionSetupModeRequest -> value.encode(builder) + is ResetsSettingsRequest -> value.encode(builder) + is ResetsSettingsResponse -> value.encode(builder) + is ChangeResetsSettingsRequest -> value.encode(builder) + is StayAlignedSettingsRequest -> value.encode(builder) + is StayAlignedSettingsResponse -> value.encode(builder) + is ChangeStayAlignedSettingsRequest -> value.encode(builder) + is CompleteStayAlignedResponse -> value.encode(builder) + is StayAlignedHideCorrectionRequest -> value.encode(builder) + is HIDSettingsRequest -> value.encode(builder) + is HIDSettingsResponse -> value.encode(builder) + is ChangeHIDSettingsRequest -> value.encode(builder) + is RecordBVHRequest -> value.encode(builder) + is RecordBVHStatus -> value.encode(builder) + is SkeletonProportionsRequest -> value.encode(builder) + is ChangeSkeletonProportionsRequest -> value.encode(builder) + is SkeletonProportionsResetAllRequest -> value.encode(builder) + is SkeletonProportionsResponse -> value.encode(builder) + is OpenSerialRequest -> value.encode(builder) + is CloseSerialRequest -> value.encode(builder) + is SerialUpdateResponse -> value.encode(builder) + is AutoBoneProcessRequest -> value.encode(builder) + is AutoBoneProcessStatusResponse -> value.encode(builder) + is AutoBoneEpochResponse -> value.encode(builder) + is OverlayDisplayModeRequest -> value.encode(builder) + is OverlayDisplayModeChangeRequest -> value.encode(builder) + is OverlayDisplayModeResponse -> value.encode(builder) + is SerialTrackerRebootRequest -> value.encode(builder) + is SerialTrackerGetInfoRequest -> value.encode(builder) + is SerialTrackerFactoryResetRequest -> value.encode(builder) + is SerialDevicesRequest -> value.encode(builder) + is SerialDevicesResponse -> value.encode(builder) + is NewSerialDeviceResponse -> value.encode(builder) + is StartWifiProvisioningRequest -> value.encode(builder) + is StopWifiProvisioningRequest -> value.encode(builder) + is WifiProvisioningStatusResponse -> value.encode(builder) + is ServerInfosRequest -> value.encode(builder) + is ServerInfosResponse -> value.encode(builder) + is LegTweaksTmpChange -> value.encode(builder) + is LegTweaksTmpClear -> value.encode(builder) + is TapDetectionSetupNotification -> value.encode(builder) + is SetPauseTrackingRequest -> value.encode(builder) + is ClearMountingResetRequest -> value.encode(builder) + is AutoBoneApplyRequest -> value.encode(builder) + is AutoBoneStopRecordingRequest -> value.encode(builder) + is AutoBoneCancelRecordingRequest -> value.encode(builder) + is SaveFileNotification -> value.encode(builder) + is TrackingPauseStateRequest -> value.encode(builder) + is TrackingPauseStateResponse -> value.encode(builder) + is SerialTrackerGetWifiScanRequest -> value.encode(builder) + is UnknownDeviceHandshakeNotification -> value.encode(builder) + is AddUnknownDeviceRequest -> value.encode(builder) + is ForgetDeviceRequest -> value.encode(builder) + is FirmwareUpdateRequest -> value.encode(builder) + is FirmwareUpdateStatusResponse -> value.encode(builder) + is FirmwareUpdateStopQueuesRequest -> value.encode(builder) + is SettingsResetRequest -> value.encode(builder) + is MagToggleRequest -> value.encode(builder) + is MagToggleResponse -> value.encode(builder) + is ChangeMagToggleRequest -> value.encode(builder) + is RecordBVHStatusRequest -> value.encode(builder) + is VRCConfigStateRequest -> value.encode(builder) + is VRCConfigStateChangeResponse -> value.encode(builder) + is EnableStayAlignedRequest -> value.encode(builder) + is DetectStayAlignedRelaxedPoseRequest -> value.encode(builder) + is ResetStayAlignedRelaxedPoseRequest -> value.encode(builder) + is SerialTrackerCustomCommandRequest -> value.encode(builder) + is VRCConfigSettingToggleMute -> value.encode(builder) + is TrackingChecklistRequest -> value.encode(builder) + is TrackingChecklistResponse -> value.encode(builder) + is IgnoreTrackingChecklistStepRequest -> value.encode(builder) + is StartUserHeightCalibration -> value.encode(builder) + is CancelUserHeightCalibration -> value.encode(builder) + is UserHeightRecordingStatusResponse -> value.encode(builder) + is VRCOSCSettingsRequest -> value.encode(builder) + is VRCOSCSettingsResponse -> value.encode(builder) + is ChangeVRCOSCSettingsRequest -> value.encode(builder) + is VRCOSCStatusRequest -> value.encode(builder) + is VRCOSCStatusChangeResponse -> value.encode(builder) + is KeybindRequest -> value.encode(builder) + is ChangeKeybindRequest -> value.encode(builder) + is KeybindResponse -> value.encode(builder) + is InstalledInfoRequest -> value.encode(builder) + is InstalledInfoResponse -> value.encode(builder) + is OpenUriRequest -> value.encode(builder) + is OpenUriResponse -> value.encode(builder) + is EnableSteamVRDriverRequest -> value.encode(builder) + } + } +} + +public data class RpcMessageHeader( + public val txId: TransactionId? = null, + public val message: RpcMessage? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_message = message?.let { RpcMessage.encode(it, builder) } + val __type_message = message?.let { RpcMessage.typeIndex(it) } ?: 0.toByte() + + builder.startTable(3) + txId?.let { builder.addStruct(0, it.encode(builder), 0) } + builder.addByte(1, __type_message, 0) + __off_message?.let { builder.addOffset(2, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): RpcMessageHeader { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_txId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __type_message = if (vtableSize > 6 && bb.getShort(vtableOffset + 6).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + 6).toInt()) else 0 + val __offset_message = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return RpcMessageHeader( + txId = if (__offset_txId != 0) TransactionId.decode(bb, tableOffset + __offset_txId) else null, + message = if (__offset_message != 0) RpcMessage.decode(__type_message, bb, tableOffset + __offset_message + bb.getInt(tableOffset + __offset_message)) else null + ) + } + } +} + +public class HeartbeatRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HeartbeatRequest = HeartbeatRequest() + } +} + +public class HeartbeatResponse : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HeartbeatResponse = HeartbeatResponse() + } +} + +/** + * Resets the server settings + */ +public class SettingsResetRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SettingsResetRequest = SettingsResetRequest() + } +} + +public class OpenUriRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OpenUriRequest = OpenUriRequest() + } +} + +public data class OpenUriResponse( + public val success: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (success != null) { builder.forceDefaults(true); builder.addBoolean(0, success, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OpenUriResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_success = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return OpenUriResponse( + success = if (__offset_success != 0) bb.get(tableOffset + __offset_success) != 0.toByte() else null + ) + } + } +} + +public class InstalledInfoRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): InstalledInfoRequest = InstalledInfoRequest() + } +} + +public data class InstalledInfoResponse( + public val isUdevInstalled: Boolean? = null, + public val isWayland: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (isUdevInstalled != null) { builder.forceDefaults(true); builder.addBoolean(0, isUdevInstalled, false); builder.forceDefaults(false) } + if (isWayland != null) { builder.forceDefaults(true); builder.addBoolean(1, isWayland, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): InstalledInfoResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_isUdevInstalled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_isWayland = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return InstalledInfoResponse( + isUdevInstalled = if (__offset_isUdevInstalled != 0) bb.get(tableOffset + __offset_isUdevInstalled) != 0.toByte() else null, + isWayland = if (__offset_isWayland != 0) bb.get(tableOffset + __offset_isWayland) != 0.toByte() else null + ) + } + } +} + +/** + * Allows to ask generic infos about the server, + * like the local ip address, the version of the server, the java version, + * the current working dir and other information we might want to show in the gui + * for information/debug purposes + */ +public class ServerInfosRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ServerInfosRequest = ServerInfosRequest() + } +} + +/** + * Holds the Server information, this is a basic table holding various information about the currently running server + * like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more + * infos we might want to add in the future. (like java version, working dir, server version ....) + * This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance + */ +public data class ServerInfosResponse( + public val localIp: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_localIp = localIp?.let { builder.createString(it) } + + builder.startTable(1) + __off_localIp?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ServerInfosResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_localIp = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ServerInfosResponse( + localIp = if (__offset_localIp != 0) readFlatBufferString(bb, tableOffset + __offset_localIp) else null + ) + } + } +} + +/** + * Common folders often used in computers for storing files + */ +public enum class ComputerDirectory( + public val `value`: UByte, +) { + DOCUMENTS(0.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): ComputerDirectory? = entries.firstOrNull { it.value == value } + } +} + +/** + * Used for the server to save a file and have it prompt in the user side + */ +public data class SaveFileNotification( + public val `data`: List? = null, + public val mimeType: String? = null, + public val extension: String? = null, + public val expectedDir: ComputerDirectory? = null, + public val expectedFilename: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_data = data?.let { builder.createByteVector(it.map { b -> b.toByte() }.toByteArray()) } + val __off_mimeType = mimeType?.let { builder.createString(it) } + val __off_extension = extension?.let { builder.createString(it) } + val __off_expectedFilename = expectedFilename?.let { builder.createString(it) } + + builder.startTable(5) + __off_data?.let { builder.addOffset(0, it, 0) } + __off_mimeType?.let { builder.addOffset(1, it, 0) } + __off_extension?.let { builder.addOffset(2, it, 0) } + if (expectedDir != null) { builder.forceDefaults(true); builder.addByte(3, expectedDir.value.toByte(), 0); builder.forceDefaults(false) } + __off_expectedFilename?.let { builder.addOffset(4, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SaveFileNotification { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_data = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_mimeType = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_extension = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_expectedDir = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_expectedFilename = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return SaveFileNotification( + data = if (__offset_data != 0) { val vecOff = tableOffset + __offset_data + bb.getInt(tableOffset + __offset_data); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> bb.get(vecOff + 4 + i * 1).toUByte() } } else null, + mimeType = if (__offset_mimeType != 0) readFlatBufferString(bb, tableOffset + __offset_mimeType) else null, + extension = if (__offset_extension != 0) readFlatBufferString(bb, tableOffset + __offset_extension) else null, + expectedDir = if (__offset_expectedDir != 0) ComputerDirectory.fromValue(bb.get(tableOffset + __offset_expectedDir).toUByte()) else null, + expectedFilename = if (__offset_expectedFilename != 0) readFlatBufferString(bb, tableOffset + __offset_expectedFilename) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Serial.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Serial.kt new file mode 100644 index 000000000..6b99dee14 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Serial.kt @@ -0,0 +1,335 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.collections.List + +public enum class SerialDeviceType( + public val `value`: UByte, +) { + ESP_TRACKER(0.toUByte()), + HID_RECEIVER(1.toUByte()), + HID_TRACKER(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): SerialDeviceType? = entries.firstOrNull { it.value == value } + } +} + +public data class SerialDevice( + public val port: String? = null, + public val name: String? = null, + public val type: SerialDeviceType? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_port = port?.let { builder.createString(it) } + val __off_name = name?.let { builder.createString(it) } + + builder.startTable(3) + __off_port?.let { builder.addOffset(0, it, 0) } + __off_name?.let { builder.addOffset(1, it, 0) } + if (type != null) { builder.forceDefaults(true); builder.addByte(2, type.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialDevice { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_port = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_name = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_type = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return SerialDevice( + port = if (__offset_port != 0) readFlatBufferString(bb, tableOffset + __offset_port) else null, + name = if (__offset_name != 0) readFlatBufferString(bb, tableOffset + __offset_name) else null, + type = if (__offset_type != 0) SerialDeviceType.fromValue(bb.get(tableOffset + __offset_type).toUByte()) else null + ) + } + } +} + +public data class OpenSerialRequest( + public val auto: Boolean? = null, + public val port: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_port = port?.let { builder.createString(it) } + + builder.startTable(2) + if (auto != null) { builder.forceDefaults(true); builder.addBoolean(0, auto, false); builder.forceDefaults(false) } + __off_port?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OpenSerialRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_auto = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_port = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return OpenSerialRequest( + auto = if (__offset_auto != 0) bb.get(tableOffset + __offset_auto) != 0.toByte() else null, + port = if (__offset_port != 0) readFlatBufferString(bb, tableOffset + __offset_port) else null + ) + } + } +} + +public class CloseSerialRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): CloseSerialRequest = CloseSerialRequest() + } +} + +public data class SerialUpdateResponse( + public val log: String? = null, + public val closed: Boolean? = null, + public val device: SerialDevice? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_log = log?.let { builder.createString(it) } + val __off_device = device?.encode(builder) + + builder.startTable(3) + __off_log?.let { builder.addOffset(0, it, 0) } + if (closed != null) { builder.forceDefaults(true); builder.addBoolean(1, closed, false); builder.forceDefaults(false) } + __off_device?.let { builder.addOffset(2, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialUpdateResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_log = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_closed = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_device = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return SerialUpdateResponse( + log = if (__offset_log != 0) readFlatBufferString(bb, tableOffset + __offset_log) else null, + closed = if (__offset_closed != 0) bb.get(tableOffset + __offset_closed) != 0.toByte() else null, + device = if (__offset_device != 0) SerialDevice.decode(bb, tableOffset + __offset_device + bb.getInt(tableOffset + __offset_device)) else null + ) + } + } +} + +/** + * Reboots the tracker connected to the serial monitor + */ +public class SerialTrackerRebootRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialTrackerRebootRequest = SerialTrackerRebootRequest() + } +} + +/** + * Sends the GET INFO cmd to the current tracker on the serial monitor + */ +public class SerialTrackerGetInfoRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialTrackerGetInfoRequest = SerialTrackerGetInfoRequest() + } +} + +/** + * Sends the FRST cmd to the currently connected Tracker over the Serial Monitor + */ +public class SerialTrackerFactoryResetRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialTrackerFactoryResetRequest = SerialTrackerFactoryResetRequest() + } +} + +/** + * Sends a custom cmd to the currently connected Tracker over the Serial Monitor + */ +public data class SerialTrackerCustomCommandRequest( + public val command: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_command = command?.let { builder.createString(it) } + + builder.startTable(1) + __off_command?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialTrackerCustomCommandRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_command = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return SerialTrackerCustomCommandRequest( + command = if (__offset_command != 0) readFlatBufferString(bb, tableOffset + __offset_command) else null + ) + } + } +} + +public class SerialDevicesRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialDevicesRequest = SerialDevicesRequest() + } +} + +public data class SerialDevicesResponse( + public val devices: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_devices = devices?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(1) + __off_devices?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialDevicesResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_devices = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return SerialDevicesResponse( + devices = if (__offset_devices != 0) { val vecOff = tableOffset + __offset_devices + bb.getInt(tableOffset + __offset_devices); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) SerialDevice.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +public data class NewSerialDeviceResponse( + public val device: SerialDevice? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_device = device?.encode(builder) + + builder.startTable(1) + __off_device?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): NewSerialDeviceResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_device = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return NewSerialDeviceResponse( + device = if (__offset_device != 0) SerialDevice.decode(bb, tableOffset + __offset_device + bb.getInt(tableOffset + __offset_device)) else null + ) + } + } +} + +/** + * Sends the GET WIFISCAN cmd to the current tracker on the serial monitor + */ +public class SerialTrackerGetWifiScanRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SerialTrackerGetWifiScanRequest = SerialTrackerGetWifiScanRequest() + } +} + +public class HIDSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HIDSettingsRequest = HIDSettingsRequest() + } +} + +public data class HIDSettingsResponse( + public val trackersOverHid: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackersOverHid != null) { builder.forceDefaults(true); builder.addBoolean(0, trackersOverHid, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): HIDSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackersOverHid = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return HIDSettingsResponse( + trackersOverHid = if (__offset_trackersOverHid != 0) bb.get(tableOffset + __offset_trackersOverHid) != 0.toByte() else null + ) + } + } +} + +public data class ChangeHIDSettingsRequest( + public val trackersOverHid: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackersOverHid != null) { builder.forceDefaults(true); builder.addBoolean(0, trackersOverHid, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeHIDSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackersOverHid = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ChangeHIDSettingsRequest( + trackersOverHid = if (__offset_trackersOverHid != 0) bb.get(tableOffset + __offset_trackersOverHid) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Skeleton.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Skeleton.kt new file mode 100644 index 000000000..47b5c7810 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Skeleton.kt @@ -0,0 +1,640 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.UByte +import kotlin.collections.List +import solarxr_protocol.datatypes.BodyPart + +public enum class SkeletonBone( + public val `value`: UByte, +) { + NONE(0.toUByte()), + HEAD(1.toUByte()), + NECK(2.toUByte()), + CHEST(3.toUByte()), + CHEST_OFFSET(4.toUByte()), + WAIST(5.toUByte()), + HIP(6.toUByte()), + HIP_OFFSET(7.toUByte()), + HIPS_WIDTH(8.toUByte()), + UPPER_LEG(9.toUByte()), + LOWER_LEG(10.toUByte()), + FOOT_LENGTH(11.toUByte()), + FOOT_SHIFT(12.toUByte()), + SKELETON_OFFSET(13.toUByte()), + SHOULDERS_DISTANCE(14.toUByte()), + SHOULDERS_WIDTH(15.toUByte()), + UPPER_ARM(16.toUByte()), + LOWER_ARM(17.toUByte()), + HAND_Y(18.toUByte()), + HAND_Z(19.toUByte()), + ELBOW_OFFSET(20.toUByte()), + UPPER_CHEST(21.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): SkeletonBone? = entries.firstOrNull { it.value == value } + } +} + +public data class SkeletonPart( + public val bone: SkeletonBone? = null, + public val `value`: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (bone != null) { builder.forceDefaults(true); builder.addByte(0, bone.value.toByte(), 0); builder.forceDefaults(false) } + if (value != null) { builder.forceDefaults(true); builder.addFloat(1, value, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonPart { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_bone = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_value = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return SkeletonPart( + bone = if (__offset_bone != 0) SkeletonBone.fromValue(bb.get(tableOffset + __offset_bone).toUByte()) else null, + value = if (__offset_value != 0) bb.getFloat(tableOffset + __offset_value) else null + ) + } + } +} + +public class SkeletonProportionsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonProportionsRequest = SkeletonProportionsRequest() + } +} + +public data class SkeletonProportionsResponse( + public val skeletonParts: List? = null, + public val userHeight: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_skeletonParts = skeletonParts?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(2) + __off_skeletonParts?.let { builder.addOffset(0, it, 0) } + if (userHeight != null) { builder.forceDefaults(true); builder.addFloat(1, userHeight, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonProportionsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_skeletonParts = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_userHeight = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return SkeletonProportionsResponse( + skeletonParts = if (__offset_skeletonParts != 0) { val vecOff = tableOffset + __offset_skeletonParts + bb.getInt(tableOffset + __offset_skeletonParts); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) SkeletonPart.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + userHeight = if (__offset_userHeight != 0) bb.getFloat(tableOffset + __offset_userHeight) else null + ) + } + } +} + +public data class ChangeSkeletonProportionsRequest( + public val bone: SkeletonBone? = null, + public val `value`: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (bone != null) { builder.forceDefaults(true); builder.addByte(0, bone.value.toByte(), 0); builder.forceDefaults(false) } + if (value != null) { builder.forceDefaults(true); builder.addFloat(1, value, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeSkeletonProportionsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_bone = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_value = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return ChangeSkeletonProportionsRequest( + bone = if (__offset_bone != 0) SkeletonBone.fromValue(bb.get(tableOffset + __offset_bone).toUByte()) else null, + value = if (__offset_value != 0) bb.getFloat(tableOffset + __offset_value) else null + ) + } + } +} + +public class SkeletonProportionsResetAllRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonProportionsResetAllRequest = SkeletonProportionsResetAllRequest() + } +} + +/** + * Makes a temporary change to legtweaks. This is not saved to disk, and can be + * cleared with `LegTweaksTmpClear` + */ +public data class LegTweaksTmpChange( + public val floorClip: Boolean? = null, + public val skatingCorrection: Boolean? = null, + public val toeSnap: Boolean? = null, + public val footPlant: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(4) + if (floorClip != null) { builder.forceDefaults(true); builder.addBoolean(0, floorClip, false); builder.forceDefaults(false) } + if (skatingCorrection != null) { builder.forceDefaults(true); builder.addBoolean(1, skatingCorrection, false); builder.forceDefaults(false) } + if (toeSnap != null) { builder.forceDefaults(true); builder.addBoolean(2, toeSnap, false); builder.forceDefaults(false) } + if (footPlant != null) { builder.forceDefaults(true); builder.addBoolean(3, footPlant, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): LegTweaksTmpChange { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_floorClip = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_skatingCorrection = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_toeSnap = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_footPlant = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return LegTweaksTmpChange( + floorClip = if (__offset_floorClip != 0) bb.get(tableOffset + __offset_floorClip) != 0.toByte() else null, + skatingCorrection = if (__offset_skatingCorrection != 0) bb.get(tableOffset + __offset_skatingCorrection) != 0.toByte() else null, + toeSnap = if (__offset_toeSnap != 0) bb.get(tableOffset + __offset_toeSnap) != 0.toByte() else null, + footPlant = if (__offset_footPlant != 0) bb.get(tableOffset + __offset_footPlant) != 0.toByte() else null + ) + } + } +} + +/** + * Clears the legtweaks temporary state back to what the config has. + * Setting a field to `true` will reset that field. + */ +public data class LegTweaksTmpClear( + public val floorClip: Boolean = false, + public val skatingCorrection: Boolean = false, + public val toeSnap: Boolean = false, + public val footPlant: Boolean = false, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(4) + builder.addBoolean(0, floorClip, false) + builder.addBoolean(1, skatingCorrection, false) + builder.addBoolean(2, toeSnap, false) + builder.addBoolean(3, footPlant, false) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): LegTweaksTmpClear { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_floorClip = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_skatingCorrection = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_toeSnap = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_footPlant = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return LegTweaksTmpClear( + floorClip = if (__offset_floorClip != 0) bb.get(tableOffset + __offset_floorClip) != 0.toByte() else false, + skatingCorrection = if (__offset_skatingCorrection != 0) bb.get(tableOffset + __offset_skatingCorrection) != 0.toByte() else false, + toeSnap = if (__offset_toeSnap != 0) bb.get(tableOffset + __offset_toeSnap) != 0.toByte() else false, + footPlant = if (__offset_footPlant != 0) bb.get(tableOffset + __offset_footPlant) != 0.toByte() else false + ) + } + } +} + +public data class SetPauseTrackingRequest( + public val pauseTracking: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (pauseTracking != null) { builder.forceDefaults(true); builder.addBoolean(0, pauseTracking, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SetPauseTrackingRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_pauseTracking = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return SetPauseTrackingRequest( + pauseTracking = if (__offset_pauseTracking != 0) bb.get(tableOffset + __offset_pauseTracking) != 0.toByte() else null + ) + } + } +} + +/** + * Requests the current state of tracking pause + */ +public class TrackingPauseStateRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingPauseStateRequest = TrackingPauseStateRequest() + } +} + +public data class TrackingPauseStateResponse( + public val trackingPaused: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackingPaused != null) { builder.forceDefaults(true); builder.addBoolean(0, trackingPaused, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingPauseStateResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackingPaused = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingPauseStateResponse( + trackingPaused = if (__offset_trackingPaused != 0) bb.get(tableOffset + __offset_trackingPaused) != 0.toByte() else null + ) + } + } +} + +/** + * Toggles for the skeletal model. + */ +public data class SkeletonToggles( + public val forceArmsFromHmd: Boolean? = null, + public val floorClip: Boolean? = null, + public val skatingCorrection: Boolean? = null, + public val toeSnap: Boolean? = null, + public val footPlant: Boolean? = null, + public val selfLocalization: Boolean? = null, + public val usePosition: Boolean? = null, + public val enforceConstraints: Boolean? = null, + public val correctConstraints: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(9) + if (forceArmsFromHmd != null) { builder.forceDefaults(true); builder.addBoolean(0, forceArmsFromHmd, false); builder.forceDefaults(false) } + if (floorClip != null) { builder.forceDefaults(true); builder.addBoolean(1, floorClip, false); builder.forceDefaults(false) } + if (skatingCorrection != null) { builder.forceDefaults(true); builder.addBoolean(2, skatingCorrection, false); builder.forceDefaults(false) } + if (toeSnap != null) { builder.forceDefaults(true); builder.addBoolean(3, toeSnap, false); builder.forceDefaults(false) } + if (footPlant != null) { builder.forceDefaults(true); builder.addBoolean(4, footPlant, false); builder.forceDefaults(false) } + if (selfLocalization != null) { builder.forceDefaults(true); builder.addBoolean(5, selfLocalization, false); builder.forceDefaults(false) } + if (usePosition != null) { builder.forceDefaults(true); builder.addBoolean(6, usePosition, false); builder.forceDefaults(false) } + if (enforceConstraints != null) { builder.forceDefaults(true); builder.addBoolean(7, enforceConstraints, false); builder.forceDefaults(false) } + if (correctConstraints != null) { builder.forceDefaults(true); builder.addBoolean(8, correctConstraints, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonToggles { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_forceArmsFromHmd = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_floorClip = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_skatingCorrection = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_toeSnap = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_footPlant = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_selfLocalization = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_usePosition = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_enforceConstraints = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_correctConstraints = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + + return SkeletonToggles( + forceArmsFromHmd = if (__offset_forceArmsFromHmd != 0) bb.get(tableOffset + __offset_forceArmsFromHmd) != 0.toByte() else null, + floorClip = if (__offset_floorClip != 0) bb.get(tableOffset + __offset_floorClip) != 0.toByte() else null, + skatingCorrection = if (__offset_skatingCorrection != 0) bb.get(tableOffset + __offset_skatingCorrection) != 0.toByte() else null, + toeSnap = if (__offset_toeSnap != 0) bb.get(tableOffset + __offset_toeSnap) != 0.toByte() else null, + footPlant = if (__offset_footPlant != 0) bb.get(tableOffset + __offset_footPlant) != 0.toByte() else null, + selfLocalization = if (__offset_selfLocalization != 0) bb.get(tableOffset + __offset_selfLocalization) != 0.toByte() else null, + usePosition = if (__offset_usePosition != 0) bb.get(tableOffset + __offset_usePosition) != 0.toByte() else null, + enforceConstraints = if (__offset_enforceConstraints != 0) bb.get(tableOffset + __offset_enforceConstraints) != 0.toByte() else null, + correctConstraints = if (__offset_correctConstraints != 0) bb.get(tableOffset + __offset_correctConstraints) != 0.toByte() else null + ) + } + } +} + +/** + * Ratios for the skeletal model. Accepted values for them range from 0 to 1 + */ +public data class SkeletonRatios( + public val imputeSpineFromUpperLower: Float? = null, + public val imputeSpineCurvature: Float? = null, + public val interpHipLegs: Float? = null, + public val interpKneeTrackerAnkle: Float? = null, + public val interpKneeAnkle: Float? = null, + public val skatingCorrectionStrength: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(6) + if (imputeSpineFromUpperLower != null) { builder.forceDefaults(true); builder.addFloat(0, imputeSpineFromUpperLower, 0.0); builder.forceDefaults(false) } + if (imputeSpineCurvature != null) { builder.forceDefaults(true); builder.addFloat(1, imputeSpineCurvature, 0.0); builder.forceDefaults(false) } + if (interpHipLegs != null) { builder.forceDefaults(true); builder.addFloat(2, interpHipLegs, 0.0); builder.forceDefaults(false) } + if (interpKneeTrackerAnkle != null) { builder.forceDefaults(true); builder.addFloat(3, interpKneeTrackerAnkle, 0.0); builder.forceDefaults(false) } + if (interpKneeAnkle != null) { builder.forceDefaults(true); builder.addFloat(4, interpKneeAnkle, 0.0); builder.forceDefaults(false) } + if (skatingCorrectionStrength != null) { builder.forceDefaults(true); builder.addFloat(5, skatingCorrectionStrength, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonRatios { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_imputeSpineFromUpperLower = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_imputeSpineCurvature = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_interpHipLegs = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_interpKneeTrackerAnkle = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_interpKneeAnkle = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_skatingCorrectionStrength = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return SkeletonRatios( + imputeSpineFromUpperLower = if (__offset_imputeSpineFromUpperLower != 0) bb.getFloat(tableOffset + __offset_imputeSpineFromUpperLower) else null, + imputeSpineCurvature = if (__offset_imputeSpineCurvature != 0) bb.getFloat(tableOffset + __offset_imputeSpineCurvature) else null, + interpHipLegs = if (__offset_interpHipLegs != 0) bb.getFloat(tableOffset + __offset_interpHipLegs) else null, + interpKneeTrackerAnkle = if (__offset_interpKneeTrackerAnkle != 0) bb.getFloat(tableOffset + __offset_interpKneeTrackerAnkle) else null, + interpKneeAnkle = if (__offset_interpKneeAnkle != 0) bb.getFloat(tableOffset + __offset_interpKneeAnkle) else null, + skatingCorrectionStrength = if (__offset_skatingCorrectionStrength != 0) bb.getFloat(tableOffset + __offset_skatingCorrectionStrength) else null + ) + } + } +} + +public enum class FilteringType( + public val `value`: UByte, +) { + NONE(0.toUByte()), + SMOOTHING(1.toUByte()), + PREDICTION(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): FilteringType? = entries.firstOrNull { it.value == value } + } +} + +/** + * Filtering (e.g smoothing) applied to the skeleton's movements + */ +public data class SkeletonFiltering( + public val type: FilteringType? = null, + public val amount: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (type != null) { builder.forceDefaults(true); builder.addByte(0, type.value.toByte(), 0); builder.forceDefaults(false) } + if (amount != null) { builder.forceDefaults(true); builder.addFloat(1, amount, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonFiltering { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_type = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_amount = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return SkeletonFiltering( + type = if (__offset_type != 0) FilteringType.fromValue(bb.get(tableOffset + __offset_type).toUByte()) else null, + amount = if (__offset_amount != 0) bb.getFloat(tableOffset + __offset_amount) else null + ) + } + } +} + +/** + * Data used to compute the skeleton's height. + */ +public data class SkeletonHeight( + public val hmdHeight: Float? = null, + public val floorHeight: Float? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (hmdHeight != null) { builder.forceDefaults(true); builder.addFloat(0, hmdHeight, 0.0); builder.forceDefaults(false) } + if (floorHeight != null) { builder.forceDefaults(true); builder.addFloat(1, floorHeight, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonHeight { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_hmdHeight = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_floorHeight = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return SkeletonHeight( + hmdHeight = if (__offset_hmdHeight != 0) bb.getFloat(tableOffset + __offset_hmdHeight) else null, + floorHeight = if (__offset_floorHeight != 0) bb.getFloat(tableOffset + __offset_floorHeight) else null + ) + } + } +} + +public class SkeletonSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonSettingsRequest = SkeletonSettingsRequest() + } +} + +public data class SkeletonSettingsResponse( + public val toggles: SkeletonToggles? = null, + public val ratios: SkeletonRatios? = null, + public val filtering: SkeletonFiltering? = null, + public val skeletonHeight: SkeletonHeight? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_toggles = toggles?.encode(builder) + val __off_ratios = ratios?.encode(builder) + val __off_filtering = filtering?.encode(builder) + val __off_skeletonHeight = skeletonHeight?.encode(builder) + + builder.startTable(4) + __off_toggles?.let { builder.addOffset(0, it, 0) } + __off_ratios?.let { builder.addOffset(1, it, 0) } + __off_filtering?.let { builder.addOffset(2, it, 0) } + __off_skeletonHeight?.let { builder.addOffset(3, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): SkeletonSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_toggles = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_ratios = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_filtering = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_skeletonHeight = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return SkeletonSettingsResponse( + toggles = if (__offset_toggles != 0) SkeletonToggles.decode(bb, tableOffset + __offset_toggles + bb.getInt(tableOffset + __offset_toggles)) else null, + ratios = if (__offset_ratios != 0) SkeletonRatios.decode(bb, tableOffset + __offset_ratios + bb.getInt(tableOffset + __offset_ratios)) else null, + filtering = if (__offset_filtering != 0) SkeletonFiltering.decode(bb, tableOffset + __offset_filtering + bb.getInt(tableOffset + __offset_filtering)) else null, + skeletonHeight = if (__offset_skeletonHeight != 0) SkeletonHeight.decode(bb, tableOffset + __offset_skeletonHeight + bb.getInt(tableOffset + __offset_skeletonHeight)) else null + ) + } + } +} + +public data class ChangeSkeletonSettingsRequest( + public val toggles: SkeletonToggles? = null, + public val ratios: SkeletonRatios? = null, + public val filtering: SkeletonFiltering? = null, + public val skeletonHeight: SkeletonHeight? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_toggles = toggles?.encode(builder) + val __off_ratios = ratios?.encode(builder) + val __off_filtering = filtering?.encode(builder) + val __off_skeletonHeight = skeletonHeight?.encode(builder) + + builder.startTable(4) + __off_toggles?.let { builder.addOffset(0, it, 0) } + __off_ratios?.let { builder.addOffset(1, it, 0) } + __off_filtering?.let { builder.addOffset(2, it, 0) } + __off_skeletonHeight?.let { builder.addOffset(3, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeSkeletonSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_toggles = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_ratios = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_filtering = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_skeletonHeight = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return ChangeSkeletonSettingsRequest( + toggles = if (__offset_toggles != 0) SkeletonToggles.decode(bb, tableOffset + __offset_toggles + bb.getInt(tableOffset + __offset_toggles)) else null, + ratios = if (__offset_ratios != 0) SkeletonRatios.decode(bb, tableOffset + __offset_ratios + bb.getInt(tableOffset + __offset_ratios)) else null, + filtering = if (__offset_filtering != 0) SkeletonFiltering.decode(bb, tableOffset + __offset_filtering + bb.getInt(tableOffset + __offset_filtering)) else null, + skeletonHeight = if (__offset_skeletonHeight != 0) SkeletonHeight.decode(bb, tableOffset + __offset_skeletonHeight + bb.getInt(tableOffset + __offset_skeletonHeight)) else null + ) + } + } +} + +public class OutputTrackersSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OutputTrackersSettingsRequest = OutputTrackersSettingsRequest() + } +} + +public data class OutputTrackersSettingsResponse( + public val automaticTrackerToggle: Boolean? = null, + public val trackers: List? = null, + public val sendDerivedVelocity: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackers = trackers?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(3) + if (automaticTrackerToggle != null) { builder.forceDefaults(true); builder.addBoolean(0, automaticTrackerToggle, false); builder.forceDefaults(false) } + __off_trackers?.let { builder.addOffset(1, it, 0) } + if (sendDerivedVelocity != null) { builder.forceDefaults(true); builder.addBoolean(2, sendDerivedVelocity, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): OutputTrackersSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_automaticTrackerToggle = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_trackers = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_sendDerivedVelocity = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return OutputTrackersSettingsResponse( + automaticTrackerToggle = if (__offset_automaticTrackerToggle != 0) bb.get(tableOffset + __offset_automaticTrackerToggle) != 0.toByte() else null, + trackers = if (__offset_trackers != 0) { val vecOff = tableOffset + __offset_trackers + bb.getInt(tableOffset + __offset_trackers); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> BodyPart.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null, + sendDerivedVelocity = if (__offset_sendDerivedVelocity != 0) bb.get(tableOffset + __offset_sendDerivedVelocity) != 0.toByte() else null + ) + } + } +} + +public data class ChangeOutputTrackersSettingsRequest( + public val automaticTrackerToggle: Boolean? = null, + public val trackers: List? = null, + public val sendDerivedVelocity: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackers = trackers?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(3) + if (automaticTrackerToggle != null) { builder.forceDefaults(true); builder.addBoolean(0, automaticTrackerToggle, false); builder.forceDefaults(false) } + __off_trackers?.let { builder.addOffset(1, it, 0) } + if (sendDerivedVelocity != null) { builder.forceDefaults(true); builder.addBoolean(2, sendDerivedVelocity, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeOutputTrackersSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_automaticTrackerToggle = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_trackers = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_sendDerivedVelocity = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return ChangeOutputTrackersSettingsRequest( + automaticTrackerToggle = if (__offset_automaticTrackerToggle != 0) bb.get(tableOffset + __offset_automaticTrackerToggle) != 0.toByte() else null, + trackers = if (__offset_trackers != 0) { val vecOff = tableOffset + __offset_trackers + bb.getInt(tableOffset + __offset_trackers); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> BodyPart.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null, + sendDerivedVelocity = if (__offset_sendDerivedVelocity != 0) bb.get(tableOffset + __offset_sendDerivedVelocity) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/StayAligned.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/StayAligned.kt new file mode 100644 index 000000000..ebae6ae82 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/StayAligned.kt @@ -0,0 +1,283 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.UByte + +public data class EnableStayAlignedRequest( + public val enable: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (enable != null) { builder.forceDefaults(true); builder.addBoolean(0, enable, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): EnableStayAlignedRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enable = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return EnableStayAlignedRequest( + enable = if (__offset_enable != 0) bb.get(tableOffset + __offset_enable) != 0.toByte() else null + ) + } + } +} + +public enum class StayAlignedRelaxedPose( + public val `value`: UByte, +) { + STANDING(0.toUByte()), + SITTING(1.toUByte()), + FLAT(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): StayAlignedRelaxedPose? = entries.firstOrNull { it.value == value } + } +} + +public data class DetectStayAlignedRelaxedPoseRequest( + public val pose: StayAlignedRelaxedPose? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (pose != null) { builder.forceDefaults(true); builder.addByte(0, pose.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): DetectStayAlignedRelaxedPoseRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_pose = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return DetectStayAlignedRelaxedPoseRequest( + pose = if (__offset_pose != 0) StayAlignedRelaxedPose.fromValue(bb.get(tableOffset + __offset_pose).toUByte()) else null + ) + } + } +} + +public data class ResetStayAlignedRelaxedPoseRequest( + public val pose: StayAlignedRelaxedPose? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (pose != null) { builder.forceDefaults(true); builder.addByte(0, pose.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ResetStayAlignedRelaxedPoseRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_pose = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ResetStayAlignedRelaxedPoseRequest( + pose = if (__offset_pose != 0) StayAlignedRelaxedPose.fromValue(bb.get(tableOffset + __offset_pose).toUByte()) else null + ) + } + } +} + +public class StayAlignedSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StayAlignedSettingsRequest = StayAlignedSettingsRequest() + } +} + +public data class StayAlignedSettingsResponse( + public val enabled: Boolean? = null, + public val standingEnabled: Boolean? = null, + public val standingUpperLegAngle: Float? = null, + public val standingLowerLegAngle: Float? = null, + public val standingFootAngle: Float? = null, + public val sittingEnabled: Boolean? = null, + public val sittingUpperLegAngle: Float? = null, + public val sittingLowerLegAngle: Float? = null, + public val sittingFootAngle: Float? = null, + public val flatEnabled: Boolean? = null, + public val flatUpperLegAngle: Float? = null, + public val flatLowerLegAngle: Float? = null, + public val flatFootAngle: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(13) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + if (standingEnabled != null) { builder.forceDefaults(true); builder.addBoolean(1, standingEnabled, false); builder.forceDefaults(false) } + if (standingUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(2, standingUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (standingLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(3, standingLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (standingFootAngle != null) { builder.forceDefaults(true); builder.addFloat(4, standingFootAngle, 0.0); builder.forceDefaults(false) } + if (sittingEnabled != null) { builder.forceDefaults(true); builder.addBoolean(5, sittingEnabled, false); builder.forceDefaults(false) } + if (sittingUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(6, sittingUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (sittingLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(7, sittingLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (sittingFootAngle != null) { builder.forceDefaults(true); builder.addFloat(8, sittingFootAngle, 0.0); builder.forceDefaults(false) } + if (flatEnabled != null) { builder.forceDefaults(true); builder.addBoolean(9, flatEnabled, false); builder.forceDefaults(false) } + if (flatUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(10, flatUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (flatLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(11, flatLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (flatFootAngle != null) { builder.forceDefaults(true); builder.addFloat(12, flatFootAngle, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StayAlignedSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_standingEnabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_standingUpperLegAngle = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_standingLowerLegAngle = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_standingFootAngle = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_sittingEnabled = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_sittingUpperLegAngle = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_sittingLowerLegAngle = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_sittingFootAngle = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_flatEnabled = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_flatUpperLegAngle = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_flatLowerLegAngle = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_flatFootAngle = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return StayAlignedSettingsResponse( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + standingEnabled = if (__offset_standingEnabled != 0) bb.get(tableOffset + __offset_standingEnabled) != 0.toByte() else null, + standingUpperLegAngle = if (__offset_standingUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_standingUpperLegAngle) else null, + standingLowerLegAngle = if (__offset_standingLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_standingLowerLegAngle) else null, + standingFootAngle = if (__offset_standingFootAngle != 0) bb.getFloat(tableOffset + __offset_standingFootAngle) else null, + sittingEnabled = if (__offset_sittingEnabled != 0) bb.get(tableOffset + __offset_sittingEnabled) != 0.toByte() else null, + sittingUpperLegAngle = if (__offset_sittingUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_sittingUpperLegAngle) else null, + sittingLowerLegAngle = if (__offset_sittingLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_sittingLowerLegAngle) else null, + sittingFootAngle = if (__offset_sittingFootAngle != 0) bb.getFloat(tableOffset + __offset_sittingFootAngle) else null, + flatEnabled = if (__offset_flatEnabled != 0) bb.get(tableOffset + __offset_flatEnabled) != 0.toByte() else null, + flatUpperLegAngle = if (__offset_flatUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_flatUpperLegAngle) else null, + flatLowerLegAngle = if (__offset_flatLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_flatLowerLegAngle) else null, + flatFootAngle = if (__offset_flatFootAngle != 0) bb.getFloat(tableOffset + __offset_flatFootAngle) else null + ) + } + } +} + +public data class ChangeStayAlignedSettingsRequest( + public val enabled: Boolean? = null, + public val standingEnabled: Boolean? = null, + public val standingUpperLegAngle: Float? = null, + public val standingLowerLegAngle: Float? = null, + public val standingFootAngle: Float? = null, + public val sittingEnabled: Boolean? = null, + public val sittingUpperLegAngle: Float? = null, + public val sittingLowerLegAngle: Float? = null, + public val sittingFootAngle: Float? = null, + public val flatEnabled: Boolean? = null, + public val flatUpperLegAngle: Float? = null, + public val flatLowerLegAngle: Float? = null, + public val flatFootAngle: Float? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(13) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + if (standingEnabled != null) { builder.forceDefaults(true); builder.addBoolean(1, standingEnabled, false); builder.forceDefaults(false) } + if (standingUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(2, standingUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (standingLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(3, standingLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (standingFootAngle != null) { builder.forceDefaults(true); builder.addFloat(4, standingFootAngle, 0.0); builder.forceDefaults(false) } + if (sittingEnabled != null) { builder.forceDefaults(true); builder.addBoolean(5, sittingEnabled, false); builder.forceDefaults(false) } + if (sittingUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(6, sittingUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (sittingLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(7, sittingLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (sittingFootAngle != null) { builder.forceDefaults(true); builder.addFloat(8, sittingFootAngle, 0.0); builder.forceDefaults(false) } + if (flatEnabled != null) { builder.forceDefaults(true); builder.addBoolean(9, flatEnabled, false); builder.forceDefaults(false) } + if (flatUpperLegAngle != null) { builder.forceDefaults(true); builder.addFloat(10, flatUpperLegAngle, 0.0); builder.forceDefaults(false) } + if (flatLowerLegAngle != null) { builder.forceDefaults(true); builder.addFloat(11, flatLowerLegAngle, 0.0); builder.forceDefaults(false) } + if (flatFootAngle != null) { builder.forceDefaults(true); builder.addFloat(12, flatFootAngle, 0.0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeStayAlignedSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_standingEnabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_standingUpperLegAngle = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_standingLowerLegAngle = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_standingFootAngle = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_sittingEnabled = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_sittingUpperLegAngle = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_sittingLowerLegAngle = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_sittingFootAngle = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_flatEnabled = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_flatUpperLegAngle = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_flatLowerLegAngle = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_flatFootAngle = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return ChangeStayAlignedSettingsRequest( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + standingEnabled = if (__offset_standingEnabled != 0) bb.get(tableOffset + __offset_standingEnabled) != 0.toByte() else null, + standingUpperLegAngle = if (__offset_standingUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_standingUpperLegAngle) else null, + standingLowerLegAngle = if (__offset_standingLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_standingLowerLegAngle) else null, + standingFootAngle = if (__offset_standingFootAngle != 0) bb.getFloat(tableOffset + __offset_standingFootAngle) else null, + sittingEnabled = if (__offset_sittingEnabled != 0) bb.get(tableOffset + __offset_sittingEnabled) != 0.toByte() else null, + sittingUpperLegAngle = if (__offset_sittingUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_sittingUpperLegAngle) else null, + sittingLowerLegAngle = if (__offset_sittingLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_sittingLowerLegAngle) else null, + sittingFootAngle = if (__offset_sittingFootAngle != 0) bb.getFloat(tableOffset + __offset_sittingFootAngle) else null, + flatEnabled = if (__offset_flatEnabled != 0) bb.get(tableOffset + __offset_flatEnabled) != 0.toByte() else null, + flatUpperLegAngle = if (__offset_flatUpperLegAngle != 0) bb.getFloat(tableOffset + __offset_flatUpperLegAngle) else null, + flatLowerLegAngle = if (__offset_flatLowerLegAngle != 0) bb.getFloat(tableOffset + __offset_flatLowerLegAngle) else null, + flatFootAngle = if (__offset_flatFootAngle != 0) bb.getFloat(tableOffset + __offset_flatFootAngle) else null + ) + } + } +} + +public class CompleteStayAlignedResponse : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): CompleteStayAlignedResponse = CompleteStayAlignedResponse() + } +} + +public data class StayAlignedHideCorrectionRequest( + public val hideCorrection: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (hideCorrection != null) { builder.forceDefaults(true); builder.addBoolean(0, hideCorrection, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): StayAlignedHideCorrectionRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_hideCorrection = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return StayAlignedHideCorrectionRequest( + hideCorrection = if (__offset_hideCorrection != 0) bb.get(tableOffset + __offset_hideCorrection) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Tracker.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Tracker.kt new file mode 100644 index 000000000..5e6bb0607 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Tracker.kt @@ -0,0 +1,348 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.UShort +import solarxr_protocol.datatypes.BodyPart +import solarxr_protocol.datatypes.math.Quat + +public data class AssignTrackerRequest( + public val trackerId: UShort? = null, + public val bodyPosition: BodyPart? = null, + public val mountingOrientation: Quat? = null, + public val displayName: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_displayName = displayName?.let { builder.createString(it) } + + builder.startTable(4) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + if (bodyPosition != null) { builder.forceDefaults(true); builder.addByte(1, bodyPosition.value.toByte(), 0); builder.forceDefaults(false) } + mountingOrientation?.let { builder.addStruct(2, it.encode(builder), 0) } + __off_displayName?.let { builder.addOffset(3, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): AssignTrackerRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_bodyPosition = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_mountingOrientation = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_displayName = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return AssignTrackerRequest( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null, + bodyPosition = if (__offset_bodyPosition != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_bodyPosition).toUByte()) else null, + mountingOrientation = if (__offset_mountingOrientation != 0) Quat.decode(bb, tableOffset + __offset_mountingOrientation) else null, + displayName = if (__offset_displayName != 0) readFlatBufferString(bb, tableOffset + __offset_displayName) else null + ) + } + } +} + +public class TapDetectionSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TapDetectionSettingsRequest = TapDetectionSettingsRequest() + } +} + +public data class TapDetectionSettingsResponse( + public val fullResetDelay: Float? = null, + public val fullResetEnabled: Boolean? = null, + public val fullResetTaps: UByte? = null, + public val yawResetDelay: Float? = null, + public val yawResetEnabled: Boolean? = null, + public val yawResetTaps: UByte? = null, + public val mountingResetDelay: Float? = null, + public val mountingResetEnabled: Boolean? = null, + public val mountingResetTaps: UByte? = null, + public val numberTrackersOverThreshold: UByte? = null, + public val yawResetTracker: BodyPart? = null, + public val fullResetTracker: BodyPart? = null, + public val mountingResetTracker: BodyPart? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(13) + if (fullResetDelay != null) { builder.forceDefaults(true); builder.addFloat(0, fullResetDelay, 0.0); builder.forceDefaults(false) } + if (fullResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(1, fullResetEnabled, false); builder.forceDefaults(false) } + if (fullResetTaps != null) { builder.forceDefaults(true); builder.addByte(2, fullResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (yawResetDelay != null) { builder.forceDefaults(true); builder.addFloat(3, yawResetDelay, 0.0); builder.forceDefaults(false) } + if (yawResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(4, yawResetEnabled, false); builder.forceDefaults(false) } + if (yawResetTaps != null) { builder.forceDefaults(true); builder.addByte(5, yawResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (mountingResetDelay != null) { builder.forceDefaults(true); builder.addFloat(6, mountingResetDelay, 0.0); builder.forceDefaults(false) } + if (mountingResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(7, mountingResetEnabled, false); builder.forceDefaults(false) } + if (mountingResetTaps != null) { builder.forceDefaults(true); builder.addByte(8, mountingResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (numberTrackersOverThreshold != null) { builder.forceDefaults(true); builder.addByte(9, numberTrackersOverThreshold.toByte(), 0); builder.forceDefaults(false) } + if (yawResetTracker != null) { builder.forceDefaults(true); builder.addByte(10, yawResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + if (fullResetTracker != null) { builder.forceDefaults(true); builder.addByte(11, fullResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + if (mountingResetTracker != null) { builder.forceDefaults(true); builder.addByte(12, mountingResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TapDetectionSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_fullResetDelay = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_fullResetEnabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_fullResetTaps = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_yawResetDelay = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_yawResetEnabled = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_yawResetTaps = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_mountingResetDelay = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_mountingResetEnabled = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_mountingResetTaps = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_numberTrackersOverThreshold = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_yawResetTracker = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_fullResetTracker = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_mountingResetTracker = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return TapDetectionSettingsResponse( + fullResetDelay = if (__offset_fullResetDelay != 0) bb.getFloat(tableOffset + __offset_fullResetDelay) else null, + fullResetEnabled = if (__offset_fullResetEnabled != 0) bb.get(tableOffset + __offset_fullResetEnabled) != 0.toByte() else null, + fullResetTaps = if (__offset_fullResetTaps != 0) bb.get(tableOffset + __offset_fullResetTaps).toUByte() else null, + yawResetDelay = if (__offset_yawResetDelay != 0) bb.getFloat(tableOffset + __offset_yawResetDelay) else null, + yawResetEnabled = if (__offset_yawResetEnabled != 0) bb.get(tableOffset + __offset_yawResetEnabled) != 0.toByte() else null, + yawResetTaps = if (__offset_yawResetTaps != 0) bb.get(tableOffset + __offset_yawResetTaps).toUByte() else null, + mountingResetDelay = if (__offset_mountingResetDelay != 0) bb.getFloat(tableOffset + __offset_mountingResetDelay) else null, + mountingResetEnabled = if (__offset_mountingResetEnabled != 0) bb.get(tableOffset + __offset_mountingResetEnabled) != 0.toByte() else null, + mountingResetTaps = if (__offset_mountingResetTaps != 0) bb.get(tableOffset + __offset_mountingResetTaps).toUByte() else null, + numberTrackersOverThreshold = if (__offset_numberTrackersOverThreshold != 0) bb.get(tableOffset + __offset_numberTrackersOverThreshold).toUByte() else null, + yawResetTracker = if (__offset_yawResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_yawResetTracker).toUByte()) else null, + fullResetTracker = if (__offset_fullResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_fullResetTracker).toUByte()) else null, + mountingResetTracker = if (__offset_mountingResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_mountingResetTracker).toUByte()) else null + ) + } + } +} + +public data class ChangeTapDetectionSettingsRequest( + public val fullResetDelay: Float? = null, + public val fullResetEnabled: Boolean? = null, + public val fullResetTaps: UByte? = null, + public val yawResetDelay: Float? = null, + public val yawResetEnabled: Boolean? = null, + public val yawResetTaps: UByte? = null, + public val mountingResetDelay: Float? = null, + public val mountingResetEnabled: Boolean? = null, + public val mountingResetTaps: UByte? = null, + public val numberTrackersOverThreshold: UByte? = null, + public val yawResetTracker: BodyPart? = null, + public val fullResetTracker: BodyPart? = null, + public val mountingResetTracker: BodyPart? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(13) + if (fullResetDelay != null) { builder.forceDefaults(true); builder.addFloat(0, fullResetDelay, 0.0); builder.forceDefaults(false) } + if (fullResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(1, fullResetEnabled, false); builder.forceDefaults(false) } + if (fullResetTaps != null) { builder.forceDefaults(true); builder.addByte(2, fullResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (yawResetDelay != null) { builder.forceDefaults(true); builder.addFloat(3, yawResetDelay, 0.0); builder.forceDefaults(false) } + if (yawResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(4, yawResetEnabled, false); builder.forceDefaults(false) } + if (yawResetTaps != null) { builder.forceDefaults(true); builder.addByte(5, yawResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (mountingResetDelay != null) { builder.forceDefaults(true); builder.addFloat(6, mountingResetDelay, 0.0); builder.forceDefaults(false) } + if (mountingResetEnabled != null) { builder.forceDefaults(true); builder.addBoolean(7, mountingResetEnabled, false); builder.forceDefaults(false) } + if (mountingResetTaps != null) { builder.forceDefaults(true); builder.addByte(8, mountingResetTaps.toByte(), 0); builder.forceDefaults(false) } + if (numberTrackersOverThreshold != null) { builder.forceDefaults(true); builder.addByte(9, numberTrackersOverThreshold.toByte(), 0); builder.forceDefaults(false) } + if (yawResetTracker != null) { builder.forceDefaults(true); builder.addByte(10, yawResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + if (fullResetTracker != null) { builder.forceDefaults(true); builder.addByte(11, fullResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + if (mountingResetTracker != null) { builder.forceDefaults(true); builder.addByte(12, mountingResetTracker.value.toByte(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeTapDetectionSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_fullResetDelay = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_fullResetEnabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_fullResetTaps = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_yawResetDelay = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_yawResetEnabled = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_yawResetTaps = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_mountingResetDelay = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_mountingResetEnabled = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_mountingResetTaps = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_numberTrackersOverThreshold = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_yawResetTracker = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_fullResetTracker = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_mountingResetTracker = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + + return ChangeTapDetectionSettingsRequest( + fullResetDelay = if (__offset_fullResetDelay != 0) bb.getFloat(tableOffset + __offset_fullResetDelay) else null, + fullResetEnabled = if (__offset_fullResetEnabled != 0) bb.get(tableOffset + __offset_fullResetEnabled) != 0.toByte() else null, + fullResetTaps = if (__offset_fullResetTaps != 0) bb.get(tableOffset + __offset_fullResetTaps).toUByte() else null, + yawResetDelay = if (__offset_yawResetDelay != 0) bb.getFloat(tableOffset + __offset_yawResetDelay) else null, + yawResetEnabled = if (__offset_yawResetEnabled != 0) bb.get(tableOffset + __offset_yawResetEnabled) != 0.toByte() else null, + yawResetTaps = if (__offset_yawResetTaps != 0) bb.get(tableOffset + __offset_yawResetTaps).toUByte() else null, + mountingResetDelay = if (__offset_mountingResetDelay != 0) bb.getFloat(tableOffset + __offset_mountingResetDelay) else null, + mountingResetEnabled = if (__offset_mountingResetEnabled != 0) bb.get(tableOffset + __offset_mountingResetEnabled) != 0.toByte() else null, + mountingResetTaps = if (__offset_mountingResetTaps != 0) bb.get(tableOffset + __offset_mountingResetTaps).toUByte() else null, + numberTrackersOverThreshold = if (__offset_numberTrackersOverThreshold != 0) bb.get(tableOffset + __offset_numberTrackersOverThreshold).toUByte() else null, + yawResetTracker = if (__offset_yawResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_yawResetTracker).toUByte()) else null, + fullResetTracker = if (__offset_fullResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_fullResetTracker).toUByte()) else null, + mountingResetTracker = if (__offset_mountingResetTracker != 0) BodyPart.fromValue(bb.get(tableOffset + __offset_mountingResetTracker).toUByte()) else null + ) + } + } +} + +/** + * Sets the TapDetection setup mode. + */ +public data class TapDetectionSetupModeRequest( + public val setupMode: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (setupMode != null) { builder.forceDefaults(true); builder.addBoolean(0, setupMode, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TapDetectionSetupModeRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_setupMode = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TapDetectionSetupModeRequest( + setupMode = if (__offset_setupMode != 0) bb.get(tableOffset + __offset_setupMode) != 0.toByte() else null + ) + } + } +} + +/** + * Indicates which tracker got triggered by TapDetection while setup mode is enabled + */ +public data class TapDetectionSetupNotification( + public val trackerId: UShort? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TapDetectionSetupNotification { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TapDetectionSetupNotification( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null + ) + } + } +} + +/** + * If no tracker ID is given, it's the setting for every tracker/device + */ +public data class MagToggleRequest( + public val trackerId: UShort? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): MagToggleRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return MagToggleRequest( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null + ) + } + } +} + +/** + * If no tracker ID is given, it's the setting for every tracker/device + */ +public data class MagToggleResponse( + public val trackerId: UShort? = null, + public val enable: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + if (enable != null) { builder.forceDefaults(true); builder.addBoolean(1, enable, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): MagToggleResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_enable = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return MagToggleResponse( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null, + enable = if (__offset_enable != 0) bb.get(tableOffset + __offset_enable) != 0.toByte() else null + ) + } + } +} + +/** + * If no tracker ID is given, it's the setting for every tracker/device + */ +public data class ChangeMagToggleRequest( + public val trackerId: UShort? = null, + public val enable: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + if (enable != null) { builder.forceDefaults(true); builder.addBoolean(1, enable, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeMagToggleRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_enable = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return ChangeMagToggleRequest( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null, + enable = if (__offset_enable != 0) bb.get(tableOffset + __offset_enable) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/TrackingChecklist.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/TrackingChecklist.kt new file mode 100644 index 000000000..af948037b --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/TrackingChecklist.kt @@ -0,0 +1,382 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Byte +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.UShort +import kotlin.collections.List + +public enum class TrackingChecklistStepId( + public val `value`: UByte, +) { + UNKNOWN(0.toUByte()), + TRACKERS_REST_CALIBRATION(1.toUByte()), + FULL_RESET(2.toUByte()), + VRCHAT_SETTINGS(3.toUByte()), + STEAMVR_DISCONNECTED(4.toUByte()), + UNASSIGNED_HMD(5.toUByte()), + TRACKER_ERROR(6.toUByte()), + NETWORK_PROFILE_PUBLIC(7.toUByte()), + MOUNTING_CALIBRATION(8.toUByte()), + FEET_MOUNTING_CALIBRATION(9.toUByte()), + STAY_ALIGNED_CONFIGURED(10.toUByte()), + STEAMVR_HANDS_ENABLED(11.toUByte()), + STANDABLE_INSTALLED(12.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): TrackingChecklistStepId? = entries.firstOrNull { it.value == value } + } +} + +public enum class TrackingChecklistStepVisibility( + public val `value`: UByte, +) { + ALWAYS(0.toUByte()), + WHEN_INVALID(1.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): TrackingChecklistStepVisibility? = entries.firstOrNull { it.value == value } + } +} + +/** + * Trackers that need a reset + */ +public data class TrackingChecklistTrackerReset( + public val trackersId: List? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackersId = trackersId?.let { run { val values = it; builder.startVector(2, values.size, 2); for (value in values.asReversed()) builder.putShort(value.toShort()); builder.endVector() } } + + builder.startTable(1) + __off_trackersId?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistTrackerReset { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackersId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingChecklistTrackerReset( + trackersId = if (__offset_trackersId != 0) { val vecOff = tableOffset + __offset_trackersId + bb.getInt(tableOffset + __offset_trackersId); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> bb.getShort(vecOff + 4 + i * 2).toUShort() } } else null + ) + } + } +} + +/** + * Trackers with error state + */ +public data class TrackingChecklistTrackerError( + public val trackersId: List? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackersId = trackersId?.let { run { val values = it; builder.startVector(2, values.size, 2); for (value in values.asReversed()) builder.putShort(value.toShort()); builder.endVector() } } + + builder.startTable(1) + __off_trackersId?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistTrackerError { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackersId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingChecklistTrackerError( + trackersId = if (__offset_trackersId != 0) { val vecOff = tableOffset + __offset_trackersId + bb.getInt(tableOffset + __offset_trackersId); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> bb.getShort(vecOff + 4 + i * 2).toUShort() } } else null + ) + } + } +} + +public data class TrackingChecklistNeedCalibration( + public val trackersId: List? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + val __off_trackersId = trackersId?.let { run { val values = it; builder.startVector(2, values.size, 2); for (value in values.asReversed()) builder.putShort(value.toShort()); builder.endVector() } } + + builder.startTable(1) + __off_trackersId?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistNeedCalibration { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackersId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingChecklistNeedCalibration( + trackersId = if (__offset_trackersId != 0) { val vecOff = tableOffset + __offset_trackersId + bb.getInt(tableOffset + __offset_trackersId); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> bb.getShort(vecOff + 4 + i * 2).toUShort() } } else null + ) + } + } +} + +public data class TrackingChecklistSteamVRDisconnected( + public val bridgeSettingsName: String? = null, + public val driverInstalled: Boolean? = null, + public val driverBlockedBySafeMode: Boolean? = null, + public val driverEnabled: Boolean? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + val __off_bridgeSettingsName = bridgeSettingsName?.let { builder.createString(it) } + + builder.startTable(4) + __off_bridgeSettingsName?.let { builder.addOffset(0, it, 0) } + if (driverInstalled != null) { builder.forceDefaults(true); builder.addBoolean(1, driverInstalled, false); builder.forceDefaults(false) } + if (driverBlockedBySafeMode != null) { builder.forceDefaults(true); builder.addBoolean(2, driverBlockedBySafeMode, false); builder.forceDefaults(false) } + if (driverEnabled != null) { builder.forceDefaults(true); builder.addBoolean(3, driverEnabled, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistSteamVRDisconnected { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_bridgeSettingsName = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_driverInstalled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_driverBlockedBySafeMode = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_driverEnabled = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + + return TrackingChecklistSteamVRDisconnected( + bridgeSettingsName = if (__offset_bridgeSettingsName != 0) readFlatBufferString(bb, tableOffset + __offset_bridgeSettingsName) else null, + driverInstalled = if (__offset_driverInstalled != 0) bb.get(tableOffset + __offset_driverInstalled) != 0.toByte() else null, + driverBlockedBySafeMode = if (__offset_driverBlockedBySafeMode != 0) bb.get(tableOffset + __offset_driverBlockedBySafeMode) != 0.toByte() else null, + driverEnabled = if (__offset_driverEnabled != 0) bb.get(tableOffset + __offset_driverEnabled) != 0.toByte() else null + ) + } + } +} + +public class EnableSteamVRDriverRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): EnableSteamVRDriverRequest = EnableSteamVRDriverRequest() + } +} + +public data class TrackingChecklistUnassignedHMD( + public val trackerId: UShort? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(1) + if (trackerId != null) { builder.forceDefaults(true); builder.addShort(0, trackerId.toShort(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistUnassignedHMD { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_trackerId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingChecklistUnassignedHMD( + trackerId = if (__offset_trackerId != 0) bb.getShort(tableOffset + __offset_trackerId).toUShort() else null + ) + } + } +} + +public data class TrackingChecklistPublicNetworks( + public val adapters: List? = null, +) : TrackingChecklistExtraData { + public fun encode(builder: FlatBufferWriter): Int { + val __off_adapters = adapters?.let { builder.createVectorOfTables(it.map { s -> builder.createString(s) }.toIntArray()) } + + builder.startTable(1) + __off_adapters?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistPublicNetworks { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_adapters = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return TrackingChecklistPublicNetworks( + adapters = if (__offset_adapters != 0) { val vecOff = tableOffset + __offset_adapters + bb.getInt(tableOffset + __offset_adapters); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> readFlatBufferString(bb, vecOff + 4 + i * 4) } } else null + ) + } + } +} + +public sealed interface TrackingChecklistExtraData { + public companion object { + public fun decode( + type: Byte, + bb: FlatBufferReader, + offset: Int, + ): TrackingChecklistExtraData? = when (type.toInt()) { + 1 -> TrackingChecklistTrackerReset.decode(bb, offset) + 2 -> TrackingChecklistTrackerError.decode(bb, offset) + 3 -> TrackingChecklistSteamVRDisconnected.decode(bb, offset) + 4 -> TrackingChecklistUnassignedHMD.decode(bb, offset) + 5 -> TrackingChecklistNeedCalibration.decode(bb, offset) + 6 -> TrackingChecklistPublicNetworks.decode(bb, offset) + else -> null + } + + public fun typeIndex(`value`: TrackingChecklistExtraData): Byte = when (value) { + is TrackingChecklistTrackerReset -> 1 + is TrackingChecklistTrackerError -> 2 + is TrackingChecklistSteamVRDisconnected -> 3 + is TrackingChecklistUnassignedHMD -> 4 + is TrackingChecklistNeedCalibration -> 5 + is TrackingChecklistPublicNetworks -> 6 + } + + public fun encode(`value`: TrackingChecklistExtraData, builder: FlatBufferWriter): Int = when (value) { + is TrackingChecklistTrackerReset -> value.encode(builder) + is TrackingChecklistTrackerError -> value.encode(builder) + is TrackingChecklistSteamVRDisconnected -> value.encode(builder) + is TrackingChecklistUnassignedHMD -> value.encode(builder) + is TrackingChecklistNeedCalibration -> value.encode(builder) + is TrackingChecklistPublicNetworks -> value.encode(builder) + } + } +} + +public data class TrackingChecklistStep( + public val id: TrackingChecklistStepId? = null, + public val valid: Boolean? = null, + public val enabled: Boolean? = null, + public val visibility: TrackingChecklistStepVisibility? = null, + public val optional: Boolean? = null, + public val ignorable: Boolean? = null, + public val extraData: TrackingChecklistExtraData? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_extraData = extraData?.let { TrackingChecklistExtraData.encode(it, builder) } + val __type_extraData = extraData?.let { TrackingChecklistExtraData.typeIndex(it) } ?: 0.toByte() + + builder.startTable(8) + if (id != null) { builder.forceDefaults(true); builder.addByte(0, id.value.toByte(), 0); builder.forceDefaults(false) } + if (valid != null) { builder.forceDefaults(true); builder.addBoolean(1, valid, false); builder.forceDefaults(false) } + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(2, enabled, false); builder.forceDefaults(false) } + if (visibility != null) { builder.forceDefaults(true); builder.addByte(3, visibility.value.toByte(), 0); builder.forceDefaults(false) } + if (optional != null) { builder.forceDefaults(true); builder.addBoolean(4, optional, false); builder.forceDefaults(false) } + if (ignorable != null) { builder.forceDefaults(true); builder.addBoolean(5, ignorable, false); builder.forceDefaults(false) } + builder.addByte(6, __type_extraData, 0) + __off_extraData?.let { builder.addOffset(7, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistStep { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_id = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_valid = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_enabled = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_visibility = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_optional = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_ignorable = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __type_extraData = if (vtableSize > 16 && bb.getShort(vtableOffset + 16).toInt() != 0) bb.get(tableOffset + bb.getShort(vtableOffset + 16).toInt()) else 0 + val __offset_extraData = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + + return TrackingChecklistStep( + id = if (__offset_id != 0) TrackingChecklistStepId.fromValue(bb.get(tableOffset + __offset_id).toUByte()) else null, + valid = if (__offset_valid != 0) bb.get(tableOffset + __offset_valid) != 0.toByte() else null, + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + visibility = if (__offset_visibility != 0) TrackingChecklistStepVisibility.fromValue(bb.get(tableOffset + __offset_visibility).toUByte()) else null, + optional = if (__offset_optional != 0) bb.get(tableOffset + __offset_optional) != 0.toByte() else null, + ignorable = if (__offset_ignorable != 0) bb.get(tableOffset + __offset_ignorable) != 0.toByte() else null, + extraData = if (__offset_extraData != 0) TrackingChecklistExtraData.decode(__type_extraData, bb, tableOffset + __offset_extraData + bb.getInt(tableOffset + __offset_extraData)) else null + ) + } + } +} + +public class TrackingChecklistRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistRequest = TrackingChecklistRequest() + } +} + +public data class TrackingChecklistResponse( + public val steps: List? = null, + public val ignoredSteps: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_steps = steps?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + val __off_ignoredSteps = ignoredSteps?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(2) + __off_steps?.let { builder.addOffset(0, it, 0) } + __off_ignoredSteps?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): TrackingChecklistResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_steps = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_ignoredSteps = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return TrackingChecklistResponse( + steps = if (__offset_steps != 0) { val vecOff = tableOffset + __offset_steps + bb.getInt(tableOffset + __offset_steps); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) TrackingChecklistStep.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null, + ignoredSteps = if (__offset_ignoredSteps != 0) { val vecOff = tableOffset + __offset_ignoredSteps + bb.getInt(tableOffset + __offset_ignoredSteps); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> TrackingChecklistStepId.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null + ) + } + } +} + +public data class IgnoreTrackingChecklistStepRequest( + public val stepId: TrackingChecklistStepId? = null, + public val ignore: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(2) + if (stepId != null) { builder.forceDefaults(true); builder.addByte(0, stepId.value.toByte(), 0); builder.forceDefaults(false) } + if (ignore != null) { builder.forceDefaults(true); builder.addBoolean(1, ignore, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): IgnoreTrackingChecklistStepRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_stepId = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_ignore = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return IgnoreTrackingChecklistStepRequest( + stepId = if (__offset_stepId != 0) TrackingChecklistStepId.fromValue(bb.get(tableOffset + __offset_stepId).toUByte()) else null, + ignore = if (__offset_ignore != 0) bb.get(tableOffset + __offset_ignore) != 0.toByte() else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vmc.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vmc.kt new file mode 100644 index 000000000..86541b889 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vmc.kt @@ -0,0 +1,171 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String +import kotlin.UShort + +public class VMCOSCSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VMCOSCSettingsRequest = VMCOSCSettingsRequest() + } +} + +public data class VMCOSCSettingsResponse( + public val enabled: Boolean? = null, + public val portIn: UShort? = null, + public val portOut: UShort? = null, + public val address: String? = null, + public val anchorHip: Boolean? = null, + public val mirrorTracking: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_address = address?.let { builder.createString(it) } + + builder.startTable(6) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + if (portIn != null) { builder.forceDefaults(true); builder.addShort(1, portIn.toShort(), 0); builder.forceDefaults(false) } + if (portOut != null) { builder.forceDefaults(true); builder.addShort(2, portOut.toShort(), 0); builder.forceDefaults(false) } + __off_address?.let { builder.addOffset(3, it, 0) } + if (anchorHip != null) { builder.forceDefaults(true); builder.addBoolean(4, anchorHip, false); builder.forceDefaults(false) } + if (mirrorTracking != null) { builder.forceDefaults(true); builder.addBoolean(5, mirrorTracking, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VMCOSCSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_portIn = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_portOut = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_address = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_anchorHip = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_mirrorTracking = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return VMCOSCSettingsResponse( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + portIn = if (__offset_portIn != 0) bb.getShort(tableOffset + __offset_portIn).toUShort() else null, + portOut = if (__offset_portOut != 0) bb.getShort(tableOffset + __offset_portOut).toUShort() else null, + address = if (__offset_address != 0) readFlatBufferString(bb, tableOffset + __offset_address) else null, + anchorHip = if (__offset_anchorHip != 0) bb.get(tableOffset + __offset_anchorHip) != 0.toByte() else null, + mirrorTracking = if (__offset_mirrorTracking != 0) bb.get(tableOffset + __offset_mirrorTracking) != 0.toByte() else null + ) + } + } +} + +public data class ChangeVMCOSCSettingsRequest( + public val enabled: Boolean? = null, + public val portIn: UShort? = null, + public val portOut: UShort? = null, + public val address: String? = null, + public val anchorHip: Boolean? = null, + public val mirrorTracking: Boolean? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_address = address?.let { builder.createString(it) } + + builder.startTable(6) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + if (portIn != null) { builder.forceDefaults(true); builder.addShort(1, portIn.toShort(), 0); builder.forceDefaults(false) } + if (portOut != null) { builder.forceDefaults(true); builder.addShort(2, portOut.toShort(), 0); builder.forceDefaults(false) } + __off_address?.let { builder.addOffset(3, it, 0) } + if (anchorHip != null) { builder.forceDefaults(true); builder.addBoolean(4, anchorHip, false); builder.forceDefaults(false) } + if (mirrorTracking != null) { builder.forceDefaults(true); builder.addBoolean(5, mirrorTracking, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeVMCOSCSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_portIn = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_portOut = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_address = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_anchorHip = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_mirrorTracking = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + + return ChangeVMCOSCSettingsRequest( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + portIn = if (__offset_portIn != 0) bb.getShort(tableOffset + __offset_portIn).toUShort() else null, + portOut = if (__offset_portOut != 0) bb.getShort(tableOffset + __offset_portOut).toUShort() else null, + address = if (__offset_address != 0) readFlatBufferString(bb, tableOffset + __offset_address) else null, + anchorHip = if (__offset_anchorHip != 0) bb.get(tableOffset + __offset_anchorHip) != 0.toByte() else null, + mirrorTracking = if (__offset_mirrorTracking != 0) bb.get(tableOffset + __offset_mirrorTracking) != 0.toByte() else null + ) + } + } +} + +public class VRMSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRMSettingsRequest = VRMSettingsRequest() + } +} + +public data class VRMSettingsResponse( + public val vrmJson: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_vrmJson = vrmJson?.let { builder.createString(it) } + + builder.startTable(1) + __off_vrmJson?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRMSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_vrmJson = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return VRMSettingsResponse( + vrmJson = if (__offset_vrmJson != 0) readFlatBufferString(bb, tableOffset + __offset_vrmJson) else null + ) + } + } +} + +public data class ChangeVRMSettingsRequest( + public val vrmJson: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_vrmJson = vrmJson?.let { builder.createString(it) } + + builder.startTable(1) + __off_vrmJson?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeVRMSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_vrmJson = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return ChangeVRMSettingsRequest( + vrmJson = if (__offset_vrmJson != 0) readFlatBufferString(bb, tableOffset + __offset_vrmJson) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrchat.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrchat.kt new file mode 100644 index 000000000..9ae8a935f --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrchat.kt @@ -0,0 +1,306 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Float +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.collections.List + +public enum class VRCTrackerModel( + public val `value`: UByte, +) { + UNKNOWN(0.toUByte()), + SPHERE(1.toUByte()), + SYSTEM(2.toUByte()), + BOX(3.toUByte()), + AXIS(4.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCTrackerModel? = entries.firstOrNull { it.value == value } + } +} + +public enum class VRCSpineMode( + public val `value`: UByte, +) { + UNKNOWN(0.toUByte()), + LOCK_HIP(1.toUByte()), + LOCK_HEAD(2.toUByte()), + LOCK_BOTH(3.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCSpineMode? = entries.firstOrNull { it.value == value } + } +} + +public enum class VRCAvatarMeasurementType( + public val `value`: UByte, +) { + UNKNOWN(0.toUByte()), + HEIGHT(1.toUByte()), + ARM_SPAN(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCAvatarMeasurementType? = entries.firstOrNull { it.value == value } + } +} + +public data class VRCConfigValidity( + public val legacyModeOk: Boolean? = null, + public val shoulderTrackingOk: Boolean? = null, + public val userHeightOk: Boolean? = null, + public val calibrationRangeOk: Boolean? = null, + public val calibrationVisualsOk: Boolean? = null, + public val trackerModelOk: Boolean? = null, + public val spineModeOk: Boolean? = null, + public val avatarMeasurementTypeOk: Boolean? = null, + public val shoulderWidthCompensationOk: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(9) + if (legacyModeOk != null) { builder.forceDefaults(true); builder.addBoolean(0, legacyModeOk, false); builder.forceDefaults(false) } + if (shoulderTrackingOk != null) { builder.forceDefaults(true); builder.addBoolean(1, shoulderTrackingOk, false); builder.forceDefaults(false) } + if (userHeightOk != null) { builder.forceDefaults(true); builder.addBoolean(2, userHeightOk, false); builder.forceDefaults(false) } + if (calibrationRangeOk != null) { builder.forceDefaults(true); builder.addBoolean(3, calibrationRangeOk, false); builder.forceDefaults(false) } + if (calibrationVisualsOk != null) { builder.forceDefaults(true); builder.addBoolean(4, calibrationVisualsOk, false); builder.forceDefaults(false) } + if (trackerModelOk != null) { builder.forceDefaults(true); builder.addBoolean(5, trackerModelOk, false); builder.forceDefaults(false) } + if (spineModeOk != null) { builder.forceDefaults(true); builder.addBoolean(6, spineModeOk, false); builder.forceDefaults(false) } + if (avatarMeasurementTypeOk != null) { builder.forceDefaults(true); builder.addBoolean(7, avatarMeasurementTypeOk, false); builder.forceDefaults(false) } + if (shoulderWidthCompensationOk != null) { builder.forceDefaults(true); builder.addBoolean(8, shoulderWidthCompensationOk, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigValidity { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_legacyModeOk = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_shoulderTrackingOk = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_userHeightOk = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_calibrationRangeOk = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_calibrationVisualsOk = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_trackerModelOk = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_spineModeOk = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_avatarMeasurementTypeOk = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_shoulderWidthCompensationOk = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + + return VRCConfigValidity( + legacyModeOk = if (__offset_legacyModeOk != 0) bb.get(tableOffset + __offset_legacyModeOk) != 0.toByte() else null, + shoulderTrackingOk = if (__offset_shoulderTrackingOk != 0) bb.get(tableOffset + __offset_shoulderTrackingOk) != 0.toByte() else null, + userHeightOk = if (__offset_userHeightOk != 0) bb.get(tableOffset + __offset_userHeightOk) != 0.toByte() else null, + calibrationRangeOk = if (__offset_calibrationRangeOk != 0) bb.get(tableOffset + __offset_calibrationRangeOk) != 0.toByte() else null, + calibrationVisualsOk = if (__offset_calibrationVisualsOk != 0) bb.get(tableOffset + __offset_calibrationVisualsOk) != 0.toByte() else null, + trackerModelOk = if (__offset_trackerModelOk != 0) bb.get(tableOffset + __offset_trackerModelOk) != 0.toByte() else null, + spineModeOk = if (__offset_spineModeOk != 0) bb.get(tableOffset + __offset_spineModeOk) != 0.toByte() else null, + avatarMeasurementTypeOk = if (__offset_avatarMeasurementTypeOk != 0) bb.get(tableOffset + __offset_avatarMeasurementTypeOk) != 0.toByte() else null, + shoulderWidthCompensationOk = if (__offset_shoulderWidthCompensationOk != 0) bb.get(tableOffset + __offset_shoulderWidthCompensationOk) != 0.toByte() else null + ) + } + } +} + +public data class VRCConfigValues( + public val legacyMode: Boolean? = null, + public val shoulderTrackingDisabled: Boolean? = null, + public val userHeight: Float? = null, + public val calibrationRange: Float? = null, + public val calibrationVisuals: Boolean? = null, + public val trackerModel: VRCTrackerModel? = null, + public val spineMode: VRCSpineMode? = null, + public val avatarMeasurementType: VRCAvatarMeasurementType? = null, + public val shoulderWidthCompensation: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + + builder.startTable(9) + if (legacyMode != null) { builder.forceDefaults(true); builder.addBoolean(0, legacyMode, false); builder.forceDefaults(false) } + if (shoulderTrackingDisabled != null) { builder.forceDefaults(true); builder.addBoolean(1, shoulderTrackingDisabled, false); builder.forceDefaults(false) } + if (userHeight != null) { builder.forceDefaults(true); builder.addFloat(2, userHeight, 0.0); builder.forceDefaults(false) } + if (calibrationRange != null) { builder.forceDefaults(true); builder.addFloat(3, calibrationRange, 0.0); builder.forceDefaults(false) } + if (calibrationVisuals != null) { builder.forceDefaults(true); builder.addBoolean(4, calibrationVisuals, false); builder.forceDefaults(false) } + if (trackerModel != null) { builder.forceDefaults(true); builder.addByte(5, trackerModel.value.toByte(), 0); builder.forceDefaults(false) } + if (spineMode != null) { builder.forceDefaults(true); builder.addByte(6, spineMode.value.toByte(), 0); builder.forceDefaults(false) } + if (avatarMeasurementType != null) { builder.forceDefaults(true); builder.addByte(7, avatarMeasurementType.value.toByte(), 0); builder.forceDefaults(false) } + if (shoulderWidthCompensation != null) { builder.forceDefaults(true); builder.addBoolean(8, shoulderWidthCompensation, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigValues { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_legacyMode = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_shoulderTrackingDisabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_userHeight = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_calibrationRange = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_calibrationVisuals = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_trackerModel = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_spineMode = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_avatarMeasurementType = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_shoulderWidthCompensation = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + + return VRCConfigValues( + legacyMode = if (__offset_legacyMode != 0) bb.get(tableOffset + __offset_legacyMode) != 0.toByte() else null, + shoulderTrackingDisabled = if (__offset_shoulderTrackingDisabled != 0) bb.get(tableOffset + __offset_shoulderTrackingDisabled) != 0.toByte() else null, + userHeight = if (__offset_userHeight != 0) bb.getFloat(tableOffset + __offset_userHeight) else null, + calibrationRange = if (__offset_calibrationRange != 0) bb.getFloat(tableOffset + __offset_calibrationRange) else null, + calibrationVisuals = if (__offset_calibrationVisuals != 0) bb.get(tableOffset + __offset_calibrationVisuals) != 0.toByte() else null, + trackerModel = if (__offset_trackerModel != 0) VRCTrackerModel.fromValue(bb.get(tableOffset + __offset_trackerModel).toUByte()) else null, + spineMode = if (__offset_spineMode != 0) VRCSpineMode.fromValue(bb.get(tableOffset + __offset_spineMode).toUByte()) else null, + avatarMeasurementType = if (__offset_avatarMeasurementType != 0) VRCAvatarMeasurementType.fromValue(bb.get(tableOffset + __offset_avatarMeasurementType).toUByte()) else null, + shoulderWidthCompensation = if (__offset_shoulderWidthCompensation != 0) bb.get(tableOffset + __offset_shoulderWidthCompensation) != 0.toByte() else null + ) + } + } +} + +public data class VRCConfigRecommendedValues( + public val legacyMode: Boolean? = null, + public val shoulderTrackingDisabled: Boolean? = null, + public val userHeight: Float? = null, + public val calibrationRange: Float? = null, + public val calibrationVisuals: Boolean? = null, + public val trackerModel: VRCTrackerModel? = null, + public val spineMode: List? = null, + public val avatarMeasurementType: VRCAvatarMeasurementType? = null, + public val shoulderWidthCompensation: Boolean? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_spineMode = spineMode?.let { builder.createByteVector(it.map { e -> e.value.toByte() }.toByteArray()) } + + builder.startTable(9) + if (legacyMode != null) { builder.forceDefaults(true); builder.addBoolean(0, legacyMode, false); builder.forceDefaults(false) } + if (shoulderTrackingDisabled != null) { builder.forceDefaults(true); builder.addBoolean(1, shoulderTrackingDisabled, false); builder.forceDefaults(false) } + if (userHeight != null) { builder.forceDefaults(true); builder.addFloat(2, userHeight, 0.0); builder.forceDefaults(false) } + if (calibrationRange != null) { builder.forceDefaults(true); builder.addFloat(3, calibrationRange, 0.0); builder.forceDefaults(false) } + if (calibrationVisuals != null) { builder.forceDefaults(true); builder.addBoolean(4, calibrationVisuals, false); builder.forceDefaults(false) } + if (trackerModel != null) { builder.forceDefaults(true); builder.addByte(5, trackerModel.value.toByte(), 0); builder.forceDefaults(false) } + __off_spineMode?.let { builder.addOffset(6, it, 0) } + if (avatarMeasurementType != null) { builder.forceDefaults(true); builder.addByte(7, avatarMeasurementType.value.toByte(), 0); builder.forceDefaults(false) } + if (shoulderWidthCompensation != null) { builder.forceDefaults(true); builder.addBoolean(8, shoulderWidthCompensation, false); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigRecommendedValues { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_legacyMode = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_shoulderTrackingDisabled = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_userHeight = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_calibrationRange = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_calibrationVisuals = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_trackerModel = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_spineMode = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_avatarMeasurementType = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_shoulderWidthCompensation = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + + return VRCConfigRecommendedValues( + legacyMode = if (__offset_legacyMode != 0) bb.get(tableOffset + __offset_legacyMode) != 0.toByte() else null, + shoulderTrackingDisabled = if (__offset_shoulderTrackingDisabled != 0) bb.get(tableOffset + __offset_shoulderTrackingDisabled) != 0.toByte() else null, + userHeight = if (__offset_userHeight != 0) bb.getFloat(tableOffset + __offset_userHeight) else null, + calibrationRange = if (__offset_calibrationRange != 0) bb.getFloat(tableOffset + __offset_calibrationRange) else null, + calibrationVisuals = if (__offset_calibrationVisuals != 0) bb.get(tableOffset + __offset_calibrationVisuals) != 0.toByte() else null, + trackerModel = if (__offset_trackerModel != 0) VRCTrackerModel.fromValue(bb.get(tableOffset + __offset_trackerModel).toUByte()) else null, + spineMode = if (__offset_spineMode != 0) { val vecOff = tableOffset + __offset_spineMode + bb.getInt(tableOffset + __offset_spineMode); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> VRCSpineMode.fromValue(bb.get(vecOff + 4 + i * 1).toUByte()) } } else null, + avatarMeasurementType = if (__offset_avatarMeasurementType != 0) VRCAvatarMeasurementType.fromValue(bb.get(tableOffset + __offset_avatarMeasurementType).toUByte()) else null, + shoulderWidthCompensation = if (__offset_shoulderWidthCompensation != 0) bb.get(tableOffset + __offset_shoulderWidthCompensation) != 0.toByte() else null + ) + } + } +} + +public class VRCConfigStateRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigStateRequest = VRCConfigStateRequest() + } +} + +/** + * Sent every time the vrchat config state gets updated + * used to display vrchat missconfig settings to the user + */ +public data class VRCConfigStateChangeResponse( + public val isSupported: Boolean? = null, + public val validity: VRCConfigValidity? = null, + public val state: VRCConfigValues? = null, + public val recommended: VRCConfigRecommendedValues? = null, + public val muted: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_validity = validity?.encode(builder) + val __off_state = state?.encode(builder) + val __off_recommended = recommended?.encode(builder) + val __off_muted = muted?.let { builder.createVectorOfTables(it.map { s -> builder.createString(s) }.toIntArray()) } + + builder.startTable(5) + if (isSupported != null) { builder.forceDefaults(true); builder.addBoolean(0, isSupported, false); builder.forceDefaults(false) } + __off_validity?.let { builder.addOffset(1, it, 0) } + __off_state?.let { builder.addOffset(2, it, 0) } + __off_recommended?.let { builder.addOffset(3, it, 0) } + __off_muted?.let { builder.addOffset(4, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigStateChangeResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_isSupported = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_validity = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_state = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_recommended = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_muted = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + + return VRCConfigStateChangeResponse( + isSupported = if (__offset_isSupported != 0) bb.get(tableOffset + __offset_isSupported) != 0.toByte() else null, + validity = if (__offset_validity != 0) VRCConfigValidity.decode(bb, tableOffset + __offset_validity + bb.getInt(tableOffset + __offset_validity)) else null, + state = if (__offset_state != 0) VRCConfigValues.decode(bb, tableOffset + __offset_state + bb.getInt(tableOffset + __offset_state)) else null, + recommended = if (__offset_recommended != 0) VRCConfigRecommendedValues.decode(bb, tableOffset + __offset_recommended + bb.getInt(tableOffset + __offset_recommended)) else null, + muted = if (__offset_muted != 0) { val vecOff = tableOffset + __offset_muted + bb.getInt(tableOffset + __offset_muted); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> readFlatBufferString(bb, vecOff + 4 + i * 4) } } else null + ) + } + } +} + +public data class VRCConfigSettingToggleMute( + public val key: String? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_key = key?.let { builder.createString(it) } + + builder.startTable(1) + __off_key?.let { builder.addOffset(0, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCConfigSettingToggleMute { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_key = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + + return VRCConfigSettingToggleMute( + key = if (__offset_key != 0) readFlatBufferString(bb, tableOffset + __offset_key) else null + ) + } + } +} diff --git a/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrcosc.kt b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrcosc.kt new file mode 100644 index 000000000..5d5a5cd43 --- /dev/null +++ b/protocol/kotlin/src/generated/kotlin/solarxr_protocol/rpc/Vrcosc.kt @@ -0,0 +1,297 @@ +package solarxr_protocol.rpc + +import dev.slimevr.fbscodegen.runtime.FlatBufferReader +import dev.slimevr.fbscodegen.runtime.FlatBufferWriter +import dev.slimevr.fbscodegen.runtime.readFlatBufferString +import kotlin.Boolean +import kotlin.Int +import kotlin.String +import kotlin.UByte +import kotlin.ULong +import kotlin.UShort +import kotlin.collections.List + +public data class VRCOSCNetworkSettings( + public val portIn: UShort? = null, + public val portOut: UShort? = null, + public val address: String? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_address = address?.let { builder.createString(it) } + + builder.startTable(3) + if (portIn != null) { builder.forceDefaults(true); builder.addShort(0, portIn.toShort(), 0); builder.forceDefaults(false) } + if (portOut != null) { builder.forceDefaults(true); builder.addShort(1, portOut.toShort(), 0); builder.forceDefaults(false) } + __off_address?.let { builder.addOffset(2, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCNetworkSettings { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_portIn = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_portOut = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_address = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return VRCOSCNetworkSettings( + portIn = if (__offset_portIn != 0) bb.getShort(tableOffset + __offset_portIn).toUShort() else null, + portOut = if (__offset_portOut != 0) bb.getShort(tableOffset + __offset_portOut).toUShort() else null, + address = if (__offset_address != 0) readFlatBufferString(bb, tableOffset + __offset_address) else null + ) + } + } +} + +public data class VRCOSCDiscoveredTarget( + public val name: String? = null, + public val address: String? = null, + public val portOut: UShort? = null, +) { + public fun encode(builder: FlatBufferWriter): Int { + val __off_name = name?.let { builder.createString(it) } + val __off_address = address?.let { builder.createString(it) } + + builder.startTable(3) + __off_name?.let { builder.addOffset(0, it, 0) } + __off_address?.let { builder.addOffset(1, it, 0) } + if (portOut != null) { builder.forceDefaults(true); builder.addShort(2, portOut.toShort(), 0); builder.forceDefaults(false) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCDiscoveredTarget { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_name = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_address = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_portOut = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + + return VRCOSCDiscoveredTarget( + name = if (__offset_name != 0) readFlatBufferString(bb, tableOffset + __offset_name) else null, + address = if (__offset_address != 0) readFlatBufferString(bb, tableOffset + __offset_address) else null, + portOut = if (__offset_portOut != 0) bb.getShort(tableOffset + __offset_portOut).toUShort() else null + ) + } + } +} + +public enum class VRCOSCInputState( + public val `value`: UByte, +) { + IDLE(0.toUByte()), + LISTENING(1.toUByte()), + ERROR(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCOSCInputState? = entries.firstOrNull { it.value == value } + } +} + +public enum class VRCOSCOutputState( + public val `value`: UByte, +) { + IDLE(0.toUByte()), + READY(1.toUByte()), + ERROR(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCOSCOutputState? = entries.firstOrNull { it.value == value } + } +} + +public enum class VRCOSCTargetSource( + public val `value`: UByte, +) { + NONE(0.toUByte()), + MANUAL(1.toUByte()), + DISCOVERED(2.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCOSCTargetSource? = entries.firstOrNull { it.value == value } + } +} + +public enum class VRCOSCOscQueryState( + public val `value`: UByte, +) { + DISABLED(0.toUByte()), + SEARCHING(1.toUByte()), + FOUND(2.toUByte()), + ERROR(3.toUByte()), + ; + + public companion object { + public fun fromValue(`value`: UByte): VRCOSCOscQueryState? = entries.firstOrNull { it.value == value } + } +} + +public class VRCOSCStatusRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCStatusRequest = VRCOSCStatusRequest() + } +} + +public data class VRCOSCStatusChangeResponse( + public val enabled: Boolean? = null, + public val inputState: VRCOSCInputState? = null, + public val inputPort: UShort? = null, + public val inputError: String? = null, + public val lastReceivedInputMillis: ULong? = null, + public val outputState: VRCOSCOutputState? = null, + public val outputError: String? = null, + public val targetAddress: String? = null, + public val targetPort: UShort? = null, + public val targetSource: VRCOSCTargetSource? = null, + public val lastFrameSentMillis: ULong? = null, + public val oscqueryState: VRCOSCOscQueryState? = null, + public val oscqueryAdvertisedPort: UShort? = null, + public val oscqueryError: String? = null, + public val discoveredTargets: List? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_inputError = inputError?.let { builder.createString(it) } + val __off_outputError = outputError?.let { builder.createString(it) } + val __off_targetAddress = targetAddress?.let { builder.createString(it) } + val __off_oscqueryError = oscqueryError?.let { builder.createString(it) } + val __off_discoveredTargets = discoveredTargets?.let { builder.createVectorOfTables(it.map { e -> e.encode(builder) }.toIntArray()) } + + builder.startTable(15) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + if (inputState != null) { builder.forceDefaults(true); builder.addByte(1, inputState.value.toByte(), 0); builder.forceDefaults(false) } + if (inputPort != null) { builder.forceDefaults(true); builder.addShort(2, inputPort.toShort(), 0); builder.forceDefaults(false) } + __off_inputError?.let { builder.addOffset(3, it, 0) } + if (lastReceivedInputMillis != null) { builder.forceDefaults(true); builder.addLong(4, lastReceivedInputMillis.toLong(), 0L); builder.forceDefaults(false) } + if (outputState != null) { builder.forceDefaults(true); builder.addByte(5, outputState.value.toByte(), 0); builder.forceDefaults(false) } + __off_outputError?.let { builder.addOffset(6, it, 0) } + __off_targetAddress?.let { builder.addOffset(7, it, 0) } + if (targetPort != null) { builder.forceDefaults(true); builder.addShort(8, targetPort.toShort(), 0); builder.forceDefaults(false) } + if (targetSource != null) { builder.forceDefaults(true); builder.addByte(9, targetSource.value.toByte(), 0); builder.forceDefaults(false) } + if (lastFrameSentMillis != null) { builder.forceDefaults(true); builder.addLong(10, lastFrameSentMillis.toLong(), 0L); builder.forceDefaults(false) } + if (oscqueryState != null) { builder.forceDefaults(true); builder.addByte(11, oscqueryState.value.toByte(), 0); builder.forceDefaults(false) } + if (oscqueryAdvertisedPort != null) { builder.forceDefaults(true); builder.addShort(12, oscqueryAdvertisedPort.toShort(), 0); builder.forceDefaults(false) } + __off_oscqueryError?.let { builder.addOffset(13, it, 0) } + __off_discoveredTargets?.let { builder.addOffset(14, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCStatusChangeResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_inputState = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + val __offset_inputPort = if (vtableSize > 8) bb.getShort(vtableOffset + 8).toInt() else 0 + val __offset_inputError = if (vtableSize > 10) bb.getShort(vtableOffset + 10).toInt() else 0 + val __offset_lastReceivedInputMillis = if (vtableSize > 12) bb.getShort(vtableOffset + 12).toInt() else 0 + val __offset_outputState = if (vtableSize > 14) bb.getShort(vtableOffset + 14).toInt() else 0 + val __offset_outputError = if (vtableSize > 16) bb.getShort(vtableOffset + 16).toInt() else 0 + val __offset_targetAddress = if (vtableSize > 18) bb.getShort(vtableOffset + 18).toInt() else 0 + val __offset_targetPort = if (vtableSize > 20) bb.getShort(vtableOffset + 20).toInt() else 0 + val __offset_targetSource = if (vtableSize > 22) bb.getShort(vtableOffset + 22).toInt() else 0 + val __offset_lastFrameSentMillis = if (vtableSize > 24) bb.getShort(vtableOffset + 24).toInt() else 0 + val __offset_oscqueryState = if (vtableSize > 26) bb.getShort(vtableOffset + 26).toInt() else 0 + val __offset_oscqueryAdvertisedPort = if (vtableSize > 28) bb.getShort(vtableOffset + 28).toInt() else 0 + val __offset_oscqueryError = if (vtableSize > 30) bb.getShort(vtableOffset + 30).toInt() else 0 + val __offset_discoveredTargets = if (vtableSize > 32) bb.getShort(vtableOffset + 32).toInt() else 0 + + return VRCOSCStatusChangeResponse( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + inputState = if (__offset_inputState != 0) VRCOSCInputState.fromValue(bb.get(tableOffset + __offset_inputState).toUByte()) else null, + inputPort = if (__offset_inputPort != 0) bb.getShort(tableOffset + __offset_inputPort).toUShort() else null, + inputError = if (__offset_inputError != 0) readFlatBufferString(bb, tableOffset + __offset_inputError) else null, + lastReceivedInputMillis = if (__offset_lastReceivedInputMillis != 0) bb.getLong(tableOffset + __offset_lastReceivedInputMillis).toULong() else null, + outputState = if (__offset_outputState != 0) VRCOSCOutputState.fromValue(bb.get(tableOffset + __offset_outputState).toUByte()) else null, + outputError = if (__offset_outputError != 0) readFlatBufferString(bb, tableOffset + __offset_outputError) else null, + targetAddress = if (__offset_targetAddress != 0) readFlatBufferString(bb, tableOffset + __offset_targetAddress) else null, + targetPort = if (__offset_targetPort != 0) bb.getShort(tableOffset + __offset_targetPort).toUShort() else null, + targetSource = if (__offset_targetSource != 0) VRCOSCTargetSource.fromValue(bb.get(tableOffset + __offset_targetSource).toUByte()) else null, + lastFrameSentMillis = if (__offset_lastFrameSentMillis != 0) bb.getLong(tableOffset + __offset_lastFrameSentMillis).toULong() else null, + oscqueryState = if (__offset_oscqueryState != 0) VRCOSCOscQueryState.fromValue(bb.get(tableOffset + __offset_oscqueryState).toUByte()) else null, + oscqueryAdvertisedPort = if (__offset_oscqueryAdvertisedPort != 0) bb.getShort(tableOffset + __offset_oscqueryAdvertisedPort).toUShort() else null, + oscqueryError = if (__offset_oscqueryError != 0) readFlatBufferString(bb, tableOffset + __offset_oscqueryError) else null, + discoveredTargets = if (__offset_discoveredTargets != 0) { val vecOff = tableOffset + __offset_discoveredTargets + bb.getInt(tableOffset + __offset_discoveredTargets); val len = bb.getInt(vecOff); (0 until len).mapNotNull { i -> if (bb.getInt(vecOff + 4 + i * 4) != 0) VRCOSCDiscoveredTarget.decode(bb, vecOff + 4 + i * 4 + bb.getInt(vecOff + 4 + i * 4)) else null } } else null + ) + } + } +} + +public class VRCOSCSettingsRequest : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + builder.startTable(0) + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCSettingsRequest = VRCOSCSettingsRequest() + } +} + +public data class VRCOSCSettingsResponse( + public val enabled: Boolean? = null, + public val manualNetwork: VRCOSCNetworkSettings? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_manualNetwork = manualNetwork?.encode(builder) + + builder.startTable(2) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + __off_manualNetwork?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): VRCOSCSettingsResponse { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_manualNetwork = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return VRCOSCSettingsResponse( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + manualNetwork = if (__offset_manualNetwork != 0) VRCOSCNetworkSettings.decode(bb, tableOffset + __offset_manualNetwork + bb.getInt(tableOffset + __offset_manualNetwork)) else null + ) + } + } +} + +public data class ChangeVRCOSCSettingsRequest( + public val enabled: Boolean? = null, + public val manualNetwork: VRCOSCNetworkSettings? = null, +) : RpcMessage { + public fun encode(builder: FlatBufferWriter): Int { + val __off_manualNetwork = manualNetwork?.encode(builder) + + builder.startTable(2) + if (enabled != null) { builder.forceDefaults(true); builder.addBoolean(0, enabled, false); builder.forceDefaults(false) } + __off_manualNetwork?.let { builder.addOffset(1, it, 0) } + return builder.endTable() + } + + public companion object { + public fun decode(bb: FlatBufferReader, tableOffset: Int): ChangeVRCOSCSettingsRequest { + val vtableOffset = tableOffset - bb.getInt(tableOffset) + val vtableSize = bb.getShort(vtableOffset).toInt() + + val __offset_enabled = if (vtableSize > 4) bb.getShort(vtableOffset + 4).toInt() else 0 + val __offset_manualNetwork = if (vtableSize > 6) bb.getShort(vtableOffset + 6).toInt() else 0 + + return ChangeVRCOSCSettingsRequest( + enabled = if (__offset_enabled != 0) bb.get(tableOffset + __offset_enabled) != 0.toByte() else null, + manualNetwork = if (__offset_manualNetwork != 0) VRCOSCNetworkSettings.decode(bb, tableOffset + __offset_manualNetwork + bb.getInt(tableOffset + __offset_manualNetwork)) else null + ) + } + } +} diff --git a/protocol/kotlin/src/jvmMain/kotlin/dev/slimevr/fbscodegen/runtime/Runtime.kt b/protocol/kotlin/src/jvmMain/kotlin/dev/slimevr/fbscodegen/runtime/Runtime.kt new file mode 100644 index 000000000..45746c0b0 --- /dev/null +++ b/protocol/kotlin/src/jvmMain/kotlin/dev/slimevr/fbscodegen/runtime/Runtime.kt @@ -0,0 +1,57 @@ +package dev.slimevr.fbscodegen.runtime + +import java.nio.ByteBuffer +import java.nio.ByteOrder + +/** + * JVM implementation of FlatBufferReader wrapping a ByteBuffer. + * It ensures the buffer is in LITTLE_ENDIAN order. + */ +class JvmFlatBufferReader(private val bb: ByteBuffer) : FlatBufferReader { + init { + bb.order(ByteOrder.LITTLE_ENDIAN) + } + + override fun get(offset: Int): Byte = bb.get(bb.position() + offset) + override fun getShort(offset: Int): Short = bb.getShort(bb.position() + offset) + override fun getInt(offset: Int): Int = bb.getInt(bb.position() + offset) + override fun getLong(offset: Int): Long = bb.getLong(bb.position() + offset) + override fun getFloat(offset: Int): Float = bb.getFloat(bb.position() + offset) + override fun getDouble(offset: Int): Double = bb.getDouble(bb.position() + offset) +} + +/** + * JVM implementation of FlatBufferWriter wrapping a FlatBufferBuilder. + */ +class JvmFlatBufferWriter(private val builder: com.google.flatbuffers.FlatBufferBuilder) : FlatBufferWriter { + override fun startTable(numFields: Int) = builder.startTable(numFields) + override fun endTable(): Int = builder.endTable() + override fun finish(rootOffset: Int) = builder.finish(rootOffset) + override fun createString(s: String): Int = builder.createString(s) + override fun addOffset(slot: Int, offset: Int, default: Int) = builder.addOffset(slot, offset, default) + override fun addByte(slot: Int, value: Byte, default: Int) = builder.addByte(slot, value, default) + override fun addShort(slot: Int, value: Short, default: Int) = builder.addShort(slot, value, default) + override fun addInt(slot: Int, value: Int, default: Int) = builder.addInt(slot, value, default) + override fun addLong(slot: Int, value: Long, default: Long) = builder.addLong(slot, value, default) + override fun addFloat(slot: Int, value: Float, default: Double) = builder.addFloat(slot, value, default) + override fun addDouble(slot: Int, value: Double, default: Double) = builder.addDouble(slot, value, default) + override fun addBoolean(slot: Int, value: Boolean, default: Boolean) = builder.addBoolean(slot, value, default) + override fun addStruct(slot: Int, offset: Int, default: Int) = builder.addStruct(slot, offset, default) + + override fun prep(size: Int, additionalBytes: Int) = builder.prep(size, additionalBytes) + override fun pad(count: Int) = builder.pad(count) + override fun putByte(value: Byte) = builder.putByte(value) + override fun putShort(value: Short) = builder.putShort(value) + override fun putInt(value: Int) = builder.putInt(value) + override fun putLong(value: Long) = builder.putLong(value) + override fun putFloat(value: Float) = builder.putFloat(value) + override fun putDouble(value: Double) = builder.putDouble(value) + override fun offset(): Int = builder.offset() + + override fun startVector(elemSize: Int, numElems: Int, alignment: Int) = builder.startVector(elemSize, numElems, alignment) + override fun endVector(): Int = builder.endVector() + override fun createByteVector(bytes: ByteArray): Int = builder.createByteVector(bytes) + override fun createVectorOfTables(offsets: IntArray): Int = builder.createVectorOfTables(offsets) + + override fun forceDefaults(force: Boolean) { builder.forceDefaults(force) } +} diff --git a/protocol/kotlin/src/solarxr_protocol/MessageBundle.kt b/protocol/kotlin/src/solarxr_protocol/MessageBundle.kt deleted file mode 100644 index be2e44a35..000000000 --- a/protocol/kotlin/src/solarxr_protocol/MessageBundle.kt +++ /dev/null @@ -1,124 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * MessageBundle contains all of the messages for the data feed system and the - * rpc system that will be sent in one buffer. - */ -@Suppress("unused") -class MessageBundle : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : MessageBundle { - __init(_i, _bb) - return this - } - fun dataFeedMsgs(j: Int) : solarxr_protocol.data_feed.DataFeedMessageHeader? = dataFeedMsgs(solarxr_protocol.data_feed.DataFeedMessageHeader(), j) - fun dataFeedMsgs(obj: solarxr_protocol.data_feed.DataFeedMessageHeader, j: Int) : solarxr_protocol.data_feed.DataFeedMessageHeader? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val dataFeedMsgsLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - fun rpcMsgs(j: Int) : solarxr_protocol.rpc.RpcMessageHeader? = rpcMsgs(solarxr_protocol.rpc.RpcMessageHeader(), j) - fun rpcMsgs(obj: solarxr_protocol.rpc.RpcMessageHeader, j: Int) : solarxr_protocol.rpc.RpcMessageHeader? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val rpcMsgsLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - fun pubSubMsgs(j: Int) : solarxr_protocol.pub_sub.PubSubHeader? = pubSubMsgs(solarxr_protocol.pub_sub.PubSubHeader(), j) - fun pubSubMsgs(obj: solarxr_protocol.pub_sub.PubSubHeader, j: Int) : solarxr_protocol.pub_sub.PubSubHeader? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val pubSubMsgsLength : Int - get() { - val o = __offset(8); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsMessageBundle(_bb: ByteBuffer): MessageBundle = getRootAsMessageBundle(_bb, MessageBundle()) - @JvmStatic - fun getRootAsMessageBundle(_bb: ByteBuffer, obj: MessageBundle): MessageBundle { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createMessageBundle(builder: FlatBufferBuilder, dataFeedMsgsOffset: Int, rpcMsgsOffset: Int, pubSubMsgsOffset: Int) : Int { - builder.startTable(3) - addPubSubMsgs(builder, pubSubMsgsOffset) - addRpcMsgs(builder, rpcMsgsOffset) - addDataFeedMsgs(builder, dataFeedMsgsOffset) - return endMessageBundle(builder) - } - @JvmStatic - fun startMessageBundle(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addDataFeedMsgs(builder: FlatBufferBuilder, dataFeedMsgs: Int) = builder.addOffset(0, dataFeedMsgs, 0) - @JvmStatic - fun createDataFeedMsgsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startDataFeedMsgsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addRpcMsgs(builder: FlatBufferBuilder, rpcMsgs: Int) = builder.addOffset(1, rpcMsgs, 0) - @JvmStatic - fun createRpcMsgsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startRpcMsgsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addPubSubMsgs(builder: FlatBufferBuilder, pubSubMsgs: Int) = builder.addOffset(2, pubSubMsgs, 0) - @JvmStatic - fun createPubSubMsgsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startPubSubMsgsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endMessageBundle(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/Bone.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/Bone.kt deleted file mode 100644 index 30a30746d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/Bone.kt +++ /dev/null @@ -1,85 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class Bone : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Bone { - __init(_i, _bb) - return this - } - val bodyPart : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * The global rotation of the bone. - * - * Note that the identity rotation is where a bone's tail is towards -y (assuming - * the head of the bone is the origin) - */ - val rotationG : solarxr_protocol.datatypes.math.Quat? get() = rotationG(solarxr_protocol.datatypes.math.Quat()) - fun rotationG(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - val boneLength : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - /** - * The global position of the head of this bone. - * - * The head of a bone is joint/node of the bone touching the parent bone. The - * parent is defined as the bone closer to the HMD. - */ - val headPositionG : solarxr_protocol.datatypes.math.Vec3f? get() = headPositionG(solarxr_protocol.datatypes.math.Vec3f()) - fun headPositionG(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsBone(_bb: ByteBuffer): Bone = getRootAsBone(_bb, Bone()) - @JvmStatic - fun getRootAsBone(_bb: ByteBuffer, obj: Bone): Bone { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startBone(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addBodyPart(builder: FlatBufferBuilder, bodyPart: UByte) = builder.addByte(0, bodyPart.toByte(), 0) - @JvmStatic - fun addRotationG(builder: FlatBufferBuilder, rotationG: Int) = builder.addStruct(1, rotationG, 0) - @JvmStatic - fun addBoneLength(builder: FlatBufferBuilder, boneLength: Float) = builder.addFloat(2, boneLength, 0.0) - @JvmStatic - fun addHeadPositionG(builder: FlatBufferBuilder, headPositionG: Int) = builder.addStruct(3, headPositionG, 0) - @JvmStatic - fun endBone(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt deleted file mode 100644 index 09e0a0269..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt +++ /dev/null @@ -1,106 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * All information related to the configuration of a data feed. This may be sent - * as part of a `StartFeed`. - */ -@Suppress("unused") -class DataFeedConfig : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DataFeedConfig { - __init(_i, _bb) - return this - } - /** - * Minimum delay in milliseconds between new data updates. This value will be - * ignored when used for a `PollDataFeed`. - */ - val minimumTimeSinceLast : UShort - get() { - val o = __offset(4) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - val dataMask : solarxr_protocol.data_feed.device_data.DeviceDataMask? get() = dataMask(solarxr_protocol.data_feed.device_data.DeviceDataMask()) - fun dataMask(obj: solarxr_protocol.data_feed.device_data.DeviceDataMask) : solarxr_protocol.data_feed.device_data.DeviceDataMask? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val syntheticTrackersMask : solarxr_protocol.data_feed.tracker.TrackerDataMask? get() = syntheticTrackersMask(solarxr_protocol.data_feed.tracker.TrackerDataMask()) - fun syntheticTrackersMask(obj: solarxr_protocol.data_feed.tracker.TrackerDataMask) : solarxr_protocol.data_feed.tracker.TrackerDataMask? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val boneMask : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val stayAlignedPoseMask : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val serverGuardsMask : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDataFeedConfig(_bb: ByteBuffer): DataFeedConfig = getRootAsDataFeedConfig(_bb, DataFeedConfig()) - @JvmStatic - fun getRootAsDataFeedConfig(_bb: ByteBuffer, obj: DataFeedConfig): DataFeedConfig { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDataFeedConfig(builder: FlatBufferBuilder, minimumTimeSinceLast: UShort, dataMaskOffset: Int, syntheticTrackersMaskOffset: Int, boneMask: Boolean, stayAlignedPoseMask: Boolean, serverGuardsMask: Boolean) : Int { - builder.startTable(6) - addSyntheticTrackersMask(builder, syntheticTrackersMaskOffset) - addDataMask(builder, dataMaskOffset) - addMinimumTimeSinceLast(builder, minimumTimeSinceLast) - addServerGuardsMask(builder, serverGuardsMask) - addStayAlignedPoseMask(builder, stayAlignedPoseMask) - addBoneMask(builder, boneMask) - return endDataFeedConfig(builder) - } - @JvmStatic - fun startDataFeedConfig(builder: FlatBufferBuilder) = builder.startTable(6) - @JvmStatic - fun addMinimumTimeSinceLast(builder: FlatBufferBuilder, minimumTimeSinceLast: UShort) = builder.addShort(0, minimumTimeSinceLast.toShort(), 0) - @JvmStatic - fun addDataMask(builder: FlatBufferBuilder, dataMask: Int) = builder.addOffset(1, dataMask, 0) - @JvmStatic - fun addSyntheticTrackersMask(builder: FlatBufferBuilder, syntheticTrackersMask: Int) = builder.addOffset(2, syntheticTrackersMask, 0) - @JvmStatic - fun addBoneMask(builder: FlatBufferBuilder, boneMask: Boolean) = builder.addBoolean(3, boneMask, false) - @JvmStatic - fun addStayAlignedPoseMask(builder: FlatBufferBuilder, stayAlignedPoseMask: Boolean) = builder.addBoolean(4, stayAlignedPoseMask, false) - @JvmStatic - fun addServerGuardsMask(builder: FlatBufferBuilder, serverGuardsMask: Boolean) = builder.addBoolean(5, serverGuardsMask, false) - @JvmStatic - fun endDataFeedConfig(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessage.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessage.kt deleted file mode 100644 index ca5376073..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessage.kt +++ /dev/null @@ -1,17 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -@Suppress("unused") -class DataFeedMessage private constructor() { - companion object { - const val NONE: UByte = 0u - const val PollDataFeed: UByte = 1u - const val StartDataFeed: UByte = 2u - const val DataFeedUpdate: UByte = 3u - const val DataFeedConfig: UByte = 4u - val names : Array = arrayOf("NONE", "PollDataFeed", "StartDataFeed", "DataFeedUpdate", "DataFeedConfig") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessageHeader.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessageHeader.kt deleted file mode 100644 index 18b243e9a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedMessageHeader.kt +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class DataFeedMessageHeader : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DataFeedMessageHeader { - __init(_i, _bb) - return this - } - val messageType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun message(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDataFeedMessageHeader(_bb: ByteBuffer): DataFeedMessageHeader = getRootAsDataFeedMessageHeader(_bb, DataFeedMessageHeader()) - @JvmStatic - fun getRootAsDataFeedMessageHeader(_bb: ByteBuffer, obj: DataFeedMessageHeader): DataFeedMessageHeader { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDataFeedMessageHeader(builder: FlatBufferBuilder, messageType: UByte, messageOffset: Int) : Int { - builder.startTable(2) - addMessage(builder, messageOffset) - addMessageType(builder, messageType) - return endDataFeedMessageHeader(builder) - } - @JvmStatic - fun startDataFeedMessageHeader(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addMessageType(builder: FlatBufferBuilder, messageType: UByte) = builder.addByte(0, messageType.toByte(), 0) - @JvmStatic - fun addMessage(builder: FlatBufferBuilder, message: Int) = builder.addOffset(1, message, 0) - @JvmStatic - fun endDataFeedMessageHeader(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt deleted file mode 100644 index 57d5b4e8b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt +++ /dev/null @@ -1,164 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * All of the data components related to a single data feed. A data feed is comprised - * of device data, and tracker data. - * - * A data feed might send data only when it changes/updates, and we should make no - * assumptions that the data is actually delivered. If you want to guarantee - * delivery and avoid dropped observations of data (such as a user-initiated - * button press), it is better to use the RPC system. - */ -@Suppress("unused") -class DataFeedUpdate : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DataFeedUpdate { - __init(_i, _bb) - return this - } - fun devices(j: Int) : solarxr_protocol.data_feed.device_data.DeviceData? = devices(solarxr_protocol.data_feed.device_data.DeviceData(), j) - fun devices(obj: solarxr_protocol.data_feed.device_data.DeviceData, j: Int) : solarxr_protocol.data_feed.device_data.DeviceData? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val devicesLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - fun syntheticTrackers(j: Int) : solarxr_protocol.data_feed.tracker.TrackerData? = syntheticTrackers(solarxr_protocol.data_feed.tracker.TrackerData(), j) - fun syntheticTrackers(obj: solarxr_protocol.data_feed.tracker.TrackerData, j: Int) : solarxr_protocol.data_feed.tracker.TrackerData? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val syntheticTrackersLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - /** - * This must represent a set, where there is no more than one bone for a `BodyPart`. - */ - fun bones(j: Int) : solarxr_protocol.data_feed.Bone? = bones(solarxr_protocol.data_feed.Bone(), j) - fun bones(obj: solarxr_protocol.data_feed.Bone, j: Int) : solarxr_protocol.data_feed.Bone? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val bonesLength : Int - get() { - val o = __offset(8); return if (o != 0) __vector_len(o) else 0 - } - val stayAlignedPose : solarxr_protocol.data_feed.stay_aligned.StayAlignedPose? get() = stayAlignedPose(solarxr_protocol.data_feed.stay_aligned.StayAlignedPose()) - fun stayAlignedPose(obj: solarxr_protocol.data_feed.stay_aligned.StayAlignedPose) : solarxr_protocol.data_feed.stay_aligned.StayAlignedPose? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val index : UByte - get() { - val o = __offset(12) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val serverGuards : solarxr_protocol.data_feed.server.ServerGuards? get() = serverGuards(solarxr_protocol.data_feed.server.ServerGuards()) - fun serverGuards(obj: solarxr_protocol.data_feed.server.ServerGuards) : solarxr_protocol.data_feed.server.ServerGuards? { - val o = __offset(14) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDataFeedUpdate(_bb: ByteBuffer): DataFeedUpdate = getRootAsDataFeedUpdate(_bb, DataFeedUpdate()) - @JvmStatic - fun getRootAsDataFeedUpdate(_bb: ByteBuffer, obj: DataFeedUpdate): DataFeedUpdate { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDataFeedUpdate(builder: FlatBufferBuilder, devicesOffset: Int, syntheticTrackersOffset: Int, bonesOffset: Int, stayAlignedPoseOffset: Int, index: UByte, serverGuardsOffset: Int) : Int { - builder.startTable(6) - addServerGuards(builder, serverGuardsOffset) - addStayAlignedPose(builder, stayAlignedPoseOffset) - addBones(builder, bonesOffset) - addSyntheticTrackers(builder, syntheticTrackersOffset) - addDevices(builder, devicesOffset) - addIndex(builder, index) - return endDataFeedUpdate(builder) - } - @JvmStatic - fun startDataFeedUpdate(builder: FlatBufferBuilder) = builder.startTable(6) - @JvmStatic - fun addDevices(builder: FlatBufferBuilder, devices: Int) = builder.addOffset(0, devices, 0) - @JvmStatic - fun createDevicesVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startDevicesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addSyntheticTrackers(builder: FlatBufferBuilder, syntheticTrackers: Int) = builder.addOffset(1, syntheticTrackers, 0) - @JvmStatic - fun createSyntheticTrackersVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startSyntheticTrackersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addBones(builder: FlatBufferBuilder, bones: Int) = builder.addOffset(2, bones, 0) - @JvmStatic - fun createBonesVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startBonesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addStayAlignedPose(builder: FlatBufferBuilder, stayAlignedPose: Int) = builder.addOffset(3, stayAlignedPose, 0) - @JvmStatic - fun addIndex(builder: FlatBufferBuilder, index: UByte) = builder.addByte(4, index.toByte(), 0) - @JvmStatic - fun addServerGuards(builder: FlatBufferBuilder, serverGuards: Int) = builder.addOffset(5, serverGuards, 0) - @JvmStatic - fun endDataFeedUpdate(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/PollDataFeed.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/PollDataFeed.kt deleted file mode 100644 index 7f6086b76..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/PollDataFeed.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Requests for a single `Update` to be sent. This is helpful when getting - * initial info about the device. - */ -@Suppress("unused") -class PollDataFeed : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : PollDataFeed { - __init(_i, _bb) - return this - } - val config : solarxr_protocol.data_feed.DataFeedConfig? get() = config(solarxr_protocol.data_feed.DataFeedConfig()) - fun config(obj: solarxr_protocol.data_feed.DataFeedConfig) : solarxr_protocol.data_feed.DataFeedConfig? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsPollDataFeed(_bb: ByteBuffer): PollDataFeed = getRootAsPollDataFeed(_bb, PollDataFeed()) - @JvmStatic - fun getRootAsPollDataFeed(_bb: ByteBuffer, obj: PollDataFeed): PollDataFeed { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createPollDataFeed(builder: FlatBufferBuilder, configOffset: Int) : Int { - builder.startTable(1) - addConfig(builder, configOffset) - return endPollDataFeed(builder) - } - @JvmStatic - fun startPollDataFeed(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addConfig(builder: FlatBufferBuilder, config: Int) = builder.addOffset(0, config, 0) - @JvmStatic - fun endPollDataFeed(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/StartDataFeed.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/StartDataFeed.kt deleted file mode 100644 index eec7f5b64..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/StartDataFeed.kt +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Requests for the other party to send `data_feeds`. - * For example, GUI requests for position data to be sent from server. - * - * When sending a new `StartFeed`, the old data feeds should stop being sent. - * We still support multiple data feeds at the same time, because `data_feeds` - * is a list. - * - * Multiple data feeds are useful to get data at different frequencies. - */ -@Suppress("unused") -class StartDataFeed : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StartDataFeed { - __init(_i, _bb) - return this - } - fun dataFeeds(j: Int) : solarxr_protocol.data_feed.DataFeedConfig? = dataFeeds(solarxr_protocol.data_feed.DataFeedConfig(), j) - fun dataFeeds(obj: solarxr_protocol.data_feed.DataFeedConfig, j: Int) : solarxr_protocol.data_feed.DataFeedConfig? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val dataFeedsLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStartDataFeed(_bb: ByteBuffer): StartDataFeed = getRootAsStartDataFeed(_bb, StartDataFeed()) - @JvmStatic - fun getRootAsStartDataFeed(_bb: ByteBuffer, obj: StartDataFeed): StartDataFeed { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStartDataFeed(builder: FlatBufferBuilder, dataFeedsOffset: Int) : Int { - builder.startTable(1) - addDataFeeds(builder, dataFeedsOffset) - return endStartDataFeed(builder) - } - @JvmStatic - fun startStartDataFeed(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addDataFeeds(builder: FlatBufferBuilder, dataFeeds: Int) = builder.addOffset(0, dataFeeds, 0) - @JvmStatic - fun createDataFeedsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startDataFeedsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endStartDataFeed(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceData.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceData.kt deleted file mode 100644 index 7ea843d8c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceData.kt +++ /dev/null @@ -1,122 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.device_data - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Describes all possible information about a hardware device. For example, a - * vive tracker is a single hardware device, and a slime tracker with two - * extensions is a single hardware device but two trackers. - */ -@Suppress("unused") -class DeviceData : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DeviceData { - __init(_i, _bb) - return this - } - val id : solarxr_protocol.datatypes.DeviceId? get() = id(solarxr_protocol.datatypes.DeviceId()) - fun id(obj: solarxr_protocol.datatypes.DeviceId) : solarxr_protocol.datatypes.DeviceId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * The dynamically changeable name of the device. This might be set by the - * user to help them remember which tracker is which. - */ - val customName : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val customNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun customNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - /** - * Mostly-static info about the device hardware - */ - val hardwareInfo : solarxr_protocol.datatypes.hardware_info.HardwareInfo? get() = hardwareInfo(solarxr_protocol.datatypes.hardware_info.HardwareInfo()) - fun hardwareInfo(obj: solarxr_protocol.datatypes.hardware_info.HardwareInfo) : solarxr_protocol.datatypes.hardware_info.HardwareInfo? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - /** - * General info about the status of the device - */ - val hardwareStatus : solarxr_protocol.datatypes.hardware_info.HardwareStatus? get() = hardwareStatus(solarxr_protocol.datatypes.hardware_info.HardwareStatus()) - fun hardwareStatus(obj: solarxr_protocol.datatypes.hardware_info.HardwareStatus) : solarxr_protocol.datatypes.hardware_info.HardwareStatus? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - /** - * Info about all trackers attached to this device - */ - fun trackers(j: Int) : solarxr_protocol.data_feed.tracker.TrackerData? = trackers(solarxr_protocol.data_feed.tracker.TrackerData(), j) - fun trackers(obj: solarxr_protocol.data_feed.tracker.TrackerData, j: Int) : solarxr_protocol.data_feed.tracker.TrackerData? { - val o = __offset(12) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackersLength : Int - get() { - val o = __offset(12); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDeviceData(_bb: ByteBuffer): DeviceData = getRootAsDeviceData(_bb, DeviceData()) - @JvmStatic - fun getRootAsDeviceData(_bb: ByteBuffer, obj: DeviceData): DeviceData { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startDeviceData(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: Int) = builder.addStruct(0, id, 0) - @JvmStatic - fun addCustomName(builder: FlatBufferBuilder, customName: Int) = builder.addOffset(1, customName, 0) - @JvmStatic - fun addHardwareInfo(builder: FlatBufferBuilder, hardwareInfo: Int) = builder.addOffset(2, hardwareInfo, 0) - @JvmStatic - fun addHardwareStatus(builder: FlatBufferBuilder, hardwareStatus: Int) = builder.addOffset(3, hardwareStatus, 0) - @JvmStatic - fun addTrackers(builder: FlatBufferBuilder, trackers: Int) = builder.addOffset(4, trackers, 0) - @JvmStatic - fun createTrackersVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endDeviceData(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.kt deleted file mode 100644 index 392aa8279..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/device_data/DeviceDataMask.kt +++ /dev/null @@ -1,76 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.device_data - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A mask of values to be reported in subsequent DeviceStatus. Values set to `false` - * or `null` will not reported. By default, all fields are false/null. - * - * If you set a value to `true`, it is not guaranteed that the sender actually has - * such a value to send. In this case, they will probably send `null`, and the receiver - * has the choice to disconnect due to missing data. - */ -@Suppress("unused") -class DeviceDataMask : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DeviceDataMask { - __init(_i, _bb) - return this - } - /** - * Which tracker data should be sent in this data feed - */ - val trackerData : solarxr_protocol.data_feed.tracker.TrackerDataMask? get() = trackerData(solarxr_protocol.data_feed.tracker.TrackerDataMask()) - fun trackerData(obj: solarxr_protocol.data_feed.tracker.TrackerDataMask) : solarxr_protocol.data_feed.tracker.TrackerDataMask? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - /** - * true if device data should be sent in this data feed - */ - val deviceData : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDeviceDataMask(_bb: ByteBuffer): DeviceDataMask = getRootAsDeviceDataMask(_bb, DeviceDataMask()) - @JvmStatic - fun getRootAsDeviceDataMask(_bb: ByteBuffer, obj: DeviceDataMask): DeviceDataMask { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDeviceDataMask(builder: FlatBufferBuilder, trackerDataOffset: Int, deviceData: Boolean) : Int { - builder.startTable(2) - addTrackerData(builder, trackerDataOffset) - addDeviceData(builder, deviceData) - return endDeviceDataMask(builder) - } - @JvmStatic - fun startDeviceDataMask(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addTrackerData(builder: FlatBufferBuilder, trackerData: Int) = builder.addOffset(0, trackerData, 0) - @JvmStatic - fun addDeviceData(builder: FlatBufferBuilder, deviceData: Boolean) = builder.addBoolean(1, deviceData, false) - @JvmStatic - fun endDeviceDataMask(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt deleted file mode 100644 index 46817fca9..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt +++ /dev/null @@ -1,66 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.server - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ServerGuards : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ServerGuards { - __init(_i, _bb) - return this - } - val canDoMounting : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val canDoYawReset : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val canDoUserHeightCalibration : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsServerGuards(_bb: ByteBuffer): ServerGuards = getRootAsServerGuards(_bb, ServerGuards()) - @JvmStatic - fun getRootAsServerGuards(_bb: ByteBuffer, obj: ServerGuards): ServerGuards { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createServerGuards(builder: FlatBufferBuilder, canDoMounting: Boolean, canDoYawReset: Boolean, canDoUserHeightCalibration: Boolean) : Int { - builder.startTable(3) - addCanDoUserHeightCalibration(builder, canDoUserHeightCalibration) - addCanDoYawReset(builder, canDoYawReset) - addCanDoMounting(builder, canDoMounting) - return endServerGuards(builder) - } - @JvmStatic - fun startServerGuards(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addCanDoMounting(builder: FlatBufferBuilder, canDoMounting: Boolean) = builder.addBoolean(0, canDoMounting, false) - @JvmStatic - fun addCanDoYawReset(builder: FlatBufferBuilder, canDoYawReset: Boolean) = builder.addBoolean(1, canDoYawReset, false) - @JvmStatic - fun addCanDoUserHeightCalibration(builder: FlatBufferBuilder, canDoUserHeightCalibration: Boolean) = builder.addBoolean(2, canDoUserHeightCalibration, false) - @JvmStatic - fun endServerGuards(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedPose.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedPose.kt deleted file mode 100644 index a872b30c9..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedPose.kt +++ /dev/null @@ -1,66 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.stay_aligned - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StayAlignedPose : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StayAlignedPose { - __init(_i, _bb) - return this - } - val upperLegAngleInDeg : Float - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val lowerLegAngleInDeg : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val footAngleInDeg : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStayAlignedPose(_bb: ByteBuffer): StayAlignedPose = getRootAsStayAlignedPose(_bb, StayAlignedPose()) - @JvmStatic - fun getRootAsStayAlignedPose(_bb: ByteBuffer, obj: StayAlignedPose): StayAlignedPose { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStayAlignedPose(builder: FlatBufferBuilder, upperLegAngleInDeg: Float, lowerLegAngleInDeg: Float, footAngleInDeg: Float) : Int { - builder.startTable(3) - addFootAngleInDeg(builder, footAngleInDeg) - addLowerLegAngleInDeg(builder, lowerLegAngleInDeg) - addUpperLegAngleInDeg(builder, upperLegAngleInDeg) - return endStayAlignedPose(builder) - } - @JvmStatic - fun startStayAlignedPose(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addUpperLegAngleInDeg(builder: FlatBufferBuilder, upperLegAngleInDeg: Float) = builder.addFloat(0, upperLegAngleInDeg, 0.0) - @JvmStatic - fun addLowerLegAngleInDeg(builder: FlatBufferBuilder, lowerLegAngleInDeg: Float) = builder.addFloat(1, lowerLegAngleInDeg, 0.0) - @JvmStatic - fun addFootAngleInDeg(builder: FlatBufferBuilder, footAngleInDeg: Float) = builder.addFloat(2, footAngleInDeg, 0.0) - @JvmStatic - fun endStayAlignedPose(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedTracker.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedTracker.kt deleted file mode 100644 index 3bb7e998b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedTracker.kt +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.stay_aligned - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StayAlignedTracker : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StayAlignedTracker { - __init(_i, _bb) - return this - } - val yawCorrectionInDeg : Float - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val lockedErrorInDeg : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val centerErrorInDeg : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val neighborErrorInDeg : Float - get() { - val o = __offset(10) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val locked : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStayAlignedTracker(_bb: ByteBuffer): StayAlignedTracker = getRootAsStayAlignedTracker(_bb, StayAlignedTracker()) - @JvmStatic - fun getRootAsStayAlignedTracker(_bb: ByteBuffer, obj: StayAlignedTracker): StayAlignedTracker { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStayAlignedTracker(builder: FlatBufferBuilder, yawCorrectionInDeg: Float, lockedErrorInDeg: Float, centerErrorInDeg: Float, neighborErrorInDeg: Float, locked: Boolean) : Int { - builder.startTable(5) - addNeighborErrorInDeg(builder, neighborErrorInDeg) - addCenterErrorInDeg(builder, centerErrorInDeg) - addLockedErrorInDeg(builder, lockedErrorInDeg) - addYawCorrectionInDeg(builder, yawCorrectionInDeg) - addLocked(builder, locked) - return endStayAlignedTracker(builder) - } - @JvmStatic - fun startStayAlignedTracker(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addYawCorrectionInDeg(builder: FlatBufferBuilder, yawCorrectionInDeg: Float) = builder.addFloat(0, yawCorrectionInDeg, 0.0) - @JvmStatic - fun addLockedErrorInDeg(builder: FlatBufferBuilder, lockedErrorInDeg: Float) = builder.addFloat(1, lockedErrorInDeg, 0.0) - @JvmStatic - fun addCenterErrorInDeg(builder: FlatBufferBuilder, centerErrorInDeg: Float) = builder.addFloat(2, centerErrorInDeg, 0.0) - @JvmStatic - fun addNeighborErrorInDeg(builder: FlatBufferBuilder, neighborErrorInDeg: Float) = builder.addFloat(3, neighborErrorInDeg, 0.0) - @JvmStatic - fun addLocked(builder: FlatBufferBuilder, locked: Boolean) = builder.addBoolean(4, locked, false) - @JvmStatic - fun endStayAlignedTracker(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerData.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerData.kt deleted file mode 100644 index 55ba052c3..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerData.kt +++ /dev/null @@ -1,233 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.tracker - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Describes all possible information about a tracker. A tracker is anything that - * provides kinematic data about a particular body part. - * - * Trackers may be synthetic/computed or instead part of an actual hardware device. - * There can be multiple trackers per hardware device. - */ -@Suppress("unused") -class TrackerData : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackerData { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val info : solarxr_protocol.data_feed.tracker.TrackerInfo? get() = info(solarxr_protocol.data_feed.tracker.TrackerInfo()) - fun info(obj: solarxr_protocol.data_feed.tracker.TrackerInfo) : solarxr_protocol.data_feed.tracker.TrackerInfo? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val status : UByte - get() { - val o = __offset(8) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * Sensor rotation after fusion - */ - val rotation : solarxr_protocol.datatypes.math.Quat? get() = rotation(solarxr_protocol.datatypes.math.Quat()) - fun rotation(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Position, in meters - */ - val position : solarxr_protocol.datatypes.math.Vec3f? get() = position(solarxr_protocol.datatypes.math.Vec3f()) - fun position(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(12) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Raw angular velocity, in euler angles, rad/s - */ - val rawAngularVelocity : solarxr_protocol.datatypes.math.Vec3f? get() = rawAngularVelocity(solarxr_protocol.datatypes.math.Vec3f()) - fun rawAngularVelocity(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(14) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Raw acceleration, in m/s^2 - */ - val rawAcceleration : solarxr_protocol.datatypes.math.Vec3f? get() = rawAcceleration(solarxr_protocol.datatypes.math.Vec3f()) - fun rawAcceleration(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(16) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Temperature, in degrees celsius - */ - val temp : solarxr_protocol.datatypes.Temperature? get() = temp(solarxr_protocol.datatypes.Temperature()) - fun temp(obj: solarxr_protocol.datatypes.Temperature) : solarxr_protocol.datatypes.Temperature? { - val o = __offset(18) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Acceleration without gravity, in m/s^2 - */ - val linearAcceleration : solarxr_protocol.datatypes.math.Vec3f? get() = linearAcceleration(solarxr_protocol.datatypes.math.Vec3f()) - fun linearAcceleration(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(20) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - * In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), - * triggered after user input (using reset buttons). - * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. - * Includes: mounting orientation, full, quick and mounting reset adjustments. - * This rotation can be used to reconstruct a skeleton pose using forward kinematics. - */ - val rotationReferenceAdjusted : solarxr_protocol.datatypes.math.Quat? get() = rotationReferenceAdjusted(solarxr_protocol.datatypes.math.Quat()) - fun rotationReferenceAdjusted(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(22) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - * In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by - * inverting the current rotation, triggered after user input (using reset buttons). - * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. - * Includes: only full and quick reset adjustments. - * This rotation can be used in visualizations for IMU debugging. - */ - val rotationIdentityAdjusted : solarxr_protocol.datatypes.math.Quat? get() = rotationIdentityAdjusted(solarxr_protocol.datatypes.math.Quat()) - fun rotationIdentityAdjusted(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(24) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Data ticks per second, processed by SlimeVR server - */ - val tps : UShort? - get() { - val o = __offset(26) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else null - } - /** - * Magnetic field vector, in mGauss - */ - val rawMagneticVector : solarxr_protocol.datatypes.math.Vec3f? get() = rawMagneticVector(solarxr_protocol.datatypes.math.Vec3f()) - fun rawMagneticVector(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { - val o = __offset(28) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Stay Aligned - */ - val stayAligned : solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker? get() = stayAligned(solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker()) - fun stayAligned(obj: solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker) : solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker? { - val o = __offset(30) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackerData(_bb: ByteBuffer): TrackerData = getRootAsTrackerData(_bb, TrackerData()) - @JvmStatic - fun getRootAsTrackerData(_bb: ByteBuffer, obj: TrackerData): TrackerData { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startTrackerData(builder: FlatBufferBuilder) = builder.startTable(14) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun addInfo(builder: FlatBufferBuilder, info: Int) = builder.addOffset(1, info, 0) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(2, status.toByte(), 0) - @JvmStatic - fun addRotation(builder: FlatBufferBuilder, rotation: Int) = builder.addStruct(3, rotation, 0) - @JvmStatic - fun addPosition(builder: FlatBufferBuilder, position: Int) = builder.addStruct(4, position, 0) - @JvmStatic - fun addRawAngularVelocity(builder: FlatBufferBuilder, rawAngularVelocity: Int) = builder.addStruct(5, rawAngularVelocity, 0) - @JvmStatic - fun addRawAcceleration(builder: FlatBufferBuilder, rawAcceleration: Int) = builder.addStruct(6, rawAcceleration, 0) - @JvmStatic - fun addTemp(builder: FlatBufferBuilder, temp: Int) = builder.addStruct(7, temp, 0) - @JvmStatic - fun addLinearAcceleration(builder: FlatBufferBuilder, linearAcceleration: Int) = builder.addStruct(8, linearAcceleration, 0) - @JvmStatic - fun addRotationReferenceAdjusted(builder: FlatBufferBuilder, rotationReferenceAdjusted: Int) = builder.addStruct(9, rotationReferenceAdjusted, 0) - @JvmStatic - fun addRotationIdentityAdjusted(builder: FlatBufferBuilder, rotationIdentityAdjusted: Int) = builder.addStruct(10, rotationIdentityAdjusted, 0) - @JvmStatic - fun addTps(builder: FlatBufferBuilder, tps: UShort) = builder.addShort(11, tps.toShort(), 0) - @JvmStatic - fun addRawMagneticVector(builder: FlatBufferBuilder, rawMagneticVector: Int) = builder.addStruct(12, rawMagneticVector, 0) - @JvmStatic - fun addStayAligned(builder: FlatBufferBuilder, stayAligned: Int) = builder.addOffset(13, stayAligned, 0) - @JvmStatic - fun endTrackerData(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.kt deleted file mode 100644 index 41b609797..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerDataMask.kt +++ /dev/null @@ -1,149 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.tracker - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A mask of the different components in `TrackerComponent` - */ -@Suppress("unused") -class TrackerDataMask : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackerDataMask { - __init(_i, _bb) - return this - } - val info : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val status : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rotation : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val position : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rawAngularVelocity : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rawAcceleration : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val temp : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val linearAcceleration : Boolean - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rotationReferenceAdjusted : Boolean - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rotationIdentityAdjusted : Boolean - get() { - val o = __offset(22) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val tps : Boolean - get() { - val o = __offset(24) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rawMagneticVector : Boolean - get() { - val o = __offset(26) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val stayAligned : Boolean - get() { - val o = __offset(28) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackerDataMask(_bb: ByteBuffer): TrackerDataMask = getRootAsTrackerDataMask(_bb, TrackerDataMask()) - @JvmStatic - fun getRootAsTrackerDataMask(_bb: ByteBuffer, obj: TrackerDataMask): TrackerDataMask { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackerDataMask(builder: FlatBufferBuilder, info: Boolean, status: Boolean, rotation: Boolean, position: Boolean, rawAngularVelocity: Boolean, rawAcceleration: Boolean, temp: Boolean, linearAcceleration: Boolean, rotationReferenceAdjusted: Boolean, rotationIdentityAdjusted: Boolean, tps: Boolean, rawMagneticVector: Boolean, stayAligned: Boolean) : Int { - builder.startTable(13) - addStayAligned(builder, stayAligned) - addRawMagneticVector(builder, rawMagneticVector) - addTps(builder, tps) - addRotationIdentityAdjusted(builder, rotationIdentityAdjusted) - addRotationReferenceAdjusted(builder, rotationReferenceAdjusted) - addLinearAcceleration(builder, linearAcceleration) - addTemp(builder, temp) - addRawAcceleration(builder, rawAcceleration) - addRawAngularVelocity(builder, rawAngularVelocity) - addPosition(builder, position) - addRotation(builder, rotation) - addStatus(builder, status) - addInfo(builder, info) - return endTrackerDataMask(builder) - } - @JvmStatic - fun startTrackerDataMask(builder: FlatBufferBuilder) = builder.startTable(13) - @JvmStatic - fun addInfo(builder: FlatBufferBuilder, info: Boolean) = builder.addBoolean(0, info, false) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: Boolean) = builder.addBoolean(1, status, false) - @JvmStatic - fun addRotation(builder: FlatBufferBuilder, rotation: Boolean) = builder.addBoolean(2, rotation, false) - @JvmStatic - fun addPosition(builder: FlatBufferBuilder, position: Boolean) = builder.addBoolean(3, position, false) - @JvmStatic - fun addRawAngularVelocity(builder: FlatBufferBuilder, rawAngularVelocity: Boolean) = builder.addBoolean(4, rawAngularVelocity, false) - @JvmStatic - fun addRawAcceleration(builder: FlatBufferBuilder, rawAcceleration: Boolean) = builder.addBoolean(5, rawAcceleration, false) - @JvmStatic - fun addTemp(builder: FlatBufferBuilder, temp: Boolean) = builder.addBoolean(6, temp, false) - @JvmStatic - fun addLinearAcceleration(builder: FlatBufferBuilder, linearAcceleration: Boolean) = builder.addBoolean(7, linearAcceleration, false) - @JvmStatic - fun addRotationReferenceAdjusted(builder: FlatBufferBuilder, rotationReferenceAdjusted: Boolean) = builder.addBoolean(8, rotationReferenceAdjusted, false) - @JvmStatic - fun addRotationIdentityAdjusted(builder: FlatBufferBuilder, rotationIdentityAdjusted: Boolean) = builder.addBoolean(9, rotationIdentityAdjusted, false) - @JvmStatic - fun addTps(builder: FlatBufferBuilder, tps: Boolean) = builder.addBoolean(10, tps, false) - @JvmStatic - fun addRawMagneticVector(builder: FlatBufferBuilder, rawMagneticVector: Boolean) = builder.addBoolean(11, rawMagneticVector, false) - @JvmStatic - fun addStayAligned(builder: FlatBufferBuilder, stayAligned: Boolean) = builder.addBoolean(12, stayAligned, false) - @JvmStatic - fun endTrackerDataMask(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt deleted file mode 100644 index a24af5083..000000000 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt +++ /dev/null @@ -1,192 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.data_feed.tracker - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Static description of a tracker - */ -@Suppress("unused") -class TrackerInfo : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackerInfo { - __init(_i, _bb) - return this - } - val imuType : UShort - get() { - val o = __offset(4) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - /** - * The user-assigned role of the tracker. - */ - val bodyPart : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * average samples per second - */ - val pollRate : solarxr_protocol.datatypes.HzF32? get() = pollRate(solarxr_protocol.datatypes.HzF32()) - fun pollRate(obj: solarxr_protocol.datatypes.HzF32) : solarxr_protocol.datatypes.HzF32? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * The orientation of the tracker when mounted on the body - */ - val mountingOrientation : solarxr_protocol.datatypes.math.Quat? get() = mountingOrientation(solarxr_protocol.datatypes.math.Quat()) - fun mountingOrientation(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Should the tracker's settings be editable by the user - */ - val editable : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * Indicates if the tracker is computed (solved position and rotation) - */ - val isComputed : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * Indicates if the tracker is using an IMU for its tracking data - */ - val isImu : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * A human-friendly name to display as the name of the tracker. - */ - val displayName : String? - get() { - val o = __offset(18) - return if (o != 0) __string(o + bb_pos) else null - } - val displayNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(18, 1) - fun displayNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 18, 1) - /** - * name to display as the name of the tracker set by the user - */ - val customName : String? - get() { - val o = __offset(20) - return if (o != 0) __string(o + bb_pos) else null - } - val customNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(20, 1) - fun customNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 20, 1) - /** - * Whether to allow yaw drift compensation for this tracker or not. - */ - val allowDriftCompensation : Boolean - get() { - val o = __offset(22) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * Mounting Reset orientation overrides the current `mounting_orientation` of - * the tracker, this orientation is not saved and needs to be calculated - * each time the server is ran - */ - val mountingResetOrientation : solarxr_protocol.datatypes.math.Quat? get() = mountingResetOrientation(solarxr_protocol.datatypes.math.Quat()) - fun mountingResetOrientation(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(24) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * Indicates if the tracker is actually an HMD - */ - val isHmd : Boolean - get() { - val o = __offset(26) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val magnetometer : UByte - get() { - val o = __offset(28) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) - */ - val dataSupport : UByte - get() { - val o = __offset(30) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackerInfo(_bb: ByteBuffer): TrackerInfo = getRootAsTrackerInfo(_bb, TrackerInfo()) - @JvmStatic - fun getRootAsTrackerInfo(_bb: ByteBuffer, obj: TrackerInfo): TrackerInfo { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startTrackerInfo(builder: FlatBufferBuilder) = builder.startTable(14) - @JvmStatic - fun addImuType(builder: FlatBufferBuilder, imuType: UShort) = builder.addShort(0, imuType.toShort(), 0) - @JvmStatic - fun addBodyPart(builder: FlatBufferBuilder, bodyPart: UByte) = builder.addByte(1, bodyPart.toByte(), 0) - @JvmStatic - fun addPollRate(builder: FlatBufferBuilder, pollRate: Int) = builder.addStruct(2, pollRate, 0) - @JvmStatic - fun addMountingOrientation(builder: FlatBufferBuilder, mountingOrientation: Int) = builder.addStruct(3, mountingOrientation, 0) - @JvmStatic - fun addEditable(builder: FlatBufferBuilder, editable: Boolean) = builder.addBoolean(4, editable, false) - @JvmStatic - fun addIsComputed(builder: FlatBufferBuilder, isComputed: Boolean) = builder.addBoolean(5, isComputed, false) - @JvmStatic - fun addIsImu(builder: FlatBufferBuilder, isImu: Boolean) = builder.addBoolean(6, isImu, false) - @JvmStatic - fun addDisplayName(builder: FlatBufferBuilder, displayName: Int) = builder.addOffset(7, displayName, 0) - @JvmStatic - fun addCustomName(builder: FlatBufferBuilder, customName: Int) = builder.addOffset(8, customName, 0) - @JvmStatic - fun addAllowDriftCompensation(builder: FlatBufferBuilder, allowDriftCompensation: Boolean) = builder.addBoolean(9, allowDriftCompensation, false) - @JvmStatic - fun addMountingResetOrientation(builder: FlatBufferBuilder, mountingResetOrientation: Int) = builder.addStruct(10, mountingResetOrientation, 0) - @JvmStatic - fun addIsHmd(builder: FlatBufferBuilder, isHmd: Boolean) = builder.addBoolean(11, isHmd, false) - @JvmStatic - fun addMagnetometer(builder: FlatBufferBuilder, magnetometer: UByte) = builder.addByte(12, magnetometer.toByte(), 0) - @JvmStatic - fun addDataSupport(builder: FlatBufferBuilder, dataSupport: UByte) = builder.addByte(13, dataSupport.toByte(), 0) - @JvmStatic - fun endTrackerInfo(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/BodyPart.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/BodyPart.kt deleted file mode 100644 index cbc73ccb0..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/BodyPart.kt +++ /dev/null @@ -1,69 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -/** - * Different parts of the body. Maps to each possible non-tracker bone in the skeleton. - * These are *NOT* the trackers. - */ -@Suppress("unused") -class BodyPart private constructor() { - companion object { - const val NONE: UByte = 0u - const val HEAD: UByte = 1u - const val NECK: UByte = 2u - const val CHEST: UByte = 3u - const val WAIST: UByte = 4u - const val HIP: UByte = 5u - const val LEFTUPPERLEG: UByte = 6u - const val RIGHTUPPERLEG: UByte = 7u - const val LEFTLOWERLEG: UByte = 8u - const val RIGHTLOWERLEG: UByte = 9u - const val LEFTFOOT: UByte = 10u - const val RIGHTFOOT: UByte = 11u - const val LEFTLOWERARM: UByte = 14u - const val RIGHTLOWERARM: UByte = 15u - const val LEFTUPPERARM: UByte = 16u - const val RIGHTUPPERARM: UByte = 17u - const val LEFTHAND: UByte = 18u - const val RIGHTHAND: UByte = 19u - const val LEFTSHOULDER: UByte = 20u - const val RIGHTSHOULDER: UByte = 21u - const val UPPERCHEST: UByte = 22u - const val LEFTHIP: UByte = 23u - const val RIGHTHIP: UByte = 24u - const val LEFTTHUMBMETACARPAL: UByte = 25u - const val LEFTTHUMBPROXIMAL: UByte = 26u - const val LEFTTHUMBDISTAL: UByte = 27u - const val LEFTINDEXPROXIMAL: UByte = 28u - const val LEFTINDEXINTERMEDIATE: UByte = 29u - const val LEFTINDEXDISTAL: UByte = 30u - const val LEFTMIDDLEPROXIMAL: UByte = 31u - const val LEFTMIDDLEINTERMEDIATE: UByte = 32u - const val LEFTMIDDLEDISTAL: UByte = 33u - const val LEFTRINGPROXIMAL: UByte = 34u - const val LEFTRINGINTERMEDIATE: UByte = 35u - const val LEFTRINGDISTAL: UByte = 36u - const val LEFTLITTLEPROXIMAL: UByte = 37u - const val LEFTLITTLEINTERMEDIATE: UByte = 38u - const val LEFTLITTLEDISTAL: UByte = 39u - const val RIGHTTHUMBMETACARPAL: UByte = 40u - const val RIGHTTHUMBPROXIMAL: UByte = 41u - const val RIGHTTHUMBDISTAL: UByte = 42u - const val RIGHTINDEXPROXIMAL: UByte = 43u - const val RIGHTINDEXINTERMEDIATE: UByte = 44u - const val RIGHTINDEXDISTAL: UByte = 45u - const val RIGHTMIDDLEPROXIMAL: UByte = 46u - const val RIGHTMIDDLEINTERMEDIATE: UByte = 47u - const val RIGHTMIDDLEDISTAL: UByte = 48u - const val RIGHTRINGPROXIMAL: UByte = 49u - const val RIGHTRINGINTERMEDIATE: UByte = 50u - const val RIGHTRINGDISTAL: UByte = 51u - const val RIGHTLITTLEPROXIMAL: UByte = 52u - const val RIGHTLITTLEINTERMEDIATE: UByte = 53u - const val RIGHTLITTLEDISTAL: UByte = 54u - val names : Array = arrayOf("NONE", "HEAD", "NECK", "CHEST", "WAIST", "HIP", "LEFT_UPPER_LEG", "RIGHT_UPPER_LEG", "LEFT_LOWER_LEG", "RIGHT_LOWER_LEG", "LEFT_FOOT", "RIGHT_FOOT", "", "", "LEFT_LOWER_ARM", "RIGHT_LOWER_ARM", "LEFT_UPPER_ARM", "RIGHT_UPPER_ARM", "LEFT_HAND", "RIGHT_HAND", "LEFT_SHOULDER", "RIGHT_SHOULDER", "UPPER_CHEST", "LEFT_HIP", "RIGHT_HIP", "LEFT_THUMB_METACARPAL", "LEFT_THUMB_PROXIMAL", "LEFT_THUMB_DISTAL", "LEFT_INDEX_PROXIMAL", "LEFT_INDEX_INTERMEDIATE", "LEFT_INDEX_DISTAL", "LEFT_MIDDLE_PROXIMAL", "LEFT_MIDDLE_INTERMEDIATE", "LEFT_MIDDLE_DISTAL", "LEFT_RING_PROXIMAL", "LEFT_RING_INTERMEDIATE", "LEFT_RING_DISTAL", "LEFT_LITTLE_PROXIMAL", "LEFT_LITTLE_INTERMEDIATE", "LEFT_LITTLE_DISTAL", "RIGHT_THUMB_METACARPAL", "RIGHT_THUMB_PROXIMAL", "RIGHT_THUMB_DISTAL", "RIGHT_INDEX_PROXIMAL", "RIGHT_INDEX_INTERMEDIATE", "RIGHT_INDEX_DISTAL", "RIGHT_MIDDLE_PROXIMAL", "RIGHT_MIDDLE_INTERMEDIATE", "RIGHT_MIDDLE_DISTAL", "RIGHT_RING_PROXIMAL", "RIGHT_RING_INTERMEDIATE", "RIGHT_RING_DISTAL", "RIGHT_LITTLE_PROXIMAL", "RIGHT_LITTLE_INTERMEDIATE", "RIGHT_LITTLE_DISTAL") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/Bytes.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/Bytes.kt deleted file mode 100644 index a18669621..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/Bytes.kt +++ /dev/null @@ -1,69 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class Bytes : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Bytes { - __init(_i, _bb) - return this - } - fun b(j: Int) : UByte { - val o = __offset(4) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val bLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - val bAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun bInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsBytes(_bb: ByteBuffer): Bytes = getRootAsBytes(_bb, Bytes()) - @JvmStatic - fun getRootAsBytes(_bb: ByteBuffer, obj: Bytes): Bytes { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createBytes(builder: FlatBufferBuilder, bOffset: Int) : Int { - builder.startTable(1) - addB(builder, bOffset) - return endBytes(builder) - } - @JvmStatic - fun startBytes(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addB(builder: FlatBufferBuilder, b: Int) = builder.addOffset(0, b, 0) - @JvmStatic - fun createBVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startBVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun endBytes(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceId.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceId.kt deleted file mode 100644 index 41a5c666f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceId.kt +++ /dev/null @@ -1,32 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A unique ID for the device. IDs are not guaranteed to be the same after - * the connection is terminated. - */ -@Suppress("unused") -class DeviceId : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DeviceId { - __init(_i, _bb) - return this - } - val id : UByte get() = bb.get(bb_pos + 0).toUByte() - companion object { - @JvmStatic - fun createDeviceId(builder: FlatBufferBuilder, id: UByte) : Int { - builder.prep(1, 1) - builder.putByte(id.toByte()) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceIdTable.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceIdTable.kt deleted file mode 100644 index d3bc5fb58..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/DeviceIdTable.kt +++ /dev/null @@ -1,51 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * To be used inside unions - */ -@Suppress("unused") -class DeviceIdTable : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DeviceIdTable { - __init(_i, _bb) - return this - } - val id : solarxr_protocol.datatypes.DeviceId? get() = id(solarxr_protocol.datatypes.DeviceId()) - fun id(obj: solarxr_protocol.datatypes.DeviceId) : solarxr_protocol.datatypes.DeviceId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDeviceIdTable(_bb: ByteBuffer): DeviceIdTable = getRootAsDeviceIdTable(_bb, DeviceIdTable()) - @JvmStatic - fun getRootAsDeviceIdTable(_bb: ByteBuffer, obj: DeviceIdTable): DeviceIdTable { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startDeviceIdTable(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: Int) = builder.addStruct(0, id, 0) - @JvmStatic - fun endDeviceIdTable(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/FilteringType.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/FilteringType.kt deleted file mode 100644 index bba3ceb5b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/FilteringType.kt +++ /dev/null @@ -1,18 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -/** - * Used for filtering tracker rotations in software - */ -@Suppress("unused") -class FilteringType private constructor() { - companion object { - const val NONE: UByte = 0u - const val SMOOTHING: UByte = 1u - const val PREDICTION: UByte = 2u - val names : Array = arrayOf("NONE", "SMOOTHING", "PREDICTION") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/FirmwareErrorCode.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/FirmwareErrorCode.kt deleted file mode 100644 index 368d08272..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/FirmwareErrorCode.kt +++ /dev/null @@ -1,19 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -/** - * A list of error codes for error conditions on the device - */ -@Suppress("unused") -class FirmwareErrorCode private constructor() { - companion object { - const val Other: UByte = 0u - const val Disconnected: UByte = 1u - const val Occluded: UByte = 2u - const val ImuError: UByte = 3u - val names : Array = arrayOf("Other", "Disconnected", "Occluded", "ImuError") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/HzF32.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/HzF32.kt deleted file mode 100644 index 741cdf2bd..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/HzF32.kt +++ /dev/null @@ -1,31 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Frequency as 32 bit float - */ -@Suppress("unused") -class HzF32 : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HzF32 { - __init(_i, _bb) - return this - } - val f : Float get() = bb.getFloat(bb_pos + 0) - companion object { - @JvmStatic - fun createHzF32(builder: FlatBufferBuilder, f: Float) : Int { - builder.prep(4, 4) - builder.putFloat(f) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/Ipv4Address.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/Ipv4Address.kt deleted file mode 100644 index 89cb17b22..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/Ipv4Address.kt +++ /dev/null @@ -1,32 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * The 4 bytes of an ip address are stored in 32 bits in big endian order. - * We will switch over to fixed size arrays when they are supported better. - */ -@Suppress("unused") -class Ipv4Address : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Ipv4Address { - __init(_i, _bb) - return this - } - val addr : UInt get() = bb.getInt(bb_pos + 0).toUInt() - companion object { - @JvmStatic - fun createIpv4Address(builder: FlatBufferBuilder, addr: UInt) : Int { - builder.prep(4, 4) - builder.putInt(addr.toInt()) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/LogData.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/LogData.kt deleted file mode 100644 index 7976bfc7f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/LogData.kt +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * General purpose logging datatype - */ -@Suppress("unused") -class LogData : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : LogData { - __init(_i, _bb) - return this - } - val message : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val messageAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun messageInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - fun data(j: Int) : UByte { - val o = __offset(6) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val dataLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - val dataAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun dataInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsLogData(_bb: ByteBuffer): LogData = getRootAsLogData(_bb, LogData()) - @JvmStatic - fun getRootAsLogData(_bb: ByteBuffer, obj: LogData): LogData { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createLogData(builder: FlatBufferBuilder, messageOffset: Int, dataOffset: Int) : Int { - builder.startTable(2) - addData(builder, dataOffset) - addMessage(builder, messageOffset) - return endLogData(builder) - } - @JvmStatic - fun startLogData(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addMessage(builder: FlatBufferBuilder, message: Int) = builder.addOffset(0, message, 0) - @JvmStatic - fun addData(builder: FlatBufferBuilder, data: Int) = builder.addOffset(1, data, 0) - @JvmStatic - fun createDataVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startDataVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun endLogData(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/MagnetometerStatus.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/MagnetometerStatus.kt deleted file mode 100644 index b47f5b4b8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/MagnetometerStatus.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -@Suppress("unused") -class MagnetometerStatus private constructor() { - companion object { - const val NOTSUPPORTED: UByte = 0u - const val DISABLED: UByte = 1u - const val ENABLED: UByte = 2u - val names : Array = arrayOf("NOT_SUPPORTED", "DISABLED", "ENABLED") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/StringTable.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/StringTable.kt deleted file mode 100644 index a16064882..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/StringTable.kt +++ /dev/null @@ -1,52 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StringTable : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StringTable { - __init(_i, _bb) - return this - } - val s : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val sAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun sInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStringTable(_bb: ByteBuffer): StringTable = getRootAsStringTable(_bb, StringTable()) - @JvmStatic - fun getRootAsStringTable(_bb: ByteBuffer, obj: StringTable): StringTable { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStringTable(builder: FlatBufferBuilder, sOffset: Int) : Int { - builder.startTable(1) - addS(builder, sOffset) - return endStringTable(builder) - } - @JvmStatic - fun startStringTable(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addS(builder: FlatBufferBuilder, s: Int) = builder.addOffset(0, s, 0) - @JvmStatic - fun endStringTable(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/Temperature.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/Temperature.kt deleted file mode 100644 index 62a15ec76..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/Temperature.kt +++ /dev/null @@ -1,31 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Temperature in degrees celsius - */ -@Suppress("unused") -class Temperature : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Temperature { - __init(_i, _bb) - return this - } - val temp : Float get() = bb.getFloat(bb_pos + 0) - companion object { - @JvmStatic - fun createTemperature(builder: FlatBufferBuilder, temp: Float) : Int { - builder.prep(4, 4) - builder.putFloat(temp) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerId.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerId.kt deleted file mode 100644 index 406ef7825..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerId.kt +++ /dev/null @@ -1,62 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackerId : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackerId { - __init(_i, _bb) - return this - } - /** - * The device the tracker is associated with. If there is no hardware device it is - * associated with, this should be `null`. - */ - val deviceId : solarxr_protocol.datatypes.DeviceId? get() = deviceId(solarxr_protocol.datatypes.DeviceId()) - fun deviceId(obj: solarxr_protocol.datatypes.DeviceId) : solarxr_protocol.datatypes.DeviceId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * There are possibly multiple trackers per device. This identifies which one. - */ - val trackerNum : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackerId(_bb: ByteBuffer): TrackerId = getRootAsTrackerId(_bb, TrackerId()) - @JvmStatic - fun getRootAsTrackerId(_bb: ByteBuffer, obj: TrackerId): TrackerId { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startTrackerId(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addDeviceId(builder: FlatBufferBuilder, deviceId: Int) = builder.addStruct(0, deviceId, 0) - @JvmStatic - fun addTrackerNum(builder: FlatBufferBuilder, trackerNum: UByte) = builder.addByte(1, trackerNum.toByte(), 0) - @JvmStatic - fun endTrackerId(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerRole.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerRole.kt deleted file mode 100644 index 85b5d9d71..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerRole.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -/** - * Possible tracker roles - * They're not perfect match for SteamVR tracker roles, - * because we support more possible roles. Host can - * chose how to map it to their supported role. - */ -@Suppress("unused") -class TrackerRole private constructor() { - companion object { - const val NONE: UByte = 0u - const val WAIST: UByte = 1u - const val LEFTFOOT: UByte = 2u - const val RIGHTFOOT: UByte = 3u - const val CHEST: UByte = 4u - const val LEFTKNEE: UByte = 5u - const val RIGHTKNEE: UByte = 6u - const val LEFTELBOW: UByte = 7u - const val RIGHTELBOW: UByte = 8u - const val LEFTSHOULDER: UByte = 9u - const val RIGHTSHOULDER: UByte = 10u - const val LEFTHAND: UByte = 11u - const val RIGHTHAND: UByte = 12u - const val LEFTCONTROLLER: UByte = 13u - const val RIGHTCONTROLLER: UByte = 14u - const val HEAD: UByte = 15u - const val NECK: UByte = 16u - const val CAMERA: UByte = 17u - const val KEYBOARD: UByte = 18u - const val HMD: UByte = 19u - const val BEACON: UByte = 20u - const val GENERICCONTROLLER: UByte = 21u - val names : Array = arrayOf("NONE", "WAIST", "LEFT_FOOT", "RIGHT_FOOT", "CHEST", "LEFT_KNEE", "RIGHT_KNEE", "LEFT_ELBOW", "RIGHT_ELBOW", "LEFT_SHOULDER", "RIGHT_SHOULDER", "LEFT_HAND", "RIGHT_HAND", "LEFT_CONTROLLER", "RIGHT_CONTROLLER", "HEAD", "NECK", "CAMERA", "KEYBOARD", "HMD", "BEACON", "GENERIC_CONTROLLER") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerStatus.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerStatus.kt deleted file mode 100644 index dd5ed25a7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/TrackerStatus.kt +++ /dev/null @@ -1,19 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -@Suppress("unused") -class TrackerStatus private constructor() { - companion object { - const val NONE: UByte = 0u - const val DISCONNECTED: UByte = 1u - const val OK: UByte = 2u - const val BUSY: UByte = 3u - const val ERROR: UByte = 4u - const val OCCLUDED: UByte = 5u - const val TIMEDOUT: UByte = 6u - val names : Array = arrayOf("NONE", "DISCONNECTED", "OK", "BUSY", "ERROR", "OCCLUDED", "TIMED_OUT") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/TransactionId.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/TransactionId.kt deleted file mode 100644 index 84b1ff7f9..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/TransactionId.kt +++ /dev/null @@ -1,31 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TransactionId : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TransactionId { - __init(_i, _bb) - return this - } - /** - * This is expected to overflow, networking logic should handle this case. - */ - val id : UInt get() = bb.getInt(bb_pos + 0).toUInt() - companion object { - @JvmStatic - fun createTransactionId(builder: FlatBufferBuilder, id: UInt) : Int { - builder.prep(4, 4) - builder.putInt(id.toInt()) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/BoardType.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/BoardType.kt deleted file mode 100644 index 6b66afc38..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/BoardType.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -@Suppress("unused") -class BoardType private constructor() { - companion object { - const val UNKNOWN: UShort = 0u - const val SLIMEVRLEGACY: UShort = 1u - const val SLIMEVRDEV: UShort = 2u - const val NODEMCU: UShort = 3u - const val CUSTOM: UShort = 4u - const val WROOM32: UShort = 5u - const val WEMOSD1MINI: UShort = 6u - const val TTGOTBASE: UShort = 7u - const val ESP01: UShort = 8u - const val SLIMEVR: UShort = 9u - const val LOLINC3MINI: UShort = 10u - const val BEETLE32C3: UShort = 11u - const val ESP32C3DEVKITM1: UShort = 12u - const val OWOTRACK: UShort = 13u - const val WRANGLER: UShort = 14u - const val MOCOPI: UShort = 15u - const val WEMOSWROOM02: UShort = 16u - const val XIAOESP32C3: UShort = 17u - const val HARITORA: UShort = 18u - const val ESP32C6DEVKITC1: UShort = 19u - const val GLOVEIMUSLIMEVRDEV: UShort = 20u - const val GESTURES: UShort = 21u - const val SLIMEVRV12: UShort = 22u - const val ESP32S3SUPERMINI: UShort = 23u - const val GENERICNRF: UShort = 24u - const val SLIMEVRBUTTERFLYDEV: UShort = 25u - const val SLIMEVRBUTTERFLY: UShort = 26u - const val DEVRESERVED: UShort = 250u - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/FirmwareStatusMask.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/FirmwareStatusMask.kt deleted file mode 100644 index bb20a406a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/FirmwareStatusMask.kt +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A mask of the data in `FirmwareStatus` - */ -@Suppress("unused") -class FirmwareStatusMask : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FirmwareStatusMask { - __init(_i, _bb) - return this - } - val errorStatus : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val tps : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val ping : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rssi : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val mcuTemp : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val batteryVoltage : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val batteryPctEstimate : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val batteryRuntimeEstimate : Boolean - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFirmwareStatusMask(_bb: ByteBuffer): FirmwareStatusMask = getRootAsFirmwareStatusMask(_bb, FirmwareStatusMask()) - @JvmStatic - fun getRootAsFirmwareStatusMask(_bb: ByteBuffer, obj: FirmwareStatusMask): FirmwareStatusMask { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createFirmwareStatusMask(builder: FlatBufferBuilder, errorStatus: Boolean, tps: Boolean, ping: Boolean, rssi: Boolean, mcuTemp: Boolean, batteryVoltage: Boolean, batteryPctEstimate: Boolean, batteryRuntimeEstimate: Boolean) : Int { - builder.startTable(8) - addBatteryRuntimeEstimate(builder, batteryRuntimeEstimate) - addBatteryPctEstimate(builder, batteryPctEstimate) - addBatteryVoltage(builder, batteryVoltage) - addMcuTemp(builder, mcuTemp) - addRssi(builder, rssi) - addPing(builder, ping) - addTps(builder, tps) - addErrorStatus(builder, errorStatus) - return endFirmwareStatusMask(builder) - } - @JvmStatic - fun startFirmwareStatusMask(builder: FlatBufferBuilder) = builder.startTable(8) - @JvmStatic - fun addErrorStatus(builder: FlatBufferBuilder, errorStatus: Boolean) = builder.addBoolean(0, errorStatus, false) - @JvmStatic - fun addTps(builder: FlatBufferBuilder, tps: Boolean) = builder.addBoolean(1, tps, false) - @JvmStatic - fun addPing(builder: FlatBufferBuilder, ping: Boolean) = builder.addBoolean(2, ping, false) - @JvmStatic - fun addRssi(builder: FlatBufferBuilder, rssi: Boolean) = builder.addBoolean(3, rssi, false) - @JvmStatic - fun addMcuTemp(builder: FlatBufferBuilder, mcuTemp: Boolean) = builder.addBoolean(4, mcuTemp, false) - @JvmStatic - fun addBatteryVoltage(builder: FlatBufferBuilder, batteryVoltage: Boolean) = builder.addBoolean(5, batteryVoltage, false) - @JvmStatic - fun addBatteryPctEstimate(builder: FlatBufferBuilder, batteryPctEstimate: Boolean) = builder.addBoolean(6, batteryPctEstimate, false) - @JvmStatic - fun addBatteryRuntimeEstimate(builder: FlatBufferBuilder, batteryRuntimeEstimate: Boolean) = builder.addBoolean(7, batteryRuntimeEstimate, false) - @JvmStatic - fun endFirmwareStatusMask(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareAddress.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareAddress.kt deleted file mode 100644 index fb4ed0c76..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareAddress.kt +++ /dev/null @@ -1,33 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A MAC address or a bluetooth address, or some other uniquely identifying address - * associated with the endpoint that we are communicating with. If it doesn't take - * up the full set of bytes, it is aligned towards the least significant bits. - */ -@Suppress("unused") -class HardwareAddress : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HardwareAddress { - __init(_i, _bb) - return this - } - val addr : ULong get() = bb.getLong(bb_pos + 0).toULong() - companion object { - @JvmStatic - fun createHardwareAddress(builder: FlatBufferBuilder, addr: ULong) : Int { - builder.prep(8, 8) - builder.putLong(addr.toLong()) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt deleted file mode 100644 index 207d58901..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareInfo.kt +++ /dev/null @@ -1,186 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Mostly static info about the device's hardware/firmware. - */ -@Suppress("unused") -class HardwareInfo : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HardwareInfo { - __init(_i, _bb) - return this - } - val mcuId : UShort - get() { - val o = __offset(4) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - /** - * A human-friendly name to display as the name of the device. - */ - val displayName : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val displayNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun displayNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - /** - * A human-friendly string for the device model. - */ - val model : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val modelAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun modelInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - /** - * A human-friendly string for the manufacturer of the device. - */ - val manufacturer : String? - get() { - val o = __offset(10) - return if (o != 0) __string(o + bb_pos) else null - } - val manufacturerAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1) - fun manufacturerInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1) - /** - * The hardware version of the device. For example, pcb version. - */ - val hardwareRevision : String? - get() { - val o = __offset(12) - return if (o != 0) __string(o + bb_pos) else null - } - val hardwareRevisionAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(12, 1) - fun hardwareRevisionInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 12, 1) - /** - * The version of the slimevr firmware that the device is running. - */ - val firmwareVersion : String? - get() { - val o = __offset(14) - return if (o != 0) __string(o + bb_pos) else null - } - val firmwareVersionAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(14, 1) - fun firmwareVersionInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 14, 1) - val hardwareAddress : solarxr_protocol.datatypes.hardware_info.HardwareAddress? get() = hardwareAddress(solarxr_protocol.datatypes.hardware_info.HardwareAddress()) - fun hardwareAddress(obj: solarxr_protocol.datatypes.hardware_info.HardwareAddress) : solarxr_protocol.datatypes.hardware_info.HardwareAddress? { - val o = __offset(16) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - val ipAddress : solarxr_protocol.datatypes.Ipv4Address? get() = ipAddress(solarxr_protocol.datatypes.Ipv4Address()) - fun ipAddress(obj: solarxr_protocol.datatypes.Ipv4Address) : solarxr_protocol.datatypes.Ipv4Address? { - val o = __offset(18) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * A board type string that can be used to name a board. if possible you should use official board type - */ - val boardType : String? - get() { - val o = __offset(20) - return if (o != 0) __string(o + bb_pos) else null - } - val boardTypeAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(20, 1) - fun boardTypeInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 20, 1) - /** - * An enum listing all the board types supported by the firmware - */ - val officialBoardType : UShort - get() { - val o = __offset(22) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - /** - * A unique identifier for the device. Depending on the type of device it can be the MAC address, - * the IP address, or some other unique identifier like what USB device it is. - */ - val hardwareIdentifier : String? - get() { - val o = __offset(24) - return if (o != 0) __string(o + bb_pos) else null - } - val hardwareIdentifierAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(24, 1) - fun hardwareIdentifierInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 24, 1) - /** - * The version of the protocol it's using to communicate with server - */ - val networkProtocolVersion : UShort? - get() { - val o = __offset(26) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else null - } - /** - * The build date of the slimevr firmware that the device is running. YYYY-MM-DD - */ - val firmwareDate : String? - get() { - val o = __offset(28) - return if (o != 0) __string(o + bb_pos) else null - } - val firmwareDateAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(28, 1) - fun firmwareDateInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 28, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHardwareInfo(_bb: ByteBuffer): HardwareInfo = getRootAsHardwareInfo(_bb, HardwareInfo()) - @JvmStatic - fun getRootAsHardwareInfo(_bb: ByteBuffer, obj: HardwareInfo): HardwareInfo { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startHardwareInfo(builder: FlatBufferBuilder) = builder.startTable(13) - @JvmStatic - fun addMcuId(builder: FlatBufferBuilder, mcuId: UShort) = builder.addShort(0, mcuId.toShort(), 0) - @JvmStatic - fun addDisplayName(builder: FlatBufferBuilder, displayName: Int) = builder.addOffset(1, displayName, 0) - @JvmStatic - fun addModel(builder: FlatBufferBuilder, model: Int) = builder.addOffset(2, model, 0) - @JvmStatic - fun addManufacturer(builder: FlatBufferBuilder, manufacturer: Int) = builder.addOffset(3, manufacturer, 0) - @JvmStatic - fun addHardwareRevision(builder: FlatBufferBuilder, hardwareRevision: Int) = builder.addOffset(4, hardwareRevision, 0) - @JvmStatic - fun addFirmwareVersion(builder: FlatBufferBuilder, firmwareVersion: Int) = builder.addOffset(5, firmwareVersion, 0) - @JvmStatic - fun addHardwareAddress(builder: FlatBufferBuilder, hardwareAddress: Int) = builder.addStruct(6, hardwareAddress, 0) - @JvmStatic - fun addIpAddress(builder: FlatBufferBuilder, ipAddress: Int) = builder.addStruct(7, ipAddress, 0) - @JvmStatic - fun addBoardType(builder: FlatBufferBuilder, boardType: Int) = builder.addOffset(8, boardType, 0) - @JvmStatic - fun addOfficialBoardType(builder: FlatBufferBuilder, officialBoardType: UShort) = builder.addShort(9, officialBoardType.toShort(), 0) - @JvmStatic - fun addHardwareIdentifier(builder: FlatBufferBuilder, hardwareIdentifier: Int) = builder.addOffset(10, hardwareIdentifier, 0) - @JvmStatic - fun addNetworkProtocolVersion(builder: FlatBufferBuilder, networkProtocolVersion: UShort) = builder.addShort(11, networkProtocolVersion.toShort(), 0) - @JvmStatic - fun addFirmwareDate(builder: FlatBufferBuilder, firmwareDate: Int) = builder.addOffset(12, firmwareDate, 0) - @JvmStatic - fun endHardwareInfo(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt deleted file mode 100644 index cb16786cc..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/HardwareStatus.kt +++ /dev/null @@ -1,146 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Mostly-dynamic status info about a tracked device's firmware - */ -@Suppress("unused") -class HardwareStatus : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HardwareStatus { - __init(_i, _bb) - return this - } - val errorStatus : UByte? - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else null - } - val ping : UShort? - get() { - val o = __offset(8) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else null - } - /** - * "Received Signal Strength Indicator" between device and wifi adapter in dBm - */ - val rssi : Short? - get() { - val o = __offset(10) - return if(o != 0) bb.getShort(o + bb_pos) else null - } - /** - * Temperature in degrees celsius - */ - val mcuTemp : Float? - get() { - val o = __offset(12) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val batteryVoltage : Float? - get() { - val o = __offset(14) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val batteryPctEstimate : UByte? - get() { - val o = __offset(16) - return if(o != 0) bb.get(o + bb_pos).toUByte() else null - } - val logData : solarxr_protocol.datatypes.LogData? get() = logData(solarxr_protocol.datatypes.LogData()) - fun logData(obj: solarxr_protocol.datatypes.LogData) : solarxr_protocol.datatypes.LogData? { - val o = __offset(18) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val packetLoss : Float? - get() { - val o = __offset(20) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val packetsLost : Int? - get() { - val o = __offset(22) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val packetsReceived : Int? - get() { - val o = __offset(24) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - /** - * Runtime estimate in microseconds - */ - val batteryRuntimeEstimate : Long? - get() { - val o = __offset(26) - return if(o != 0) bb.getLong(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHardwareStatus(_bb: ByteBuffer): HardwareStatus = getRootAsHardwareStatus(_bb, HardwareStatus()) - @JvmStatic - fun getRootAsHardwareStatus(_bb: ByteBuffer, obj: HardwareStatus): HardwareStatus { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createHardwareStatus(builder: FlatBufferBuilder, errorStatus: UByte?, ping: UShort?, rssi: Short?, mcuTemp: Float?, batteryVoltage: Float?, batteryPctEstimate: UByte?, logDataOffset: Int, packetLoss: Float?, packetsLost: Int?, packetsReceived: Int?, batteryRuntimeEstimate: Long?) : Int { - builder.startTable(12) - batteryRuntimeEstimate?.run { addBatteryRuntimeEstimate(builder, batteryRuntimeEstimate) } - packetsReceived?.run { addPacketsReceived(builder, packetsReceived) } - packetsLost?.run { addPacketsLost(builder, packetsLost) } - packetLoss?.run { addPacketLoss(builder, packetLoss) } - addLogData(builder, logDataOffset) - batteryVoltage?.run { addBatteryVoltage(builder, batteryVoltage) } - mcuTemp?.run { addMcuTemp(builder, mcuTemp) } - rssi?.run { addRssi(builder, rssi) } - ping?.run { addPing(builder, ping) } - batteryPctEstimate?.run { addBatteryPctEstimate(builder, batteryPctEstimate) } - errorStatus?.run { addErrorStatus(builder, errorStatus) } - return endHardwareStatus(builder) - } - @JvmStatic - fun startHardwareStatus(builder: FlatBufferBuilder) = builder.startTable(12) - @JvmStatic - fun addErrorStatus(builder: FlatBufferBuilder, errorStatus: UByte) = builder.addByte(0, errorStatus.toByte(), 0) - @JvmStatic - fun addPing(builder: FlatBufferBuilder, ping: UShort) = builder.addShort(2, ping.toShort(), 0) - @JvmStatic - fun addRssi(builder: FlatBufferBuilder, rssi: Short) = builder.addShort(3, rssi, 0) - @JvmStatic - fun addMcuTemp(builder: FlatBufferBuilder, mcuTemp: Float) = builder.addFloat(4, mcuTemp, 0.0) - @JvmStatic - fun addBatteryVoltage(builder: FlatBufferBuilder, batteryVoltage: Float) = builder.addFloat(5, batteryVoltage, 0.0) - @JvmStatic - fun addBatteryPctEstimate(builder: FlatBufferBuilder, batteryPctEstimate: UByte) = builder.addByte(6, batteryPctEstimate.toByte(), 0) - @JvmStatic - fun addLogData(builder: FlatBufferBuilder, logData: Int) = builder.addOffset(7, logData, 0) - @JvmStatic - fun addPacketLoss(builder: FlatBufferBuilder, packetLoss: Float) = builder.addFloat(8, packetLoss, 0.0) - @JvmStatic - fun addPacketsLost(builder: FlatBufferBuilder, packetsLost: Int) = builder.addInt(9, packetsLost, 0) - @JvmStatic - fun addPacketsReceived(builder: FlatBufferBuilder, packetsReceived: Int) = builder.addInt(10, packetsReceived, 0) - @JvmStatic - fun addBatteryRuntimeEstimate(builder: FlatBufferBuilder, batteryRuntimeEstimate: Long) = builder.addLong(11, batteryRuntimeEstimate, 0) - @JvmStatic - fun endHardwareStatus(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/McuType.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/McuType.kt deleted file mode 100644 index c6cd6dd5d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/McuType.kt +++ /dev/null @@ -1,21 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -@Suppress("unused") -class McuType private constructor() { - companion object { - const val Other: UShort = 0u - const val ESP8266: UShort = 1u - const val ESP32: UShort = 2u - const val OWOTRACKANDROID: UShort = 3u - const val WRANGLER: UShort = 4u - const val OWOTRACKIOS: UShort = 5u - const val ESP32C3: UShort = 6u - const val MOCOPI: UShort = 7u - const val HARITORA: UShort = 8u - const val NRF52: UShort = 9u - const val NRF54L: UShort = 10u - const val DEVRESERVED: UShort = 250u - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.kt deleted file mode 100644 index cb50a348e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/hardware_info/TrackerDataType.kt +++ /dev/null @@ -1,27 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.hardware_info - -/** - * What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. - */ -@Suppress("unused") -class TrackerDataType private constructor() { - companion object { - /** - * Rotation (e.g: IMUs or computed rotations in firmware) - */ - const val ROTATION: UByte = 0u - /** - * Flex resistance (e.g: raw data from flex sensors or unscaled angle on a single axis) - */ - const val FLEXRESISTANCE: UByte = 1u - /** - * Flex angle (e.g: computed angle from flex sensors or angle on a single axis) - */ - const val FLEXANGLE: UByte = 2u - val names : Array = arrayOf("ROTATION", "FLEX_RESISTANCE", "FLEX_ANGLE") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/math/Quat.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/math/Quat.kt deleted file mode 100644 index f9dc0c1d8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/math/Quat.kt +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.math - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class Quat : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Quat { - __init(_i, _bb) - return this - } - val x : Float get() = bb.getFloat(bb_pos + 0) - val y : Float get() = bb.getFloat(bb_pos + 4) - val z : Float get() = bb.getFloat(bb_pos + 8) - val w : Float get() = bb.getFloat(bb_pos + 12) - companion object { - @JvmStatic - fun createQuat(builder: FlatBufferBuilder, x: Float, y: Float, z: Float, w: Float) : Int { - builder.prep(4, 16) - builder.putFloat(w) - builder.putFloat(z) - builder.putFloat(y) - builder.putFloat(x) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/datatypes/math/Vec3f.kt b/protocol/kotlin/src/solarxr_protocol/datatypes/math/Vec3f.kt deleted file mode 100644 index 6974a1ca0..000000000 --- a/protocol/kotlin/src/solarxr_protocol/datatypes/math/Vec3f.kt +++ /dev/null @@ -1,32 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.datatypes.math - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class Vec3f : Struct() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Vec3f { - __init(_i, _bb) - return this - } - val x : Float get() = bb.getFloat(bb_pos + 0) - val y : Float get() = bb.getFloat(bb_pos + 4) - val z : Float get() = bb.getFloat(bb_pos + 8) - companion object { - @JvmStatic - fun createVec3f(builder: FlatBufferBuilder, x: Float, y: Float, z: Float) : Int { - builder.prep(4, 12) - builder.putFloat(z) - builder.putFloat(y) - builder.putFloat(x) - return builder.offset() - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/KeyValues.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/KeyValues.kt deleted file mode 100644 index 7d82dc7ad..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/KeyValues.kt +++ /dev/null @@ -1,92 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class KeyValues : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : KeyValues { - __init(_i, _bb) - return this - } - fun keys(j: Int) : String? { - val o = __offset(4) - return if (o != 0) { - __string(__vector(o) + j * 4) - } else { - null - } - } - val keysLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - fun values(j: Int) : String? { - val o = __offset(6) - return if (o != 0) { - __string(__vector(o) + j * 4) - } else { - null - } - } - val valuesLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsKeyValues(_bb: ByteBuffer): KeyValues = getRootAsKeyValues(_bb, KeyValues()) - @JvmStatic - fun getRootAsKeyValues(_bb: ByteBuffer, obj: KeyValues): KeyValues { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createKeyValues(builder: FlatBufferBuilder, keysOffset: Int, valuesOffset: Int) : Int { - builder.startTable(2) - addValues(builder, valuesOffset) - addKeys(builder, keysOffset) - return endKeyValues(builder) - } - @JvmStatic - fun startKeyValues(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addKeys(builder: FlatBufferBuilder, keys: Int) = builder.addOffset(0, keys, 0) - @JvmStatic - fun createKeysVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startKeysVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addValues(builder: FlatBufferBuilder, values: Int) = builder.addOffset(1, values, 0) - @JvmStatic - fun createValuesVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startValuesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endKeyValues(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/Message.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/Message.kt deleted file mode 100644 index 5a939e17d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/Message.kt +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Data that is sent from publishers to subscribers - */ -@Suppress("unused") -class Message : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : Message { - __init(_i, _bb) - return this - } - val topicType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun topic(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - val payloadType : UByte - get() { - val o = __offset(8) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun payload(obj: Table) : Table? { - val o = __offset(10); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsMessage(_bb: ByteBuffer): Message = getRootAsMessage(_bb, Message()) - @JvmStatic - fun getRootAsMessage(_bb: ByteBuffer, obj: Message): Message { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createMessage(builder: FlatBufferBuilder, topicType: UByte, topicOffset: Int, payloadType: UByte, payloadOffset: Int) : Int { - builder.startTable(4) - addPayload(builder, payloadOffset) - addTopic(builder, topicOffset) - addPayloadType(builder, payloadType) - addTopicType(builder, topicType) - return endMessage(builder) - } - @JvmStatic - fun startMessage(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addTopicType(builder: FlatBufferBuilder, topicType: UByte) = builder.addByte(0, topicType.toByte(), 0) - @JvmStatic - fun addTopic(builder: FlatBufferBuilder, topic: Int) = builder.addOffset(1, topic, 0) - @JvmStatic - fun addPayloadType(builder: FlatBufferBuilder, payloadType: UByte) = builder.addByte(2, payloadType.toByte(), 0) - @JvmStatic - fun addPayload(builder: FlatBufferBuilder, payload: Int) = builder.addOffset(3, payload, 0) - @JvmStatic - fun endMessage(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/Payload.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/Payload.kt deleted file mode 100644 index 0b6fdfdd4..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/Payload.kt +++ /dev/null @@ -1,16 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -@Suppress("unused") -class Payload private constructor() { - companion object { - const val NONE: UByte = 0u - const val solarxrProtocolDatatypesStringTable: UByte = 1u - const val solarxrProtocolDatatypesBytes: UByte = 2u - const val KeyValues: UByte = 3u - val names : Array = arrayOf("NONE", "solarxr_protocol_datatypes_StringTable", "solarxr_protocol_datatypes_Bytes", "KeyValues") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubHeader.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubHeader.kt deleted file mode 100644 index fdec3b39a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubHeader.kt +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class PubSubHeader : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : PubSubHeader { - __init(_i, _bb) - return this - } - val uType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun u(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsPubSubHeader(_bb: ByteBuffer): PubSubHeader = getRootAsPubSubHeader(_bb, PubSubHeader()) - @JvmStatic - fun getRootAsPubSubHeader(_bb: ByteBuffer, obj: PubSubHeader): PubSubHeader { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createPubSubHeader(builder: FlatBufferBuilder, uType: UByte, uOffset: Int) : Int { - builder.startTable(2) - addU(builder, uOffset) - addUType(builder, uType) - return endPubSubHeader(builder) - } - @JvmStatic - fun startPubSubHeader(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addUType(builder: FlatBufferBuilder, uType: UByte) = builder.addByte(0, uType.toByte(), 0) - @JvmStatic - fun addU(builder: FlatBufferBuilder, u: Int) = builder.addOffset(1, u, 0) - @JvmStatic - fun endPubSubHeader(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubUnion.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubUnion.kt deleted file mode 100644 index c028e24fd..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/PubSubUnion.kt +++ /dev/null @@ -1,17 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -@Suppress("unused") -class PubSubUnion private constructor() { - companion object { - const val NONE: UByte = 0u - const val Message: UByte = 1u - const val SubscriptionRequest: UByte = 2u - const val TopicHandleRequest: UByte = 3u - const val TopicMapping: UByte = 4u - val names : Array = arrayOf("NONE", "Message", "SubscriptionRequest", "TopicHandleRequest", "TopicMapping") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/SubscriptionRequest.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/SubscriptionRequest.kt deleted file mode 100644 index 0abd13d7f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/SubscriptionRequest.kt +++ /dev/null @@ -1,59 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Requests a subscription to `topic`. Replies with a `TopicMapping`. - */ -@Suppress("unused") -class SubscriptionRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SubscriptionRequest { - __init(_i, _bb) - return this - } - val topicType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun topic(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSubscriptionRequest(_bb: ByteBuffer): SubscriptionRequest = getRootAsSubscriptionRequest(_bb, SubscriptionRequest()) - @JvmStatic - fun getRootAsSubscriptionRequest(_bb: ByteBuffer, obj: SubscriptionRequest): SubscriptionRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSubscriptionRequest(builder: FlatBufferBuilder, topicType: UByte, topicOffset: Int) : Int { - builder.startTable(2) - addTopic(builder, topicOffset) - addTopicType(builder, topicType) - return endSubscriptionRequest(builder) - } - @JvmStatic - fun startSubscriptionRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addTopicType(builder: FlatBufferBuilder, topicType: UByte) = builder.addByte(0, topicType.toByte(), 0) - @JvmStatic - fun addTopic(builder: FlatBufferBuilder, topic: Int) = builder.addOffset(1, topic, 0) - @JvmStatic - fun endSubscriptionRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/Topic.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/Topic.kt deleted file mode 100644 index 78ef5083e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/Topic.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -@Suppress("unused") -class Topic private constructor() { - companion object { - const val NONE: UByte = 0u - const val TopicHandle: UByte = 1u - const val TopicId: UByte = 2u - val names : Array = arrayOf("NONE", "TopicHandle", "TopicId") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandle.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandle.kt deleted file mode 100644 index 405f3deca..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandle.kt +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A handle for the topic, allows referencing a topic without sending a huge - * `TopicId`. - */ -@Suppress("unused") -class TopicHandle : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TopicHandle { - __init(_i, _bb) - return this - } - val id : UShort - get() { - val o = __offset(4) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTopicHandle(_bb: ByteBuffer): TopicHandle = getRootAsTopicHandle(_bb, TopicHandle()) - @JvmStatic - fun getRootAsTopicHandle(_bb: ByteBuffer, obj: TopicHandle): TopicHandle { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTopicHandle(builder: FlatBufferBuilder, id: UShort) : Int { - builder.startTable(1) - addId(builder, id) - return endTopicHandle(builder) - } - @JvmStatic - fun startTopicHandle(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: UShort) = builder.addShort(0, id.toShort(), 0) - @JvmStatic - fun endTopicHandle(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandleRequest.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandleRequest.kt deleted file mode 100644 index 7ff6198a7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicHandleRequest.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing - * bandwidth, since `FeatureId` can be large. - */ -@Suppress("unused") -class TopicHandleRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TopicHandleRequest { - __init(_i, _bb) - return this - } - val id : solarxr_protocol.pub_sub.TopicId? get() = id(solarxr_protocol.pub_sub.TopicId()) - fun id(obj: solarxr_protocol.pub_sub.TopicId) : solarxr_protocol.pub_sub.TopicId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTopicHandleRequest(_bb: ByteBuffer): TopicHandleRequest = getRootAsTopicHandleRequest(_bb, TopicHandleRequest()) - @JvmStatic - fun getRootAsTopicHandleRequest(_bb: ByteBuffer, obj: TopicHandleRequest): TopicHandleRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTopicHandleRequest(builder: FlatBufferBuilder, idOffset: Int) : Int { - builder.startTable(1) - addId(builder, idOffset) - return endTopicHandleRequest(builder) - } - @JvmStatic - fun startTopicHandleRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: Int) = builder.addOffset(0, id, 0) - @JvmStatic - fun endTopicHandleRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicId.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicId.kt deleted file mode 100644 index e3ed16e6f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicId.kt +++ /dev/null @@ -1,91 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * A `TopicId` identifies an application-specific category of data. Because it - * is application-specific, it is up to the application within the specified - * organization to define its semantics/meaning. - * - * For example, "bob" may have an "overlay" app with a "settings" topic for controlling - * the overlay visibility and other settings, as well as a "video feed" topic for - * allowing other applications to display video data in a wrist mounted window in VR. - */ -@Suppress("unused") -class TopicId : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TopicId { - __init(_i, _bb) - return this - } - /** - * The organization/developer that defines the meaning of this feature. Avoids name - * clashes. Should be something unique - same idea as java package identifier. - */ - val organization : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val organizationAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun organizationInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - /** - * The name of the application/device. Should be unique within the organization. - */ - val appName : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val appNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun appNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - /** - * The name of the topic. Should be unique within the application. - */ - val topic : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val topicAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun topicInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTopicId(_bb: ByteBuffer): TopicId = getRootAsTopicId(_bb, TopicId()) - @JvmStatic - fun getRootAsTopicId(_bb: ByteBuffer, obj: TopicId): TopicId { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTopicId(builder: FlatBufferBuilder, organizationOffset: Int, appNameOffset: Int, topicOffset: Int) : Int { - builder.startTable(3) - addTopic(builder, topicOffset) - addAppName(builder, appNameOffset) - addOrganization(builder, organizationOffset) - return endTopicId(builder) - } - @JvmStatic - fun startTopicId(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addOrganization(builder: FlatBufferBuilder, organization: Int) = builder.addOffset(0, organization, 0) - @JvmStatic - fun addAppName(builder: FlatBufferBuilder, appName: Int) = builder.addOffset(1, appName, 0) - @JvmStatic - fun addTopic(builder: FlatBufferBuilder, topic: Int) = builder.addOffset(2, topic, 0) - @JvmStatic - fun endTopicId(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicMapping.kt b/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicMapping.kt deleted file mode 100644 index 20369942c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/pub_sub/TopicMapping.kt +++ /dev/null @@ -1,69 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.pub_sub - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Response for `TopicHandleRequest` or `SubscriptionRequest`. - */ -@Suppress("unused") -class TopicMapping : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TopicMapping { - __init(_i, _bb) - return this - } - val id : solarxr_protocol.pub_sub.TopicId? get() = id(solarxr_protocol.pub_sub.TopicId()) - fun id(obj: solarxr_protocol.pub_sub.TopicId) : solarxr_protocol.pub_sub.TopicId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val handle : solarxr_protocol.pub_sub.TopicHandle? get() = handle(solarxr_protocol.pub_sub.TopicHandle()) - fun handle(obj: solarxr_protocol.pub_sub.TopicHandle) : solarxr_protocol.pub_sub.TopicHandle? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTopicMapping(_bb: ByteBuffer): TopicMapping = getRootAsTopicMapping(_bb, TopicMapping()) - @JvmStatic - fun getRootAsTopicMapping(_bb: ByteBuffer, obj: TopicMapping): TopicMapping { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTopicMapping(builder: FlatBufferBuilder, idOffset: Int, handleOffset: Int) : Int { - builder.startTable(2) - addHandle(builder, handleOffset) - addId(builder, idOffset) - return endTopicMapping(builder) - } - @JvmStatic - fun startTopicMapping(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: Int) = builder.addOffset(0, id, 0) - @JvmStatic - fun addHandle(builder: FlatBufferBuilder, handle: Int) = builder.addOffset(1, handle, 0) - @JvmStatic - fun endTopicMapping(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AddUnknownDeviceRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AddUnknownDeviceRequest.kt deleted file mode 100644 index 7445f69aa..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AddUnknownDeviceRequest.kt +++ /dev/null @@ -1,52 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class AddUnknownDeviceRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AddUnknownDeviceRequest { - __init(_i, _bb) - return this - } - val macAddress : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val macAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun macAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAddUnknownDeviceRequest(_bb: ByteBuffer): AddUnknownDeviceRequest = getRootAsAddUnknownDeviceRequest(_bb, AddUnknownDeviceRequest()) - @JvmStatic - fun getRootAsAddUnknownDeviceRequest(_bb: ByteBuffer, obj: AddUnknownDeviceRequest): AddUnknownDeviceRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createAddUnknownDeviceRequest(builder: FlatBufferBuilder, macAddressOffset: Int) : Int { - builder.startTable(1) - addMacAddress(builder, macAddressOffset) - return endAddUnknownDeviceRequest(builder) - } - @JvmStatic - fun startAddUnknownDeviceRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addMacAddress(builder: FlatBufferBuilder, macAddress: Int) = builder.addOffset(0, macAddress, 0) - @JvmStatic - fun endAddUnknownDeviceRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ArmsMountingResetMode.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ArmsMountingResetMode.kt deleted file mode 100644 index 2f64f8bf7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ArmsMountingResetMode.kt +++ /dev/null @@ -1,28 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class ArmsMountingResetMode private constructor() { - companion object { - /** - * Upper arm going back and forearm going forward - */ - const val BACK: UByte = 0u - /** - * Arms going forward - */ - const val FORWARD: UByte = 1u - /** - * Arms going up to the sides into a tpose - */ - const val TPOSEUP: UByte = 2u - /** - * Arms going down to the sides from a tpose - */ - const val TPOSEDOWN: UByte = 3u - val names : Array = arrayOf("BACK", "FORWARD", "TPOSE_UP", "TPOSE_DOWN") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AssignTrackerRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AssignTrackerRequest.kt deleted file mode 100644 index 3febae0ff..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AssignTrackerRequest.kt +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class AssignTrackerRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AssignTrackerRequest { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val bodyPosition : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val mountingOrientation : solarxr_protocol.datatypes.math.Quat? get() = mountingOrientation(solarxr_protocol.datatypes.math.Quat()) - fun mountingOrientation(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - val displayName : String? - get() { - val o = __offset(10) - return if (o != 0) __string(o + bb_pos) else null - } - val displayNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1) - fun displayNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1) - val allowDriftCompensation : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAssignTrackerRequest(_bb: ByteBuffer): AssignTrackerRequest = getRootAsAssignTrackerRequest(_bb, AssignTrackerRequest()) - @JvmStatic - fun getRootAsAssignTrackerRequest(_bb: ByteBuffer, obj: AssignTrackerRequest): AssignTrackerRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startAssignTrackerRequest(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun addBodyPosition(builder: FlatBufferBuilder, bodyPosition: UByte) = builder.addByte(1, bodyPosition.toByte(), 0) - @JvmStatic - fun addMountingOrientation(builder: FlatBufferBuilder, mountingOrientation: Int) = builder.addStruct(2, mountingOrientation, 0) - @JvmStatic - fun addDisplayName(builder: FlatBufferBuilder, displayName: Int) = builder.addOffset(3, displayName, 0) - @JvmStatic - fun addAllowDriftCompensation(builder: FlatBufferBuilder, allowDriftCompensation: Boolean) = builder.addBoolean(4, allowDriftCompensation, false) - @JvmStatic - fun endAssignTrackerRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneApplyRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneApplyRequest.kt deleted file mode 100644 index 6ab3ef3be..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneApplyRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Applies the estimated proportions - */ -@Suppress("unused") -class AutoBoneApplyRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneApplyRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneApplyRequest(_bb: ByteBuffer): AutoBoneApplyRequest = getRootAsAutoBoneApplyRequest(_bb, AutoBoneApplyRequest()) - @JvmStatic - fun getRootAsAutoBoneApplyRequest(_bb: ByteBuffer, obj: AutoBoneApplyRequest): AutoBoneApplyRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startAutoBoneApplyRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endAutoBoneApplyRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneCancelRecordingRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneCancelRecordingRequest.kt deleted file mode 100644 index ee57c8bf8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneCancelRecordingRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Cancels the current recording, aborting the process and discarding the data - */ -@Suppress("unused") -class AutoBoneCancelRecordingRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneCancelRecordingRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneCancelRecordingRequest(_bb: ByteBuffer): AutoBoneCancelRecordingRequest = getRootAsAutoBoneCancelRecordingRequest(_bb, AutoBoneCancelRecordingRequest()) - @JvmStatic - fun getRootAsAutoBoneCancelRecordingRequest(_bb: ByteBuffer, obj: AutoBoneCancelRecordingRequest): AutoBoneCancelRecordingRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startAutoBoneCancelRecordingRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endAutoBoneCancelRecordingRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneEpochResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneEpochResponse.kt deleted file mode 100644 index aed1e4146..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneEpochResponse.kt +++ /dev/null @@ -1,98 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class AutoBoneEpochResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneEpochResponse { - __init(_i, _bb) - return this - } - val currentEpoch : UInt - get() { - val o = __offset(4) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - val totalEpochs : UInt - get() { - val o = __offset(6) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - /** - * The current error value. This can be any positive number, where lower is better. - */ - val epochError : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - /** - * A list of the current estimated body proportions. - */ - fun adjustedSkeletonParts(j: Int) : solarxr_protocol.rpc.SkeletonPart? = adjustedSkeletonParts(solarxr_protocol.rpc.SkeletonPart(), j) - fun adjustedSkeletonParts(obj: solarxr_protocol.rpc.SkeletonPart, j: Int) : solarxr_protocol.rpc.SkeletonPart? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val adjustedSkeletonPartsLength : Int - get() { - val o = __offset(10); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneEpochResponse(_bb: ByteBuffer): AutoBoneEpochResponse = getRootAsAutoBoneEpochResponse(_bb, AutoBoneEpochResponse()) - @JvmStatic - fun getRootAsAutoBoneEpochResponse(_bb: ByteBuffer, obj: AutoBoneEpochResponse): AutoBoneEpochResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createAutoBoneEpochResponse(builder: FlatBufferBuilder, currentEpoch: UInt, totalEpochs: UInt, epochError: Float, adjustedSkeletonPartsOffset: Int) : Int { - builder.startTable(4) - addAdjustedSkeletonParts(builder, adjustedSkeletonPartsOffset) - addEpochError(builder, epochError) - addTotalEpochs(builder, totalEpochs) - addCurrentEpoch(builder, currentEpoch) - return endAutoBoneEpochResponse(builder) - } - @JvmStatic - fun startAutoBoneEpochResponse(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addCurrentEpoch(builder: FlatBufferBuilder, currentEpoch: UInt) = builder.addInt(0, currentEpoch.toInt(), 0) - @JvmStatic - fun addTotalEpochs(builder: FlatBufferBuilder, totalEpochs: UInt) = builder.addInt(1, totalEpochs.toInt(), 0) - @JvmStatic - fun addEpochError(builder: FlatBufferBuilder, epochError: Float) = builder.addFloat(2, epochError, 0.0) - @JvmStatic - fun addAdjustedSkeletonParts(builder: FlatBufferBuilder, adjustedSkeletonParts: Int) = builder.addOffset(3, adjustedSkeletonParts, 0) - @JvmStatic - fun createAdjustedSkeletonPartsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startAdjustedSkeletonPartsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endAutoBoneEpochResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessRequest.kt deleted file mode 100644 index 184caaa24..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessRequest.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class AutoBoneProcessRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneProcessRequest { - __init(_i, _bb) - return this - } - val processType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneProcessRequest(_bb: ByteBuffer): AutoBoneProcessRequest = getRootAsAutoBoneProcessRequest(_bb, AutoBoneProcessRequest()) - @JvmStatic - fun getRootAsAutoBoneProcessRequest(_bb: ByteBuffer, obj: AutoBoneProcessRequest): AutoBoneProcessRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createAutoBoneProcessRequest(builder: FlatBufferBuilder, processType: UByte) : Int { - builder.startTable(1) - addProcessType(builder, processType) - return endAutoBoneProcessRequest(builder) - } - @JvmStatic - fun startAutoBoneProcessRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addProcessType(builder: FlatBufferBuilder, processType: UByte) = builder.addByte(0, processType.toByte(), 0) - @JvmStatic - fun endAutoBoneProcessRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.kt deleted file mode 100644 index 3b1cfe961..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessStatusResponse.kt +++ /dev/null @@ -1,105 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class AutoBoneProcessStatusResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneProcessStatusResponse { - __init(_i, _bb) - return this - } - val processType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * The current count. This value is -1 if there is nothing to report. - */ - val current : UInt - get() { - val o = __offset(8) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - /** - * The total count. This value is -1 if there is nothing to report. - */ - val total : UInt - get() { - val o = __offset(10) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - /** - * True if the operation has completed with any result, successful or not. - */ - val completed : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * True if the completed operation was successful, only observe if `completed` is true. - */ - val success : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * The time remaining in seconds. This value is -1 if there is nothing to report. - */ - val eta : Float - get() { - val o = __offset(16) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneProcessStatusResponse(_bb: ByteBuffer): AutoBoneProcessStatusResponse = getRootAsAutoBoneProcessStatusResponse(_bb, AutoBoneProcessStatusResponse()) - @JvmStatic - fun getRootAsAutoBoneProcessStatusResponse(_bb: ByteBuffer, obj: AutoBoneProcessStatusResponse): AutoBoneProcessStatusResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createAutoBoneProcessStatusResponse(builder: FlatBufferBuilder, processType: UByte, current: UInt, total: UInt, completed: Boolean, success: Boolean, eta: Float) : Int { - builder.startTable(7) - addEta(builder, eta) - addTotal(builder, total) - addCurrent(builder, current) - addSuccess(builder, success) - addCompleted(builder, completed) - addProcessType(builder, processType) - return endAutoBoneProcessStatusResponse(builder) - } - @JvmStatic - fun startAutoBoneProcessStatusResponse(builder: FlatBufferBuilder) = builder.startTable(7) - @JvmStatic - fun addProcessType(builder: FlatBufferBuilder, processType: UByte) = builder.addByte(0, processType.toByte(), 0) - @JvmStatic - fun addCurrent(builder: FlatBufferBuilder, current: UInt) = builder.addInt(2, current.toInt(), 0) - @JvmStatic - fun addTotal(builder: FlatBufferBuilder, total: UInt) = builder.addInt(3, total.toInt(), 0) - @JvmStatic - fun addCompleted(builder: FlatBufferBuilder, completed: Boolean) = builder.addBoolean(4, completed, false) - @JvmStatic - fun addSuccess(builder: FlatBufferBuilder, success: Boolean) = builder.addBoolean(5, success, false) - @JvmStatic - fun addEta(builder: FlatBufferBuilder, eta: Float) = builder.addFloat(6, eta, 0.0) - @JvmStatic - fun endAutoBoneProcessStatusResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessType.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessType.kt deleted file mode 100644 index 91f2c6149..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneProcessType.kt +++ /dev/null @@ -1,21 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class AutoBoneProcessType private constructor() { - companion object { - const val NONE: UByte = 0u - const val RECORD: UByte = 1u - const val SAVE: UByte = 2u - const val PROCESS: UByte = 3u - /** - * @deprecated - * Use AutoBoneApplyRequest instead - */ - const val APPLY: UByte = 4u - val names : Array = arrayOf("NONE", "RECORD", "SAVE", "PROCESS", "APPLY") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneSettings.kt deleted file mode 100644 index 2e84ff912..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneSettings.kt +++ /dev/null @@ -1,221 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt - */ -@Suppress("unused") -class AutoBoneSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneSettings { - __init(_i, _bb) - return this - } - val cursorIncrement : Int? - get() { - val o = __offset(4) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val minDataDistance : Int? - get() { - val o = __offset(6) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val maxDataDistance : Int? - get() { - val o = __offset(8) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val numEpochs : Int? - get() { - val o = __offset(10) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val printEveryNumEpochs : Int? - get() { - val o = __offset(12) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val initialAdjustRate : Float? - get() { - val o = __offset(14) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val adjustRateDecay : Float? - get() { - val o = __offset(16) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val slideErrorFactor : Float? - get() { - val o = __offset(18) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val offsetSlideErrorFactor : Float? - get() { - val o = __offset(20) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val footHeightOffsetErrorFactor : Float? - get() { - val o = __offset(22) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val bodyProportionErrorFactor : Float? - get() { - val o = __offset(24) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val heightErrorFactor : Float? - get() { - val o = __offset(26) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val positionErrorFactor : Float? - get() { - val o = __offset(28) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val positionOffsetErrorFactor : Float? - get() { - val o = __offset(30) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val calcInitError : Boolean? - get() { - val o = __offset(32) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val randomizeFrameOrder : Boolean? - get() { - val o = __offset(34) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val scaleEachStep : Boolean? - get() { - val o = __offset(36) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val sampleCount : Int? - get() { - val o = __offset(38) - return if(o != 0) bb.getInt(o + bb_pos) else null - } - val sampleRateMs : Long? - get() { - val o = __offset(40) - return if(o != 0) bb.getLong(o + bb_pos) else null - } - val saveRecordings : Boolean? - get() { - val o = __offset(42) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val useSkeletonHeight : Boolean? - get() { - val o = __offset(44) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val randSeed : Long? - get() { - val o = __offset(46) - return if(o != 0) bb.getLong(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneSettings(_bb: ByteBuffer): AutoBoneSettings = getRootAsAutoBoneSettings(_bb, AutoBoneSettings()) - @JvmStatic - fun getRootAsAutoBoneSettings(_bb: ByteBuffer, obj: AutoBoneSettings): AutoBoneSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createAutoBoneSettings(builder: FlatBufferBuilder, cursorIncrement: Int?, minDataDistance: Int?, maxDataDistance: Int?, numEpochs: Int?, printEveryNumEpochs: Int?, initialAdjustRate: Float?, adjustRateDecay: Float?, slideErrorFactor: Float?, offsetSlideErrorFactor: Float?, footHeightOffsetErrorFactor: Float?, bodyProportionErrorFactor: Float?, heightErrorFactor: Float?, positionErrorFactor: Float?, positionOffsetErrorFactor: Float?, calcInitError: Boolean?, randomizeFrameOrder: Boolean?, scaleEachStep: Boolean?, sampleCount: Int?, sampleRateMs: Long?, saveRecordings: Boolean?, useSkeletonHeight: Boolean?, randSeed: Long?) : Int { - builder.startTable(22) - randSeed?.run { addRandSeed(builder, randSeed) } - sampleRateMs?.run { addSampleRateMs(builder, sampleRateMs) } - sampleCount?.run { addSampleCount(builder, sampleCount) } - positionOffsetErrorFactor?.run { addPositionOffsetErrorFactor(builder, positionOffsetErrorFactor) } - positionErrorFactor?.run { addPositionErrorFactor(builder, positionErrorFactor) } - heightErrorFactor?.run { addHeightErrorFactor(builder, heightErrorFactor) } - bodyProportionErrorFactor?.run { addBodyProportionErrorFactor(builder, bodyProportionErrorFactor) } - footHeightOffsetErrorFactor?.run { addFootHeightOffsetErrorFactor(builder, footHeightOffsetErrorFactor) } - offsetSlideErrorFactor?.run { addOffsetSlideErrorFactor(builder, offsetSlideErrorFactor) } - slideErrorFactor?.run { addSlideErrorFactor(builder, slideErrorFactor) } - adjustRateDecay?.run { addAdjustRateDecay(builder, adjustRateDecay) } - initialAdjustRate?.run { addInitialAdjustRate(builder, initialAdjustRate) } - printEveryNumEpochs?.run { addPrintEveryNumEpochs(builder, printEveryNumEpochs) } - numEpochs?.run { addNumEpochs(builder, numEpochs) } - maxDataDistance?.run { addMaxDataDistance(builder, maxDataDistance) } - minDataDistance?.run { addMinDataDistance(builder, minDataDistance) } - cursorIncrement?.run { addCursorIncrement(builder, cursorIncrement) } - useSkeletonHeight?.run { addUseSkeletonHeight(builder, useSkeletonHeight) } - saveRecordings?.run { addSaveRecordings(builder, saveRecordings) } - scaleEachStep?.run { addScaleEachStep(builder, scaleEachStep) } - randomizeFrameOrder?.run { addRandomizeFrameOrder(builder, randomizeFrameOrder) } - calcInitError?.run { addCalcInitError(builder, calcInitError) } - return endAutoBoneSettings(builder) - } - @JvmStatic - fun startAutoBoneSettings(builder: FlatBufferBuilder) = builder.startTable(22) - @JvmStatic - fun addCursorIncrement(builder: FlatBufferBuilder, cursorIncrement: Int) = builder.addInt(0, cursorIncrement, 0) - @JvmStatic - fun addMinDataDistance(builder: FlatBufferBuilder, minDataDistance: Int) = builder.addInt(1, minDataDistance, 0) - @JvmStatic - fun addMaxDataDistance(builder: FlatBufferBuilder, maxDataDistance: Int) = builder.addInt(2, maxDataDistance, 0) - @JvmStatic - fun addNumEpochs(builder: FlatBufferBuilder, numEpochs: Int) = builder.addInt(3, numEpochs, 0) - @JvmStatic - fun addPrintEveryNumEpochs(builder: FlatBufferBuilder, printEveryNumEpochs: Int) = builder.addInt(4, printEveryNumEpochs, 0) - @JvmStatic - fun addInitialAdjustRate(builder: FlatBufferBuilder, initialAdjustRate: Float) = builder.addFloat(5, initialAdjustRate, 0.0) - @JvmStatic - fun addAdjustRateDecay(builder: FlatBufferBuilder, adjustRateDecay: Float) = builder.addFloat(6, adjustRateDecay, 0.0) - @JvmStatic - fun addSlideErrorFactor(builder: FlatBufferBuilder, slideErrorFactor: Float) = builder.addFloat(7, slideErrorFactor, 0.0) - @JvmStatic - fun addOffsetSlideErrorFactor(builder: FlatBufferBuilder, offsetSlideErrorFactor: Float) = builder.addFloat(8, offsetSlideErrorFactor, 0.0) - @JvmStatic - fun addFootHeightOffsetErrorFactor(builder: FlatBufferBuilder, footHeightOffsetErrorFactor: Float) = builder.addFloat(9, footHeightOffsetErrorFactor, 0.0) - @JvmStatic - fun addBodyProportionErrorFactor(builder: FlatBufferBuilder, bodyProportionErrorFactor: Float) = builder.addFloat(10, bodyProportionErrorFactor, 0.0) - @JvmStatic - fun addHeightErrorFactor(builder: FlatBufferBuilder, heightErrorFactor: Float) = builder.addFloat(11, heightErrorFactor, 0.0) - @JvmStatic - fun addPositionErrorFactor(builder: FlatBufferBuilder, positionErrorFactor: Float) = builder.addFloat(12, positionErrorFactor, 0.0) - @JvmStatic - fun addPositionOffsetErrorFactor(builder: FlatBufferBuilder, positionOffsetErrorFactor: Float) = builder.addFloat(13, positionOffsetErrorFactor, 0.0) - @JvmStatic - fun addCalcInitError(builder: FlatBufferBuilder, calcInitError: Boolean) = builder.addBoolean(14, calcInitError, false) - @JvmStatic - fun addRandomizeFrameOrder(builder: FlatBufferBuilder, randomizeFrameOrder: Boolean) = builder.addBoolean(15, randomizeFrameOrder, false) - @JvmStatic - fun addScaleEachStep(builder: FlatBufferBuilder, scaleEachStep: Boolean) = builder.addBoolean(16, scaleEachStep, false) - @JvmStatic - fun addSampleCount(builder: FlatBufferBuilder, sampleCount: Int) = builder.addInt(17, sampleCount, 0) - @JvmStatic - fun addSampleRateMs(builder: FlatBufferBuilder, sampleRateMs: Long) = builder.addLong(18, sampleRateMs, 0) - @JvmStatic - fun addSaveRecordings(builder: FlatBufferBuilder, saveRecordings: Boolean) = builder.addBoolean(19, saveRecordings, false) - @JvmStatic - fun addUseSkeletonHeight(builder: FlatBufferBuilder, useSkeletonHeight: Boolean) = builder.addBoolean(20, useSkeletonHeight, false) - @JvmStatic - fun addRandSeed(builder: FlatBufferBuilder, randSeed: Long) = builder.addLong(21, randSeed, 0) - @JvmStatic - fun endAutoBoneSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneStopRecordingRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneStopRecordingRequest.kt deleted file mode 100644 index 20c3fbe7d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/AutoBoneStopRecordingRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Stops the current recording, using it as far as it has been recorded - */ -@Suppress("unused") -class AutoBoneStopRecordingRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : AutoBoneStopRecordingRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsAutoBoneStopRecordingRequest(_bb: ByteBuffer): AutoBoneStopRecordingRequest = getRootAsAutoBoneStopRecordingRequest(_bb, AutoBoneStopRecordingRequest()) - @JvmStatic - fun getRootAsAutoBoneStopRecordingRequest(_bb: ByteBuffer, obj: AutoBoneStopRecordingRequest): AutoBoneStopRecordingRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startAutoBoneStopRecordingRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endAutoBoneStopRecordingRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/CancelUserHeightCalibration.kt b/protocol/kotlin/src/solarxr_protocol/rpc/CancelUserHeightCalibration.kt deleted file mode 100644 index ec5b1ec5a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/CancelUserHeightCalibration.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class CancelUserHeightCalibration : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : CancelUserHeightCalibration { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsCancelUserHeightCalibration(_bb: ByteBuffer): CancelUserHeightCalibration = getRootAsCancelUserHeightCalibration(_bb, CancelUserHeightCalibration()) - @JvmStatic - fun getRootAsCancelUserHeightCalibration(_bb: ByteBuffer, obj: CancelUserHeightCalibration): CancelUserHeightCalibration { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startCancelUserHeightCalibration(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endCancelUserHeightCalibration(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ChangeMagToggleRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ChangeMagToggleRequest.kt deleted file mode 100644 index f2f00323b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ChangeMagToggleRequest.kt +++ /dev/null @@ -1,65 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * If no tracker ID is given, it's the setting for every tracker/device - */ -@Suppress("unused") -class ChangeMagToggleRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ChangeMagToggleRequest { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val enable : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsChangeMagToggleRequest(_bb: ByteBuffer): ChangeMagToggleRequest = getRootAsChangeMagToggleRequest(_bb, ChangeMagToggleRequest()) - @JvmStatic - fun getRootAsChangeMagToggleRequest(_bb: ByteBuffer, obj: ChangeMagToggleRequest): ChangeMagToggleRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createChangeMagToggleRequest(builder: FlatBufferBuilder, trackerIdOffset: Int, enable: Boolean) : Int { - builder.startTable(2) - addTrackerId(builder, trackerIdOffset) - addEnable(builder, enable) - return endChangeMagToggleRequest(builder) - } - @JvmStatic - fun startChangeMagToggleRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun addEnable(builder: FlatBufferBuilder, enable: Boolean) = builder.addBoolean(1, enable, false) - @JvmStatic - fun endChangeMagToggleRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.kt deleted file mode 100644 index c429bbf27..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ChangeSkeletonConfigRequest.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ChangeSkeletonConfigRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ChangeSkeletonConfigRequest { - __init(_i, _bb) - return this - } - val bone : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val value : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsChangeSkeletonConfigRequest(_bb: ByteBuffer): ChangeSkeletonConfigRequest = getRootAsChangeSkeletonConfigRequest(_bb, ChangeSkeletonConfigRequest()) - @JvmStatic - fun getRootAsChangeSkeletonConfigRequest(_bb: ByteBuffer, obj: ChangeSkeletonConfigRequest): ChangeSkeletonConfigRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createChangeSkeletonConfigRequest(builder: FlatBufferBuilder, bone: UByte, value: Float) : Int { - builder.startTable(2) - addValue(builder, value) - addBone(builder, bone) - return endChangeSkeletonConfigRequest(builder) - } - @JvmStatic - fun startChangeSkeletonConfigRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addBone(builder: FlatBufferBuilder, bone: UByte) = builder.addByte(0, bone.toByte(), 0) - @JvmStatic - fun addValue(builder: FlatBufferBuilder, value: Float) = builder.addFloat(1, value, 0.0) - @JvmStatic - fun endChangeSkeletonConfigRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.kt deleted file mode 100644 index c81fa0e4c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ClearDriftCompensationRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ClearDriftCompensationRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ClearDriftCompensationRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsClearDriftCompensationRequest(_bb: ByteBuffer): ClearDriftCompensationRequest = getRootAsClearDriftCompensationRequest(_bb, ClearDriftCompensationRequest()) - @JvmStatic - fun getRootAsClearDriftCompensationRequest(_bb: ByteBuffer, obj: ClearDriftCompensationRequest): ClearDriftCompensationRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startClearDriftCompensationRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endClearDriftCompensationRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ClearMountingResetRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ClearMountingResetRequest.kt deleted file mode 100644 index 49b6d9e48..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ClearMountingResetRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Clears mounting reset data, defaulting to the manually set mounting orientations - */ -@Suppress("unused") -class ClearMountingResetRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ClearMountingResetRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsClearMountingResetRequest(_bb: ByteBuffer): ClearMountingResetRequest = getRootAsClearMountingResetRequest(_bb, ClearMountingResetRequest()) - @JvmStatic - fun getRootAsClearMountingResetRequest(_bb: ByteBuffer, obj: ClearMountingResetRequest): ClearMountingResetRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startClearMountingResetRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endClearMountingResetRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/CloseSerialRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/CloseSerialRequest.kt deleted file mode 100644 index c1bd9a199..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/CloseSerialRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class CloseSerialRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : CloseSerialRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsCloseSerialRequest(_bb: ByteBuffer): CloseSerialRequest = getRootAsCloseSerialRequest(_bb, CloseSerialRequest()) - @JvmStatic - fun getRootAsCloseSerialRequest(_bb: ByteBuffer, obj: CloseSerialRequest): CloseSerialRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startCloseSerialRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endCloseSerialRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ComputerDirectory.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ComputerDirectory.kt deleted file mode 100644 index 91540aa3a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ComputerDirectory.kt +++ /dev/null @@ -1,16 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -/** - * Common folders often used in computers for storing files - */ -@Suppress("unused") -class ComputerDirectory private constructor() { - companion object { - const val Documents: UByte = 0u - val names : Array = arrayOf("Documents") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/DetectStayAlignedRelaxedPoseRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/DetectStayAlignedRelaxedPoseRequest.kt deleted file mode 100644 index 4e97bc863..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/DetectStayAlignedRelaxedPoseRequest.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class DetectStayAlignedRelaxedPoseRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DetectStayAlignedRelaxedPoseRequest { - __init(_i, _bb) - return this - } - val pose : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDetectStayAlignedRelaxedPoseRequest(_bb: ByteBuffer): DetectStayAlignedRelaxedPoseRequest = getRootAsDetectStayAlignedRelaxedPoseRequest(_bb, DetectStayAlignedRelaxedPoseRequest()) - @JvmStatic - fun getRootAsDetectStayAlignedRelaxedPoseRequest(_bb: ByteBuffer, obj: DetectStayAlignedRelaxedPoseRequest): DetectStayAlignedRelaxedPoseRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDetectStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder, pose: UByte) : Int { - builder.startTable(1) - addPose(builder, pose) - return endDetectStayAlignedRelaxedPoseRequest(builder) - } - @JvmStatic - fun startDetectStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addPose(builder: FlatBufferBuilder, pose: UByte) = builder.addByte(0, pose.toByte(), 0) - @JvmStatic - fun endDetectStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/DriftCompensationSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/DriftCompensationSettings.kt deleted file mode 100644 index 5868ef060..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/DriftCompensationSettings.kt +++ /dev/null @@ -1,83 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Settings related to IMU yaw drift compensation - */ -@Suppress("unused") -class DriftCompensationSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : DriftCompensationSettings { - __init(_i, _bb) - return this - } - val enabled : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val prediction : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * 0 to 1. A higher value results in more yaw drift compensation - */ - val amount : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - /** - * Number of previous resets to take into account when calculating yaw drift - */ - val maxResets : UShort - get() { - val o = __offset(10) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsDriftCompensationSettings(_bb: ByteBuffer): DriftCompensationSettings = getRootAsDriftCompensationSettings(_bb, DriftCompensationSettings()) - @JvmStatic - fun getRootAsDriftCompensationSettings(_bb: ByteBuffer, obj: DriftCompensationSettings): DriftCompensationSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createDriftCompensationSettings(builder: FlatBufferBuilder, enabled: Boolean, prediction: Boolean, amount: Float, maxResets: UShort) : Int { - builder.startTable(4) - addAmount(builder, amount) - addMaxResets(builder, maxResets) - addPrediction(builder, prediction) - addEnabled(builder, enabled) - return endDriftCompensationSettings(builder) - } - @JvmStatic - fun startDriftCompensationSettings(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addEnabled(builder: FlatBufferBuilder, enabled: Boolean) = builder.addBoolean(0, enabled, false) - @JvmStatic - fun addPrediction(builder: FlatBufferBuilder, prediction: Boolean) = builder.addBoolean(1, prediction, false) - @JvmStatic - fun addAmount(builder: FlatBufferBuilder, amount: Float) = builder.addFloat(2, amount, 0.0) - @JvmStatic - fun addMaxResets(builder: FlatBufferBuilder, maxResets: UShort) = builder.addShort(3, maxResets.toShort(), 0) - @JvmStatic - fun endDriftCompensationSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/EnableStayAlignedRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/EnableStayAlignedRequest.kt deleted file mode 100644 index 2edca81e3..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/EnableStayAlignedRequest.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class EnableStayAlignedRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : EnableStayAlignedRequest { - __init(_i, _bb) - return this - } - val enable : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsEnableStayAlignedRequest(_bb: ByteBuffer): EnableStayAlignedRequest = getRootAsEnableStayAlignedRequest(_bb, EnableStayAlignedRequest()) - @JvmStatic - fun getRootAsEnableStayAlignedRequest(_bb: ByteBuffer, obj: EnableStayAlignedRequest): EnableStayAlignedRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createEnableStayAlignedRequest(builder: FlatBufferBuilder, enable: Boolean) : Int { - builder.startTable(1) - addEnable(builder, enable) - return endEnableStayAlignedRequest(builder) - } - @JvmStatic - fun startEnableStayAlignedRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addEnable(builder: FlatBufferBuilder, enable: Boolean) = builder.addBoolean(0, enable, false) - @JvmStatic - fun endEnableStayAlignedRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FilteringSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FilteringSettings.kt deleted file mode 100644 index c2bd3e37e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FilteringSettings.kt +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class FilteringSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FilteringSettings { - __init(_i, _bb) - return this - } - val type : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * 0 to 1. A higher value results in more smoothing or prediction - */ - val amount : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFilteringSettings(_bb: ByteBuffer): FilteringSettings = getRootAsFilteringSettings(_bb, FilteringSettings()) - @JvmStatic - fun getRootAsFilteringSettings(_bb: ByteBuffer, obj: FilteringSettings): FilteringSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createFilteringSettings(builder: FlatBufferBuilder, type: UByte, amount: Float) : Int { - builder.startTable(2) - addAmount(builder, amount) - addType(builder, type) - return endFilteringSettings(builder) - } - @JvmStatic - fun startFilteringSettings(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addType(builder: FlatBufferBuilder, type: UByte) = builder.addByte(0, type.toByte(), 0) - @JvmStatic - fun addAmount(builder: FlatBufferBuilder, amount: Float) = builder.addFloat(1, amount, 0.0) - @JvmStatic - fun endFilteringSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwarePart.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwarePart.kt deleted file mode 100644 index 4d29cfdfc..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwarePart.kt +++ /dev/null @@ -1,80 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class FirmwarePart : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FirmwarePart { - __init(_i, _bb) - return this - } - /** - * Url of the firmware bin to download - */ - val url : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val urlAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun urlInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - /** - * Offset of the firmware, used when flashing to the mcu, it indicates where to write this file in memory - * Will be ignored in the case of OTA flashing - */ - val offset : UInt - get() { - val o = __offset(6) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - /** - * Checksum of the file - */ - val digest : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val digestAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun digestInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFirmwarePart(_bb: ByteBuffer): FirmwarePart = getRootAsFirmwarePart(_bb, FirmwarePart()) - @JvmStatic - fun getRootAsFirmwarePart(_bb: ByteBuffer, obj: FirmwarePart): FirmwarePart { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createFirmwarePart(builder: FlatBufferBuilder, urlOffset: Int, offset: UInt, digestOffset: Int) : Int { - builder.startTable(3) - addDigest(builder, digestOffset) - addOffset(builder, offset) - addUrl(builder, urlOffset) - return endFirmwarePart(builder) - } - @JvmStatic - fun startFirmwarePart(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addUrl(builder: FlatBufferBuilder, url: Int) = builder.addOffset(0, url, 0) - @JvmStatic - fun addOffset(builder: FlatBufferBuilder, offset: UInt) = builder.addInt(1, offset.toInt(), 0) - @JvmStatic - fun addDigest(builder: FlatBufferBuilder, digest: Int) = builder.addOffset(2, digest, 0) - @JvmStatic - fun endFirmwarePart(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.kt deleted file mode 100644 index 51104e343..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateDeviceId.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class FirmwareUpdateDeviceId private constructor() { - companion object { - const val NONE: UByte = 0u - const val solarxrProtocolDatatypesDeviceIdTable: UByte = 1u - const val SerialDevicePort: UByte = 2u - val names : Array = arrayOf("NONE", "solarxr_protocol_datatypes_DeviceIdTable", "SerialDevicePort") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateMethod.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateMethod.kt deleted file mode 100644 index aad7a1639..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateMethod.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class FirmwareUpdateMethod private constructor() { - companion object { - const val NONE: UByte = 0u - const val OTAFirmwareUpdate: UByte = 1u - const val SerialFirmwareUpdate: UByte = 2u - val names : Array = arrayOf("NONE", "OTAFirmwareUpdate", "SerialFirmwareUpdate") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateRequest.kt deleted file mode 100644 index a09cb6acf..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateRequest.kt +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class FirmwareUpdateRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FirmwareUpdateRequest { - __init(_i, _bb) - return this - } - val methodType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun method(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFirmwareUpdateRequest(_bb: ByteBuffer): FirmwareUpdateRequest = getRootAsFirmwareUpdateRequest(_bb, FirmwareUpdateRequest()) - @JvmStatic - fun getRootAsFirmwareUpdateRequest(_bb: ByteBuffer, obj: FirmwareUpdateRequest): FirmwareUpdateRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createFirmwareUpdateRequest(builder: FlatBufferBuilder, methodType: UByte, methodOffset: Int) : Int { - builder.startTable(2) - addMethod(builder, methodOffset) - addMethodType(builder, methodType) - return endFirmwareUpdateRequest(builder) - } - @JvmStatic - fun startFirmwareUpdateRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addMethodType(builder: FlatBufferBuilder, methodType: UByte) = builder.addByte(0, methodType.toByte(), 0) - @JvmStatic - fun addMethod(builder: FlatBufferBuilder, method: Int) = builder.addOffset(1, method, 0) - @JvmStatic - fun endFirmwareUpdateRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt deleted file mode 100644 index 9cb442916..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class FirmwareUpdateStatus private constructor() { - companion object { - /** - * The server is downloading the firmware - */ - const val DOWNLOADING: UByte = 0u - /** - * The server is waiting for the tracker to be rebooted by the user - * Note that is is not the same as REBOOTING - */ - const val NEEDMANUALREBOOT: UByte = 1u - /** - * The server tries to authenticate with the MCU - */ - const val AUTHENTICATING: UByte = 2u - /** - * The server is uploading the firmware to the Device - */ - const val UPLOADING: UByte = 3u - /** - * The serial flasher tries to sync with the MCU - * You can use this event to prompt the user to press the boot btn - */ - const val SYNCINGWITHMCU: UByte = 4u - /** - * The MCU is rebooting - */ - const val REBOOTING: UByte = 5u - /** - * The server is provisioning the tracker - */ - const val PROVISIONING: UByte = 6u - const val DONE: UByte = 7u - /** - * Could not find the device - */ - const val ERRORDEVICENOTFOUND: UByte = 8u - /** - * The operation timed out, > 1min - */ - const val ERRORTIMEOUT: UByte = 9u - /** - * The firmware download failed - */ - const val ERRORDOWNLOADFAILED: UByte = 10u - /** - * The server could not authenticate with the MCU - */ - const val ERRORAUTHENTICATIONFAILED: UByte = 11u - /** - * Could not upload the firmware to the MCU - */ - const val ERRORUPLOADFAILED: UByte = 12u - /** - * The provision of the tracker failed, usually wifi credentials - */ - const val ERRORPROVISIONINGFAILED: UByte = 13u - /** - * An unsupported Flashing method was used - */ - const val ERRORUNSUPPORTEDMETHOD: UByte = 14u - const val ERRORUNKNOWN: UByte = 15u - val names : Array = arrayOf("DOWNLOADING", "NEED_MANUAL_REBOOT", "AUTHENTICATING", "UPLOADING", "SYNCING_WITH_MCU", "REBOOTING", "PROVISIONING", "DONE", "ERROR_DEVICE_NOT_FOUND", "ERROR_TIMEOUT", "ERROR_DOWNLOAD_FAILED", "ERROR_AUTHENTICATION_FAILED", "ERROR_UPLOAD_FAILED", "ERROR_PROVISIONING_FAILED", "ERROR_UNSUPPORTED_METHOD", "ERROR_UNKNOWN") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.kt deleted file mode 100644 index 6fa7e52bc..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatusResponse.kt +++ /dev/null @@ -1,75 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class FirmwareUpdateStatusResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FirmwareUpdateStatusResponse { - __init(_i, _bb) - return this - } - val deviceIdType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun deviceId(obj: Table) : Table? { - val o = __offset(6); return if (o != 0) __union(obj, o + bb_pos) else null - } - val status : UByte - get() { - val o = __offset(8) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * from 0 to 100 - */ - val progress : Byte - get() { - val o = __offset(10) - return if(o != 0) bb.get(o + bb_pos) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFirmwareUpdateStatusResponse(_bb: ByteBuffer): FirmwareUpdateStatusResponse = getRootAsFirmwareUpdateStatusResponse(_bb, FirmwareUpdateStatusResponse()) - @JvmStatic - fun getRootAsFirmwareUpdateStatusResponse(_bb: ByteBuffer, obj: FirmwareUpdateStatusResponse): FirmwareUpdateStatusResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createFirmwareUpdateStatusResponse(builder: FlatBufferBuilder, deviceIdType: UByte, deviceIdOffset: Int, status: UByte, progress: Byte) : Int { - builder.startTable(4) - addDeviceId(builder, deviceIdOffset) - addProgress(builder, progress) - addStatus(builder, status) - addDeviceIdType(builder, deviceIdType) - return endFirmwareUpdateStatusResponse(builder) - } - @JvmStatic - fun startFirmwareUpdateStatusResponse(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addDeviceIdType(builder: FlatBufferBuilder, deviceIdType: UByte) = builder.addByte(0, deviceIdType.toByte(), 0) - @JvmStatic - fun addDeviceId(builder: FlatBufferBuilder, deviceId: Int) = builder.addOffset(1, deviceId, 0) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(2, status.toByte(), 0) - @JvmStatic - fun addProgress(builder: FlatBufferBuilder, progress: Byte) = builder.addByte(3, progress, 0) - @JvmStatic - fun endFirmwareUpdateStatusResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStopQueuesRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStopQueuesRequest.kt deleted file mode 100644 index 2e9d80496..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStopQueuesRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class FirmwareUpdateStopQueuesRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : FirmwareUpdateStopQueuesRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsFirmwareUpdateStopQueuesRequest(_bb: ByteBuffer): FirmwareUpdateStopQueuesRequest = getRootAsFirmwareUpdateStopQueuesRequest(_bb, FirmwareUpdateStopQueuesRequest()) - @JvmStatic - fun getRootAsFirmwareUpdateStopQueuesRequest(_bb: ByteBuffer, obj: FirmwareUpdateStopQueuesRequest): FirmwareUpdateStopQueuesRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startFirmwareUpdateStopQueuesRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endFirmwareUpdateStopQueuesRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ForgetDeviceRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ForgetDeviceRequest.kt deleted file mode 100644 index 5060d7105..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ForgetDeviceRequest.kt +++ /dev/null @@ -1,52 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ForgetDeviceRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ForgetDeviceRequest { - __init(_i, _bb) - return this - } - val macAddress : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val macAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun macAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsForgetDeviceRequest(_bb: ByteBuffer): ForgetDeviceRequest = getRootAsForgetDeviceRequest(_bb, ForgetDeviceRequest()) - @JvmStatic - fun getRootAsForgetDeviceRequest(_bb: ByteBuffer, obj: ForgetDeviceRequest): ForgetDeviceRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createForgetDeviceRequest(builder: FlatBufferBuilder, macAddressOffset: Int) : Int { - builder.startTable(1) - addMacAddress(builder, macAddressOffset) - return endForgetDeviceRequest(builder) - } - @JvmStatic - fun startForgetDeviceRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addMacAddress(builder: FlatBufferBuilder, macAddress: Int) = builder.addOffset(0, macAddress, 0) - @JvmStatic - fun endForgetDeviceRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HIDSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HIDSettings.kt deleted file mode 100644 index 932b8df6a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/HIDSettings.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class HIDSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HIDSettings { - __init(_i, _bb) - return this - } - val trackersOverHid : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHIDSettings(_bb: ByteBuffer): HIDSettings = getRootAsHIDSettings(_bb, HIDSettings()) - @JvmStatic - fun getRootAsHIDSettings(_bb: ByteBuffer, obj: HIDSettings): HIDSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createHIDSettings(builder: FlatBufferBuilder, trackersOverHid: Boolean) : Int { - builder.startTable(1) - addTrackersOverHID(builder, trackersOverHid) - return endHIDSettings(builder) - } - @JvmStatic - fun startHIDSettings(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackersOverHID(builder: FlatBufferBuilder, trackersOverHid: Boolean) = builder.addBoolean(0, trackersOverHid, false) - @JvmStatic - fun endHIDSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatRequest.kt deleted file mode 100644 index 09b71013f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class HeartbeatRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HeartbeatRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHeartbeatRequest(_bb: ByteBuffer): HeartbeatRequest = getRootAsHeartbeatRequest(_bb, HeartbeatRequest()) - @JvmStatic - fun getRootAsHeartbeatRequest(_bb: ByteBuffer, obj: HeartbeatRequest): HeartbeatRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startHeartbeatRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endHeartbeatRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatResponse.kt deleted file mode 100644 index 8ddc4c2db..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/HeartbeatResponse.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class HeartbeatResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HeartbeatResponse { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHeartbeatResponse(_bb: ByteBuffer): HeartbeatResponse = getRootAsHeartbeatResponse(_bb, HeartbeatResponse()) - @JvmStatic - fun getRootAsHeartbeatResponse(_bb: ByteBuffer, obj: HeartbeatResponse): HeartbeatResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startHeartbeatResponse(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endHeartbeatResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HeightRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HeightRequest.kt deleted file mode 100644 index f7305eab4..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/HeightRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class HeightRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HeightRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHeightRequest(_bb: ByteBuffer): HeightRequest = getRootAsHeightRequest(_bb, HeightRequest()) - @JvmStatic - fun getRootAsHeightRequest(_bb: ByteBuffer, obj: HeightRequest): HeightRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startHeightRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endHeightRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HeightResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HeightResponse.kt deleted file mode 100644 index e5a63e299..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/HeightResponse.kt +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Returns the current min and max positional tracker heights - */ -@Suppress("unused") -class HeightResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : HeightResponse { - __init(_i, _bb) - return this - } - val minHeight : Float - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val maxHeight : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsHeightResponse(_bb: ByteBuffer): HeightResponse = getRootAsHeightResponse(_bb, HeightResponse()) - @JvmStatic - fun getRootAsHeightResponse(_bb: ByteBuffer, obj: HeightResponse): HeightResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createHeightResponse(builder: FlatBufferBuilder, minHeight: Float, maxHeight: Float) : Int { - builder.startTable(2) - addMaxHeight(builder, maxHeight) - addMinHeight(builder, minHeight) - return endHeightResponse(builder) - } - @JvmStatic - fun startHeightResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addMinHeight(builder: FlatBufferBuilder, minHeight: Float) = builder.addFloat(0, minHeight, 0.0) - @JvmStatic - fun addMaxHeight(builder: FlatBufferBuilder, maxHeight: Float) = builder.addFloat(1, maxHeight, 0.0) - @JvmStatic - fun endHeightResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt deleted file mode 100644 index 29d07ec89..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class IgnoreTrackingChecklistStepRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : IgnoreTrackingChecklistStepRequest { - __init(_i, _bb) - return this - } - val stepId : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val ignore : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsIgnoreTrackingChecklistStepRequest(_bb: ByteBuffer): IgnoreTrackingChecklistStepRequest = getRootAsIgnoreTrackingChecklistStepRequest(_bb, IgnoreTrackingChecklistStepRequest()) - @JvmStatic - fun getRootAsIgnoreTrackingChecklistStepRequest(_bb: ByteBuffer, obj: IgnoreTrackingChecklistStepRequest): IgnoreTrackingChecklistStepRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder, stepId: UByte, ignore: Boolean) : Int { - builder.startTable(2) - addIgnore(builder, ignore) - addStepId(builder, stepId) - return endIgnoreTrackingChecklistStepRequest(builder) - } - @JvmStatic - fun startIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addStepId(builder: FlatBufferBuilder, stepId: UByte) = builder.addByte(0, stepId.toByte(), 0) - @JvmStatic - fun addIgnore(builder: FlatBufferBuilder, ignore: Boolean) = builder.addBoolean(1, ignore, false) - @JvmStatic - fun endIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpChange.kt b/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpChange.kt deleted file mode 100644 index 39319711d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpChange.kt +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Makes a temporary change to legtweaks. This is not saved to disk, and can be - * cleared with `LegTweaksTmpClear` - */ -@Suppress("unused") -class LegTweaksTmpChange : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : LegTweaksTmpChange { - __init(_i, _bb) - return this - } - val floorClip : Boolean? - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val skatingCorrection : Boolean? - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val toeSnap : Boolean? - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val footPlant : Boolean? - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsLegTweaksTmpChange(_bb: ByteBuffer): LegTweaksTmpChange = getRootAsLegTweaksTmpChange(_bb, LegTweaksTmpChange()) - @JvmStatic - fun getRootAsLegTweaksTmpChange(_bb: ByteBuffer, obj: LegTweaksTmpChange): LegTweaksTmpChange { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createLegTweaksTmpChange(builder: FlatBufferBuilder, floorClip: Boolean?, skatingCorrection: Boolean?, toeSnap: Boolean?, footPlant: Boolean?) : Int { - builder.startTable(4) - footPlant?.run { addFootPlant(builder, footPlant) } - toeSnap?.run { addToeSnap(builder, toeSnap) } - skatingCorrection?.run { addSkatingCorrection(builder, skatingCorrection) } - floorClip?.run { addFloorClip(builder, floorClip) } - return endLegTweaksTmpChange(builder) - } - @JvmStatic - fun startLegTweaksTmpChange(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addFloorClip(builder: FlatBufferBuilder, floorClip: Boolean) = builder.addBoolean(0, floorClip, false) - @JvmStatic - fun addSkatingCorrection(builder: FlatBufferBuilder, skatingCorrection: Boolean) = builder.addBoolean(1, skatingCorrection, false) - @JvmStatic - fun addToeSnap(builder: FlatBufferBuilder, toeSnap: Boolean) = builder.addBoolean(2, toeSnap, false) - @JvmStatic - fun addFootPlant(builder: FlatBufferBuilder, footPlant: Boolean) = builder.addBoolean(3, footPlant, false) - @JvmStatic - fun endLegTweaksTmpChange(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpClear.kt b/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpClear.kt deleted file mode 100644 index c40b28505..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/LegTweaksTmpClear.kt +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Clears the legtweaks temporary state back to what the config has. - * Setting a field to `true` will reset that field. - */ -@Suppress("unused") -class LegTweaksTmpClear : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : LegTweaksTmpClear { - __init(_i, _bb) - return this - } - val floorClip : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val skatingCorrection : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val toeSnap : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val footPlant : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsLegTweaksTmpClear(_bb: ByteBuffer): LegTweaksTmpClear = getRootAsLegTweaksTmpClear(_bb, LegTweaksTmpClear()) - @JvmStatic - fun getRootAsLegTweaksTmpClear(_bb: ByteBuffer, obj: LegTweaksTmpClear): LegTweaksTmpClear { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createLegTweaksTmpClear(builder: FlatBufferBuilder, floorClip: Boolean, skatingCorrection: Boolean, toeSnap: Boolean, footPlant: Boolean) : Int { - builder.startTable(4) - addFootPlant(builder, footPlant) - addToeSnap(builder, toeSnap) - addSkatingCorrection(builder, skatingCorrection) - addFloorClip(builder, floorClip) - return endLegTweaksTmpClear(builder) - } - @JvmStatic - fun startLegTweaksTmpClear(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addFloorClip(builder: FlatBufferBuilder, floorClip: Boolean) = builder.addBoolean(0, floorClip, false) - @JvmStatic - fun addSkatingCorrection(builder: FlatBufferBuilder, skatingCorrection: Boolean) = builder.addBoolean(1, skatingCorrection, false) - @JvmStatic - fun addToeSnap(builder: FlatBufferBuilder, toeSnap: Boolean) = builder.addBoolean(2, toeSnap, false) - @JvmStatic - fun addFootPlant(builder: FlatBufferBuilder, footPlant: Boolean) = builder.addBoolean(3, footPlant, false) - @JvmStatic - fun endLegTweaksTmpClear(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleRequest.kt deleted file mode 100644 index 9161c480d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleRequest.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * If no tracker ID is given, it's the setting for every tracker/device - */ -@Suppress("unused") -class MagToggleRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : MagToggleRequest { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsMagToggleRequest(_bb: ByteBuffer): MagToggleRequest = getRootAsMagToggleRequest(_bb, MagToggleRequest()) - @JvmStatic - fun getRootAsMagToggleRequest(_bb: ByteBuffer, obj: MagToggleRequest): MagToggleRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createMagToggleRequest(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endMagToggleRequest(builder) - } - @JvmStatic - fun startMagToggleRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun endMagToggleRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleResponse.kt deleted file mode 100644 index 0cd996a68..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/MagToggleResponse.kt +++ /dev/null @@ -1,65 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * If no tracker ID is given, it's the setting for every tracker/device - */ -@Suppress("unused") -class MagToggleResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : MagToggleResponse { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val enable : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsMagToggleResponse(_bb: ByteBuffer): MagToggleResponse = getRootAsMagToggleResponse(_bb, MagToggleResponse()) - @JvmStatic - fun getRootAsMagToggleResponse(_bb: ByteBuffer, obj: MagToggleResponse): MagToggleResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createMagToggleResponse(builder: FlatBufferBuilder, trackerIdOffset: Int, enable: Boolean) : Int { - builder.startTable(2) - addTrackerId(builder, trackerIdOffset) - addEnable(builder, enable) - return endMagToggleResponse(builder) - } - @JvmStatic - fun startMagToggleResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun addEnable(builder: FlatBufferBuilder, enable: Boolean) = builder.addBoolean(1, enable, false) - @JvmStatic - fun endMagToggleResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/NewSerialDeviceResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/NewSerialDeviceResponse.kt deleted file mode 100644 index 5df5f36a2..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/NewSerialDeviceResponse.kt +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class NewSerialDeviceResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : NewSerialDeviceResponse { - __init(_i, _bb) - return this - } - val device : solarxr_protocol.rpc.SerialDevice? get() = device(solarxr_protocol.rpc.SerialDevice()) - fun device(obj: solarxr_protocol.rpc.SerialDevice) : solarxr_protocol.rpc.SerialDevice? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsNewSerialDeviceResponse(_bb: ByteBuffer): NewSerialDeviceResponse = getRootAsNewSerialDeviceResponse(_bb, NewSerialDeviceResponse()) - @JvmStatic - fun getRootAsNewSerialDeviceResponse(_bb: ByteBuffer, obj: NewSerialDeviceResponse): NewSerialDeviceResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createNewSerialDeviceResponse(builder: FlatBufferBuilder, deviceOffset: Int) : Int { - builder.startTable(1) - addDevice(builder, deviceOffset) - return endNewSerialDeviceResponse(builder) - } - @JvmStatic - fun startNewSerialDeviceResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addDevice(builder: FlatBufferBuilder, device: Int) = builder.addOffset(0, device, 0) - @JvmStatic - fun endNewSerialDeviceResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OSCRouterSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OSCRouterSettings.kt deleted file mode 100644 index 230e46124..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OSCRouterSettings.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. - */ -@Suppress("unused") -class OSCRouterSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OSCRouterSettings { - __init(_i, _bb) - return this - } - val oscSettings : solarxr_protocol.rpc.OSCSettings? get() = oscSettings(solarxr_protocol.rpc.OSCSettings()) - fun oscSettings(obj: solarxr_protocol.rpc.OSCSettings) : solarxr_protocol.rpc.OSCSettings? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOSCRouterSettings(_bb: ByteBuffer): OSCRouterSettings = getRootAsOSCRouterSettings(_bb, OSCRouterSettings()) - @JvmStatic - fun getRootAsOSCRouterSettings(_bb: ByteBuffer, obj: OSCRouterSettings): OSCRouterSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOSCRouterSettings(builder: FlatBufferBuilder, oscSettingsOffset: Int) : Int { - builder.startTable(1) - addOscSettings(builder, oscSettingsOffset) - return endOSCRouterSettings(builder) - } - @JvmStatic - fun startOSCRouterSettings(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addOscSettings(builder: FlatBufferBuilder, oscSettings: Int) = builder.addOffset(0, oscSettings, 0) - @JvmStatic - fun endOSCRouterSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OSCSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OSCSettings.kt deleted file mode 100644 index e942d084f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OSCSettings.kt +++ /dev/null @@ -1,79 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * OSC Settings that are used in *any* osc application. - */ -@Suppress("unused") -class OSCSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OSCSettings { - __init(_i, _bb) - return this - } - val enabled : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val portIn : UShort - get() { - val o = __offset(6) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - val portOut : UShort - get() { - val o = __offset(8) - return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u - } - val address : String? - get() { - val o = __offset(10) - return if (o != 0) __string(o + bb_pos) else null - } - val addressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1) - fun addressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOSCSettings(_bb: ByteBuffer): OSCSettings = getRootAsOSCSettings(_bb, OSCSettings()) - @JvmStatic - fun getRootAsOSCSettings(_bb: ByteBuffer, obj: OSCSettings): OSCSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOSCSettings(builder: FlatBufferBuilder, enabled: Boolean, portIn: UShort, portOut: UShort, addressOffset: Int) : Int { - builder.startTable(4) - addAddress(builder, addressOffset) - addPortOut(builder, portOut) - addPortIn(builder, portIn) - addEnabled(builder, enabled) - return endOSCSettings(builder) - } - @JvmStatic - fun startOSCSettings(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addEnabled(builder: FlatBufferBuilder, enabled: Boolean) = builder.addBoolean(0, enabled, false) - @JvmStatic - fun addPortIn(builder: FlatBufferBuilder, portIn: UShort) = builder.addShort(1, portIn.toShort(), 0) - @JvmStatic - fun addPortOut(builder: FlatBufferBuilder, portOut: UShort) = builder.addShort(2, portOut.toShort(), 0) - @JvmStatic - fun addAddress(builder: FlatBufferBuilder, address: Int) = builder.addOffset(3, address, 0) - @JvmStatic - fun endOSCSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OSCTrackersSetting.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OSCTrackersSetting.kt deleted file mode 100644 index f179aca35..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OSCTrackersSetting.kt +++ /dev/null @@ -1,98 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class OSCTrackersSetting : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OSCTrackersSetting { - __init(_i, _bb) - return this - } - val head : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val chest : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val waist : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val knees : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val feet : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val elbows : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val hands : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOSCTrackersSetting(_bb: ByteBuffer): OSCTrackersSetting = getRootAsOSCTrackersSetting(_bb, OSCTrackersSetting()) - @JvmStatic - fun getRootAsOSCTrackersSetting(_bb: ByteBuffer, obj: OSCTrackersSetting): OSCTrackersSetting { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOSCTrackersSetting(builder: FlatBufferBuilder, head: Boolean, chest: Boolean, waist: Boolean, knees: Boolean, feet: Boolean, elbows: Boolean, hands: Boolean) : Int { - builder.startTable(7) - addHands(builder, hands) - addElbows(builder, elbows) - addFeet(builder, feet) - addKnees(builder, knees) - addWaist(builder, waist) - addChest(builder, chest) - addHead(builder, head) - return endOSCTrackersSetting(builder) - } - @JvmStatic - fun startOSCTrackersSetting(builder: FlatBufferBuilder) = builder.startTable(7) - @JvmStatic - fun addHead(builder: FlatBufferBuilder, head: Boolean) = builder.addBoolean(0, head, false) - @JvmStatic - fun addChest(builder: FlatBufferBuilder, chest: Boolean) = builder.addBoolean(1, chest, false) - @JvmStatic - fun addWaist(builder: FlatBufferBuilder, waist: Boolean) = builder.addBoolean(2, waist, false) - @JvmStatic - fun addKnees(builder: FlatBufferBuilder, knees: Boolean) = builder.addBoolean(3, knees, false) - @JvmStatic - fun addFeet(builder: FlatBufferBuilder, feet: Boolean) = builder.addBoolean(4, feet, false) - @JvmStatic - fun addElbows(builder: FlatBufferBuilder, elbows: Boolean) = builder.addBoolean(5, elbows, false) - @JvmStatic - fun addHands(builder: FlatBufferBuilder, hands: Boolean) = builder.addBoolean(6, hands, false) - @JvmStatic - fun endOSCTrackersSetting(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OTAFirmwareUpdate.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OTAFirmwareUpdate.kt deleted file mode 100644 index 998659ad2..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OTAFirmwareUpdate.kt +++ /dev/null @@ -1,65 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class OTAFirmwareUpdate : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OTAFirmwareUpdate { - __init(_i, _bb) - return this - } - /** - * id of the device, this refer to the actual DeviceId from the protocol - */ - val deviceId : solarxr_protocol.datatypes.DeviceId? get() = deviceId(solarxr_protocol.datatypes.DeviceId()) - fun deviceId(obj: solarxr_protocol.datatypes.DeviceId) : solarxr_protocol.datatypes.DeviceId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - /** - * A table containing the url and offset of the firmware bin file - */ - val firmwarePart : solarxr_protocol.rpc.FirmwarePart? get() = firmwarePart(solarxr_protocol.rpc.FirmwarePart()) - fun firmwarePart(obj: solarxr_protocol.rpc.FirmwarePart) : solarxr_protocol.rpc.FirmwarePart? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOTAFirmwareUpdate(_bb: ByteBuffer): OTAFirmwareUpdate = getRootAsOTAFirmwareUpdate(_bb, OTAFirmwareUpdate()) - @JvmStatic - fun getRootAsOTAFirmwareUpdate(_bb: ByteBuffer, obj: OTAFirmwareUpdate): OTAFirmwareUpdate { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startOTAFirmwareUpdate(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addDeviceId(builder: FlatBufferBuilder, deviceId: Int) = builder.addStruct(0, deviceId, 0) - @JvmStatic - fun addFirmwarePart(builder: FlatBufferBuilder, firmwarePart: Int) = builder.addOffset(1, firmwarePart, 0) - @JvmStatic - fun endOTAFirmwareUpdate(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OpenSerialRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OpenSerialRequest.kt deleted file mode 100644 index fb41dd509..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OpenSerialRequest.kt +++ /dev/null @@ -1,63 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class OpenSerialRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OpenSerialRequest { - __init(_i, _bb) - return this - } - /** - * Automatically pick the first serial device available - */ - val auto : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val port : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val portAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun portInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOpenSerialRequest(_bb: ByteBuffer): OpenSerialRequest = getRootAsOpenSerialRequest(_bb, OpenSerialRequest()) - @JvmStatic - fun getRootAsOpenSerialRequest(_bb: ByteBuffer, obj: OpenSerialRequest): OpenSerialRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOpenSerialRequest(builder: FlatBufferBuilder, auto: Boolean, portOffset: Int) : Int { - builder.startTable(2) - addPort(builder, portOffset) - addAuto(builder, auto) - return endOpenSerialRequest(builder) - } - @JvmStatic - fun startOpenSerialRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addAuto(builder: FlatBufferBuilder, auto: Boolean) = builder.addBoolean(0, auto, false) - @JvmStatic - fun addPort(builder: FlatBufferBuilder, port: Int) = builder.addOffset(1, port, 0) - @JvmStatic - fun endOpenSerialRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeChangeRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeChangeRequest.kt deleted file mode 100644 index f2cb40df1..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeChangeRequest.kt +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Changes the state of the overlay's display mode. - */ -@Suppress("unused") -class OverlayDisplayModeChangeRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OverlayDisplayModeChangeRequest { - __init(_i, _bb) - return this - } - val isVisible : Boolean? - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val isMirrored : Boolean? - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOverlayDisplayModeChangeRequest(_bb: ByteBuffer): OverlayDisplayModeChangeRequest = getRootAsOverlayDisplayModeChangeRequest(_bb, OverlayDisplayModeChangeRequest()) - @JvmStatic - fun getRootAsOverlayDisplayModeChangeRequest(_bb: ByteBuffer, obj: OverlayDisplayModeChangeRequest): OverlayDisplayModeChangeRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOverlayDisplayModeChangeRequest(builder: FlatBufferBuilder, isVisible: Boolean?, isMirrored: Boolean?) : Int { - builder.startTable(2) - isMirrored?.run { addIsMirrored(builder, isMirrored) } - isVisible?.run { addIsVisible(builder, isVisible) } - return endOverlayDisplayModeChangeRequest(builder) - } - @JvmStatic - fun startOverlayDisplayModeChangeRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addIsVisible(builder: FlatBufferBuilder, isVisible: Boolean) = builder.addBoolean(0, isVisible, false) - @JvmStatic - fun addIsMirrored(builder: FlatBufferBuilder, isMirrored: Boolean) = builder.addBoolean(1, isMirrored, false) - @JvmStatic - fun endOverlayDisplayModeChangeRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeRequest.kt deleted file mode 100644 index 0d5b619a6..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Requests the current state of `OverlayDisplayModeResponse`. - */ -@Suppress("unused") -class OverlayDisplayModeRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OverlayDisplayModeRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOverlayDisplayModeRequest(_bb: ByteBuffer): OverlayDisplayModeRequest = getRootAsOverlayDisplayModeRequest(_bb, OverlayDisplayModeRequest()) - @JvmStatic - fun getRootAsOverlayDisplayModeRequest(_bb: ByteBuffer, obj: OverlayDisplayModeRequest): OverlayDisplayModeRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startOverlayDisplayModeRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endOverlayDisplayModeRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeResponse.kt deleted file mode 100644 index 8730be56a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/OverlayDisplayModeResponse.kt +++ /dev/null @@ -1,61 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * The current state of the overlay's display mode. - */ -@Suppress("unused") -class OverlayDisplayModeResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : OverlayDisplayModeResponse { - __init(_i, _bb) - return this - } - val isVisible : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val isMirrored : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsOverlayDisplayModeResponse(_bb: ByteBuffer): OverlayDisplayModeResponse = getRootAsOverlayDisplayModeResponse(_bb, OverlayDisplayModeResponse()) - @JvmStatic - fun getRootAsOverlayDisplayModeResponse(_bb: ByteBuffer, obj: OverlayDisplayModeResponse): OverlayDisplayModeResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createOverlayDisplayModeResponse(builder: FlatBufferBuilder, isVisible: Boolean, isMirrored: Boolean) : Int { - builder.startTable(2) - addIsMirrored(builder, isMirrored) - addIsVisible(builder, isVisible) - return endOverlayDisplayModeResponse(builder) - } - @JvmStatic - fun startOverlayDisplayModeResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addIsVisible(builder: FlatBufferBuilder, isVisible: Boolean) = builder.addBoolean(0, isVisible, false) - @JvmStatic - fun addIsMirrored(builder: FlatBufferBuilder, isMirrored: Boolean) = builder.addBoolean(1, isMirrored, false) - @JvmStatic - fun endOverlayDisplayModeResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHRequest.kt deleted file mode 100644 index d536697df..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHRequest.kt +++ /dev/null @@ -1,64 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class RecordBVHRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : RecordBVHRequest { - __init(_i, _bb) - return this - } - val stop : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * Path sent when starting the recording, if null the recording won't happen. - * Has different behavior depending if its a file path or a directory path. - */ - val path : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val pathAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun pathInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsRecordBVHRequest(_bb: ByteBuffer): RecordBVHRequest = getRootAsRecordBVHRequest(_bb, RecordBVHRequest()) - @JvmStatic - fun getRootAsRecordBVHRequest(_bb: ByteBuffer, obj: RecordBVHRequest): RecordBVHRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createRecordBVHRequest(builder: FlatBufferBuilder, stop: Boolean, pathOffset: Int) : Int { - builder.startTable(2) - addPath(builder, pathOffset) - addStop(builder, stop) - return endRecordBVHRequest(builder) - } - @JvmStatic - fun startRecordBVHRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addStop(builder: FlatBufferBuilder, stop: Boolean) = builder.addBoolean(0, stop, false) - @JvmStatic - fun addPath(builder: FlatBufferBuilder, path: Int) = builder.addOffset(1, path, 0) - @JvmStatic - fun endRecordBVHRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatus.kt deleted file mode 100644 index ba5499e36..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatus.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class RecordBVHStatus : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : RecordBVHStatus { - __init(_i, _bb) - return this - } - val recording : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsRecordBVHStatus(_bb: ByteBuffer): RecordBVHStatus = getRootAsRecordBVHStatus(_bb, RecordBVHStatus()) - @JvmStatic - fun getRootAsRecordBVHStatus(_bb: ByteBuffer, obj: RecordBVHStatus): RecordBVHStatus { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createRecordBVHStatus(builder: FlatBufferBuilder, recording: Boolean) : Int { - builder.startTable(1) - addRecording(builder, recording) - return endRecordBVHStatus(builder) - } - @JvmStatic - fun startRecordBVHStatus(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addRecording(builder: FlatBufferBuilder, recording: Boolean) = builder.addBoolean(0, recording, false) - @JvmStatic - fun endRecordBVHStatus(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatusRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatusRequest.kt deleted file mode 100644 index 3139e29a0..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RecordBVHStatusRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class RecordBVHStatusRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : RecordBVHStatusRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsRecordBVHStatusRequest(_bb: ByteBuffer): RecordBVHStatusRequest = getRootAsRecordBVHStatusRequest(_bb, RecordBVHStatusRequest()) - @JvmStatic - fun getRootAsRecordBVHStatusRequest(_bb: ByteBuffer, obj: RecordBVHStatusRequest): RecordBVHStatusRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startRecordBVHStatusRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endRecordBVHStatusRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetRequest.kt deleted file mode 100644 index b5af1e312..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetRequest.kt +++ /dev/null @@ -1,88 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ResetRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ResetRequest { - __init(_i, _bb) - return this - } - val resetType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * Which body parts to reset. Server handles it if empty (usually all) - */ - fun bodyParts(j: Int) : UByte { - val o = __offset(6) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val bodyPartsLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - val bodyPartsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun bodyPartsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - val delay : Float? - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsResetRequest(_bb: ByteBuffer): ResetRequest = getRootAsResetRequest(_bb, ResetRequest()) - @JvmStatic - fun getRootAsResetRequest(_bb: ByteBuffer, obj: ResetRequest): ResetRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createResetRequest(builder: FlatBufferBuilder, resetType: UByte, bodyPartsOffset: Int, delay: Float?) : Int { - builder.startTable(3) - delay?.run { addDelay(builder, delay) } - addBodyParts(builder, bodyPartsOffset) - addResetType(builder, resetType) - return endResetRequest(builder) - } - @JvmStatic - fun startResetRequest(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addResetType(builder: FlatBufferBuilder, resetType: UByte) = builder.addByte(0, resetType.toByte(), 0) - @JvmStatic - fun addBodyParts(builder: FlatBufferBuilder, bodyParts: Int) = builder.addOffset(1, bodyParts, 0) - @JvmStatic - fun createBodyPartsVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startBodyPartsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun addDelay(builder: FlatBufferBuilder, delay: Float) = builder.addFloat(2, delay, 0.0) - @JvmStatic - fun endResetRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt deleted file mode 100644 index d96a2b0c5..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ResetResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ResetResponse { - __init(_i, _bb) - return this - } - val resetType : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val status : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - /** - * Should return the body parts reseted / being reset - */ - fun bodyParts(j: Int) : UByte { - val o = __offset(8) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val bodyPartsLength : Int - get() { - val o = __offset(8); return if (o != 0) __vector_len(o) else 0 - } - val bodyPartsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun bodyPartsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - /** - * gives the time in seconds passed since the start of the reset - * is 0 when status == FINISHED - * starts at 0 - */ - val progress : Int - get() { - val o = __offset(10) - return if(o != 0) bb.getInt(o + bb_pos) else 0 - } - val duration : Int - get() { - val o = __offset(12) - return if(o != 0) bb.getInt(o + bb_pos) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsResetResponse(_bb: ByteBuffer): ResetResponse = getRootAsResetResponse(_bb, ResetResponse()) - @JvmStatic - fun getRootAsResetResponse(_bb: ByteBuffer, obj: ResetResponse): ResetResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createResetResponse(builder: FlatBufferBuilder, resetType: UByte, status: UByte, bodyPartsOffset: Int, progress: Int, duration: Int) : Int { - builder.startTable(5) - addDuration(builder, duration) - addProgress(builder, progress) - addBodyParts(builder, bodyPartsOffset) - addStatus(builder, status) - addResetType(builder, resetType) - return endResetResponse(builder) - } - @JvmStatic - fun startResetResponse(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addResetType(builder: FlatBufferBuilder, resetType: UByte) = builder.addByte(0, resetType.toByte(), 0) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(1, status.toByte(), 0) - @JvmStatic - fun addBodyParts(builder: FlatBufferBuilder, bodyParts: Int) = builder.addOffset(2, bodyParts, 0) - @JvmStatic - fun createBodyPartsVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startBodyPartsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun addProgress(builder: FlatBufferBuilder, progress: Int) = builder.addInt(3, progress, 0) - @JvmStatic - fun addDuration(builder: FlatBufferBuilder, duration: Int) = builder.addInt(4, duration, 0) - @JvmStatic - fun endResetResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetStatus.kt deleted file mode 100644 index a15b278b0..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetStatus.kt +++ /dev/null @@ -1,14 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class ResetStatus private constructor() { - companion object { - const val STARTED: UByte = 0u - const val FINISHED: UByte = 1u - val names : Array = arrayOf("STARTED", "FINISHED") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetStayAlignedRelaxedPoseRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetStayAlignedRelaxedPoseRequest.kt deleted file mode 100644 index 4f404e3b2..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetStayAlignedRelaxedPoseRequest.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ResetStayAlignedRelaxedPoseRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ResetStayAlignedRelaxedPoseRequest { - __init(_i, _bb) - return this - } - val pose : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsResetStayAlignedRelaxedPoseRequest(_bb: ByteBuffer): ResetStayAlignedRelaxedPoseRequest = getRootAsResetStayAlignedRelaxedPoseRequest(_bb, ResetStayAlignedRelaxedPoseRequest()) - @JvmStatic - fun getRootAsResetStayAlignedRelaxedPoseRequest(_bb: ByteBuffer, obj: ResetStayAlignedRelaxedPoseRequest): ResetStayAlignedRelaxedPoseRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createResetStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder, pose: UByte) : Int { - builder.startTable(1) - addPose(builder, pose) - return endResetStayAlignedRelaxedPoseRequest(builder) - } - @JvmStatic - fun startResetStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addPose(builder: FlatBufferBuilder, pose: UByte) = builder.addByte(0, pose.toByte(), 0) - @JvmStatic - fun endResetStayAlignedRelaxedPoseRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetType.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetType.kt deleted file mode 100644 index 00cc7ac9e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetType.kt +++ /dev/null @@ -1,18 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class ResetType private constructor() { - companion object { - const val Yaw: UByte = 0u - const val Full: UByte = 1u - /** - * Second pose for calibrating mounting rotation - */ - const val Mounting: UByte = 2u - val names : Array = arrayOf("Yaw", "Full", "Mounting") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetsSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetsSettings.kt deleted file mode 100644 index 1ff79fa11..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetsSettings.kt +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class ResetsSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ResetsSettings { - __init(_i, _bb) - return this - } - val resetMountingFeet : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val armsMountingResetMode : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val yawResetSmoothTime : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val saveMountingReset : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val resetHmdPitch : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsResetsSettings(_bb: ByteBuffer): ResetsSettings = getRootAsResetsSettings(_bb, ResetsSettings()) - @JvmStatic - fun getRootAsResetsSettings(_bb: ByteBuffer, obj: ResetsSettings): ResetsSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createResetsSettings(builder: FlatBufferBuilder, resetMountingFeet: Boolean, armsMountingResetMode: UByte, yawResetSmoothTime: Float, saveMountingReset: Boolean, resetHmdPitch: Boolean) : Int { - builder.startTable(5) - addYawResetSmoothTime(builder, yawResetSmoothTime) - addResetHmdPitch(builder, resetHmdPitch) - addSaveMountingReset(builder, saveMountingReset) - addArmsMountingResetMode(builder, armsMountingResetMode) - addResetMountingFeet(builder, resetMountingFeet) - return endResetsSettings(builder) - } - @JvmStatic - fun startResetsSettings(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addResetMountingFeet(builder: FlatBufferBuilder, resetMountingFeet: Boolean) = builder.addBoolean(0, resetMountingFeet, false) - @JvmStatic - fun addArmsMountingResetMode(builder: FlatBufferBuilder, armsMountingResetMode: UByte) = builder.addByte(1, armsMountingResetMode.toByte(), 0) - @JvmStatic - fun addYawResetSmoothTime(builder: FlatBufferBuilder, yawResetSmoothTime: Float) = builder.addFloat(2, yawResetSmoothTime, 0.0) - @JvmStatic - fun addSaveMountingReset(builder: FlatBufferBuilder, saveMountingReset: Boolean) = builder.addBoolean(3, saveMountingReset, false) - @JvmStatic - fun addResetHmdPitch(builder: FlatBufferBuilder, resetHmdPitch: Boolean) = builder.addBoolean(4, resetHmdPitch, false) - @JvmStatic - fun endResetsSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessageHeader.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessageHeader.kt deleted file mode 100644 index 9756bbe47..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessageHeader.kt +++ /dev/null @@ -1,64 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class RpcMessageHeader : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : RpcMessageHeader { - __init(_i, _bb) - return this - } - /** - * For a request, this identifies the request. For a response, this corresponds - * to the request that it is responding to. - */ - val txId : solarxr_protocol.datatypes.TransactionId? get() = txId(solarxr_protocol.datatypes.TransactionId()) - fun txId(obj: solarxr_protocol.datatypes.TransactionId) : solarxr_protocol.datatypes.TransactionId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(o + bb_pos, bb) - } else { - null - } - } - val messageType : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun message(obj: Table) : Table? { - val o = __offset(8); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsRpcMessageHeader(_bb: ByteBuffer): RpcMessageHeader = getRootAsRpcMessageHeader(_bb, RpcMessageHeader()) - @JvmStatic - fun getRootAsRpcMessageHeader(_bb: ByteBuffer, obj: RpcMessageHeader): RpcMessageHeader { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startRpcMessageHeader(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addTxId(builder: FlatBufferBuilder, txId: Int) = builder.addStruct(0, txId, 0) - @JvmStatic - fun addMessageType(builder: FlatBufferBuilder, messageType: UByte) = builder.addByte(1, messageType.toByte(), 0) - @JvmStatic - fun addMessage(builder: FlatBufferBuilder, message: Int) = builder.addOffset(2, message, 0) - @JvmStatic - fun endRpcMessageHeader(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SaveFileNotification.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SaveFileNotification.kt deleted file mode 100644 index da35d2a72..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SaveFileNotification.kt +++ /dev/null @@ -1,125 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Used for the server to save a file and have it prompt in the user side - */ -@Suppress("unused") -class SaveFileNotification : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SaveFileNotification { - __init(_i, _bb) - return this - } - /** - * Binary data of the file - */ - fun data(j: Int) : UByte { - val o = __offset(4) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val dataLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - val dataAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun dataInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - /** - * MIME type of file if one exists, use `file_extension` otherwise - */ - val mimeType : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val mimeTypeAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun mimeTypeInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - /** - * Use MIME type preferably if one exists - */ - val fileExtension : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val fileExtensionAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun fileExtensionInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - /** - * Directory recommended to save the file on - */ - val expectedDir : UByte? - get() { - val o = __offset(10) - return if(o != 0) bb.get(o + bb_pos).toUByte() else null - } - /** - * Recommended filename - */ - val expectedFilename : String? - get() { - val o = __offset(12) - return if (o != 0) __string(o + bb_pos) else null - } - val expectedFilenameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(12, 1) - fun expectedFilenameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 12, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSaveFileNotification(_bb: ByteBuffer): SaveFileNotification = getRootAsSaveFileNotification(_bb, SaveFileNotification()) - @JvmStatic - fun getRootAsSaveFileNotification(_bb: ByteBuffer, obj: SaveFileNotification): SaveFileNotification { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSaveFileNotification(builder: FlatBufferBuilder, dataOffset: Int, mimeTypeOffset: Int, fileExtensionOffset: Int, expectedDir: UByte?, expectedFilenameOffset: Int) : Int { - builder.startTable(5) - addExpectedFilename(builder, expectedFilenameOffset) - addFileExtension(builder, fileExtensionOffset) - addMimeType(builder, mimeTypeOffset) - addData(builder, dataOffset) - expectedDir?.run { addExpectedDir(builder, expectedDir) } - return endSaveFileNotification(builder) - } - @JvmStatic - fun startSaveFileNotification(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addData(builder: FlatBufferBuilder, data: Int) = builder.addOffset(0, data, 0) - @JvmStatic - fun createDataVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startDataVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun addMimeType(builder: FlatBufferBuilder, mimeType: Int) = builder.addOffset(1, mimeType, 0) - @JvmStatic - fun addFileExtension(builder: FlatBufferBuilder, fileExtension: Int) = builder.addOffset(2, fileExtension, 0) - @JvmStatic - fun addExpectedDir(builder: FlatBufferBuilder, expectedDir: UByte) = builder.addByte(3, expectedDir.toByte(), 0) - @JvmStatic - fun addExpectedFilename(builder: FlatBufferBuilder, expectedFilename: Int) = builder.addOffset(4, expectedFilename, 0) - @JvmStatic - fun endSaveFileNotification(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicePort.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicePort.kt deleted file mode 100644 index 4abc93252..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicePort.kt +++ /dev/null @@ -1,52 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SerialDevicePort : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialDevicePort { - __init(_i, _bb) - return this - } - val port : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val portAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun portInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialDevicePort(_bb: ByteBuffer): SerialDevicePort = getRootAsSerialDevicePort(_bb, SerialDevicePort()) - @JvmStatic - fun getRootAsSerialDevicePort(_bb: ByteBuffer, obj: SerialDevicePort): SerialDevicePort { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSerialDevicePort(builder: FlatBufferBuilder, portOffset: Int) : Int { - builder.startTable(1) - addPort(builder, portOffset) - return endSerialDevicePort(builder) - } - @JvmStatic - fun startSerialDevicePort(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addPort(builder: FlatBufferBuilder, port: Int) = builder.addOffset(0, port, 0) - @JvmStatic - fun endSerialDevicePort(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesRequest.kt deleted file mode 100644 index 591883e76..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SerialDevicesRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialDevicesRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialDevicesRequest(_bb: ByteBuffer): SerialDevicesRequest = getRootAsSerialDevicesRequest(_bb, SerialDevicesRequest()) - @JvmStatic - fun getRootAsSerialDevicesRequest(_bb: ByteBuffer, obj: SerialDevicesRequest): SerialDevicesRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSerialDevicesRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSerialDevicesRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesResponse.kt deleted file mode 100644 index acef65b97..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialDevicesResponse.kt +++ /dev/null @@ -1,68 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SerialDevicesResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialDevicesResponse { - __init(_i, _bb) - return this - } - fun devices(j: Int) : solarxr_protocol.rpc.SerialDevice? = devices(solarxr_protocol.rpc.SerialDevice(), j) - fun devices(obj: solarxr_protocol.rpc.SerialDevice, j: Int) : solarxr_protocol.rpc.SerialDevice? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val devicesLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialDevicesResponse(_bb: ByteBuffer): SerialDevicesResponse = getRootAsSerialDevicesResponse(_bb, SerialDevicesResponse()) - @JvmStatic - fun getRootAsSerialDevicesResponse(_bb: ByteBuffer, obj: SerialDevicesResponse): SerialDevicesResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSerialDevicesResponse(builder: FlatBufferBuilder, devicesOffset: Int) : Int { - builder.startTable(1) - addDevices(builder, devicesOffset) - return endSerialDevicesResponse(builder) - } - @JvmStatic - fun startSerialDevicesResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addDevices(builder: FlatBufferBuilder, devices: Int) = builder.addOffset(0, devices, 0) - @JvmStatic - fun createDevicesVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startDevicesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endSerialDevicesResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialFirmwareUpdate.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialFirmwareUpdate.kt deleted file mode 100644 index d373c2fd8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialFirmwareUpdate.kt +++ /dev/null @@ -1,122 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SerialFirmwareUpdate : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialFirmwareUpdate { - __init(_i, _bb) - return this - } - /** - * id of the device, this refer to a serial port id - */ - val deviceId : solarxr_protocol.rpc.SerialDevicePort? get() = deviceId(solarxr_protocol.rpc.SerialDevicePort()) - fun deviceId(obj: solarxr_protocol.rpc.SerialDevicePort) : solarxr_protocol.rpc.SerialDevicePort? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - /** - * Will make the server ask for the tracker to be manually rebooted by the user - * after the tracker is done flashing - */ - val needManualReboot : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - /** - * Credentials to provision after the flashing - * Only used with Serial flashing, because OTA is already connected to the wifi - */ - val ssid : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val ssidAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun ssidInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - val password : String? - get() { - val o = __offset(10) - return if (o != 0) __string(o + bb_pos) else null - } - val passwordAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1) - fun passwordInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1) - /** - * A list of urls and offsets of the different firmware files to flash - */ - fun firmwarePart(j: Int) : solarxr_protocol.rpc.FirmwarePart? = firmwarePart(solarxr_protocol.rpc.FirmwarePart(), j) - fun firmwarePart(obj: solarxr_protocol.rpc.FirmwarePart, j: Int) : solarxr_protocol.rpc.FirmwarePart? { - val o = __offset(12) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val firmwarePartLength : Int - get() { - val o = __offset(12); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialFirmwareUpdate(_bb: ByteBuffer): SerialFirmwareUpdate = getRootAsSerialFirmwareUpdate(_bb, SerialFirmwareUpdate()) - @JvmStatic - fun getRootAsSerialFirmwareUpdate(_bb: ByteBuffer, obj: SerialFirmwareUpdate): SerialFirmwareUpdate { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSerialFirmwareUpdate(builder: FlatBufferBuilder, deviceIdOffset: Int, needManualReboot: Boolean, ssidOffset: Int, passwordOffset: Int, firmwarePartOffset: Int) : Int { - builder.startTable(5) - addFirmwarePart(builder, firmwarePartOffset) - addPassword(builder, passwordOffset) - addSsid(builder, ssidOffset) - addDeviceId(builder, deviceIdOffset) - addNeedManualReboot(builder, needManualReboot) - return endSerialFirmwareUpdate(builder) - } - @JvmStatic - fun startSerialFirmwareUpdate(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addDeviceId(builder: FlatBufferBuilder, deviceId: Int) = builder.addOffset(0, deviceId, 0) - @JvmStatic - fun addNeedManualReboot(builder: FlatBufferBuilder, needManualReboot: Boolean) = builder.addBoolean(1, needManualReboot, false) - @JvmStatic - fun addSsid(builder: FlatBufferBuilder, ssid: Int) = builder.addOffset(2, ssid, 0) - @JvmStatic - fun addPassword(builder: FlatBufferBuilder, password: Int) = builder.addOffset(3, password, 0) - @JvmStatic - fun addFirmwarePart(builder: FlatBufferBuilder, firmwarePart: Int) = builder.addOffset(4, firmwarePart, 0) - @JvmStatic - fun createFirmwarePartVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startFirmwarePartVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endSerialFirmwareUpdate(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerCustomCommandRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerCustomCommandRequest.kt deleted file mode 100644 index 214269585..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerCustomCommandRequest.kt +++ /dev/null @@ -1,55 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Sends a custom cmd to the currently connected Tracker over the Serial Monitor - */ -@Suppress("unused") -class SerialTrackerCustomCommandRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialTrackerCustomCommandRequest { - __init(_i, _bb) - return this - } - val command : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val commandAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun commandInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialTrackerCustomCommandRequest(_bb: ByteBuffer): SerialTrackerCustomCommandRequest = getRootAsSerialTrackerCustomCommandRequest(_bb, SerialTrackerCustomCommandRequest()) - @JvmStatic - fun getRootAsSerialTrackerCustomCommandRequest(_bb: ByteBuffer, obj: SerialTrackerCustomCommandRequest): SerialTrackerCustomCommandRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSerialTrackerCustomCommandRequest(builder: FlatBufferBuilder, commandOffset: Int) : Int { - builder.startTable(1) - addCommand(builder, commandOffset) - return endSerialTrackerCustomCommandRequest(builder) - } - @JvmStatic - fun startSerialTrackerCustomCommandRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addCommand(builder: FlatBufferBuilder, command: Int) = builder.addOffset(0, command, 0) - @JvmStatic - fun endSerialTrackerCustomCommandRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerFactoryResetRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerFactoryResetRequest.kt deleted file mode 100644 index 0c8d90574..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerFactoryResetRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Sends the FRST cmd to the currently connected Tracker over the Serial Monitor - */ -@Suppress("unused") -class SerialTrackerFactoryResetRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialTrackerFactoryResetRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialTrackerFactoryResetRequest(_bb: ByteBuffer): SerialTrackerFactoryResetRequest = getRootAsSerialTrackerFactoryResetRequest(_bb, SerialTrackerFactoryResetRequest()) - @JvmStatic - fun getRootAsSerialTrackerFactoryResetRequest(_bb: ByteBuffer, obj: SerialTrackerFactoryResetRequest): SerialTrackerFactoryResetRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSerialTrackerFactoryResetRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSerialTrackerFactoryResetRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetInfoRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetInfoRequest.kt deleted file mode 100644 index b83f9bbe7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetInfoRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Sends the GET INFO cmd to the current tracker on the serial monitor - */ -@Suppress("unused") -class SerialTrackerGetInfoRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialTrackerGetInfoRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialTrackerGetInfoRequest(_bb: ByteBuffer): SerialTrackerGetInfoRequest = getRootAsSerialTrackerGetInfoRequest(_bb, SerialTrackerGetInfoRequest()) - @JvmStatic - fun getRootAsSerialTrackerGetInfoRequest(_bb: ByteBuffer, obj: SerialTrackerGetInfoRequest): SerialTrackerGetInfoRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSerialTrackerGetInfoRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSerialTrackerGetInfoRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetWifiScanRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetWifiScanRequest.kt deleted file mode 100644 index b776857c2..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerGetWifiScanRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Sends the GET WIFISCAN cmd to the current tracker on the serial monitor - */ -@Suppress("unused") -class SerialTrackerGetWifiScanRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialTrackerGetWifiScanRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialTrackerGetWifiScanRequest(_bb: ByteBuffer): SerialTrackerGetWifiScanRequest = getRootAsSerialTrackerGetWifiScanRequest(_bb, SerialTrackerGetWifiScanRequest()) - @JvmStatic - fun getRootAsSerialTrackerGetWifiScanRequest(_bb: ByteBuffer, obj: SerialTrackerGetWifiScanRequest): SerialTrackerGetWifiScanRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSerialTrackerGetWifiScanRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSerialTrackerGetWifiScanRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerRebootRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerRebootRequest.kt deleted file mode 100644 index e57da4ce9..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SerialTrackerRebootRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Reboots the tracker connected to the serial monitor - */ -@Suppress("unused") -class SerialTrackerRebootRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SerialTrackerRebootRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSerialTrackerRebootRequest(_bb: ByteBuffer): SerialTrackerRebootRequest = getRootAsSerialTrackerRebootRequest(_bb, SerialTrackerRebootRequest()) - @JvmStatic - fun getRootAsSerialTrackerRebootRequest(_bb: ByteBuffer, obj: SerialTrackerRebootRequest): SerialTrackerRebootRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSerialTrackerRebootRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSerialTrackerRebootRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosRequest.kt deleted file mode 100644 index 085c63a6d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosRequest.kt +++ /dev/null @@ -1,43 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Allows to ask generic infos about the server, - * like the local ip address, the version of the server, the java version, - * the current working dir and other information we might want to show in the gui - * for information/debug purposes - */ -@Suppress("unused") -class ServerInfosRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ServerInfosRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsServerInfosRequest(_bb: ByteBuffer): ServerInfosRequest = getRootAsServerInfosRequest(_bb, ServerInfosRequest()) - @JvmStatic - fun getRootAsServerInfosRequest(_bb: ByteBuffer, obj: ServerInfosRequest): ServerInfosRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startServerInfosRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endServerInfosRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosResponse.kt deleted file mode 100644 index f60dbf10f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ServerInfosResponse.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Holds the Server information, this is a basic table holding various information about the currently running server - * like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more - * infos we might want to add in the future. (like java version, working dir, server version ....) - * This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance - */ -@Suppress("unused") -class ServerInfosResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ServerInfosResponse { - __init(_i, _bb) - return this - } - val localIp : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val localIpAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun localIpInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsServerInfosResponse(_bb: ByteBuffer): ServerInfosResponse = getRootAsServerInfosResponse(_bb, ServerInfosResponse()) - @JvmStatic - fun getRootAsServerInfosResponse(_bb: ByteBuffer, obj: ServerInfosResponse): ServerInfosResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createServerInfosResponse(builder: FlatBufferBuilder, localIpOffset: Int) : Int { - builder.startTable(1) - addLocalIp(builder, localIpOffset) - return endServerInfosResponse(builder) - } - @JvmStatic - fun startServerInfosResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addLocalIp(builder: FlatBufferBuilder, localIp: Int) = builder.addOffset(0, localIp, 0) - @JvmStatic - fun endServerInfosResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SetPauseTrackingRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SetPauseTrackingRequest.kt deleted file mode 100644 index 20d07f46c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SetPauseTrackingRequest.kt +++ /dev/null @@ -1,53 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SetPauseTrackingRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SetPauseTrackingRequest { - __init(_i, _bb) - return this - } - /** - * Pauses skeleton tracking if true, resumes skeleton tracking if false. - */ - val pauseTracking : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSetPauseTrackingRequest(_bb: ByteBuffer): SetPauseTrackingRequest = getRootAsSetPauseTrackingRequest(_bb, SetPauseTrackingRequest()) - @JvmStatic - fun getRootAsSetPauseTrackingRequest(_bb: ByteBuffer, obj: SetPauseTrackingRequest): SetPauseTrackingRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSetPauseTrackingRequest(builder: FlatBufferBuilder, pauseTracking: Boolean) : Int { - builder.startTable(1) - addPauseTracking(builder, pauseTracking) - return endSetPauseTrackingRequest(builder) - } - @JvmStatic - fun startSetPauseTrackingRequest(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addPauseTracking(builder: FlatBufferBuilder, pauseTracking: Boolean) = builder.addBoolean(0, pauseTracking, false) - @JvmStatic - fun endSetPauseTrackingRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SetWifiRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SetWifiRequest.kt deleted file mode 100644 index 3c5757ff9..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SetWifiRequest.kt +++ /dev/null @@ -1,62 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SetWifiRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SetWifiRequest { - __init(_i, _bb) - return this - } - val ssid : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val ssidAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun ssidInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - val password : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val passwordAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun passwordInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSetWifiRequest(_bb: ByteBuffer): SetWifiRequest = getRootAsSetWifiRequest(_bb, SetWifiRequest()) - @JvmStatic - fun getRootAsSetWifiRequest(_bb: ByteBuffer, obj: SetWifiRequest): SetWifiRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSetWifiRequest(builder: FlatBufferBuilder, ssidOffset: Int, passwordOffset: Int) : Int { - builder.startTable(2) - addPassword(builder, passwordOffset) - addSsid(builder, ssidOffset) - return endSetWifiRequest(builder) - } - @JvmStatic - fun startSetWifiRequest(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addSsid(builder: FlatBufferBuilder, ssid: Int) = builder.addOffset(0, ssid, 0) - @JvmStatic - fun addPassword(builder: FlatBufferBuilder, password: Int) = builder.addOffset(1, password, 0) - @JvmStatic - fun endSetWifiRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SettingsRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SettingsRequest.kt deleted file mode 100644 index 796f9c47c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SettingsRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SettingsRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SettingsRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSettingsRequest(_bb: ByteBuffer): SettingsRequest = getRootAsSettingsRequest(_bb, SettingsRequest()) - @JvmStatic - fun getRootAsSettingsRequest(_bb: ByteBuffer, obj: SettingsRequest): SettingsRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSettingsRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSettingsRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SettingsResetRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SettingsResetRequest.kt deleted file mode 100644 index 4267c4c36..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SettingsResetRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SettingsResetRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SettingsResetRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSettingsResetRequest(_bb: ByteBuffer): SettingsResetRequest = getRootAsSettingsResetRequest(_bb, SettingsResetRequest()) - @JvmStatic - fun getRootAsSettingsResetRequest(_bb: ByteBuffer, obj: SettingsResetRequest): SettingsResetRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSettingsResetRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSettingsResetRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonBone.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonBone.kt deleted file mode 100644 index 85cdac0e7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonBone.kt +++ /dev/null @@ -1,34 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class SkeletonBone private constructor() { - companion object { - const val NONE: UByte = 0u - const val HEAD: UByte = 1u - const val NECK: UByte = 2u - const val CHEST: UByte = 3u - const val CHESTOFFSET: UByte = 4u - const val WAIST: UByte = 5u - const val HIP: UByte = 6u - const val HIPOFFSET: UByte = 7u - const val HIPSWIDTH: UByte = 8u - const val UPPERLEG: UByte = 9u - const val LOWERLEG: UByte = 10u - const val FOOTLENGTH: UByte = 11u - const val FOOTSHIFT: UByte = 12u - const val SKELETONOFFSET: UByte = 13u - const val SHOULDERSDISTANCE: UByte = 14u - const val SHOULDERSWIDTH: UByte = 15u - const val UPPERARM: UByte = 16u - const val LOWERARM: UByte = 17u - const val HANDY: UByte = 18u - const val HANDZ: UByte = 19u - const val ELBOWOFFSET: UByte = 20u - const val UPPERCHEST: UByte = 21u - val names : Array = arrayOf("NONE", "HEAD", "NECK", "CHEST", "CHEST_OFFSET", "WAIST", "HIP", "HIP_OFFSET", "HIPS_WIDTH", "UPPER_LEG", "LOWER_LEG", "FOOT_LENGTH", "FOOT_SHIFT", "SKELETON_OFFSET", "SHOULDERS_DISTANCE", "SHOULDERS_WIDTH", "UPPER_ARM", "LOWER_ARM", "HAND_Y", "HAND_Z", "ELBOW_OFFSET", "UPPER_CHEST") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigRequest.kt deleted file mode 100644 index 11f96293e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SkeletonConfigRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SkeletonConfigRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSkeletonConfigRequest(_bb: ByteBuffer): SkeletonConfigRequest = getRootAsSkeletonConfigRequest(_bb, SkeletonConfigRequest()) - @JvmStatic - fun getRootAsSkeletonConfigRequest(_bb: ByteBuffer, obj: SkeletonConfigRequest): SkeletonConfigRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSkeletonConfigRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSkeletonConfigRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigResponse.kt deleted file mode 100644 index d7938090f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonConfigResponse.kt +++ /dev/null @@ -1,76 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SkeletonConfigResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SkeletonConfigResponse { - __init(_i, _bb) - return this - } - fun skeletonParts(j: Int) : solarxr_protocol.rpc.SkeletonPart? = skeletonParts(solarxr_protocol.rpc.SkeletonPart(), j) - fun skeletonParts(obj: solarxr_protocol.rpc.SkeletonPart, j: Int) : solarxr_protocol.rpc.SkeletonPart? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val skeletonPartsLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - val userHeight : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSkeletonConfigResponse(_bb: ByteBuffer): SkeletonConfigResponse = getRootAsSkeletonConfigResponse(_bb, SkeletonConfigResponse()) - @JvmStatic - fun getRootAsSkeletonConfigResponse(_bb: ByteBuffer, obj: SkeletonConfigResponse): SkeletonConfigResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSkeletonConfigResponse(builder: FlatBufferBuilder, skeletonPartsOffset: Int, userHeight: Float) : Int { - builder.startTable(2) - addUserHeight(builder, userHeight) - addSkeletonParts(builder, skeletonPartsOffset) - return endSkeletonConfigResponse(builder) - } - @JvmStatic - fun startSkeletonConfigResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addSkeletonParts(builder: FlatBufferBuilder, skeletonParts: Int) = builder.addOffset(0, skeletonParts, 0) - @JvmStatic - fun createSkeletonPartsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startSkeletonPartsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addUserHeight(builder: FlatBufferBuilder, userHeight: Float) = builder.addFloat(1, userHeight, 0.0) - @JvmStatic - fun endSkeletonConfigResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonPart.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonPart.kt deleted file mode 100644 index 5d3f5c478..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonPart.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SkeletonPart : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SkeletonPart { - __init(_i, _bb) - return this - } - val bone : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val value : Float - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSkeletonPart(_bb: ByteBuffer): SkeletonPart = getRootAsSkeletonPart(_bb, SkeletonPart()) - @JvmStatic - fun getRootAsSkeletonPart(_bb: ByteBuffer, obj: SkeletonPart): SkeletonPart { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSkeletonPart(builder: FlatBufferBuilder, bone: UByte, value: Float) : Int { - builder.startTable(2) - addValue(builder, value) - addBone(builder, bone) - return endSkeletonPart(builder) - } - @JvmStatic - fun startSkeletonPart(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addBone(builder: FlatBufferBuilder, bone: UByte) = builder.addByte(0, bone.toByte(), 0) - @JvmStatic - fun addValue(builder: FlatBufferBuilder, value: Float) = builder.addFloat(1, value, 0.0) - @JvmStatic - fun endSkeletonPart(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonResetAllRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonResetAllRequest.kt deleted file mode 100644 index d3324ac78..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SkeletonResetAllRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SkeletonResetAllRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SkeletonResetAllRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSkeletonResetAllRequest(_bb: ByteBuffer): SkeletonResetAllRequest = getRootAsSkeletonResetAllRequest(_bb, SkeletonResetAllRequest()) - @JvmStatic - fun getRootAsSkeletonResetAllRequest(_bb: ByteBuffer, obj: SkeletonResetAllRequest): SkeletonResetAllRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startSkeletonResetAllRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endSkeletonResetAllRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StartUserHeightCalibration.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StartUserHeightCalibration.kt deleted file mode 100644 index 57ad1ba03..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StartUserHeightCalibration.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StartUserHeightCalibration : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StartUserHeightCalibration { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStartUserHeightCalibration(_bb: ByteBuffer): StartUserHeightCalibration = getRootAsStartUserHeightCalibration(_bb, StartUserHeightCalibration()) - @JvmStatic - fun getRootAsStartUserHeightCalibration(_bb: ByteBuffer, obj: StartUserHeightCalibration): StartUserHeightCalibration { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startStartUserHeightCalibration(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endStartUserHeightCalibration(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StartWifiProvisioningRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StartWifiProvisioningRequest.kt deleted file mode 100644 index 8e63d7054..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StartWifiProvisioningRequest.kt +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StartWifiProvisioningRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StartWifiProvisioningRequest { - __init(_i, _bb) - return this - } - val ssid : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val ssidAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun ssidInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - val password : String? - get() { - val o = __offset(6) - return if (o != 0) __string(o + bb_pos) else null - } - val passwordAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun passwordInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - val port : String? - get() { - val o = __offset(8) - return if (o != 0) __string(o + bb_pos) else null - } - val portAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) - fun portInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStartWifiProvisioningRequest(_bb: ByteBuffer): StartWifiProvisioningRequest = getRootAsStartWifiProvisioningRequest(_bb, StartWifiProvisioningRequest()) - @JvmStatic - fun getRootAsStartWifiProvisioningRequest(_bb: ByteBuffer, obj: StartWifiProvisioningRequest): StartWifiProvisioningRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStartWifiProvisioningRequest(builder: FlatBufferBuilder, ssidOffset: Int, passwordOffset: Int, portOffset: Int) : Int { - builder.startTable(3) - addPort(builder, portOffset) - addPassword(builder, passwordOffset) - addSsid(builder, ssidOffset) - return endStartWifiProvisioningRequest(builder) - } - @JvmStatic - fun startStartWifiProvisioningRequest(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addSsid(builder: FlatBufferBuilder, ssid: Int) = builder.addOffset(0, ssid, 0) - @JvmStatic - fun addPassword(builder: FlatBufferBuilder, password: Int) = builder.addOffset(1, password, 0) - @JvmStatic - fun addPort(builder: FlatBufferBuilder, port: Int) = builder.addOffset(2, port, 0) - @JvmStatic - fun endStartWifiProvisioningRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt deleted file mode 100644 index d2fecbae8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt +++ /dev/null @@ -1,18 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class StatusData private constructor() { - companion object { - const val NONE: UByte = 0u - const val StatusTrackerReset: UByte = 1u - const val StatusTrackerError: UByte = 2u - const val StatusSteamVRDisconnected: UByte = 3u - const val StatusUnassignedHMD: UByte = 4u - const val StatusPublicNetwork: UByte = 5u - val names : Array = arrayOf("NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusMessage.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusMessage.kt deleted file mode 100644 index 66b7858b4..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusMessage.kt +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * An status is some kind of warning sent by the server, it's mainly made for - * showing problems with the server and need attention from the user. - */ -@Suppress("unused") -class StatusMessage : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusMessage { - __init(_i, _bb) - return this - } - /** - * The status ID - */ - val id : UInt - get() { - val o = __offset(4) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - /** - * This should be prioritized in the GUI in some way if true - */ - val prioritized : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val dataType : UByte - get() { - val o = __offset(8) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun data(obj: Table) : Table? { - val o = __offset(10); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusMessage(_bb: ByteBuffer): StatusMessage = getRootAsStatusMessage(_bb, StatusMessage()) - @JvmStatic - fun getRootAsStatusMessage(_bb: ByteBuffer, obj: StatusMessage): StatusMessage { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusMessage(builder: FlatBufferBuilder, id: UInt, prioritized: Boolean, dataType: UByte, dataOffset: Int) : Int { - builder.startTable(4) - addData(builder, dataOffset) - addId(builder, id) - addDataType(builder, dataType) - addPrioritized(builder, prioritized) - return endStatusMessage(builder) - } - @JvmStatic - fun startStatusMessage(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: UInt) = builder.addInt(0, id.toInt(), 0) - @JvmStatic - fun addPrioritized(builder: FlatBufferBuilder, prioritized: Boolean) = builder.addBoolean(1, prioritized, false) - @JvmStatic - fun addDataType(builder: FlatBufferBuilder, dataType: UByte) = builder.addByte(2, dataType.toByte(), 0) - @JvmStatic - fun addData(builder: FlatBufferBuilder, data: Int) = builder.addOffset(3, data, 0) - @JvmStatic - fun endStatusMessage(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt deleted file mode 100644 index 1f47c0c8c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * When the server detects a public network profile - */ -@Suppress("unused") -class StatusPublicNetwork : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusPublicNetwork { - __init(_i, _bb) - return this - } - /** - * names of the adapters set to public - */ - fun adapters(j: Int) : String? { - val o = __offset(4) - return if (o != 0) { - __string(__vector(o) + j * 4) - } else { - null - } - } - val adaptersLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusPublicNetwork(_bb: ByteBuffer): StatusPublicNetwork = getRootAsStatusPublicNetwork(_bb, StatusPublicNetwork()) - @JvmStatic - fun getRootAsStatusPublicNetwork(_bb: ByteBuffer, obj: StatusPublicNetwork): StatusPublicNetwork { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusPublicNetwork(builder: FlatBufferBuilder, adaptersOffset: Int) : Int { - builder.startTable(1) - addAdapters(builder, adaptersOffset) - return endStatusPublicNetwork(builder) - } - @JvmStatic - fun startStatusPublicNetwork(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addAdapters(builder: FlatBufferBuilder, adapters: Int) = builder.addOffset(0, adapters, 0) - @JvmStatic - fun createAdaptersVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startAdaptersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endStatusPublicNetwork(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.kt deleted file mode 100644 index 9bd3b565b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSteamVRDisconnected.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * SteamVR bridge is disconnected - */ -@Suppress("unused") -class StatusSteamVRDisconnected : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusSteamVRDisconnected { - __init(_i, _bb) - return this - } - /** - * Name of bridge in the server's config - */ - val bridgeSettingsName : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val bridgeSettingsNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun bridgeSettingsNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusSteamVRDisconnected(_bb: ByteBuffer): StatusSteamVRDisconnected = getRootAsStatusSteamVRDisconnected(_bb, StatusSteamVRDisconnected()) - @JvmStatic - fun getRootAsStatusSteamVRDisconnected(_bb: ByteBuffer, obj: StatusSteamVRDisconnected): StatusSteamVRDisconnected { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusSteamVRDisconnected(builder: FlatBufferBuilder, bridgeSettingsNameOffset: Int) : Int { - builder.startTable(1) - addBridgeSettingsName(builder, bridgeSettingsNameOffset) - return endStatusSteamVRDisconnected(builder) - } - @JvmStatic - fun startStatusSteamVRDisconnected(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addBridgeSettingsName(builder: FlatBufferBuilder, bridgeSettingsName: Int) = builder.addOffset(0, bridgeSettingsName, 0) - @JvmStatic - fun endStatusSteamVRDisconnected(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemFixed.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemFixed.kt deleted file mode 100644 index 91656b15f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemFixed.kt +++ /dev/null @@ -1,53 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * When an status is fixed and it's removed, it's ID is sent - */ -@Suppress("unused") -class StatusSystemFixed : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusSystemFixed { - __init(_i, _bb) - return this - } - val fixedStatusId : UInt - get() { - val o = __offset(4) - return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusSystemFixed(_bb: ByteBuffer): StatusSystemFixed = getRootAsStatusSystemFixed(_bb, StatusSystemFixed()) - @JvmStatic - fun getRootAsStatusSystemFixed(_bb: ByteBuffer, obj: StatusSystemFixed): StatusSystemFixed { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusSystemFixed(builder: FlatBufferBuilder, fixedStatusId: UInt) : Int { - builder.startTable(1) - addFixedStatusId(builder, fixedStatusId) - return endStatusSystemFixed(builder) - } - @JvmStatic - fun startStatusSystemFixed(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addFixedStatusId(builder: FlatBufferBuilder, fixedStatusId: UInt) = builder.addInt(0, fixedStatusId.toInt(), 0) - @JvmStatic - fun endStatusSystemFixed(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemRequest.kt deleted file mode 100644 index 391449ca7..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Request current statuses that we have - */ -@Suppress("unused") -class StatusSystemRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusSystemRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusSystemRequest(_bb: ByteBuffer): StatusSystemRequest = getRootAsStatusSystemRequest(_bb, StatusSystemRequest()) - @JvmStatic - fun getRootAsStatusSystemRequest(_bb: ByteBuffer, obj: StatusSystemRequest): StatusSystemRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startStatusSystemRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endStatusSystemRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemResponse.kt deleted file mode 100644 index ee7d9b044..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemResponse.kt +++ /dev/null @@ -1,71 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Response containing all current valid statuses - */ -@Suppress("unused") -class StatusSystemResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusSystemResponse { - __init(_i, _bb) - return this - } - fun currentStatuses(j: Int) : solarxr_protocol.rpc.StatusMessage? = currentStatuses(solarxr_protocol.rpc.StatusMessage(), j) - fun currentStatuses(obj: solarxr_protocol.rpc.StatusMessage, j: Int) : solarxr_protocol.rpc.StatusMessage? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val currentStatusesLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusSystemResponse(_bb: ByteBuffer): StatusSystemResponse = getRootAsStatusSystemResponse(_bb, StatusSystemResponse()) - @JvmStatic - fun getRootAsStatusSystemResponse(_bb: ByteBuffer, obj: StatusSystemResponse): StatusSystemResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusSystemResponse(builder: FlatBufferBuilder, currentStatusesOffset: Int) : Int { - builder.startTable(1) - addCurrentStatuses(builder, currentStatusesOffset) - return endStatusSystemResponse(builder) - } - @JvmStatic - fun startStatusSystemResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addCurrentStatuses(builder: FlatBufferBuilder, currentStatuses: Int) = builder.addOffset(0, currentStatuses, 0) - @JvmStatic - fun createCurrentStatusesVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startCurrentStatusesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endStatusSystemResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemUpdate.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemUpdate.kt deleted file mode 100644 index 57e385933..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusSystemUpdate.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * When a new status appears, it's sent alone - */ -@Suppress("unused") -class StatusSystemUpdate : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusSystemUpdate { - __init(_i, _bb) - return this - } - val newStatus : solarxr_protocol.rpc.StatusMessage? get() = newStatus(solarxr_protocol.rpc.StatusMessage()) - fun newStatus(obj: solarxr_protocol.rpc.StatusMessage) : solarxr_protocol.rpc.StatusMessage? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusSystemUpdate(_bb: ByteBuffer): StatusSystemUpdate = getRootAsStatusSystemUpdate(_bb, StatusSystemUpdate()) - @JvmStatic - fun getRootAsStatusSystemUpdate(_bb: ByteBuffer, obj: StatusSystemUpdate): StatusSystemUpdate { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusSystemUpdate(builder: FlatBufferBuilder, newStatusOffset: Int) : Int { - builder.startTable(1) - addNewStatus(builder, newStatusOffset) - return endStatusSystemUpdate(builder) - } - @JvmStatic - fun startStatusSystemUpdate(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addNewStatus(builder: FlatBufferBuilder, newStatus: Int) = builder.addOffset(0, newStatus, 0) - @JvmStatic - fun endStatusSystemUpdate(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt deleted file mode 100644 index cf0440443..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt +++ /dev/null @@ -1,71 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Trackers with error state - */ -@Suppress("unused") -class StatusTrackerError : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusTrackerError { - __init(_i, _bb) - return this - } - fun trackerId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackerId(solarxr_protocol.datatypes.TrackerId(), j) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackerIdLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusTrackerError(_bb: ByteBuffer): StatusTrackerError = getRootAsStatusTrackerError(_bb, StatusTrackerError()) - @JvmStatic - fun getRootAsStatusTrackerError(_bb: ByteBuffer, obj: StatusTrackerError): StatusTrackerError { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusTrackerError(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endStatusTrackerError(builder) - } - @JvmStatic - fun startStatusTrackerError(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun createTrackerIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackerIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endStatusTrackerError(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt deleted file mode 100644 index c912d612b..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt +++ /dev/null @@ -1,71 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Tracker requires full reset - */ -@Suppress("unused") -class StatusTrackerReset : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusTrackerReset { - __init(_i, _bb) - return this - } - fun trackerId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackerId(solarxr_protocol.datatypes.TrackerId(), j) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackerIdLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusTrackerReset(_bb: ByteBuffer): StatusTrackerReset = getRootAsStatusTrackerReset(_bb, StatusTrackerReset()) - @JvmStatic - fun getRootAsStatusTrackerReset(_bb: ByteBuffer, obj: StatusTrackerReset): StatusTrackerReset { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusTrackerReset(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endStatusTrackerReset(builder) - } - @JvmStatic - fun startStatusTrackerReset(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun createTrackerIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackerIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endStatusTrackerReset(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusUnassignedHMD.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusUnassignedHMD.kt deleted file mode 100644 index 88bfcba95..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusUnassignedHMD.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * There is an available HMD tracker and it's not assigned to head - */ -@Suppress("unused") -class StatusUnassignedHMD : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StatusUnassignedHMD { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStatusUnassignedHMD(_bb: ByteBuffer): StatusUnassignedHMD = getRootAsStatusUnassignedHMD(_bb, StatusUnassignedHMD()) - @JvmStatic - fun getRootAsStatusUnassignedHMD(_bb: ByteBuffer, obj: StatusUnassignedHMD): StatusUnassignedHMD { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStatusUnassignedHMD(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endStatusUnassignedHMD(builder) - } - @JvmStatic - fun startStatusUnassignedHMD(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun endStatusUnassignedHMD(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedRelaxedPose.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedRelaxedPose.kt deleted file mode 100644 index 31dd35081..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedRelaxedPose.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class StayAlignedRelaxedPose private constructor() { - companion object { - const val STANDING: UByte = 0u - const val SITTING: UByte = 1u - const val FLAT: UByte = 2u - val names : Array = arrayOf("STANDING", "SITTING", "FLAT") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedSettings.kt deleted file mode 100644 index fd789e2b5..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StayAlignedSettings.kt +++ /dev/null @@ -1,170 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StayAlignedSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StayAlignedSettings { - __init(_i, _bb) - return this - } - val enabled : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val extraYawCorrection : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val hideYawCorrection : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val standingEnabled : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val standingUpperLegAngle : Float - get() { - val o = __offset(12) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val standingLowerLegAngle : Float - get() { - val o = __offset(14) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val standingFootAngle : Float - get() { - val o = __offset(16) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val sittingEnabled : Boolean - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val sittingUpperLegAngle : Float - get() { - val o = __offset(20) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val sittingLowerLegAngle : Float - get() { - val o = __offset(22) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val sittingFootAngle : Float - get() { - val o = __offset(24) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val flatEnabled : Boolean - get() { - val o = __offset(26) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val flatUpperLegAngle : Float - get() { - val o = __offset(28) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val flatLowerLegAngle : Float - get() { - val o = __offset(30) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val flatFootAngle : Float - get() { - val o = __offset(32) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val setupComplete : Boolean - get() { - val o = __offset(34) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStayAlignedSettings(_bb: ByteBuffer): StayAlignedSettings = getRootAsStayAlignedSettings(_bb, StayAlignedSettings()) - @JvmStatic - fun getRootAsStayAlignedSettings(_bb: ByteBuffer, obj: StayAlignedSettings): StayAlignedSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createStayAlignedSettings(builder: FlatBufferBuilder, enabled: Boolean, extraYawCorrection: Boolean, hideYawCorrection: Boolean, standingEnabled: Boolean, standingUpperLegAngle: Float, standingLowerLegAngle: Float, standingFootAngle: Float, sittingEnabled: Boolean, sittingUpperLegAngle: Float, sittingLowerLegAngle: Float, sittingFootAngle: Float, flatEnabled: Boolean, flatUpperLegAngle: Float, flatLowerLegAngle: Float, flatFootAngle: Float, setupComplete: Boolean) : Int { - builder.startTable(16) - addFlatFootAngle(builder, flatFootAngle) - addFlatLowerLegAngle(builder, flatLowerLegAngle) - addFlatUpperLegAngle(builder, flatUpperLegAngle) - addSittingFootAngle(builder, sittingFootAngle) - addSittingLowerLegAngle(builder, sittingLowerLegAngle) - addSittingUpperLegAngle(builder, sittingUpperLegAngle) - addStandingFootAngle(builder, standingFootAngle) - addStandingLowerLegAngle(builder, standingLowerLegAngle) - addStandingUpperLegAngle(builder, standingUpperLegAngle) - addSetupComplete(builder, setupComplete) - addFlatEnabled(builder, flatEnabled) - addSittingEnabled(builder, sittingEnabled) - addStandingEnabled(builder, standingEnabled) - addHideYawCorrection(builder, hideYawCorrection) - addExtraYawCorrection(builder, extraYawCorrection) - addEnabled(builder, enabled) - return endStayAlignedSettings(builder) - } - @JvmStatic - fun startStayAlignedSettings(builder: FlatBufferBuilder) = builder.startTable(16) - @JvmStatic - fun addEnabled(builder: FlatBufferBuilder, enabled: Boolean) = builder.addBoolean(0, enabled, false) - @JvmStatic - fun addExtraYawCorrection(builder: FlatBufferBuilder, extraYawCorrection: Boolean) = builder.addBoolean(1, extraYawCorrection, false) - @JvmStatic - fun addHideYawCorrection(builder: FlatBufferBuilder, hideYawCorrection: Boolean) = builder.addBoolean(2, hideYawCorrection, false) - @JvmStatic - fun addStandingEnabled(builder: FlatBufferBuilder, standingEnabled: Boolean) = builder.addBoolean(3, standingEnabled, false) - @JvmStatic - fun addStandingUpperLegAngle(builder: FlatBufferBuilder, standingUpperLegAngle: Float) = builder.addFloat(4, standingUpperLegAngle, 0.0) - @JvmStatic - fun addStandingLowerLegAngle(builder: FlatBufferBuilder, standingLowerLegAngle: Float) = builder.addFloat(5, standingLowerLegAngle, 0.0) - @JvmStatic - fun addStandingFootAngle(builder: FlatBufferBuilder, standingFootAngle: Float) = builder.addFloat(6, standingFootAngle, 0.0) - @JvmStatic - fun addSittingEnabled(builder: FlatBufferBuilder, sittingEnabled: Boolean) = builder.addBoolean(7, sittingEnabled, false) - @JvmStatic - fun addSittingUpperLegAngle(builder: FlatBufferBuilder, sittingUpperLegAngle: Float) = builder.addFloat(8, sittingUpperLegAngle, 0.0) - @JvmStatic - fun addSittingLowerLegAngle(builder: FlatBufferBuilder, sittingLowerLegAngle: Float) = builder.addFloat(9, sittingLowerLegAngle, 0.0) - @JvmStatic - fun addSittingFootAngle(builder: FlatBufferBuilder, sittingFootAngle: Float) = builder.addFloat(10, sittingFootAngle, 0.0) - @JvmStatic - fun addFlatEnabled(builder: FlatBufferBuilder, flatEnabled: Boolean) = builder.addBoolean(11, flatEnabled, false) - @JvmStatic - fun addFlatUpperLegAngle(builder: FlatBufferBuilder, flatUpperLegAngle: Float) = builder.addFloat(12, flatUpperLegAngle, 0.0) - @JvmStatic - fun addFlatLowerLegAngle(builder: FlatBufferBuilder, flatLowerLegAngle: Float) = builder.addFloat(13, flatLowerLegAngle, 0.0) - @JvmStatic - fun addFlatFootAngle(builder: FlatBufferBuilder, flatFootAngle: Float) = builder.addFloat(14, flatFootAngle, 0.0) - @JvmStatic - fun addSetupComplete(builder: FlatBufferBuilder, setupComplete: Boolean) = builder.addBoolean(15, setupComplete, false) - @JvmStatic - fun endStayAlignedSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/SteamVRTrackersSetting.kt b/protocol/kotlin/src/solarxr_protocol/rpc/SteamVRTrackersSetting.kt deleted file mode 100644 index 5befe9f25..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/SteamVRTrackersSetting.kt +++ /dev/null @@ -1,130 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SteamVRTrackersSetting : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SteamVRTrackersSetting { - __init(_i, _bb) - return this - } - val waist : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val chest : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val automaticTrackerToggle : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val leftFoot : Boolean - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rightFoot : Boolean - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val leftKnee : Boolean - get() { - val o = __offset(22) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rightKnee : Boolean - get() { - val o = __offset(24) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val leftElbow : Boolean - get() { - val o = __offset(26) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rightElbow : Boolean - get() { - val o = __offset(28) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val leftHand : Boolean - get() { - val o = __offset(30) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val rightHand : Boolean - get() { - val o = __offset(32) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSteamVRTrackersSetting(_bb: ByteBuffer): SteamVRTrackersSetting = getRootAsSteamVRTrackersSetting(_bb, SteamVRTrackersSetting()) - @JvmStatic - fun getRootAsSteamVRTrackersSetting(_bb: ByteBuffer, obj: SteamVRTrackersSetting): SteamVRTrackersSetting { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSteamVRTrackersSetting(builder: FlatBufferBuilder, waist: Boolean, chest: Boolean, automaticTrackerToggle: Boolean, leftFoot: Boolean, rightFoot: Boolean, leftKnee: Boolean, rightKnee: Boolean, leftElbow: Boolean, rightElbow: Boolean, leftHand: Boolean, rightHand: Boolean) : Int { - builder.startTable(15) - addRightHand(builder, rightHand) - addLeftHand(builder, leftHand) - addRightElbow(builder, rightElbow) - addLeftElbow(builder, leftElbow) - addRightKnee(builder, rightKnee) - addLeftKnee(builder, leftKnee) - addRightFoot(builder, rightFoot) - addLeftFoot(builder, leftFoot) - addAutomaticTrackerToggle(builder, automaticTrackerToggle) - addChest(builder, chest) - addWaist(builder, waist) - return endSteamVRTrackersSetting(builder) - } - @JvmStatic - fun startSteamVRTrackersSetting(builder: FlatBufferBuilder) = builder.startTable(15) - @JvmStatic - fun addWaist(builder: FlatBufferBuilder, waist: Boolean) = builder.addBoolean(0, waist, false) - @JvmStatic - fun addChest(builder: FlatBufferBuilder, chest: Boolean) = builder.addBoolean(1, chest, false) - @JvmStatic - fun addAutomaticTrackerToggle(builder: FlatBufferBuilder, automaticTrackerToggle: Boolean) = builder.addBoolean(6, automaticTrackerToggle, false) - @JvmStatic - fun addLeftFoot(builder: FlatBufferBuilder, leftFoot: Boolean) = builder.addBoolean(7, leftFoot, false) - @JvmStatic - fun addRightFoot(builder: FlatBufferBuilder, rightFoot: Boolean) = builder.addBoolean(8, rightFoot, false) - @JvmStatic - fun addLeftKnee(builder: FlatBufferBuilder, leftKnee: Boolean) = builder.addBoolean(9, leftKnee, false) - @JvmStatic - fun addRightKnee(builder: FlatBufferBuilder, rightKnee: Boolean) = builder.addBoolean(10, rightKnee, false) - @JvmStatic - fun addLeftElbow(builder: FlatBufferBuilder, leftElbow: Boolean) = builder.addBoolean(11, leftElbow, false) - @JvmStatic - fun addRightElbow(builder: FlatBufferBuilder, rightElbow: Boolean) = builder.addBoolean(12, rightElbow, false) - @JvmStatic - fun addLeftHand(builder: FlatBufferBuilder, leftHand: Boolean) = builder.addBoolean(13, leftHand, false) - @JvmStatic - fun addRightHand(builder: FlatBufferBuilder, rightHand: Boolean) = builder.addBoolean(14, rightHand, false) - @JvmStatic - fun endSteamVRTrackersSetting(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StopWifiProvisioningRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StopWifiProvisioningRequest.kt deleted file mode 100644 index 287fb99c0..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StopWifiProvisioningRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class StopWifiProvisioningRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : StopWifiProvisioningRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsStopWifiProvisioningRequest(_bb: ByteBuffer): StopWifiProvisioningRequest = getRootAsStopWifiProvisioningRequest(_bb, StopWifiProvisioningRequest()) - @JvmStatic - fun getRootAsStopWifiProvisioningRequest(_bb: ByteBuffer, obj: StopWifiProvisioningRequest): StopWifiProvisioningRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startStopWifiProvisioningRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endStopWifiProvisioningRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TapDetectionSetupNotification.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TapDetectionSetupNotification.kt deleted file mode 100644 index 0d73e6f87..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TapDetectionSetupNotification.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * See TapDetectionSettings::setup_mode - */ -@Suppress("unused") -class TapDetectionSetupNotification : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TapDetectionSetupNotification { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTapDetectionSetupNotification(_bb: ByteBuffer): TapDetectionSetupNotification = getRootAsTapDetectionSetupNotification(_bb, TapDetectionSetupNotification()) - @JvmStatic - fun getRootAsTapDetectionSetupNotification(_bb: ByteBuffer, obj: TapDetectionSetupNotification): TapDetectionSetupNotification { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTapDetectionSetupNotification(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endTapDetectionSetupNotification(builder) - } - @JvmStatic - fun startTapDetectionSetupNotification(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun endTapDetectionSetupNotification(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt deleted file mode 100644 index 13ef0e6bc..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt +++ /dev/null @@ -1,19 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class TrackingChecklistExtraData private constructor() { - companion object { - const val NONE: UByte = 0u - const val TrackingChecklistTrackerReset: UByte = 1u - const val TrackingChecklistTrackerError: UByte = 2u - const val TrackingChecklistSteamVRDisconnected: UByte = 3u - const val TrackingChecklistUnassignedHMD: UByte = 4u - const val TrackingChecklistNeedCalibration: UByte = 5u - const val TrackingChecklistPublicNetworks: UByte = 6u - val names : Array = arrayOf("NONE", "TrackingChecklistTrackerReset", "TrackingChecklistTrackerError", "TrackingChecklistSteamVRDisconnected", "TrackingChecklistUnassignedHMD", "TrackingChecklistNeedCalibration", "TrackingChecklistPublicNetworks") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt deleted file mode 100644 index cb43b152a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt +++ /dev/null @@ -1,68 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistNeedCalibration : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistNeedCalibration { - __init(_i, _bb) - return this - } - fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) - fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackersIdLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistNeedCalibration(_bb: ByteBuffer): TrackingChecklistNeedCalibration = getRootAsTrackingChecklistNeedCalibration(_bb, TrackingChecklistNeedCalibration()) - @JvmStatic - fun getRootAsTrackingChecklistNeedCalibration(_bb: ByteBuffer, obj: TrackingChecklistNeedCalibration): TrackingChecklistNeedCalibration { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistNeedCalibration(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { - builder.startTable(1) - addTrackersId(builder, trackersIdOffset) - return endTrackingChecklistNeedCalibration(builder) - } - @JvmStatic - fun startTrackingChecklistNeedCalibration(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) - @JvmStatic - fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endTrackingChecklistNeedCalibration(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt deleted file mode 100644 index c9d59f3f6..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt +++ /dev/null @@ -1,67 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistPublicNetworks : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistPublicNetworks { - __init(_i, _bb) - return this - } - fun adapters(j: Int) : String? { - val o = __offset(4) - return if (o != 0) { - __string(__vector(o) + j * 4) - } else { - null - } - } - val adaptersLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistPublicNetworks(_bb: ByteBuffer): TrackingChecklistPublicNetworks = getRootAsTrackingChecklistPublicNetworks(_bb, TrackingChecklistPublicNetworks()) - @JvmStatic - fun getRootAsTrackingChecklistPublicNetworks(_bb: ByteBuffer, obj: TrackingChecklistPublicNetworks): TrackingChecklistPublicNetworks { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistPublicNetworks(builder: FlatBufferBuilder, adaptersOffset: Int) : Int { - builder.startTable(1) - addAdapters(builder, adaptersOffset) - return endTrackingChecklistPublicNetworks(builder) - } - @JvmStatic - fun startTrackingChecklistPublicNetworks(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addAdapters(builder: FlatBufferBuilder, adapters: Int) = builder.addOffset(0, adapters, 0) - @JvmStatic - fun createAdaptersVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startAdaptersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endTrackingChecklistPublicNetworks(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt deleted file mode 100644 index 3dbc280d4..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistRequest(_bb: ByteBuffer): TrackingChecklistRequest = getRootAsTrackingChecklistRequest(_bb, TrackingChecklistRequest()) - @JvmStatic - fun getRootAsTrackingChecklistRequest(_bb: ByteBuffer, obj: TrackingChecklistRequest): TrackingChecklistRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startTrackingChecklistRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endTrackingChecklistRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt deleted file mode 100644 index 40d2bae3a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt +++ /dev/null @@ -1,95 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistResponse { - __init(_i, _bb) - return this - } - fun steps(j: Int) : solarxr_protocol.rpc.TrackingChecklistStep? = steps(solarxr_protocol.rpc.TrackingChecklistStep(), j) - fun steps(obj: solarxr_protocol.rpc.TrackingChecklistStep, j: Int) : solarxr_protocol.rpc.TrackingChecklistStep? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val stepsLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - fun ignoredSteps(j: Int) : UByte { - val o = __offset(6) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val ignoredStepsLength : Int - get() { - val o = __offset(6); return if (o != 0) __vector_len(o) else 0 - } - val ignoredStepsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) - fun ignoredStepsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistResponse(_bb: ByteBuffer): TrackingChecklistResponse = getRootAsTrackingChecklistResponse(_bb, TrackingChecklistResponse()) - @JvmStatic - fun getRootAsTrackingChecklistResponse(_bb: ByteBuffer, obj: TrackingChecklistResponse): TrackingChecklistResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistResponse(builder: FlatBufferBuilder, stepsOffset: Int, ignoredStepsOffset: Int) : Int { - builder.startTable(2) - addIgnoredSteps(builder, ignoredStepsOffset) - addSteps(builder, stepsOffset) - return endTrackingChecklistResponse(builder) - } - @JvmStatic - fun startTrackingChecklistResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addSteps(builder: FlatBufferBuilder, steps: Int) = builder.addOffset(0, steps, 0) - @JvmStatic - fun createStepsVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startStepsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun addIgnoredSteps(builder: FlatBufferBuilder, ignoredSteps: Int) = builder.addOffset(1, ignoredSteps, 0) - @JvmStatic - fun createIgnoredStepsVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startIgnoredStepsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun endTrackingChecklistResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt deleted file mode 100644 index 01a0cd07f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt +++ /dev/null @@ -1,104 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistStep : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistStep { - __init(_i, _bb) - return this - } - val id : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val valid : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val enabled : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val visibility : UByte - get() { - val o = __offset(10) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val optional : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val ignorable : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val extraDataType : UByte - get() { - val o = __offset(16) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun extraData(obj: Table) : Table? { - val o = __offset(18); return if (o != 0) __union(obj, o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistStep(_bb: ByteBuffer): TrackingChecklistStep = getRootAsTrackingChecklistStep(_bb, TrackingChecklistStep()) - @JvmStatic - fun getRootAsTrackingChecklistStep(_bb: ByteBuffer, obj: TrackingChecklistStep): TrackingChecklistStep { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistStep(builder: FlatBufferBuilder, id: UByte, valid: Boolean, enabled: Boolean, visibility: UByte, optional: Boolean, ignorable: Boolean, extraDataType: UByte, extraDataOffset: Int) : Int { - builder.startTable(8) - addExtraData(builder, extraDataOffset) - addExtraDataType(builder, extraDataType) - addIgnorable(builder, ignorable) - addOptional(builder, optional) - addVisibility(builder, visibility) - addEnabled(builder, enabled) - addValid(builder, valid) - addId(builder, id) - return endTrackingChecklistStep(builder) - } - @JvmStatic - fun startTrackingChecklistStep(builder: FlatBufferBuilder) = builder.startTable(8) - @JvmStatic - fun addId(builder: FlatBufferBuilder, id: UByte) = builder.addByte(0, id.toByte(), 0) - @JvmStatic - fun addValid(builder: FlatBufferBuilder, valid: Boolean) = builder.addBoolean(1, valid, false) - @JvmStatic - fun addEnabled(builder: FlatBufferBuilder, enabled: Boolean) = builder.addBoolean(2, enabled, false) - @JvmStatic - fun addVisibility(builder: FlatBufferBuilder, visibility: UByte) = builder.addByte(3, visibility.toByte(), 0) - @JvmStatic - fun addOptional(builder: FlatBufferBuilder, optional: Boolean) = builder.addBoolean(4, optional, false) - @JvmStatic - fun addIgnorable(builder: FlatBufferBuilder, ignorable: Boolean) = builder.addBoolean(5, ignorable, false) - @JvmStatic - fun addExtraDataType(builder: FlatBufferBuilder, extraDataType: UByte) = builder.addByte(6, extraDataType.toByte(), 0) - @JvmStatic - fun addExtraData(builder: FlatBufferBuilder, extraData: Int) = builder.addOffset(7, extraData, 0) - @JvmStatic - fun endTrackingChecklistStep(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt deleted file mode 100644 index 8e9164be1..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt +++ /dev/null @@ -1,14 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class TrackingChecklistStepVisibility private constructor() { - companion object { - const val ALWAYS: UByte = 0u - const val WHENINVALID: UByte = 1u - val names : Array = arrayOf("ALWAYS", "WHEN_INVALID") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt deleted file mode 100644 index 84962e66a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt +++ /dev/null @@ -1,71 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Trackers with error state - */ -@Suppress("unused") -class TrackingChecklistTrackerError : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistTrackerError { - __init(_i, _bb) - return this - } - fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) - fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackersIdLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistTrackerError(_bb: ByteBuffer): TrackingChecklistTrackerError = getRootAsTrackingChecklistTrackerError(_bb, TrackingChecklistTrackerError()) - @JvmStatic - fun getRootAsTrackingChecklistTrackerError(_bb: ByteBuffer, obj: TrackingChecklistTrackerError): TrackingChecklistTrackerError { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistTrackerError(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { - builder.startTable(1) - addTrackersId(builder, trackersIdOffset) - return endTrackingChecklistTrackerError(builder) - } - @JvmStatic - fun startTrackingChecklistTrackerError(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) - @JvmStatic - fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endTrackingChecklistTrackerError(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt deleted file mode 100644 index f3979fb89..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt +++ /dev/null @@ -1,71 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Trackers that need a reset - */ -@Suppress("unused") -class TrackingChecklistTrackerReset : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistTrackerReset { - __init(_i, _bb) - return this - } - fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) - fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(__vector(o) + j * 4), bb) - } else { - null - } - } - val trackersIdLength : Int - get() { - val o = __offset(4); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistTrackerReset(_bb: ByteBuffer): TrackingChecklistTrackerReset = getRootAsTrackingChecklistTrackerReset(_bb, TrackingChecklistTrackerReset()) - @JvmStatic - fun getRootAsTrackingChecklistTrackerReset(_bb: ByteBuffer, obj: TrackingChecklistTrackerReset): TrackingChecklistTrackerReset { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistTrackerReset(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { - builder.startTable(1) - addTrackersId(builder, trackersIdOffset) - return endTrackingChecklistTrackerReset(builder) - } - @JvmStatic - fun startTrackingChecklistTrackerReset(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) - @JvmStatic - fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endTrackingChecklistTrackerReset(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt deleted file mode 100644 index 1f4fae3b8..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingChecklistUnassignedHMD : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistUnassignedHMD { - __init(_i, _bb) - return this - } - val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) - fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingChecklistUnassignedHMD(_bb: ByteBuffer): TrackingChecklistUnassignedHMD = getRootAsTrackingChecklistUnassignedHMD(_bb, TrackingChecklistUnassignedHMD()) - @JvmStatic - fun getRootAsTrackingChecklistUnassignedHMD(_bb: ByteBuffer, obj: TrackingChecklistUnassignedHMD): TrackingChecklistUnassignedHMD { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { - builder.startTable(1) - addTrackerId(builder, trackerIdOffset) - return endTrackingChecklistUnassignedHMD(builder) - } - @JvmStatic - fun startTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) - @JvmStatic - fun endTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateRequest.kt deleted file mode 100644 index f2aa5eb01..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateRequest.kt +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Requests the current state of tracking pause - */ -@Suppress("unused") -class TrackingPauseStateRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingPauseStateRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingPauseStateRequest(_bb: ByteBuffer): TrackingPauseStateRequest = getRootAsTrackingPauseStateRequest(_bb, TrackingPauseStateRequest()) - @JvmStatic - fun getRootAsTrackingPauseStateRequest(_bb: ByteBuffer, obj: TrackingPauseStateRequest): TrackingPauseStateRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startTrackingPauseStateRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endTrackingPauseStateRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateResponse.kt deleted file mode 100644 index 256c1a3d6..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingPauseStateResponse.kt +++ /dev/null @@ -1,53 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class TrackingPauseStateResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : TrackingPauseStateResponse { - __init(_i, _bb) - return this - } - /** - * Skeleton tracking is paused if true, skeleton tracking is unpaused if false. - */ - val trackingPaused : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsTrackingPauseStateResponse(_bb: ByteBuffer): TrackingPauseStateResponse = getRootAsTrackingPauseStateResponse(_bb, TrackingPauseStateResponse()) - @JvmStatic - fun getRootAsTrackingPauseStateResponse(_bb: ByteBuffer, obj: TrackingPauseStateResponse): TrackingPauseStateResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createTrackingPauseStateResponse(builder: FlatBufferBuilder, trackingPaused: Boolean) : Int { - builder.startTable(1) - addTrackingPaused(builder, trackingPaused) - return endTrackingPauseStateResponse(builder) - } - @JvmStatic - fun startTrackingPauseStateResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addTrackingPaused(builder: FlatBufferBuilder, trackingPaused: Boolean) = builder.addBoolean(0, trackingPaused, false) - @JvmStatic - fun endTrackingPauseStateResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UnknownDeviceHandshakeNotification.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UnknownDeviceHandshakeNotification.kt deleted file mode 100644 index d4fae87f1..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/UnknownDeviceHandshakeNotification.kt +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Server notifies connection of an unknown device. - * If the notification is no longer sent, it means the device connected to another - * server, got connected to this server or it was turned off. - */ -@Suppress("unused") -class UnknownDeviceHandshakeNotification : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : UnknownDeviceHandshakeNotification { - __init(_i, _bb) - return this - } - val macAddress : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val macAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun macAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsUnknownDeviceHandshakeNotification(_bb: ByteBuffer): UnknownDeviceHandshakeNotification = getRootAsUnknownDeviceHandshakeNotification(_bb, UnknownDeviceHandshakeNotification()) - @JvmStatic - fun getRootAsUnknownDeviceHandshakeNotification(_bb: ByteBuffer, obj: UnknownDeviceHandshakeNotification): UnknownDeviceHandshakeNotification { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createUnknownDeviceHandshakeNotification(builder: FlatBufferBuilder, macAddressOffset: Int) : Int { - builder.startTable(1) - addMacAddress(builder, macAddressOffset) - return endUnknownDeviceHandshakeNotification(builder) - } - @JvmStatic - fun startUnknownDeviceHandshakeNotification(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addMacAddress(builder: FlatBufferBuilder, macAddress: Int) = builder.addOffset(0, macAddress, 0) - @JvmStatic - fun endUnknownDeviceHandshakeNotification(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightCalibrationStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightCalibrationStatus.kt deleted file mode 100644 index b8770fb5c..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightCalibrationStatus.kt +++ /dev/null @@ -1,22 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class UserHeightCalibrationStatus private constructor() { - companion object { - const val NONE: UByte = 0u - const val RECORDINGFLOOR: UByte = 1u - const val WAITINGFORCONTROLLERPITCH: UByte = 2u - const val WAITINGFORRISE: UByte = 3u - const val WAITINGFORFWLOOK: UByte = 4u - const val RECORDINGHEIGHT: UByte = 5u - const val DONE: UByte = 6u - const val ERRORTOOHIGH: UByte = 7u - const val ERRORTOOSMALL: UByte = 8u - const val ERRORTIMEOUT: UByte = 9u - val names : Array = arrayOf("NONE", "RECORDING_FLOOR", "WAITING_FOR_CONTROLLER_PITCH", "WAITING_FOR_RISE", "WAITING_FOR_FW_LOOK", "RECORDING_HEIGHT", "DONE", "ERROR_TOO_HIGH", "ERROR_TOO_SMALL", "ERROR_TIMEOUT") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightRecordingStatusResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightRecordingStatusResponse.kt deleted file mode 100644 index 3b8b6a5f6..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/UserHeightRecordingStatusResponse.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class UserHeightRecordingStatusResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : UserHeightRecordingStatusResponse { - __init(_i, _bb) - return this - } - val hmdHeight : Float - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val status : UByte - get() { - val o = __offset(6) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsUserHeightRecordingStatusResponse(_bb: ByteBuffer): UserHeightRecordingStatusResponse = getRootAsUserHeightRecordingStatusResponse(_bb, UserHeightRecordingStatusResponse()) - @JvmStatic - fun getRootAsUserHeightRecordingStatusResponse(_bb: ByteBuffer, obj: UserHeightRecordingStatusResponse): UserHeightRecordingStatusResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createUserHeightRecordingStatusResponse(builder: FlatBufferBuilder, hmdHeight: Float, status: UByte) : Int { - builder.startTable(2) - addHmdHeight(builder, hmdHeight) - addStatus(builder, status) - return endUserHeightRecordingStatusResponse(builder) - } - @JvmStatic - fun startUserHeightRecordingStatusResponse(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addHmdHeight(builder: FlatBufferBuilder, hmdHeight: Float) = builder.addFloat(0, hmdHeight, 0.0) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(1, status.toByte(), 0) - @JvmStatic - fun endUserHeightRecordingStatusResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCAvatarMeasurementType.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCAvatarMeasurementType.kt deleted file mode 100644 index 68ed8fc87..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCAvatarMeasurementType.kt +++ /dev/null @@ -1,15 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class VRCAvatarMeasurementType private constructor() { - companion object { - const val UNKNOWN: UByte = 0u - const val HEIGHT: UByte = 1u - const val ARMSPAN: UByte = 2u - val names : Array = arrayOf("UNKNOWN", "HEIGHT", "ARM_SPAN") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigRecommendedValues.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigRecommendedValues.kt deleted file mode 100644 index e83749152..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigRecommendedValues.kt +++ /dev/null @@ -1,133 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class VRCConfigRecommendedValues : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigRecommendedValues { - __init(_i, _bb) - return this - } - val legacyMode : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val shoulderTrackingDisabled : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val userHeight : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val calibrationRange : Float - get() { - val o = __offset(10) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val calibrationVisuals : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val trackerModel : UByte - get() { - val o = __offset(14) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - fun spineMode(j: Int) : UByte { - val o = __offset(16) - return if (o != 0) { - bb.get(__vector(o) + j * 1).toUByte() - } else { - 0u - } - } - val spineModeLength : Int - get() { - val o = __offset(16); return if (o != 0) __vector_len(o) else 0 - } - val spineModeAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(16, 1) - fun spineModeInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 16, 1) - val avatarMeasurementType : UByte - get() { - val o = __offset(18) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val shoulderWidthCompensation : Boolean - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigRecommendedValues(_bb: ByteBuffer): VRCConfigRecommendedValues = getRootAsVRCConfigRecommendedValues(_bb, VRCConfigRecommendedValues()) - @JvmStatic - fun getRootAsVRCConfigRecommendedValues(_bb: ByteBuffer, obj: VRCConfigRecommendedValues): VRCConfigRecommendedValues { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCConfigRecommendedValues(builder: FlatBufferBuilder, legacyMode: Boolean, shoulderTrackingDisabled: Boolean, userHeight: Float, calibrationRange: Float, calibrationVisuals: Boolean, trackerModel: UByte, spineModeOffset: Int, avatarMeasurementType: UByte, shoulderWidthCompensation: Boolean) : Int { - builder.startTable(9) - addSpineMode(builder, spineModeOffset) - addCalibrationRange(builder, calibrationRange) - addUserHeight(builder, userHeight) - addShoulderWidthCompensation(builder, shoulderWidthCompensation) - addAvatarMeasurementType(builder, avatarMeasurementType) - addTrackerModel(builder, trackerModel) - addCalibrationVisuals(builder, calibrationVisuals) - addShoulderTrackingDisabled(builder, shoulderTrackingDisabled) - addLegacyMode(builder, legacyMode) - return endVRCConfigRecommendedValues(builder) - } - @JvmStatic - fun startVRCConfigRecommendedValues(builder: FlatBufferBuilder) = builder.startTable(9) - @JvmStatic - fun addLegacyMode(builder: FlatBufferBuilder, legacyMode: Boolean) = builder.addBoolean(0, legacyMode, false) - @JvmStatic - fun addShoulderTrackingDisabled(builder: FlatBufferBuilder, shoulderTrackingDisabled: Boolean) = builder.addBoolean(1, shoulderTrackingDisabled, false) - @JvmStatic - fun addUserHeight(builder: FlatBufferBuilder, userHeight: Float) = builder.addFloat(2, userHeight, 0.0) - @JvmStatic - fun addCalibrationRange(builder: FlatBufferBuilder, calibrationRange: Float) = builder.addFloat(3, calibrationRange, 0.0) - @JvmStatic - fun addCalibrationVisuals(builder: FlatBufferBuilder, calibrationVisuals: Boolean) = builder.addBoolean(4, calibrationVisuals, false) - @JvmStatic - fun addTrackerModel(builder: FlatBufferBuilder, trackerModel: UByte) = builder.addByte(5, trackerModel.toByte(), 0) - @JvmStatic - fun addSpineMode(builder: FlatBufferBuilder, spineMode: Int) = builder.addOffset(6, spineMode, 0) - @JvmStatic - fun createSpineModeVector(builder: FlatBufferBuilder, data: UByteArray) : Int { - builder.startVector(1, data.size, 1) - for (i in data.size - 1 downTo 0) { - builder.addByte(data[i].toByte()) - } - return builder.endVector() - } - @JvmStatic - fun startSpineModeVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) - @JvmStatic - fun addAvatarMeasurementType(builder: FlatBufferBuilder, avatarMeasurementType: UByte) = builder.addByte(7, avatarMeasurementType.toByte(), 0) - @JvmStatic - fun addShoulderWidthCompensation(builder: FlatBufferBuilder, shoulderWidthCompensation: Boolean) = builder.addBoolean(8, shoulderWidthCompensation, false) - @JvmStatic - fun endVRCConfigRecommendedValues(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt deleted file mode 100644 index 7c067ad70..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt +++ /dev/null @@ -1,52 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class VRCConfigSettingToggleMute : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigSettingToggleMute { - __init(_i, _bb) - return this - } - val key : String? - get() { - val o = __offset(4) - return if (o != 0) __string(o + bb_pos) else null - } - val keyAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) - fun keyInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigSettingToggleMute(_bb: ByteBuffer): VRCConfigSettingToggleMute = getRootAsVRCConfigSettingToggleMute(_bb, VRCConfigSettingToggleMute()) - @JvmStatic - fun getRootAsVRCConfigSettingToggleMute(_bb: ByteBuffer, obj: VRCConfigSettingToggleMute): VRCConfigSettingToggleMute { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCConfigSettingToggleMute(builder: FlatBufferBuilder, keyOffset: Int) : Int { - builder.startTable(1) - addKey(builder, keyOffset) - return endVRCConfigSettingToggleMute(builder) - } - @JvmStatic - fun startVRCConfigSettingToggleMute(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addKey(builder: FlatBufferBuilder, key: Int) = builder.addOffset(0, key, 0) - @JvmStatic - fun endVRCConfigSettingToggleMute(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt deleted file mode 100644 index 63eb3393e..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt +++ /dev/null @@ -1,115 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Sent every time the vrchat config state gets updated - * used to display vrchat missconfig settings to the user - */ -@Suppress("unused") -class VRCConfigStateChangeResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigStateChangeResponse { - __init(_i, _bb) - return this - } - val isSupported : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val validity : solarxr_protocol.rpc.VRCConfigValidity? get() = validity(solarxr_protocol.rpc.VRCConfigValidity()) - fun validity(obj: solarxr_protocol.rpc.VRCConfigValidity) : solarxr_protocol.rpc.VRCConfigValidity? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val state : solarxr_protocol.rpc.VRCConfigValues? get() = state(solarxr_protocol.rpc.VRCConfigValues()) - fun state(obj: solarxr_protocol.rpc.VRCConfigValues) : solarxr_protocol.rpc.VRCConfigValues? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val recommended : solarxr_protocol.rpc.VRCConfigRecommendedValues? get() = recommended(solarxr_protocol.rpc.VRCConfigRecommendedValues()) - fun recommended(obj: solarxr_protocol.rpc.VRCConfigRecommendedValues) : solarxr_protocol.rpc.VRCConfigRecommendedValues? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - fun muted(j: Int) : String? { - val o = __offset(12) - return if (o != 0) { - __string(__vector(o) + j * 4) - } else { - null - } - } - val mutedLength : Int - get() { - val o = __offset(12); return if (o != 0) __vector_len(o) else 0 - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigStateChangeResponse(_bb: ByteBuffer): VRCConfigStateChangeResponse = getRootAsVRCConfigStateChangeResponse(_bb, VRCConfigStateChangeResponse()) - @JvmStatic - fun getRootAsVRCConfigStateChangeResponse(_bb: ByteBuffer, obj: VRCConfigStateChangeResponse): VRCConfigStateChangeResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCConfigStateChangeResponse(builder: FlatBufferBuilder, isSupported: Boolean, validityOffset: Int, stateOffset: Int, recommendedOffset: Int, mutedOffset: Int) : Int { - builder.startTable(5) - addMuted(builder, mutedOffset) - addRecommended(builder, recommendedOffset) - addState(builder, stateOffset) - addValidity(builder, validityOffset) - addIsSupported(builder, isSupported) - return endVRCConfigStateChangeResponse(builder) - } - @JvmStatic - fun startVRCConfigStateChangeResponse(builder: FlatBufferBuilder) = builder.startTable(5) - @JvmStatic - fun addIsSupported(builder: FlatBufferBuilder, isSupported: Boolean) = builder.addBoolean(0, isSupported, false) - @JvmStatic - fun addValidity(builder: FlatBufferBuilder, validity: Int) = builder.addOffset(1, validity, 0) - @JvmStatic - fun addState(builder: FlatBufferBuilder, state: Int) = builder.addOffset(2, state, 0) - @JvmStatic - fun addRecommended(builder: FlatBufferBuilder, recommended: Int) = builder.addOffset(3, recommended, 0) - @JvmStatic - fun addMuted(builder: FlatBufferBuilder, muted: Int) = builder.addOffset(4, muted, 0) - @JvmStatic - fun createMutedVector(builder: FlatBufferBuilder, data: IntArray) : Int { - builder.startVector(4, data.size, 4) - for (i in data.size - 1 downTo 0) { - builder.addOffset(data[i]) - } - return builder.endVector() - } - @JvmStatic - fun startMutedVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) - @JvmStatic - fun endVRCConfigStateChangeResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateRequest.kt deleted file mode 100644 index 5911502ca..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateRequest.kt +++ /dev/null @@ -1,37 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class VRCConfigStateRequest : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigStateRequest { - __init(_i, _bb) - return this - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigStateRequest(_bb: ByteBuffer): VRCConfigStateRequest = getRootAsVRCConfigStateRequest(_bb, VRCConfigStateRequest()) - @JvmStatic - fun getRootAsVRCConfigStateRequest(_bb: ByteBuffer, obj: VRCConfigStateRequest): VRCConfigStateRequest { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun startVRCConfigStateRequest(builder: FlatBufferBuilder) = builder.startTable(0) - @JvmStatic - fun endVRCConfigStateRequest(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValidity.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValidity.kt deleted file mode 100644 index bc9add47a..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValidity.kt +++ /dev/null @@ -1,114 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class VRCConfigValidity : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigValidity { - __init(_i, _bb) - return this - } - val legacyModeOk : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val shoulderTrackingOk : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val userHeightOk : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val calibrationRangeOk : Boolean - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val calibrationVisualsOk : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val trackerModelOk : Boolean - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val spineModeOk : Boolean - get() { - val o = __offset(16) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val avatarMeasurementTypeOk : Boolean - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val shoulderWidthCompensationOk : Boolean - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigValidity(_bb: ByteBuffer): VRCConfigValidity = getRootAsVRCConfigValidity(_bb, VRCConfigValidity()) - @JvmStatic - fun getRootAsVRCConfigValidity(_bb: ByteBuffer, obj: VRCConfigValidity): VRCConfigValidity { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCConfigValidity(builder: FlatBufferBuilder, legacyModeOk: Boolean, shoulderTrackingOk: Boolean, userHeightOk: Boolean, calibrationRangeOk: Boolean, calibrationVisualsOk: Boolean, trackerModelOk: Boolean, spineModeOk: Boolean, avatarMeasurementTypeOk: Boolean, shoulderWidthCompensationOk: Boolean) : Int { - builder.startTable(9) - addShoulderWidthCompensationOk(builder, shoulderWidthCompensationOk) - addAvatarMeasurementTypeOk(builder, avatarMeasurementTypeOk) - addSpineModeOk(builder, spineModeOk) - addTrackerModelOk(builder, trackerModelOk) - addCalibrationVisualsOk(builder, calibrationVisualsOk) - addCalibrationRangeOk(builder, calibrationRangeOk) - addUserHeightOk(builder, userHeightOk) - addShoulderTrackingOk(builder, shoulderTrackingOk) - addLegacyModeOk(builder, legacyModeOk) - return endVRCConfigValidity(builder) - } - @JvmStatic - fun startVRCConfigValidity(builder: FlatBufferBuilder) = builder.startTable(9) - @JvmStatic - fun addLegacyModeOk(builder: FlatBufferBuilder, legacyModeOk: Boolean) = builder.addBoolean(0, legacyModeOk, false) - @JvmStatic - fun addShoulderTrackingOk(builder: FlatBufferBuilder, shoulderTrackingOk: Boolean) = builder.addBoolean(1, shoulderTrackingOk, false) - @JvmStatic - fun addUserHeightOk(builder: FlatBufferBuilder, userHeightOk: Boolean) = builder.addBoolean(2, userHeightOk, false) - @JvmStatic - fun addCalibrationRangeOk(builder: FlatBufferBuilder, calibrationRangeOk: Boolean) = builder.addBoolean(3, calibrationRangeOk, false) - @JvmStatic - fun addCalibrationVisualsOk(builder: FlatBufferBuilder, calibrationVisualsOk: Boolean) = builder.addBoolean(4, calibrationVisualsOk, false) - @JvmStatic - fun addTrackerModelOk(builder: FlatBufferBuilder, trackerModelOk: Boolean) = builder.addBoolean(5, trackerModelOk, false) - @JvmStatic - fun addSpineModeOk(builder: FlatBufferBuilder, spineModeOk: Boolean) = builder.addBoolean(6, spineModeOk, false) - @JvmStatic - fun addAvatarMeasurementTypeOk(builder: FlatBufferBuilder, avatarMeasurementTypeOk: Boolean) = builder.addBoolean(7, avatarMeasurementTypeOk, false) - @JvmStatic - fun addShoulderWidthCompensationOk(builder: FlatBufferBuilder, shoulderWidthCompensationOk: Boolean) = builder.addBoolean(8, shoulderWidthCompensationOk, false) - @JvmStatic - fun endVRCConfigValidity(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValues.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValues.kt deleted file mode 100644 index 910a95d6d..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigValues.kt +++ /dev/null @@ -1,114 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class VRCConfigValues : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigValues { - __init(_i, _bb) - return this - } - val legacyMode : Boolean - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val shoulderTrackingDisabled : Boolean - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val userHeight : Float - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val calibrationRange : Float - get() { - val o = __offset(10) - return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f - } - val calibrationVisuals : Boolean - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - val trackerModel : UByte - get() { - val o = __offset(14) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val spineMode : UByte - get() { - val o = __offset(16) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val avatarMeasurementType : UByte - get() { - val o = __offset(18) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - val shoulderWidthCompensation : Boolean - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCConfigValues(_bb: ByteBuffer): VRCConfigValues = getRootAsVRCConfigValues(_bb, VRCConfigValues()) - @JvmStatic - fun getRootAsVRCConfigValues(_bb: ByteBuffer, obj: VRCConfigValues): VRCConfigValues { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCConfigValues(builder: FlatBufferBuilder, legacyMode: Boolean, shoulderTrackingDisabled: Boolean, userHeight: Float, calibrationRange: Float, calibrationVisuals: Boolean, trackerModel: UByte, spineMode: UByte, avatarMeasurementType: UByte, shoulderWidthCompensation: Boolean) : Int { - builder.startTable(9) - addCalibrationRange(builder, calibrationRange) - addUserHeight(builder, userHeight) - addShoulderWidthCompensation(builder, shoulderWidthCompensation) - addAvatarMeasurementType(builder, avatarMeasurementType) - addSpineMode(builder, spineMode) - addTrackerModel(builder, trackerModel) - addCalibrationVisuals(builder, calibrationVisuals) - addShoulderTrackingDisabled(builder, shoulderTrackingDisabled) - addLegacyMode(builder, legacyMode) - return endVRCConfigValues(builder) - } - @JvmStatic - fun startVRCConfigValues(builder: FlatBufferBuilder) = builder.startTable(9) - @JvmStatic - fun addLegacyMode(builder: FlatBufferBuilder, legacyMode: Boolean) = builder.addBoolean(0, legacyMode, false) - @JvmStatic - fun addShoulderTrackingDisabled(builder: FlatBufferBuilder, shoulderTrackingDisabled: Boolean) = builder.addBoolean(1, shoulderTrackingDisabled, false) - @JvmStatic - fun addUserHeight(builder: FlatBufferBuilder, userHeight: Float) = builder.addFloat(2, userHeight, 0.0) - @JvmStatic - fun addCalibrationRange(builder: FlatBufferBuilder, calibrationRange: Float) = builder.addFloat(3, calibrationRange, 0.0) - @JvmStatic - fun addCalibrationVisuals(builder: FlatBufferBuilder, calibrationVisuals: Boolean) = builder.addBoolean(4, calibrationVisuals, false) - @JvmStatic - fun addTrackerModel(builder: FlatBufferBuilder, trackerModel: UByte) = builder.addByte(5, trackerModel.toByte(), 0) - @JvmStatic - fun addSpineMode(builder: FlatBufferBuilder, spineMode: UByte) = builder.addByte(6, spineMode.toByte(), 0) - @JvmStatic - fun addAvatarMeasurementType(builder: FlatBufferBuilder, avatarMeasurementType: UByte) = builder.addByte(7, avatarMeasurementType.toByte(), 0) - @JvmStatic - fun addShoulderWidthCompensation(builder: FlatBufferBuilder, shoulderWidthCompensation: Boolean) = builder.addBoolean(8, shoulderWidthCompensation, false) - @JvmStatic - fun endVRCConfigValues(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCOSCSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCOSCSettings.kt deleted file mode 100644 index 27ee96fb6..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCOSCSettings.kt +++ /dev/null @@ -1,77 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * OSC Settings specific to VRChat - */ -@Suppress("unused") -class VRCOSCSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : VRCOSCSettings { - __init(_i, _bb) - return this - } - val oscSettings : solarxr_protocol.rpc.OSCSettings? get() = oscSettings(solarxr_protocol.rpc.OSCSettings()) - fun oscSettings(obj: solarxr_protocol.rpc.OSCSettings) : solarxr_protocol.rpc.OSCSettings? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val trackers : solarxr_protocol.rpc.OSCTrackersSetting? get() = trackers(solarxr_protocol.rpc.OSCTrackersSetting()) - fun trackers(obj: solarxr_protocol.rpc.OSCTrackersSetting) : solarxr_protocol.rpc.OSCTrackersSetting? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val oscqueryEnabled : Boolean - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsVRCOSCSettings(_bb: ByteBuffer): VRCOSCSettings = getRootAsVRCOSCSettings(_bb, VRCOSCSettings()) - @JvmStatic - fun getRootAsVRCOSCSettings(_bb: ByteBuffer, obj: VRCOSCSettings): VRCOSCSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createVRCOSCSettings(builder: FlatBufferBuilder, oscSettingsOffset: Int, trackersOffset: Int, oscqueryEnabled: Boolean) : Int { - builder.startTable(3) - addTrackers(builder, trackersOffset) - addOscSettings(builder, oscSettingsOffset) - addOscqueryEnabled(builder, oscqueryEnabled) - return endVRCOSCSettings(builder) - } - @JvmStatic - fun startVRCOSCSettings(builder: FlatBufferBuilder) = builder.startTable(3) - @JvmStatic - fun addOscSettings(builder: FlatBufferBuilder, oscSettings: Int) = builder.addOffset(0, oscSettings, 0) - @JvmStatic - fun addTrackers(builder: FlatBufferBuilder, trackers: Int) = builder.addOffset(1, trackers, 0) - @JvmStatic - fun addOscqueryEnabled(builder: FlatBufferBuilder, oscqueryEnabled: Boolean) = builder.addBoolean(2, oscqueryEnabled, false) - @JvmStatic - fun endVRCOSCSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCSpineMode.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCSpineMode.kt deleted file mode 100644 index 2d93be4ec..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCSpineMode.kt +++ /dev/null @@ -1,16 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class VRCSpineMode private constructor() { - companion object { - const val UNKNOWN: UByte = 0u - const val LOCKHIP: UByte = 1u - const val LOCKHEAD: UByte = 2u - const val LOCKBOTH: UByte = 3u - val names : Array = arrayOf("UNKNOWN", "LOCK_HIP", "LOCK_HEAD", "LOCK_BOTH") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCTrackerModel.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCTrackerModel.kt deleted file mode 100644 index ed6183eee..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCTrackerModel.kt +++ /dev/null @@ -1,17 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class VRCTrackerModel private constructor() { - companion object { - const val UNKNOWN: UByte = 0u - const val SPHERE: UByte = 1u - const val SYSTEM: UByte = 2u - const val BOX: UByte = 3u - const val AXIS: UByte = 4u - val names : Array = arrayOf("UNKNOWN", "SPHERE", "SYSTEM", "BOX", "AXIS") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatus.kt deleted file mode 100644 index 3189756ea..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatus.kt +++ /dev/null @@ -1,23 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -@Suppress("unused") -class WifiProvisioningStatus private constructor() { - companion object { - const val NONE: UByte = 0u - const val SERIALINIT: UByte = 1u - const val PROVISIONING: UByte = 2u - const val CONNECTING: UByte = 3u - const val CONNECTIONERROR: UByte = 4u - const val LOOKINGFORSERVER: UByte = 5u - const val COULDNOTFINDSERVER: UByte = 6u - const val DONE: UByte = 7u - const val OBTAININGMACADDRESS: UByte = 8u - const val NOSERIALLOGSERROR: UByte = 9u - const val NOSERIALDEVICEFOUND: UByte = 10u - val names : Array = arrayOf("NONE", "SERIAL_INIT", "PROVISIONING", "CONNECTING", "CONNECTION_ERROR", "LOOKING_FOR_SERVER", "COULD_NOT_FIND_SERVER", "DONE", "OBTAINING_MAC_ADDRESS", "NO_SERIAL_LOGS_ERROR", "NO_SERIAL_DEVICE_FOUND") - @JvmStatic - fun name(e: Int) : String = names[e] - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatusResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatusResponse.kt deleted file mode 100644 index b8d624283..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/WifiProvisioningStatusResponse.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class WifiProvisioningStatusResponse : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : WifiProvisioningStatusResponse { - __init(_i, _bb) - return this - } - val status : UByte - get() { - val o = __offset(4) - return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsWifiProvisioningStatusResponse(_bb: ByteBuffer): WifiProvisioningStatusResponse = getRootAsWifiProvisioningStatusResponse(_bb, WifiProvisioningStatusResponse()) - @JvmStatic - fun getRootAsWifiProvisioningStatusResponse(_bb: ByteBuffer, obj: WifiProvisioningStatusResponse): WifiProvisioningStatusResponse { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createWifiProvisioningStatusResponse(builder: FlatBufferBuilder, status: UByte) : Int { - builder.startTable(1) - addStatus(builder, status) - return endWifiProvisioningStatusResponse(builder) - } - @JvmStatic - fun startWifiProvisioningStatusResponse(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(0, status.toByte(), 0) - @JvmStatic - fun endWifiProvisioningStatusResponse(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/settings/LegTweaksSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/settings/LegTweaksSettings.kt deleted file mode 100644 index dc6758ce5..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/settings/LegTweaksSettings.kt +++ /dev/null @@ -1,50 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class LegTweaksSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : LegTweaksSettings { - __init(_i, _bb) - return this - } - val correctionStrength : Float? - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsLegTweaksSettings(_bb: ByteBuffer): LegTweaksSettings = getRootAsLegTweaksSettings(_bb, LegTweaksSettings()) - @JvmStatic - fun getRootAsLegTweaksSettings(_bb: ByteBuffer, obj: LegTweaksSettings): LegTweaksSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createLegTweaksSettings(builder: FlatBufferBuilder, correctionStrength: Float?) : Int { - builder.startTable(1) - correctionStrength?.run { addCorrectionStrength(builder, correctionStrength) } - return endLegTweaksSettings(builder) - } - @JvmStatic - fun startLegTweaksSettings(builder: FlatBufferBuilder) = builder.startTable(1) - @JvmStatic - fun addCorrectionStrength(builder: FlatBufferBuilder, correctionStrength: Float) = builder.addFloat(0, correctionStrength, 0.0) - @JvmStatic - fun endLegTweaksSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelRatios.kt b/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelRatios.kt deleted file mode 100644 index 452c0be5f..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelRatios.kt +++ /dev/null @@ -1,111 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Settings for the skeletal model that are ratios. - * These values range from 0 to 1. - */ -@Suppress("unused") -class ModelRatios : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ModelRatios { - __init(_i, _bb) - return this - } - val imputeWaistFromChestHip : Float? - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val imputeWaistFromChestLegs : Float? - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val imputeHipFromChestLegs : Float? - get() { - val o = __offset(8) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val imputeHipFromWaistLegs : Float? - get() { - val o = __offset(10) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - /** - * Hip's yaw and roll is set to the average of legs when 1.0 - */ - val interpHipLegs : Float? - get() { - val o = __offset(12) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - /** - * Knee trackers' yaw and roll is set to the lower leg's when 1.0 - */ - val interpKneeTrackerAnkle : Float? - get() { - val o = __offset(14) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - /** - * Upper leg's yaw and roll is set to the lower leg's when 1.0 - */ - val interpKneeAnkle : Float? - get() { - val o = __offset(16) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsModelRatios(_bb: ByteBuffer): ModelRatios = getRootAsModelRatios(_bb, ModelRatios()) - @JvmStatic - fun getRootAsModelRatios(_bb: ByteBuffer, obj: ModelRatios): ModelRatios { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createModelRatios(builder: FlatBufferBuilder, imputeWaistFromChestHip: Float?, imputeWaistFromChestLegs: Float?, imputeHipFromChestLegs: Float?, imputeHipFromWaistLegs: Float?, interpHipLegs: Float?, interpKneeTrackerAnkle: Float?, interpKneeAnkle: Float?) : Int { - builder.startTable(7) - interpKneeAnkle?.run { addInterpKneeAnkle(builder, interpKneeAnkle) } - interpKneeTrackerAnkle?.run { addInterpKneeTrackerAnkle(builder, interpKneeTrackerAnkle) } - interpHipLegs?.run { addInterpHipLegs(builder, interpHipLegs) } - imputeHipFromWaistLegs?.run { addImputeHipFromWaistLegs(builder, imputeHipFromWaistLegs) } - imputeHipFromChestLegs?.run { addImputeHipFromChestLegs(builder, imputeHipFromChestLegs) } - imputeWaistFromChestLegs?.run { addImputeWaistFromChestLegs(builder, imputeWaistFromChestLegs) } - imputeWaistFromChestHip?.run { addImputeWaistFromChestHip(builder, imputeWaistFromChestHip) } - return endModelRatios(builder) - } - @JvmStatic - fun startModelRatios(builder: FlatBufferBuilder) = builder.startTable(7) - @JvmStatic - fun addImputeWaistFromChestHip(builder: FlatBufferBuilder, imputeWaistFromChestHip: Float) = builder.addFloat(0, imputeWaistFromChestHip, 0.0) - @JvmStatic - fun addImputeWaistFromChestLegs(builder: FlatBufferBuilder, imputeWaistFromChestLegs: Float) = builder.addFloat(1, imputeWaistFromChestLegs, 0.0) - @JvmStatic - fun addImputeHipFromChestLegs(builder: FlatBufferBuilder, imputeHipFromChestLegs: Float) = builder.addFloat(2, imputeHipFromChestLegs, 0.0) - @JvmStatic - fun addImputeHipFromWaistLegs(builder: FlatBufferBuilder, imputeHipFromWaistLegs: Float) = builder.addFloat(3, imputeHipFromWaistLegs, 0.0) - @JvmStatic - fun addInterpHipLegs(builder: FlatBufferBuilder, interpHipLegs: Float) = builder.addFloat(4, interpHipLegs, 0.0) - @JvmStatic - fun addInterpKneeTrackerAnkle(builder: FlatBufferBuilder, interpKneeTrackerAnkle: Float) = builder.addFloat(5, interpKneeTrackerAnkle, 0.0) - @JvmStatic - fun addInterpKneeAnkle(builder: FlatBufferBuilder, interpKneeAnkle: Float) = builder.addFloat(6, interpKneeAnkle, 0.0) - @JvmStatic - fun endModelRatios(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelSettings.kt b/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelSettings.kt deleted file mode 100644 index 618c437b4..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelSettings.kt +++ /dev/null @@ -1,93 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Settings for the skeletal model. - */ -@Suppress("unused") -class ModelSettings : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ModelSettings { - __init(_i, _bb) - return this - } - val toggles : solarxr_protocol.rpc.settings.ModelToggles? get() = toggles(solarxr_protocol.rpc.settings.ModelToggles()) - fun toggles(obj: solarxr_protocol.rpc.settings.ModelToggles) : solarxr_protocol.rpc.settings.ModelToggles? { - val o = __offset(4) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val ratios : solarxr_protocol.rpc.settings.ModelRatios? get() = ratios(solarxr_protocol.rpc.settings.ModelRatios()) - fun ratios(obj: solarxr_protocol.rpc.settings.ModelRatios) : solarxr_protocol.rpc.settings.ModelRatios? { - val o = __offset(6) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val legTweaks : solarxr_protocol.rpc.settings.LegTweaksSettings? get() = legTweaks(solarxr_protocol.rpc.settings.LegTweaksSettings()) - fun legTweaks(obj: solarxr_protocol.rpc.settings.LegTweaksSettings) : solarxr_protocol.rpc.settings.LegTweaksSettings? { - val o = __offset(8) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - val skeletonHeight : solarxr_protocol.rpc.settings.SkeletonHeight? get() = skeletonHeight(solarxr_protocol.rpc.settings.SkeletonHeight()) - fun skeletonHeight(obj: solarxr_protocol.rpc.settings.SkeletonHeight) : solarxr_protocol.rpc.settings.SkeletonHeight? { - val o = __offset(10) - return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) - } else { - null - } - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsModelSettings(_bb: ByteBuffer): ModelSettings = getRootAsModelSettings(_bb, ModelSettings()) - @JvmStatic - fun getRootAsModelSettings(_bb: ByteBuffer, obj: ModelSettings): ModelSettings { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createModelSettings(builder: FlatBufferBuilder, togglesOffset: Int, ratiosOffset: Int, legTweaksOffset: Int, skeletonHeightOffset: Int) : Int { - builder.startTable(4) - addSkeletonHeight(builder, skeletonHeightOffset) - addLegTweaks(builder, legTweaksOffset) - addRatios(builder, ratiosOffset) - addToggles(builder, togglesOffset) - return endModelSettings(builder) - } - @JvmStatic - fun startModelSettings(builder: FlatBufferBuilder) = builder.startTable(4) - @JvmStatic - fun addToggles(builder: FlatBufferBuilder, toggles: Int) = builder.addOffset(0, toggles, 0) - @JvmStatic - fun addRatios(builder: FlatBufferBuilder, ratios: Int) = builder.addOffset(1, ratios, 0) - @JvmStatic - fun addLegTweaks(builder: FlatBufferBuilder, legTweaks: Int) = builder.addOffset(2, legTweaks, 0) - @JvmStatic - fun addSkeletonHeight(builder: FlatBufferBuilder, skeletonHeight: Int) = builder.addOffset(3, skeletonHeight, 0) - @JvmStatic - fun endModelSettings(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelToggles.kt b/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelToggles.kt deleted file mode 100644 index e5508fa32..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/settings/ModelToggles.kt +++ /dev/null @@ -1,141 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -/** - * Settings for the skeletal model that are toggles. - */ -@Suppress("unused") -class ModelToggles : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : ModelToggles { - __init(_i, _bb) - return this - } - val extendedSpine : Boolean? - get() { - val o = __offset(4) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val extendedPelvis : Boolean? - get() { - val o = __offset(6) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val extendedKnee : Boolean? - get() { - val o = __offset(8) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val forceArmsFromHmd : Boolean? - get() { - val o = __offset(10) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val floorClip : Boolean? - get() { - val o = __offset(12) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val skatingCorrection : Boolean? - get() { - val o = __offset(14) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val toeSnap : Boolean? - get() { - val o = __offset(18) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val footPlant : Boolean? - get() { - val o = __offset(20) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val selfLocalization : Boolean? - get() { - val o = __offset(22) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val usePosition : Boolean? - get() { - val o = __offset(24) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val enforceConstraints : Boolean? - get() { - val o = __offset(26) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - val correctConstraints : Boolean? - get() { - val o = __offset(28) - return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsModelToggles(_bb: ByteBuffer): ModelToggles = getRootAsModelToggles(_bb, ModelToggles()) - @JvmStatic - fun getRootAsModelToggles(_bb: ByteBuffer, obj: ModelToggles): ModelToggles { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createModelToggles(builder: FlatBufferBuilder, extendedSpine: Boolean?, extendedPelvis: Boolean?, extendedKnee: Boolean?, forceArmsFromHmd: Boolean?, floorClip: Boolean?, skatingCorrection: Boolean?, toeSnap: Boolean?, footPlant: Boolean?, selfLocalization: Boolean?, usePosition: Boolean?, enforceConstraints: Boolean?, correctConstraints: Boolean?) : Int { - builder.startTable(13) - correctConstraints?.run { addCorrectConstraints(builder, correctConstraints) } - enforceConstraints?.run { addEnforceConstraints(builder, enforceConstraints) } - usePosition?.run { addUsePosition(builder, usePosition) } - selfLocalization?.run { addSelfLocalization(builder, selfLocalization) } - footPlant?.run { addFootPlant(builder, footPlant) } - toeSnap?.run { addToeSnap(builder, toeSnap) } - skatingCorrection?.run { addSkatingCorrection(builder, skatingCorrection) } - floorClip?.run { addFloorClip(builder, floorClip) } - forceArmsFromHmd?.run { addForceArmsFromHmd(builder, forceArmsFromHmd) } - extendedKnee?.run { addExtendedKnee(builder, extendedKnee) } - extendedPelvis?.run { addExtendedPelvis(builder, extendedPelvis) } - extendedSpine?.run { addExtendedSpine(builder, extendedSpine) } - return endModelToggles(builder) - } - @JvmStatic - fun startModelToggles(builder: FlatBufferBuilder) = builder.startTable(13) - @JvmStatic - fun addExtendedSpine(builder: FlatBufferBuilder, extendedSpine: Boolean) = builder.addBoolean(0, extendedSpine, false) - @JvmStatic - fun addExtendedPelvis(builder: FlatBufferBuilder, extendedPelvis: Boolean) = builder.addBoolean(1, extendedPelvis, false) - @JvmStatic - fun addExtendedKnee(builder: FlatBufferBuilder, extendedKnee: Boolean) = builder.addBoolean(2, extendedKnee, false) - @JvmStatic - fun addForceArmsFromHmd(builder: FlatBufferBuilder, forceArmsFromHmd: Boolean) = builder.addBoolean(3, forceArmsFromHmd, false) - @JvmStatic - fun addFloorClip(builder: FlatBufferBuilder, floorClip: Boolean) = builder.addBoolean(4, floorClip, false) - @JvmStatic - fun addSkatingCorrection(builder: FlatBufferBuilder, skatingCorrection: Boolean) = builder.addBoolean(5, skatingCorrection, false) - @JvmStatic - fun addToeSnap(builder: FlatBufferBuilder, toeSnap: Boolean) = builder.addBoolean(7, toeSnap, false) - @JvmStatic - fun addFootPlant(builder: FlatBufferBuilder, footPlant: Boolean) = builder.addBoolean(8, footPlant, false) - @JvmStatic - fun addSelfLocalization(builder: FlatBufferBuilder, selfLocalization: Boolean) = builder.addBoolean(9, selfLocalization, false) - @JvmStatic - fun addUsePosition(builder: FlatBufferBuilder, usePosition: Boolean) = builder.addBoolean(10, usePosition, false) - @JvmStatic - fun addEnforceConstraints(builder: FlatBufferBuilder, enforceConstraints: Boolean) = builder.addBoolean(11, enforceConstraints, false) - @JvmStatic - fun addCorrectConstraints(builder: FlatBufferBuilder, correctConstraints: Boolean) = builder.addBoolean(12, correctConstraints, false) - @JvmStatic - fun endModelToggles(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/settings/SkeletonHeight.kt b/protocol/kotlin/src/solarxr_protocol/rpc/settings/SkeletonHeight.kt deleted file mode 100644 index 51d7d7908..000000000 --- a/protocol/kotlin/src/solarxr_protocol/rpc/settings/SkeletonHeight.kt +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -package solarxr_protocol.rpc.settings - -import java.nio.* -import kotlin.math.sign -import com.google.flatbuffers.* - -@Suppress("unused") -class SkeletonHeight : Table() { - - fun __init(_i: Int, _bb: ByteBuffer) { - __reset(_i, _bb) - } - fun __assign(_i: Int, _bb: ByteBuffer) : SkeletonHeight { - __init(_i, _bb) - return this - } - val hmdHeight : Float? - get() { - val o = __offset(4) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - val floorHeight : Float? - get() { - val o = __offset(6) - return if(o != 0) bb.getFloat(o + bb_pos) else null - } - companion object { - @JvmStatic - fun validateVersion() = Constants.FLATBUFFERS_22_10_26() - @JvmStatic - fun getRootAsSkeletonHeight(_bb: ByteBuffer): SkeletonHeight = getRootAsSkeletonHeight(_bb, SkeletonHeight()) - @JvmStatic - fun getRootAsSkeletonHeight(_bb: ByteBuffer, obj: SkeletonHeight): SkeletonHeight { - _bb.order(ByteOrder.LITTLE_ENDIAN) - return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) - } - @JvmStatic - fun createSkeletonHeight(builder: FlatBufferBuilder, hmdHeight: Float?, floorHeight: Float?) : Int { - builder.startTable(2) - floorHeight?.run { addFloorHeight(builder, floorHeight) } - hmdHeight?.run { addHmdHeight(builder, hmdHeight) } - return endSkeletonHeight(builder) - } - @JvmStatic - fun startSkeletonHeight(builder: FlatBufferBuilder) = builder.startTable(2) - @JvmStatic - fun addHmdHeight(builder: FlatBufferBuilder, hmdHeight: Float) = builder.addFloat(0, hmdHeight, 0.0) - @JvmStatic - fun addFloorHeight(builder: FlatBufferBuilder, floorHeight: Float) = builder.addFloat(1, floorHeight, 0.0) - @JvmStatic - fun endSkeletonHeight(builder: FlatBufferBuilder) : Int { - val o = builder.endTable() - return o - } - } -} diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs index 8ed5e4a0c..60d48ddba 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -23,7 +23,7 @@ pub mod solarxr_protocol { mod stay_aligned_tracker_generated; pub use self::stay_aligned_tracker_generated::*; } // stay_aligned - pub mod tracker { + pub mod tracker_data { use super::*; mod tracker_data_generated; pub use self::tracker_data_generated::*; @@ -31,7 +31,7 @@ pub mod solarxr_protocol { pub use self::tracker_data_mask_generated::*; mod tracker_info_generated; pub use self::tracker_info_generated::*; - } // tracker + } // tracker_data mod data_feed_message_generated; pub use self::data_feed_message_generated::*; mod bone_generated; @@ -77,8 +77,6 @@ pub mod solarxr_protocol { } // math mod firmware_error_code_generated; pub use self::firmware_error_code_generated::*; - mod filtering_type_generated; - pub use self::filtering_type_generated::*; mod tracker_role_generated; pub use self::tracker_role_generated::*; mod body_part_generated; @@ -91,107 +89,113 @@ pub mod solarxr_protocol { pub use self::hz_f32_generated::*; mod transaction_id_generated; pub use self::transaction_id_generated::*; - mod device_id_generated; - pub use self::device_id_generated::*; - mod device_id_table_generated; - pub use self::device_id_table_generated::*; - mod tracker_id_generated; - pub use self::tracker_id_generated::*; mod log_data_generated; pub use self::log_data_generated::*; mod temperature_generated; pub use self::temperature_generated::*; mod ipv_4_address_generated; pub use self::ipv_4_address_generated::*; - mod bytes_generated; - pub use self::bytes_generated::*; - mod string_table_generated; - pub use self::string_table_generated::*; } // datatypes - pub mod pub_sub { - use super::*; - mod topic_generated; - pub use self::topic_generated::*; - mod pub_sub_union_generated; - pub use self::pub_sub_union_generated::*; - mod payload_generated; - pub use self::payload_generated::*; - mod topic_id_generated; - pub use self::topic_id_generated::*; - mod topic_handle_generated; - pub use self::topic_handle_generated::*; - mod topic_mapping_generated; - pub use self::topic_mapping_generated::*; - mod topic_handle_request_generated; - pub use self::topic_handle_request_generated::*; - mod subscription_request_generated; - pub use self::subscription_request_generated::*; - mod pub_sub_header_generated; - pub use self::pub_sub_header_generated::*; - mod message_generated; - pub use self::message_generated::*; - mod key_values_generated; - pub use self::key_values_generated::*; - } // pub_sub pub mod rpc { use super::*; - pub mod settings { - use super::*; - mod model_toggles_generated; - pub use self::model_toggles_generated::*; - mod model_ratios_generated; - pub use self::model_ratios_generated::*; - mod leg_tweaks_settings_generated; - pub use self::leg_tweaks_settings_generated::*; - mod skeleton_height_generated; - pub use self::skeleton_height_generated::*; - mod model_settings_generated; - pub use self::model_settings_generated::*; - } // settings - mod rpc_message_generated; - pub use self::rpc_message_generated::*; - mod keybind_id_generated; - pub use self::keybind_id_generated::*; - mod reset_type_generated; - pub use self::reset_type_generated::*; - mod reset_status_generated; - pub use self::reset_status_generated::*; - mod arms_mounting_reset_mode_generated; - pub use self::arms_mounting_reset_mode_generated::*; - mod skeleton_bone_generated; - pub use self::skeleton_bone_generated::*; - mod serial_device_type_generated; - pub use self::serial_device_type_generated::*; - mod wifi_provisioning_status_generated; - pub use self::wifi_provisioning_status_generated::*; mod auto_bone_process_type_generated; pub use self::auto_bone_process_type_generated::*; - mod status_data_generated; - pub use self::status_data_generated::*; - mod computer_directory_generated; - pub use self::computer_directory_generated::*; mod firmware_update_status_generated; pub use self::firmware_update_status_generated::*; mod firmware_update_device_id_generated; pub use self::firmware_update_device_id_generated::*; mod firmware_update_method_generated; pub use self::firmware_update_method_generated::*; - mod vrctracker_model_generated; - pub use self::vrctracker_model_generated::*; - mod vrcspine_mode_generated; - pub use self::vrcspine_mode_generated::*; - mod vrcavatar_measurement_type_generated; - pub use self::vrcavatar_measurement_type_generated::*; + mod user_height_calibration_status_generated; + pub use self::user_height_calibration_status_generated::*; + mod keybind_id_generated; + pub use self::keybind_id_generated::*; + mod wifi_provisioning_status_generated; + pub use self::wifi_provisioning_status_generated::*; + mod reset_type_generated; + pub use self::reset_type_generated::*; + mod reset_status_generated; + pub use self::reset_status_generated::*; + mod arms_reset_mode_generated; + pub use self::arms_reset_mode_generated::*; + mod serial_device_type_generated; + pub use self::serial_device_type_generated::*; + mod skeleton_bone_generated; + pub use self::skeleton_bone_generated::*; + mod filtering_type_generated; + pub use self::filtering_type_generated::*; + mod stay_aligned_relaxed_pose_generated; + pub use self::stay_aligned_relaxed_pose_generated::*; mod tracking_checklist_step_id_generated; pub use self::tracking_checklist_step_id_generated::*; mod tracking_checklist_step_visibility_generated; pub use self::tracking_checklist_step_visibility_generated::*; mod tracking_checklist_extra_data_generated; pub use self::tracking_checklist_extra_data_generated::*; - mod stay_aligned_relaxed_pose_generated; - pub use self::stay_aligned_relaxed_pose_generated::*; - mod user_height_calibration_status_generated; - pub use self::user_height_calibration_status_generated::*; + mod vrctracker_model_generated; + pub use self::vrctracker_model_generated::*; + mod vrcspine_mode_generated; + pub use self::vrcspine_mode_generated::*; + mod vrcavatar_measurement_type_generated; + pub use self::vrcavatar_measurement_type_generated::*; + mod vrcoscinput_state_generated; + pub use self::vrcoscinput_state_generated::*; + mod vrcoscoutput_state_generated; + pub use self::vrcoscoutput_state_generated::*; + mod vrcosctarget_source_generated; + pub use self::vrcosctarget_source_generated::*; + mod vrcoscosc_query_state_generated; + pub use self::vrcoscosc_query_state_generated::*; + mod rpc_message_generated; + pub use self::rpc_message_generated::*; + mod computer_directory_generated; + pub use self::computer_directory_generated::*; + mod auto_bone_process_request_generated; + pub use self::auto_bone_process_request_generated::*; + mod auto_bone_process_status_response_generated; + pub use self::auto_bone_process_status_response_generated::*; + mod auto_bone_epoch_response_generated; + pub use self::auto_bone_epoch_response_generated::*; + mod auto_bone_apply_request_generated; + pub use self::auto_bone_apply_request_generated::*; + mod auto_bone_stop_recording_request_generated; + pub use self::auto_bone_stop_recording_request_generated::*; + mod auto_bone_cancel_recording_request_generated; + pub use self::auto_bone_cancel_recording_request_generated::*; + mod record_bvhrequest_generated; + pub use self::record_bvhrequest_generated::*; + mod record_bvhstatus_generated; + pub use self::record_bvhstatus_generated::*; + mod record_bvhstatus_request_generated; + pub use self::record_bvhstatus_request_generated::*; + mod unknown_device_handshake_notification_generated; + pub use self::unknown_device_handshake_notification_generated::*; + mod add_unknown_device_request_generated; + pub use self::add_unknown_device_request_generated::*; + mod forget_device_request_generated; + pub use self::forget_device_request_generated::*; + mod serial_device_port_generated; + pub use self::serial_device_port_generated::*; + mod firmware_device_id_table_generated; + pub use self::firmware_device_id_table_generated::*; + mod firmware_part_generated; + pub use self::firmware_part_generated::*; + mod firmware_update_request_generated; + pub use self::firmware_update_request_generated::*; + mod otafirmware_update_generated; + pub use self::otafirmware_update_generated::*; + mod serial_firmware_update_generated; + pub use self::serial_firmware_update_generated::*; + mod firmware_update_status_response_generated; + pub use self::firmware_update_status_response_generated::*; + mod firmware_update_stop_queues_request_generated; + pub use self::firmware_update_stop_queues_request_generated::*; + mod start_user_height_calibration_generated; + pub use self::start_user_height_calibration_generated::*; + mod cancel_user_height_calibration_generated; + pub use self::cancel_user_height_calibration_generated::*; + mod user_height_recording_status_response_generated; + pub use self::user_height_recording_status_response_generated::*; mod keybind_generated; pub use self::keybind_generated::*; mod keybind_request_generated; @@ -200,90 +204,36 @@ pub mod solarxr_protocol { pub use self::keybind_response_generated::*; mod change_keybind_request_generated; pub use self::change_keybind_request_generated::*; - mod open_uri_request_generated; - pub use self::open_uri_request_generated::*; - mod open_uri_response_generated; - pub use self::open_uri_response_generated::*; - mod rpc_message_header_generated; - pub use self::rpc_message_header_generated::*; - mod installed_info_request_generated; - pub use self::installed_info_request_generated::*; - mod installed_info_response_generated; - pub use self::installed_info_response_generated::*; - mod heartbeat_request_generated; - pub use self::heartbeat_request_generated::*; - mod heartbeat_response_generated; - pub use self::heartbeat_response_generated::*; + mod overlay_display_mode_request_generated; + pub use self::overlay_display_mode_request_generated::*; + mod overlay_display_mode_change_request_generated; + pub use self::overlay_display_mode_change_request_generated::*; + mod overlay_display_mode_response_generated; + pub use self::overlay_display_mode_response_generated::*; + mod start_wifi_provisioning_request_generated; + pub use self::start_wifi_provisioning_request_generated::*; + mod stop_wifi_provisioning_request_generated; + pub use self::stop_wifi_provisioning_request_generated::*; + mod wifi_provisioning_status_response_generated; + pub use self::wifi_provisioning_status_response_generated::*; mod reset_request_generated; pub use self::reset_request_generated::*; mod reset_response_generated; pub use self::reset_response_generated::*; - mod assign_tracker_request_generated; - pub use self::assign_tracker_request_generated::*; - mod clear_drift_compensation_request_generated; - pub use self::clear_drift_compensation_request_generated::*; - mod settings_request_generated; - pub use self::settings_request_generated::*; - mod settings_response_generated; - pub use self::settings_response_generated::*; - mod change_settings_request_generated; - pub use self::change_settings_request_generated::*; - mod steam_vrtrackers_setting_generated; - pub use self::steam_vrtrackers_setting_generated::*; - mod filtering_settings_generated; - pub use self::filtering_settings_generated::*; - mod drift_compensation_settings_generated; - pub use self::drift_compensation_settings_generated::*; - mod oscrouter_settings_generated; - pub use self::oscrouter_settings_generated::*; - mod vrcoscsettings_generated; - pub use self::vrcoscsettings_generated::*; - mod vmcoscsettings_generated; - pub use self::vmcoscsettings_generated::*; - mod vrmsettings_generated; - pub use self::vrmsettings_generated::*; - mod oscsettings_generated; - pub use self::oscsettings_generated::*; - mod osctrackers_setting_generated; - pub use self::osctrackers_setting_generated::*; - mod tap_detection_settings_generated; - pub use self::tap_detection_settings_generated::*; - mod resets_settings_generated; - pub use self::resets_settings_generated::*; - mod stay_aligned_settings_generated; - pub use self::stay_aligned_settings_generated::*; - mod hidsettings_generated; - pub use self::hidsettings_generated::*; - mod timeout_settings_generated; - pub use self::timeout_settings_generated::*; - mod velocity_settings_generated; - pub use self::velocity_settings_generated::*; - mod tap_detection_setup_notification_generated; - pub use self::tap_detection_setup_notification_generated::*; - mod record_bvhrequest_generated; - pub use self::record_bvhrequest_generated::*; - mod record_bvhstatus_generated; - pub use self::record_bvhstatus_generated::*; - mod record_bvhstatus_request_generated; - pub use self::record_bvhstatus_request_generated::*; - mod skeleton_part_generated; - pub use self::skeleton_part_generated::*; - mod skeleton_config_request_generated; - pub use self::skeleton_config_request_generated::*; - mod skeleton_config_response_generated; - pub use self::skeleton_config_response_generated::*; - mod skeleton_reset_all_request_generated; - pub use self::skeleton_reset_all_request_generated::*; - mod change_skeleton_config_request_generated; - pub use self::change_skeleton_config_request_generated::*; + mod clear_mounting_reset_request_generated; + pub use self::clear_mounting_reset_request_generated::*; + mod resets_settings_request_generated; + pub use self::resets_settings_request_generated::*; + mod resets_settings_response_generated; + pub use self::resets_settings_response_generated::*; + mod change_resets_settings_request_generated; + pub use self::change_resets_settings_request_generated::*; mod serial_device_generated; pub use self::serial_device_generated::*; mod open_serial_request_generated; pub use self::open_serial_request_generated::*; mod close_serial_request_generated; pub use self::close_serial_request_generated::*; - mod set_wifi_request_generated; - pub use self::set_wifi_request_generated::*; mod serial_update_response_generated; pub use self::serial_update_response_generated::*; mod serial_tracker_reboot_request_generated; @@ -300,116 +250,88 @@ pub mod solarxr_protocol { pub use self::serial_devices_response_generated::*; mod new_serial_device_response_generated; pub use self::new_serial_device_response_generated::*; - mod start_wifi_provisioning_request_generated; - pub use self::start_wifi_provisioning_request_generated::*; - mod stop_wifi_provisioning_request_generated; - pub use self::stop_wifi_provisioning_request_generated::*; - mod wifi_provisioning_status_response_generated; - pub use self::wifi_provisioning_status_response_generated::*; - mod auto_bone_process_request_generated; - pub use self::auto_bone_process_request_generated::*; - mod auto_bone_process_status_response_generated; - pub use self::auto_bone_process_status_response_generated::*; - mod auto_bone_epoch_response_generated; - pub use self::auto_bone_epoch_response_generated::*; - mod auto_bone_settings_generated; - pub use self::auto_bone_settings_generated::*; - mod height_request_generated; - pub use self::height_request_generated::*; - mod height_response_generated; - pub use self::height_response_generated::*; - mod auto_bone_apply_request_generated; - pub use self::auto_bone_apply_request_generated::*; - mod auto_bone_stop_recording_request_generated; - pub use self::auto_bone_stop_recording_request_generated::*; - mod auto_bone_cancel_recording_request_generated; - pub use self::auto_bone_cancel_recording_request_generated::*; - mod overlay_display_mode_request_generated; - pub use self::overlay_display_mode_request_generated::*; - mod overlay_display_mode_change_request_generated; - pub use self::overlay_display_mode_change_request_generated::*; - mod overlay_display_mode_response_generated; - pub use self::overlay_display_mode_response_generated::*; - mod server_infos_request_generated; - pub use self::server_infos_request_generated::*; - mod server_infos_response_generated; - pub use self::server_infos_response_generated::*; + mod serial_tracker_get_wifi_scan_request_generated; + pub use self::serial_tracker_get_wifi_scan_request_generated::*; + mod hidsettings_request_generated; + pub use self::hidsettings_request_generated::*; + mod hidsettings_response_generated; + pub use self::hidsettings_response_generated::*; + mod change_hidsettings_request_generated; + pub use self::change_hidsettings_request_generated::*; + mod skeleton_part_generated; + pub use self::skeleton_part_generated::*; + mod skeleton_proportions_request_generated; + pub use self::skeleton_proportions_request_generated::*; + mod skeleton_proportions_response_generated; + pub use self::skeleton_proportions_response_generated::*; + mod change_skeleton_proportions_request_generated; + pub use self::change_skeleton_proportions_request_generated::*; + mod skeleton_proportions_reset_all_request_generated; + pub use self::skeleton_proportions_reset_all_request_generated::*; mod leg_tweaks_tmp_change_generated; pub use self::leg_tweaks_tmp_change_generated::*; mod leg_tweaks_tmp_clear_generated; pub use self::leg_tweaks_tmp_clear_generated::*; - mod status_tracker_reset_generated; - pub use self::status_tracker_reset_generated::*; - mod status_tracker_error_generated; - pub use self::status_tracker_error_generated::*; - mod status_steam_vrdisconnected_generated; - pub use self::status_steam_vrdisconnected_generated::*; - mod status_unassigned_hmd_generated; - pub use self::status_unassigned_hmd_generated::*; - mod status_system_request_generated; - pub use self::status_system_request_generated::*; - mod status_system_response_generated; - pub use self::status_system_response_generated::*; - mod status_system_update_generated; - pub use self::status_system_update_generated::*; - mod status_system_fixed_generated; - pub use self::status_system_fixed_generated::*; - mod status_public_network_generated; - pub use self::status_public_network_generated::*; - mod status_message_generated; - pub use self::status_message_generated::*; mod set_pause_tracking_request_generated; pub use self::set_pause_tracking_request_generated::*; - mod clear_mounting_reset_request_generated; - pub use self::clear_mounting_reset_request_generated::*; - mod save_file_notification_generated; - pub use self::save_file_notification_generated::*; - mod serial_device_port_generated; - pub use self::serial_device_port_generated::*; - mod firmware_part_generated; - pub use self::firmware_part_generated::*; - mod firmware_update_request_generated; - pub use self::firmware_update_request_generated::*; - mod otafirmware_update_generated; - pub use self::otafirmware_update_generated::*; - mod serial_firmware_update_generated; - pub use self::serial_firmware_update_generated::*; - mod firmware_update_status_response_generated; - pub use self::firmware_update_status_response_generated::*; - mod firmware_update_stop_queues_request_generated; - pub use self::firmware_update_stop_queues_request_generated::*; mod tracking_pause_state_request_generated; pub use self::tracking_pause_state_request_generated::*; mod tracking_pause_state_response_generated; pub use self::tracking_pause_state_response_generated::*; - mod serial_tracker_get_wifi_scan_request_generated; - pub use self::serial_tracker_get_wifi_scan_request_generated::*; - mod unknown_device_handshake_notification_generated; - pub use self::unknown_device_handshake_notification_generated::*; - mod add_unknown_device_request_generated; - pub use self::add_unknown_device_request_generated::*; - mod forget_device_request_generated; - pub use self::forget_device_request_generated::*; - mod settings_reset_request_generated; - pub use self::settings_reset_request_generated::*; + mod skeleton_toggles_generated; + pub use self::skeleton_toggles_generated::*; + mod skeleton_ratios_generated; + pub use self::skeleton_ratios_generated::*; + mod skeleton_filtering_generated; + pub use self::skeleton_filtering_generated::*; + mod skeleton_height_generated; + pub use self::skeleton_height_generated::*; + mod skeleton_settings_request_generated; + pub use self::skeleton_settings_request_generated::*; + mod skeleton_settings_response_generated; + pub use self::skeleton_settings_response_generated::*; + mod change_skeleton_settings_request_generated; + pub use self::change_skeleton_settings_request_generated::*; + mod output_trackers_settings_request_generated; + pub use self::output_trackers_settings_request_generated::*; + mod output_trackers_settings_response_generated; + pub use self::output_trackers_settings_response_generated::*; + mod change_output_trackers_settings_request_generated; + pub use self::change_output_trackers_settings_request_generated::*; + mod enable_stay_aligned_request_generated; + pub use self::enable_stay_aligned_request_generated::*; + mod detect_stay_aligned_relaxed_pose_request_generated; + pub use self::detect_stay_aligned_relaxed_pose_request_generated::*; + mod reset_stay_aligned_relaxed_pose_request_generated; + pub use self::reset_stay_aligned_relaxed_pose_request_generated::*; + mod stay_aligned_settings_request_generated; + pub use self::stay_aligned_settings_request_generated::*; + mod stay_aligned_settings_response_generated; + pub use self::stay_aligned_settings_response_generated::*; + mod change_stay_aligned_settings_request_generated; + pub use self::change_stay_aligned_settings_request_generated::*; + mod complete_stay_aligned_response_generated; + pub use self::complete_stay_aligned_response_generated::*; + mod stay_aligned_hide_correction_request_generated; + pub use self::stay_aligned_hide_correction_request_generated::*; + mod assign_tracker_request_generated; + pub use self::assign_tracker_request_generated::*; + mod tap_detection_settings_request_generated; + pub use self::tap_detection_settings_request_generated::*; + mod tap_detection_settings_response_generated; + pub use self::tap_detection_settings_response_generated::*; + mod change_tap_detection_settings_request_generated; + pub use self::change_tap_detection_settings_request_generated::*; + mod tap_detection_setup_mode_request_generated; + pub use self::tap_detection_setup_mode_request_generated::*; + mod tap_detection_setup_notification_generated; + pub use self::tap_detection_setup_notification_generated::*; mod mag_toggle_request_generated; pub use self::mag_toggle_request_generated::*; mod mag_toggle_response_generated; pub use self::mag_toggle_response_generated::*; mod change_mag_toggle_request_generated; pub use self::change_mag_toggle_request_generated::*; - mod vrcconfig_validity_generated; - pub use self::vrcconfig_validity_generated::*; - mod vrcconfig_values_generated; - pub use self::vrcconfig_values_generated::*; - mod vrcconfig_recommended_values_generated; - pub use self::vrcconfig_recommended_values_generated::*; - mod vrcconfig_state_request_generated; - pub use self::vrcconfig_state_request_generated::*; - mod vrcconfig_state_change_response_generated; - pub use self::vrcconfig_state_change_response_generated::*; - mod vrcconfig_setting_toggle_mute_generated; - pub use self::vrcconfig_setting_toggle_mute_generated::*; mod tracking_checklist_tracker_reset_generated; pub use self::tracking_checklist_tracker_reset_generated::*; mod tracking_checklist_tracker_error_generated; @@ -432,18 +354,66 @@ pub mod solarxr_protocol { pub use self::tracking_checklist_response_generated::*; mod ignore_tracking_checklist_step_request_generated; pub use self::ignore_tracking_checklist_step_request_generated::*; - mod enable_stay_aligned_request_generated; - pub use self::enable_stay_aligned_request_generated::*; - mod detect_stay_aligned_relaxed_pose_request_generated; - pub use self::detect_stay_aligned_relaxed_pose_request_generated::*; - mod reset_stay_aligned_relaxed_pose_request_generated; - pub use self::reset_stay_aligned_relaxed_pose_request_generated::*; - mod start_user_height_calibration_generated; - pub use self::start_user_height_calibration_generated::*; - mod cancel_user_height_calibration_generated; - pub use self::cancel_user_height_calibration_generated::*; - mod user_height_recording_status_response_generated; - pub use self::user_height_recording_status_response_generated::*; + mod vmcoscsettings_request_generated; + pub use self::vmcoscsettings_request_generated::*; + mod vmcoscsettings_response_generated; + pub use self::vmcoscsettings_response_generated::*; + mod change_vmcoscsettings_request_generated; + pub use self::change_vmcoscsettings_request_generated::*; + mod vrmsettings_request_generated; + pub use self::vrmsettings_request_generated::*; + mod vrmsettings_response_generated; + pub use self::vrmsettings_response_generated::*; + mod change_vrmsettings_request_generated; + pub use self::change_vrmsettings_request_generated::*; + mod vrcconfig_validity_generated; + pub use self::vrcconfig_validity_generated::*; + mod vrcconfig_values_generated; + pub use self::vrcconfig_values_generated::*; + mod vrcconfig_recommended_values_generated; + pub use self::vrcconfig_recommended_values_generated::*; + mod vrcconfig_state_request_generated; + pub use self::vrcconfig_state_request_generated::*; + mod vrcconfig_state_change_response_generated; + pub use self::vrcconfig_state_change_response_generated::*; + mod vrcconfig_setting_toggle_mute_generated; + pub use self::vrcconfig_setting_toggle_mute_generated::*; + mod vrcoscnetwork_settings_generated; + pub use self::vrcoscnetwork_settings_generated::*; + mod vrcoscdiscovered_target_generated; + pub use self::vrcoscdiscovered_target_generated::*; + mod vrcoscstatus_request_generated; + pub use self::vrcoscstatus_request_generated::*; + mod vrcoscstatus_change_response_generated; + pub use self::vrcoscstatus_change_response_generated::*; + mod vrcoscsettings_request_generated; + pub use self::vrcoscsettings_request_generated::*; + mod vrcoscsettings_response_generated; + pub use self::vrcoscsettings_response_generated::*; + mod change_vrcoscsettings_request_generated; + pub use self::change_vrcoscsettings_request_generated::*; + mod rpc_message_header_generated; + pub use self::rpc_message_header_generated::*; + mod heartbeat_request_generated; + pub use self::heartbeat_request_generated::*; + mod heartbeat_response_generated; + pub use self::heartbeat_response_generated::*; + mod settings_reset_request_generated; + pub use self::settings_reset_request_generated::*; + mod open_uri_request_generated; + pub use self::open_uri_request_generated::*; + mod open_uri_response_generated; + pub use self::open_uri_response_generated::*; + mod installed_info_request_generated; + pub use self::installed_info_request_generated::*; + mod installed_info_response_generated; + pub use self::installed_info_response_generated::*; + mod server_infos_request_generated; + pub use self::server_infos_request_generated::*; + mod server_infos_response_generated; + pub use self::server_infos_response_generated::*; + mod save_file_notification_generated; + pub use self::save_file_notification_generated::*; } // rpc mod message_bundle_generated; pub use self::message_bundle_generated::*; diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs index d77d7a127..7866e78d4 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs @@ -71,11 +71,11 @@ impl<'a> DataFeedConfig<'a> { unsafe { self._tab.get::>(DataFeedConfig::VT_DATA_MASK, None)} } #[inline] - pub fn synthetic_trackers_mask(&self) -> Option> { + pub fn synthetic_trackers_mask(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(DataFeedConfig::VT_SYNTHETIC_TRACKERS_MASK, None)} + unsafe { self._tab.get::>(DataFeedConfig::VT_SYNTHETIC_TRACKERS_MASK, None)} } #[inline] pub fn bone_mask(&self) -> bool { @@ -109,7 +109,7 @@ impl flatbuffers::Verifiable for DataFeedConfig<'_> { v.visit_table(pos)? .visit_field::("minimum_time_since_last", Self::VT_MINIMUM_TIME_SINCE_LAST, false)? .visit_field::>("data_mask", Self::VT_DATA_MASK, false)? - .visit_field::>("synthetic_trackers_mask", Self::VT_SYNTHETIC_TRACKERS_MASK, false)? + .visit_field::>("synthetic_trackers_mask", Self::VT_SYNTHETIC_TRACKERS_MASK, false)? .visit_field::("bone_mask", Self::VT_BONE_MASK, false)? .visit_field::("stay_aligned_pose_mask", Self::VT_STAY_ALIGNED_POSE_MASK, false)? .visit_field::("server_guards_mask", Self::VT_SERVER_GUARDS_MASK, false)? @@ -120,7 +120,7 @@ impl flatbuffers::Verifiable for DataFeedConfig<'_> { pub struct DataFeedConfigArgs<'a> { pub minimum_time_since_last: u16, pub data_mask: Option>>, - pub synthetic_trackers_mask: Option>>, + pub synthetic_trackers_mask: Option>>, pub bone_mask: bool, pub stay_aligned_pose_mask: bool, pub server_guards_mask: bool, @@ -153,8 +153,8 @@ impl<'a: 'b, 'b> DataFeedConfigBuilder<'a, 'b> { self.fbb_.push_slot_always::>(DataFeedConfig::VT_DATA_MASK, data_mask); } #[inline] - pub fn add_synthetic_trackers_mask(&mut self, synthetic_trackers_mask: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(DataFeedConfig::VT_SYNTHETIC_TRACKERS_MASK, synthetic_trackers_mask); + pub fn add_synthetic_trackers_mask(&mut self, synthetic_trackers_mask: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(DataFeedConfig::VT_SYNTHETIC_TRACKERS_MASK, synthetic_trackers_mask); } #[inline] pub fn add_bone_mask(&mut self, bone_mask: bool) { diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs index 63062213b..0ee82ea97 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs @@ -67,11 +67,11 @@ impl<'a> DataFeedUpdate<'a> { unsafe { self._tab.get::>>>(DataFeedUpdate::VT_DEVICES, None)} } #[inline] - pub fn synthetic_trackers(&self) -> Option>>> { + pub fn synthetic_trackers(&self) -> Option>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(DataFeedUpdate::VT_SYNTHETIC_TRACKERS, None)} + unsafe { self._tab.get::>>>(DataFeedUpdate::VT_SYNTHETIC_TRACKERS, None)} } /// This must represent a set, where there is no more than one bone for a `BodyPart`. #[inline] @@ -88,6 +88,7 @@ impl<'a> DataFeedUpdate<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(DataFeedUpdate::VT_STAY_ALIGNED_POSE, None)} } + /// gives the index of the datafeed config that initiated the update #[inline] pub fn index(&self) -> u8 { // Safety: @@ -112,7 +113,7 @@ impl flatbuffers::Verifiable for DataFeedUpdate<'_> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::>>>("devices", Self::VT_DEVICES, false)? - .visit_field::>>>("synthetic_trackers", Self::VT_SYNTHETIC_TRACKERS, false)? + .visit_field::>>>("synthetic_trackers", Self::VT_SYNTHETIC_TRACKERS, false)? .visit_field::>>>("bones", Self::VT_BONES, false)? .visit_field::>("stay_aligned_pose", Self::VT_STAY_ALIGNED_POSE, false)? .visit_field::("index", Self::VT_INDEX, false)? @@ -123,7 +124,7 @@ impl flatbuffers::Verifiable for DataFeedUpdate<'_> { } pub struct DataFeedUpdateArgs<'a> { pub devices: Option>>>>, - pub synthetic_trackers: Option>>>>, + pub synthetic_trackers: Option>>>>, pub bones: Option>>>>, pub stay_aligned_pose: Option>>, pub index: u8, @@ -153,7 +154,7 @@ impl<'a: 'b, 'b> DataFeedUpdateBuilder<'a, 'b> { self.fbb_.push_slot_always::>(DataFeedUpdate::VT_DEVICES, devices); } #[inline] - pub fn add_synthetic_trackers(&mut self, synthetic_trackers: flatbuffers::WIPOffset>>>) { + pub fn add_synthetic_trackers(&mut self, synthetic_trackers: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(DataFeedUpdate::VT_SYNTHETIC_TRACKERS, synthetic_trackers); } #[inline] diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_generated.rs index af9a830a3..3cfeae761 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_generated.rs @@ -13,7 +13,7 @@ pub enum DeviceDataOffset {} #[derive(Copy, Clone, PartialEq)] /// Describes all possible information about a hardware device. For example, a -/// vive tracker is a single hardware device, and a slime tracker with two +/// vive tracker is a single hardware device, and a slime tracker with two /// extensions is a single hardware device but two trackers. pub struct DeviceData<'a> { pub _tab: flatbuffers::Table<'a>, @@ -48,17 +48,17 @@ impl<'a> DeviceData<'a> { if let Some(x) = args.hardware_status { builder.add_hardware_status(x); } if let Some(x) = args.hardware_info { builder.add_hardware_info(x); } if let Some(x) = args.custom_name { builder.add_custom_name(x); } - if let Some(x) = args.id { builder.add_id(x); } + builder.add_id(args.id); builder.finish() } #[inline] - pub fn id(&self) -> Option<&'a super::super::datatypes::DeviceId> { + pub fn id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(DeviceData::VT_ID, None)} + unsafe { self._tab.get::(DeviceData::VT_ID, Some(0)).unwrap()} } /// The dynamically changeable name of the device. This might be set by the /// user to help them remember which tracker is which. @@ -87,11 +87,11 @@ impl<'a> DeviceData<'a> { } /// Info about all trackers attached to this device #[inline] - pub fn trackers(&self) -> Option>>> { + pub fn trackers(&self) -> Option>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(DeviceData::VT_TRACKERS, None)} + unsafe { self._tab.get::>>>(DeviceData::VT_TRACKERS, None)} } } @@ -102,27 +102,27 @@ impl flatbuffers::Verifiable for DeviceData<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("id", Self::VT_ID, false)? + .visit_field::("id", Self::VT_ID, false)? .visit_field::>("custom_name", Self::VT_CUSTOM_NAME, false)? .visit_field::>("hardware_info", Self::VT_HARDWARE_INFO, false)? .visit_field::>("hardware_status", Self::VT_HARDWARE_STATUS, false)? - .visit_field::>>>("trackers", Self::VT_TRACKERS, false)? + .visit_field::>>>("trackers", Self::VT_TRACKERS, false)? .finish(); Ok(()) } } pub struct DeviceDataArgs<'a> { - pub id: Option<&'a super::super::datatypes::DeviceId>, + pub id: u16, pub custom_name: Option>, pub hardware_info: Option>>, pub hardware_status: Option>>, - pub trackers: Option>>>>, + pub trackers: Option>>>>, } impl<'a> Default for DeviceDataArgs<'a> { #[inline] fn default() -> Self { DeviceDataArgs { - id: None, + id: 0, custom_name: None, hardware_info: None, hardware_status: None, @@ -137,8 +137,8 @@ pub struct DeviceDataBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> DeviceDataBuilder<'a, 'b> { #[inline] - pub fn add_id(&mut self, id: &super::super::datatypes::DeviceId) { - self.fbb_.push_slot_always::<&super::super::datatypes::DeviceId>(DeviceData::VT_ID, id); + pub fn add_id(&mut self, id: u16) { + self.fbb_.push_slot::(DeviceData::VT_ID, id, 0); } #[inline] pub fn add_custom_name(&mut self, custom_name: flatbuffers::WIPOffset<&'b str>) { @@ -153,7 +153,7 @@ impl<'a: 'b, 'b> DeviceDataBuilder<'a, 'b> { self.fbb_.push_slot_always::>(DeviceData::VT_HARDWARE_STATUS, hardware_status); } #[inline] - pub fn add_trackers(&mut self, trackers: flatbuffers::WIPOffset>>>) { + pub fn add_trackers(&mut self, trackers: flatbuffers::WIPOffset>>>) { self.fbb_.push_slot_always::>(DeviceData::VT_TRACKERS, trackers); } #[inline] diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_mask_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_mask_generated.rs index 392426af6..bdf818744 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_mask_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/device_data/device_data_mask_generated.rs @@ -52,11 +52,11 @@ impl<'a> DeviceDataMask<'a> { /// Which tracker data should be sent in this data feed #[inline] - pub fn tracker_data(&self) -> Option> { + pub fn tracker_data(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(DeviceDataMask::VT_TRACKER_DATA, None)} + unsafe { self._tab.get::>(DeviceDataMask::VT_TRACKER_DATA, None)} } /// true if device data should be sent in this data feed #[inline] @@ -75,14 +75,14 @@ impl flatbuffers::Verifiable for DeviceDataMask<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_data", Self::VT_TRACKER_DATA, false)? + .visit_field::>("tracker_data", Self::VT_TRACKER_DATA, false)? .visit_field::("device_data", Self::VT_DEVICE_DATA, false)? .finish(); Ok(()) } } pub struct DeviceDataMaskArgs<'a> { - pub tracker_data: Option>>, + pub tracker_data: Option>>, pub device_data: bool, } impl<'a> Default for DeviceDataMaskArgs<'a> { @@ -101,8 +101,8 @@ pub struct DeviceDataMaskBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> DeviceDataMaskBuilder<'a, 'b> { #[inline] - pub fn add_tracker_data(&mut self, tracker_data: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(DeviceDataMask::VT_TRACKER_DATA, tracker_data); + pub fn add_tracker_data(&mut self, tracker_data: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(DeviceDataMask::VT_TRACKER_DATA, tracker_data); } #[inline] pub fn add_device_data(&mut self, device_data: bool) { diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs index c00771ffa..ff201871c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs @@ -12,6 +12,10 @@ use super::*; pub enum ServerGuardsOffset {} #[derive(Copy, Clone, PartialEq)] +/// Contains various of flags / guards that inform the GUI +/// about possible actions or blocked states. +/// The idea is to have one source of truth for all these rules +/// that are spread accross the GUI. pub struct ServerGuards<'a> { pub _tab: flatbuffers::Table<'a>, } @@ -25,9 +29,9 @@ impl<'a> flatbuffers::Follow<'a> for ServerGuards<'a> { } impl<'a> ServerGuards<'a> { - pub const VT_CANDOMOUNTING: flatbuffers::VOffsetT = 4; - pub const VT_CANDOYAWRESET: flatbuffers::VOffsetT = 6; - pub const VT_CANDOUSERHEIGHTCALIBRATION: flatbuffers::VOffsetT = 8; + pub const VT_CAN_DO_MOUNTING_RESET: flatbuffers::VOffsetT = 4; + pub const VT_CAN_DO_YAW_RESET: flatbuffers::VOffsetT = 6; + pub const VT_CAN_DO_USER_HEIGHT_CALIBRATION: flatbuffers::VOffsetT = 8; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -39,33 +43,33 @@ impl<'a> ServerGuards<'a> { args: &'args ServerGuardsArgs ) -> flatbuffers::WIPOffset> { let mut builder = ServerGuardsBuilder::new(_fbb); - builder.add_canDoUserHeightCalibration(args.canDoUserHeightCalibration); - builder.add_canDoYawReset(args.canDoYawReset); - builder.add_canDoMounting(args.canDoMounting); + builder.add_can_do_user_height_calibration(args.can_do_user_height_calibration); + builder.add_can_do_yaw_reset(args.can_do_yaw_reset); + builder.add_can_do_mounting_reset(args.can_do_mounting_reset); builder.finish() } #[inline] - pub fn canDoMounting(&self) -> bool { + pub fn can_do_mounting_reset(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ServerGuards::VT_CANDOMOUNTING, Some(false)).unwrap()} + unsafe { self._tab.get::(ServerGuards::VT_CAN_DO_MOUNTING_RESET, Some(false)).unwrap()} } #[inline] - pub fn canDoYawReset(&self) -> bool { + pub fn can_do_yaw_reset(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ServerGuards::VT_CANDOYAWRESET, Some(false)).unwrap()} + unsafe { self._tab.get::(ServerGuards::VT_CAN_DO_YAW_RESET, Some(false)).unwrap()} } #[inline] - pub fn canDoUserHeightCalibration(&self) -> bool { + pub fn can_do_user_height_calibration(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ServerGuards::VT_CANDOUSERHEIGHTCALIBRATION, Some(false)).unwrap()} + unsafe { self._tab.get::(ServerGuards::VT_CAN_DO_USER_HEIGHT_CALIBRATION, Some(false)).unwrap()} } } @@ -76,25 +80,25 @@ impl flatbuffers::Verifiable for ServerGuards<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("canDoMounting", Self::VT_CANDOMOUNTING, false)? - .visit_field::("canDoYawReset", Self::VT_CANDOYAWRESET, false)? - .visit_field::("canDoUserHeightCalibration", Self::VT_CANDOUSERHEIGHTCALIBRATION, false)? + .visit_field::("can_do_mounting_reset", Self::VT_CAN_DO_MOUNTING_RESET, false)? + .visit_field::("can_do_yaw_reset", Self::VT_CAN_DO_YAW_RESET, false)? + .visit_field::("can_do_user_height_calibration", Self::VT_CAN_DO_USER_HEIGHT_CALIBRATION, false)? .finish(); Ok(()) } } pub struct ServerGuardsArgs { - pub canDoMounting: bool, - pub canDoYawReset: bool, - pub canDoUserHeightCalibration: bool, + pub can_do_mounting_reset: bool, + pub can_do_yaw_reset: bool, + pub can_do_user_height_calibration: bool, } impl<'a> Default for ServerGuardsArgs { #[inline] fn default() -> Self { ServerGuardsArgs { - canDoMounting: false, - canDoYawReset: false, - canDoUserHeightCalibration: false, + can_do_mounting_reset: false, + can_do_yaw_reset: false, + can_do_user_height_calibration: false, } } } @@ -105,16 +109,16 @@ pub struct ServerGuardsBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> ServerGuardsBuilder<'a, 'b> { #[inline] - pub fn add_canDoMounting(&mut self, canDoMounting: bool) { - self.fbb_.push_slot::(ServerGuards::VT_CANDOMOUNTING, canDoMounting, false); + pub fn add_can_do_mounting_reset(&mut self, can_do_mounting_reset: bool) { + self.fbb_.push_slot::(ServerGuards::VT_CAN_DO_MOUNTING_RESET, can_do_mounting_reset, false); } #[inline] - pub fn add_canDoYawReset(&mut self, canDoYawReset: bool) { - self.fbb_.push_slot::(ServerGuards::VT_CANDOYAWRESET, canDoYawReset, false); + pub fn add_can_do_yaw_reset(&mut self, can_do_yaw_reset: bool) { + self.fbb_.push_slot::(ServerGuards::VT_CAN_DO_YAW_RESET, can_do_yaw_reset, false); } #[inline] - pub fn add_canDoUserHeightCalibration(&mut self, canDoUserHeightCalibration: bool) { - self.fbb_.push_slot::(ServerGuards::VT_CANDOUSERHEIGHTCALIBRATION, canDoUserHeightCalibration, false); + pub fn add_can_do_user_height_calibration(&mut self, can_do_user_height_calibration: bool) { + self.fbb_.push_slot::(ServerGuards::VT_CAN_DO_USER_HEIGHT_CALIBRATION, can_do_user_height_calibration, false); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ServerGuardsBuilder<'a, 'b> { @@ -134,9 +138,9 @@ impl<'a: 'b, 'b> ServerGuardsBuilder<'a, 'b> { impl core::fmt::Debug for ServerGuards<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ServerGuards"); - ds.field("canDoMounting", &self.canDoMounting()); - ds.field("canDoYawReset", &self.canDoYawReset()); - ds.field("canDoUserHeightCalibration", &self.canDoUserHeightCalibration()); + ds.field("can_do_mounting_reset", &self.can_do_mounting_reset()); + ds.field("can_do_yaw_reset", &self.can_do_yaw_reset()); + ds.field("can_do_user_height_calibration", &self.can_do_user_height_calibration()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_data_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_data_generated.rs similarity index 89% rename from protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_data_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_data_generated.rs index 8e8d355c8..f714b24e6 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_data_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_data_generated.rs @@ -30,20 +30,21 @@ impl<'a> flatbuffers::Follow<'a> for TrackerData<'a> { } impl<'a> TrackerData<'a> { - pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; - pub const VT_INFO: flatbuffers::VOffsetT = 6; - pub const VT_STATUS: flatbuffers::VOffsetT = 8; - pub const VT_ROTATION: flatbuffers::VOffsetT = 10; - pub const VT_POSITION: flatbuffers::VOffsetT = 12; - pub const VT_RAW_ANGULAR_VELOCITY: flatbuffers::VOffsetT = 14; - pub const VT_RAW_ACCELERATION: flatbuffers::VOffsetT = 16; - pub const VT_TEMP: flatbuffers::VOffsetT = 18; - pub const VT_LINEAR_ACCELERATION: flatbuffers::VOffsetT = 20; - pub const VT_ROTATION_REFERENCE_ADJUSTED: flatbuffers::VOffsetT = 22; - pub const VT_ROTATION_IDENTITY_ADJUSTED: flatbuffers::VOffsetT = 24; - pub const VT_TPS: flatbuffers::VOffsetT = 26; - pub const VT_RAW_MAGNETIC_VECTOR: flatbuffers::VOffsetT = 28; - pub const VT_STAY_ALIGNED: flatbuffers::VOffsetT = 30; + pub const VT_DEVICE_ID: flatbuffers::VOffsetT = 4; + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 6; + pub const VT_INFO: flatbuffers::VOffsetT = 8; + pub const VT_STATUS: flatbuffers::VOffsetT = 10; + pub const VT_ROTATION: flatbuffers::VOffsetT = 12; + pub const VT_POSITION: flatbuffers::VOffsetT = 14; + pub const VT_RAW_ANGULAR_VELOCITY: flatbuffers::VOffsetT = 16; + pub const VT_RAW_ACCELERATION: flatbuffers::VOffsetT = 18; + pub const VT_TEMP: flatbuffers::VOffsetT = 20; + pub const VT_LINEAR_ACCELERATION: flatbuffers::VOffsetT = 22; + pub const VT_ROTATION_REFERENCE_ADJUSTED: flatbuffers::VOffsetT = 24; + pub const VT_ROTATION_IDENTITY_ADJUSTED: flatbuffers::VOffsetT = 26; + pub const VT_TPS: flatbuffers::VOffsetT = 28; + pub const VT_RAW_MAGNETIC_VECTOR: flatbuffers::VOffsetT = 30; + pub const VT_STAY_ALIGNED: flatbuffers::VOffsetT = 32; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -66,19 +67,27 @@ impl<'a> TrackerData<'a> { if let Some(x) = args.position { builder.add_position(x); } if let Some(x) = args.rotation { builder.add_rotation(x); } if let Some(x) = args.info { builder.add_info(x); } - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } if let Some(x) = args.tps { builder.add_tps(x); } + builder.add_tracker_id(args.tracker_id); + builder.add_device_id(args.device_id); builder.add_status(args.status); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn device_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(TrackerData::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(TrackerData::VT_DEVICE_ID, Some(0)).unwrap()} + } + #[inline] + pub fn tracker_id(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackerData::VT_TRACKER_ID, Some(0)).unwrap()} } #[inline] pub fn info(&self) -> Option> { @@ -102,7 +111,7 @@ impl<'a> TrackerData<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(TrackerData::VT_ROTATION, None)} } - /// Position, in meters + /// Position in meters in OpenVR's space (left-handed, X+ Right, Y+ Up, Z- Forward) #[inline] pub fn position(&self) -> Option<&'a super::super::datatypes::math::Vec3f> { // Safety: @@ -143,7 +152,7 @@ impl<'a> TrackerData<'a> { unsafe { self._tab.get::(TrackerData::VT_LINEAR_ACCELERATION, None)} } /// Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - /// In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), + /// In other words, a rotation that is aligned to a reliable source of rotation (0, HMD YAW, 0), /// triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: mounting orientation, full, quick and mounting reset adjustments. @@ -156,7 +165,7 @@ impl<'a> TrackerData<'a> { unsafe { self._tab.get::(TrackerData::VT_ROTATION_REFERENCE_ADJUSTED, None)} } /// Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - /// In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by + /// In other words, a rotation that is aligned to a zero vector (0, 0, 0) by /// inverting the current rotation, triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: only full and quick reset adjustments. @@ -201,7 +210,8 @@ impl flatbuffers::Verifiable for TrackerData<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("device_id", Self::VT_DEVICE_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .visit_field::>("info", Self::VT_INFO, false)? .visit_field::("status", Self::VT_STATUS, false)? .visit_field::("rotation", Self::VT_ROTATION, false)? @@ -220,7 +230,8 @@ impl flatbuffers::Verifiable for TrackerData<'_> { } } pub struct TrackerDataArgs<'a> { - pub tracker_id: Option>>, + pub device_id: u16, + pub tracker_id: u16, pub info: Option>>, pub status: super::super::datatypes::TrackerStatus, pub rotation: Option<&'a super::super::datatypes::math::Quat>, @@ -239,7 +250,8 @@ impl<'a> Default for TrackerDataArgs<'a> { #[inline] fn default() -> Self { TrackerDataArgs { - tracker_id: None, + device_id: 0, + tracker_id: 0, info: None, status: super::super::datatypes::TrackerStatus::NONE, rotation: None, @@ -263,8 +275,12 @@ pub struct TrackerDataBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackerDataBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TrackerData::VT_TRACKER_ID, tracker_id); + pub fn add_device_id(&mut self, device_id: u16) { + self.fbb_.push_slot::(TrackerData::VT_DEVICE_ID, device_id, 0); + } + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(TrackerData::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn add_info(&mut self, info: flatbuffers::WIPOffset>) { @@ -336,6 +352,7 @@ impl<'a: 'b, 'b> TrackerDataBuilder<'a, 'b> { impl core::fmt::Debug for TrackerData<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("TrackerData"); + ds.field("device_id", &self.device_id()); ds.field("tracker_id", &self.tracker_id()); ds.field("info", &self.info()); ds.field("status", &self.status()); diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_data_mask_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_data_mask_generated.rs similarity index 100% rename from protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_data_mask_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_data_mask_generated.rs diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_info_generated.rs similarity index 91% rename from protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_info_generated.rs index a53ebd36f..a010c6103 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/tracker_data/tracker_info_generated.rs @@ -35,11 +35,10 @@ impl<'a> TrackerInfo<'a> { pub const VT_IS_IMU: flatbuffers::VOffsetT = 16; pub const VT_DISPLAY_NAME: flatbuffers::VOffsetT = 18; pub const VT_CUSTOM_NAME: flatbuffers::VOffsetT = 20; - pub const VT_ALLOW_DRIFT_COMPENSATION: flatbuffers::VOffsetT = 22; - pub const VT_MOUNTING_RESET_ORIENTATION: flatbuffers::VOffsetT = 24; - pub const VT_IS_HMD: flatbuffers::VOffsetT = 26; - pub const VT_MAGNETOMETER: flatbuffers::VOffsetT = 28; - pub const VT_DATA_SUPPORT: flatbuffers::VOffsetT = 30; + pub const VT_MOUNTING_RESET_ORIENTATION: flatbuffers::VOffsetT = 22; + pub const VT_IS_HMD: flatbuffers::VOffsetT = 24; + pub const VT_MAGNETOMETER: flatbuffers::VOffsetT = 26; + pub const VT_DATA_SUPPORT: flatbuffers::VOffsetT = 28; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -60,7 +59,6 @@ impl<'a> TrackerInfo<'a> { builder.add_data_support(args.data_support); builder.add_magnetometer(args.magnetometer); builder.add_is_hmd(args.is_hmd); - builder.add_allow_drift_compensation(args.allow_drift_compensation); builder.add_is_imu(args.is_imu); builder.add_is_computed(args.is_computed); builder.add_editable(args.editable); @@ -74,7 +72,7 @@ impl<'a> TrackerInfo<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TrackerInfo::VT_IMU_TYPE, Some(super::super::datatypes::hardware_info::ImuType::Other)).unwrap()} + unsafe { self._tab.get::(TrackerInfo::VT_IMU_TYPE, Some(super::super::datatypes::hardware_info::ImuType::UNKNOWN)).unwrap()} } /// The user-assigned role of the tracker. #[inline] @@ -84,7 +82,7 @@ impl<'a> TrackerInfo<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(TrackerInfo::VT_BODY_PART, Some(super::super::datatypes::BodyPart::NONE)).unwrap()} } - /// average samples per second + /// Average samples per second #[inline] pub fn poll_rate(&self) -> Option<&'a super::super::datatypes::HzF32> { // Safety: @@ -140,14 +138,6 @@ impl<'a> TrackerInfo<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(TrackerInfo::VT_CUSTOM_NAME, None)} } - /// Whether to allow yaw drift compensation for this tracker or not. - #[inline] - pub fn allow_drift_compensation(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TrackerInfo::VT_ALLOW_DRIFT_COMPENSATION, Some(false)).unwrap()} - } /// Mounting Reset orientation overrides the current `mounting_orientation` of /// the tracker, this orientation is not saved and needs to be calculated /// each time the server is ran @@ -158,7 +148,7 @@ impl<'a> TrackerInfo<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(TrackerInfo::VT_MOUNTING_RESET_ORIENTATION, None)} } - /// Indicates if the tracker is actually an HMD + /// Indicates if the tracker is actually a VR headset #[inline] pub fn is_hmd(&self) -> bool { // Safety: @@ -173,7 +163,7 @@ impl<'a> TrackerInfo<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(TrackerInfo::VT_MAGNETOMETER, Some(super::super::datatypes::MagnetometerStatus::NOT_SUPPORTED)).unwrap()} } - /// Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) + /// Indicates what type of data the tracker sends (that gets transformed into a rotation) #[inline] pub fn data_support(&self) -> super::super::datatypes::hardware_info::TrackerDataType { // Safety: @@ -199,7 +189,6 @@ impl flatbuffers::Verifiable for TrackerInfo<'_> { .visit_field::("is_imu", Self::VT_IS_IMU, false)? .visit_field::>("display_name", Self::VT_DISPLAY_NAME, false)? .visit_field::>("custom_name", Self::VT_CUSTOM_NAME, false)? - .visit_field::("allow_drift_compensation", Self::VT_ALLOW_DRIFT_COMPENSATION, false)? .visit_field::("mounting_reset_orientation", Self::VT_MOUNTING_RESET_ORIENTATION, false)? .visit_field::("is_hmd", Self::VT_IS_HMD, false)? .visit_field::("magnetometer", Self::VT_MAGNETOMETER, false)? @@ -218,7 +207,6 @@ pub struct TrackerInfoArgs<'a> { pub is_imu: bool, pub display_name: Option>, pub custom_name: Option>, - pub allow_drift_compensation: bool, pub mounting_reset_orientation: Option<&'a super::super::datatypes::math::Quat>, pub is_hmd: bool, pub magnetometer: super::super::datatypes::MagnetometerStatus, @@ -228,7 +216,7 @@ impl<'a> Default for TrackerInfoArgs<'a> { #[inline] fn default() -> Self { TrackerInfoArgs { - imu_type: super::super::datatypes::hardware_info::ImuType::Other, + imu_type: super::super::datatypes::hardware_info::ImuType::UNKNOWN, body_part: super::super::datatypes::BodyPart::NONE, poll_rate: None, mounting_orientation: None, @@ -237,7 +225,6 @@ impl<'a> Default for TrackerInfoArgs<'a> { is_imu: false, display_name: None, custom_name: None, - allow_drift_compensation: false, mounting_reset_orientation: None, is_hmd: false, magnetometer: super::super::datatypes::MagnetometerStatus::NOT_SUPPORTED, @@ -253,7 +240,7 @@ pub struct TrackerInfoBuilder<'a: 'b, 'b> { impl<'a: 'b, 'b> TrackerInfoBuilder<'a, 'b> { #[inline] pub fn add_imu_type(&mut self, imu_type: super::super::datatypes::hardware_info::ImuType) { - self.fbb_.push_slot::(TrackerInfo::VT_IMU_TYPE, imu_type, super::super::datatypes::hardware_info::ImuType::Other); + self.fbb_.push_slot::(TrackerInfo::VT_IMU_TYPE, imu_type, super::super::datatypes::hardware_info::ImuType::UNKNOWN); } #[inline] pub fn add_body_part(&mut self, body_part: super::super::datatypes::BodyPart) { @@ -288,10 +275,6 @@ impl<'a: 'b, 'b> TrackerInfoBuilder<'a, 'b> { self.fbb_.push_slot_always::>(TrackerInfo::VT_CUSTOM_NAME, custom_name); } #[inline] - pub fn add_allow_drift_compensation(&mut self, allow_drift_compensation: bool) { - self.fbb_.push_slot::(TrackerInfo::VT_ALLOW_DRIFT_COMPENSATION, allow_drift_compensation, false); - } - #[inline] pub fn add_mounting_reset_orientation(&mut self, mounting_reset_orientation: &super::super::datatypes::math::Quat) { self.fbb_.push_slot_always::<&super::super::datatypes::math::Quat>(TrackerInfo::VT_MOUNTING_RESET_ORIENTATION, mounting_reset_orientation); } @@ -334,7 +317,6 @@ impl core::fmt::Debug for TrackerInfo<'_> { ds.field("is_imu", &self.is_imu()); ds.field("display_name", &self.display_name()); ds.field("custom_name", &self.custom_name()); - ds.field("allow_drift_compensation", &self.allow_drift_compensation()); ds.field("mounting_reset_orientation", &self.mounting_reset_orientation()); ds.field("is_hmd", &self.is_hmd()); ds.field("magnetometer", &self.magnetometer()); diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_generated.rs deleted file mode 100644 index 6333a53ec..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_generated.rs +++ /dev/null @@ -1,105 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -/// A unique ID for the device. IDs are not guaranteed to be the same after -/// the connection is terminated. -// struct DeviceId, aligned to 1 -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq)] -pub struct DeviceId(pub [u8; 1]); -impl Default for DeviceId { - fn default() -> Self { - Self([0; 1]) - } -} -impl core::fmt::Debug for DeviceId { - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { - f.debug_struct("DeviceId") - .field("id", &self.id()) - .finish() - } -} - -impl flatbuffers::SimpleToVerifyInSlice for DeviceId {} -impl<'a> flatbuffers::Follow<'a> for DeviceId { - type Inner = &'a DeviceId; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - <&'a DeviceId>::follow(buf, loc) - } -} -impl<'a> flatbuffers::Follow<'a> for &'a DeviceId { - type Inner = &'a DeviceId; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::follow_cast_ref::(buf, loc) - } -} -impl<'b> flatbuffers::Push for DeviceId { - type Output = DeviceId; - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - let src = ::core::slice::from_raw_parts(self as *const DeviceId as *const u8, Self::size()); - dst.copy_from_slice(src); - } -} - -impl<'a> flatbuffers::Verifiable for DeviceId { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.in_buffer::(pos) - } -} - -impl<'a> DeviceId { - #[allow(clippy::too_many_arguments)] - pub fn new( - id: u8, - ) -> Self { - let mut s = Self([0; 1]); - s.set_id(id); - s - } - - pub fn id(&self) -> u8 { - let mut mem = core::mem::MaybeUninit::<::Scalar>::uninit(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - EndianScalar::from_little_endian(unsafe { - core::ptr::copy_nonoverlapping( - self.0[0..].as_ptr(), - mem.as_mut_ptr() as *mut u8, - core::mem::size_of::<::Scalar>(), - ); - mem.assume_init() - }) - } - - pub fn set_id(&mut self, x: u8) { - let x_le = x.to_little_endian(); - // Safety: - // Created from a valid Table for this object - // Which contains a valid value in this slot - unsafe { - core::ptr::copy_nonoverlapping( - &x_le as *const _ as *const u8, - self.0[0..].as_mut_ptr(), - core::mem::size_of::<::Scalar>(), - ); - } - } - -} - diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_table_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_table_generated.rs deleted file mode 100644 index 0cae1ae42..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/device_id_table_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum DeviceIdTableOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// To be used inside unions -pub struct DeviceIdTable<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for DeviceIdTable<'a> { - type Inner = DeviceIdTable<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> DeviceIdTable<'a> { - pub const VT_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DeviceIdTable { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DeviceIdTableArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = DeviceIdTableBuilder::new(_fbb); - if let Some(x) = args.id { builder.add_id(x); } - builder.finish() - } - - - #[inline] - pub fn id(&self) -> Option<&'a DeviceId> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(DeviceIdTable::VT_ID, None)} - } -} - -impl flatbuffers::Verifiable for DeviceIdTable<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("id", Self::VT_ID, false)? - .finish(); - Ok(()) - } -} -pub struct DeviceIdTableArgs<'a> { - pub id: Option<&'a DeviceId>, -} -impl<'a> Default for DeviceIdTableArgs<'a> { - #[inline] - fn default() -> Self { - DeviceIdTableArgs { - id: None, - } - } -} - -pub struct DeviceIdTableBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> DeviceIdTableBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: &DeviceId) { - self.fbb_.push_slot_always::<&DeviceId>(DeviceIdTable::VT_ID, id); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DeviceIdTableBuilder<'a, 'b> { - let start = _fbb.start_table(); - DeviceIdTableBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for DeviceIdTable<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("DeviceIdTable"); - ds.field("id", &self.id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_info_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_info_generated.rs index c030614db..463b2d3a7 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_info_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_info_generated.rs @@ -72,7 +72,7 @@ impl<'a> HardwareInfo<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(HardwareInfo::VT_MCU_ID, Some(McuType::Other)).unwrap()} + unsafe { self._tab.get::(HardwareInfo::VT_MCU_ID, Some(McuType::UNKNOWN)).unwrap()} } /// A human-friendly name to display as the name of the device. #[inline] @@ -214,7 +214,7 @@ impl<'a> Default for HardwareInfoArgs<'a> { #[inline] fn default() -> Self { HardwareInfoArgs { - mcu_id: McuType::Other, + mcu_id: McuType::UNKNOWN, display_name: None, model: None, manufacturer: None, @@ -238,7 +238,7 @@ pub struct HardwareInfoBuilder<'a: 'b, 'b> { impl<'a: 'b, 'b> HardwareInfoBuilder<'a, 'b> { #[inline] pub fn add_mcu_id(&mut self, mcu_id: McuType) { - self.fbb_.push_slot::(HardwareInfo::VT_MCU_ID, mcu_id, McuType::Other); + self.fbb_.push_slot::(HardwareInfo::VT_MCU_ID, mcu_id, McuType::UNKNOWN); } #[inline] pub fn add_display_name(&mut self, display_name: flatbuffers::WIPOffset<&'b str>) { diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs index 4cdd66029..462128bcc 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_status_generated.rs @@ -27,16 +27,16 @@ impl<'a> flatbuffers::Follow<'a> for HardwareStatus<'a> { impl<'a> HardwareStatus<'a> { pub const VT_ERROR_STATUS: flatbuffers::VOffsetT = 4; - pub const VT_PING: flatbuffers::VOffsetT = 8; - pub const VT_RSSI: flatbuffers::VOffsetT = 10; - pub const VT_MCU_TEMP: flatbuffers::VOffsetT = 12; - pub const VT_BATTERY_VOLTAGE: flatbuffers::VOffsetT = 14; - pub const VT_BATTERY_PCT_ESTIMATE: flatbuffers::VOffsetT = 16; - pub const VT_LOG_DATA: flatbuffers::VOffsetT = 18; - pub const VT_PACKET_LOSS: flatbuffers::VOffsetT = 20; - pub const VT_PACKETS_LOST: flatbuffers::VOffsetT = 22; - pub const VT_PACKETS_RECEIVED: flatbuffers::VOffsetT = 24; - pub const VT_BATTERY_RUNTIME_ESTIMATE: flatbuffers::VOffsetT = 26; + pub const VT_PING: flatbuffers::VOffsetT = 6; + pub const VT_RSSI: flatbuffers::VOffsetT = 8; + pub const VT_MCU_TEMP: flatbuffers::VOffsetT = 10; + pub const VT_BATTERY_VOLTAGE: flatbuffers::VOffsetT = 12; + pub const VT_BATTERY_PCT_ESTIMATE: flatbuffers::VOffsetT = 14; + pub const VT_LOG_DATA: flatbuffers::VOffsetT = 16; + pub const VT_PACKET_LOSS: flatbuffers::VOffsetT = 18; + pub const VT_PACKETS_LOST: flatbuffers::VOffsetT = 20; + pub const VT_PACKETS_RECEIVED: flatbuffers::VOffsetT = 22; + pub const VT_BATTERY_RUNTIME_ESTIMATE: flatbuffers::VOffsetT = 24; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/imu_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/imu_type_generated.rs index a18a5064a..33282abe7 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/imu_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/imu_type_generated.rs @@ -16,7 +16,7 @@ pub const ENUM_MAX_IMU_TYPE: u16 = 250; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_IMU_TYPE: [ImuType; 21] = [ - ImuType::Other, + ImuType::UNKNOWN, ImuType::MPU9250, ImuType::MPU6500, ImuType::BNO080, @@ -44,7 +44,7 @@ pub const ENUM_VALUES_IMU_TYPE: [ImuType; 21] = [ pub struct ImuType(pub u16); #[allow(non_upper_case_globals)] impl ImuType { - pub const Other: Self = Self(0); + pub const UNKNOWN: Self = Self(0); pub const MPU9250: Self = Self(1); pub const MPU6500: Self = Self(2); pub const BNO080: Self = Self(3); @@ -69,7 +69,7 @@ impl ImuType { pub const ENUM_MIN: u16 = 0; pub const ENUM_MAX: u16 = 250; pub const ENUM_VALUES: &'static [Self] = &[ - Self::Other, + Self::UNKNOWN, Self::MPU9250, Self::MPU6500, Self::BNO080, @@ -94,7 +94,7 @@ impl ImuType { /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::Other => Some("Other"), + Self::UNKNOWN => Some("UNKNOWN"), Self::MPU9250 => Some("MPU9250"), Self::MPU6500 => Some("MPU6500"), Self::BNO080 => Some("BNO080"), diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/mcu_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/mcu_type_generated.rs index 060262cd6..f0610b2fd 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/mcu_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/mcu_type_generated.rs @@ -16,7 +16,7 @@ pub const ENUM_MAX_MCU_TYPE: u16 = 250; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_MCU_TYPE: [McuType; 12] = [ - McuType::Other, + McuType::UNKNOWN, McuType::ESP8266, McuType::ESP32, McuType::OWOTRACK_ANDROID, @@ -35,7 +35,7 @@ pub const ENUM_VALUES_MCU_TYPE: [McuType; 12] = [ pub struct McuType(pub u16); #[allow(non_upper_case_globals)] impl McuType { - pub const Other: Self = Self(0); + pub const UNKNOWN: Self = Self(0); pub const ESP8266: Self = Self(1); pub const ESP32: Self = Self(2); pub const OWOTRACK_ANDROID: Self = Self(3); @@ -51,7 +51,7 @@ impl McuType { pub const ENUM_MIN: u16 = 0; pub const ENUM_MAX: u16 = 250; pub const ENUM_VALUES: &'static [Self] = &[ - Self::Other, + Self::UNKNOWN, Self::ESP8266, Self::ESP32, Self::OWOTRACK_ANDROID, @@ -67,7 +67,7 @@ impl McuType { /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::Other => Some("Other"), + Self::UNKNOWN => Some("UNKNOWN"), Self::ESP8266 => Some("ESP8266"), Self::ESP32 => Some("ESP32"), Self::OWOTRACK_ANDROID => Some("OWOTRACK_ANDROID"), diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/tracker_data_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/tracker_data_type_generated.rs index 87bb0fd05..7a4066039 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/tracker_data_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/tracker_data_type_generated.rs @@ -21,7 +21,7 @@ pub const ENUM_VALUES_TRACKER_DATA_TYPE: [TrackerDataType; 3] = [ TrackerDataType::FLEX_ANGLE, ]; -/// What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. +/// What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct TrackerDataType(pub u8); diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/tracker_id_generated.rs b/protocol/rust/src/generated/solarxr_protocol/datatypes/tracker_id_generated.rs deleted file mode 100644 index 79d8f0805..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/tracker_id_generated.rs +++ /dev/null @@ -1,128 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum TrackerIdOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct TrackerId<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for TrackerId<'a> { - type Inner = TrackerId<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> TrackerId<'a> { - pub const VT_DEVICE_ID: flatbuffers::VOffsetT = 4; - pub const VT_TRACKER_NUM: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TrackerId { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TrackerIdArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = TrackerIdBuilder::new(_fbb); - if let Some(x) = args.device_id { builder.add_device_id(x); } - builder.add_tracker_num(args.tracker_num); - builder.finish() - } - - - /// The device the tracker is associated with. If there is no hardware device it is - /// associated with, this should be `null`. - #[inline] - pub fn device_id(&self) -> Option<&'a DeviceId> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TrackerId::VT_DEVICE_ID, None)} - } - /// There are possibly multiple trackers per device. This identifies which one. - #[inline] - pub fn tracker_num(&self) -> u8 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TrackerId::VT_TRACKER_NUM, Some(0)).unwrap()} - } -} - -impl flatbuffers::Verifiable for TrackerId<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("device_id", Self::VT_DEVICE_ID, false)? - .visit_field::("tracker_num", Self::VT_TRACKER_NUM, false)? - .finish(); - Ok(()) - } -} -pub struct TrackerIdArgs<'a> { - pub device_id: Option<&'a DeviceId>, - pub tracker_num: u8, -} -impl<'a> Default for TrackerIdArgs<'a> { - #[inline] - fn default() -> Self { - TrackerIdArgs { - device_id: None, - tracker_num: 0, - } - } -} - -pub struct TrackerIdBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> TrackerIdBuilder<'a, 'b> { - #[inline] - pub fn add_device_id(&mut self, device_id: &DeviceId) { - self.fbb_.push_slot_always::<&DeviceId>(TrackerId::VT_DEVICE_ID, device_id); - } - #[inline] - pub fn add_tracker_num(&mut self, tracker_num: u8) { - self.fbb_.push_slot::(TrackerId::VT_TRACKER_NUM, tracker_num, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackerIdBuilder<'a, 'b> { - let start = _fbb.start_table(); - TrackerIdBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for TrackerId<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TrackerId"); - ds.field("device_id", &self.device_id()); - ds.field("tracker_num", &self.tracker_num()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/message_bundle_generated.rs b/protocol/rust/src/generated/solarxr_protocol/message_bundle_generated.rs index 81d458892..0686f3bd3 100644 --- a/protocol/rust/src/generated/solarxr_protocol/message_bundle_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/message_bundle_generated.rs @@ -29,7 +29,6 @@ impl<'a> flatbuffers::Follow<'a> for MessageBundle<'a> { impl<'a> MessageBundle<'a> { pub const VT_DATA_FEED_MSGS: flatbuffers::VOffsetT = 4; pub const VT_RPC_MSGS: flatbuffers::VOffsetT = 6; - pub const VT_PUB_SUB_MSGS: flatbuffers::VOffsetT = 8; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -41,7 +40,6 @@ impl<'a> MessageBundle<'a> { args: &'args MessageBundleArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = MessageBundleBuilder::new(_fbb); - if let Some(x) = args.pub_sub_msgs { builder.add_pub_sub_msgs(x); } if let Some(x) = args.rpc_msgs { builder.add_rpc_msgs(x); } if let Some(x) = args.data_feed_msgs { builder.add_data_feed_msgs(x); } builder.finish() @@ -62,13 +60,6 @@ impl<'a> MessageBundle<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>>>(MessageBundle::VT_RPC_MSGS, None)} } - #[inline] - pub fn pub_sub_msgs(&self) -> Option>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(MessageBundle::VT_PUB_SUB_MSGS, None)} - } } impl flatbuffers::Verifiable for MessageBundle<'_> { @@ -80,7 +71,6 @@ impl flatbuffers::Verifiable for MessageBundle<'_> { v.visit_table(pos)? .visit_field::>>>("data_feed_msgs", Self::VT_DATA_FEED_MSGS, false)? .visit_field::>>>("rpc_msgs", Self::VT_RPC_MSGS, false)? - .visit_field::>>>("pub_sub_msgs", Self::VT_PUB_SUB_MSGS, false)? .finish(); Ok(()) } @@ -88,7 +78,6 @@ impl flatbuffers::Verifiable for MessageBundle<'_> { pub struct MessageBundleArgs<'a> { pub data_feed_msgs: Option>>>>, pub rpc_msgs: Option>>>>, - pub pub_sub_msgs: Option>>>>, } impl<'a> Default for MessageBundleArgs<'a> { #[inline] @@ -96,7 +85,6 @@ impl<'a> Default for MessageBundleArgs<'a> { MessageBundleArgs { data_feed_msgs: None, rpc_msgs: None, - pub_sub_msgs: None, } } } @@ -115,10 +103,6 @@ impl<'a: 'b, 'b> MessageBundleBuilder<'a, 'b> { self.fbb_.push_slot_always::>(MessageBundle::VT_RPC_MSGS, rpc_msgs); } #[inline] - pub fn add_pub_sub_msgs(&mut self, pub_sub_msgs: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(MessageBundle::VT_PUB_SUB_MSGS, pub_sub_msgs); - } - #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MessageBundleBuilder<'a, 'b> { let start = _fbb.start_table(); MessageBundleBuilder { @@ -138,7 +122,6 @@ impl core::fmt::Debug for MessageBundle<'_> { let mut ds = f.debug_struct("MessageBundle"); ds.field("data_feed_msgs", &self.data_feed_msgs()); ds.field("rpc_msgs", &self.rpc_msgs()); - ds.field("pub_sub_msgs", &self.pub_sub_msgs()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/key_values_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/key_values_generated.rs deleted file mode 100644 index f5d15e4a6..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/key_values_generated.rs +++ /dev/null @@ -1,125 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum KeyValuesOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct KeyValues<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for KeyValues<'a> { - type Inner = KeyValues<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> KeyValues<'a> { - pub const VT_KEYS: flatbuffers::VOffsetT = 4; - pub const VT_VALUES: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - KeyValues { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args KeyValuesArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = KeyValuesBuilder::new(_fbb); - if let Some(x) = args.values { builder.add_values(x); } - if let Some(x) = args.keys { builder.add_keys(x); } - builder.finish() - } - - - #[inline] - pub fn keys(&self) -> Option>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(KeyValues::VT_KEYS, None)} - } - #[inline] - pub fn values(&self) -> Option>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(KeyValues::VT_VALUES, None)} - } -} - -impl flatbuffers::Verifiable for KeyValues<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>>>("keys", Self::VT_KEYS, false)? - .visit_field::>>>("values", Self::VT_VALUES, false)? - .finish(); - Ok(()) - } -} -pub struct KeyValuesArgs<'a> { - pub keys: Option>>>, - pub values: Option>>>, -} -impl<'a> Default for KeyValuesArgs<'a> { - #[inline] - fn default() -> Self { - KeyValuesArgs { - keys: None, - values: None, - } - } -} - -pub struct KeyValuesBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> KeyValuesBuilder<'a, 'b> { - #[inline] - pub fn add_keys(&mut self, keys: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(KeyValues::VT_KEYS, keys); - } - #[inline] - pub fn add_values(&mut self, values: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(KeyValues::VT_VALUES, values); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeyValuesBuilder<'a, 'b> { - let start = _fbb.start_table(); - KeyValuesBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for KeyValues<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("KeyValues"); - ds.field("keys", &self.keys()); - ds.field("values", &self.values()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/message_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/message_generated.rs deleted file mode 100644 index 24af74f5e..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/message_generated.rs +++ /dev/null @@ -1,291 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum MessageOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Data that is sent from publishers to subscribers -pub struct Message<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for Message<'a> { - type Inner = Message<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> Message<'a> { - pub const VT_TOPIC_TYPE: flatbuffers::VOffsetT = 4; - pub const VT_TOPIC: flatbuffers::VOffsetT = 6; - pub const VT_PAYLOAD_TYPE: flatbuffers::VOffsetT = 8; - pub const VT_PAYLOAD: flatbuffers::VOffsetT = 10; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - Message { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args MessageArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = MessageBuilder::new(_fbb); - if let Some(x) = args.payload { builder.add_payload(x); } - if let Some(x) = args.topic { builder.add_topic(x); } - builder.add_payload_type(args.payload_type); - builder.add_topic_type(args.topic_type); - builder.finish() - } - - - #[inline] - pub fn topic_type(&self) -> Topic { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Message::VT_TOPIC_TYPE, Some(Topic::NONE)).unwrap()} - } - #[inline] - pub fn topic(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>(Message::VT_TOPIC, None)} - } - #[inline] - pub fn payload_type(&self) -> Payload { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(Message::VT_PAYLOAD_TYPE, Some(Payload::NONE)).unwrap()} - } - #[inline] - pub fn payload(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>(Message::VT_PAYLOAD, None)} - } - #[inline] - #[allow(non_snake_case)] - pub fn topic_as_topic_handle(&self) -> Option> { - if self.topic_type() == Topic::TopicHandle { - self.topic().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicHandle::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn topic_as_topic_id(&self) -> Option> { - if self.topic_type() == Topic::TopicId { - self.topic().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicId::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn payload_as_solarxr_protocol_datatypes_string_table(&self) -> Option> { - if self.payload_type() == Payload::solarxr_protocol_datatypes_StringTable { - self.payload().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::datatypes::StringTable::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn payload_as_solarxr_protocol_datatypes_bytes(&self) -> Option> { - if self.payload_type() == Payload::solarxr_protocol_datatypes_Bytes { - self.payload().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { super::datatypes::Bytes::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn payload_as_key_values(&self) -> Option> { - if self.payload_type() == Payload::KeyValues { - self.payload().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { KeyValues::init_from_table(t) } - }) - } else { - None - } - } - -} - -impl flatbuffers::Verifiable for Message<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_union::("topic_type", Self::VT_TOPIC_TYPE, "topic", Self::VT_TOPIC, false, |key, v, pos| { - match key { - Topic::TopicHandle => v.verify_union_variant::>("Topic::TopicHandle", pos), - Topic::TopicId => v.verify_union_variant::>("Topic::TopicId", pos), - _ => Ok(()), - } - })? - .visit_union::("payload_type", Self::VT_PAYLOAD_TYPE, "payload", Self::VT_PAYLOAD, false, |key, v, pos| { - match key { - Payload::solarxr_protocol_datatypes_StringTable => v.verify_union_variant::>("Payload::solarxr_protocol_datatypes_StringTable", pos), - Payload::solarxr_protocol_datatypes_Bytes => v.verify_union_variant::>("Payload::solarxr_protocol_datatypes_Bytes", pos), - Payload::KeyValues => v.verify_union_variant::>("Payload::KeyValues", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } -} -pub struct MessageArgs { - pub topic_type: Topic, - pub topic: Option>, - pub payload_type: Payload, - pub payload: Option>, -} -impl<'a> Default for MessageArgs { - #[inline] - fn default() -> Self { - MessageArgs { - topic_type: Topic::NONE, - topic: None, - payload_type: Payload::NONE, - payload: None, - } - } -} - -pub struct MessageBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> MessageBuilder<'a, 'b> { - #[inline] - pub fn add_topic_type(&mut self, topic_type: Topic) { - self.fbb_.push_slot::(Message::VT_TOPIC_TYPE, topic_type, Topic::NONE); - } - #[inline] - pub fn add_topic(&mut self, topic: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(Message::VT_TOPIC, topic); - } - #[inline] - pub fn add_payload_type(&mut self, payload_type: Payload) { - self.fbb_.push_slot::(Message::VT_PAYLOAD_TYPE, payload_type, Payload::NONE); - } - #[inline] - pub fn add_payload(&mut self, payload: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(Message::VT_PAYLOAD, payload); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MessageBuilder<'a, 'b> { - let start = _fbb.start_table(); - MessageBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for Message<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("Message"); - ds.field("topic_type", &self.topic_type()); - match self.topic_type() { - Topic::TopicHandle => { - if let Some(x) = self.topic_as_topic_handle() { - ds.field("topic", &x) - } else { - ds.field("topic", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - Topic::TopicId => { - if let Some(x) = self.topic_as_topic_id() { - ds.field("topic", &x) - } else { - ds.field("topic", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("topic", &x) - }, - }; - ds.field("payload_type", &self.payload_type()); - match self.payload_type() { - Payload::solarxr_protocol_datatypes_StringTable => { - if let Some(x) = self.payload_as_solarxr_protocol_datatypes_string_table() { - ds.field("payload", &x) - } else { - ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - Payload::solarxr_protocol_datatypes_Bytes => { - if let Some(x) = self.payload_as_solarxr_protocol_datatypes_bytes() { - ds.field("payload", &x) - } else { - ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - Payload::KeyValues => { - if let Some(x) = self.payload_as_key_values() { - ds.field("payload", &x) - } else { - ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("payload", &x) - }, - }; - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_header_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_header_generated.rs deleted file mode 100644 index aa4184319..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_header_generated.rs +++ /dev/null @@ -1,225 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum PubSubHeaderOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct PubSubHeader<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for PubSubHeader<'a> { - type Inner = PubSubHeader<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> PubSubHeader<'a> { - pub const VT_U_TYPE: flatbuffers::VOffsetT = 4; - pub const VT_U: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - PubSubHeader { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args PubSubHeaderArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = PubSubHeaderBuilder::new(_fbb); - if let Some(x) = args.u { builder.add_u(x); } - builder.add_u_type(args.u_type); - builder.finish() - } - - - #[inline] - pub fn u_type(&self) -> PubSubUnion { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(PubSubHeader::VT_U_TYPE, Some(PubSubUnion::NONE)).unwrap()} - } - #[inline] - pub fn u(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>(PubSubHeader::VT_U, None)} - } - #[inline] - #[allow(non_snake_case)] - pub fn u_as_message(&self) -> Option> { - if self.u_type() == PubSubUnion::Message { - self.u().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { Message::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn u_as_subscription_request(&self) -> Option> { - if self.u_type() == PubSubUnion::SubscriptionRequest { - self.u().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { SubscriptionRequest::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn u_as_topic_handle_request(&self) -> Option> { - if self.u_type() == PubSubUnion::TopicHandleRequest { - self.u().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicHandleRequest::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn u_as_topic_mapping(&self) -> Option> { - if self.u_type() == PubSubUnion::TopicMapping { - self.u().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicMapping::init_from_table(t) } - }) - } else { - None - } - } - -} - -impl flatbuffers::Verifiable for PubSubHeader<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_union::("u_type", Self::VT_U_TYPE, "u", Self::VT_U, false, |key, v, pos| { - match key { - PubSubUnion::Message => v.verify_union_variant::>("PubSubUnion::Message", pos), - PubSubUnion::SubscriptionRequest => v.verify_union_variant::>("PubSubUnion::SubscriptionRequest", pos), - PubSubUnion::TopicHandleRequest => v.verify_union_variant::>("PubSubUnion::TopicHandleRequest", pos), - PubSubUnion::TopicMapping => v.verify_union_variant::>("PubSubUnion::TopicMapping", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } -} -pub struct PubSubHeaderArgs { - pub u_type: PubSubUnion, - pub u: Option>, -} -impl<'a> Default for PubSubHeaderArgs { - #[inline] - fn default() -> Self { - PubSubHeaderArgs { - u_type: PubSubUnion::NONE, - u: None, - } - } -} - -pub struct PubSubHeaderBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> PubSubHeaderBuilder<'a, 'b> { - #[inline] - pub fn add_u_type(&mut self, u_type: PubSubUnion) { - self.fbb_.push_slot::(PubSubHeader::VT_U_TYPE, u_type, PubSubUnion::NONE); - } - #[inline] - pub fn add_u(&mut self, u: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(PubSubHeader::VT_U, u); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> PubSubHeaderBuilder<'a, 'b> { - let start = _fbb.start_table(); - PubSubHeaderBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for PubSubHeader<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("PubSubHeader"); - ds.field("u_type", &self.u_type()); - match self.u_type() { - PubSubUnion::Message => { - if let Some(x) = self.u_as_message() { - ds.field("u", &x) - } else { - ds.field("u", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - PubSubUnion::SubscriptionRequest => { - if let Some(x) = self.u_as_subscription_request() { - ds.field("u", &x) - } else { - ds.field("u", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - PubSubUnion::TopicHandleRequest => { - if let Some(x) = self.u_as_topic_handle_request() { - ds.field("u", &x) - } else { - ds.field("u", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - PubSubUnion::TopicMapping => { - if let Some(x) = self.u_as_topic_mapping() { - ds.field("u", &x) - } else { - ds.field("u", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("u", &x) - }, - }; - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/subscription_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/subscription_request_generated.rs deleted file mode 100644 index 6ca3428fa..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/subscription_request_generated.rs +++ /dev/null @@ -1,180 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum SubscriptionRequestOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Requests a subscription to `topic`. Replies with a `TopicMapping`. -pub struct SubscriptionRequest<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for SubscriptionRequest<'a> { - type Inner = SubscriptionRequest<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> SubscriptionRequest<'a> { - pub const VT_TOPIC_TYPE: flatbuffers::VOffsetT = 4; - pub const VT_TOPIC: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SubscriptionRequest { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SubscriptionRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = SubscriptionRequestBuilder::new(_fbb); - if let Some(x) = args.topic { builder.add_topic(x); } - builder.add_topic_type(args.topic_type); - builder.finish() - } - - - #[inline] - pub fn topic_type(&self) -> Topic { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SubscriptionRequest::VT_TOPIC_TYPE, Some(Topic::NONE)).unwrap()} - } - #[inline] - pub fn topic(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>(SubscriptionRequest::VT_TOPIC, None)} - } - #[inline] - #[allow(non_snake_case)] - pub fn topic_as_topic_handle(&self) -> Option> { - if self.topic_type() == Topic::TopicHandle { - self.topic().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicHandle::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn topic_as_topic_id(&self) -> Option> { - if self.topic_type() == Topic::TopicId { - self.topic().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { TopicId::init_from_table(t) } - }) - } else { - None - } - } - -} - -impl flatbuffers::Verifiable for SubscriptionRequest<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_union::("topic_type", Self::VT_TOPIC_TYPE, "topic", Self::VT_TOPIC, false, |key, v, pos| { - match key { - Topic::TopicHandle => v.verify_union_variant::>("Topic::TopicHandle", pos), - Topic::TopicId => v.verify_union_variant::>("Topic::TopicId", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } -} -pub struct SubscriptionRequestArgs { - pub topic_type: Topic, - pub topic: Option>, -} -impl<'a> Default for SubscriptionRequestArgs { - #[inline] - fn default() -> Self { - SubscriptionRequestArgs { - topic_type: Topic::NONE, - topic: None, - } - } -} - -pub struct SubscriptionRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> SubscriptionRequestBuilder<'a, 'b> { - #[inline] - pub fn add_topic_type(&mut self, topic_type: Topic) { - self.fbb_.push_slot::(SubscriptionRequest::VT_TOPIC_TYPE, topic_type, Topic::NONE); - } - #[inline] - pub fn add_topic(&mut self, topic: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(SubscriptionRequest::VT_TOPIC, topic); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SubscriptionRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - SubscriptionRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for SubscriptionRequest<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SubscriptionRequest"); - ds.field("topic_type", &self.topic_type()); - match self.topic_type() { - Topic::TopicHandle => { - if let Some(x) = self.topic_as_topic_handle() { - ds.field("topic", &x) - } else { - ds.field("topic", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - Topic::TopicId => { - if let Some(x) = self.topic_as_topic_id() { - ds.field("topic", &x) - } else { - ds.field("topic", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("topic", &x) - }, - }; - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_request_generated.rs deleted file mode 100644 index c9184a4f2..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_request_generated.rs +++ /dev/null @@ -1,110 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum TopicHandleRequestOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing -/// bandwidth, since `FeatureId` can be large. -pub struct TopicHandleRequest<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for TopicHandleRequest<'a> { - type Inner = TopicHandleRequest<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> TopicHandleRequest<'a> { - pub const VT_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TopicHandleRequest { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TopicHandleRequestArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = TopicHandleRequestBuilder::new(_fbb); - if let Some(x) = args.id { builder.add_id(x); } - builder.finish() - } - - - #[inline] - pub fn id(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicHandleRequest::VT_ID, None)} - } -} - -impl flatbuffers::Verifiable for TopicHandleRequest<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("id", Self::VT_ID, false)? - .finish(); - Ok(()) - } -} -pub struct TopicHandleRequestArgs<'a> { - pub id: Option>>, -} -impl<'a> Default for TopicHandleRequestArgs<'a> { - #[inline] - fn default() -> Self { - TopicHandleRequestArgs { - id: None, - } - } -} - -pub struct TopicHandleRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> TopicHandleRequestBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TopicHandleRequest::VT_ID, id); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TopicHandleRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - TopicHandleRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for TopicHandleRequest<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TopicHandleRequest"); - ds.field("id", &self.id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_id_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_id_generated.rs deleted file mode 100644 index 0220472a6..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_id_generated.rs +++ /dev/null @@ -1,153 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum TopicIdOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// A `TopicId` identifies an application-specific category of data. Because it -/// is application-specific, it is up to the application within the specified -/// organization to define its semantics/meaning. -/// -/// For example, "bob" may have an "overlay" app with a "settings" topic for controlling -/// the overlay visibility and other settings, as well as a "video feed" topic for -/// allowing other applications to display video data in a wrist mounted window in VR. -pub struct TopicId<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for TopicId<'a> { - type Inner = TopicId<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> TopicId<'a> { - pub const VT_ORGANIZATION: flatbuffers::VOffsetT = 4; - pub const VT_APP_NAME: flatbuffers::VOffsetT = 6; - pub const VT_TOPIC: flatbuffers::VOffsetT = 8; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TopicId { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TopicIdArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = TopicIdBuilder::new(_fbb); - if let Some(x) = args.topic { builder.add_topic(x); } - if let Some(x) = args.app_name { builder.add_app_name(x); } - if let Some(x) = args.organization { builder.add_organization(x); } - builder.finish() - } - - - /// The organization/developer that defines the meaning of this feature. Avoids name - /// clashes. Should be something unique - same idea as java package identifier. - #[inline] - pub fn organization(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicId::VT_ORGANIZATION, None)} - } - /// The name of the application/device. Should be unique within the organization. - #[inline] - pub fn app_name(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicId::VT_APP_NAME, None)} - } - /// The name of the topic. Should be unique within the application. - #[inline] - pub fn topic(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicId::VT_TOPIC, None)} - } -} - -impl flatbuffers::Verifiable for TopicId<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("organization", Self::VT_ORGANIZATION, false)? - .visit_field::>("app_name", Self::VT_APP_NAME, false)? - .visit_field::>("topic", Self::VT_TOPIC, false)? - .finish(); - Ok(()) - } -} -pub struct TopicIdArgs<'a> { - pub organization: Option>, - pub app_name: Option>, - pub topic: Option>, -} -impl<'a> Default for TopicIdArgs<'a> { - #[inline] - fn default() -> Self { - TopicIdArgs { - organization: None, - app_name: None, - topic: None, - } - } -} - -pub struct TopicIdBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> TopicIdBuilder<'a, 'b> { - #[inline] - pub fn add_organization(&mut self, organization: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(TopicId::VT_ORGANIZATION, organization); - } - #[inline] - pub fn add_app_name(&mut self, app_name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(TopicId::VT_APP_NAME, app_name); - } - #[inline] - pub fn add_topic(&mut self, topic: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(TopicId::VT_TOPIC, topic); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TopicIdBuilder<'a, 'b> { - let start = _fbb.start_table(); - TopicIdBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for TopicId<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TopicId"); - ds.field("organization", &self.organization()); - ds.field("app_name", &self.app_name()); - ds.field("topic", &self.topic()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_mapping_generated.rs b/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_mapping_generated.rs deleted file mode 100644 index 48a84930b..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_mapping_generated.rs +++ /dev/null @@ -1,126 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum TopicMappingOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Response for `TopicHandleRequest` or `SubscriptionRequest`. -pub struct TopicMapping<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for TopicMapping<'a> { - type Inner = TopicMapping<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> TopicMapping<'a> { - pub const VT_ID: flatbuffers::VOffsetT = 4; - pub const VT_HANDLE: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TopicMapping { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TopicMappingArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = TopicMappingBuilder::new(_fbb); - if let Some(x) = args.handle { builder.add_handle(x); } - if let Some(x) = args.id { builder.add_id(x); } - builder.finish() - } - - - #[inline] - pub fn id(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicMapping::VT_ID, None)} - } - #[inline] - pub fn handle(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(TopicMapping::VT_HANDLE, None)} - } -} - -impl flatbuffers::Verifiable for TopicMapping<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("id", Self::VT_ID, false)? - .visit_field::>("handle", Self::VT_HANDLE, false)? - .finish(); - Ok(()) - } -} -pub struct TopicMappingArgs<'a> { - pub id: Option>>, - pub handle: Option>>, -} -impl<'a> Default for TopicMappingArgs<'a> { - #[inline] - fn default() -> Self { - TopicMappingArgs { - id: None, - handle: None, - } - } -} - -pub struct TopicMappingBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> TopicMappingBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TopicMapping::VT_ID, id); - } - #[inline] - pub fn add_handle(&mut self, handle: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TopicMapping::VT_HANDLE, handle); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TopicMappingBuilder<'a, 'b> { - let start = _fbb.start_table(); - TopicMappingBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for TopicMapping<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TopicMapping"); - ds.field("id", &self.id()); - ds.field("handle", &self.handle()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/arms_mounting_reset_mode_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/arms_reset_mode_generated.rs similarity index 65% rename from protocol/rust/src/generated/solarxr_protocol/rpc/arms_mounting_reset_mode_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/arms_reset_mode_generated.rs index 694b1046e..1540ba60f 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/arms_mounting_reset_mode_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/arms_reset_mode_generated.rs @@ -10,52 +10,52 @@ use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MIN_ARMS_MOUNTING_RESET_MODE: u8 = 0; +pub const ENUM_MIN_ARMS_RESET_MODE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_ARMS_MOUNTING_RESET_MODE: u8 = 3; +pub const ENUM_MAX_ARMS_RESET_MODE: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_ARMS_MOUNTING_RESET_MODE: [ArmsMountingResetMode; 4] = [ - ArmsMountingResetMode::BACK, - ArmsMountingResetMode::FORWARD, - ArmsMountingResetMode::TPOSE_UP, - ArmsMountingResetMode::TPOSE_DOWN, +pub const ENUM_VALUES_ARMS_RESET_MODE: [ArmsResetMode; 4] = [ + ArmsResetMode::BACK, + ArmsResetMode::FORWARD, + ArmsResetMode::T_POSE_UP, + ArmsResetMode::T_POSE_DOWN, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -pub struct ArmsMountingResetMode(pub u8); +pub struct ArmsResetMode(pub u8); #[allow(non_upper_case_globals)] -impl ArmsMountingResetMode { - /// Upper arm going back and forearm going forward +impl ArmsResetMode { + /// Down to the sides for full. Upper arm going back and forearm going forward for mounting. pub const BACK: Self = Self(0); - /// Arms going forward + /// Down to the sides for full. Arms going forward for mounting. pub const FORWARD: Self = Self(1); - /// Arms going up to the sides into a tpose - pub const TPOSE_UP: Self = Self(2); - /// Arms going down to the sides from a tpose - pub const TPOSE_DOWN: Self = Self(3); + /// Down to the sides for full. T-pose for mounting. + pub const T_POSE_UP: Self = Self(2); + /// T-pose for full. Down to the sides for mounting. + pub const T_POSE_DOWN: Self = Self(3); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ Self::BACK, Self::FORWARD, - Self::TPOSE_UP, - Self::TPOSE_DOWN, + Self::T_POSE_UP, + Self::T_POSE_DOWN, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::BACK => Some("BACK"), Self::FORWARD => Some("FORWARD"), - Self::TPOSE_UP => Some("TPOSE_UP"), - Self::TPOSE_DOWN => Some("TPOSE_DOWN"), + Self::T_POSE_UP => Some("T_POSE_UP"), + Self::T_POSE_DOWN => Some("T_POSE_DOWN"), _ => None, } } } -impl core::fmt::Debug for ArmsMountingResetMode { +impl core::fmt::Debug for ArmsResetMode { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) @@ -64,7 +64,7 @@ impl core::fmt::Debug for ArmsMountingResetMode { } } } -impl<'a> flatbuffers::Follow<'a> for ArmsMountingResetMode { +impl<'a> flatbuffers::Follow<'a> for ArmsResetMode { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { @@ -73,15 +73,15 @@ impl<'a> flatbuffers::Follow<'a> for ArmsMountingResetMode { } } -impl flatbuffers::Push for ArmsMountingResetMode { - type Output = ArmsMountingResetMode; +impl flatbuffers::Push for ArmsResetMode { + type Output = ArmsResetMode; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { flatbuffers::emplace_scalar::(dst, self.0); } } -impl flatbuffers::EndianScalar for ArmsMountingResetMode { +impl flatbuffers::EndianScalar for ArmsResetMode { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -95,7 +95,7 @@ impl flatbuffers::EndianScalar for ArmsMountingResetMode { } } -impl<'a> flatbuffers::Verifiable for ArmsMountingResetMode { +impl<'a> flatbuffers::Verifiable for ArmsResetMode { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -105,4 +105,4 @@ impl<'a> flatbuffers::Verifiable for ArmsMountingResetMode { } } -impl flatbuffers::SimpleToVerifyInSlice for ArmsMountingResetMode {} +impl flatbuffers::SimpleToVerifyInSlice for ArmsResetMode {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/assign_tracker_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/assign_tracker_request_generated.rs index 603a99655..fa74a0650 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/assign_tracker_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/assign_tracker_request_generated.rs @@ -29,7 +29,6 @@ impl<'a> AssignTrackerRequest<'a> { pub const VT_BODY_POSITION: flatbuffers::VOffsetT = 6; pub const VT_MOUNTING_ORIENTATION: flatbuffers::VOffsetT = 8; pub const VT_DISPLAY_NAME: flatbuffers::VOffsetT = 10; - pub const VT_ALLOW_DRIFT_COMPENSATION: flatbuffers::VOffsetT = 12; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -43,19 +42,18 @@ impl<'a> AssignTrackerRequest<'a> { let mut builder = AssignTrackerRequestBuilder::new(_fbb); if let Some(x) = args.display_name { builder.add_display_name(x); } if let Some(x) = args.mounting_orientation { builder.add_mounting_orientation(x); } - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } - builder.add_allow_drift_compensation(args.allow_drift_compensation); + builder.add_tracker_id(args.tracker_id); builder.add_body_position(args.body_position); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(AssignTrackerRequest::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(AssignTrackerRequest::VT_TRACKER_ID, Some(0)).unwrap()} } #[inline] pub fn body_position(&self) -> super::datatypes::BodyPart { @@ -78,13 +76,6 @@ impl<'a> AssignTrackerRequest<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(AssignTrackerRequest::VT_DISPLAY_NAME, None)} } - #[inline] - pub fn allow_drift_compensation(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AssignTrackerRequest::VT_ALLOW_DRIFT_COMPENSATION, Some(false)).unwrap()} - } } impl flatbuffers::Verifiable for AssignTrackerRequest<'_> { @@ -94,31 +85,28 @@ impl flatbuffers::Verifiable for AssignTrackerRequest<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .visit_field::("body_position", Self::VT_BODY_POSITION, false)? .visit_field::("mounting_orientation", Self::VT_MOUNTING_ORIENTATION, false)? .visit_field::>("display_name", Self::VT_DISPLAY_NAME, false)? - .visit_field::("allow_drift_compensation", Self::VT_ALLOW_DRIFT_COMPENSATION, false)? .finish(); Ok(()) } } pub struct AssignTrackerRequestArgs<'a> { - pub tracker_id: Option>>, + pub tracker_id: u16, pub body_position: super::datatypes::BodyPart, pub mounting_orientation: Option<&'a super::datatypes::math::Quat>, pub display_name: Option>, - pub allow_drift_compensation: bool, } impl<'a> Default for AssignTrackerRequestArgs<'a> { #[inline] fn default() -> Self { AssignTrackerRequestArgs { - tracker_id: None, + tracker_id: 0, body_position: super::datatypes::BodyPart::NONE, mounting_orientation: None, display_name: None, - allow_drift_compensation: false, } } } @@ -129,8 +117,8 @@ pub struct AssignTrackerRequestBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> AssignTrackerRequestBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(AssignTrackerRequest::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(AssignTrackerRequest::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn add_body_position(&mut self, body_position: super::datatypes::BodyPart) { @@ -145,10 +133,6 @@ impl<'a: 'b, 'b> AssignTrackerRequestBuilder<'a, 'b> { self.fbb_.push_slot_always::>(AssignTrackerRequest::VT_DISPLAY_NAME, display_name); } #[inline] - pub fn add_allow_drift_compensation(&mut self, allow_drift_compensation: bool) { - self.fbb_.push_slot::(AssignTrackerRequest::VT_ALLOW_DRIFT_COMPENSATION, allow_drift_compensation, false); - } - #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AssignTrackerRequestBuilder<'a, 'b> { let start = _fbb.start_table(); AssignTrackerRequestBuilder { @@ -170,7 +154,6 @@ impl core::fmt::Debug for AssignTrackerRequest<'_> { ds.field("body_position", &self.body_position()); ds.field("mounting_orientation", &self.mounting_orientation()); ds.field("display_name", &self.display_name()); - ds.field("allow_drift_compensation", &self.allow_drift_compensation()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_status_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_status_response_generated.rs index d3d1cf3e3..7187701e7 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_status_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_status_response_generated.rs @@ -26,11 +26,11 @@ impl<'a> flatbuffers::Follow<'a> for AutoBoneProcessStatusResponse<'a> { impl<'a> AutoBoneProcessStatusResponse<'a> { pub const VT_PROCESS_TYPE: flatbuffers::VOffsetT = 4; - pub const VT_CURRENT: flatbuffers::VOffsetT = 8; - pub const VT_TOTAL: flatbuffers::VOffsetT = 10; - pub const VT_COMPLETED: flatbuffers::VOffsetT = 12; - pub const VT_SUCCESS: flatbuffers::VOffsetT = 14; - pub const VT_ETA: flatbuffers::VOffsetT = 16; + pub const VT_CURRENT: flatbuffers::VOffsetT = 6; + pub const VT_TOTAL: flatbuffers::VOffsetT = 8; + pub const VT_COMPLETED: flatbuffers::VOffsetT = 10; + pub const VT_SUCCESS: flatbuffers::VOffsetT = 12; + pub const VT_ETA: flatbuffers::VOffsetT = 14; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_type_generated.rs index 6e0a00021..256203f50 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_process_type_generated.rs @@ -12,15 +12,14 @@ use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_AUTO_BONE_PROCESS_TYPE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_AUTO_BONE_PROCESS_TYPE: u8 = 4; +pub const ENUM_MAX_AUTO_BONE_PROCESS_TYPE: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_AUTO_BONE_PROCESS_TYPE: [AutoBoneProcessType; 5] = [ +pub const ENUM_VALUES_AUTO_BONE_PROCESS_TYPE: [AutoBoneProcessType; 4] = [ AutoBoneProcessType::NONE, AutoBoneProcessType::RECORD, AutoBoneProcessType::SAVE, AutoBoneProcessType::PROCESS, - AutoBoneProcessType::APPLY, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -32,18 +31,14 @@ impl AutoBoneProcessType { pub const RECORD: Self = Self(1); pub const SAVE: Self = Self(2); pub const PROCESS: Self = Self(3); - /// @deprecated - /// Use AutoBoneApplyRequest instead - pub const APPLY: Self = Self(4); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 4; + pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::RECORD, Self::SAVE, Self::PROCESS, - Self::APPLY, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -52,7 +47,6 @@ impl AutoBoneProcessType { Self::RECORD => Some("RECORD"), Self::SAVE => Some("SAVE"), Self::PROCESS => Some("PROCESS"), - Self::APPLY => Some("APPLY"), _ => None, } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_settings_generated.rs deleted file mode 100644 index 52123cfbc..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/auto_bone_settings_generated.rs +++ /dev/null @@ -1,466 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum AutoBoneSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt -pub struct AutoBoneSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for AutoBoneSettings<'a> { - type Inner = AutoBoneSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> AutoBoneSettings<'a> { - pub const VT_CURSOR_INCREMENT: flatbuffers::VOffsetT = 4; - pub const VT_MIN_DATA_DISTANCE: flatbuffers::VOffsetT = 6; - pub const VT_MAX_DATA_DISTANCE: flatbuffers::VOffsetT = 8; - pub const VT_NUM_EPOCHS: flatbuffers::VOffsetT = 10; - pub const VT_PRINT_EVERY_NUM_EPOCHS: flatbuffers::VOffsetT = 12; - pub const VT_INITIAL_ADJUST_RATE: flatbuffers::VOffsetT = 14; - pub const VT_ADJUST_RATE_DECAY: flatbuffers::VOffsetT = 16; - pub const VT_SLIDE_ERROR_FACTOR: flatbuffers::VOffsetT = 18; - pub const VT_OFFSET_SLIDE_ERROR_FACTOR: flatbuffers::VOffsetT = 20; - pub const VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR: flatbuffers::VOffsetT = 22; - pub const VT_BODY_PROPORTION_ERROR_FACTOR: flatbuffers::VOffsetT = 24; - pub const VT_HEIGHT_ERROR_FACTOR: flatbuffers::VOffsetT = 26; - pub const VT_POSITION_ERROR_FACTOR: flatbuffers::VOffsetT = 28; - pub const VT_POSITION_OFFSET_ERROR_FACTOR: flatbuffers::VOffsetT = 30; - pub const VT_CALC_INIT_ERROR: flatbuffers::VOffsetT = 32; - pub const VT_RANDOMIZE_FRAME_ORDER: flatbuffers::VOffsetT = 34; - pub const VT_SCALE_EACH_STEP: flatbuffers::VOffsetT = 36; - pub const VT_SAMPLE_COUNT: flatbuffers::VOffsetT = 38; - pub const VT_SAMPLE_RATE_MS: flatbuffers::VOffsetT = 40; - pub const VT_SAVE_RECORDINGS: flatbuffers::VOffsetT = 42; - pub const VT_USE_SKELETON_HEIGHT: flatbuffers::VOffsetT = 44; - pub const VT_RAND_SEED: flatbuffers::VOffsetT = 46; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - AutoBoneSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args AutoBoneSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = AutoBoneSettingsBuilder::new(_fbb); - if let Some(x) = args.rand_seed { builder.add_rand_seed(x); } - if let Some(x) = args.sample_rate_ms { builder.add_sample_rate_ms(x); } - if let Some(x) = args.sample_count { builder.add_sample_count(x); } - if let Some(x) = args.position_offset_error_factor { builder.add_position_offset_error_factor(x); } - if let Some(x) = args.position_error_factor { builder.add_position_error_factor(x); } - if let Some(x) = args.height_error_factor { builder.add_height_error_factor(x); } - if let Some(x) = args.body_proportion_error_factor { builder.add_body_proportion_error_factor(x); } - if let Some(x) = args.foot_height_offset_error_factor { builder.add_foot_height_offset_error_factor(x); } - if let Some(x) = args.offset_slide_error_factor { builder.add_offset_slide_error_factor(x); } - if let Some(x) = args.slide_error_factor { builder.add_slide_error_factor(x); } - if let Some(x) = args.adjust_rate_decay { builder.add_adjust_rate_decay(x); } - if let Some(x) = args.initial_adjust_rate { builder.add_initial_adjust_rate(x); } - if let Some(x) = args.print_every_num_epochs { builder.add_print_every_num_epochs(x); } - if let Some(x) = args.num_epochs { builder.add_num_epochs(x); } - if let Some(x) = args.max_data_distance { builder.add_max_data_distance(x); } - if let Some(x) = args.min_data_distance { builder.add_min_data_distance(x); } - if let Some(x) = args.cursor_increment { builder.add_cursor_increment(x); } - if let Some(x) = args.use_skeleton_height { builder.add_use_skeleton_height(x); } - if let Some(x) = args.save_recordings { builder.add_save_recordings(x); } - if let Some(x) = args.scale_each_step { builder.add_scale_each_step(x); } - if let Some(x) = args.randomize_frame_order { builder.add_randomize_frame_order(x); } - if let Some(x) = args.calc_init_error { builder.add_calc_init_error(x); } - builder.finish() - } - - - #[inline] - pub fn cursor_increment(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_CURSOR_INCREMENT, None)} - } - #[inline] - pub fn min_data_distance(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_MIN_DATA_DISTANCE, None)} - } - #[inline] - pub fn max_data_distance(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_MAX_DATA_DISTANCE, None)} - } - #[inline] - pub fn num_epochs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_NUM_EPOCHS, None)} - } - #[inline] - pub fn print_every_num_epochs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_PRINT_EVERY_NUM_EPOCHS, None)} - } - #[inline] - pub fn initial_adjust_rate(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_INITIAL_ADJUST_RATE, None)} - } - #[inline] - pub fn adjust_rate_decay(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_ADJUST_RATE_DECAY, None)} - } - #[inline] - pub fn slide_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_SLIDE_ERROR_FACTOR, None)} - } - #[inline] - pub fn offset_slide_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_OFFSET_SLIDE_ERROR_FACTOR, None)} - } - #[inline] - pub fn foot_height_offset_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR, None)} - } - #[inline] - pub fn body_proportion_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_BODY_PROPORTION_ERROR_FACTOR, None)} - } - #[inline] - pub fn height_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_HEIGHT_ERROR_FACTOR, None)} - } - #[inline] - pub fn position_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_POSITION_ERROR_FACTOR, None)} - } - #[inline] - pub fn position_offset_error_factor(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_POSITION_OFFSET_ERROR_FACTOR, None)} - } - #[inline] - pub fn calc_init_error(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_CALC_INIT_ERROR, None)} - } - #[inline] - pub fn randomize_frame_order(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_RANDOMIZE_FRAME_ORDER, None)} - } - #[inline] - pub fn scale_each_step(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_SCALE_EACH_STEP, None)} - } - #[inline] - pub fn sample_count(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_SAMPLE_COUNT, None)} - } - #[inline] - pub fn sample_rate_ms(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_SAMPLE_RATE_MS, None)} - } - #[inline] - pub fn save_recordings(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_SAVE_RECORDINGS, None)} - } - #[inline] - pub fn use_skeleton_height(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_USE_SKELETON_HEIGHT, None)} - } - #[inline] - pub fn rand_seed(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(AutoBoneSettings::VT_RAND_SEED, None)} - } -} - -impl flatbuffers::Verifiable for AutoBoneSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("cursor_increment", Self::VT_CURSOR_INCREMENT, false)? - .visit_field::("min_data_distance", Self::VT_MIN_DATA_DISTANCE, false)? - .visit_field::("max_data_distance", Self::VT_MAX_DATA_DISTANCE, false)? - .visit_field::("num_epochs", Self::VT_NUM_EPOCHS, false)? - .visit_field::("print_every_num_epochs", Self::VT_PRINT_EVERY_NUM_EPOCHS, false)? - .visit_field::("initial_adjust_rate", Self::VT_INITIAL_ADJUST_RATE, false)? - .visit_field::("adjust_rate_decay", Self::VT_ADJUST_RATE_DECAY, false)? - .visit_field::("slide_error_factor", Self::VT_SLIDE_ERROR_FACTOR, false)? - .visit_field::("offset_slide_error_factor", Self::VT_OFFSET_SLIDE_ERROR_FACTOR, false)? - .visit_field::("foot_height_offset_error_factor", Self::VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR, false)? - .visit_field::("body_proportion_error_factor", Self::VT_BODY_PROPORTION_ERROR_FACTOR, false)? - .visit_field::("height_error_factor", Self::VT_HEIGHT_ERROR_FACTOR, false)? - .visit_field::("position_error_factor", Self::VT_POSITION_ERROR_FACTOR, false)? - .visit_field::("position_offset_error_factor", Self::VT_POSITION_OFFSET_ERROR_FACTOR, false)? - .visit_field::("calc_init_error", Self::VT_CALC_INIT_ERROR, false)? - .visit_field::("randomize_frame_order", Self::VT_RANDOMIZE_FRAME_ORDER, false)? - .visit_field::("scale_each_step", Self::VT_SCALE_EACH_STEP, false)? - .visit_field::("sample_count", Self::VT_SAMPLE_COUNT, false)? - .visit_field::("sample_rate_ms", Self::VT_SAMPLE_RATE_MS, false)? - .visit_field::("save_recordings", Self::VT_SAVE_RECORDINGS, false)? - .visit_field::("use_skeleton_height", Self::VT_USE_SKELETON_HEIGHT, false)? - .visit_field::("rand_seed", Self::VT_RAND_SEED, false)? - .finish(); - Ok(()) - } -} -pub struct AutoBoneSettingsArgs { - pub cursor_increment: Option, - pub min_data_distance: Option, - pub max_data_distance: Option, - pub num_epochs: Option, - pub print_every_num_epochs: Option, - pub initial_adjust_rate: Option, - pub adjust_rate_decay: Option, - pub slide_error_factor: Option, - pub offset_slide_error_factor: Option, - pub foot_height_offset_error_factor: Option, - pub body_proportion_error_factor: Option, - pub height_error_factor: Option, - pub position_error_factor: Option, - pub position_offset_error_factor: Option, - pub calc_init_error: Option, - pub randomize_frame_order: Option, - pub scale_each_step: Option, - pub sample_count: Option, - pub sample_rate_ms: Option, - pub save_recordings: Option, - pub use_skeleton_height: Option, - pub rand_seed: Option, -} -impl<'a> Default for AutoBoneSettingsArgs { - #[inline] - fn default() -> Self { - AutoBoneSettingsArgs { - cursor_increment: None, - min_data_distance: None, - max_data_distance: None, - num_epochs: None, - print_every_num_epochs: None, - initial_adjust_rate: None, - adjust_rate_decay: None, - slide_error_factor: None, - offset_slide_error_factor: None, - foot_height_offset_error_factor: None, - body_proportion_error_factor: None, - height_error_factor: None, - position_error_factor: None, - position_offset_error_factor: None, - calc_init_error: None, - randomize_frame_order: None, - scale_each_step: None, - sample_count: None, - sample_rate_ms: None, - save_recordings: None, - use_skeleton_height: None, - rand_seed: None, - } - } -} - -pub struct AutoBoneSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> AutoBoneSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_cursor_increment(&mut self, cursor_increment: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_CURSOR_INCREMENT, cursor_increment); - } - #[inline] - pub fn add_min_data_distance(&mut self, min_data_distance: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_MIN_DATA_DISTANCE, min_data_distance); - } - #[inline] - pub fn add_max_data_distance(&mut self, max_data_distance: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_MAX_DATA_DISTANCE, max_data_distance); - } - #[inline] - pub fn add_num_epochs(&mut self, num_epochs: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_NUM_EPOCHS, num_epochs); - } - #[inline] - pub fn add_print_every_num_epochs(&mut self, print_every_num_epochs: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_PRINT_EVERY_NUM_EPOCHS, print_every_num_epochs); - } - #[inline] - pub fn add_initial_adjust_rate(&mut self, initial_adjust_rate: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_INITIAL_ADJUST_RATE, initial_adjust_rate); - } - #[inline] - pub fn add_adjust_rate_decay(&mut self, adjust_rate_decay: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_ADJUST_RATE_DECAY, adjust_rate_decay); - } - #[inline] - pub fn add_slide_error_factor(&mut self, slide_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_SLIDE_ERROR_FACTOR, slide_error_factor); - } - #[inline] - pub fn add_offset_slide_error_factor(&mut self, offset_slide_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_OFFSET_SLIDE_ERROR_FACTOR, offset_slide_error_factor); - } - #[inline] - pub fn add_foot_height_offset_error_factor(&mut self, foot_height_offset_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_FOOT_HEIGHT_OFFSET_ERROR_FACTOR, foot_height_offset_error_factor); - } - #[inline] - pub fn add_body_proportion_error_factor(&mut self, body_proportion_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_BODY_PROPORTION_ERROR_FACTOR, body_proportion_error_factor); - } - #[inline] - pub fn add_height_error_factor(&mut self, height_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_HEIGHT_ERROR_FACTOR, height_error_factor); - } - #[inline] - pub fn add_position_error_factor(&mut self, position_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_POSITION_ERROR_FACTOR, position_error_factor); - } - #[inline] - pub fn add_position_offset_error_factor(&mut self, position_offset_error_factor: f32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_POSITION_OFFSET_ERROR_FACTOR, position_offset_error_factor); - } - #[inline] - pub fn add_calc_init_error(&mut self, calc_init_error: bool) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_CALC_INIT_ERROR, calc_init_error); - } - #[inline] - pub fn add_randomize_frame_order(&mut self, randomize_frame_order: bool) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_RANDOMIZE_FRAME_ORDER, randomize_frame_order); - } - #[inline] - pub fn add_scale_each_step(&mut self, scale_each_step: bool) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_SCALE_EACH_STEP, scale_each_step); - } - #[inline] - pub fn add_sample_count(&mut self, sample_count: i32) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_SAMPLE_COUNT, sample_count); - } - #[inline] - pub fn add_sample_rate_ms(&mut self, sample_rate_ms: i64) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_SAMPLE_RATE_MS, sample_rate_ms); - } - #[inline] - pub fn add_save_recordings(&mut self, save_recordings: bool) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_SAVE_RECORDINGS, save_recordings); - } - #[inline] - pub fn add_use_skeleton_height(&mut self, use_skeleton_height: bool) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_USE_SKELETON_HEIGHT, use_skeleton_height); - } - #[inline] - pub fn add_rand_seed(&mut self, rand_seed: i64) { - self.fbb_.push_slot_always::(AutoBoneSettings::VT_RAND_SEED, rand_seed); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AutoBoneSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - AutoBoneSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for AutoBoneSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("AutoBoneSettings"); - ds.field("cursor_increment", &self.cursor_increment()); - ds.field("min_data_distance", &self.min_data_distance()); - ds.field("max_data_distance", &self.max_data_distance()); - ds.field("num_epochs", &self.num_epochs()); - ds.field("print_every_num_epochs", &self.print_every_num_epochs()); - ds.field("initial_adjust_rate", &self.initial_adjust_rate()); - ds.field("adjust_rate_decay", &self.adjust_rate_decay()); - ds.field("slide_error_factor", &self.slide_error_factor()); - ds.field("offset_slide_error_factor", &self.offset_slide_error_factor()); - ds.field("foot_height_offset_error_factor", &self.foot_height_offset_error_factor()); - ds.field("body_proportion_error_factor", &self.body_proportion_error_factor()); - ds.field("height_error_factor", &self.height_error_factor()); - ds.field("position_error_factor", &self.position_error_factor()); - ds.field("position_offset_error_factor", &self.position_offset_error_factor()); - ds.field("calc_init_error", &self.calc_init_error()); - ds.field("randomize_frame_order", &self.randomize_frame_order()); - ds.field("scale_each_step", &self.scale_each_step()); - ds.field("sample_count", &self.sample_count()); - ds.field("sample_rate_ms", &self.sample_rate_ms()); - ds.field("save_recordings", &self.save_recordings()); - ds.field("use_skeleton_height", &self.use_skeleton_height()); - ds.field("rand_seed", &self.rand_seed()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_hidsettings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_hidsettings_request_generated.rs new file mode 100644 index 000000000..1386f535c --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_hidsettings_request_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeHIDSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeHIDSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeHIDSettingsRequest<'a> { + type Inner = ChangeHIDSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeHIDSettingsRequest<'a> { + pub const VT_TRACKERS_OVER_HID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeHIDSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeHIDSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeHIDSettingsRequestBuilder::new(_fbb); + builder.add_trackers_over_hid(args.trackers_over_hid); + builder.finish() + } + + + #[inline] + pub fn trackers_over_hid(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeHIDSettingsRequest::VT_TRACKERS_OVER_HID, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ChangeHIDSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("trackers_over_hid", Self::VT_TRACKERS_OVER_HID, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeHIDSettingsRequestArgs { + pub trackers_over_hid: bool, +} +impl<'a> Default for ChangeHIDSettingsRequestArgs { + #[inline] + fn default() -> Self { + ChangeHIDSettingsRequestArgs { + trackers_over_hid: false, + } + } +} + +pub struct ChangeHIDSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeHIDSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_trackers_over_hid(&mut self, trackers_over_hid: bool) { + self.fbb_.push_slot::(ChangeHIDSettingsRequest::VT_TRACKERS_OVER_HID, trackers_over_hid, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeHIDSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeHIDSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeHIDSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeHIDSettingsRequest"); + ds.field("trackers_over_hid", &self.trackers_over_hid()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_mag_toggle_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_mag_toggle_request_generated.rs index 3299ff1ad..3a024bd8c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/change_mag_toggle_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_mag_toggle_request_generated.rs @@ -36,21 +36,21 @@ impl<'a> ChangeMagToggleRequest<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ChangeMagToggleRequestArgs<'args> + args: &'args ChangeMagToggleRequestArgs ) -> flatbuffers::WIPOffset> { let mut builder = ChangeMagToggleRequestBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_tracker_id(args.tracker_id); builder.add_enable(args.enable); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeMagToggleRequest::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(ChangeMagToggleRequest::VT_TRACKER_ID, Some(0)).unwrap()} } #[inline] pub fn enable(&self) -> bool { @@ -68,21 +68,21 @@ impl flatbuffers::Verifiable for ChangeMagToggleRequest<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .visit_field::("enable", Self::VT_ENABLE, false)? .finish(); Ok(()) } } -pub struct ChangeMagToggleRequestArgs<'a> { - pub tracker_id: Option>>, +pub struct ChangeMagToggleRequestArgs { + pub tracker_id: u16, pub enable: bool, } -impl<'a> Default for ChangeMagToggleRequestArgs<'a> { +impl<'a> Default for ChangeMagToggleRequestArgs { #[inline] fn default() -> Self { ChangeMagToggleRequestArgs { - tracker_id: None, + tracker_id: 0, enable: false, } } @@ -94,8 +94,8 @@ pub struct ChangeMagToggleRequestBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> ChangeMagToggleRequestBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeMagToggleRequest::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(ChangeMagToggleRequest::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn add_enable(&mut self, enable: bool) { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_output_trackers_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_output_trackers_settings_request_generated.rs new file mode 100644 index 000000000..7f67ca24d --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_output_trackers_settings_request_generated.rs @@ -0,0 +1,142 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeOutputTrackersSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeOutputTrackersSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeOutputTrackersSettingsRequest<'a> { + type Inner = ChangeOutputTrackersSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeOutputTrackersSettingsRequest<'a> { + pub const VT_AUTOMATIC_TRACKER_TOGGLE: flatbuffers::VOffsetT = 4; + pub const VT_TRACKERS: flatbuffers::VOffsetT = 6; + pub const VT_SEND_DERIVED_VELOCITY: flatbuffers::VOffsetT = 8; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeOutputTrackersSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeOutputTrackersSettingsRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeOutputTrackersSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.trackers { builder.add_trackers(x); } + builder.add_send_derived_velocity(args.send_derived_velocity); + builder.add_automatic_tracker_toggle(args.automatic_tracker_toggle); + builder.finish() + } + + + #[inline] + pub fn automatic_tracker_toggle(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeOutputTrackersSettingsRequest::VT_AUTOMATIC_TRACKER_TOGGLE, Some(false)).unwrap()} + } + #[inline] + pub fn trackers(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(ChangeOutputTrackersSettingsRequest::VT_TRACKERS, None)} + } + #[inline] + pub fn send_derived_velocity(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeOutputTrackersSettingsRequest::VT_SEND_DERIVED_VELOCITY, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ChangeOutputTrackersSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("automatic_tracker_toggle", Self::VT_AUTOMATIC_TRACKER_TOGGLE, false)? + .visit_field::>>("trackers", Self::VT_TRACKERS, false)? + .visit_field::("send_derived_velocity", Self::VT_SEND_DERIVED_VELOCITY, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeOutputTrackersSettingsRequestArgs<'a> { + pub automatic_tracker_toggle: bool, + pub trackers: Option>>, + pub send_derived_velocity: bool, +} +impl<'a> Default for ChangeOutputTrackersSettingsRequestArgs<'a> { + #[inline] + fn default() -> Self { + ChangeOutputTrackersSettingsRequestArgs { + automatic_tracker_toggle: false, + trackers: None, + send_derived_velocity: false, + } + } +} + +pub struct ChangeOutputTrackersSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeOutputTrackersSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_automatic_tracker_toggle(&mut self, automatic_tracker_toggle: bool) { + self.fbb_.push_slot::(ChangeOutputTrackersSettingsRequest::VT_AUTOMATIC_TRACKER_TOGGLE, automatic_tracker_toggle, false); + } + #[inline] + pub fn add_trackers(&mut self, trackers: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeOutputTrackersSettingsRequest::VT_TRACKERS, trackers); + } + #[inline] + pub fn add_send_derived_velocity(&mut self, send_derived_velocity: bool) { + self.fbb_.push_slot::(ChangeOutputTrackersSettingsRequest::VT_SEND_DERIVED_VELOCITY, send_derived_velocity, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeOutputTrackersSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeOutputTrackersSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeOutputTrackersSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeOutputTrackersSettingsRequest"); + ds.field("automatic_tracker_toggle", &self.automatic_tracker_toggle()); + ds.field("trackers", &self.trackers()); + ds.field("send_derived_velocity", &self.send_derived_velocity()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_resets_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_resets_settings_request_generated.rs new file mode 100644 index 000000000..35f6774e7 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_resets_settings_request_generated.rs @@ -0,0 +1,177 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeResetsSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeResetsSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeResetsSettingsRequest<'a> { + type Inner = ChangeResetsSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeResetsSettingsRequest<'a> { + pub const VT_RESET_MOUNTING_FEET: flatbuffers::VOffsetT = 4; + pub const VT_ARMS_RESET_MODE: flatbuffers::VOffsetT = 6; + pub const VT_YAW_RESET_SMOOTH_TIME: flatbuffers::VOffsetT = 8; + pub const VT_SAVE_MOUNTING_RESET: flatbuffers::VOffsetT = 10; + pub const VT_RESET_HMD_PITCH: flatbuffers::VOffsetT = 12; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeResetsSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeResetsSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeResetsSettingsRequestBuilder::new(_fbb); + builder.add_yaw_reset_smooth_time(args.yaw_reset_smooth_time); + builder.add_reset_hmd_pitch(args.reset_hmd_pitch); + builder.add_save_mounting_reset(args.save_mounting_reset); + builder.add_arms_reset_mode(args.arms_reset_mode); + builder.add_reset_mounting_feet(args.reset_mounting_feet); + builder.finish() + } + + + /// Makes it so feet will be mounting reset when passing no BodyPart + #[inline] + pub fn reset_mounting_feet(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeResetsSettingsRequest::VT_RESET_MOUNTING_FEET, Some(false)).unwrap()} + } + #[inline] + pub fn arms_reset_mode(&self) -> ArmsResetMode { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeResetsSettingsRequest::VT_ARMS_RESET_MODE, Some(ArmsResetMode::BACK)).unwrap()} + } + #[inline] + pub fn yaw_reset_smooth_time(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeResetsSettingsRequest::VT_YAW_RESET_SMOOTH_TIME, Some(0.0)).unwrap()} + } + #[inline] + pub fn save_mounting_reset(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeResetsSettingsRequest::VT_SAVE_MOUNTING_RESET, Some(false)).unwrap()} + } + #[inline] + pub fn reset_hmd_pitch(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeResetsSettingsRequest::VT_RESET_HMD_PITCH, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ChangeResetsSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("reset_mounting_feet", Self::VT_RESET_MOUNTING_FEET, false)? + .visit_field::("arms_reset_mode", Self::VT_ARMS_RESET_MODE, false)? + .visit_field::("yaw_reset_smooth_time", Self::VT_YAW_RESET_SMOOTH_TIME, false)? + .visit_field::("save_mounting_reset", Self::VT_SAVE_MOUNTING_RESET, false)? + .visit_field::("reset_hmd_pitch", Self::VT_RESET_HMD_PITCH, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeResetsSettingsRequestArgs { + pub reset_mounting_feet: bool, + pub arms_reset_mode: ArmsResetMode, + pub yaw_reset_smooth_time: f32, + pub save_mounting_reset: bool, + pub reset_hmd_pitch: bool, +} +impl<'a> Default for ChangeResetsSettingsRequestArgs { + #[inline] + fn default() -> Self { + ChangeResetsSettingsRequestArgs { + reset_mounting_feet: false, + arms_reset_mode: ArmsResetMode::BACK, + yaw_reset_smooth_time: 0.0, + save_mounting_reset: false, + reset_hmd_pitch: false, + } + } +} + +pub struct ChangeResetsSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeResetsSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_reset_mounting_feet(&mut self, reset_mounting_feet: bool) { + self.fbb_.push_slot::(ChangeResetsSettingsRequest::VT_RESET_MOUNTING_FEET, reset_mounting_feet, false); + } + #[inline] + pub fn add_arms_reset_mode(&mut self, arms_reset_mode: ArmsResetMode) { + self.fbb_.push_slot::(ChangeResetsSettingsRequest::VT_ARMS_RESET_MODE, arms_reset_mode, ArmsResetMode::BACK); + } + #[inline] + pub fn add_yaw_reset_smooth_time(&mut self, yaw_reset_smooth_time: f32) { + self.fbb_.push_slot::(ChangeResetsSettingsRequest::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0); + } + #[inline] + pub fn add_save_mounting_reset(&mut self, save_mounting_reset: bool) { + self.fbb_.push_slot::(ChangeResetsSettingsRequest::VT_SAVE_MOUNTING_RESET, save_mounting_reset, false); + } + #[inline] + pub fn add_reset_hmd_pitch(&mut self, reset_hmd_pitch: bool) { + self.fbb_.push_slot::(ChangeResetsSettingsRequest::VT_RESET_HMD_PITCH, reset_hmd_pitch, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeResetsSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeResetsSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeResetsSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeResetsSettingsRequest"); + ds.field("reset_mounting_feet", &self.reset_mounting_feet()); + ds.field("arms_reset_mode", &self.arms_reset_mode()); + ds.field("yaw_reset_smooth_time", &self.yaw_reset_smooth_time()); + ds.field("save_mounting_reset", &self.save_mounting_reset()); + ds.field("reset_hmd_pitch", &self.reset_hmd_pitch()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_settings_request_generated.rs deleted file mode 100644 index 404e9a8f0..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/change_settings_request_generated.rs +++ /dev/null @@ -1,346 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum ChangeSettingsRequestOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct ChangeSettingsRequest<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for ChangeSettingsRequest<'a> { - type Inner = ChangeSettingsRequest<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> ChangeSettingsRequest<'a> { - pub const VT_STEAM_VR_TRACKERS: flatbuffers::VOffsetT = 4; - pub const VT_FILTERING: flatbuffers::VOffsetT = 6; - pub const VT_DRIFT_COMPENSATION: flatbuffers::VOffsetT = 8; - pub const VT_OSC_ROUTER: flatbuffers::VOffsetT = 10; - pub const VT_VRC_OSC: flatbuffers::VOffsetT = 12; - pub const VT_VMC_OSC: flatbuffers::VOffsetT = 14; - pub const VT_MODEL_SETTINGS: flatbuffers::VOffsetT = 16; - pub const VT_TAP_DETECTION_SETTINGS: flatbuffers::VOffsetT = 18; - pub const VT_AUTO_BONE_SETTINGS: flatbuffers::VOffsetT = 20; - pub const VT_RESETS_SETTINGS: flatbuffers::VOffsetT = 22; - pub const VT_STAY_ALIGNED: flatbuffers::VOffsetT = 24; - pub const VT_HID_SETTINGS: flatbuffers::VOffsetT = 26; - pub const VT_TIMEOUT: flatbuffers::VOffsetT = 28; - pub const VT_VELOCITY_SETTINGS: flatbuffers::VOffsetT = 30; - pub const VT_VRM: flatbuffers::VOffsetT = 32; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ChangeSettingsRequest { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ChangeSettingsRequestArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = ChangeSettingsRequestBuilder::new(_fbb); - if let Some(x) = args.vrm { builder.add_vrm(x); } - if let Some(x) = args.velocity_settings { builder.add_velocity_settings(x); } - if let Some(x) = args.timeout { builder.add_timeout(x); } - if let Some(x) = args.hid_settings { builder.add_hid_settings(x); } - if let Some(x) = args.stay_aligned { builder.add_stay_aligned(x); } - if let Some(x) = args.resets_settings { builder.add_resets_settings(x); } - if let Some(x) = args.auto_bone_settings { builder.add_auto_bone_settings(x); } - if let Some(x) = args.tap_detection_settings { builder.add_tap_detection_settings(x); } - if let Some(x) = args.model_settings { builder.add_model_settings(x); } - if let Some(x) = args.vmc_osc { builder.add_vmc_osc(x); } - if let Some(x) = args.vrc_osc { builder.add_vrc_osc(x); } - if let Some(x) = args.osc_router { builder.add_osc_router(x); } - if let Some(x) = args.drift_compensation { builder.add_drift_compensation(x); } - if let Some(x) = args.filtering { builder.add_filtering(x); } - if let Some(x) = args.steam_vr_trackers { builder.add_steam_vr_trackers(x); } - builder.finish() - } - - - #[inline] - pub fn steam_vr_trackers(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_STEAM_VR_TRACKERS, None)} - } - #[inline] - pub fn filtering(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_FILTERING, None)} - } - #[inline] - pub fn drift_compensation(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_DRIFT_COMPENSATION, None)} - } - #[inline] - pub fn osc_router(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_OSC_ROUTER, None)} - } - #[inline] - pub fn vrc_osc(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_VRC_OSC, None)} - } - #[inline] - pub fn vmc_osc(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_VMC_OSC, None)} - } - #[inline] - pub fn model_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_MODEL_SETTINGS, None)} - } - #[inline] - pub fn tap_detection_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_TAP_DETECTION_SETTINGS, None)} - } - #[inline] - pub fn auto_bone_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_AUTO_BONE_SETTINGS, None)} - } - #[inline] - pub fn resets_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_RESETS_SETTINGS, None)} - } - #[inline] - pub fn stay_aligned(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_STAY_ALIGNED, None)} - } - #[inline] - pub fn hid_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_HID_SETTINGS, None)} - } - #[inline] - pub fn timeout(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_TIMEOUT, None)} - } - #[inline] - pub fn velocity_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_VELOCITY_SETTINGS, None)} - } - #[inline] - pub fn vrm(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(ChangeSettingsRequest::VT_VRM, None)} - } -} - -impl flatbuffers::Verifiable for ChangeSettingsRequest<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("steam_vr_trackers", Self::VT_STEAM_VR_TRACKERS, false)? - .visit_field::>("filtering", Self::VT_FILTERING, false)? - .visit_field::>("drift_compensation", Self::VT_DRIFT_COMPENSATION, false)? - .visit_field::>("osc_router", Self::VT_OSC_ROUTER, false)? - .visit_field::>("vrc_osc", Self::VT_VRC_OSC, false)? - .visit_field::>("vmc_osc", Self::VT_VMC_OSC, false)? - .visit_field::>("model_settings", Self::VT_MODEL_SETTINGS, false)? - .visit_field::>("tap_detection_settings", Self::VT_TAP_DETECTION_SETTINGS, false)? - .visit_field::>("auto_bone_settings", Self::VT_AUTO_BONE_SETTINGS, false)? - .visit_field::>("resets_settings", Self::VT_RESETS_SETTINGS, false)? - .visit_field::>("stay_aligned", Self::VT_STAY_ALIGNED, false)? - .visit_field::>("hid_settings", Self::VT_HID_SETTINGS, false)? - .visit_field::>("timeout", Self::VT_TIMEOUT, false)? - .visit_field::>("velocity_settings", Self::VT_VELOCITY_SETTINGS, false)? - .visit_field::>("vrm", Self::VT_VRM, false)? - .finish(); - Ok(()) - } -} -pub struct ChangeSettingsRequestArgs<'a> { - pub steam_vr_trackers: Option>>, - pub filtering: Option>>, - pub drift_compensation: Option>>, - pub osc_router: Option>>, - pub vrc_osc: Option>>, - pub vmc_osc: Option>>, - pub model_settings: Option>>, - pub tap_detection_settings: Option>>, - pub auto_bone_settings: Option>>, - pub resets_settings: Option>>, - pub stay_aligned: Option>>, - pub hid_settings: Option>>, - pub timeout: Option>>, - pub velocity_settings: Option>>, - pub vrm: Option>>, -} -impl<'a> Default for ChangeSettingsRequestArgs<'a> { - #[inline] - fn default() -> Self { - ChangeSettingsRequestArgs { - steam_vr_trackers: None, - filtering: None, - drift_compensation: None, - osc_router: None, - vrc_osc: None, - vmc_osc: None, - model_settings: None, - tap_detection_settings: None, - auto_bone_settings: None, - resets_settings: None, - stay_aligned: None, - hid_settings: None, - timeout: None, - velocity_settings: None, - vrm: None, - } - } -} - -pub struct ChangeSettingsRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> ChangeSettingsRequestBuilder<'a, 'b> { - #[inline] - pub fn add_steam_vr_trackers(&mut self, steam_vr_trackers: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_STEAM_VR_TRACKERS, steam_vr_trackers); - } - #[inline] - pub fn add_filtering(&mut self, filtering: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_FILTERING, filtering); - } - #[inline] - pub fn add_drift_compensation(&mut self, drift_compensation: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_DRIFT_COMPENSATION, drift_compensation); - } - #[inline] - pub fn add_osc_router(&mut self, osc_router: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_OSC_ROUTER, osc_router); - } - #[inline] - pub fn add_vrc_osc(&mut self, vrc_osc: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_VRC_OSC, vrc_osc); - } - #[inline] - pub fn add_vmc_osc(&mut self, vmc_osc: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_VMC_OSC, vmc_osc); - } - #[inline] - pub fn add_model_settings(&mut self, model_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_MODEL_SETTINGS, model_settings); - } - #[inline] - pub fn add_tap_detection_settings(&mut self, tap_detection_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_TAP_DETECTION_SETTINGS, tap_detection_settings); - } - #[inline] - pub fn add_auto_bone_settings(&mut self, auto_bone_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_AUTO_BONE_SETTINGS, auto_bone_settings); - } - #[inline] - pub fn add_resets_settings(&mut self, resets_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_RESETS_SETTINGS, resets_settings); - } - #[inline] - pub fn add_stay_aligned(&mut self, stay_aligned: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_STAY_ALIGNED, stay_aligned); - } - #[inline] - pub fn add_hid_settings(&mut self, hid_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_HID_SETTINGS, hid_settings); - } - #[inline] - pub fn add_timeout(&mut self, timeout: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_TIMEOUT, timeout); - } - #[inline] - pub fn add_velocity_settings(&mut self, velocity_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_VELOCITY_SETTINGS, velocity_settings); - } - #[inline] - pub fn add_vrm(&mut self, vrm: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ChangeSettingsRequest::VT_VRM, vrm); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeSettingsRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - ChangeSettingsRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for ChangeSettingsRequest<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ChangeSettingsRequest"); - ds.field("steam_vr_trackers", &self.steam_vr_trackers()); - ds.field("filtering", &self.filtering()); - ds.field("drift_compensation", &self.drift_compensation()); - ds.field("osc_router", &self.osc_router()); - ds.field("vrc_osc", &self.vrc_osc()); - ds.field("vmc_osc", &self.vmc_osc()); - ds.field("model_settings", &self.model_settings()); - ds.field("tap_detection_settings", &self.tap_detection_settings()); - ds.field("auto_bone_settings", &self.auto_bone_settings()); - ds.field("resets_settings", &self.resets_settings()); - ds.field("stay_aligned", &self.stay_aligned()); - ds.field("hid_settings", &self.hid_settings()); - ds.field("timeout", &self.timeout()); - ds.field("velocity_settings", &self.velocity_settings()); - ds.field("vrm", &self.vrm()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_config_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_proportions_request_generated.rs similarity index 60% rename from protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_config_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_proportions_request_generated.rs index 1cbb7256f..5f4e6218a 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_config_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_proportions_request_generated.rs @@ -9,35 +9,35 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum ChangeSkeletonConfigRequestOffset {} +pub enum ChangeSkeletonProportionsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct ChangeSkeletonConfigRequest<'a> { +pub struct ChangeSkeletonProportionsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for ChangeSkeletonConfigRequest<'a> { - type Inner = ChangeSkeletonConfigRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for ChangeSkeletonProportionsRequest<'a> { + type Inner = ChangeSkeletonProportionsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> ChangeSkeletonConfigRequest<'a> { +impl<'a> ChangeSkeletonProportionsRequest<'a> { pub const VT_BONE: flatbuffers::VOffsetT = 4; pub const VT_VALUE: flatbuffers::VOffsetT = 6; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ChangeSkeletonConfigRequest { _tab: table } + ChangeSkeletonProportionsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ChangeSkeletonConfigRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = ChangeSkeletonConfigRequestBuilder::new(_fbb); + args: &'args ChangeSkeletonProportionsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeSkeletonProportionsRequestBuilder::new(_fbb); builder.add_value(args.value); builder.add_bone(args.bone); builder.finish() @@ -49,18 +49,18 @@ impl<'a> ChangeSkeletonConfigRequest<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ChangeSkeletonConfigRequest::VT_BONE, Some(SkeletonBone::NONE)).unwrap()} + unsafe { self._tab.get::(ChangeSkeletonProportionsRequest::VT_BONE, Some(SkeletonBone::NONE)).unwrap()} } #[inline] pub fn value(&self) -> f32 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ChangeSkeletonConfigRequest::VT_VALUE, Some(0.0)).unwrap()} + unsafe { self._tab.get::(ChangeSkeletonProportionsRequest::VT_VALUE, Some(0.0)).unwrap()} } } -impl flatbuffers::Verifiable for ChangeSkeletonConfigRequest<'_> { +impl flatbuffers::Verifiable for ChangeSkeletonProportionsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -73,51 +73,51 @@ impl flatbuffers::Verifiable for ChangeSkeletonConfigRequest<'_> { Ok(()) } } -pub struct ChangeSkeletonConfigRequestArgs { +pub struct ChangeSkeletonProportionsRequestArgs { pub bone: SkeletonBone, pub value: f32, } -impl<'a> Default for ChangeSkeletonConfigRequestArgs { +impl<'a> Default for ChangeSkeletonProportionsRequestArgs { #[inline] fn default() -> Self { - ChangeSkeletonConfigRequestArgs { + ChangeSkeletonProportionsRequestArgs { bone: SkeletonBone::NONE, value: 0.0, } } } -pub struct ChangeSkeletonConfigRequestBuilder<'a: 'b, 'b> { +pub struct ChangeSkeletonProportionsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> ChangeSkeletonConfigRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> ChangeSkeletonProportionsRequestBuilder<'a, 'b> { #[inline] pub fn add_bone(&mut self, bone: SkeletonBone) { - self.fbb_.push_slot::(ChangeSkeletonConfigRequest::VT_BONE, bone, SkeletonBone::NONE); + self.fbb_.push_slot::(ChangeSkeletonProportionsRequest::VT_BONE, bone, SkeletonBone::NONE); } #[inline] pub fn add_value(&mut self, value: f32) { - self.fbb_.push_slot::(ChangeSkeletonConfigRequest::VT_VALUE, value, 0.0); + self.fbb_.push_slot::(ChangeSkeletonProportionsRequest::VT_VALUE, value, 0.0); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeSkeletonConfigRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeSkeletonProportionsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - ChangeSkeletonConfigRequestBuilder { + ChangeSkeletonProportionsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for ChangeSkeletonConfigRequest<'_> { +impl core::fmt::Debug for ChangeSkeletonProportionsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ChangeSkeletonConfigRequest"); + let mut ds = f.debug_struct("ChangeSkeletonProportionsRequest"); ds.field("bone", &self.bone()); ds.field("value", &self.value()); ds.finish() diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_settings_request_generated.rs new file mode 100644 index 000000000..f8c56c332 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_skeleton_settings_request_generated.rs @@ -0,0 +1,159 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeSkeletonSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeSkeletonSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeSkeletonSettingsRequest<'a> { + type Inner = ChangeSkeletonSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeSkeletonSettingsRequest<'a> { + pub const VT_TOGGLES: flatbuffers::VOffsetT = 4; + pub const VT_RATIOS: flatbuffers::VOffsetT = 6; + pub const VT_FILTERING: flatbuffers::VOffsetT = 8; + pub const VT_SKELETON_HEIGHT: flatbuffers::VOffsetT = 10; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeSkeletonSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeSkeletonSettingsRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeSkeletonSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.skeleton_height { builder.add_skeleton_height(x); } + if let Some(x) = args.filtering { builder.add_filtering(x); } + if let Some(x) = args.ratios { builder.add_ratios(x); } + if let Some(x) = args.toggles { builder.add_toggles(x); } + builder.finish() + } + + + #[inline] + pub fn toggles(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeSkeletonSettingsRequest::VT_TOGGLES, None)} + } + #[inline] + pub fn ratios(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeSkeletonSettingsRequest::VT_RATIOS, None)} + } + #[inline] + pub fn filtering(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeSkeletonSettingsRequest::VT_FILTERING, None)} + } + #[inline] + pub fn skeleton_height(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeSkeletonSettingsRequest::VT_SKELETON_HEIGHT, None)} + } +} + +impl flatbuffers::Verifiable for ChangeSkeletonSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("toggles", Self::VT_TOGGLES, false)? + .visit_field::>("ratios", Self::VT_RATIOS, false)? + .visit_field::>("filtering", Self::VT_FILTERING, false)? + .visit_field::>("skeleton_height", Self::VT_SKELETON_HEIGHT, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeSkeletonSettingsRequestArgs<'a> { + pub toggles: Option>>, + pub ratios: Option>>, + pub filtering: Option>>, + pub skeleton_height: Option>>, +} +impl<'a> Default for ChangeSkeletonSettingsRequestArgs<'a> { + #[inline] + fn default() -> Self { + ChangeSkeletonSettingsRequestArgs { + toggles: None, + ratios: None, + filtering: None, + skeleton_height: None, + } + } +} + +pub struct ChangeSkeletonSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeSkeletonSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_toggles(&mut self, toggles: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeSkeletonSettingsRequest::VT_TOGGLES, toggles); + } + #[inline] + pub fn add_ratios(&mut self, ratios: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeSkeletonSettingsRequest::VT_RATIOS, ratios); + } + #[inline] + pub fn add_filtering(&mut self, filtering: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeSkeletonSettingsRequest::VT_FILTERING, filtering); + } + #[inline] + pub fn add_skeleton_height(&mut self, skeleton_height: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeSkeletonSettingsRequest::VT_SKELETON_HEIGHT, skeleton_height); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeSkeletonSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeSkeletonSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeSkeletonSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeSkeletonSettingsRequest"); + ds.field("toggles", &self.toggles()); + ds.field("ratios", &self.ratios()); + ds.field("filtering", &self.filtering()); + ds.field("skeleton_height", &self.skeleton_height()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_stay_aligned_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_stay_aligned_settings_request_generated.rs new file mode 100644 index 000000000..170585602 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_stay_aligned_settings_request_generated.rs @@ -0,0 +1,312 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeStayAlignedSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeStayAlignedSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeStayAlignedSettingsRequest<'a> { + type Inner = ChangeStayAlignedSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeStayAlignedSettingsRequest<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_STANDING_ENABLED: flatbuffers::VOffsetT = 6; + pub const VT_STANDING_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 8; + pub const VT_STANDING_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 10; + pub const VT_STANDING_FOOT_ANGLE: flatbuffers::VOffsetT = 12; + pub const VT_SITTING_ENABLED: flatbuffers::VOffsetT = 14; + pub const VT_SITTING_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 16; + pub const VT_SITTING_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 18; + pub const VT_SITTING_FOOT_ANGLE: flatbuffers::VOffsetT = 20; + pub const VT_FLAT_ENABLED: flatbuffers::VOffsetT = 22; + pub const VT_FLAT_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 24; + pub const VT_FLAT_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 26; + pub const VT_FLAT_FOOT_ANGLE: flatbuffers::VOffsetT = 28; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeStayAlignedSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeStayAlignedSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeStayAlignedSettingsRequestBuilder::new(_fbb); + builder.add_flat_foot_angle(args.flat_foot_angle); + builder.add_flat_lower_leg_angle(args.flat_lower_leg_angle); + builder.add_flat_upper_leg_angle(args.flat_upper_leg_angle); + builder.add_sitting_foot_angle(args.sitting_foot_angle); + builder.add_sitting_lower_leg_angle(args.sitting_lower_leg_angle); + builder.add_sitting_upper_leg_angle(args.sitting_upper_leg_angle); + builder.add_standing_foot_angle(args.standing_foot_angle); + builder.add_standing_lower_leg_angle(args.standing_lower_leg_angle); + builder.add_standing_upper_leg_angle(args.standing_upper_leg_angle); + builder.add_flat_enabled(args.flat_enabled); + builder.add_sitting_enabled(args.sitting_enabled); + builder.add_standing_enabled(args.standing_enabled); + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn standing_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_STANDING_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn standing_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_STANDING_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn standing_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_STANDING_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn standing_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_STANDING_FOOT_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_SITTING_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn sitting_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_SITTING_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_SITTING_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_SITTING_FOOT_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_FLAT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn flat_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_FLAT_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_FLAT_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeStayAlignedSettingsRequest::VT_FLAT_FOOT_ANGLE, Some(0.0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ChangeStayAlignedSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("standing_enabled", Self::VT_STANDING_ENABLED, false)? + .visit_field::("standing_upper_leg_angle", Self::VT_STANDING_UPPER_LEG_ANGLE, false)? + .visit_field::("standing_lower_leg_angle", Self::VT_STANDING_LOWER_LEG_ANGLE, false)? + .visit_field::("standing_foot_angle", Self::VT_STANDING_FOOT_ANGLE, false)? + .visit_field::("sitting_enabled", Self::VT_SITTING_ENABLED, false)? + .visit_field::("sitting_upper_leg_angle", Self::VT_SITTING_UPPER_LEG_ANGLE, false)? + .visit_field::("sitting_lower_leg_angle", Self::VT_SITTING_LOWER_LEG_ANGLE, false)? + .visit_field::("sitting_foot_angle", Self::VT_SITTING_FOOT_ANGLE, false)? + .visit_field::("flat_enabled", Self::VT_FLAT_ENABLED, false)? + .visit_field::("flat_upper_leg_angle", Self::VT_FLAT_UPPER_LEG_ANGLE, false)? + .visit_field::("flat_lower_leg_angle", Self::VT_FLAT_LOWER_LEG_ANGLE, false)? + .visit_field::("flat_foot_angle", Self::VT_FLAT_FOOT_ANGLE, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeStayAlignedSettingsRequestArgs { + pub enabled: bool, + pub standing_enabled: bool, + pub standing_upper_leg_angle: f32, + pub standing_lower_leg_angle: f32, + pub standing_foot_angle: f32, + pub sitting_enabled: bool, + pub sitting_upper_leg_angle: f32, + pub sitting_lower_leg_angle: f32, + pub sitting_foot_angle: f32, + pub flat_enabled: bool, + pub flat_upper_leg_angle: f32, + pub flat_lower_leg_angle: f32, + pub flat_foot_angle: f32, +} +impl<'a> Default for ChangeStayAlignedSettingsRequestArgs { + #[inline] + fn default() -> Self { + ChangeStayAlignedSettingsRequestArgs { + enabled: false, + standing_enabled: false, + standing_upper_leg_angle: 0.0, + standing_lower_leg_angle: 0.0, + standing_foot_angle: 0.0, + sitting_enabled: false, + sitting_upper_leg_angle: 0.0, + sitting_lower_leg_angle: 0.0, + sitting_foot_angle: 0.0, + flat_enabled: false, + flat_upper_leg_angle: 0.0, + flat_lower_leg_angle: 0.0, + flat_foot_angle: 0.0, + } + } +} + +pub struct ChangeStayAlignedSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeStayAlignedSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_standing_enabled(&mut self, standing_enabled: bool) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_STANDING_ENABLED, standing_enabled, false); + } + #[inline] + pub fn add_standing_upper_leg_angle(&mut self, standing_upper_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_STANDING_UPPER_LEG_ANGLE, standing_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_standing_lower_leg_angle(&mut self, standing_lower_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_STANDING_LOWER_LEG_ANGLE, standing_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_standing_foot_angle(&mut self, standing_foot_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_STANDING_FOOT_ANGLE, standing_foot_angle, 0.0); + } + #[inline] + pub fn add_sitting_enabled(&mut self, sitting_enabled: bool) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_SITTING_ENABLED, sitting_enabled, false); + } + #[inline] + pub fn add_sitting_upper_leg_angle(&mut self, sitting_upper_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_SITTING_UPPER_LEG_ANGLE, sitting_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_sitting_lower_leg_angle(&mut self, sitting_lower_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_SITTING_LOWER_LEG_ANGLE, sitting_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_sitting_foot_angle(&mut self, sitting_foot_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_SITTING_FOOT_ANGLE, sitting_foot_angle, 0.0); + } + #[inline] + pub fn add_flat_enabled(&mut self, flat_enabled: bool) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_FLAT_ENABLED, flat_enabled, false); + } + #[inline] + pub fn add_flat_upper_leg_angle(&mut self, flat_upper_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_FLAT_UPPER_LEG_ANGLE, flat_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_flat_lower_leg_angle(&mut self, flat_lower_leg_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_FLAT_LOWER_LEG_ANGLE, flat_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_flat_foot_angle(&mut self, flat_foot_angle: f32) { + self.fbb_.push_slot::(ChangeStayAlignedSettingsRequest::VT_FLAT_FOOT_ANGLE, flat_foot_angle, 0.0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeStayAlignedSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeStayAlignedSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeStayAlignedSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeStayAlignedSettingsRequest"); + ds.field("enabled", &self.enabled()); + ds.field("standing_enabled", &self.standing_enabled()); + ds.field("standing_upper_leg_angle", &self.standing_upper_leg_angle()); + ds.field("standing_lower_leg_angle", &self.standing_lower_leg_angle()); + ds.field("standing_foot_angle", &self.standing_foot_angle()); + ds.field("sitting_enabled", &self.sitting_enabled()); + ds.field("sitting_upper_leg_angle", &self.sitting_upper_leg_angle()); + ds.field("sitting_lower_leg_angle", &self.sitting_lower_leg_angle()); + ds.field("sitting_foot_angle", &self.sitting_foot_angle()); + ds.field("flat_enabled", &self.flat_enabled()); + ds.field("flat_upper_leg_angle", &self.flat_upper_leg_angle()); + ds.field("flat_lower_leg_angle", &self.flat_lower_leg_angle()); + ds.field("flat_foot_angle", &self.flat_foot_angle()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_tap_detection_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_tap_detection_settings_request_generated.rs new file mode 100644 index 000000000..7969cab6b --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_tap_detection_settings_request_generated.rs @@ -0,0 +1,312 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeTapDetectionSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeTapDetectionSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeTapDetectionSettingsRequest<'a> { + type Inner = ChangeTapDetectionSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeTapDetectionSettingsRequest<'a> { + pub const VT_FULL_RESET_DELAY: flatbuffers::VOffsetT = 4; + pub const VT_FULL_RESET_ENABLED: flatbuffers::VOffsetT = 6; + pub const VT_FULL_RESET_TAPS: flatbuffers::VOffsetT = 8; + pub const VT_YAW_RESET_DELAY: flatbuffers::VOffsetT = 10; + pub const VT_YAW_RESET_ENABLED: flatbuffers::VOffsetT = 12; + pub const VT_YAW_RESET_TAPS: flatbuffers::VOffsetT = 14; + pub const VT_MOUNTING_RESET_DELAY: flatbuffers::VOffsetT = 16; + pub const VT_MOUNTING_RESET_ENABLED: flatbuffers::VOffsetT = 18; + pub const VT_MOUNTING_RESET_TAPS: flatbuffers::VOffsetT = 20; + pub const VT_NUMBER_TRACKERS_OVER_THRESHOLD: flatbuffers::VOffsetT = 22; + pub const VT_YAW_RESET_TRACKER: flatbuffers::VOffsetT = 24; + pub const VT_FULL_RESET_TRACKER: flatbuffers::VOffsetT = 26; + pub const VT_MOUNTING_RESET_TRACKER: flatbuffers::VOffsetT = 28; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeTapDetectionSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeTapDetectionSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeTapDetectionSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.mounting_reset_delay { builder.add_mounting_reset_delay(x); } + if let Some(x) = args.yaw_reset_delay { builder.add_yaw_reset_delay(x); } + if let Some(x) = args.full_reset_delay { builder.add_full_reset_delay(x); } + if let Some(x) = args.mounting_reset_tracker { builder.add_mounting_reset_tracker(x); } + if let Some(x) = args.full_reset_tracker { builder.add_full_reset_tracker(x); } + if let Some(x) = args.yaw_reset_tracker { builder.add_yaw_reset_tracker(x); } + if let Some(x) = args.number_trackers_over_threshold { builder.add_number_trackers_over_threshold(x); } + if let Some(x) = args.mounting_reset_taps { builder.add_mounting_reset_taps(x); } + if let Some(x) = args.mounting_reset_enabled { builder.add_mounting_reset_enabled(x); } + if let Some(x) = args.yaw_reset_taps { builder.add_yaw_reset_taps(x); } + if let Some(x) = args.yaw_reset_enabled { builder.add_yaw_reset_enabled(x); } + if let Some(x) = args.full_reset_taps { builder.add_full_reset_taps(x); } + if let Some(x) = args.full_reset_enabled { builder.add_full_reset_enabled(x); } + builder.finish() + } + + + #[inline] + pub fn full_reset_delay(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_DELAY, None)} + } + #[inline] + pub fn full_reset_enabled(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_ENABLED, None)} + } + #[inline] + pub fn full_reset_taps(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TAPS, None)} + } + #[inline] + pub fn yaw_reset_delay(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_DELAY, None)} + } + #[inline] + pub fn yaw_reset_enabled(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_ENABLED, None)} + } + #[inline] + pub fn yaw_reset_taps(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TAPS, None)} + } + #[inline] + pub fn mounting_reset_delay(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_DELAY, None)} + } + #[inline] + pub fn mounting_reset_enabled(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_ENABLED, None)} + } + #[inline] + pub fn mounting_reset_taps(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TAPS, None)} + } + #[inline] + pub fn number_trackers_over_threshold(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_NUMBER_TRACKERS_OVER_THRESHOLD, None)} + } + #[inline] + pub fn yaw_reset_tracker(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TRACKER, None)} + } + #[inline] + pub fn full_reset_tracker(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TRACKER, None)} + } + #[inline] + pub fn mounting_reset_tracker(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TRACKER, None)} + } +} + +impl flatbuffers::Verifiable for ChangeTapDetectionSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("full_reset_delay", Self::VT_FULL_RESET_DELAY, false)? + .visit_field::("full_reset_enabled", Self::VT_FULL_RESET_ENABLED, false)? + .visit_field::("full_reset_taps", Self::VT_FULL_RESET_TAPS, false)? + .visit_field::("yaw_reset_delay", Self::VT_YAW_RESET_DELAY, false)? + .visit_field::("yaw_reset_enabled", Self::VT_YAW_RESET_ENABLED, false)? + .visit_field::("yaw_reset_taps", Self::VT_YAW_RESET_TAPS, false)? + .visit_field::("mounting_reset_delay", Self::VT_MOUNTING_RESET_DELAY, false)? + .visit_field::("mounting_reset_enabled", Self::VT_MOUNTING_RESET_ENABLED, false)? + .visit_field::("mounting_reset_taps", Self::VT_MOUNTING_RESET_TAPS, false)? + .visit_field::("number_trackers_over_threshold", Self::VT_NUMBER_TRACKERS_OVER_THRESHOLD, false)? + .visit_field::("yaw_reset_tracker", Self::VT_YAW_RESET_TRACKER, false)? + .visit_field::("full_reset_tracker", Self::VT_FULL_RESET_TRACKER, false)? + .visit_field::("mounting_reset_tracker", Self::VT_MOUNTING_RESET_TRACKER, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeTapDetectionSettingsRequestArgs { + pub full_reset_delay: Option, + pub full_reset_enabled: Option, + pub full_reset_taps: Option, + pub yaw_reset_delay: Option, + pub yaw_reset_enabled: Option, + pub yaw_reset_taps: Option, + pub mounting_reset_delay: Option, + pub mounting_reset_enabled: Option, + pub mounting_reset_taps: Option, + pub number_trackers_over_threshold: Option, + pub yaw_reset_tracker: Option, + pub full_reset_tracker: Option, + pub mounting_reset_tracker: Option, +} +impl<'a> Default for ChangeTapDetectionSettingsRequestArgs { + #[inline] + fn default() -> Self { + ChangeTapDetectionSettingsRequestArgs { + full_reset_delay: None, + full_reset_enabled: None, + full_reset_taps: None, + yaw_reset_delay: None, + yaw_reset_enabled: None, + yaw_reset_taps: None, + mounting_reset_delay: None, + mounting_reset_enabled: None, + mounting_reset_taps: None, + number_trackers_over_threshold: None, + yaw_reset_tracker: None, + full_reset_tracker: None, + mounting_reset_tracker: None, + } + } +} + +pub struct ChangeTapDetectionSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeTapDetectionSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_full_reset_delay(&mut self, full_reset_delay: f32) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_DELAY, full_reset_delay); + } + #[inline] + pub fn add_full_reset_enabled(&mut self, full_reset_enabled: bool) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_ENABLED, full_reset_enabled); + } + #[inline] + pub fn add_full_reset_taps(&mut self, full_reset_taps: u8) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TAPS, full_reset_taps); + } + #[inline] + pub fn add_yaw_reset_delay(&mut self, yaw_reset_delay: f32) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_DELAY, yaw_reset_delay); + } + #[inline] + pub fn add_yaw_reset_enabled(&mut self, yaw_reset_enabled: bool) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_ENABLED, yaw_reset_enabled); + } + #[inline] + pub fn add_yaw_reset_taps(&mut self, yaw_reset_taps: u8) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TAPS, yaw_reset_taps); + } + #[inline] + pub fn add_mounting_reset_delay(&mut self, mounting_reset_delay: f32) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); + } + #[inline] + pub fn add_mounting_reset_enabled(&mut self, mounting_reset_enabled: bool) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_ENABLED, mounting_reset_enabled); + } + #[inline] + pub fn add_mounting_reset_taps(&mut self, mounting_reset_taps: u8) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); + } + #[inline] + pub fn add_number_trackers_over_threshold(&mut self, number_trackers_over_threshold: u8) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); + } + #[inline] + pub fn add_yaw_reset_tracker(&mut self, yaw_reset_tracker: super::datatypes::BodyPart) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_YAW_RESET_TRACKER, yaw_reset_tracker); + } + #[inline] + pub fn add_full_reset_tracker(&mut self, full_reset_tracker: super::datatypes::BodyPart) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_FULL_RESET_TRACKER, full_reset_tracker); + } + #[inline] + pub fn add_mounting_reset_tracker(&mut self, mounting_reset_tracker: super::datatypes::BodyPart) { + self.fbb_.push_slot_always::(ChangeTapDetectionSettingsRequest::VT_MOUNTING_RESET_TRACKER, mounting_reset_tracker); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeTapDetectionSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeTapDetectionSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeTapDetectionSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeTapDetectionSettingsRequest"); + ds.field("full_reset_delay", &self.full_reset_delay()); + ds.field("full_reset_enabled", &self.full_reset_enabled()); + ds.field("full_reset_taps", &self.full_reset_taps()); + ds.field("yaw_reset_delay", &self.yaw_reset_delay()); + ds.field("yaw_reset_enabled", &self.yaw_reset_enabled()); + ds.field("yaw_reset_taps", &self.yaw_reset_taps()); + ds.field("mounting_reset_delay", &self.mounting_reset_delay()); + ds.field("mounting_reset_enabled", &self.mounting_reset_enabled()); + ds.field("mounting_reset_taps", &self.mounting_reset_taps()); + ds.field("number_trackers_over_threshold", &self.number_trackers_over_threshold()); + ds.field("yaw_reset_tracker", &self.yaw_reset_tracker()); + ds.field("full_reset_tracker", &self.full_reset_tracker()); + ds.field("mounting_reset_tracker", &self.mounting_reset_tracker()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_vmcoscsettings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vmcoscsettings_request_generated.rs new file mode 100644 index 000000000..97fcd4ac0 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vmcoscsettings_request_generated.rs @@ -0,0 +1,193 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeVMCOSCSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeVMCOSCSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeVMCOSCSettingsRequest<'a> { + type Inner = ChangeVMCOSCSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeVMCOSCSettingsRequest<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_PORT_IN: flatbuffers::VOffsetT = 6; + pub const VT_PORT_OUT: flatbuffers::VOffsetT = 8; + pub const VT_ADDRESS: flatbuffers::VOffsetT = 10; + pub const VT_ANCHOR_HIP: flatbuffers::VOffsetT = 12; + pub const VT_MIRROR_TRACKING: flatbuffers::VOffsetT = 14; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeVMCOSCSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeVMCOSCSettingsRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeVMCOSCSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.address { builder.add_address(x); } + builder.add_port_out(args.port_out); + builder.add_port_in(args.port_in); + builder.add_mirror_tracking(args.mirror_tracking); + builder.add_anchor_hip(args.anchor_hip); + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVMCOSCSettingsRequest::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn port_in(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVMCOSCSettingsRequest::VT_PORT_IN, Some(0)).unwrap()} + } + #[inline] + pub fn port_out(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVMCOSCSettingsRequest::VT_PORT_OUT, Some(0)).unwrap()} + } + #[inline] + pub fn address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeVMCOSCSettingsRequest::VT_ADDRESS, None)} + } + #[inline] + pub fn anchor_hip(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVMCOSCSettingsRequest::VT_ANCHOR_HIP, Some(false)).unwrap()} + } + #[inline] + pub fn mirror_tracking(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVMCOSCSettingsRequest::VT_MIRROR_TRACKING, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ChangeVMCOSCSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("port_in", Self::VT_PORT_IN, false)? + .visit_field::("port_out", Self::VT_PORT_OUT, false)? + .visit_field::>("address", Self::VT_ADDRESS, false)? + .visit_field::("anchor_hip", Self::VT_ANCHOR_HIP, false)? + .visit_field::("mirror_tracking", Self::VT_MIRROR_TRACKING, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeVMCOSCSettingsRequestArgs<'a> { + pub enabled: bool, + pub port_in: u16, + pub port_out: u16, + pub address: Option>, + pub anchor_hip: bool, + pub mirror_tracking: bool, +} +impl<'a> Default for ChangeVMCOSCSettingsRequestArgs<'a> { + #[inline] + fn default() -> Self { + ChangeVMCOSCSettingsRequestArgs { + enabled: false, + port_in: 0, + port_out: 0, + address: None, + anchor_hip: false, + mirror_tracking: false, + } + } +} + +pub struct ChangeVMCOSCSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeVMCOSCSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(ChangeVMCOSCSettingsRequest::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_port_in(&mut self, port_in: u16) { + self.fbb_.push_slot::(ChangeVMCOSCSettingsRequest::VT_PORT_IN, port_in, 0); + } + #[inline] + pub fn add_port_out(&mut self, port_out: u16) { + self.fbb_.push_slot::(ChangeVMCOSCSettingsRequest::VT_PORT_OUT, port_out, 0); + } + #[inline] + pub fn add_address(&mut self, address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ChangeVMCOSCSettingsRequest::VT_ADDRESS, address); + } + #[inline] + pub fn add_anchor_hip(&mut self, anchor_hip: bool) { + self.fbb_.push_slot::(ChangeVMCOSCSettingsRequest::VT_ANCHOR_HIP, anchor_hip, false); + } + #[inline] + pub fn add_mirror_tracking(&mut self, mirror_tracking: bool) { + self.fbb_.push_slot::(ChangeVMCOSCSettingsRequest::VT_MIRROR_TRACKING, mirror_tracking, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeVMCOSCSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeVMCOSCSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeVMCOSCSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeVMCOSCSettingsRequest"); + ds.field("enabled", &self.enabled()); + ds.field("port_in", &self.port_in()); + ds.field("port_out", &self.port_out()); + ds.field("address", &self.address()); + ds.field("anchor_hip", &self.anchor_hip()); + ds.field("mirror_tracking", &self.mirror_tracking()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_vrcoscsettings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vrcoscsettings_request_generated.rs new file mode 100644 index 000000000..a99b974e0 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vrcoscsettings_request_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeVRCOSCSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeVRCOSCSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeVRCOSCSettingsRequest<'a> { + type Inner = ChangeVRCOSCSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeVRCOSCSettingsRequest<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_MANUAL_NETWORK: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeVRCOSCSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeVRCOSCSettingsRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeVRCOSCSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.manual_network { builder.add_manual_network(x); } + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ChangeVRCOSCSettingsRequest::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn manual_network(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ChangeVRCOSCSettingsRequest::VT_MANUAL_NETWORK, None)} + } +} + +impl flatbuffers::Verifiable for ChangeVRCOSCSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::>("manual_network", Self::VT_MANUAL_NETWORK, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeVRCOSCSettingsRequestArgs<'a> { + pub enabled: bool, + pub manual_network: Option>>, +} +impl<'a> Default for ChangeVRCOSCSettingsRequestArgs<'a> { + #[inline] + fn default() -> Self { + ChangeVRCOSCSettingsRequestArgs { + enabled: false, + manual_network: None, + } + } +} + +pub struct ChangeVRCOSCSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeVRCOSCSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(ChangeVRCOSCSettingsRequest::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_manual_network(&mut self, manual_network: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ChangeVRCOSCSettingsRequest::VT_MANUAL_NETWORK, manual_network); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeVRCOSCSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeVRCOSCSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for ChangeVRCOSCSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeVRCOSCSettingsRequest"); + ds.field("enabled", &self.enabled()); + ds.field("manual_network", &self.manual_network()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/string_table_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vrmsettings_request_generated.rs similarity index 51% rename from protocol/rust/src/generated/solarxr_protocol/datatypes/string_table_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/change_vrmsettings_request_generated.rs index 6c0d76e84..56ce070e8 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/string_table_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_vrmsettings_request_generated.rs @@ -9,100 +9,100 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum StringTableOffset {} +pub enum ChangeVRMSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct StringTable<'a> { +pub struct ChangeVRMSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for StringTable<'a> { - type Inner = StringTable<'a>; +impl<'a> flatbuffers::Follow<'a> for ChangeVRMSettingsRequest<'a> { + type Inner = ChangeVRMSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> StringTable<'a> { - pub const VT_S: flatbuffers::VOffsetT = 4; +impl<'a> ChangeVRMSettingsRequest<'a> { + pub const VT_VRM_JSON: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StringTable { _tab: table } + ChangeVRMSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StringTableArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StringTableBuilder::new(_fbb); - if let Some(x) = args.s { builder.add_s(x); } + args: &'args ChangeVRMSettingsRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeVRMSettingsRequestBuilder::new(_fbb); + if let Some(x) = args.vrm_json { builder.add_vrm_json(x); } builder.finish() } #[inline] - pub fn s(&self) -> Option<&'a str> { + pub fn vrm_json(&self) -> Option<&'a str> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(StringTable::VT_S, None)} + unsafe { self._tab.get::>(ChangeVRMSettingsRequest::VT_VRM_JSON, None)} } } -impl flatbuffers::Verifiable for StringTable<'_> { +impl flatbuffers::Verifiable for ChangeVRMSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("s", Self::VT_S, false)? + .visit_field::>("vrm_json", Self::VT_VRM_JSON, false)? .finish(); Ok(()) } } -pub struct StringTableArgs<'a> { - pub s: Option>, +pub struct ChangeVRMSettingsRequestArgs<'a> { + pub vrm_json: Option>, } -impl<'a> Default for StringTableArgs<'a> { +impl<'a> Default for ChangeVRMSettingsRequestArgs<'a> { #[inline] fn default() -> Self { - StringTableArgs { - s: None, + ChangeVRMSettingsRequestArgs { + vrm_json: None, } } } -pub struct StringTableBuilder<'a: 'b, 'b> { +pub struct ChangeVRMSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> StringTableBuilder<'a, 'b> { +impl<'a: 'b, 'b> ChangeVRMSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn add_s(&mut self, s: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(StringTable::VT_S, s); + pub fn add_vrm_json(&mut self, vrm_json: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ChangeVRMSettingsRequest::VT_VRM_JSON, vrm_json); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StringTableBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeVRMSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - StringTableBuilder { + ChangeVRMSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for StringTable<'_> { +impl core::fmt::Debug for ChangeVRMSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StringTable"); - ds.field("s", &self.s()); + let mut ds = f.debug_struct("ChangeVRMSettingsRequest"); + ds.field("vrm_json", &self.vrm_json()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/complete_stay_aligned_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/complete_stay_aligned_response_generated.rs new file mode 100644 index 000000000..884254682 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/complete_stay_aligned_response_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum CompleteStayAlignedResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct CompleteStayAlignedResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for CompleteStayAlignedResponse<'a> { + type Inner = CompleteStayAlignedResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> CompleteStayAlignedResponse<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + CompleteStayAlignedResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args CompleteStayAlignedResponseArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = CompleteStayAlignedResponseBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for CompleteStayAlignedResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct CompleteStayAlignedResponseArgs { +} +impl<'a> Default for CompleteStayAlignedResponseArgs { + #[inline] + fn default() -> Self { + CompleteStayAlignedResponseArgs { + } + } +} + +pub struct CompleteStayAlignedResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> CompleteStayAlignedResponseBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CompleteStayAlignedResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + CompleteStayAlignedResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for CompleteStayAlignedResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("CompleteStayAlignedResponse"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/computer_directory_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/computer_directory_generated.rs index 77e30ac3e..8126ecb4a 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/computer_directory_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/computer_directory_generated.rs @@ -16,7 +16,7 @@ pub const ENUM_MAX_COMPUTER_DIRECTORY: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_COMPUTER_DIRECTORY: [ComputerDirectory; 1] = [ - ComputerDirectory::Documents, + ComputerDirectory::DOCUMENTS, ]; /// Common folders often used in computers for storing files @@ -25,17 +25,17 @@ pub const ENUM_VALUES_COMPUTER_DIRECTORY: [ComputerDirectory; 1] = [ pub struct ComputerDirectory(pub u8); #[allow(non_upper_case_globals)] impl ComputerDirectory { - pub const Documents: Self = Self(0); + pub const DOCUMENTS: Self = Self(0); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 0; pub const ENUM_VALUES: &'static [Self] = &[ - Self::Documents, + Self::DOCUMENTS, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::Documents => Some("Documents"), + Self::DOCUMENTS => Some("DOCUMENTS"), _ => None, } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/drift_compensation_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/drift_compensation_settings_generated.rs deleted file mode 100644 index 3a5e1840a..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/drift_compensation_settings_generated.rs +++ /dev/null @@ -1,162 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum DriftCompensationSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Settings related to IMU yaw drift compensation -pub struct DriftCompensationSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for DriftCompensationSettings<'a> { - type Inner = DriftCompensationSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> DriftCompensationSettings<'a> { - pub const VT_ENABLED: flatbuffers::VOffsetT = 4; - pub const VT_PREDICTION: flatbuffers::VOffsetT = 6; - pub const VT_AMOUNT: flatbuffers::VOffsetT = 8; - pub const VT_MAX_RESETS: flatbuffers::VOffsetT = 10; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DriftCompensationSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DriftCompensationSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = DriftCompensationSettingsBuilder::new(_fbb); - builder.add_amount(args.amount); - builder.add_max_resets(args.max_resets); - builder.add_prediction(args.prediction); - builder.add_enabled(args.enabled); - builder.finish() - } - - - #[inline] - pub fn enabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(DriftCompensationSettings::VT_ENABLED, Some(false)).unwrap()} - } - #[inline] - pub fn prediction(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(DriftCompensationSettings::VT_PREDICTION, Some(false)).unwrap()} - } - /// 0 to 1. A higher value results in more yaw drift compensation - #[inline] - pub fn amount(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(DriftCompensationSettings::VT_AMOUNT, Some(0.0)).unwrap()} - } - /// Number of previous resets to take into account when calculating yaw drift - #[inline] - pub fn max_resets(&self) -> u16 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(DriftCompensationSettings::VT_MAX_RESETS, Some(0)).unwrap()} - } -} - -impl flatbuffers::Verifiable for DriftCompensationSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("enabled", Self::VT_ENABLED, false)? - .visit_field::("prediction", Self::VT_PREDICTION, false)? - .visit_field::("amount", Self::VT_AMOUNT, false)? - .visit_field::("max_resets", Self::VT_MAX_RESETS, false)? - .finish(); - Ok(()) - } -} -pub struct DriftCompensationSettingsArgs { - pub enabled: bool, - pub prediction: bool, - pub amount: f32, - pub max_resets: u16, -} -impl<'a> Default for DriftCompensationSettingsArgs { - #[inline] - fn default() -> Self { - DriftCompensationSettingsArgs { - enabled: false, - prediction: false, - amount: 0.0, - max_resets: 0, - } - } -} - -pub struct DriftCompensationSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> DriftCompensationSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_enabled(&mut self, enabled: bool) { - self.fbb_.push_slot::(DriftCompensationSettings::VT_ENABLED, enabled, false); - } - #[inline] - pub fn add_prediction(&mut self, prediction: bool) { - self.fbb_.push_slot::(DriftCompensationSettings::VT_PREDICTION, prediction, false); - } - #[inline] - pub fn add_amount(&mut self, amount: f32) { - self.fbb_.push_slot::(DriftCompensationSettings::VT_AMOUNT, amount, 0.0); - } - #[inline] - pub fn add_max_resets(&mut self, max_resets: u16) { - self.fbb_.push_slot::(DriftCompensationSettings::VT_MAX_RESETS, max_resets, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DriftCompensationSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - DriftCompensationSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for DriftCompensationSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("DriftCompensationSettings"); - ds.field("enabled", &self.enabled()); - ds.field("prediction", &self.prediction()); - ds.field("amount", &self.amount()); - ds.field("max_resets", &self.max_resets()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/filtering_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/filtering_type_generated.rs similarity index 98% rename from protocol/rust/src/generated/solarxr_protocol/datatypes/filtering_type_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/filtering_type_generated.rs index cebb78b0f..8f8b25d9a 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/filtering_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/filtering_type_generated.rs @@ -21,7 +21,6 @@ pub const ENUM_VALUES_FILTERING_TYPE: [FilteringType; 3] = [ FilteringType::PREDICTION, ]; -/// Used for filtering tracker rotations in software #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct FilteringType(pub u8); diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_device_id_table_generated.rs similarity index 63% rename from protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/firmware_device_id_table_generated.rs index e9e07f6fb..ea01afdb1 100644 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_handle_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_device_id_table_generated.rs @@ -9,36 +9,34 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum TopicHandleOffset {} +pub enum FirmwareDeviceIdTableOffset {} #[derive(Copy, Clone, PartialEq)] -/// A handle for the topic, allows referencing a topic without sending a huge -/// `TopicId`. -pub struct TopicHandle<'a> { +pub struct FirmwareDeviceIdTable<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for TopicHandle<'a> { - type Inner = TopicHandle<'a>; +impl<'a> flatbuffers::Follow<'a> for FirmwareDeviceIdTable<'a> { + type Inner = FirmwareDeviceIdTable<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> TopicHandle<'a> { +impl<'a> FirmwareDeviceIdTable<'a> { pub const VT_ID: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TopicHandle { _tab: table } + FirmwareDeviceIdTable { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TopicHandleArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = TopicHandleBuilder::new(_fbb); + args: &'args FirmwareDeviceIdTableArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = FirmwareDeviceIdTableBuilder::new(_fbb); builder.add_id(args.id); builder.finish() } @@ -49,11 +47,11 @@ impl<'a> TopicHandle<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TopicHandle::VT_ID, Some(0)).unwrap()} + unsafe { self._tab.get::(FirmwareDeviceIdTable::VT_ID, Some(0)).unwrap()} } } -impl flatbuffers::Verifiable for TopicHandle<'_> { +impl flatbuffers::Verifiable for FirmwareDeviceIdTable<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -65,45 +63,45 @@ impl flatbuffers::Verifiable for TopicHandle<'_> { Ok(()) } } -pub struct TopicHandleArgs { +pub struct FirmwareDeviceIdTableArgs { pub id: u16, } -impl<'a> Default for TopicHandleArgs { +impl<'a> Default for FirmwareDeviceIdTableArgs { #[inline] fn default() -> Self { - TopicHandleArgs { + FirmwareDeviceIdTableArgs { id: 0, } } } -pub struct TopicHandleBuilder<'a: 'b, 'b> { +pub struct FirmwareDeviceIdTableBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> TopicHandleBuilder<'a, 'b> { +impl<'a: 'b, 'b> FirmwareDeviceIdTableBuilder<'a, 'b> { #[inline] pub fn add_id(&mut self, id: u16) { - self.fbb_.push_slot::(TopicHandle::VT_ID, id, 0); + self.fbb_.push_slot::(FirmwareDeviceIdTable::VT_ID, id, 0); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TopicHandleBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FirmwareDeviceIdTableBuilder<'a, 'b> { let start = _fbb.start_table(); - TopicHandleBuilder { + FirmwareDeviceIdTableBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for TopicHandle<'_> { +impl core::fmt::Debug for FirmwareDeviceIdTable<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TopicHandle"); + let mut ds = f.debug_struct("FirmwareDeviceIdTable"); ds.field("id", &self.id()); ds.finish() } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_device_id_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_device_id_generated.rs index 28a68f79e..5dec910f2 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_device_id_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_device_id_generated.rs @@ -17,7 +17,7 @@ pub const ENUM_MAX_FIRMWARE_UPDATE_DEVICE_ID: u8 = 2; #[allow(non_camel_case_types)] pub const ENUM_VALUES_FIRMWARE_UPDATE_DEVICE_ID: [FirmwareUpdateDeviceId; 3] = [ FirmwareUpdateDeviceId::NONE, - FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable, + FirmwareUpdateDeviceId::FirmwareDeviceIdTable, FirmwareUpdateDeviceId::SerialDevicePort, ]; @@ -27,21 +27,21 @@ pub struct FirmwareUpdateDeviceId(pub u8); #[allow(non_upper_case_globals)] impl FirmwareUpdateDeviceId { pub const NONE: Self = Self(0); - pub const solarxr_protocol_datatypes_DeviceIdTable: Self = Self(1); + pub const FirmwareDeviceIdTable: Self = Self(1); pub const SerialDevicePort: Self = Self(2); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 2; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, - Self::solarxr_protocol_datatypes_DeviceIdTable, + Self::FirmwareDeviceIdTable, Self::SerialDevicePort, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::NONE => Some("NONE"), - Self::solarxr_protocol_datatypes_DeviceIdTable => Some("solarxr_protocol_datatypes_DeviceIdTable"), + Self::FirmwareDeviceIdTable => Some("FirmwareDeviceIdTable"), Self::SerialDevicePort => Some("SerialDevicePort"), _ => None, } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs index fedb4dbe6..d7024ac3f 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs @@ -55,6 +55,7 @@ impl FirmwareUpdateStatus { pub const REBOOTING: Self = Self(5); /// The server is provisioning the tracker pub const PROVISIONING: Self = Self(6); + /// The update process completed with success pub const DONE: Self = Self(7); /// Could not find the device pub const ERROR_DEVICE_NOT_FOUND: Self = Self(8); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_response_generated.rs index 64a60c7e4..dca5e0d27 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_response_generated.rs @@ -79,13 +79,13 @@ impl<'a> FirmwareUpdateStatusResponse<'a> { } #[inline] #[allow(non_snake_case)] - pub fn device_id_as_solarxr_protocol_datatypes_device_id_table(&self) -> Option> { - if self.device_id_type() == FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable { + pub fn device_id_as_firmware_device_id_table(&self) -> Option> { + if self.device_id_type() == FirmwareUpdateDeviceId::FirmwareDeviceIdTable { self.device_id().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { super::datatypes::DeviceIdTable::init_from_table(t) } + unsafe { FirmwareDeviceIdTable::init_from_table(t) } }) } else { None @@ -118,7 +118,7 @@ impl flatbuffers::Verifiable for FirmwareUpdateStatusResponse<'_> { v.visit_table(pos)? .visit_union::("device_id_type", Self::VT_DEVICE_ID_TYPE, "device_id", Self::VT_DEVICE_ID, false, |key, v, pos| { match key { - FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable => v.verify_union_variant::>("FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable", pos), + FirmwareUpdateDeviceId::FirmwareDeviceIdTable => v.verify_union_variant::>("FirmwareUpdateDeviceId::FirmwareDeviceIdTable", pos), FirmwareUpdateDeviceId::SerialDevicePort => v.verify_union_variant::>("FirmwareUpdateDeviceId::SerialDevicePort", pos), _ => Ok(()), } @@ -188,8 +188,8 @@ impl core::fmt::Debug for FirmwareUpdateStatusResponse<'_> { let mut ds = f.debug_struct("FirmwareUpdateStatusResponse"); ds.field("device_id_type", &self.device_id_type()); match self.device_id_type() { - FirmwareUpdateDeviceId::solarxr_protocol_datatypes_DeviceIdTable => { - if let Some(x) = self.device_id_as_solarxr_protocol_datatypes_device_id_table() { + FirmwareUpdateDeviceId::FirmwareDeviceIdTable => { + if let Some(x) = self.device_id_as_firmware_device_id_table() { ds.field("device_id", &x) } else { ds.field("device_id", &"InvalidFlatbuffer: Union discriminant does not match value.") diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/height_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/height_response_generated.rs deleted file mode 100644 index ff0c23a21..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/height_response_generated.rs +++ /dev/null @@ -1,126 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum HeightResponseOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Returns the current min and max positional tracker heights -pub struct HeightResponse<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for HeightResponse<'a> { - type Inner = HeightResponse<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> HeightResponse<'a> { - pub const VT_MIN_HEIGHT: flatbuffers::VOffsetT = 4; - pub const VT_MAX_HEIGHT: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HeightResponse { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HeightResponseArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = HeightResponseBuilder::new(_fbb); - builder.add_max_height(args.max_height); - builder.add_min_height(args.min_height); - builder.finish() - } - - - #[inline] - pub fn min_height(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(HeightResponse::VT_MIN_HEIGHT, Some(0.0)).unwrap()} - } - #[inline] - pub fn max_height(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(HeightResponse::VT_MAX_HEIGHT, Some(0.0)).unwrap()} - } -} - -impl flatbuffers::Verifiable for HeightResponse<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("min_height", Self::VT_MIN_HEIGHT, false)? - .visit_field::("max_height", Self::VT_MAX_HEIGHT, false)? - .finish(); - Ok(()) - } -} -pub struct HeightResponseArgs { - pub min_height: f32, - pub max_height: f32, -} -impl<'a> Default for HeightResponseArgs { - #[inline] - fn default() -> Self { - HeightResponseArgs { - min_height: 0.0, - max_height: 0.0, - } - } -} - -pub struct HeightResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> HeightResponseBuilder<'a, 'b> { - #[inline] - pub fn add_min_height(&mut self, min_height: f32) { - self.fbb_.push_slot::(HeightResponse::VT_MIN_HEIGHT, min_height, 0.0); - } - #[inline] - pub fn add_max_height(&mut self, max_height: f32) { - self.fbb_.push_slot::(HeightResponse::VT_MAX_HEIGHT, max_height, 0.0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HeightResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - HeightResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for HeightResponse<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("HeightResponse"); - ds.field("min_height", &self.min_height()); - ds.field("max_height", &self.max_height()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_generated.rs deleted file mode 100644 index 5e09e42f3..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_generated.rs +++ /dev/null @@ -1,108 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum HIDSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct HIDSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for HIDSettings<'a> { - type Inner = HIDSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> HIDSettings<'a> { - pub const VT_TRACKERSOVERHID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HIDSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HIDSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = HIDSettingsBuilder::new(_fbb); - builder.add_trackersOverHID(args.trackersOverHID); - builder.finish() - } - - - #[inline] - pub fn trackersOverHID(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(HIDSettings::VT_TRACKERSOVERHID, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for HIDSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("trackersOverHID", Self::VT_TRACKERSOVERHID, false)? - .finish(); - Ok(()) - } -} -pub struct HIDSettingsArgs { - pub trackersOverHID: bool, -} -impl<'a> Default for HIDSettingsArgs { - #[inline] - fn default() -> Self { - HIDSettingsArgs { - trackersOverHID: false, - } - } -} - -pub struct HIDSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> HIDSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_trackersOverHID(&mut self, trackersOverHID: bool) { - self.fbb_.push_slot::(HIDSettings::VT_TRACKERSOVERHID, trackersOverHID, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HIDSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - HIDSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for HIDSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("HIDSettings"); - ds.field("trackersOverHID", &self.trackersOverHID()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/height_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_request_generated.rs similarity index 62% rename from protocol/rust/src/generated/solarxr_protocol/rpc/height_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_request_generated.rs index 2679cab3e..fd3103936 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/height_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_request_generated.rs @@ -9,39 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum HeightRequestOffset {} +pub enum HIDSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct HeightRequest<'a> { +pub struct HIDSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for HeightRequest<'a> { - type Inner = HeightRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for HIDSettingsRequest<'a> { + type Inner = HIDSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> HeightRequest<'a> { +impl<'a> HIDSettingsRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HeightRequest { _tab: table } + HIDSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args HeightRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = HeightRequestBuilder::new(_fbb); + _args: &'args HIDSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = HIDSettingsRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for HeightRequest<'_> { +impl flatbuffers::Verifiable for HIDSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -52,39 +52,39 @@ impl flatbuffers::Verifiable for HeightRequest<'_> { Ok(()) } } -pub struct HeightRequestArgs { +pub struct HIDSettingsRequestArgs { } -impl<'a> Default for HeightRequestArgs { +impl<'a> Default for HIDSettingsRequestArgs { #[inline] fn default() -> Self { - HeightRequestArgs { + HIDSettingsRequestArgs { } } } -pub struct HeightRequestBuilder<'a: 'b, 'b> { +pub struct HIDSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> HeightRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> HIDSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HeightRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HIDSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - HeightRequestBuilder { + HIDSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for HeightRequest<'_> { +impl core::fmt::Debug for HIDSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("HeightRequest"); + let mut ds = f.debug_struct("HIDSettingsRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/datatypes/bytes_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_response_generated.rs similarity index 51% rename from protocol/rust/src/generated/solarxr_protocol/datatypes/bytes_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_response_generated.rs index e0ddb063e..c673f7531 100644 --- a/protocol/rust/src/generated/solarxr_protocol/datatypes/bytes_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/hidsettings_response_generated.rs @@ -9,100 +9,100 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum BytesOffset {} +pub enum HIDSettingsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct Bytes<'a> { +pub struct HIDSettingsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for Bytes<'a> { - type Inner = Bytes<'a>; +impl<'a> flatbuffers::Follow<'a> for HIDSettingsResponse<'a> { + type Inner = HIDSettingsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> Bytes<'a> { - pub const VT_B: flatbuffers::VOffsetT = 4; +impl<'a> HIDSettingsResponse<'a> { + pub const VT_TRACKERS_OVER_HID: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - Bytes { _tab: table } + HIDSettingsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args BytesArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = BytesBuilder::new(_fbb); - if let Some(x) = args.b { builder.add_b(x); } + args: &'args HIDSettingsResponseArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = HIDSettingsResponseBuilder::new(_fbb); + builder.add_trackers_over_hid(args.trackers_over_hid); builder.finish() } #[inline] - pub fn b(&self) -> Option> { + pub fn trackers_over_hid(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>(Bytes::VT_B, None)} + unsafe { self._tab.get::(HIDSettingsResponse::VT_TRACKERS_OVER_HID, Some(false)).unwrap()} } } -impl flatbuffers::Verifiable for Bytes<'_> { +impl flatbuffers::Verifiable for HIDSettingsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>>("b", Self::VT_B, false)? + .visit_field::("trackers_over_hid", Self::VT_TRACKERS_OVER_HID, false)? .finish(); Ok(()) } } -pub struct BytesArgs<'a> { - pub b: Option>>, +pub struct HIDSettingsResponseArgs { + pub trackers_over_hid: bool, } -impl<'a> Default for BytesArgs<'a> { +impl<'a> Default for HIDSettingsResponseArgs { #[inline] fn default() -> Self { - BytesArgs { - b: None, + HIDSettingsResponseArgs { + trackers_over_hid: false, } } } -pub struct BytesBuilder<'a: 'b, 'b> { +pub struct HIDSettingsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> BytesBuilder<'a, 'b> { +impl<'a: 'b, 'b> HIDSettingsResponseBuilder<'a, 'b> { #[inline] - pub fn add_b(&mut self, b: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(Bytes::VT_B, b); + pub fn add_trackers_over_hid(&mut self, trackers_over_hid: bool) { + self.fbb_.push_slot::(HIDSettingsResponse::VT_TRACKERS_OVER_HID, trackers_over_hid, false); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> BytesBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HIDSettingsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - BytesBuilder { + HIDSettingsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for Bytes<'_> { +impl core::fmt::Debug for HIDSettingsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("Bytes"); - ds.field("b", &self.b()); + let mut ds = f.debug_struct("HIDSettingsResponse"); + ds.field("trackers_over_hid", &self.trackers_over_hid()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/installed_info_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/installed_info_response_generated.rs index 7b4c20719..51bf38362 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/installed_info_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/installed_info_response_generated.rs @@ -25,8 +25,8 @@ impl<'a> flatbuffers::Follow<'a> for InstalledInfoResponse<'a> { } impl<'a> InstalledInfoResponse<'a> { - pub const VT_ISUDEVINSTALLED: flatbuffers::VOffsetT = 4; - pub const VT_ISWAYLAND: flatbuffers::VOffsetT = 6; + pub const VT_IS_UDEV_INSTALLED: flatbuffers::VOffsetT = 4; + pub const VT_IS_WAYLAND: flatbuffers::VOffsetT = 6; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -38,25 +38,25 @@ impl<'a> InstalledInfoResponse<'a> { args: &'args InstalledInfoResponseArgs ) -> flatbuffers::WIPOffset> { let mut builder = InstalledInfoResponseBuilder::new(_fbb); - builder.add_isWayland(args.isWayland); - builder.add_isUdevInstalled(args.isUdevInstalled); + builder.add_is_wayland(args.is_wayland); + builder.add_is_udev_installed(args.is_udev_installed); builder.finish() } #[inline] - pub fn isUdevInstalled(&self) -> bool { + pub fn is_udev_installed(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(InstalledInfoResponse::VT_ISUDEVINSTALLED, Some(false)).unwrap()} + unsafe { self._tab.get::(InstalledInfoResponse::VT_IS_UDEV_INSTALLED, Some(false)).unwrap()} } #[inline] - pub fn isWayland(&self) -> bool { + pub fn is_wayland(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(InstalledInfoResponse::VT_ISWAYLAND, Some(false)).unwrap()} + unsafe { self._tab.get::(InstalledInfoResponse::VT_IS_WAYLAND, Some(false)).unwrap()} } } @@ -67,22 +67,22 @@ impl flatbuffers::Verifiable for InstalledInfoResponse<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("isUdevInstalled", Self::VT_ISUDEVINSTALLED, false)? - .visit_field::("isWayland", Self::VT_ISWAYLAND, false)? + .visit_field::("is_udev_installed", Self::VT_IS_UDEV_INSTALLED, false)? + .visit_field::("is_wayland", Self::VT_IS_WAYLAND, false)? .finish(); Ok(()) } } pub struct InstalledInfoResponseArgs { - pub isUdevInstalled: bool, - pub isWayland: bool, + pub is_udev_installed: bool, + pub is_wayland: bool, } impl<'a> Default for InstalledInfoResponseArgs { #[inline] fn default() -> Self { InstalledInfoResponseArgs { - isUdevInstalled: false, - isWayland: false, + is_udev_installed: false, + is_wayland: false, } } } @@ -93,12 +93,12 @@ pub struct InstalledInfoResponseBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> InstalledInfoResponseBuilder<'a, 'b> { #[inline] - pub fn add_isUdevInstalled(&mut self, isUdevInstalled: bool) { - self.fbb_.push_slot::(InstalledInfoResponse::VT_ISUDEVINSTALLED, isUdevInstalled, false); + pub fn add_is_udev_installed(&mut self, is_udev_installed: bool) { + self.fbb_.push_slot::(InstalledInfoResponse::VT_IS_UDEV_INSTALLED, is_udev_installed, false); } #[inline] - pub fn add_isWayland(&mut self, isWayland: bool) { - self.fbb_.push_slot::(InstalledInfoResponse::VT_ISWAYLAND, isWayland, false); + pub fn add_is_wayland(&mut self, is_wayland: bool) { + self.fbb_.push_slot::(InstalledInfoResponse::VT_IS_WAYLAND, is_wayland, false); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> InstalledInfoResponseBuilder<'a, 'b> { @@ -118,8 +118,8 @@ impl<'a: 'b, 'b> InstalledInfoResponseBuilder<'a, 'b> { impl core::fmt::Debug for InstalledInfoResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("InstalledInfoResponse"); - ds.field("isUdevInstalled", &self.isUdevInstalled()); - ds.field("isWayland", &self.isWayland()); + ds.field("is_udev_installed", &self.is_udev_installed()); + ds.field("is_wayland", &self.is_wayland()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs index 777207a44..5c9f8653a 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs @@ -12,6 +12,7 @@ use super::*; pub enum KeybindRequestOffset {} #[derive(Copy, Clone, PartialEq)] +/// Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui pub struct KeybindRequest<'a> { pub _tab: flatbuffers::Table<'a>, } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs index 5a6caf374..76ab4f42e 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs @@ -12,6 +12,7 @@ use super::*; pub enum KeybindResponseOffset {} #[derive(Copy, Clone, PartialEq)] +/// Returns keybinds for displaying in gui pub struct KeybindResponse<'a> { pub _tab: flatbuffers::Table<'a>, } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_request_generated.rs index 2cd913fe2..4e42561e8 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_request_generated.rs @@ -35,20 +35,20 @@ impl<'a> MagToggleRequest<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args MagToggleRequestArgs<'args> + args: &'args MagToggleRequestArgs ) -> flatbuffers::WIPOffset> { let mut builder = MagToggleRequestBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_tracker_id(args.tracker_id); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(MagToggleRequest::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(MagToggleRequest::VT_TRACKER_ID, Some(0)).unwrap()} } } @@ -59,19 +59,19 @@ impl flatbuffers::Verifiable for MagToggleRequest<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .finish(); Ok(()) } } -pub struct MagToggleRequestArgs<'a> { - pub tracker_id: Option>>, +pub struct MagToggleRequestArgs { + pub tracker_id: u16, } -impl<'a> Default for MagToggleRequestArgs<'a> { +impl<'a> Default for MagToggleRequestArgs { #[inline] fn default() -> Self { MagToggleRequestArgs { - tracker_id: None, + tracker_id: 0, } } } @@ -82,8 +82,8 @@ pub struct MagToggleRequestBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> MagToggleRequestBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(MagToggleRequest::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(MagToggleRequest::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MagToggleRequestBuilder<'a, 'b> { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_response_generated.rs index 2cb5bfadf..a6e7b3124 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/mag_toggle_response_generated.rs @@ -36,21 +36,21 @@ impl<'a> MagToggleResponse<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args MagToggleResponseArgs<'args> + args: &'args MagToggleResponseArgs ) -> flatbuffers::WIPOffset> { let mut builder = MagToggleResponseBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_tracker_id(args.tracker_id); builder.add_enable(args.enable); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(MagToggleResponse::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(MagToggleResponse::VT_TRACKER_ID, Some(0)).unwrap()} } #[inline] pub fn enable(&self) -> bool { @@ -68,21 +68,21 @@ impl flatbuffers::Verifiable for MagToggleResponse<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .visit_field::("enable", Self::VT_ENABLE, false)? .finish(); Ok(()) } } -pub struct MagToggleResponseArgs<'a> { - pub tracker_id: Option>>, +pub struct MagToggleResponseArgs { + pub tracker_id: u16, pub enable: bool, } -impl<'a> Default for MagToggleResponseArgs<'a> { +impl<'a> Default for MagToggleResponseArgs { #[inline] fn default() -> Self { MagToggleResponseArgs { - tracker_id: None, + tracker_id: 0, enable: false, } } @@ -94,8 +94,8 @@ pub struct MagToggleResponseBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> MagToggleResponseBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(MagToggleResponse::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(MagToggleResponse::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn add_enable(&mut self, enable: bool) { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/oscrouter_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/oscrouter_settings_generated.rs deleted file mode 100644 index b21029c27..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/oscrouter_settings_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum OSCRouterSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. -pub struct OSCRouterSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for OSCRouterSettings<'a> { - type Inner = OSCRouterSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> OSCRouterSettings<'a> { - pub const VT_OSC_SETTINGS: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - OSCRouterSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args OSCRouterSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = OSCRouterSettingsBuilder::new(_fbb); - if let Some(x) = args.osc_settings { builder.add_osc_settings(x); } - builder.finish() - } - - - #[inline] - pub fn osc_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(OSCRouterSettings::VT_OSC_SETTINGS, None)} - } -} - -impl flatbuffers::Verifiable for OSCRouterSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("osc_settings", Self::VT_OSC_SETTINGS, false)? - .finish(); - Ok(()) - } -} -pub struct OSCRouterSettingsArgs<'a> { - pub osc_settings: Option>>, -} -impl<'a> Default for OSCRouterSettingsArgs<'a> { - #[inline] - fn default() -> Self { - OSCRouterSettingsArgs { - osc_settings: None, - } - } -} - -pub struct OSCRouterSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> OSCRouterSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_osc_settings(&mut self, osc_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(OSCRouterSettings::VT_OSC_SETTINGS, osc_settings); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OSCRouterSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - OSCRouterSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for OSCRouterSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("OSCRouterSettings"); - ds.field("osc_settings", &self.osc_settings()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/osctrackers_setting_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/osctrackers_setting_generated.rs deleted file mode 100644 index 21543dcc8..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/osctrackers_setting_generated.rs +++ /dev/null @@ -1,210 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum OSCTrackersSettingOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct OSCTrackersSetting<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for OSCTrackersSetting<'a> { - type Inner = OSCTrackersSetting<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> OSCTrackersSetting<'a> { - pub const VT_HEAD: flatbuffers::VOffsetT = 4; - pub const VT_CHEST: flatbuffers::VOffsetT = 6; - pub const VT_WAIST: flatbuffers::VOffsetT = 8; - pub const VT_KNEES: flatbuffers::VOffsetT = 10; - pub const VT_FEET: flatbuffers::VOffsetT = 12; - pub const VT_ELBOWS: flatbuffers::VOffsetT = 14; - pub const VT_HANDS: flatbuffers::VOffsetT = 16; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - OSCTrackersSetting { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args OSCTrackersSettingArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = OSCTrackersSettingBuilder::new(_fbb); - builder.add_hands(args.hands); - builder.add_elbows(args.elbows); - builder.add_feet(args.feet); - builder.add_knees(args.knees); - builder.add_waist(args.waist); - builder.add_chest(args.chest); - builder.add_head(args.head); - builder.finish() - } - - - #[inline] - pub fn head(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_HEAD, Some(false)).unwrap()} - } - #[inline] - pub fn chest(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_CHEST, Some(false)).unwrap()} - } - #[inline] - pub fn waist(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_WAIST, Some(false)).unwrap()} - } - #[inline] - pub fn knees(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_KNEES, Some(false)).unwrap()} - } - #[inline] - pub fn feet(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_FEET, Some(false)).unwrap()} - } - #[inline] - pub fn elbows(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_ELBOWS, Some(false)).unwrap()} - } - #[inline] - pub fn hands(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCTrackersSetting::VT_HANDS, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for OSCTrackersSetting<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("head", Self::VT_HEAD, false)? - .visit_field::("chest", Self::VT_CHEST, false)? - .visit_field::("waist", Self::VT_WAIST, false)? - .visit_field::("knees", Self::VT_KNEES, false)? - .visit_field::("feet", Self::VT_FEET, false)? - .visit_field::("elbows", Self::VT_ELBOWS, false)? - .visit_field::("hands", Self::VT_HANDS, false)? - .finish(); - Ok(()) - } -} -pub struct OSCTrackersSettingArgs { - pub head: bool, - pub chest: bool, - pub waist: bool, - pub knees: bool, - pub feet: bool, - pub elbows: bool, - pub hands: bool, -} -impl<'a> Default for OSCTrackersSettingArgs { - #[inline] - fn default() -> Self { - OSCTrackersSettingArgs { - head: false, - chest: false, - waist: false, - knees: false, - feet: false, - elbows: false, - hands: false, - } - } -} - -pub struct OSCTrackersSettingBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> OSCTrackersSettingBuilder<'a, 'b> { - #[inline] - pub fn add_head(&mut self, head: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_HEAD, head, false); - } - #[inline] - pub fn add_chest(&mut self, chest: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_CHEST, chest, false); - } - #[inline] - pub fn add_waist(&mut self, waist: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_WAIST, waist, false); - } - #[inline] - pub fn add_knees(&mut self, knees: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_KNEES, knees, false); - } - #[inline] - pub fn add_feet(&mut self, feet: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_FEET, feet, false); - } - #[inline] - pub fn add_elbows(&mut self, elbows: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_ELBOWS, elbows, false); - } - #[inline] - pub fn add_hands(&mut self, hands: bool) { - self.fbb_.push_slot::(OSCTrackersSetting::VT_HANDS, hands, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OSCTrackersSettingBuilder<'a, 'b> { - let start = _fbb.start_table(); - OSCTrackersSettingBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for OSCTrackersSetting<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("OSCTrackersSetting"); - ds.field("head", &self.head()); - ds.field("chest", &self.chest()); - ds.field("waist", &self.waist()); - ds.field("knees", &self.knees()); - ds.field("feet", &self.feet()); - ds.field("elbows", &self.elbows()); - ds.field("hands", &self.hands()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/otafirmware_update_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/otafirmware_update_generated.rs index 31f16021c..354e4c5ce 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/otafirmware_update_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/otafirmware_update_generated.rs @@ -39,18 +39,18 @@ impl<'a> OTAFirmwareUpdate<'a> { ) -> flatbuffers::WIPOffset> { let mut builder = OTAFirmwareUpdateBuilder::new(_fbb); if let Some(x) = args.firmware_part { builder.add_firmware_part(x); } - if let Some(x) = args.device_id { builder.add_device_id(x); } + builder.add_device_id(args.device_id); builder.finish() } - /// id of the device, this refer to the actual DeviceId from the protocol + /// Id of the device #[inline] - pub fn device_id(&self) -> Option<&'a super::datatypes::DeviceId> { + pub fn device_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(OTAFirmwareUpdate::VT_DEVICE_ID, None)} + unsafe { self._tab.get::(OTAFirmwareUpdate::VT_DEVICE_ID, Some(0)).unwrap()} } /// A table containing the url and offset of the firmware bin file #[inline] @@ -69,21 +69,21 @@ impl flatbuffers::Verifiable for OTAFirmwareUpdate<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("device_id", Self::VT_DEVICE_ID, false)? + .visit_field::("device_id", Self::VT_DEVICE_ID, false)? .visit_field::>("firmware_part", Self::VT_FIRMWARE_PART, false)? .finish(); Ok(()) } } pub struct OTAFirmwareUpdateArgs<'a> { - pub device_id: Option<&'a super::datatypes::DeviceId>, + pub device_id: u16, pub firmware_part: Option>>, } impl<'a> Default for OTAFirmwareUpdateArgs<'a> { #[inline] fn default() -> Self { OTAFirmwareUpdateArgs { - device_id: None, + device_id: 0, firmware_part: None, } } @@ -95,8 +95,8 @@ pub struct OTAFirmwareUpdateBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> OTAFirmwareUpdateBuilder<'a, 'b> { #[inline] - pub fn add_device_id(&mut self, device_id: &super::datatypes::DeviceId) { - self.fbb_.push_slot_always::<&super::datatypes::DeviceId>(OTAFirmwareUpdate::VT_DEVICE_ID, device_id); + pub fn add_device_id(&mut self, device_id: u16) { + self.fbb_.push_slot::(OTAFirmwareUpdate::VT_DEVICE_ID, device_id, 0); } #[inline] pub fn add_firmware_part(&mut self, firmware_part: flatbuffers::WIPOffset>) { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/clear_drift_compensation_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_request_generated.rs similarity index 58% rename from protocol/rust/src/generated/solarxr_protocol/rpc/clear_drift_compensation_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_request_generated.rs index 9f0581306..4e8cfa836 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/clear_drift_compensation_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_request_generated.rs @@ -9,39 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum ClearDriftCompensationRequestOffset {} +pub enum OutputTrackersSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct ClearDriftCompensationRequest<'a> { +pub struct OutputTrackersSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for ClearDriftCompensationRequest<'a> { - type Inner = ClearDriftCompensationRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for OutputTrackersSettingsRequest<'a> { + type Inner = OutputTrackersSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> ClearDriftCompensationRequest<'a> { +impl<'a> OutputTrackersSettingsRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ClearDriftCompensationRequest { _tab: table } + OutputTrackersSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args ClearDriftCompensationRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = ClearDriftCompensationRequestBuilder::new(_fbb); + _args: &'args OutputTrackersSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = OutputTrackersSettingsRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for ClearDriftCompensationRequest<'_> { +impl flatbuffers::Verifiable for OutputTrackersSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -52,39 +52,39 @@ impl flatbuffers::Verifiable for ClearDriftCompensationRequest<'_> { Ok(()) } } -pub struct ClearDriftCompensationRequestArgs { +pub struct OutputTrackersSettingsRequestArgs { } -impl<'a> Default for ClearDriftCompensationRequestArgs { +impl<'a> Default for OutputTrackersSettingsRequestArgs { #[inline] fn default() -> Self { - ClearDriftCompensationRequestArgs { + OutputTrackersSettingsRequestArgs { } } } -pub struct ClearDriftCompensationRequestBuilder<'a: 'b, 'b> { +pub struct OutputTrackersSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> ClearDriftCompensationRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> OutputTrackersSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ClearDriftCompensationRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OutputTrackersSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - ClearDriftCompensationRequestBuilder { + OutputTrackersSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for ClearDriftCompensationRequest<'_> { +impl core::fmt::Debug for OutputTrackersSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ClearDriftCompensationRequest"); + let mut ds = f.debug_struct("OutputTrackersSettingsRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_response_generated.rs new file mode 100644 index 000000000..59c5f43d3 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/output_trackers_settings_response_generated.rs @@ -0,0 +1,142 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum OutputTrackersSettingsResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct OutputTrackersSettingsResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for OutputTrackersSettingsResponse<'a> { + type Inner = OutputTrackersSettingsResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> OutputTrackersSettingsResponse<'a> { + pub const VT_AUTOMATIC_TRACKER_TOGGLE: flatbuffers::VOffsetT = 4; + pub const VT_TRACKERS: flatbuffers::VOffsetT = 6; + pub const VT_SEND_DERIVED_VELOCITY: flatbuffers::VOffsetT = 8; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + OutputTrackersSettingsResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args OutputTrackersSettingsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = OutputTrackersSettingsResponseBuilder::new(_fbb); + if let Some(x) = args.trackers { builder.add_trackers(x); } + builder.add_send_derived_velocity(args.send_derived_velocity); + builder.add_automatic_tracker_toggle(args.automatic_tracker_toggle); + builder.finish() + } + + + #[inline] + pub fn automatic_tracker_toggle(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(OutputTrackersSettingsResponse::VT_AUTOMATIC_TRACKER_TOGGLE, Some(false)).unwrap()} + } + #[inline] + pub fn trackers(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(OutputTrackersSettingsResponse::VT_TRACKERS, None)} + } + #[inline] + pub fn send_derived_velocity(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(OutputTrackersSettingsResponse::VT_SEND_DERIVED_VELOCITY, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for OutputTrackersSettingsResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("automatic_tracker_toggle", Self::VT_AUTOMATIC_TRACKER_TOGGLE, false)? + .visit_field::>>("trackers", Self::VT_TRACKERS, false)? + .visit_field::("send_derived_velocity", Self::VT_SEND_DERIVED_VELOCITY, false)? + .finish(); + Ok(()) + } +} +pub struct OutputTrackersSettingsResponseArgs<'a> { + pub automatic_tracker_toggle: bool, + pub trackers: Option>>, + pub send_derived_velocity: bool, +} +impl<'a> Default for OutputTrackersSettingsResponseArgs<'a> { + #[inline] + fn default() -> Self { + OutputTrackersSettingsResponseArgs { + automatic_tracker_toggle: false, + trackers: None, + send_derived_velocity: false, + } + } +} + +pub struct OutputTrackersSettingsResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> OutputTrackersSettingsResponseBuilder<'a, 'b> { + #[inline] + pub fn add_automatic_tracker_toggle(&mut self, automatic_tracker_toggle: bool) { + self.fbb_.push_slot::(OutputTrackersSettingsResponse::VT_AUTOMATIC_TRACKER_TOGGLE, automatic_tracker_toggle, false); + } + #[inline] + pub fn add_trackers(&mut self, trackers: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(OutputTrackersSettingsResponse::VT_TRACKERS, trackers); + } + #[inline] + pub fn add_send_derived_velocity(&mut self, send_derived_velocity: bool) { + self.fbb_.push_slot::(OutputTrackersSettingsResponse::VT_SEND_DERIVED_VELOCITY, send_derived_velocity, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OutputTrackersSettingsResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + OutputTrackersSettingsResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for OutputTrackersSettingsResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("OutputTrackersSettingsResponse"); + ds.field("automatic_tracker_toggle", &self.automatic_tracker_toggle()); + ds.field("trackers", &self.trackers()); + ds.field("send_derived_velocity", &self.send_derived_velocity()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_request_generated.rs index 42fd87121..112846284 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_request_generated.rs @@ -51,7 +51,7 @@ impl<'a> ResetRequest<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetRequest::VT_RESET_TYPE, Some(ResetType::Yaw)).unwrap()} + unsafe { self._tab.get::(ResetRequest::VT_RESET_TYPE, Some(ResetType::YAW)).unwrap()} } /// Which body parts to reset. Server handles it if empty (usually all) #[inline] @@ -93,7 +93,7 @@ impl<'a> Default for ResetRequestArgs<'a> { #[inline] fn default() -> Self { ResetRequestArgs { - reset_type: ResetType::Yaw, + reset_type: ResetType::YAW, body_parts: None, delay: None, } @@ -107,7 +107,7 @@ pub struct ResetRequestBuilder<'a: 'b, 'b> { impl<'a: 'b, 'b> ResetRequestBuilder<'a, 'b> { #[inline] pub fn add_reset_type(&mut self, reset_type: ResetType) { - self.fbb_.push_slot::(ResetRequest::VT_RESET_TYPE, reset_type, ResetType::Yaw); + self.fbb_.push_slot::(ResetRequest::VT_RESET_TYPE, reset_type, ResetType::YAW); } #[inline] pub fn add_body_parts(&mut self, body_parts: flatbuffers::WIPOffset>) { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs index b8a5ff873..559453fb4 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs @@ -55,7 +55,7 @@ impl<'a> ResetResponse<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetResponse::VT_RESET_TYPE, Some(ResetType::Yaw)).unwrap()} + unsafe { self._tab.get::(ResetResponse::VT_RESET_TYPE, Some(ResetType::YAW)).unwrap()} } #[inline] pub fn status(&self) -> ResetStatus { @@ -64,7 +64,7 @@ impl<'a> ResetResponse<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(ResetResponse::VT_STATUS, Some(ResetStatus::STARTED)).unwrap()} } - /// Should return the body parts reseted / being reset + /// Should return the body parts reset / being reset #[inline] pub fn body_parts(&self) -> Option> { // Safety: @@ -73,8 +73,7 @@ impl<'a> ResetResponse<'a> { unsafe { self._tab.get::>>(ResetResponse::VT_BODY_PARTS, None)} } /// gives the time in seconds passed since the start of the reset - /// is 0 when status == FINISHED - /// starts at 0 + /// Starts at 0. Should be equal to 'duration' when status == FINISHED #[inline] pub fn progress(&self) -> i32 { // Safety: @@ -118,7 +117,7 @@ impl<'a> Default for ResetResponseArgs<'a> { #[inline] fn default() -> Self { ResetResponseArgs { - reset_type: ResetType::Yaw, + reset_type: ResetType::YAW, status: ResetStatus::STARTED, body_parts: None, progress: 0, @@ -134,7 +133,7 @@ pub struct ResetResponseBuilder<'a: 'b, 'b> { impl<'a: 'b, 'b> ResetResponseBuilder<'a, 'b> { #[inline] pub fn add_reset_type(&mut self, reset_type: ResetType) { - self.fbb_.push_slot::(ResetResponse::VT_RESET_TYPE, reset_type, ResetType::Yaw); + self.fbb_.push_slot::(ResetResponse::VT_RESET_TYPE, reset_type, ResetType::YAW); } #[inline] pub fn add_status(&mut self, status: ResetStatus) { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_type_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_type_generated.rs index e2cad5f5f..04828482d 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_type_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_type_generated.rs @@ -16,9 +16,9 @@ pub const ENUM_MAX_RESET_TYPE: u8 = 2; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] pub const ENUM_VALUES_RESET_TYPE: [ResetType; 3] = [ - ResetType::Yaw, - ResetType::Full, - ResetType::Mounting, + ResetType::YAW, + ResetType::FULL, + ResetType::MOUNTING, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -26,24 +26,26 @@ pub const ENUM_VALUES_RESET_TYPE: [ResetType; 3] = [ pub struct ResetType(pub u8); #[allow(non_upper_case_globals)] impl ResetType { - pub const Yaw: Self = Self(0); - pub const Full: Self = Self(1); + /// Resets the yaw (horizontal) axis + pub const YAW: Self = Self(0); + /// Resets all axes + pub const FULL: Self = Self(1); /// Second pose for calibrating mounting rotation - pub const Mounting: Self = Self(2); + pub const MOUNTING: Self = Self(2); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 2; pub const ENUM_VALUES: &'static [Self] = &[ - Self::Yaw, - Self::Full, - Self::Mounting, + Self::YAW, + Self::FULL, + Self::MOUNTING, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::Yaw => Some("Yaw"), - Self::Full => Some("Full"), - Self::Mounting => Some("Mounting"), + Self::YAW => Some("YAW"), + Self::FULL => Some("FULL"), + Self::MOUNTING => Some("MOUNTING"), _ => None, } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_request_generated.rs similarity index 61% rename from protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_request_generated.rs index 08d9c43a3..b265d47ba 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_request_generated.rs @@ -9,39 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum SkeletonConfigRequestOffset {} +pub enum ResetsSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct SkeletonConfigRequest<'a> { +pub struct ResetsSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for SkeletonConfigRequest<'a> { - type Inner = SkeletonConfigRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for ResetsSettingsRequest<'a> { + type Inner = ResetsSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> SkeletonConfigRequest<'a> { +impl<'a> ResetsSettingsRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SkeletonConfigRequest { _tab: table } + ResetsSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args SkeletonConfigRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = SkeletonConfigRequestBuilder::new(_fbb); + _args: &'args ResetsSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ResetsSettingsRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for SkeletonConfigRequest<'_> { +impl flatbuffers::Verifiable for ResetsSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -52,39 +52,39 @@ impl flatbuffers::Verifiable for SkeletonConfigRequest<'_> { Ok(()) } } -pub struct SkeletonConfigRequestArgs { +pub struct ResetsSettingsRequestArgs { } -impl<'a> Default for SkeletonConfigRequestArgs { +impl<'a> Default for ResetsSettingsRequestArgs { #[inline] fn default() -> Self { - SkeletonConfigRequestArgs { + ResetsSettingsRequestArgs { } } } -pub struct SkeletonConfigRequestBuilder<'a: 'b, 'b> { +pub struct ResetsSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> SkeletonConfigRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> ResetsSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonConfigRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ResetsSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - SkeletonConfigRequestBuilder { + ResetsSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for SkeletonConfigRequest<'_> { +impl core::fmt::Debug for ResetsSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SkeletonConfigRequest"); + let mut ds = f.debug_struct("ResetsSettingsRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_response_generated.rs similarity index 60% rename from protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_response_generated.rs index 4d66e0bd1..05043fb2b 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/resets_settings_response_generated.rs @@ -9,85 +9,86 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum ResetsSettingsOffset {} +pub enum ResetsSettingsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct ResetsSettings<'a> { +pub struct ResetsSettingsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for ResetsSettings<'a> { - type Inner = ResetsSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for ResetsSettingsResponse<'a> { + type Inner = ResetsSettingsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> ResetsSettings<'a> { +impl<'a> ResetsSettingsResponse<'a> { pub const VT_RESET_MOUNTING_FEET: flatbuffers::VOffsetT = 4; - pub const VT_ARMS_MOUNTING_RESET_MODE: flatbuffers::VOffsetT = 6; + pub const VT_ARMS_RESET_MODE: flatbuffers::VOffsetT = 6; pub const VT_YAW_RESET_SMOOTH_TIME: flatbuffers::VOffsetT = 8; pub const VT_SAVE_MOUNTING_RESET: flatbuffers::VOffsetT = 10; pub const VT_RESET_HMD_PITCH: flatbuffers::VOffsetT = 12; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ResetsSettings { _tab: table } + ResetsSettingsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ResetsSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = ResetsSettingsBuilder::new(_fbb); + args: &'args ResetsSettingsResponseArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ResetsSettingsResponseBuilder::new(_fbb); builder.add_yaw_reset_smooth_time(args.yaw_reset_smooth_time); builder.add_reset_hmd_pitch(args.reset_hmd_pitch); builder.add_save_mounting_reset(args.save_mounting_reset); - builder.add_arms_mounting_reset_mode(args.arms_mounting_reset_mode); + builder.add_arms_reset_mode(args.arms_reset_mode); builder.add_reset_mounting_feet(args.reset_mounting_feet); builder.finish() } + /// Makes it so feet will be mounting reset when passing no BodyPart #[inline] pub fn reset_mounting_feet(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetsSettings::VT_RESET_MOUNTING_FEET, Some(false)).unwrap()} + unsafe { self._tab.get::(ResetsSettingsResponse::VT_RESET_MOUNTING_FEET, Some(false)).unwrap()} } #[inline] - pub fn arms_mounting_reset_mode(&self) -> ArmsMountingResetMode { + pub fn arms_reset_mode(&self) -> ArmsResetMode { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetsSettings::VT_ARMS_MOUNTING_RESET_MODE, Some(ArmsMountingResetMode::BACK)).unwrap()} + unsafe { self._tab.get::(ResetsSettingsResponse::VT_ARMS_RESET_MODE, Some(ArmsResetMode::BACK)).unwrap()} } #[inline] pub fn yaw_reset_smooth_time(&self) -> f32 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetsSettings::VT_YAW_RESET_SMOOTH_TIME, Some(0.0)).unwrap()} + unsafe { self._tab.get::(ResetsSettingsResponse::VT_YAW_RESET_SMOOTH_TIME, Some(0.0)).unwrap()} } #[inline] pub fn save_mounting_reset(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetsSettings::VT_SAVE_MOUNTING_RESET, Some(false)).unwrap()} + unsafe { self._tab.get::(ResetsSettingsResponse::VT_SAVE_MOUNTING_RESET, Some(false)).unwrap()} } #[inline] pub fn reset_hmd_pitch(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ResetsSettings::VT_RESET_HMD_PITCH, Some(false)).unwrap()} + unsafe { self._tab.get::(ResetsSettingsResponse::VT_RESET_HMD_PITCH, Some(false)).unwrap()} } } -impl flatbuffers::Verifiable for ResetsSettings<'_> { +impl flatbuffers::Verifiable for ResetsSettingsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -95,7 +96,7 @@ impl flatbuffers::Verifiable for ResetsSettings<'_> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::("reset_mounting_feet", Self::VT_RESET_MOUNTING_FEET, false)? - .visit_field::("arms_mounting_reset_mode", Self::VT_ARMS_MOUNTING_RESET_MODE, false)? + .visit_field::("arms_reset_mode", Self::VT_ARMS_RESET_MODE, false)? .visit_field::("yaw_reset_smooth_time", Self::VT_YAW_RESET_SMOOTH_TIME, false)? .visit_field::("save_mounting_reset", Self::VT_SAVE_MOUNTING_RESET, false)? .visit_field::("reset_hmd_pitch", Self::VT_RESET_HMD_PITCH, false)? @@ -103,19 +104,19 @@ impl flatbuffers::Verifiable for ResetsSettings<'_> { Ok(()) } } -pub struct ResetsSettingsArgs { +pub struct ResetsSettingsResponseArgs { pub reset_mounting_feet: bool, - pub arms_mounting_reset_mode: ArmsMountingResetMode, + pub arms_reset_mode: ArmsResetMode, pub yaw_reset_smooth_time: f32, pub save_mounting_reset: bool, pub reset_hmd_pitch: bool, } -impl<'a> Default for ResetsSettingsArgs { +impl<'a> Default for ResetsSettingsResponseArgs { #[inline] fn default() -> Self { - ResetsSettingsArgs { + ResetsSettingsResponseArgs { reset_mounting_feet: false, - arms_mounting_reset_mode: ArmsMountingResetMode::BACK, + arms_reset_mode: ArmsResetMode::BACK, yaw_reset_smooth_time: 0.0, save_mounting_reset: false, reset_hmd_pitch: false, @@ -123,51 +124,51 @@ impl<'a> Default for ResetsSettingsArgs { } } -pub struct ResetsSettingsBuilder<'a: 'b, 'b> { +pub struct ResetsSettingsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> ResetsSettingsBuilder<'a, 'b> { +impl<'a: 'b, 'b> ResetsSettingsResponseBuilder<'a, 'b> { #[inline] pub fn add_reset_mounting_feet(&mut self, reset_mounting_feet: bool) { - self.fbb_.push_slot::(ResetsSettings::VT_RESET_MOUNTING_FEET, reset_mounting_feet, false); + self.fbb_.push_slot::(ResetsSettingsResponse::VT_RESET_MOUNTING_FEET, reset_mounting_feet, false); } #[inline] - pub fn add_arms_mounting_reset_mode(&mut self, arms_mounting_reset_mode: ArmsMountingResetMode) { - self.fbb_.push_slot::(ResetsSettings::VT_ARMS_MOUNTING_RESET_MODE, arms_mounting_reset_mode, ArmsMountingResetMode::BACK); + pub fn add_arms_reset_mode(&mut self, arms_reset_mode: ArmsResetMode) { + self.fbb_.push_slot::(ResetsSettingsResponse::VT_ARMS_RESET_MODE, arms_reset_mode, ArmsResetMode::BACK); } #[inline] pub fn add_yaw_reset_smooth_time(&mut self, yaw_reset_smooth_time: f32) { - self.fbb_.push_slot::(ResetsSettings::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0); + self.fbb_.push_slot::(ResetsSettingsResponse::VT_YAW_RESET_SMOOTH_TIME, yaw_reset_smooth_time, 0.0); } #[inline] pub fn add_save_mounting_reset(&mut self, save_mounting_reset: bool) { - self.fbb_.push_slot::(ResetsSettings::VT_SAVE_MOUNTING_RESET, save_mounting_reset, false); + self.fbb_.push_slot::(ResetsSettingsResponse::VT_SAVE_MOUNTING_RESET, save_mounting_reset, false); } #[inline] pub fn add_reset_hmd_pitch(&mut self, reset_hmd_pitch: bool) { - self.fbb_.push_slot::(ResetsSettings::VT_RESET_HMD_PITCH, reset_hmd_pitch, false); + self.fbb_.push_slot::(ResetsSettingsResponse::VT_RESET_HMD_PITCH, reset_hmd_pitch, false); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ResetsSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ResetsSettingsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - ResetsSettingsBuilder { + ResetsSettingsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for ResetsSettings<'_> { +impl core::fmt::Debug for ResetsSettingsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ResetsSettings"); + let mut ds = f.debug_struct("ResetsSettingsResponse"); ds.field("reset_mounting_feet", &self.reset_mounting_feet()); - ds.field("arms_mounting_reset_mode", &self.arms_mounting_reset_mode()); + ds.field("arms_reset_mode", &self.arms_reset_mode()); ds.field("yaw_reset_smooth_time", &self.yaw_reset_smooth_time()); ds.field("save_mounting_reset", &self.save_mounting_reset()); ds.field("reset_hmd_pitch", &self.reset_hmd_pitch()); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs index 71ce97ba3..3daf378db 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs @@ -12,29 +12,51 @@ use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_RPC_MESSAGE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_RPC_MESSAGE: u8 = 86; +pub const ENUM_MAX_RPC_MESSAGE: u8 = 107; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 87] = [ +pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 108] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, RpcMessage::ResetRequest, RpcMessage::ResetResponse, RpcMessage::AssignTrackerRequest, - RpcMessage::SettingsRequest, - RpcMessage::SettingsResponse, - RpcMessage::ChangeSettingsRequest, - RpcMessage::ClearDriftCompensationRequest, + RpcMessage::OutputTrackersSettingsRequest, + RpcMessage::OutputTrackersSettingsResponse, + RpcMessage::ChangeOutputTrackersSettingsRequest, + RpcMessage::VMCOSCSettingsRequest, + RpcMessage::VMCOSCSettingsResponse, + RpcMessage::ChangeVMCOSCSettingsRequest, + RpcMessage::VRMSettingsRequest, + RpcMessage::VRMSettingsResponse, + RpcMessage::ChangeVRMSettingsRequest, + RpcMessage::SkeletonSettingsRequest, + RpcMessage::SkeletonSettingsResponse, + RpcMessage::ChangeSkeletonSettingsRequest, + RpcMessage::TapDetectionSettingsRequest, + RpcMessage::TapDetectionSettingsResponse, + RpcMessage::ChangeTapDetectionSettingsRequest, + RpcMessage::TapDetectionSetupModeRequest, + RpcMessage::ResetsSettingsRequest, + RpcMessage::ResetsSettingsResponse, + RpcMessage::ChangeResetsSettingsRequest, + RpcMessage::StayAlignedSettingsRequest, + RpcMessage::StayAlignedSettingsResponse, + RpcMessage::ChangeStayAlignedSettingsRequest, + RpcMessage::CompleteStayAlignedResponse, + RpcMessage::StayAlignedHideCorrectionRequest, + RpcMessage::HIDSettingsRequest, + RpcMessage::HIDSettingsResponse, + RpcMessage::ChangeHIDSettingsRequest, RpcMessage::RecordBVHRequest, RpcMessage::RecordBVHStatus, - RpcMessage::SkeletonConfigRequest, - RpcMessage::ChangeSkeletonConfigRequest, - RpcMessage::SkeletonResetAllRequest, - RpcMessage::SkeletonConfigResponse, + RpcMessage::SkeletonProportionsRequest, + RpcMessage::ChangeSkeletonProportionsRequest, + RpcMessage::SkeletonProportionsResetAllRequest, + RpcMessage::SkeletonProportionsResponse, RpcMessage::OpenSerialRequest, RpcMessage::CloseSerialRequest, - RpcMessage::SetWifiRequest, RpcMessage::SerialUpdateResponse, RpcMessage::AutoBoneProcessRequest, RpcMessage::AutoBoneProcessStatusResponse, @@ -57,13 +79,7 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 87] = [ RpcMessage::LegTweaksTmpClear, RpcMessage::TapDetectionSetupNotification, RpcMessage::SetPauseTrackingRequest, - RpcMessage::StatusSystemRequest, - RpcMessage::StatusSystemResponse, - RpcMessage::StatusSystemUpdate, - RpcMessage::StatusSystemFixed, RpcMessage::ClearMountingResetRequest, - RpcMessage::HeightRequest, - RpcMessage::HeightResponse, RpcMessage::AutoBoneApplyRequest, RpcMessage::AutoBoneStopRecordingRequest, RpcMessage::AutoBoneCancelRecordingRequest, @@ -95,6 +111,11 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 87] = [ RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::VRCOSCSettingsRequest, + RpcMessage::VRCOSCSettingsResponse, + RpcMessage::ChangeVRCOSCSettingsRequest, + RpcMessage::VRCOSCStatusRequest, + RpcMessage::VRCOSCStatusChangeResponse, RpcMessage::KeybindRequest, RpcMessage::ChangeKeybindRequest, RpcMessage::KeybindResponse, @@ -116,90 +137,111 @@ impl RpcMessage { pub const ResetRequest: Self = Self(3); pub const ResetResponse: Self = Self(4); pub const AssignTrackerRequest: Self = Self(5); - pub const SettingsRequest: Self = Self(6); - pub const SettingsResponse: Self = Self(7); - pub const ChangeSettingsRequest: Self = Self(8); - pub const ClearDriftCompensationRequest: Self = Self(9); - pub const RecordBVHRequest: Self = Self(10); - pub const RecordBVHStatus: Self = Self(11); - pub const SkeletonConfigRequest: Self = Self(12); - pub const ChangeSkeletonConfigRequest: Self = Self(13); - pub const SkeletonResetAllRequest: Self = Self(14); - pub const SkeletonConfigResponse: Self = Self(15); - pub const OpenSerialRequest: Self = Self(16); - pub const CloseSerialRequest: Self = Self(17); - pub const SetWifiRequest: Self = Self(18); - pub const SerialUpdateResponse: Self = Self(19); - pub const AutoBoneProcessRequest: Self = Self(20); - pub const AutoBoneProcessStatusResponse: Self = Self(21); - pub const AutoBoneEpochResponse: Self = Self(22); - pub const OverlayDisplayModeRequest: Self = Self(23); - pub const OverlayDisplayModeChangeRequest: Self = Self(24); - pub const OverlayDisplayModeResponse: Self = Self(25); - pub const SerialTrackerRebootRequest: Self = Self(26); - pub const SerialTrackerGetInfoRequest: Self = Self(27); - pub const SerialTrackerFactoryResetRequest: Self = Self(28); - pub const SerialDevicesRequest: Self = Self(29); - pub const SerialDevicesResponse: Self = Self(30); - pub const NewSerialDeviceResponse: Self = Self(31); - pub const StartWifiProvisioningRequest: Self = Self(32); - pub const StopWifiProvisioningRequest: Self = Self(33); - pub const WifiProvisioningStatusResponse: Self = Self(34); - pub const ServerInfosRequest: Self = Self(35); - pub const ServerInfosResponse: Self = Self(36); - pub const LegTweaksTmpChange: Self = Self(37); - pub const LegTweaksTmpClear: Self = Self(38); - pub const TapDetectionSetupNotification: Self = Self(39); - pub const SetPauseTrackingRequest: Self = Self(40); - pub const StatusSystemRequest: Self = Self(41); - pub const StatusSystemResponse: Self = Self(42); - pub const StatusSystemUpdate: Self = Self(43); - pub const StatusSystemFixed: Self = Self(44); - pub const ClearMountingResetRequest: Self = Self(45); - pub const HeightRequest: Self = Self(46); - pub const HeightResponse: Self = Self(47); - pub const AutoBoneApplyRequest: Self = Self(48); - pub const AutoBoneStopRecordingRequest: Self = Self(49); - pub const AutoBoneCancelRecordingRequest: Self = Self(50); - pub const SaveFileNotification: Self = Self(51); - pub const TrackingPauseStateRequest: Self = Self(52); - pub const TrackingPauseStateResponse: Self = Self(53); - pub const SerialTrackerGetWifiScanRequest: Self = Self(54); - pub const UnknownDeviceHandshakeNotification: Self = Self(55); - pub const AddUnknownDeviceRequest: Self = Self(56); - pub const ForgetDeviceRequest: Self = Self(57); - pub const FirmwareUpdateRequest: Self = Self(58); - pub const FirmwareUpdateStatusResponse: Self = Self(59); - pub const FirmwareUpdateStopQueuesRequest: Self = Self(60); - pub const SettingsResetRequest: Self = Self(61); - pub const MagToggleRequest: Self = Self(62); - pub const MagToggleResponse: Self = Self(63); - pub const ChangeMagToggleRequest: Self = Self(64); - pub const RecordBVHStatusRequest: Self = Self(65); - pub const VRCConfigStateRequest: Self = Self(66); - pub const VRCConfigStateChangeResponse: Self = Self(67); - pub const EnableStayAlignedRequest: Self = Self(68); - pub const DetectStayAlignedRelaxedPoseRequest: Self = Self(69); - pub const ResetStayAlignedRelaxedPoseRequest: Self = Self(70); - pub const SerialTrackerCustomCommandRequest: Self = Self(71); - pub const VRCConfigSettingToggleMute: Self = Self(72); - pub const TrackingChecklistRequest: Self = Self(73); - pub const TrackingChecklistResponse: Self = Self(74); - pub const IgnoreTrackingChecklistStepRequest: Self = Self(75); - pub const StartUserHeightCalibration: Self = Self(76); - pub const CancelUserHeightCalibration: Self = Self(77); - pub const UserHeightRecordingStatusResponse: Self = Self(78); - pub const KeybindRequest: Self = Self(79); - pub const ChangeKeybindRequest: Self = Self(80); - pub const KeybindResponse: Self = Self(81); - pub const InstalledInfoRequest: Self = Self(82); - pub const InstalledInfoResponse: Self = Self(83); - pub const OpenUriRequest: Self = Self(84); - pub const OpenUriResponse: Self = Self(85); - pub const EnableSteamVRDriverRequest: Self = Self(86); + pub const OutputTrackersSettingsRequest: Self = Self(6); + pub const OutputTrackersSettingsResponse: Self = Self(7); + pub const ChangeOutputTrackersSettingsRequest: Self = Self(8); + pub const VMCOSCSettingsRequest: Self = Self(9); + pub const VMCOSCSettingsResponse: Self = Self(10); + pub const ChangeVMCOSCSettingsRequest: Self = Self(11); + pub const VRMSettingsRequest: Self = Self(12); + pub const VRMSettingsResponse: Self = Self(13); + pub const ChangeVRMSettingsRequest: Self = Self(14); + pub const SkeletonSettingsRequest: Self = Self(15); + pub const SkeletonSettingsResponse: Self = Self(16); + pub const ChangeSkeletonSettingsRequest: Self = Self(17); + pub const TapDetectionSettingsRequest: Self = Self(18); + pub const TapDetectionSettingsResponse: Self = Self(19); + pub const ChangeTapDetectionSettingsRequest: Self = Self(20); + pub const TapDetectionSetupModeRequest: Self = Self(21); + pub const ResetsSettingsRequest: Self = Self(22); + pub const ResetsSettingsResponse: Self = Self(23); + pub const ChangeResetsSettingsRequest: Self = Self(24); + pub const StayAlignedSettingsRequest: Self = Self(25); + pub const StayAlignedSettingsResponse: Self = Self(26); + pub const ChangeStayAlignedSettingsRequest: Self = Self(27); + pub const CompleteStayAlignedResponse: Self = Self(28); + pub const StayAlignedHideCorrectionRequest: Self = Self(29); + pub const HIDSettingsRequest: Self = Self(30); + pub const HIDSettingsResponse: Self = Self(31); + pub const ChangeHIDSettingsRequest: Self = Self(32); + pub const RecordBVHRequest: Self = Self(33); + pub const RecordBVHStatus: Self = Self(34); + pub const SkeletonProportionsRequest: Self = Self(35); + pub const ChangeSkeletonProportionsRequest: Self = Self(36); + pub const SkeletonProportionsResetAllRequest: Self = Self(37); + pub const SkeletonProportionsResponse: Self = Self(38); + pub const OpenSerialRequest: Self = Self(39); + pub const CloseSerialRequest: Self = Self(40); + pub const SerialUpdateResponse: Self = Self(41); + pub const AutoBoneProcessRequest: Self = Self(42); + pub const AutoBoneProcessStatusResponse: Self = Self(43); + pub const AutoBoneEpochResponse: Self = Self(44); + pub const OverlayDisplayModeRequest: Self = Self(45); + pub const OverlayDisplayModeChangeRequest: Self = Self(46); + pub const OverlayDisplayModeResponse: Self = Self(47); + pub const SerialTrackerRebootRequest: Self = Self(48); + pub const SerialTrackerGetInfoRequest: Self = Self(49); + pub const SerialTrackerFactoryResetRequest: Self = Self(50); + pub const SerialDevicesRequest: Self = Self(51); + pub const SerialDevicesResponse: Self = Self(52); + pub const NewSerialDeviceResponse: Self = Self(53); + pub const StartWifiProvisioningRequest: Self = Self(54); + pub const StopWifiProvisioningRequest: Self = Self(55); + pub const WifiProvisioningStatusResponse: Self = Self(56); + pub const ServerInfosRequest: Self = Self(57); + pub const ServerInfosResponse: Self = Self(58); + pub const LegTweaksTmpChange: Self = Self(59); + pub const LegTweaksTmpClear: Self = Self(60); + pub const TapDetectionSetupNotification: Self = Self(61); + pub const SetPauseTrackingRequest: Self = Self(62); + pub const ClearMountingResetRequest: Self = Self(63); + pub const AutoBoneApplyRequest: Self = Self(64); + pub const AutoBoneStopRecordingRequest: Self = Self(65); + pub const AutoBoneCancelRecordingRequest: Self = Self(66); + pub const SaveFileNotification: Self = Self(67); + pub const TrackingPauseStateRequest: Self = Self(68); + pub const TrackingPauseStateResponse: Self = Self(69); + pub const SerialTrackerGetWifiScanRequest: Self = Self(70); + pub const UnknownDeviceHandshakeNotification: Self = Self(71); + pub const AddUnknownDeviceRequest: Self = Self(72); + pub const ForgetDeviceRequest: Self = Self(73); + pub const FirmwareUpdateRequest: Self = Self(74); + pub const FirmwareUpdateStatusResponse: Self = Self(75); + pub const FirmwareUpdateStopQueuesRequest: Self = Self(76); + pub const SettingsResetRequest: Self = Self(77); + pub const MagToggleRequest: Self = Self(78); + pub const MagToggleResponse: Self = Self(79); + pub const ChangeMagToggleRequest: Self = Self(80); + pub const RecordBVHStatusRequest: Self = Self(81); + pub const VRCConfigStateRequest: Self = Self(82); + pub const VRCConfigStateChangeResponse: Self = Self(83); + pub const EnableStayAlignedRequest: Self = Self(84); + pub const DetectStayAlignedRelaxedPoseRequest: Self = Self(85); + pub const ResetStayAlignedRelaxedPoseRequest: Self = Self(86); + pub const SerialTrackerCustomCommandRequest: Self = Self(87); + pub const VRCConfigSettingToggleMute: Self = Self(88); + pub const TrackingChecklistRequest: Self = Self(89); + pub const TrackingChecklistResponse: Self = Self(90); + pub const IgnoreTrackingChecklistStepRequest: Self = Self(91); + pub const StartUserHeightCalibration: Self = Self(92); + pub const CancelUserHeightCalibration: Self = Self(93); + pub const UserHeightRecordingStatusResponse: Self = Self(94); + pub const VRCOSCSettingsRequest: Self = Self(95); + pub const VRCOSCSettingsResponse: Self = Self(96); + pub const ChangeVRCOSCSettingsRequest: Self = Self(97); + pub const VRCOSCStatusRequest: Self = Self(98); + pub const VRCOSCStatusChangeResponse: Self = Self(99); + pub const KeybindRequest: Self = Self(100); + pub const ChangeKeybindRequest: Self = Self(101); + pub const KeybindResponse: Self = Self(102); + pub const InstalledInfoRequest: Self = Self(103); + pub const InstalledInfoResponse: Self = Self(104); + pub const OpenUriRequest: Self = Self(105); + pub const OpenUriResponse: Self = Self(106); + pub const EnableSteamVRDriverRequest: Self = Self(107); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 86; + pub const ENUM_MAX: u8 = 107; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -207,19 +249,41 @@ impl RpcMessage { Self::ResetRequest, Self::ResetResponse, Self::AssignTrackerRequest, - Self::SettingsRequest, - Self::SettingsResponse, - Self::ChangeSettingsRequest, - Self::ClearDriftCompensationRequest, + Self::OutputTrackersSettingsRequest, + Self::OutputTrackersSettingsResponse, + Self::ChangeOutputTrackersSettingsRequest, + Self::VMCOSCSettingsRequest, + Self::VMCOSCSettingsResponse, + Self::ChangeVMCOSCSettingsRequest, + Self::VRMSettingsRequest, + Self::VRMSettingsResponse, + Self::ChangeVRMSettingsRequest, + Self::SkeletonSettingsRequest, + Self::SkeletonSettingsResponse, + Self::ChangeSkeletonSettingsRequest, + Self::TapDetectionSettingsRequest, + Self::TapDetectionSettingsResponse, + Self::ChangeTapDetectionSettingsRequest, + Self::TapDetectionSetupModeRequest, + Self::ResetsSettingsRequest, + Self::ResetsSettingsResponse, + Self::ChangeResetsSettingsRequest, + Self::StayAlignedSettingsRequest, + Self::StayAlignedSettingsResponse, + Self::ChangeStayAlignedSettingsRequest, + Self::CompleteStayAlignedResponse, + Self::StayAlignedHideCorrectionRequest, + Self::HIDSettingsRequest, + Self::HIDSettingsResponse, + Self::ChangeHIDSettingsRequest, Self::RecordBVHRequest, Self::RecordBVHStatus, - Self::SkeletonConfigRequest, - Self::ChangeSkeletonConfigRequest, - Self::SkeletonResetAllRequest, - Self::SkeletonConfigResponse, + Self::SkeletonProportionsRequest, + Self::ChangeSkeletonProportionsRequest, + Self::SkeletonProportionsResetAllRequest, + Self::SkeletonProportionsResponse, Self::OpenSerialRequest, Self::CloseSerialRequest, - Self::SetWifiRequest, Self::SerialUpdateResponse, Self::AutoBoneProcessRequest, Self::AutoBoneProcessStatusResponse, @@ -242,13 +306,7 @@ impl RpcMessage { Self::LegTweaksTmpClear, Self::TapDetectionSetupNotification, Self::SetPauseTrackingRequest, - Self::StatusSystemRequest, - Self::StatusSystemResponse, - Self::StatusSystemUpdate, - Self::StatusSystemFixed, Self::ClearMountingResetRequest, - Self::HeightRequest, - Self::HeightResponse, Self::AutoBoneApplyRequest, Self::AutoBoneStopRecordingRequest, Self::AutoBoneCancelRecordingRequest, @@ -280,6 +338,11 @@ impl RpcMessage { Self::StartUserHeightCalibration, Self::CancelUserHeightCalibration, Self::UserHeightRecordingStatusResponse, + Self::VRCOSCSettingsRequest, + Self::VRCOSCSettingsResponse, + Self::ChangeVRCOSCSettingsRequest, + Self::VRCOSCStatusRequest, + Self::VRCOSCStatusChangeResponse, Self::KeybindRequest, Self::ChangeKeybindRequest, Self::KeybindResponse, @@ -298,19 +361,41 @@ impl RpcMessage { Self::ResetRequest => Some("ResetRequest"), Self::ResetResponse => Some("ResetResponse"), Self::AssignTrackerRequest => Some("AssignTrackerRequest"), - Self::SettingsRequest => Some("SettingsRequest"), - Self::SettingsResponse => Some("SettingsResponse"), - Self::ChangeSettingsRequest => Some("ChangeSettingsRequest"), - Self::ClearDriftCompensationRequest => Some("ClearDriftCompensationRequest"), + Self::OutputTrackersSettingsRequest => Some("OutputTrackersSettingsRequest"), + Self::OutputTrackersSettingsResponse => Some("OutputTrackersSettingsResponse"), + Self::ChangeOutputTrackersSettingsRequest => Some("ChangeOutputTrackersSettingsRequest"), + Self::VMCOSCSettingsRequest => Some("VMCOSCSettingsRequest"), + Self::VMCOSCSettingsResponse => Some("VMCOSCSettingsResponse"), + Self::ChangeVMCOSCSettingsRequest => Some("ChangeVMCOSCSettingsRequest"), + Self::VRMSettingsRequest => Some("VRMSettingsRequest"), + Self::VRMSettingsResponse => Some("VRMSettingsResponse"), + Self::ChangeVRMSettingsRequest => Some("ChangeVRMSettingsRequest"), + Self::SkeletonSettingsRequest => Some("SkeletonSettingsRequest"), + Self::SkeletonSettingsResponse => Some("SkeletonSettingsResponse"), + Self::ChangeSkeletonSettingsRequest => Some("ChangeSkeletonSettingsRequest"), + Self::TapDetectionSettingsRequest => Some("TapDetectionSettingsRequest"), + Self::TapDetectionSettingsResponse => Some("TapDetectionSettingsResponse"), + Self::ChangeTapDetectionSettingsRequest => Some("ChangeTapDetectionSettingsRequest"), + Self::TapDetectionSetupModeRequest => Some("TapDetectionSetupModeRequest"), + Self::ResetsSettingsRequest => Some("ResetsSettingsRequest"), + Self::ResetsSettingsResponse => Some("ResetsSettingsResponse"), + Self::ChangeResetsSettingsRequest => Some("ChangeResetsSettingsRequest"), + Self::StayAlignedSettingsRequest => Some("StayAlignedSettingsRequest"), + Self::StayAlignedSettingsResponse => Some("StayAlignedSettingsResponse"), + Self::ChangeStayAlignedSettingsRequest => Some("ChangeStayAlignedSettingsRequest"), + Self::CompleteStayAlignedResponse => Some("CompleteStayAlignedResponse"), + Self::StayAlignedHideCorrectionRequest => Some("StayAlignedHideCorrectionRequest"), + Self::HIDSettingsRequest => Some("HIDSettingsRequest"), + Self::HIDSettingsResponse => Some("HIDSettingsResponse"), + Self::ChangeHIDSettingsRequest => Some("ChangeHIDSettingsRequest"), Self::RecordBVHRequest => Some("RecordBVHRequest"), Self::RecordBVHStatus => Some("RecordBVHStatus"), - Self::SkeletonConfigRequest => Some("SkeletonConfigRequest"), - Self::ChangeSkeletonConfigRequest => Some("ChangeSkeletonConfigRequest"), - Self::SkeletonResetAllRequest => Some("SkeletonResetAllRequest"), - Self::SkeletonConfigResponse => Some("SkeletonConfigResponse"), + Self::SkeletonProportionsRequest => Some("SkeletonProportionsRequest"), + Self::ChangeSkeletonProportionsRequest => Some("ChangeSkeletonProportionsRequest"), + Self::SkeletonProportionsResetAllRequest => Some("SkeletonProportionsResetAllRequest"), + Self::SkeletonProportionsResponse => Some("SkeletonProportionsResponse"), Self::OpenSerialRequest => Some("OpenSerialRequest"), Self::CloseSerialRequest => Some("CloseSerialRequest"), - Self::SetWifiRequest => Some("SetWifiRequest"), Self::SerialUpdateResponse => Some("SerialUpdateResponse"), Self::AutoBoneProcessRequest => Some("AutoBoneProcessRequest"), Self::AutoBoneProcessStatusResponse => Some("AutoBoneProcessStatusResponse"), @@ -333,13 +418,7 @@ impl RpcMessage { Self::LegTweaksTmpClear => Some("LegTweaksTmpClear"), Self::TapDetectionSetupNotification => Some("TapDetectionSetupNotification"), Self::SetPauseTrackingRequest => Some("SetPauseTrackingRequest"), - Self::StatusSystemRequest => Some("StatusSystemRequest"), - Self::StatusSystemResponse => Some("StatusSystemResponse"), - Self::StatusSystemUpdate => Some("StatusSystemUpdate"), - Self::StatusSystemFixed => Some("StatusSystemFixed"), Self::ClearMountingResetRequest => Some("ClearMountingResetRequest"), - Self::HeightRequest => Some("HeightRequest"), - Self::HeightResponse => Some("HeightResponse"), Self::AutoBoneApplyRequest => Some("AutoBoneApplyRequest"), Self::AutoBoneStopRecordingRequest => Some("AutoBoneStopRecordingRequest"), Self::AutoBoneCancelRecordingRequest => Some("AutoBoneCancelRecordingRequest"), @@ -371,6 +450,11 @@ impl RpcMessage { Self::StartUserHeightCalibration => Some("StartUserHeightCalibration"), Self::CancelUserHeightCalibration => Some("CancelUserHeightCalibration"), Self::UserHeightRecordingStatusResponse => Some("UserHeightRecordingStatusResponse"), + Self::VRCOSCSettingsRequest => Some("VRCOSCSettingsRequest"), + Self::VRCOSCSettingsResponse => Some("VRCOSCSettingsResponse"), + Self::ChangeVRCOSCSettingsRequest => Some("ChangeVRCOSCSettingsRequest"), + Self::VRCOSCStatusRequest => Some("VRCOSCStatusRequest"), + Self::VRCOSCStatusChangeResponse => Some("VRCOSCStatusChangeResponse"), Self::KeybindRequest => Some("KeybindRequest"), Self::ChangeKeybindRequest => Some("ChangeKeybindRequest"), Self::KeybindResponse => Some("KeybindResponse"), diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs index ca504d347..4f08e35cb 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs @@ -46,8 +46,8 @@ impl<'a> RpcMessageHeader<'a> { } - /// For a request, this identifies the request. For a response, this corresponds - /// to the request that it is responding to. + /// For a request, this identifies the request. + /// For a response, this corresponds to the request that it is responding to. #[inline] pub fn tx_id(&self) -> Option<&'a super::datatypes::TransactionId> { // Safety: @@ -146,13 +146,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_settings_request(&self) -> Option> { - if self.message_type() == RpcMessage::SettingsRequest { + pub fn message_as_output_trackers_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::OutputTrackersSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SettingsRequest::init_from_table(t) } + unsafe { OutputTrackersSettingsRequest::init_from_table(t) } }) } else { None @@ -161,13 +161,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_settings_response(&self) -> Option> { - if self.message_type() == RpcMessage::SettingsResponse { + pub fn message_as_output_trackers_settings_response(&self) -> Option> { + if self.message_type() == RpcMessage::OutputTrackersSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SettingsResponse::init_from_table(t) } + unsafe { OutputTrackersSettingsResponse::init_from_table(t) } }) } else { None @@ -176,13 +176,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_change_settings_request(&self) -> Option> { - if self.message_type() == RpcMessage::ChangeSettingsRequest { + pub fn message_as_change_output_trackers_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeOutputTrackersSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ChangeSettingsRequest::init_from_table(t) } + unsafe { ChangeOutputTrackersSettingsRequest::init_from_table(t) } }) } else { None @@ -191,13 +191,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_clear_drift_compensation_request(&self) -> Option> { - if self.message_type() == RpcMessage::ClearDriftCompensationRequest { + pub fn message_as_vmcoscsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::VMCOSCSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ClearDriftCompensationRequest::init_from_table(t) } + unsafe { VMCOSCSettingsRequest::init_from_table(t) } }) } else { None @@ -206,13 +206,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_record_bvhrequest(&self) -> Option> { - if self.message_type() == RpcMessage::RecordBVHRequest { + pub fn message_as_vmcoscsettings_response(&self) -> Option> { + if self.message_type() == RpcMessage::VMCOSCSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { RecordBVHRequest::init_from_table(t) } + unsafe { VMCOSCSettingsResponse::init_from_table(t) } }) } else { None @@ -221,13 +221,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_record_bvhstatus(&self) -> Option> { - if self.message_type() == RpcMessage::RecordBVHStatus { + pub fn message_as_change_vmcoscsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeVMCOSCSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { RecordBVHStatus::init_from_table(t) } + unsafe { ChangeVMCOSCSettingsRequest::init_from_table(t) } }) } else { None @@ -236,13 +236,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_skeleton_config_request(&self) -> Option> { - if self.message_type() == RpcMessage::SkeletonConfigRequest { + pub fn message_as_vrmsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::VRMSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SkeletonConfigRequest::init_from_table(t) } + unsafe { VRMSettingsRequest::init_from_table(t) } }) } else { None @@ -251,13 +251,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_change_skeleton_config_request(&self) -> Option> { - if self.message_type() == RpcMessage::ChangeSkeletonConfigRequest { + pub fn message_as_vrmsettings_response(&self) -> Option> { + if self.message_type() == RpcMessage::VRMSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ChangeSkeletonConfigRequest::init_from_table(t) } + unsafe { VRMSettingsResponse::init_from_table(t) } }) } else { None @@ -266,13 +266,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_skeleton_reset_all_request(&self) -> Option> { - if self.message_type() == RpcMessage::SkeletonResetAllRequest { + pub fn message_as_change_vrmsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeVRMSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SkeletonResetAllRequest::init_from_table(t) } + unsafe { ChangeVRMSettingsRequest::init_from_table(t) } }) } else { None @@ -281,13 +281,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_skeleton_config_response(&self) -> Option> { - if self.message_type() == RpcMessage::SkeletonConfigResponse { + pub fn message_as_skeleton_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::SkeletonSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SkeletonConfigResponse::init_from_table(t) } + unsafe { SkeletonSettingsRequest::init_from_table(t) } }) } else { None @@ -296,13 +296,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_open_serial_request(&self) -> Option> { - if self.message_type() == RpcMessage::OpenSerialRequest { + pub fn message_as_skeleton_settings_response(&self) -> Option> { + if self.message_type() == RpcMessage::SkeletonSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { OpenSerialRequest::init_from_table(t) } + unsafe { SkeletonSettingsResponse::init_from_table(t) } }) } else { None @@ -311,13 +311,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_close_serial_request(&self) -> Option> { - if self.message_type() == RpcMessage::CloseSerialRequest { + pub fn message_as_change_skeleton_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeSkeletonSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { CloseSerialRequest::init_from_table(t) } + unsafe { ChangeSkeletonSettingsRequest::init_from_table(t) } }) } else { None @@ -326,13 +326,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_set_wifi_request(&self) -> Option> { - if self.message_type() == RpcMessage::SetWifiRequest { + pub fn message_as_tap_detection_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::TapDetectionSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SetWifiRequest::init_from_table(t) } + unsafe { TapDetectionSettingsRequest::init_from_table(t) } }) } else { None @@ -341,13 +341,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_update_response(&self) -> Option> { - if self.message_type() == RpcMessage::SerialUpdateResponse { + pub fn message_as_tap_detection_settings_response(&self) -> Option> { + if self.message_type() == RpcMessage::TapDetectionSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialUpdateResponse::init_from_table(t) } + unsafe { TapDetectionSettingsResponse::init_from_table(t) } }) } else { None @@ -356,13 +356,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_auto_bone_process_request(&self) -> Option> { - if self.message_type() == RpcMessage::AutoBoneProcessRequest { + pub fn message_as_change_tap_detection_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeTapDetectionSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { AutoBoneProcessRequest::init_from_table(t) } + unsafe { ChangeTapDetectionSettingsRequest::init_from_table(t) } }) } else { None @@ -371,13 +371,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_auto_bone_process_status_response(&self) -> Option> { - if self.message_type() == RpcMessage::AutoBoneProcessStatusResponse { + pub fn message_as_tap_detection_setup_mode_request(&self) -> Option> { + if self.message_type() == RpcMessage::TapDetectionSetupModeRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { AutoBoneProcessStatusResponse::init_from_table(t) } + unsafe { TapDetectionSetupModeRequest::init_from_table(t) } }) } else { None @@ -386,13 +386,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_auto_bone_epoch_response(&self) -> Option> { - if self.message_type() == RpcMessage::AutoBoneEpochResponse { + pub fn message_as_resets_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ResetsSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { AutoBoneEpochResponse::init_from_table(t) } + unsafe { ResetsSettingsRequest::init_from_table(t) } }) } else { None @@ -401,13 +401,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_overlay_display_mode_request(&self) -> Option> { - if self.message_type() == RpcMessage::OverlayDisplayModeRequest { + pub fn message_as_resets_settings_response(&self) -> Option> { + if self.message_type() == RpcMessage::ResetsSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { OverlayDisplayModeRequest::init_from_table(t) } + unsafe { ResetsSettingsResponse::init_from_table(t) } }) } else { None @@ -416,13 +416,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_overlay_display_mode_change_request(&self) -> Option> { - if self.message_type() == RpcMessage::OverlayDisplayModeChangeRequest { + pub fn message_as_change_resets_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeResetsSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { OverlayDisplayModeChangeRequest::init_from_table(t) } + unsafe { ChangeResetsSettingsRequest::init_from_table(t) } }) } else { None @@ -431,13 +431,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_overlay_display_mode_response(&self) -> Option> { - if self.message_type() == RpcMessage::OverlayDisplayModeResponse { + pub fn message_as_stay_aligned_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::StayAlignedSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { OverlayDisplayModeResponse::init_from_table(t) } + unsafe { StayAlignedSettingsRequest::init_from_table(t) } }) } else { None @@ -446,13 +446,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_tracker_reboot_request(&self) -> Option> { - if self.message_type() == RpcMessage::SerialTrackerRebootRequest { + pub fn message_as_stay_aligned_settings_response(&self) -> Option> { + if self.message_type() == RpcMessage::StayAlignedSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialTrackerRebootRequest::init_from_table(t) } + unsafe { StayAlignedSettingsResponse::init_from_table(t) } }) } else { None @@ -461,13 +461,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_tracker_get_info_request(&self) -> Option> { - if self.message_type() == RpcMessage::SerialTrackerGetInfoRequest { + pub fn message_as_change_stay_aligned_settings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeStayAlignedSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialTrackerGetInfoRequest::init_from_table(t) } + unsafe { ChangeStayAlignedSettingsRequest::init_from_table(t) } }) } else { None @@ -476,13 +476,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_tracker_factory_reset_request(&self) -> Option> { - if self.message_type() == RpcMessage::SerialTrackerFactoryResetRequest { + pub fn message_as_complete_stay_aligned_response(&self) -> Option> { + if self.message_type() == RpcMessage::CompleteStayAlignedResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialTrackerFactoryResetRequest::init_from_table(t) } + unsafe { CompleteStayAlignedResponse::init_from_table(t) } }) } else { None @@ -491,13 +491,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_devices_request(&self) -> Option> { - if self.message_type() == RpcMessage::SerialDevicesRequest { + pub fn message_as_stay_aligned_hide_correction_request(&self) -> Option> { + if self.message_type() == RpcMessage::StayAlignedHideCorrectionRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialDevicesRequest::init_from_table(t) } + unsafe { StayAlignedHideCorrectionRequest::init_from_table(t) } }) } else { None @@ -506,13 +506,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_serial_devices_response(&self) -> Option> { - if self.message_type() == RpcMessage::SerialDevicesResponse { + pub fn message_as_hidsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::HIDSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SerialDevicesResponse::init_from_table(t) } + unsafe { HIDSettingsRequest::init_from_table(t) } }) } else { None @@ -521,13 +521,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_new_serial_device_response(&self) -> Option> { - if self.message_type() == RpcMessage::NewSerialDeviceResponse { + pub fn message_as_hidsettings_response(&self) -> Option> { + if self.message_type() == RpcMessage::HIDSettingsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { NewSerialDeviceResponse::init_from_table(t) } + unsafe { HIDSettingsResponse::init_from_table(t) } }) } else { None @@ -536,13 +536,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_start_wifi_provisioning_request(&self) -> Option> { - if self.message_type() == RpcMessage::StartWifiProvisioningRequest { + pub fn message_as_change_hidsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeHIDSettingsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StartWifiProvisioningRequest::init_from_table(t) } + unsafe { ChangeHIDSettingsRequest::init_from_table(t) } }) } else { None @@ -551,13 +551,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_stop_wifi_provisioning_request(&self) -> Option> { - if self.message_type() == RpcMessage::StopWifiProvisioningRequest { + pub fn message_as_record_bvhrequest(&self) -> Option> { + if self.message_type() == RpcMessage::RecordBVHRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StopWifiProvisioningRequest::init_from_table(t) } + unsafe { RecordBVHRequest::init_from_table(t) } }) } else { None @@ -566,13 +566,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_wifi_provisioning_status_response(&self) -> Option> { - if self.message_type() == RpcMessage::WifiProvisioningStatusResponse { + pub fn message_as_record_bvhstatus(&self) -> Option> { + if self.message_type() == RpcMessage::RecordBVHStatus { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { WifiProvisioningStatusResponse::init_from_table(t) } + unsafe { RecordBVHStatus::init_from_table(t) } }) } else { None @@ -581,13 +581,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_server_infos_request(&self) -> Option> { - if self.message_type() == RpcMessage::ServerInfosRequest { + pub fn message_as_skeleton_proportions_request(&self) -> Option> { + if self.message_type() == RpcMessage::SkeletonProportionsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ServerInfosRequest::init_from_table(t) } + unsafe { SkeletonProportionsRequest::init_from_table(t) } }) } else { None @@ -596,13 +596,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_server_infos_response(&self) -> Option> { - if self.message_type() == RpcMessage::ServerInfosResponse { + pub fn message_as_change_skeleton_proportions_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeSkeletonProportionsRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ServerInfosResponse::init_from_table(t) } + unsafe { ChangeSkeletonProportionsRequest::init_from_table(t) } }) } else { None @@ -611,13 +611,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_leg_tweaks_tmp_change(&self) -> Option> { - if self.message_type() == RpcMessage::LegTweaksTmpChange { + pub fn message_as_skeleton_proportions_reset_all_request(&self) -> Option> { + if self.message_type() == RpcMessage::SkeletonProportionsResetAllRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { LegTweaksTmpChange::init_from_table(t) } + unsafe { SkeletonProportionsResetAllRequest::init_from_table(t) } }) } else { None @@ -626,13 +626,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_leg_tweaks_tmp_clear(&self) -> Option> { - if self.message_type() == RpcMessage::LegTweaksTmpClear { + pub fn message_as_skeleton_proportions_response(&self) -> Option> { + if self.message_type() == RpcMessage::SkeletonProportionsResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { LegTweaksTmpClear::init_from_table(t) } + unsafe { SkeletonProportionsResponse::init_from_table(t) } }) } else { None @@ -641,13 +641,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_tap_detection_setup_notification(&self) -> Option> { - if self.message_type() == RpcMessage::TapDetectionSetupNotification { + pub fn message_as_open_serial_request(&self) -> Option> { + if self.message_type() == RpcMessage::OpenSerialRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { TapDetectionSetupNotification::init_from_table(t) } + unsafe { OpenSerialRequest::init_from_table(t) } }) } else { None @@ -656,13 +656,28 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_set_pause_tracking_request(&self) -> Option> { - if self.message_type() == RpcMessage::SetPauseTrackingRequest { + pub fn message_as_close_serial_request(&self) -> Option> { + if self.message_type() == RpcMessage::CloseSerialRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { SetPauseTrackingRequest::init_from_table(t) } + unsafe { CloseSerialRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_update_response(&self) -> Option> { + if self.message_type() == RpcMessage::SerialUpdateResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialUpdateResponse::init_from_table(t) } }) } else { None @@ -671,13 +686,238 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_status_system_request(&self) -> Option> { - if self.message_type() == RpcMessage::StatusSystemRequest { + pub fn message_as_auto_bone_process_request(&self) -> Option> { + if self.message_type() == RpcMessage::AutoBoneProcessRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { AutoBoneProcessRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_auto_bone_process_status_response(&self) -> Option> { + if self.message_type() == RpcMessage::AutoBoneProcessStatusResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { AutoBoneProcessStatusResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_auto_bone_epoch_response(&self) -> Option> { + if self.message_type() == RpcMessage::AutoBoneEpochResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { AutoBoneEpochResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_overlay_display_mode_request(&self) -> Option> { + if self.message_type() == RpcMessage::OverlayDisplayModeRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { OverlayDisplayModeRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_overlay_display_mode_change_request(&self) -> Option> { + if self.message_type() == RpcMessage::OverlayDisplayModeChangeRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StatusSystemRequest::init_from_table(t) } + unsafe { OverlayDisplayModeChangeRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_overlay_display_mode_response(&self) -> Option> { + if self.message_type() == RpcMessage::OverlayDisplayModeResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { OverlayDisplayModeResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_tracker_reboot_request(&self) -> Option> { + if self.message_type() == RpcMessage::SerialTrackerRebootRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialTrackerRebootRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_tracker_get_info_request(&self) -> Option> { + if self.message_type() == RpcMessage::SerialTrackerGetInfoRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialTrackerGetInfoRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_tracker_factory_reset_request(&self) -> Option> { + if self.message_type() == RpcMessage::SerialTrackerFactoryResetRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialTrackerFactoryResetRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_devices_request(&self) -> Option> { + if self.message_type() == RpcMessage::SerialDevicesRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialDevicesRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_serial_devices_response(&self) -> Option> { + if self.message_type() == RpcMessage::SerialDevicesResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { SerialDevicesResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_new_serial_device_response(&self) -> Option> { + if self.message_type() == RpcMessage::NewSerialDeviceResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { NewSerialDeviceResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_start_wifi_provisioning_request(&self) -> Option> { + if self.message_type() == RpcMessage::StartWifiProvisioningRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { StartWifiProvisioningRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_stop_wifi_provisioning_request(&self) -> Option> { + if self.message_type() == RpcMessage::StopWifiProvisioningRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { StopWifiProvisioningRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_wifi_provisioning_status_response(&self) -> Option> { + if self.message_type() == RpcMessage::WifiProvisioningStatusResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { WifiProvisioningStatusResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_server_infos_request(&self) -> Option> { + if self.message_type() == RpcMessage::ServerInfosRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { ServerInfosRequest::init_from_table(t) } }) } else { None @@ -686,13 +926,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_status_system_response(&self) -> Option> { - if self.message_type() == RpcMessage::StatusSystemResponse { + pub fn message_as_server_infos_response(&self) -> Option> { + if self.message_type() == RpcMessage::ServerInfosResponse { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StatusSystemResponse::init_from_table(t) } + unsafe { ServerInfosResponse::init_from_table(t) } }) } else { None @@ -701,13 +941,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_status_system_update(&self) -> Option> { - if self.message_type() == RpcMessage::StatusSystemUpdate { + pub fn message_as_leg_tweaks_tmp_change(&self) -> Option> { + if self.message_type() == RpcMessage::LegTweaksTmpChange { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StatusSystemUpdate::init_from_table(t) } + unsafe { LegTweaksTmpChange::init_from_table(t) } }) } else { None @@ -716,13 +956,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_status_system_fixed(&self) -> Option> { - if self.message_type() == RpcMessage::StatusSystemFixed { + pub fn message_as_leg_tweaks_tmp_clear(&self) -> Option> { + if self.message_type() == RpcMessage::LegTweaksTmpClear { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { StatusSystemFixed::init_from_table(t) } + unsafe { LegTweaksTmpClear::init_from_table(t) } }) } else { None @@ -731,13 +971,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_clear_mounting_reset_request(&self) -> Option> { - if self.message_type() == RpcMessage::ClearMountingResetRequest { + pub fn message_as_tap_detection_setup_notification(&self) -> Option> { + if self.message_type() == RpcMessage::TapDetectionSetupNotification { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { ClearMountingResetRequest::init_from_table(t) } + unsafe { TapDetectionSetupNotification::init_from_table(t) } }) } else { None @@ -746,13 +986,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_height_request(&self) -> Option> { - if self.message_type() == RpcMessage::HeightRequest { + pub fn message_as_set_pause_tracking_request(&self) -> Option> { + if self.message_type() == RpcMessage::SetPauseTrackingRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { HeightRequest::init_from_table(t) } + unsafe { SetPauseTrackingRequest::init_from_table(t) } }) } else { None @@ -761,13 +1001,13 @@ impl<'a> RpcMessageHeader<'a> { #[inline] #[allow(non_snake_case)] - pub fn message_as_height_response(&self) -> Option> { - if self.message_type() == RpcMessage::HeightResponse { + pub fn message_as_clear_mounting_reset_request(&self) -> Option> { + if self.message_type() == RpcMessage::ClearMountingResetRequest { self.message().map(|t| { // Safety: // Created from a valid Table for this object // Which contains a valid union in this slot - unsafe { HeightResponse::init_from_table(t) } + unsafe { ClearMountingResetRequest::init_from_table(t) } }) } else { None @@ -1239,6 +1479,81 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_vrcoscsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::VRCOSCSettingsRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VRCOSCSettingsRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_vrcoscsettings_response(&self) -> Option> { + if self.message_type() == RpcMessage::VRCOSCSettingsResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VRCOSCSettingsResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_change_vrcoscsettings_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeVRCOSCSettingsRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { ChangeVRCOSCSettingsRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_vrcoscstatus_request(&self) -> Option> { + if self.message_type() == RpcMessage::VRCOSCStatusRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VRCOSCStatusRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_vrcoscstatus_change_response(&self) -> Option> { + if self.message_type() == RpcMessage::VRCOSCStatusChangeResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VRCOSCStatusChangeResponse::init_from_table(t) } + }) + } else { + None + } + } + #[inline] #[allow(non_snake_case)] pub fn message_as_keybind_request(&self) -> Option> { @@ -1376,19 +1691,41 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::ResetRequest => v.verify_union_variant::>("RpcMessage::ResetRequest", pos), RpcMessage::ResetResponse => v.verify_union_variant::>("RpcMessage::ResetResponse", pos), RpcMessage::AssignTrackerRequest => v.verify_union_variant::>("RpcMessage::AssignTrackerRequest", pos), - RpcMessage::SettingsRequest => v.verify_union_variant::>("RpcMessage::SettingsRequest", pos), - RpcMessage::SettingsResponse => v.verify_union_variant::>("RpcMessage::SettingsResponse", pos), - RpcMessage::ChangeSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeSettingsRequest", pos), - RpcMessage::ClearDriftCompensationRequest => v.verify_union_variant::>("RpcMessage::ClearDriftCompensationRequest", pos), + RpcMessage::OutputTrackersSettingsRequest => v.verify_union_variant::>("RpcMessage::OutputTrackersSettingsRequest", pos), + RpcMessage::OutputTrackersSettingsResponse => v.verify_union_variant::>("RpcMessage::OutputTrackersSettingsResponse", pos), + RpcMessage::ChangeOutputTrackersSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeOutputTrackersSettingsRequest", pos), + RpcMessage::VMCOSCSettingsRequest => v.verify_union_variant::>("RpcMessage::VMCOSCSettingsRequest", pos), + RpcMessage::VMCOSCSettingsResponse => v.verify_union_variant::>("RpcMessage::VMCOSCSettingsResponse", pos), + RpcMessage::ChangeVMCOSCSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeVMCOSCSettingsRequest", pos), + RpcMessage::VRMSettingsRequest => v.verify_union_variant::>("RpcMessage::VRMSettingsRequest", pos), + RpcMessage::VRMSettingsResponse => v.verify_union_variant::>("RpcMessage::VRMSettingsResponse", pos), + RpcMessage::ChangeVRMSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeVRMSettingsRequest", pos), + RpcMessage::SkeletonSettingsRequest => v.verify_union_variant::>("RpcMessage::SkeletonSettingsRequest", pos), + RpcMessage::SkeletonSettingsResponse => v.verify_union_variant::>("RpcMessage::SkeletonSettingsResponse", pos), + RpcMessage::ChangeSkeletonSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeSkeletonSettingsRequest", pos), + RpcMessage::TapDetectionSettingsRequest => v.verify_union_variant::>("RpcMessage::TapDetectionSettingsRequest", pos), + RpcMessage::TapDetectionSettingsResponse => v.verify_union_variant::>("RpcMessage::TapDetectionSettingsResponse", pos), + RpcMessage::ChangeTapDetectionSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeTapDetectionSettingsRequest", pos), + RpcMessage::TapDetectionSetupModeRequest => v.verify_union_variant::>("RpcMessage::TapDetectionSetupModeRequest", pos), + RpcMessage::ResetsSettingsRequest => v.verify_union_variant::>("RpcMessage::ResetsSettingsRequest", pos), + RpcMessage::ResetsSettingsResponse => v.verify_union_variant::>("RpcMessage::ResetsSettingsResponse", pos), + RpcMessage::ChangeResetsSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeResetsSettingsRequest", pos), + RpcMessage::StayAlignedSettingsRequest => v.verify_union_variant::>("RpcMessage::StayAlignedSettingsRequest", pos), + RpcMessage::StayAlignedSettingsResponse => v.verify_union_variant::>("RpcMessage::StayAlignedSettingsResponse", pos), + RpcMessage::ChangeStayAlignedSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeStayAlignedSettingsRequest", pos), + RpcMessage::CompleteStayAlignedResponse => v.verify_union_variant::>("RpcMessage::CompleteStayAlignedResponse", pos), + RpcMessage::StayAlignedHideCorrectionRequest => v.verify_union_variant::>("RpcMessage::StayAlignedHideCorrectionRequest", pos), + RpcMessage::HIDSettingsRequest => v.verify_union_variant::>("RpcMessage::HIDSettingsRequest", pos), + RpcMessage::HIDSettingsResponse => v.verify_union_variant::>("RpcMessage::HIDSettingsResponse", pos), + RpcMessage::ChangeHIDSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeHIDSettingsRequest", pos), RpcMessage::RecordBVHRequest => v.verify_union_variant::>("RpcMessage::RecordBVHRequest", pos), RpcMessage::RecordBVHStatus => v.verify_union_variant::>("RpcMessage::RecordBVHStatus", pos), - RpcMessage::SkeletonConfigRequest => v.verify_union_variant::>("RpcMessage::SkeletonConfigRequest", pos), - RpcMessage::ChangeSkeletonConfigRequest => v.verify_union_variant::>("RpcMessage::ChangeSkeletonConfigRequest", pos), - RpcMessage::SkeletonResetAllRequest => v.verify_union_variant::>("RpcMessage::SkeletonResetAllRequest", pos), - RpcMessage::SkeletonConfigResponse => v.verify_union_variant::>("RpcMessage::SkeletonConfigResponse", pos), + RpcMessage::SkeletonProportionsRequest => v.verify_union_variant::>("RpcMessage::SkeletonProportionsRequest", pos), + RpcMessage::ChangeSkeletonProportionsRequest => v.verify_union_variant::>("RpcMessage::ChangeSkeletonProportionsRequest", pos), + RpcMessage::SkeletonProportionsResetAllRequest => v.verify_union_variant::>("RpcMessage::SkeletonProportionsResetAllRequest", pos), + RpcMessage::SkeletonProportionsResponse => v.verify_union_variant::>("RpcMessage::SkeletonProportionsResponse", pos), RpcMessage::OpenSerialRequest => v.verify_union_variant::>("RpcMessage::OpenSerialRequest", pos), RpcMessage::CloseSerialRequest => v.verify_union_variant::>("RpcMessage::CloseSerialRequest", pos), - RpcMessage::SetWifiRequest => v.verify_union_variant::>("RpcMessage::SetWifiRequest", pos), RpcMessage::SerialUpdateResponse => v.verify_union_variant::>("RpcMessage::SerialUpdateResponse", pos), RpcMessage::AutoBoneProcessRequest => v.verify_union_variant::>("RpcMessage::AutoBoneProcessRequest", pos), RpcMessage::AutoBoneProcessStatusResponse => v.verify_union_variant::>("RpcMessage::AutoBoneProcessStatusResponse", pos), @@ -1411,13 +1748,7 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::LegTweaksTmpClear => v.verify_union_variant::>("RpcMessage::LegTweaksTmpClear", pos), RpcMessage::TapDetectionSetupNotification => v.verify_union_variant::>("RpcMessage::TapDetectionSetupNotification", pos), RpcMessage::SetPauseTrackingRequest => v.verify_union_variant::>("RpcMessage::SetPauseTrackingRequest", pos), - RpcMessage::StatusSystemRequest => v.verify_union_variant::>("RpcMessage::StatusSystemRequest", pos), - RpcMessage::StatusSystemResponse => v.verify_union_variant::>("RpcMessage::StatusSystemResponse", pos), - RpcMessage::StatusSystemUpdate => v.verify_union_variant::>("RpcMessage::StatusSystemUpdate", pos), - RpcMessage::StatusSystemFixed => v.verify_union_variant::>("RpcMessage::StatusSystemFixed", pos), RpcMessage::ClearMountingResetRequest => v.verify_union_variant::>("RpcMessage::ClearMountingResetRequest", pos), - RpcMessage::HeightRequest => v.verify_union_variant::>("RpcMessage::HeightRequest", pos), - RpcMessage::HeightResponse => v.verify_union_variant::>("RpcMessage::HeightResponse", pos), RpcMessage::AutoBoneApplyRequest => v.verify_union_variant::>("RpcMessage::AutoBoneApplyRequest", pos), RpcMessage::AutoBoneStopRecordingRequest => v.verify_union_variant::>("RpcMessage::AutoBoneStopRecordingRequest", pos), RpcMessage::AutoBoneCancelRecordingRequest => v.verify_union_variant::>("RpcMessage::AutoBoneCancelRecordingRequest", pos), @@ -1449,6 +1780,11 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::StartUserHeightCalibration => v.verify_union_variant::>("RpcMessage::StartUserHeightCalibration", pos), RpcMessage::CancelUserHeightCalibration => v.verify_union_variant::>("RpcMessage::CancelUserHeightCalibration", pos), RpcMessage::UserHeightRecordingStatusResponse => v.verify_union_variant::>("RpcMessage::UserHeightRecordingStatusResponse", pos), + RpcMessage::VRCOSCSettingsRequest => v.verify_union_variant::>("RpcMessage::VRCOSCSettingsRequest", pos), + RpcMessage::VRCOSCSettingsResponse => v.verify_union_variant::>("RpcMessage::VRCOSCSettingsResponse", pos), + RpcMessage::ChangeVRCOSCSettingsRequest => v.verify_union_variant::>("RpcMessage::ChangeVRCOSCSettingsRequest", pos), + RpcMessage::VRCOSCStatusRequest => v.verify_union_variant::>("RpcMessage::VRCOSCStatusRequest", pos), + RpcMessage::VRCOSCStatusChangeResponse => v.verify_union_variant::>("RpcMessage::VRCOSCStatusChangeResponse", pos), RpcMessage::KeybindRequest => v.verify_union_variant::>("RpcMessage::KeybindRequest", pos), RpcMessage::ChangeKeybindRequest => v.verify_union_variant::>("RpcMessage::ChangeKeybindRequest", pos), RpcMessage::KeybindResponse => v.verify_union_variant::>("RpcMessage::KeybindResponse", pos), @@ -1553,29 +1889,190 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SettingsRequest => { - if let Some(x) = self.message_as_settings_request() { + RpcMessage::OutputTrackersSettingsRequest => { + if let Some(x) = self.message_as_output_trackers_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::OutputTrackersSettingsResponse => { + if let Some(x) = self.message_as_output_trackers_settings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeOutputTrackersSettingsRequest => { + if let Some(x) = self.message_as_change_output_trackers_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VMCOSCSettingsRequest => { + if let Some(x) = self.message_as_vmcoscsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VMCOSCSettingsResponse => { + if let Some(x) = self.message_as_vmcoscsettings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeVMCOSCSettingsRequest => { + if let Some(x) = self.message_as_change_vmcoscsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VRMSettingsRequest => { + if let Some(x) = self.message_as_vrmsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VRMSettingsResponse => { + if let Some(x) = self.message_as_vrmsettings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeVRMSettingsRequest => { + if let Some(x) = self.message_as_change_vrmsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::SkeletonSettingsRequest => { + if let Some(x) = self.message_as_skeleton_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::SkeletonSettingsResponse => { + if let Some(x) = self.message_as_skeleton_settings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeSkeletonSettingsRequest => { + if let Some(x) = self.message_as_change_skeleton_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::TapDetectionSettingsRequest => { + if let Some(x) = self.message_as_tap_detection_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::TapDetectionSettingsResponse => { + if let Some(x) = self.message_as_tap_detection_settings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeTapDetectionSettingsRequest => { + if let Some(x) = self.message_as_change_tap_detection_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::TapDetectionSetupModeRequest => { + if let Some(x) = self.message_as_tap_detection_setup_mode_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ResetsSettingsRequest => { + if let Some(x) = self.message_as_resets_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ResetsSettingsResponse => { + if let Some(x) = self.message_as_resets_settings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeResetsSettingsRequest => { + if let Some(x) = self.message_as_change_resets_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::StayAlignedSettingsRequest => { + if let Some(x) = self.message_as_stay_aligned_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::StayAlignedSettingsResponse => { + if let Some(x) = self.message_as_stay_aligned_settings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeStayAlignedSettingsRequest => { + if let Some(x) = self.message_as_change_stay_aligned_settings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::CompleteStayAlignedResponse => { + if let Some(x) = self.message_as_complete_stay_aligned_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::StayAlignedHideCorrectionRequest => { + if let Some(x) = self.message_as_stay_aligned_hide_correction_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SettingsResponse => { - if let Some(x) = self.message_as_settings_response() { + RpcMessage::HIDSettingsRequest => { + if let Some(x) = self.message_as_hidsettings_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::ChangeSettingsRequest => { - if let Some(x) = self.message_as_change_settings_request() { + RpcMessage::HIDSettingsResponse => { + if let Some(x) = self.message_as_hidsettings_response() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::ClearDriftCompensationRequest => { - if let Some(x) = self.message_as_clear_drift_compensation_request() { + RpcMessage::ChangeHIDSettingsRequest => { + if let Some(x) = self.message_as_change_hidsettings_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") @@ -1595,29 +2092,29 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SkeletonConfigRequest => { - if let Some(x) = self.message_as_skeleton_config_request() { + RpcMessage::SkeletonProportionsRequest => { + if let Some(x) = self.message_as_skeleton_proportions_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::ChangeSkeletonConfigRequest => { - if let Some(x) = self.message_as_change_skeleton_config_request() { + RpcMessage::ChangeSkeletonProportionsRequest => { + if let Some(x) = self.message_as_change_skeleton_proportions_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SkeletonResetAllRequest => { - if let Some(x) = self.message_as_skeleton_reset_all_request() { + RpcMessage::SkeletonProportionsResetAllRequest => { + if let Some(x) = self.message_as_skeleton_proportions_reset_all_request() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SkeletonConfigResponse => { - if let Some(x) = self.message_as_skeleton_config_response() { + RpcMessage::SkeletonProportionsResponse => { + if let Some(x) = self.message_as_skeleton_proportions_response() { ds.field("message", &x) } else { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") @@ -1637,13 +2134,6 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::SetWifiRequest => { - if let Some(x) = self.message_as_set_wifi_request() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, RpcMessage::SerialUpdateResponse => { if let Some(x) = self.message_as_serial_update_response() { ds.field("message", &x) @@ -1798,34 +2288,6 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::StatusSystemRequest => { - if let Some(x) = self.message_as_status_system_request() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - RpcMessage::StatusSystemResponse => { - if let Some(x) = self.message_as_status_system_response() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - RpcMessage::StatusSystemUpdate => { - if let Some(x) = self.message_as_status_system_update() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - RpcMessage::StatusSystemFixed => { - if let Some(x) = self.message_as_status_system_fixed() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, RpcMessage::ClearMountingResetRequest => { if let Some(x) = self.message_as_clear_mounting_reset_request() { ds.field("message", &x) @@ -1833,20 +2295,6 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, - RpcMessage::HeightRequest => { - if let Some(x) = self.message_as_height_request() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - RpcMessage::HeightResponse => { - if let Some(x) = self.message_as_height_response() { - ds.field("message", &x) - } else { - ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, RpcMessage::AutoBoneApplyRequest => { if let Some(x) = self.message_as_auto_bone_apply_request() { ds.field("message", &x) @@ -2064,6 +2512,41 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::VRCOSCSettingsRequest => { + if let Some(x) = self.message_as_vrcoscsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VRCOSCSettingsResponse => { + if let Some(x) = self.message_as_vrcoscsettings_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeVRCOSCSettingsRequest => { + if let Some(x) = self.message_as_change_vrcoscsettings_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VRCOSCStatusRequest => { + if let Some(x) = self.message_as_vrcoscstatus_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VRCOSCStatusChangeResponse => { + if let Some(x) = self.message_as_vrcoscstatus_change_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, RpcMessage::KeybindRequest => { if let Some(x) = self.message_as_keybind_request() { ds.field("message", &x) diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/save_file_notification_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/save_file_notification_generated.rs index d3b2204fb..d5f249e06 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/save_file_notification_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/save_file_notification_generated.rs @@ -28,7 +28,7 @@ impl<'a> flatbuffers::Follow<'a> for SaveFileNotification<'a> { impl<'a> SaveFileNotification<'a> { pub const VT_DATA: flatbuffers::VOffsetT = 4; pub const VT_MIME_TYPE: flatbuffers::VOffsetT = 6; - pub const VT_FILE_EXTENSION: flatbuffers::VOffsetT = 8; + pub const VT_EXTENSION: flatbuffers::VOffsetT = 8; pub const VT_EXPECTED_DIR: flatbuffers::VOffsetT = 10; pub const VT_EXPECTED_FILENAME: flatbuffers::VOffsetT = 12; @@ -43,7 +43,7 @@ impl<'a> SaveFileNotification<'a> { ) -> flatbuffers::WIPOffset> { let mut builder = SaveFileNotificationBuilder::new(_fbb); if let Some(x) = args.expected_filename { builder.add_expected_filename(x); } - if let Some(x) = args.file_extension { builder.add_file_extension(x); } + if let Some(x) = args.extension { builder.add_extension(x); } if let Some(x) = args.mime_type { builder.add_mime_type(x); } if let Some(x) = args.data { builder.add_data(x); } if let Some(x) = args.expected_dir { builder.add_expected_dir(x); } @@ -59,7 +59,7 @@ impl<'a> SaveFileNotification<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>>(SaveFileNotification::VT_DATA, None)} } - /// MIME type of file if one exists, use `file_extension` otherwise + /// MIME type of file if one exists, use `extension` otherwise #[inline] pub fn mime_type(&self) -> Option<&'a str> { // Safety: @@ -69,11 +69,11 @@ impl<'a> SaveFileNotification<'a> { } /// Use MIME type preferably if one exists #[inline] - pub fn file_extension(&self) -> Option<&'a str> { + pub fn extension(&self) -> Option<&'a str> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(SaveFileNotification::VT_FILE_EXTENSION, None)} + unsafe { self._tab.get::>(SaveFileNotification::VT_EXTENSION, None)} } /// Directory recommended to save the file on #[inline] @@ -102,7 +102,7 @@ impl flatbuffers::Verifiable for SaveFileNotification<'_> { v.visit_table(pos)? .visit_field::>>("data", Self::VT_DATA, false)? .visit_field::>("mime_type", Self::VT_MIME_TYPE, false)? - .visit_field::>("file_extension", Self::VT_FILE_EXTENSION, false)? + .visit_field::>("extension", Self::VT_EXTENSION, false)? .visit_field::("expected_dir", Self::VT_EXPECTED_DIR, false)? .visit_field::>("expected_filename", Self::VT_EXPECTED_FILENAME, false)? .finish(); @@ -112,7 +112,7 @@ impl flatbuffers::Verifiable for SaveFileNotification<'_> { pub struct SaveFileNotificationArgs<'a> { pub data: Option>>, pub mime_type: Option>, - pub file_extension: Option>, + pub extension: Option>, pub expected_dir: Option, pub expected_filename: Option>, } @@ -122,7 +122,7 @@ impl<'a> Default for SaveFileNotificationArgs<'a> { SaveFileNotificationArgs { data: None, mime_type: None, - file_extension: None, + extension: None, expected_dir: None, expected_filename: None, } @@ -143,8 +143,8 @@ impl<'a: 'b, 'b> SaveFileNotificationBuilder<'a, 'b> { self.fbb_.push_slot_always::>(SaveFileNotification::VT_MIME_TYPE, mime_type); } #[inline] - pub fn add_file_extension(&mut self, file_extension: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(SaveFileNotification::VT_FILE_EXTENSION, file_extension); + pub fn add_extension(&mut self, extension: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(SaveFileNotification::VT_EXTENSION, extension); } #[inline] pub fn add_expected_dir(&mut self, expected_dir: ComputerDirectory) { @@ -174,7 +174,7 @@ impl core::fmt::Debug for SaveFileNotification<'_> { let mut ds = f.debug_struct("SaveFileNotification"); ds.field("data", &self.data()); ds.field("mime_type", &self.mime_type()); - ds.field("file_extension", &self.file_extension()); + ds.field("extension", &self.extension()); ds.field("expected_dir", &self.expected_dir()); ds.field("expected_filename", &self.expected_filename()); ds.finish() diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/serial_firmware_update_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/serial_firmware_update_generated.rs index 70b3e5996..b22902b50 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/serial_firmware_update_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/serial_firmware_update_generated.rs @@ -26,7 +26,7 @@ impl<'a> flatbuffers::Follow<'a> for SerialFirmwareUpdate<'a> { impl<'a> SerialFirmwareUpdate<'a> { pub const VT_DEVICE_ID: flatbuffers::VOffsetT = 4; - pub const VT_NEEDMANUALREBOOT: flatbuffers::VOffsetT = 6; + pub const VT_NEED_MANUAL_REBOOT: flatbuffers::VOffsetT = 6; pub const VT_SSID: flatbuffers::VOffsetT = 8; pub const VT_PASSWORD: flatbuffers::VOffsetT = 10; pub const VT_FIRMWARE_PART: flatbuffers::VOffsetT = 12; @@ -45,7 +45,7 @@ impl<'a> SerialFirmwareUpdate<'a> { if let Some(x) = args.password { builder.add_password(x); } if let Some(x) = args.ssid { builder.add_ssid(x); } if let Some(x) = args.device_id { builder.add_device_id(x); } - builder.add_needManualReboot(args.needManualReboot); + builder.add_need_manual_reboot(args.need_manual_reboot); builder.finish() } @@ -61,11 +61,11 @@ impl<'a> SerialFirmwareUpdate<'a> { /// Will make the server ask for the tracker to be manually rebooted by the user /// after the tracker is done flashing #[inline] - pub fn needManualReboot(&self) -> bool { + pub fn need_manual_reboot(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(SerialFirmwareUpdate::VT_NEEDMANUALREBOOT, Some(false)).unwrap()} + unsafe { self._tab.get::(SerialFirmwareUpdate::VT_NEED_MANUAL_REBOOT, Some(false)).unwrap()} } /// Credentials to provision after the flashing /// Only used with Serial flashing, because OTA is already connected to the wifi @@ -101,7 +101,7 @@ impl flatbuffers::Verifiable for SerialFirmwareUpdate<'_> { use self::flatbuffers::Verifiable; v.visit_table(pos)? .visit_field::>("device_id", Self::VT_DEVICE_ID, false)? - .visit_field::("needManualReboot", Self::VT_NEEDMANUALREBOOT, false)? + .visit_field::("need_manual_reboot", Self::VT_NEED_MANUAL_REBOOT, false)? .visit_field::>("ssid", Self::VT_SSID, false)? .visit_field::>("password", Self::VT_PASSWORD, false)? .visit_field::>>>("firmware_part", Self::VT_FIRMWARE_PART, false)? @@ -111,7 +111,7 @@ impl flatbuffers::Verifiable for SerialFirmwareUpdate<'_> { } pub struct SerialFirmwareUpdateArgs<'a> { pub device_id: Option>>, - pub needManualReboot: bool, + pub need_manual_reboot: bool, pub ssid: Option>, pub password: Option>, pub firmware_part: Option>>>>, @@ -121,7 +121,7 @@ impl<'a> Default for SerialFirmwareUpdateArgs<'a> { fn default() -> Self { SerialFirmwareUpdateArgs { device_id: None, - needManualReboot: false, + need_manual_reboot: false, ssid: None, password: None, firmware_part: None, @@ -139,8 +139,8 @@ impl<'a: 'b, 'b> SerialFirmwareUpdateBuilder<'a, 'b> { self.fbb_.push_slot_always::>(SerialFirmwareUpdate::VT_DEVICE_ID, device_id); } #[inline] - pub fn add_needManualReboot(&mut self, needManualReboot: bool) { - self.fbb_.push_slot::(SerialFirmwareUpdate::VT_NEEDMANUALREBOOT, needManualReboot, false); + pub fn add_need_manual_reboot(&mut self, need_manual_reboot: bool) { + self.fbb_.push_slot::(SerialFirmwareUpdate::VT_NEED_MANUAL_REBOOT, need_manual_reboot, false); } #[inline] pub fn add_ssid(&mut self, ssid: flatbuffers::WIPOffset<&'b str>) { @@ -173,7 +173,7 @@ impl core::fmt::Debug for SerialFirmwareUpdate<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("SerialFirmwareUpdate"); ds.field("device_id", &self.device_id()); - ds.field("needManualReboot", &self.needManualReboot()); + ds.field("need_manual_reboot", &self.need_manual_reboot()); ds.field("ssid", &self.ssid()); ds.field("password", &self.password()); ds.field("firmware_part", &self.firmware_part()); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/server_infos_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/server_infos_response_generated.rs index c3610f72a..b5fbbf896 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/server_infos_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/server_infos_response_generated.rs @@ -29,7 +29,7 @@ impl<'a> flatbuffers::Follow<'a> for ServerInfosResponse<'a> { } impl<'a> ServerInfosResponse<'a> { - pub const VT_LOCALIP: flatbuffers::VOffsetT = 4; + pub const VT_LOCAL_IP: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -41,17 +41,17 @@ impl<'a> ServerInfosResponse<'a> { args: &'args ServerInfosResponseArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = ServerInfosResponseBuilder::new(_fbb); - if let Some(x) = args.localIp { builder.add_localIp(x); } + if let Some(x) = args.local_ip { builder.add_local_ip(x); } builder.finish() } #[inline] - pub fn localIp(&self) -> Option<&'a str> { + pub fn local_ip(&self) -> Option<&'a str> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ServerInfosResponse::VT_LOCALIP, None)} + unsafe { self._tab.get::>(ServerInfosResponse::VT_LOCAL_IP, None)} } } @@ -62,19 +62,19 @@ impl flatbuffers::Verifiable for ServerInfosResponse<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("localIp", Self::VT_LOCALIP, false)? + .visit_field::>("local_ip", Self::VT_LOCAL_IP, false)? .finish(); Ok(()) } } pub struct ServerInfosResponseArgs<'a> { - pub localIp: Option>, + pub local_ip: Option>, } impl<'a> Default for ServerInfosResponseArgs<'a> { #[inline] fn default() -> Self { ServerInfosResponseArgs { - localIp: None, + local_ip: None, } } } @@ -85,8 +85,8 @@ pub struct ServerInfosResponseBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> ServerInfosResponseBuilder<'a, 'b> { #[inline] - pub fn add_localIp(&mut self, localIp: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(ServerInfosResponse::VT_LOCALIP, localIp); + pub fn add_local_ip(&mut self, local_ip: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ServerInfosResponse::VT_LOCAL_IP, local_ip); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ServerInfosResponseBuilder<'a, 'b> { @@ -106,7 +106,7 @@ impl<'a: 'b, 'b> ServerInfosResponseBuilder<'a, 'b> { impl core::fmt::Debug for ServerInfosResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("ServerInfosResponse"); - ds.field("localIp", &self.localIp()); + ds.field("local_ip", &self.local_ip()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/set_pause_tracking_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/set_pause_tracking_request_generated.rs index 9a62544bb..0453eec6b 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/set_pause_tracking_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/set_pause_tracking_request_generated.rs @@ -25,7 +25,7 @@ impl<'a> flatbuffers::Follow<'a> for SetPauseTrackingRequest<'a> { } impl<'a> SetPauseTrackingRequest<'a> { - pub const VT_PAUSETRACKING: flatbuffers::VOffsetT = 4; + pub const VT_PAUSE_TRACKING: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -37,18 +37,18 @@ impl<'a> SetPauseTrackingRequest<'a> { args: &'args SetPauseTrackingRequestArgs ) -> flatbuffers::WIPOffset> { let mut builder = SetPauseTrackingRequestBuilder::new(_fbb); - builder.add_pauseTracking(args.pauseTracking); + builder.add_pause_tracking(args.pause_tracking); builder.finish() } /// Pauses skeleton tracking if true, resumes skeleton tracking if false. #[inline] - pub fn pauseTracking(&self) -> bool { + pub fn pause_tracking(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(SetPauseTrackingRequest::VT_PAUSETRACKING, Some(false)).unwrap()} + unsafe { self._tab.get::(SetPauseTrackingRequest::VT_PAUSE_TRACKING, Some(false)).unwrap()} } } @@ -59,19 +59,19 @@ impl flatbuffers::Verifiable for SetPauseTrackingRequest<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("pauseTracking", Self::VT_PAUSETRACKING, false)? + .visit_field::("pause_tracking", Self::VT_PAUSE_TRACKING, false)? .finish(); Ok(()) } } pub struct SetPauseTrackingRequestArgs { - pub pauseTracking: bool, + pub pause_tracking: bool, } impl<'a> Default for SetPauseTrackingRequestArgs { #[inline] fn default() -> Self { SetPauseTrackingRequestArgs { - pauseTracking: false, + pause_tracking: false, } } } @@ -82,8 +82,8 @@ pub struct SetPauseTrackingRequestBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> SetPauseTrackingRequestBuilder<'a, 'b> { #[inline] - pub fn add_pauseTracking(&mut self, pauseTracking: bool) { - self.fbb_.push_slot::(SetPauseTrackingRequest::VT_PAUSETRACKING, pauseTracking, false); + pub fn add_pause_tracking(&mut self, pause_tracking: bool) { + self.fbb_.push_slot::(SetPauseTrackingRequest::VT_PAUSE_TRACKING, pause_tracking, false); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SetPauseTrackingRequestBuilder<'a, 'b> { @@ -103,7 +103,7 @@ impl<'a: 'b, 'b> SetPauseTrackingRequestBuilder<'a, 'b> { impl core::fmt::Debug for SetPauseTrackingRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("SetPauseTrackingRequest"); - ds.field("pauseTracking", &self.pauseTracking()); + ds.field("pause_tracking", &self.pause_tracking()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/set_wifi_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/set_wifi_request_generated.rs deleted file mode 100644 index 0e0bee60c..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/set_wifi_request_generated.rs +++ /dev/null @@ -1,125 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum SetWifiRequestOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct SetWifiRequest<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for SetWifiRequest<'a> { - type Inner = SetWifiRequest<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> SetWifiRequest<'a> { - pub const VT_SSID: flatbuffers::VOffsetT = 4; - pub const VT_PASSWORD: flatbuffers::VOffsetT = 6; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SetWifiRequest { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SetWifiRequestArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = SetWifiRequestBuilder::new(_fbb); - if let Some(x) = args.password { builder.add_password(x); } - if let Some(x) = args.ssid { builder.add_ssid(x); } - builder.finish() - } - - - #[inline] - pub fn ssid(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SetWifiRequest::VT_SSID, None)} - } - #[inline] - pub fn password(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SetWifiRequest::VT_PASSWORD, None)} - } -} - -impl flatbuffers::Verifiable for SetWifiRequest<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("ssid", Self::VT_SSID, false)? - .visit_field::>("password", Self::VT_PASSWORD, false)? - .finish(); - Ok(()) - } -} -pub struct SetWifiRequestArgs<'a> { - pub ssid: Option>, - pub password: Option>, -} -impl<'a> Default for SetWifiRequestArgs<'a> { - #[inline] - fn default() -> Self { - SetWifiRequestArgs { - ssid: None, - password: None, - } - } -} - -pub struct SetWifiRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> SetWifiRequestBuilder<'a, 'b> { - #[inline] - pub fn add_ssid(&mut self, ssid: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(SetWifiRequest::VT_SSID, ssid); - } - #[inline] - pub fn add_password(&mut self, password: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(SetWifiRequest::VT_PASSWORD, password); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SetWifiRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - SetWifiRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for SetWifiRequest<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SetWifiRequest"); - ds.field("ssid", &self.ssid()); - ds.field("password", &self.password()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/leg_tweaks_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/settings/leg_tweaks_settings_generated.rs deleted file mode 100644 index 39a24c5c9..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/leg_tweaks_settings_generated.rs +++ /dev/null @@ -1,108 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum LegTweaksSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct LegTweaksSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for LegTweaksSettings<'a> { - type Inner = LegTweaksSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> LegTweaksSettings<'a> { - pub const VT_CORRECTION_STRENGTH: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - LegTweaksSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args LegTweaksSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = LegTweaksSettingsBuilder::new(_fbb); - if let Some(x) = args.correction_strength { builder.add_correction_strength(x); } - builder.finish() - } - - - #[inline] - pub fn correction_strength(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(LegTweaksSettings::VT_CORRECTION_STRENGTH, None)} - } -} - -impl flatbuffers::Verifiable for LegTweaksSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("correction_strength", Self::VT_CORRECTION_STRENGTH, false)? - .finish(); - Ok(()) - } -} -pub struct LegTweaksSettingsArgs { - pub correction_strength: Option, -} -impl<'a> Default for LegTweaksSettingsArgs { - #[inline] - fn default() -> Self { - LegTweaksSettingsArgs { - correction_strength: None, - } - } -} - -pub struct LegTweaksSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> LegTweaksSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_correction_strength(&mut self, correction_strength: f32) { - self.fbb_.push_slot_always::(LegTweaksSettings::VT_CORRECTION_STRENGTH, correction_strength); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LegTweaksSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - LegTweaksSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for LegTweaksSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("LegTweaksSettings"); - ds.field("correction_strength", &self.correction_strength()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_ratios_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_ratios_generated.rs deleted file mode 100644 index 6af212321..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_ratios_generated.rs +++ /dev/null @@ -1,215 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum ModelRatiosOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Settings for the skeletal model that are ratios. -/// These values range from 0 to 1. -pub struct ModelRatios<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for ModelRatios<'a> { - type Inner = ModelRatios<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> ModelRatios<'a> { - pub const VT_IMPUTE_WAIST_FROM_CHEST_HIP: flatbuffers::VOffsetT = 4; - pub const VT_IMPUTE_WAIST_FROM_CHEST_LEGS: flatbuffers::VOffsetT = 6; - pub const VT_IMPUTE_HIP_FROM_CHEST_LEGS: flatbuffers::VOffsetT = 8; - pub const VT_IMPUTE_HIP_FROM_WAIST_LEGS: flatbuffers::VOffsetT = 10; - pub const VT_INTERP_HIP_LEGS: flatbuffers::VOffsetT = 12; - pub const VT_INTERP_KNEE_TRACKER_ANKLE: flatbuffers::VOffsetT = 14; - pub const VT_INTERP_KNEE_ANKLE: flatbuffers::VOffsetT = 16; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ModelRatios { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ModelRatiosArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = ModelRatiosBuilder::new(_fbb); - if let Some(x) = args.interp_knee_ankle { builder.add_interp_knee_ankle(x); } - if let Some(x) = args.interp_knee_tracker_ankle { builder.add_interp_knee_tracker_ankle(x); } - if let Some(x) = args.interp_hip_legs { builder.add_interp_hip_legs(x); } - if let Some(x) = args.impute_hip_from_waist_legs { builder.add_impute_hip_from_waist_legs(x); } - if let Some(x) = args.impute_hip_from_chest_legs { builder.add_impute_hip_from_chest_legs(x); } - if let Some(x) = args.impute_waist_from_chest_legs { builder.add_impute_waist_from_chest_legs(x); } - if let Some(x) = args.impute_waist_from_chest_hip { builder.add_impute_waist_from_chest_hip(x); } - builder.finish() - } - - - #[inline] - pub fn impute_waist_from_chest_hip(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_HIP, None)} - } - #[inline] - pub fn impute_waist_from_chest_legs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_LEGS, None)} - } - #[inline] - pub fn impute_hip_from_chest_legs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_IMPUTE_HIP_FROM_CHEST_LEGS, None)} - } - #[inline] - pub fn impute_hip_from_waist_legs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_IMPUTE_HIP_FROM_WAIST_LEGS, None)} - } - /// Hip's yaw and roll is set to the average of legs when 1.0 - #[inline] - pub fn interp_hip_legs(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_INTERP_HIP_LEGS, None)} - } - /// Knee trackers' yaw and roll is set to the lower leg's when 1.0 - #[inline] - pub fn interp_knee_tracker_ankle(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_INTERP_KNEE_TRACKER_ANKLE, None)} - } - /// Upper leg's yaw and roll is set to the lower leg's when 1.0 - #[inline] - pub fn interp_knee_ankle(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelRatios::VT_INTERP_KNEE_ANKLE, None)} - } -} - -impl flatbuffers::Verifiable for ModelRatios<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("impute_waist_from_chest_hip", Self::VT_IMPUTE_WAIST_FROM_CHEST_HIP, false)? - .visit_field::("impute_waist_from_chest_legs", Self::VT_IMPUTE_WAIST_FROM_CHEST_LEGS, false)? - .visit_field::("impute_hip_from_chest_legs", Self::VT_IMPUTE_HIP_FROM_CHEST_LEGS, false)? - .visit_field::("impute_hip_from_waist_legs", Self::VT_IMPUTE_HIP_FROM_WAIST_LEGS, false)? - .visit_field::("interp_hip_legs", Self::VT_INTERP_HIP_LEGS, false)? - .visit_field::("interp_knee_tracker_ankle", Self::VT_INTERP_KNEE_TRACKER_ANKLE, false)? - .visit_field::("interp_knee_ankle", Self::VT_INTERP_KNEE_ANKLE, false)? - .finish(); - Ok(()) - } -} -pub struct ModelRatiosArgs { - pub impute_waist_from_chest_hip: Option, - pub impute_waist_from_chest_legs: Option, - pub impute_hip_from_chest_legs: Option, - pub impute_hip_from_waist_legs: Option, - pub interp_hip_legs: Option, - pub interp_knee_tracker_ankle: Option, - pub interp_knee_ankle: Option, -} -impl<'a> Default for ModelRatiosArgs { - #[inline] - fn default() -> Self { - ModelRatiosArgs { - impute_waist_from_chest_hip: None, - impute_waist_from_chest_legs: None, - impute_hip_from_chest_legs: None, - impute_hip_from_waist_legs: None, - interp_hip_legs: None, - interp_knee_tracker_ankle: None, - interp_knee_ankle: None, - } - } -} - -pub struct ModelRatiosBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> ModelRatiosBuilder<'a, 'b> { - #[inline] - pub fn add_impute_waist_from_chest_hip(&mut self, impute_waist_from_chest_hip: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_HIP, impute_waist_from_chest_hip); - } - #[inline] - pub fn add_impute_waist_from_chest_legs(&mut self, impute_waist_from_chest_legs: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_IMPUTE_WAIST_FROM_CHEST_LEGS, impute_waist_from_chest_legs); - } - #[inline] - pub fn add_impute_hip_from_chest_legs(&mut self, impute_hip_from_chest_legs: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_IMPUTE_HIP_FROM_CHEST_LEGS, impute_hip_from_chest_legs); - } - #[inline] - pub fn add_impute_hip_from_waist_legs(&mut self, impute_hip_from_waist_legs: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_IMPUTE_HIP_FROM_WAIST_LEGS, impute_hip_from_waist_legs); - } - #[inline] - pub fn add_interp_hip_legs(&mut self, interp_hip_legs: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_INTERP_HIP_LEGS, interp_hip_legs); - } - #[inline] - pub fn add_interp_knee_tracker_ankle(&mut self, interp_knee_tracker_ankle: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_INTERP_KNEE_TRACKER_ANKLE, interp_knee_tracker_ankle); - } - #[inline] - pub fn add_interp_knee_ankle(&mut self, interp_knee_ankle: f32) { - self.fbb_.push_slot_always::(ModelRatios::VT_INTERP_KNEE_ANKLE, interp_knee_ankle); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ModelRatiosBuilder<'a, 'b> { - let start = _fbb.start_table(); - ModelRatiosBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for ModelRatios<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ModelRatios"); - ds.field("impute_waist_from_chest_hip", &self.impute_waist_from_chest_hip()); - ds.field("impute_waist_from_chest_legs", &self.impute_waist_from_chest_legs()); - ds.field("impute_hip_from_chest_legs", &self.impute_hip_from_chest_legs()); - ds.field("impute_hip_from_waist_legs", &self.impute_hip_from_waist_legs()); - ds.field("interp_hip_legs", &self.interp_hip_legs()); - ds.field("interp_knee_tracker_ankle", &self.interp_knee_tracker_ankle()); - ds.field("interp_knee_ankle", &self.interp_knee_ankle()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_reset_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/settings_reset_request_generated.rs index d90f8c930..15b22fb30 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_reset_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/settings_reset_request_generated.rs @@ -12,6 +12,7 @@ use super::*; pub enum SettingsResetRequestOffset {} #[derive(Copy, Clone, PartialEq)] +/// Resets the server settings pub struct SettingsResetRequest<'a> { pub _tab: flatbuffers::Table<'a>, } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/settings_response_generated.rs deleted file mode 100644 index ecc67436a..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_response_generated.rs +++ /dev/null @@ -1,346 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum SettingsResponseOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct SettingsResponse<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for SettingsResponse<'a> { - type Inner = SettingsResponse<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> SettingsResponse<'a> { - pub const VT_STEAM_VR_TRACKERS: flatbuffers::VOffsetT = 4; - pub const VT_FILTERING: flatbuffers::VOffsetT = 6; - pub const VT_DRIFT_COMPENSATION: flatbuffers::VOffsetT = 8; - pub const VT_OSC_ROUTER: flatbuffers::VOffsetT = 10; - pub const VT_VRC_OSC: flatbuffers::VOffsetT = 12; - pub const VT_VMC_OSC: flatbuffers::VOffsetT = 14; - pub const VT_MODEL_SETTINGS: flatbuffers::VOffsetT = 16; - pub const VT_TAP_DETECTION_SETTINGS: flatbuffers::VOffsetT = 18; - pub const VT_AUTO_BONE_SETTINGS: flatbuffers::VOffsetT = 20; - pub const VT_RESETS_SETTINGS: flatbuffers::VOffsetT = 22; - pub const VT_STAY_ALIGNED: flatbuffers::VOffsetT = 24; - pub const VT_HID_SETTINGS: flatbuffers::VOffsetT = 26; - pub const VT_TIMEOUT: flatbuffers::VOffsetT = 28; - pub const VT_VELOCITY_SETTINGS: flatbuffers::VOffsetT = 30; - pub const VT_VRM: flatbuffers::VOffsetT = 32; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SettingsResponse { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SettingsResponseArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = SettingsResponseBuilder::new(_fbb); - if let Some(x) = args.vrm { builder.add_vrm(x); } - if let Some(x) = args.velocity_settings { builder.add_velocity_settings(x); } - if let Some(x) = args.timeout { builder.add_timeout(x); } - if let Some(x) = args.hid_settings { builder.add_hid_settings(x); } - if let Some(x) = args.stay_aligned { builder.add_stay_aligned(x); } - if let Some(x) = args.resets_settings { builder.add_resets_settings(x); } - if let Some(x) = args.auto_bone_settings { builder.add_auto_bone_settings(x); } - if let Some(x) = args.tap_detection_settings { builder.add_tap_detection_settings(x); } - if let Some(x) = args.model_settings { builder.add_model_settings(x); } - if let Some(x) = args.vmc_osc { builder.add_vmc_osc(x); } - if let Some(x) = args.vrc_osc { builder.add_vrc_osc(x); } - if let Some(x) = args.osc_router { builder.add_osc_router(x); } - if let Some(x) = args.drift_compensation { builder.add_drift_compensation(x); } - if let Some(x) = args.filtering { builder.add_filtering(x); } - if let Some(x) = args.steam_vr_trackers { builder.add_steam_vr_trackers(x); } - builder.finish() - } - - - #[inline] - pub fn steam_vr_trackers(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_STEAM_VR_TRACKERS, None)} - } - #[inline] - pub fn filtering(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_FILTERING, None)} - } - #[inline] - pub fn drift_compensation(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_DRIFT_COMPENSATION, None)} - } - #[inline] - pub fn osc_router(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_OSC_ROUTER, None)} - } - #[inline] - pub fn vrc_osc(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_VRC_OSC, None)} - } - #[inline] - pub fn vmc_osc(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_VMC_OSC, None)} - } - #[inline] - pub fn model_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_MODEL_SETTINGS, None)} - } - #[inline] - pub fn tap_detection_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_TAP_DETECTION_SETTINGS, None)} - } - #[inline] - pub fn auto_bone_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_AUTO_BONE_SETTINGS, None)} - } - #[inline] - pub fn resets_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_RESETS_SETTINGS, None)} - } - #[inline] - pub fn stay_aligned(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_STAY_ALIGNED, None)} - } - #[inline] - pub fn hid_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_HID_SETTINGS, None)} - } - #[inline] - pub fn timeout(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_TIMEOUT, None)} - } - #[inline] - pub fn velocity_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_VELOCITY_SETTINGS, None)} - } - #[inline] - pub fn vrm(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(SettingsResponse::VT_VRM, None)} - } -} - -impl flatbuffers::Verifiable for SettingsResponse<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("steam_vr_trackers", Self::VT_STEAM_VR_TRACKERS, false)? - .visit_field::>("filtering", Self::VT_FILTERING, false)? - .visit_field::>("drift_compensation", Self::VT_DRIFT_COMPENSATION, false)? - .visit_field::>("osc_router", Self::VT_OSC_ROUTER, false)? - .visit_field::>("vrc_osc", Self::VT_VRC_OSC, false)? - .visit_field::>("vmc_osc", Self::VT_VMC_OSC, false)? - .visit_field::>("model_settings", Self::VT_MODEL_SETTINGS, false)? - .visit_field::>("tap_detection_settings", Self::VT_TAP_DETECTION_SETTINGS, false)? - .visit_field::>("auto_bone_settings", Self::VT_AUTO_BONE_SETTINGS, false)? - .visit_field::>("resets_settings", Self::VT_RESETS_SETTINGS, false)? - .visit_field::>("stay_aligned", Self::VT_STAY_ALIGNED, false)? - .visit_field::>("hid_settings", Self::VT_HID_SETTINGS, false)? - .visit_field::>("timeout", Self::VT_TIMEOUT, false)? - .visit_field::>("velocity_settings", Self::VT_VELOCITY_SETTINGS, false)? - .visit_field::>("vrm", Self::VT_VRM, false)? - .finish(); - Ok(()) - } -} -pub struct SettingsResponseArgs<'a> { - pub steam_vr_trackers: Option>>, - pub filtering: Option>>, - pub drift_compensation: Option>>, - pub osc_router: Option>>, - pub vrc_osc: Option>>, - pub vmc_osc: Option>>, - pub model_settings: Option>>, - pub tap_detection_settings: Option>>, - pub auto_bone_settings: Option>>, - pub resets_settings: Option>>, - pub stay_aligned: Option>>, - pub hid_settings: Option>>, - pub timeout: Option>>, - pub velocity_settings: Option>>, - pub vrm: Option>>, -} -impl<'a> Default for SettingsResponseArgs<'a> { - #[inline] - fn default() -> Self { - SettingsResponseArgs { - steam_vr_trackers: None, - filtering: None, - drift_compensation: None, - osc_router: None, - vrc_osc: None, - vmc_osc: None, - model_settings: None, - tap_detection_settings: None, - auto_bone_settings: None, - resets_settings: None, - stay_aligned: None, - hid_settings: None, - timeout: None, - velocity_settings: None, - vrm: None, - } - } -} - -pub struct SettingsResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> SettingsResponseBuilder<'a, 'b> { - #[inline] - pub fn add_steam_vr_trackers(&mut self, steam_vr_trackers: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_STEAM_VR_TRACKERS, steam_vr_trackers); - } - #[inline] - pub fn add_filtering(&mut self, filtering: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_FILTERING, filtering); - } - #[inline] - pub fn add_drift_compensation(&mut self, drift_compensation: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_DRIFT_COMPENSATION, drift_compensation); - } - #[inline] - pub fn add_osc_router(&mut self, osc_router: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_OSC_ROUTER, osc_router); - } - #[inline] - pub fn add_vrc_osc(&mut self, vrc_osc: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_VRC_OSC, vrc_osc); - } - #[inline] - pub fn add_vmc_osc(&mut self, vmc_osc: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_VMC_OSC, vmc_osc); - } - #[inline] - pub fn add_model_settings(&mut self, model_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_MODEL_SETTINGS, model_settings); - } - #[inline] - pub fn add_tap_detection_settings(&mut self, tap_detection_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_TAP_DETECTION_SETTINGS, tap_detection_settings); - } - #[inline] - pub fn add_auto_bone_settings(&mut self, auto_bone_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_AUTO_BONE_SETTINGS, auto_bone_settings); - } - #[inline] - pub fn add_resets_settings(&mut self, resets_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_RESETS_SETTINGS, resets_settings); - } - #[inline] - pub fn add_stay_aligned(&mut self, stay_aligned: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_STAY_ALIGNED, stay_aligned); - } - #[inline] - pub fn add_hid_settings(&mut self, hid_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_HID_SETTINGS, hid_settings); - } - #[inline] - pub fn add_timeout(&mut self, timeout: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_TIMEOUT, timeout); - } - #[inline] - pub fn add_velocity_settings(&mut self, velocity_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_VELOCITY_SETTINGS, velocity_settings); - } - #[inline] - pub fn add_vrm(&mut self, vrm: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(SettingsResponse::VT_VRM, vrm); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SettingsResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - SettingsResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for SettingsResponse<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SettingsResponse"); - ds.field("steam_vr_trackers", &self.steam_vr_trackers()); - ds.field("filtering", &self.filtering()); - ds.field("drift_compensation", &self.drift_compensation()); - ds.field("osc_router", &self.osc_router()); - ds.field("vrc_osc", &self.vrc_osc()); - ds.field("vmc_osc", &self.vmc_osc()); - ds.field("model_settings", &self.model_settings()); - ds.field("tap_detection_settings", &self.tap_detection_settings()); - ds.field("auto_bone_settings", &self.auto_bone_settings()); - ds.field("resets_settings", &self.resets_settings()); - ds.field("stay_aligned", &self.stay_aligned()); - ds.field("hid_settings", &self.hid_settings()); - ds.field("timeout", &self.timeout()); - ds.field("velocity_settings", &self.velocity_settings()); - ds.field("vrm", &self.vrm()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/filtering_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_filtering_generated.rs similarity index 57% rename from protocol/rust/src/generated/solarxr_protocol/rpc/filtering_settings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_filtering_generated.rs index 150545626..ceadb9646 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/filtering_settings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_filtering_generated.rs @@ -9,35 +9,36 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum FilteringSettingsOffset {} +pub enum SkeletonFilteringOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct FilteringSettings<'a> { +/// Filtering (e.g smoothing) applied to the skeleton's movements +pub struct SkeletonFiltering<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for FilteringSettings<'a> { - type Inner = FilteringSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for SkeletonFiltering<'a> { + type Inner = SkeletonFiltering<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> FilteringSettings<'a> { +impl<'a> SkeletonFiltering<'a> { pub const VT_TYPE_: flatbuffers::VOffsetT = 4; pub const VT_AMOUNT: flatbuffers::VOffsetT = 6; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - FilteringSettings { _tab: table } + SkeletonFiltering { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args FilteringSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = FilteringSettingsBuilder::new(_fbb); + args: &'args SkeletonFilteringArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonFilteringBuilder::new(_fbb); builder.add_amount(args.amount); builder.add_type_(args.type_); builder.finish() @@ -45,80 +46,80 @@ impl<'a> FilteringSettings<'a> { #[inline] - pub fn type_(&self) -> super::datatypes::FilteringType { + pub fn type_(&self) -> FilteringType { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(FilteringSettings::VT_TYPE_, Some(super::datatypes::FilteringType::NONE)).unwrap()} + unsafe { self._tab.get::(SkeletonFiltering::VT_TYPE_, Some(FilteringType::NONE)).unwrap()} } - /// 0 to 1. A higher value results in more smoothing or prediction + /// A higher value results in more filtering (0 to 1). #[inline] pub fn amount(&self) -> f32 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(FilteringSettings::VT_AMOUNT, Some(0.0)).unwrap()} + unsafe { self._tab.get::(SkeletonFiltering::VT_AMOUNT, Some(0.0)).unwrap()} } } -impl flatbuffers::Verifiable for FilteringSettings<'_> { +impl flatbuffers::Verifiable for SkeletonFiltering<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("type_", Self::VT_TYPE_, false)? + .visit_field::("type_", Self::VT_TYPE_, false)? .visit_field::("amount", Self::VT_AMOUNT, false)? .finish(); Ok(()) } } -pub struct FilteringSettingsArgs { - pub type_: super::datatypes::FilteringType, +pub struct SkeletonFilteringArgs { + pub type_: FilteringType, pub amount: f32, } -impl<'a> Default for FilteringSettingsArgs { +impl<'a> Default for SkeletonFilteringArgs { #[inline] fn default() -> Self { - FilteringSettingsArgs { - type_: super::datatypes::FilteringType::NONE, + SkeletonFilteringArgs { + type_: FilteringType::NONE, amount: 0.0, } } } -pub struct FilteringSettingsBuilder<'a: 'b, 'b> { +pub struct SkeletonFilteringBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> FilteringSettingsBuilder<'a, 'b> { +impl<'a: 'b, 'b> SkeletonFilteringBuilder<'a, 'b> { #[inline] - pub fn add_type_(&mut self, type_: super::datatypes::FilteringType) { - self.fbb_.push_slot::(FilteringSettings::VT_TYPE_, type_, super::datatypes::FilteringType::NONE); + pub fn add_type_(&mut self, type_: FilteringType) { + self.fbb_.push_slot::(SkeletonFiltering::VT_TYPE_, type_, FilteringType::NONE); } #[inline] pub fn add_amount(&mut self, amount: f32) { - self.fbb_.push_slot::(FilteringSettings::VT_AMOUNT, amount, 0.0); + self.fbb_.push_slot::(SkeletonFiltering::VT_AMOUNT, amount, 0.0); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FilteringSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonFilteringBuilder<'a, 'b> { let start = _fbb.start_table(); - FilteringSettingsBuilder { + SkeletonFilteringBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for FilteringSettings<'_> { +impl core::fmt::Debug for SkeletonFiltering<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("FilteringSettings"); + let mut ds = f.debug_struct("SkeletonFiltering"); ds.field("type_", &self.type_()); ds.field("amount", &self.amount()); ds.finish() diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/skeleton_height_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_height_generated.rs similarity index 98% rename from protocol/rust/src/generated/solarxr_protocol/rpc/settings/skeleton_height_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_height_generated.rs index 9bd87f27c..92bcd7d3e 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/skeleton_height_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_height_generated.rs @@ -12,6 +12,7 @@ use super::*; pub enum SkeletonHeightOffset {} #[derive(Copy, Clone, PartialEq)] +/// Data used to compute the skeleton's height. pub struct SkeletonHeight<'a> { pub _tab: flatbuffers::Table<'a>, } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_request_generated.rs new file mode 100644 index 000000000..a30b00be1 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum SkeletonProportionsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct SkeletonProportionsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for SkeletonProportionsRequest<'a> { + type Inner = SkeletonProportionsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> SkeletonProportionsRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + SkeletonProportionsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args SkeletonProportionsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonProportionsRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for SkeletonProportionsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct SkeletonProportionsRequestArgs { +} +impl<'a> Default for SkeletonProportionsRequestArgs { + #[inline] + fn default() -> Self { + SkeletonProportionsRequestArgs { + } + } +} + +pub struct SkeletonProportionsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> SkeletonProportionsRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonProportionsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + SkeletonProportionsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for SkeletonProportionsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("SkeletonProportionsRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_reset_all_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_reset_all_request_generated.rs new file mode 100644 index 000000000..d3ca8543a --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_reset_all_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum SkeletonProportionsResetAllRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct SkeletonProportionsResetAllRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for SkeletonProportionsResetAllRequest<'a> { + type Inner = SkeletonProportionsResetAllRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> SkeletonProportionsResetAllRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + SkeletonProportionsResetAllRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args SkeletonProportionsResetAllRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonProportionsResetAllRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for SkeletonProportionsResetAllRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct SkeletonProportionsResetAllRequestArgs { +} +impl<'a> Default for SkeletonProportionsResetAllRequestArgs { + #[inline] + fn default() -> Self { + SkeletonProportionsResetAllRequestArgs { + } + } +} + +pub struct SkeletonProportionsResetAllRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> SkeletonProportionsResetAllRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonProportionsResetAllRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + SkeletonProportionsResetAllRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for SkeletonProportionsResetAllRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("SkeletonProportionsResetAllRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_response_generated.rs similarity index 69% rename from protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_response_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_response_generated.rs index 086e3b136..283b05d63 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_config_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_proportions_response_generated.rs @@ -9,35 +9,35 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum SkeletonConfigResponseOffset {} +pub enum SkeletonProportionsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct SkeletonConfigResponse<'a> { +pub struct SkeletonProportionsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for SkeletonConfigResponse<'a> { - type Inner = SkeletonConfigResponse<'a>; +impl<'a> flatbuffers::Follow<'a> for SkeletonProportionsResponse<'a> { + type Inner = SkeletonProportionsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> SkeletonConfigResponse<'a> { +impl<'a> SkeletonProportionsResponse<'a> { pub const VT_SKELETON_PARTS: flatbuffers::VOffsetT = 4; pub const VT_USER_HEIGHT: flatbuffers::VOffsetT = 6; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SkeletonConfigResponse { _tab: table } + SkeletonProportionsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SkeletonConfigResponseArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = SkeletonConfigResponseBuilder::new(_fbb); + args: &'args SkeletonProportionsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonProportionsResponseBuilder::new(_fbb); builder.add_user_height(args.user_height); if let Some(x) = args.skeleton_parts { builder.add_skeleton_parts(x); } builder.finish() @@ -49,18 +49,18 @@ impl<'a> SkeletonConfigResponse<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(SkeletonConfigResponse::VT_SKELETON_PARTS, None)} + unsafe { self._tab.get::>>>(SkeletonProportionsResponse::VT_SKELETON_PARTS, None)} } #[inline] pub fn user_height(&self) -> f32 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(SkeletonConfigResponse::VT_USER_HEIGHT, Some(0.0)).unwrap()} + unsafe { self._tab.get::(SkeletonProportionsResponse::VT_USER_HEIGHT, Some(0.0)).unwrap()} } } -impl flatbuffers::Verifiable for SkeletonConfigResponse<'_> { +impl flatbuffers::Verifiable for SkeletonProportionsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -73,51 +73,51 @@ impl flatbuffers::Verifiable for SkeletonConfigResponse<'_> { Ok(()) } } -pub struct SkeletonConfigResponseArgs<'a> { +pub struct SkeletonProportionsResponseArgs<'a> { pub skeleton_parts: Option>>>>, pub user_height: f32, } -impl<'a> Default for SkeletonConfigResponseArgs<'a> { +impl<'a> Default for SkeletonProportionsResponseArgs<'a> { #[inline] fn default() -> Self { - SkeletonConfigResponseArgs { + SkeletonProportionsResponseArgs { skeleton_parts: None, user_height: 0.0, } } } -pub struct SkeletonConfigResponseBuilder<'a: 'b, 'b> { +pub struct SkeletonProportionsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> SkeletonConfigResponseBuilder<'a, 'b> { +impl<'a: 'b, 'b> SkeletonProportionsResponseBuilder<'a, 'b> { #[inline] pub fn add_skeleton_parts(&mut self, skeleton_parts: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(SkeletonConfigResponse::VT_SKELETON_PARTS, skeleton_parts); + self.fbb_.push_slot_always::>(SkeletonProportionsResponse::VT_SKELETON_PARTS, skeleton_parts); } #[inline] pub fn add_user_height(&mut self, user_height: f32) { - self.fbb_.push_slot::(SkeletonConfigResponse::VT_USER_HEIGHT, user_height, 0.0); + self.fbb_.push_slot::(SkeletonProportionsResponse::VT_USER_HEIGHT, user_height, 0.0); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonConfigResponseBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonProportionsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - SkeletonConfigResponseBuilder { + SkeletonProportionsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for SkeletonConfigResponse<'_> { +impl core::fmt::Debug for SkeletonProportionsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SkeletonConfigResponse"); + let mut ds = f.debug_struct("SkeletonProportionsResponse"); ds.field("skeleton_parts", &self.skeleton_parts()); ds.field("user_height", &self.user_height()); ds.finish() diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_ratios_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_ratios_generated.rs new file mode 100644 index 000000000..0933eec2e --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_ratios_generated.rs @@ -0,0 +1,200 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum SkeletonRatiosOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Ratios for the skeletal model. Accepted values for them range from 0 to 1 +pub struct SkeletonRatios<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for SkeletonRatios<'a> { + type Inner = SkeletonRatios<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> SkeletonRatios<'a> { + pub const VT_IMPUTE_SPINE_FROM_UPPER_LOWER: flatbuffers::VOffsetT = 4; + pub const VT_IMPUTE_SPINE_CURVATURE: flatbuffers::VOffsetT = 6; + pub const VT_INTERP_HIP_LEGS: flatbuffers::VOffsetT = 8; + pub const VT_INTERP_KNEE_TRACKER_ANKLE: flatbuffers::VOffsetT = 10; + pub const VT_INTERP_KNEE_ANKLE: flatbuffers::VOffsetT = 12; + pub const VT_SKATING_CORRECTION_STRENGTH: flatbuffers::VOffsetT = 14; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + SkeletonRatios { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args SkeletonRatiosArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonRatiosBuilder::new(_fbb); + if let Some(x) = args.skating_correction_strength { builder.add_skating_correction_strength(x); } + if let Some(x) = args.interp_knee_ankle { builder.add_interp_knee_ankle(x); } + if let Some(x) = args.interp_knee_tracker_ankle { builder.add_interp_knee_tracker_ankle(x); } + if let Some(x) = args.interp_hip_legs { builder.add_interp_hip_legs(x); } + if let Some(x) = args.impute_spine_curvature { builder.add_impute_spine_curvature(x); } + if let Some(x) = args.impute_spine_from_upper_lower { builder.add_impute_spine_from_upper_lower(x); } + builder.finish() + } + + + /// Compute missing spine bones as a ratio of the next available upper and lower bones. + #[inline] + pub fn impute_spine_from_upper_lower(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_IMPUTE_SPINE_FROM_UPPER_LOWER, None)} + } + /// Computes the curvature between 2 adjacent missing spine bones. Higher = more curvature. + #[inline] + pub fn impute_spine_curvature(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_IMPUTE_SPINE_CURVATURE, None)} + } + /// How much to average the hip's yaw and roll with the upper legs'. + #[inline] + pub fn interp_hip_legs(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_INTERP_HIP_LEGS, None)} + } + /// How much to average the knee trackers' yaw and roll with the lower legs'. + #[inline] + pub fn interp_knee_tracker_ankle(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_INTERP_KNEE_TRACKER_ANKLE, None)} + } + /// How much to average the upper leg's yaw and roll with the lower legs'. + #[inline] + pub fn interp_knee_ankle(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_INTERP_KNEE_ANKLE, None)} + } + /// Strength of skating correction. Enabled via SkeletonToggles.skating_correction + #[inline] + pub fn skating_correction_strength(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(SkeletonRatios::VT_SKATING_CORRECTION_STRENGTH, None)} + } +} + +impl flatbuffers::Verifiable for SkeletonRatios<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("impute_spine_from_upper_lower", Self::VT_IMPUTE_SPINE_FROM_UPPER_LOWER, false)? + .visit_field::("impute_spine_curvature", Self::VT_IMPUTE_SPINE_CURVATURE, false)? + .visit_field::("interp_hip_legs", Self::VT_INTERP_HIP_LEGS, false)? + .visit_field::("interp_knee_tracker_ankle", Self::VT_INTERP_KNEE_TRACKER_ANKLE, false)? + .visit_field::("interp_knee_ankle", Self::VT_INTERP_KNEE_ANKLE, false)? + .visit_field::("skating_correction_strength", Self::VT_SKATING_CORRECTION_STRENGTH, false)? + .finish(); + Ok(()) + } +} +pub struct SkeletonRatiosArgs { + pub impute_spine_from_upper_lower: Option, + pub impute_spine_curvature: Option, + pub interp_hip_legs: Option, + pub interp_knee_tracker_ankle: Option, + pub interp_knee_ankle: Option, + pub skating_correction_strength: Option, +} +impl<'a> Default for SkeletonRatiosArgs { + #[inline] + fn default() -> Self { + SkeletonRatiosArgs { + impute_spine_from_upper_lower: None, + impute_spine_curvature: None, + interp_hip_legs: None, + interp_knee_tracker_ankle: None, + interp_knee_ankle: None, + skating_correction_strength: None, + } + } +} + +pub struct SkeletonRatiosBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> SkeletonRatiosBuilder<'a, 'b> { + #[inline] + pub fn add_impute_spine_from_upper_lower(&mut self, impute_spine_from_upper_lower: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_IMPUTE_SPINE_FROM_UPPER_LOWER, impute_spine_from_upper_lower); + } + #[inline] + pub fn add_impute_spine_curvature(&mut self, impute_spine_curvature: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_IMPUTE_SPINE_CURVATURE, impute_spine_curvature); + } + #[inline] + pub fn add_interp_hip_legs(&mut self, interp_hip_legs: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_INTERP_HIP_LEGS, interp_hip_legs); + } + #[inline] + pub fn add_interp_knee_tracker_ankle(&mut self, interp_knee_tracker_ankle: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_INTERP_KNEE_TRACKER_ANKLE, interp_knee_tracker_ankle); + } + #[inline] + pub fn add_interp_knee_ankle(&mut self, interp_knee_ankle: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_INTERP_KNEE_ANKLE, interp_knee_ankle); + } + #[inline] + pub fn add_skating_correction_strength(&mut self, skating_correction_strength: f32) { + self.fbb_.push_slot_always::(SkeletonRatios::VT_SKATING_CORRECTION_STRENGTH, skating_correction_strength); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonRatiosBuilder<'a, 'b> { + let start = _fbb.start_table(); + SkeletonRatiosBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for SkeletonRatios<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("SkeletonRatios"); + ds.field("impute_spine_from_upper_lower", &self.impute_spine_from_upper_lower()); + ds.field("impute_spine_curvature", &self.impute_spine_curvature()); + ds.field("interp_hip_legs", &self.interp_hip_legs()); + ds.field("interp_knee_tracker_ankle", &self.interp_knee_tracker_ankle()); + ds.field("interp_knee_ankle", &self.interp_knee_ankle()); + ds.field("skating_correction_strength", &self.skating_correction_strength()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_reset_all_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_request_generated.rs similarity index 60% rename from protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_reset_all_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_request_generated.rs index 4a3328bd3..ac9ccadb2 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_reset_all_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_request_generated.rs @@ -9,39 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum SkeletonResetAllRequestOffset {} +pub enum SkeletonSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct SkeletonResetAllRequest<'a> { +pub struct SkeletonSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for SkeletonResetAllRequest<'a> { - type Inner = SkeletonResetAllRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for SkeletonSettingsRequest<'a> { + type Inner = SkeletonSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> SkeletonResetAllRequest<'a> { +impl<'a> SkeletonSettingsRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SkeletonResetAllRequest { _tab: table } + SkeletonSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args SkeletonResetAllRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = SkeletonResetAllRequestBuilder::new(_fbb); + _args: &'args SkeletonSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonSettingsRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for SkeletonResetAllRequest<'_> { +impl flatbuffers::Verifiable for SkeletonSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -52,39 +52,39 @@ impl flatbuffers::Verifiable for SkeletonResetAllRequest<'_> { Ok(()) } } -pub struct SkeletonResetAllRequestArgs { +pub struct SkeletonSettingsRequestArgs { } -impl<'a> Default for SkeletonResetAllRequestArgs { +impl<'a> Default for SkeletonSettingsRequestArgs { #[inline] fn default() -> Self { - SkeletonResetAllRequestArgs { + SkeletonSettingsRequestArgs { } } } -pub struct SkeletonResetAllRequestBuilder<'a: 'b, 'b> { +pub struct SkeletonSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> SkeletonResetAllRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> SkeletonSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonResetAllRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - SkeletonResetAllRequestBuilder { + SkeletonSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for SkeletonResetAllRequest<'_> { +impl core::fmt::Debug for SkeletonSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SkeletonResetAllRequest"); + let mut ds = f.debug_struct("SkeletonSettingsRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_response_generated.rs similarity index 51% rename from protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_settings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_response_generated.rs index fed1b713a..b9d9b467d 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_settings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_settings_response_generated.rs @@ -9,40 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum ModelSettingsOffset {} +pub enum SkeletonSettingsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -/// Settings for the skeletal model. -pub struct ModelSettings<'a> { +pub struct SkeletonSettingsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for ModelSettings<'a> { - type Inner = ModelSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for SkeletonSettingsResponse<'a> { + type Inner = SkeletonSettingsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> ModelSettings<'a> { +impl<'a> SkeletonSettingsResponse<'a> { pub const VT_TOGGLES: flatbuffers::VOffsetT = 4; pub const VT_RATIOS: flatbuffers::VOffsetT = 6; - pub const VT_LEG_TWEAKS: flatbuffers::VOffsetT = 8; + pub const VT_FILTERING: flatbuffers::VOffsetT = 8; pub const VT_SKELETON_HEIGHT: flatbuffers::VOffsetT = 10; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ModelSettings { _tab: table } + SkeletonSettingsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ModelSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = ModelSettingsBuilder::new(_fbb); + args: &'args SkeletonSettingsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonSettingsResponseBuilder::new(_fbb); if let Some(x) = args.skeleton_height { builder.add_skeleton_height(x); } - if let Some(x) = args.leg_tweaks { builder.add_leg_tweaks(x); } + if let Some(x) = args.filtering { builder.add_filtering(x); } if let Some(x) = args.ratios { builder.add_ratios(x); } if let Some(x) = args.toggles { builder.add_toggles(x); } builder.finish() @@ -50,110 +49,110 @@ impl<'a> ModelSettings<'a> { #[inline] - pub fn toggles(&self) -> Option> { + pub fn toggles(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ModelSettings::VT_TOGGLES, None)} + unsafe { self._tab.get::>(SkeletonSettingsResponse::VT_TOGGLES, None)} } #[inline] - pub fn ratios(&self) -> Option> { + pub fn ratios(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ModelSettings::VT_RATIOS, None)} + unsafe { self._tab.get::>(SkeletonSettingsResponse::VT_RATIOS, None)} } #[inline] - pub fn leg_tweaks(&self) -> Option> { + pub fn filtering(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ModelSettings::VT_LEG_TWEAKS, None)} + unsafe { self._tab.get::>(SkeletonSettingsResponse::VT_FILTERING, None)} } #[inline] pub fn skeleton_height(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(ModelSettings::VT_SKELETON_HEIGHT, None)} + unsafe { self._tab.get::>(SkeletonSettingsResponse::VT_SKELETON_HEIGHT, None)} } } -impl flatbuffers::Verifiable for ModelSettings<'_> { +impl flatbuffers::Verifiable for SkeletonSettingsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("toggles", Self::VT_TOGGLES, false)? - .visit_field::>("ratios", Self::VT_RATIOS, false)? - .visit_field::>("leg_tweaks", Self::VT_LEG_TWEAKS, false)? + .visit_field::>("toggles", Self::VT_TOGGLES, false)? + .visit_field::>("ratios", Self::VT_RATIOS, false)? + .visit_field::>("filtering", Self::VT_FILTERING, false)? .visit_field::>("skeleton_height", Self::VT_SKELETON_HEIGHT, false)? .finish(); Ok(()) } } -pub struct ModelSettingsArgs<'a> { - pub toggles: Option>>, - pub ratios: Option>>, - pub leg_tweaks: Option>>, +pub struct SkeletonSettingsResponseArgs<'a> { + pub toggles: Option>>, + pub ratios: Option>>, + pub filtering: Option>>, pub skeleton_height: Option>>, } -impl<'a> Default for ModelSettingsArgs<'a> { +impl<'a> Default for SkeletonSettingsResponseArgs<'a> { #[inline] fn default() -> Self { - ModelSettingsArgs { + SkeletonSettingsResponseArgs { toggles: None, ratios: None, - leg_tweaks: None, + filtering: None, skeleton_height: None, } } } -pub struct ModelSettingsBuilder<'a: 'b, 'b> { +pub struct SkeletonSettingsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> ModelSettingsBuilder<'a, 'b> { +impl<'a: 'b, 'b> SkeletonSettingsResponseBuilder<'a, 'b> { #[inline] - pub fn add_toggles(&mut self, toggles: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ModelSettings::VT_TOGGLES, toggles); + pub fn add_toggles(&mut self, toggles: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(SkeletonSettingsResponse::VT_TOGGLES, toggles); } #[inline] - pub fn add_ratios(&mut self, ratios: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ModelSettings::VT_RATIOS, ratios); + pub fn add_ratios(&mut self, ratios: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(SkeletonSettingsResponse::VT_RATIOS, ratios); } #[inline] - pub fn add_leg_tweaks(&mut self, leg_tweaks: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ModelSettings::VT_LEG_TWEAKS, leg_tweaks); + pub fn add_filtering(&mut self, filtering: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(SkeletonSettingsResponse::VT_FILTERING, filtering); } #[inline] pub fn add_skeleton_height(&mut self, skeleton_height: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(ModelSettings::VT_SKELETON_HEIGHT, skeleton_height); + self.fbb_.push_slot_always::>(SkeletonSettingsResponse::VT_SKELETON_HEIGHT, skeleton_height); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ModelSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonSettingsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - ModelSettingsBuilder { + SkeletonSettingsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for ModelSettings<'_> { +impl core::fmt::Debug for SkeletonSettingsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ModelSettings"); + let mut ds = f.debug_struct("SkeletonSettingsResponse"); ds.field("toggles", &self.toggles()); ds.field("ratios", &self.ratios()); - ds.field("leg_tweaks", &self.leg_tweaks()); + ds.field("filtering", &self.filtering()); ds.field("skeleton_height", &self.skeleton_height()); ds.finish() } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_toggles_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_toggles_generated.rs similarity index 55% rename from protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_toggles_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_toggles_generated.rs index b04b7eb43..0779c1935 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings/model_toggles_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/skeleton_toggles_generated.rs @@ -9,46 +9,43 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum ModelTogglesOffset {} +pub enum SkeletonTogglesOffset {} #[derive(Copy, Clone, PartialEq)] -/// Settings for the skeletal model that are toggles. -pub struct ModelToggles<'a> { +/// Toggles for the skeletal model. +pub struct SkeletonToggles<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for ModelToggles<'a> { - type Inner = ModelToggles<'a>; +impl<'a> flatbuffers::Follow<'a> for SkeletonToggles<'a> { + type Inner = SkeletonToggles<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> ModelToggles<'a> { - pub const VT_EXTENDED_SPINE: flatbuffers::VOffsetT = 4; - pub const VT_EXTENDED_PELVIS: flatbuffers::VOffsetT = 6; - pub const VT_EXTENDED_KNEE: flatbuffers::VOffsetT = 8; - pub const VT_FORCE_ARMS_FROM_HMD: flatbuffers::VOffsetT = 10; - pub const VT_FLOOR_CLIP: flatbuffers::VOffsetT = 12; - pub const VT_SKATING_CORRECTION: flatbuffers::VOffsetT = 14; - pub const VT_TOE_SNAP: flatbuffers::VOffsetT = 18; - pub const VT_FOOT_PLANT: flatbuffers::VOffsetT = 20; - pub const VT_SELF_LOCALIZATION: flatbuffers::VOffsetT = 22; - pub const VT_USE_POSITION: flatbuffers::VOffsetT = 24; - pub const VT_ENFORCE_CONSTRAINTS: flatbuffers::VOffsetT = 26; - pub const VT_CORRECT_CONSTRAINTS: flatbuffers::VOffsetT = 28; +impl<'a> SkeletonToggles<'a> { + pub const VT_FORCE_ARMS_FROM_HMD: flatbuffers::VOffsetT = 4; + pub const VT_FLOOR_CLIP: flatbuffers::VOffsetT = 6; + pub const VT_SKATING_CORRECTION: flatbuffers::VOffsetT = 8; + pub const VT_TOE_SNAP: flatbuffers::VOffsetT = 10; + pub const VT_FOOT_PLANT: flatbuffers::VOffsetT = 12; + pub const VT_SELF_LOCALIZATION: flatbuffers::VOffsetT = 14; + pub const VT_USE_POSITION: flatbuffers::VOffsetT = 16; + pub const VT_ENFORCE_CONSTRAINTS: flatbuffers::VOffsetT = 18; + pub const VT_CORRECT_CONSTRAINTS: flatbuffers::VOffsetT = 20; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ModelToggles { _tab: table } + SkeletonToggles { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ModelTogglesArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = ModelTogglesBuilder::new(_fbb); + args: &'args SkeletonTogglesArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = SkeletonTogglesBuilder::new(_fbb); if let Some(x) = args.correct_constraints { builder.add_correct_constraints(x); } if let Some(x) = args.enforce_constraints { builder.add_enforce_constraints(x); } if let Some(x) = args.use_position { builder.add_use_position(x); } @@ -58,109 +55,82 @@ impl<'a> ModelToggles<'a> { if let Some(x) = args.skating_correction { builder.add_skating_correction(x); } if let Some(x) = args.floor_clip { builder.add_floor_clip(x); } if let Some(x) = args.force_arms_from_hmd { builder.add_force_arms_from_hmd(x); } - if let Some(x) = args.extended_knee { builder.add_extended_knee(x); } - if let Some(x) = args.extended_pelvis { builder.add_extended_pelvis(x); } - if let Some(x) = args.extended_spine { builder.add_extended_spine(x); } builder.finish() } - #[inline] - pub fn extended_spine(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_EXTENDED_SPINE, None)} - } - #[inline] - pub fn extended_pelvis(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_EXTENDED_PELVIS, None)} - } - #[inline] - pub fn extended_knee(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_EXTENDED_KNEE, None)} - } #[inline] pub fn force_arms_from_hmd(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_FORCE_ARMS_FROM_HMD, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_FORCE_ARMS_FROM_HMD, None)} } #[inline] pub fn floor_clip(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_FLOOR_CLIP, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_FLOOR_CLIP, None)} } #[inline] pub fn skating_correction(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_SKATING_CORRECTION, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_SKATING_CORRECTION, None)} } #[inline] pub fn toe_snap(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_TOE_SNAP, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_TOE_SNAP, None)} } #[inline] pub fn foot_plant(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_FOOT_PLANT, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_FOOT_PLANT, None)} } #[inline] pub fn self_localization(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_SELF_LOCALIZATION, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_SELF_LOCALIZATION, None)} } #[inline] pub fn use_position(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_USE_POSITION, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_USE_POSITION, None)} } #[inline] pub fn enforce_constraints(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_ENFORCE_CONSTRAINTS, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_ENFORCE_CONSTRAINTS, None)} } #[inline] pub fn correct_constraints(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(ModelToggles::VT_CORRECT_CONSTRAINTS, None)} + unsafe { self._tab.get::(SkeletonToggles::VT_CORRECT_CONSTRAINTS, None)} } } -impl flatbuffers::Verifiable for ModelToggles<'_> { +impl flatbuffers::Verifiable for SkeletonToggles<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("extended_spine", Self::VT_EXTENDED_SPINE, false)? - .visit_field::("extended_pelvis", Self::VT_EXTENDED_PELVIS, false)? - .visit_field::("extended_knee", Self::VT_EXTENDED_KNEE, false)? .visit_field::("force_arms_from_hmd", Self::VT_FORCE_ARMS_FROM_HMD, false)? .visit_field::("floor_clip", Self::VT_FLOOR_CLIP, false)? .visit_field::("skating_correction", Self::VT_SKATING_CORRECTION, false)? @@ -174,10 +144,7 @@ impl flatbuffers::Verifiable for ModelToggles<'_> { Ok(()) } } -pub struct ModelTogglesArgs { - pub extended_spine: Option, - pub extended_pelvis: Option, - pub extended_knee: Option, +pub struct SkeletonTogglesArgs { pub force_arms_from_hmd: Option, pub floor_clip: Option, pub skating_correction: Option, @@ -188,13 +155,10 @@ pub struct ModelTogglesArgs { pub enforce_constraints: Option, pub correct_constraints: Option, } -impl<'a> Default for ModelTogglesArgs { +impl<'a> Default for SkeletonTogglesArgs { #[inline] fn default() -> Self { - ModelTogglesArgs { - extended_spine: None, - extended_pelvis: None, - extended_knee: None, + SkeletonTogglesArgs { force_arms_from_hmd: None, floor_clip: None, skating_correction: None, @@ -208,80 +172,65 @@ impl<'a> Default for ModelTogglesArgs { } } -pub struct ModelTogglesBuilder<'a: 'b, 'b> { +pub struct SkeletonTogglesBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> ModelTogglesBuilder<'a, 'b> { - #[inline] - pub fn add_extended_spine(&mut self, extended_spine: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_EXTENDED_SPINE, extended_spine); - } - #[inline] - pub fn add_extended_pelvis(&mut self, extended_pelvis: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_EXTENDED_PELVIS, extended_pelvis); - } - #[inline] - pub fn add_extended_knee(&mut self, extended_knee: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_EXTENDED_KNEE, extended_knee); - } +impl<'a: 'b, 'b> SkeletonTogglesBuilder<'a, 'b> { #[inline] pub fn add_force_arms_from_hmd(&mut self, force_arms_from_hmd: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_FORCE_ARMS_FROM_HMD, force_arms_from_hmd); + self.fbb_.push_slot_always::(SkeletonToggles::VT_FORCE_ARMS_FROM_HMD, force_arms_from_hmd); } #[inline] pub fn add_floor_clip(&mut self, floor_clip: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_FLOOR_CLIP, floor_clip); + self.fbb_.push_slot_always::(SkeletonToggles::VT_FLOOR_CLIP, floor_clip); } #[inline] pub fn add_skating_correction(&mut self, skating_correction: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_SKATING_CORRECTION, skating_correction); + self.fbb_.push_slot_always::(SkeletonToggles::VT_SKATING_CORRECTION, skating_correction); } #[inline] pub fn add_toe_snap(&mut self, toe_snap: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_TOE_SNAP, toe_snap); + self.fbb_.push_slot_always::(SkeletonToggles::VT_TOE_SNAP, toe_snap); } #[inline] pub fn add_foot_plant(&mut self, foot_plant: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_FOOT_PLANT, foot_plant); + self.fbb_.push_slot_always::(SkeletonToggles::VT_FOOT_PLANT, foot_plant); } #[inline] pub fn add_self_localization(&mut self, self_localization: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_SELF_LOCALIZATION, self_localization); + self.fbb_.push_slot_always::(SkeletonToggles::VT_SELF_LOCALIZATION, self_localization); } #[inline] pub fn add_use_position(&mut self, use_position: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_USE_POSITION, use_position); + self.fbb_.push_slot_always::(SkeletonToggles::VT_USE_POSITION, use_position); } #[inline] pub fn add_enforce_constraints(&mut self, enforce_constraints: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_ENFORCE_CONSTRAINTS, enforce_constraints); + self.fbb_.push_slot_always::(SkeletonToggles::VT_ENFORCE_CONSTRAINTS, enforce_constraints); } #[inline] pub fn add_correct_constraints(&mut self, correct_constraints: bool) { - self.fbb_.push_slot_always::(ModelToggles::VT_CORRECT_CONSTRAINTS, correct_constraints); + self.fbb_.push_slot_always::(SkeletonToggles::VT_CORRECT_CONSTRAINTS, correct_constraints); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ModelTogglesBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SkeletonTogglesBuilder<'a, 'b> { let start = _fbb.start_table(); - ModelTogglesBuilder { + SkeletonTogglesBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for ModelToggles<'_> { +impl core::fmt::Debug for SkeletonToggles<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("ModelToggles"); - ds.field("extended_spine", &self.extended_spine()); - ds.field("extended_pelvis", &self.extended_pelvis()); - ds.field("extended_knee", &self.extended_knee()); + let mut ds = f.debug_struct("SkeletonToggles"); ds.field("force_arms_from_hmd", &self.force_arms_from_hmd()); ds.field("floor_clip", &self.floor_clip()); ds.field("skating_correction", &self.skating_correction()); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs deleted file mode 100644 index 641ced847..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs +++ /dev/null @@ -1,114 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MIN_STATUS_DATA: u8 = 0; -#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_STATUS_DATA: u8 = 5; -#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -#[allow(non_camel_case_types)] -pub const ENUM_VALUES_STATUS_DATA: [StatusData; 6] = [ - StatusData::NONE, - StatusData::StatusTrackerReset, - StatusData::StatusTrackerError, - StatusData::StatusSteamVRDisconnected, - StatusData::StatusUnassignedHMD, - StatusData::StatusPublicNetwork, -]; - -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] -#[repr(transparent)] -pub struct StatusData(pub u8); -#[allow(non_upper_case_globals)] -impl StatusData { - pub const NONE: Self = Self(0); - pub const StatusTrackerReset: Self = Self(1); - pub const StatusTrackerError: Self = Self(2); - pub const StatusSteamVRDisconnected: Self = Self(3); - pub const StatusUnassignedHMD: Self = Self(4); - pub const StatusPublicNetwork: Self = Self(5); - - pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 5; - pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::StatusTrackerReset, - Self::StatusTrackerError, - Self::StatusSteamVRDisconnected, - Self::StatusUnassignedHMD, - Self::StatusPublicNetwork, - ]; - /// Returns the variant's name or "" if unknown. - pub fn variant_name(self) -> Option<&'static str> { - match self { - Self::NONE => Some("NONE"), - Self::StatusTrackerReset => Some("StatusTrackerReset"), - Self::StatusTrackerError => Some("StatusTrackerError"), - Self::StatusSteamVRDisconnected => Some("StatusSteamVRDisconnected"), - Self::StatusUnassignedHMD => Some("StatusUnassignedHMD"), - Self::StatusPublicNetwork => Some("StatusPublicNetwork"), - _ => None, - } - } -} -impl core::fmt::Debug for StatusData { - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { - if let Some(name) = self.variant_name() { - f.write_str(name) - } else { - f.write_fmt(format_args!("", self.0)) - } - } -} -impl<'a> flatbuffers::Follow<'a> for StatusData { - type Inner = Self; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - let b = flatbuffers::read_scalar_at::(buf, loc); - Self(b) - } -} - -impl flatbuffers::Push for StatusData { - type Output = StatusData; - #[inline] - unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { - flatbuffers::emplace_scalar::(dst, self.0); - } -} - -impl flatbuffers::EndianScalar for StatusData { - type Scalar = u8; - #[inline] - fn to_little_endian(self) -> u8 { - self.0.to_le() - } - #[inline] - #[allow(clippy::wrong_self_convention)] - fn from_little_endian(v: u8) -> Self { - let b = u8::from_le(v); - Self(b) - } -} - -impl<'a> flatbuffers::Verifiable for StatusData { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - u8::run_verifier(v, pos) - } -} - -impl flatbuffers::SimpleToVerifyInSlice for StatusData {} -pub struct StatusDataUnionTableOffset {} - diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs deleted file mode 100644 index 3427a5b7d..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs +++ /dev/null @@ -1,286 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusMessageOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// An status is some kind of warning sent by the server, it's mainly made for -/// showing problems with the server and need attention from the user. -pub struct StatusMessage<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusMessage<'a> { - type Inner = StatusMessage<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusMessage<'a> { - pub const VT_ID: flatbuffers::VOffsetT = 4; - pub const VT_PRIORITIZED: flatbuffers::VOffsetT = 6; - pub const VT_DATA_TYPE: flatbuffers::VOffsetT = 8; - pub const VT_DATA: flatbuffers::VOffsetT = 10; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusMessage { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusMessageArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusMessageBuilder::new(_fbb); - if let Some(x) = args.data { builder.add_data(x); } - builder.add_id(args.id); - builder.add_data_type(args.data_type); - builder.add_prioritized(args.prioritized); - builder.finish() - } - - - /// The status ID - #[inline] - pub fn id(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StatusMessage::VT_ID, Some(0)).unwrap()} - } - /// This should be prioritized in the GUI in some way if true - #[inline] - pub fn prioritized(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StatusMessage::VT_PRIORITIZED, Some(false)).unwrap()} - } - #[inline] - pub fn data_type(&self) -> StatusData { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StatusMessage::VT_DATA_TYPE, Some(StatusData::NONE)).unwrap()} - } - #[inline] - pub fn data(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>(StatusMessage::VT_DATA, None)} - } - #[inline] - #[allow(non_snake_case)] - pub fn data_as_status_tracker_reset(&self) -> Option> { - if self.data_type() == StatusData::StatusTrackerReset { - self.data().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { StatusTrackerReset::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn data_as_status_tracker_error(&self) -> Option> { - if self.data_type() == StatusData::StatusTrackerError { - self.data().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { StatusTrackerError::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn data_as_status_steam_vrdisconnected(&self) -> Option> { - if self.data_type() == StatusData::StatusSteamVRDisconnected { - self.data().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { StatusSteamVRDisconnected::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn data_as_status_unassigned_hmd(&self) -> Option> { - if self.data_type() == StatusData::StatusUnassignedHMD { - self.data().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { StatusUnassignedHMD::init_from_table(t) } - }) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn data_as_status_public_network(&self) -> Option> { - if self.data_type() == StatusData::StatusPublicNetwork { - self.data().map(|t| { - // Safety: - // Created from a valid Table for this object - // Which contains a valid union in this slot - unsafe { StatusPublicNetwork::init_from_table(t) } - }) - } else { - None - } - } - -} - -impl flatbuffers::Verifiable for StatusMessage<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("id", Self::VT_ID, false)? - .visit_field::("prioritized", Self::VT_PRIORITIZED, false)? - .visit_union::("data_type", Self::VT_DATA_TYPE, "data", Self::VT_DATA, false, |key, v, pos| { - match key { - StatusData::StatusTrackerReset => v.verify_union_variant::>("StatusData::StatusTrackerReset", pos), - StatusData::StatusTrackerError => v.verify_union_variant::>("StatusData::StatusTrackerError", pos), - StatusData::StatusSteamVRDisconnected => v.verify_union_variant::>("StatusData::StatusSteamVRDisconnected", pos), - StatusData::StatusUnassignedHMD => v.verify_union_variant::>("StatusData::StatusUnassignedHMD", pos), - StatusData::StatusPublicNetwork => v.verify_union_variant::>("StatusData::StatusPublicNetwork", pos), - _ => Ok(()), - } - })? - .finish(); - Ok(()) - } -} -pub struct StatusMessageArgs { - pub id: u32, - pub prioritized: bool, - pub data_type: StatusData, - pub data: Option>, -} -impl<'a> Default for StatusMessageArgs { - #[inline] - fn default() -> Self { - StatusMessageArgs { - id: 0, - prioritized: false, - data_type: StatusData::NONE, - data: None, - } - } -} - -pub struct StatusMessageBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusMessageBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(StatusMessage::VT_ID, id, 0); - } - #[inline] - pub fn add_prioritized(&mut self, prioritized: bool) { - self.fbb_.push_slot::(StatusMessage::VT_PRIORITIZED, prioritized, false); - } - #[inline] - pub fn add_data_type(&mut self, data_type: StatusData) { - self.fbb_.push_slot::(StatusMessage::VT_DATA_TYPE, data_type, StatusData::NONE); - } - #[inline] - pub fn add_data(&mut self, data: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(StatusMessage::VT_DATA, data); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusMessageBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusMessageBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusMessage<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusMessage"); - ds.field("id", &self.id()); - ds.field("prioritized", &self.prioritized()); - ds.field("data_type", &self.data_type()); - match self.data_type() { - StatusData::StatusTrackerReset => { - if let Some(x) = self.data_as_status_tracker_reset() { - ds.field("data", &x) - } else { - ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - StatusData::StatusTrackerError => { - if let Some(x) = self.data_as_status_tracker_error() { - ds.field("data", &x) - } else { - ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - StatusData::StatusSteamVRDisconnected => { - if let Some(x) = self.data_as_status_steam_vrdisconnected() { - ds.field("data", &x) - } else { - ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - StatusData::StatusUnassignedHMD => { - if let Some(x) = self.data_as_status_unassigned_hmd() { - ds.field("data", &x) - } else { - ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - StatusData::StatusPublicNetwork => { - if let Some(x) = self.data_as_status_public_network() { - ds.field("data", &x) - } else { - ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.") - } - }, - _ => { - let x: Option<()> = None; - ds.field("data", &x) - }, - }; - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs deleted file mode 100644 index 23d6fb2fc..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs +++ /dev/null @@ -1,110 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusPublicNetworkOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// When the server detects a public network profile -pub struct StatusPublicNetwork<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusPublicNetwork<'a> { - type Inner = StatusPublicNetwork<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusPublicNetwork<'a> { - pub const VT_ADAPTERS: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusPublicNetwork { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusPublicNetworkArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusPublicNetworkBuilder::new(_fbb); - if let Some(x) = args.adapters { builder.add_adapters(x); } - builder.finish() - } - - - /// names of the adapters set to public - #[inline] - pub fn adapters(&self) -> Option>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(StatusPublicNetwork::VT_ADAPTERS, None)} - } -} - -impl flatbuffers::Verifiable for StatusPublicNetwork<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>>>("adapters", Self::VT_ADAPTERS, false)? - .finish(); - Ok(()) - } -} -pub struct StatusPublicNetworkArgs<'a> { - pub adapters: Option>>>, -} -impl<'a> Default for StatusPublicNetworkArgs<'a> { - #[inline] - fn default() -> Self { - StatusPublicNetworkArgs { - adapters: None, - } - } -} - -pub struct StatusPublicNetworkBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusPublicNetworkBuilder<'a, 'b> { - #[inline] - pub fn add_adapters(&mut self, adapters: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(StatusPublicNetwork::VT_ADAPTERS, adapters); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusPublicNetworkBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusPublicNetworkBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusPublicNetwork<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusPublicNetwork"); - ds.field("adapters", &self.adapters()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_steam_vrdisconnected_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_steam_vrdisconnected_generated.rs deleted file mode 100644 index 875e14f0e..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_steam_vrdisconnected_generated.rs +++ /dev/null @@ -1,110 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusSteamVRDisconnectedOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// SteamVR bridge is disconnected -pub struct StatusSteamVRDisconnected<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusSteamVRDisconnected<'a> { - type Inner = StatusSteamVRDisconnected<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusSteamVRDisconnected<'a> { - pub const VT_BRIDGE_SETTINGS_NAME: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusSteamVRDisconnected { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusSteamVRDisconnectedArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusSteamVRDisconnectedBuilder::new(_fbb); - if let Some(x) = args.bridge_settings_name { builder.add_bridge_settings_name(x); } - builder.finish() - } - - - /// Name of bridge in the server's config - #[inline] - pub fn bridge_settings_name(&self) -> Option<&'a str> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(StatusSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, None)} - } -} - -impl flatbuffers::Verifiable for StatusSteamVRDisconnected<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("bridge_settings_name", Self::VT_BRIDGE_SETTINGS_NAME, false)? - .finish(); - Ok(()) - } -} -pub struct StatusSteamVRDisconnectedArgs<'a> { - pub bridge_settings_name: Option>, -} -impl<'a> Default for StatusSteamVRDisconnectedArgs<'a> { - #[inline] - fn default() -> Self { - StatusSteamVRDisconnectedArgs { - bridge_settings_name: None, - } - } -} - -pub struct StatusSteamVRDisconnectedBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusSteamVRDisconnectedBuilder<'a, 'b> { - #[inline] - pub fn add_bridge_settings_name(&mut self, bridge_settings_name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(StatusSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusSteamVRDisconnectedBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusSteamVRDisconnectedBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusSteamVRDisconnected<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusSteamVRDisconnected"); - ds.field("bridge_settings_name", &self.bridge_settings_name()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_fixed_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_fixed_generated.rs deleted file mode 100644 index 748d23484..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_fixed_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusSystemFixedOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// When an status is fixed and it's removed, it's ID is sent -pub struct StatusSystemFixed<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusSystemFixed<'a> { - type Inner = StatusSystemFixed<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusSystemFixed<'a> { - pub const VT_FIXED_STATUS_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusSystemFixed { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusSystemFixedArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusSystemFixedBuilder::new(_fbb); - builder.add_fixed_status_id(args.fixed_status_id); - builder.finish() - } - - - #[inline] - pub fn fixed_status_id(&self) -> u32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StatusSystemFixed::VT_FIXED_STATUS_ID, Some(0)).unwrap()} - } -} - -impl flatbuffers::Verifiable for StatusSystemFixed<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("fixed_status_id", Self::VT_FIXED_STATUS_ID, false)? - .finish(); - Ok(()) - } -} -pub struct StatusSystemFixedArgs { - pub fixed_status_id: u32, -} -impl<'a> Default for StatusSystemFixedArgs { - #[inline] - fn default() -> Self { - StatusSystemFixedArgs { - fixed_status_id: 0, - } - } -} - -pub struct StatusSystemFixedBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusSystemFixedBuilder<'a, 'b> { - #[inline] - pub fn add_fixed_status_id(&mut self, fixed_status_id: u32) { - self.fbb_.push_slot::(StatusSystemFixed::VT_FIXED_STATUS_ID, fixed_status_id, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusSystemFixedBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusSystemFixedBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusSystemFixed<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusSystemFixed"); - ds.field("fixed_status_id", &self.fixed_status_id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_response_generated.rs deleted file mode 100644 index c656f3f71..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_response_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusSystemResponseOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Response containing all current valid statuses -pub struct StatusSystemResponse<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusSystemResponse<'a> { - type Inner = StatusSystemResponse<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusSystemResponse<'a> { - pub const VT_CURRENT_STATUSES: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusSystemResponse { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusSystemResponseArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusSystemResponseBuilder::new(_fbb); - if let Some(x) = args.current_statuses { builder.add_current_statuses(x); } - builder.finish() - } - - - #[inline] - pub fn current_statuses(&self) -> Option>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(StatusSystemResponse::VT_CURRENT_STATUSES, None)} - } -} - -impl flatbuffers::Verifiable for StatusSystemResponse<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>>>("current_statuses", Self::VT_CURRENT_STATUSES, false)? - .finish(); - Ok(()) - } -} -pub struct StatusSystemResponseArgs<'a> { - pub current_statuses: Option>>>>, -} -impl<'a> Default for StatusSystemResponseArgs<'a> { - #[inline] - fn default() -> Self { - StatusSystemResponseArgs { - current_statuses: None, - } - } -} - -pub struct StatusSystemResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusSystemResponseBuilder<'a, 'b> { - #[inline] - pub fn add_current_statuses(&mut self, current_statuses: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(StatusSystemResponse::VT_CURRENT_STATUSES, current_statuses); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusSystemResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusSystemResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusSystemResponse<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusSystemResponse"); - ds.field("current_statuses", &self.current_statuses()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_update_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_update_generated.rs deleted file mode 100644 index d46394656..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_update_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusSystemUpdateOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// When a new status appears, it's sent alone -pub struct StatusSystemUpdate<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusSystemUpdate<'a> { - type Inner = StatusSystemUpdate<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusSystemUpdate<'a> { - pub const VT_NEW_STATUS: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusSystemUpdate { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusSystemUpdateArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusSystemUpdateBuilder::new(_fbb); - if let Some(x) = args.new_status { builder.add_new_status(x); } - builder.finish() - } - - - #[inline] - pub fn new_status(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(StatusSystemUpdate::VT_NEW_STATUS, None)} - } -} - -impl flatbuffers::Verifiable for StatusSystemUpdate<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("new_status", Self::VT_NEW_STATUS, false)? - .finish(); - Ok(()) - } -} -pub struct StatusSystemUpdateArgs<'a> { - pub new_status: Option>>, -} -impl<'a> Default for StatusSystemUpdateArgs<'a> { - #[inline] - fn default() -> Self { - StatusSystemUpdateArgs { - new_status: None, - } - } -} - -pub struct StatusSystemUpdateBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusSystemUpdateBuilder<'a, 'b> { - #[inline] - pub fn add_new_status(&mut self, new_status: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(StatusSystemUpdate::VT_NEW_STATUS, new_status); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusSystemUpdateBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusSystemUpdateBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusSystemUpdate<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusSystemUpdate"); - ds.field("new_status", &self.new_status()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs deleted file mode 100644 index 18bc87f1c..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusTrackerErrorOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Trackers with error state -pub struct StatusTrackerError<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusTrackerError<'a> { - type Inner = StatusTrackerError<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusTrackerError<'a> { - pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusTrackerError { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusTrackerErrorArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusTrackerErrorBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } - builder.finish() - } - - - #[inline] - pub fn tracker_id(&self) -> Option>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(StatusTrackerError::VT_TRACKER_ID, None)} - } -} - -impl flatbuffers::Verifiable for StatusTrackerError<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>>>("tracker_id", Self::VT_TRACKER_ID, false)? - .finish(); - Ok(()) - } -} -pub struct StatusTrackerErrorArgs<'a> { - pub tracker_id: Option>>>>, -} -impl<'a> Default for StatusTrackerErrorArgs<'a> { - #[inline] - fn default() -> Self { - StatusTrackerErrorArgs { - tracker_id: None, - } - } -} - -pub struct StatusTrackerErrorBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusTrackerErrorBuilder<'a, 'b> { - #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(StatusTrackerError::VT_TRACKER_ID, tracker_id); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusTrackerErrorBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusTrackerErrorBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusTrackerError<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusTrackerError"); - ds.field("tracker_id", &self.tracker_id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs deleted file mode 100644 index a1a125cda..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusTrackerResetOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// Tracker requires full reset -pub struct StatusTrackerReset<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusTrackerReset<'a> { - type Inner = StatusTrackerReset<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusTrackerReset<'a> { - pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusTrackerReset { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusTrackerResetArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusTrackerResetBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } - builder.finish() - } - - - #[inline] - pub fn tracker_id(&self) -> Option>>> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>>>(StatusTrackerReset::VT_TRACKER_ID, None)} - } -} - -impl flatbuffers::Verifiable for StatusTrackerReset<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>>>("tracker_id", Self::VT_TRACKER_ID, false)? - .finish(); - Ok(()) - } -} -pub struct StatusTrackerResetArgs<'a> { - pub tracker_id: Option>>>>, -} -impl<'a> Default for StatusTrackerResetArgs<'a> { - #[inline] - fn default() -> Self { - StatusTrackerResetArgs { - tracker_id: None, - } - } -} - -pub struct StatusTrackerResetBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusTrackerResetBuilder<'a, 'b> { - #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(StatusTrackerReset::VT_TRACKER_ID, tracker_id); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusTrackerResetBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusTrackerResetBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusTrackerReset<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusTrackerReset"); - ds.field("tracker_id", &self.tracker_id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_unassigned_hmd_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_unassigned_hmd_generated.rs deleted file mode 100644 index 3e728c0e9..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_unassigned_hmd_generated.rs +++ /dev/null @@ -1,109 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StatusUnassignedHMDOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// There is an available HMD tracker and it's not assigned to head -pub struct StatusUnassignedHMD<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StatusUnassignedHMD<'a> { - type Inner = StatusUnassignedHMD<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StatusUnassignedHMD<'a> { - pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusUnassignedHMD { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StatusUnassignedHMDArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusUnassignedHMDBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } - builder.finish() - } - - - #[inline] - pub fn tracker_id(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(StatusUnassignedHMD::VT_TRACKER_ID, None)} - } -} - -impl flatbuffers::Verifiable for StatusUnassignedHMD<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? - .finish(); - Ok(()) - } -} -pub struct StatusUnassignedHMDArgs<'a> { - pub tracker_id: Option>>, -} -impl<'a> Default for StatusUnassignedHMDArgs<'a> { - #[inline] - fn default() -> Self { - StatusUnassignedHMDArgs { - tracker_id: None, - } - } -} - -pub struct StatusUnassignedHMDBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StatusUnassignedHMDBuilder<'a, 'b> { - #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(StatusUnassignedHMD::VT_TRACKER_ID, tracker_id); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusUnassignedHMDBuilder<'a, 'b> { - let start = _fbb.start_table(); - StatusUnassignedHMDBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StatusUnassignedHMD<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusUnassignedHMD"); - ds.field("tracker_id", &self.tracker_id()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_hide_correction_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_hide_correction_request_generated.rs new file mode 100644 index 000000000..7a3e612d0 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_hide_correction_request_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum StayAlignedHideCorrectionRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct StayAlignedHideCorrectionRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for StayAlignedHideCorrectionRequest<'a> { + type Inner = StayAlignedHideCorrectionRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> StayAlignedHideCorrectionRequest<'a> { + pub const VT_HIDE_CORRECTION: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + StayAlignedHideCorrectionRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args StayAlignedHideCorrectionRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = StayAlignedHideCorrectionRequestBuilder::new(_fbb); + builder.add_hide_correction(args.hide_correction); + builder.finish() + } + + + #[inline] + pub fn hide_correction(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedHideCorrectionRequest::VT_HIDE_CORRECTION, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for StayAlignedHideCorrectionRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("hide_correction", Self::VT_HIDE_CORRECTION, false)? + .finish(); + Ok(()) + } +} +pub struct StayAlignedHideCorrectionRequestArgs { + pub hide_correction: bool, +} +impl<'a> Default for StayAlignedHideCorrectionRequestArgs { + #[inline] + fn default() -> Self { + StayAlignedHideCorrectionRequestArgs { + hide_correction: false, + } + } +} + +pub struct StayAlignedHideCorrectionRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> StayAlignedHideCorrectionRequestBuilder<'a, 'b> { + #[inline] + pub fn add_hide_correction(&mut self, hide_correction: bool) { + self.fbb_.push_slot::(StayAlignedHideCorrectionRequest::VT_HIDE_CORRECTION, hide_correction, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StayAlignedHideCorrectionRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + StayAlignedHideCorrectionRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for StayAlignedHideCorrectionRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("StayAlignedHideCorrectionRequest"); + ds.field("hide_correction", &self.hide_correction()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_generated.rs deleted file mode 100644 index fb2d54084..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_generated.rs +++ /dev/null @@ -1,363 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum StayAlignedSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct StayAlignedSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for StayAlignedSettings<'a> { - type Inner = StayAlignedSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> StayAlignedSettings<'a> { - pub const VT_ENABLED: flatbuffers::VOffsetT = 4; - pub const VT_EXTRAYAWCORRECTION: flatbuffers::VOffsetT = 6; - pub const VT_HIDEYAWCORRECTION: flatbuffers::VOffsetT = 8; - pub const VT_STANDINGENABLED: flatbuffers::VOffsetT = 10; - pub const VT_STANDINGUPPERLEGANGLE: flatbuffers::VOffsetT = 12; - pub const VT_STANDINGLOWERLEGANGLE: flatbuffers::VOffsetT = 14; - pub const VT_STANDINGFOOTANGLE: flatbuffers::VOffsetT = 16; - pub const VT_SITTINGENABLED: flatbuffers::VOffsetT = 18; - pub const VT_SITTINGUPPERLEGANGLE: flatbuffers::VOffsetT = 20; - pub const VT_SITTINGLOWERLEGANGLE: flatbuffers::VOffsetT = 22; - pub const VT_SITTINGFOOTANGLE: flatbuffers::VOffsetT = 24; - pub const VT_FLATENABLED: flatbuffers::VOffsetT = 26; - pub const VT_FLATUPPERLEGANGLE: flatbuffers::VOffsetT = 28; - pub const VT_FLATLOWERLEGANGLE: flatbuffers::VOffsetT = 30; - pub const VT_FLATFOOTANGLE: flatbuffers::VOffsetT = 32; - pub const VT_SETUPCOMPLETE: flatbuffers::VOffsetT = 34; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StayAlignedSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StayAlignedSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = StayAlignedSettingsBuilder::new(_fbb); - builder.add_flatFootAngle(args.flatFootAngle); - builder.add_flatLowerLegAngle(args.flatLowerLegAngle); - builder.add_flatUpperLegAngle(args.flatUpperLegAngle); - builder.add_sittingFootAngle(args.sittingFootAngle); - builder.add_sittingLowerLegAngle(args.sittingLowerLegAngle); - builder.add_sittingUpperLegAngle(args.sittingUpperLegAngle); - builder.add_standingFootAngle(args.standingFootAngle); - builder.add_standingLowerLegAngle(args.standingLowerLegAngle); - builder.add_standingUpperLegAngle(args.standingUpperLegAngle); - builder.add_setupComplete(args.setupComplete); - builder.add_flatEnabled(args.flatEnabled); - builder.add_sittingEnabled(args.sittingEnabled); - builder.add_standingEnabled(args.standingEnabled); - builder.add_hideYawCorrection(args.hideYawCorrection); - builder.add_extraYawCorrection(args.extraYawCorrection); - builder.add_enabled(args.enabled); - builder.finish() - } - - - #[inline] - pub fn enabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_ENABLED, Some(false)).unwrap()} - } - #[inline] - pub fn extraYawCorrection(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_EXTRAYAWCORRECTION, Some(false)).unwrap()} - } - #[inline] - pub fn hideYawCorrection(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_HIDEYAWCORRECTION, Some(false)).unwrap()} - } - #[inline] - pub fn standingEnabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_STANDINGENABLED, Some(false)).unwrap()} - } - #[inline] - pub fn standingUpperLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_STANDINGUPPERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn standingLowerLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_STANDINGLOWERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn standingFootAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_STANDINGFOOTANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn sittingEnabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_SITTINGENABLED, Some(false)).unwrap()} - } - #[inline] - pub fn sittingUpperLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_SITTINGUPPERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn sittingLowerLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_SITTINGLOWERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn sittingFootAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_SITTINGFOOTANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn flatEnabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_FLATENABLED, Some(false)).unwrap()} - } - #[inline] - pub fn flatUpperLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_FLATUPPERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn flatLowerLegAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_FLATLOWERLEGANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn flatFootAngle(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_FLATFOOTANGLE, Some(0.0)).unwrap()} - } - #[inline] - pub fn setupComplete(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(StayAlignedSettings::VT_SETUPCOMPLETE, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for StayAlignedSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("enabled", Self::VT_ENABLED, false)? - .visit_field::("extraYawCorrection", Self::VT_EXTRAYAWCORRECTION, false)? - .visit_field::("hideYawCorrection", Self::VT_HIDEYAWCORRECTION, false)? - .visit_field::("standingEnabled", Self::VT_STANDINGENABLED, false)? - .visit_field::("standingUpperLegAngle", Self::VT_STANDINGUPPERLEGANGLE, false)? - .visit_field::("standingLowerLegAngle", Self::VT_STANDINGLOWERLEGANGLE, false)? - .visit_field::("standingFootAngle", Self::VT_STANDINGFOOTANGLE, false)? - .visit_field::("sittingEnabled", Self::VT_SITTINGENABLED, false)? - .visit_field::("sittingUpperLegAngle", Self::VT_SITTINGUPPERLEGANGLE, false)? - .visit_field::("sittingLowerLegAngle", Self::VT_SITTINGLOWERLEGANGLE, false)? - .visit_field::("sittingFootAngle", Self::VT_SITTINGFOOTANGLE, false)? - .visit_field::("flatEnabled", Self::VT_FLATENABLED, false)? - .visit_field::("flatUpperLegAngle", Self::VT_FLATUPPERLEGANGLE, false)? - .visit_field::("flatLowerLegAngle", Self::VT_FLATLOWERLEGANGLE, false)? - .visit_field::("flatFootAngle", Self::VT_FLATFOOTANGLE, false)? - .visit_field::("setupComplete", Self::VT_SETUPCOMPLETE, false)? - .finish(); - Ok(()) - } -} -pub struct StayAlignedSettingsArgs { - pub enabled: bool, - pub extraYawCorrection: bool, - pub hideYawCorrection: bool, - pub standingEnabled: bool, - pub standingUpperLegAngle: f32, - pub standingLowerLegAngle: f32, - pub standingFootAngle: f32, - pub sittingEnabled: bool, - pub sittingUpperLegAngle: f32, - pub sittingLowerLegAngle: f32, - pub sittingFootAngle: f32, - pub flatEnabled: bool, - pub flatUpperLegAngle: f32, - pub flatLowerLegAngle: f32, - pub flatFootAngle: f32, - pub setupComplete: bool, -} -impl<'a> Default for StayAlignedSettingsArgs { - #[inline] - fn default() -> Self { - StayAlignedSettingsArgs { - enabled: false, - extraYawCorrection: false, - hideYawCorrection: false, - standingEnabled: false, - standingUpperLegAngle: 0.0, - standingLowerLegAngle: 0.0, - standingFootAngle: 0.0, - sittingEnabled: false, - sittingUpperLegAngle: 0.0, - sittingLowerLegAngle: 0.0, - sittingFootAngle: 0.0, - flatEnabled: false, - flatUpperLegAngle: 0.0, - flatLowerLegAngle: 0.0, - flatFootAngle: 0.0, - setupComplete: false, - } - } -} - -pub struct StayAlignedSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> StayAlignedSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_enabled(&mut self, enabled: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_ENABLED, enabled, false); - } - #[inline] - pub fn add_extraYawCorrection(&mut self, extraYawCorrection: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_EXTRAYAWCORRECTION, extraYawCorrection, false); - } - #[inline] - pub fn add_hideYawCorrection(&mut self, hideYawCorrection: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_HIDEYAWCORRECTION, hideYawCorrection, false); - } - #[inline] - pub fn add_standingEnabled(&mut self, standingEnabled: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_STANDINGENABLED, standingEnabled, false); - } - #[inline] - pub fn add_standingUpperLegAngle(&mut self, standingUpperLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_STANDINGUPPERLEGANGLE, standingUpperLegAngle, 0.0); - } - #[inline] - pub fn add_standingLowerLegAngle(&mut self, standingLowerLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_STANDINGLOWERLEGANGLE, standingLowerLegAngle, 0.0); - } - #[inline] - pub fn add_standingFootAngle(&mut self, standingFootAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_STANDINGFOOTANGLE, standingFootAngle, 0.0); - } - #[inline] - pub fn add_sittingEnabled(&mut self, sittingEnabled: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_SITTINGENABLED, sittingEnabled, false); - } - #[inline] - pub fn add_sittingUpperLegAngle(&mut self, sittingUpperLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_SITTINGUPPERLEGANGLE, sittingUpperLegAngle, 0.0); - } - #[inline] - pub fn add_sittingLowerLegAngle(&mut self, sittingLowerLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_SITTINGLOWERLEGANGLE, sittingLowerLegAngle, 0.0); - } - #[inline] - pub fn add_sittingFootAngle(&mut self, sittingFootAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_SITTINGFOOTANGLE, sittingFootAngle, 0.0); - } - #[inline] - pub fn add_flatEnabled(&mut self, flatEnabled: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_FLATENABLED, flatEnabled, false); - } - #[inline] - pub fn add_flatUpperLegAngle(&mut self, flatUpperLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_FLATUPPERLEGANGLE, flatUpperLegAngle, 0.0); - } - #[inline] - pub fn add_flatLowerLegAngle(&mut self, flatLowerLegAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_FLATLOWERLEGANGLE, flatLowerLegAngle, 0.0); - } - #[inline] - pub fn add_flatFootAngle(&mut self, flatFootAngle: f32) { - self.fbb_.push_slot::(StayAlignedSettings::VT_FLATFOOTANGLE, flatFootAngle, 0.0); - } - #[inline] - pub fn add_setupComplete(&mut self, setupComplete: bool) { - self.fbb_.push_slot::(StayAlignedSettings::VT_SETUPCOMPLETE, setupComplete, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StayAlignedSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - StayAlignedSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for StayAlignedSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StayAlignedSettings"); - ds.field("enabled", &self.enabled()); - ds.field("extraYawCorrection", &self.extraYawCorrection()); - ds.field("hideYawCorrection", &self.hideYawCorrection()); - ds.field("standingEnabled", &self.standingEnabled()); - ds.field("standingUpperLegAngle", &self.standingUpperLegAngle()); - ds.field("standingLowerLegAngle", &self.standingLowerLegAngle()); - ds.field("standingFootAngle", &self.standingFootAngle()); - ds.field("sittingEnabled", &self.sittingEnabled()); - ds.field("sittingUpperLegAngle", &self.sittingUpperLegAngle()); - ds.field("sittingLowerLegAngle", &self.sittingLowerLegAngle()); - ds.field("sittingFootAngle", &self.sittingFootAngle()); - ds.field("flatEnabled", &self.flatEnabled()); - ds.field("flatUpperLegAngle", &self.flatUpperLegAngle()); - ds.field("flatLowerLegAngle", &self.flatLowerLegAngle()); - ds.field("flatFootAngle", &self.flatFootAngle()); - ds.field("setupComplete", &self.setupComplete()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_request_generated.rs new file mode 100644 index 000000000..dc2dc433d --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum StayAlignedSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct StayAlignedSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for StayAlignedSettingsRequest<'a> { + type Inner = StayAlignedSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> StayAlignedSettingsRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + StayAlignedSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args StayAlignedSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = StayAlignedSettingsRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for StayAlignedSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct StayAlignedSettingsRequestArgs { +} +impl<'a> Default for StayAlignedSettingsRequestArgs { + #[inline] + fn default() -> Self { + StayAlignedSettingsRequestArgs { + } + } +} + +pub struct StayAlignedSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> StayAlignedSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StayAlignedSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + StayAlignedSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for StayAlignedSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("StayAlignedSettingsRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_response_generated.rs new file mode 100644 index 000000000..e8b144eb8 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/stay_aligned_settings_response_generated.rs @@ -0,0 +1,312 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum StayAlignedSettingsResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct StayAlignedSettingsResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for StayAlignedSettingsResponse<'a> { + type Inner = StayAlignedSettingsResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> StayAlignedSettingsResponse<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_STANDING_ENABLED: flatbuffers::VOffsetT = 6; + pub const VT_STANDING_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 8; + pub const VT_STANDING_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 10; + pub const VT_STANDING_FOOT_ANGLE: flatbuffers::VOffsetT = 12; + pub const VT_SITTING_ENABLED: flatbuffers::VOffsetT = 14; + pub const VT_SITTING_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 16; + pub const VT_SITTING_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 18; + pub const VT_SITTING_FOOT_ANGLE: flatbuffers::VOffsetT = 20; + pub const VT_FLAT_ENABLED: flatbuffers::VOffsetT = 22; + pub const VT_FLAT_UPPER_LEG_ANGLE: flatbuffers::VOffsetT = 24; + pub const VT_FLAT_LOWER_LEG_ANGLE: flatbuffers::VOffsetT = 26; + pub const VT_FLAT_FOOT_ANGLE: flatbuffers::VOffsetT = 28; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + StayAlignedSettingsResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args StayAlignedSettingsResponseArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = StayAlignedSettingsResponseBuilder::new(_fbb); + builder.add_flat_foot_angle(args.flat_foot_angle); + builder.add_flat_lower_leg_angle(args.flat_lower_leg_angle); + builder.add_flat_upper_leg_angle(args.flat_upper_leg_angle); + builder.add_sitting_foot_angle(args.sitting_foot_angle); + builder.add_sitting_lower_leg_angle(args.sitting_lower_leg_angle); + builder.add_sitting_upper_leg_angle(args.sitting_upper_leg_angle); + builder.add_standing_foot_angle(args.standing_foot_angle); + builder.add_standing_lower_leg_angle(args.standing_lower_leg_angle); + builder.add_standing_upper_leg_angle(args.standing_upper_leg_angle); + builder.add_flat_enabled(args.flat_enabled); + builder.add_sitting_enabled(args.sitting_enabled); + builder.add_standing_enabled(args.standing_enabled); + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn standing_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_STANDING_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn standing_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_STANDING_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn standing_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_STANDING_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn standing_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_STANDING_FOOT_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_SITTING_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn sitting_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_SITTING_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_SITTING_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn sitting_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_SITTING_FOOT_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_FLAT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn flat_upper_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_FLAT_UPPER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_lower_leg_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_FLAT_LOWER_LEG_ANGLE, Some(0.0)).unwrap()} + } + #[inline] + pub fn flat_foot_angle(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(StayAlignedSettingsResponse::VT_FLAT_FOOT_ANGLE, Some(0.0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for StayAlignedSettingsResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("standing_enabled", Self::VT_STANDING_ENABLED, false)? + .visit_field::("standing_upper_leg_angle", Self::VT_STANDING_UPPER_LEG_ANGLE, false)? + .visit_field::("standing_lower_leg_angle", Self::VT_STANDING_LOWER_LEG_ANGLE, false)? + .visit_field::("standing_foot_angle", Self::VT_STANDING_FOOT_ANGLE, false)? + .visit_field::("sitting_enabled", Self::VT_SITTING_ENABLED, false)? + .visit_field::("sitting_upper_leg_angle", Self::VT_SITTING_UPPER_LEG_ANGLE, false)? + .visit_field::("sitting_lower_leg_angle", Self::VT_SITTING_LOWER_LEG_ANGLE, false)? + .visit_field::("sitting_foot_angle", Self::VT_SITTING_FOOT_ANGLE, false)? + .visit_field::("flat_enabled", Self::VT_FLAT_ENABLED, false)? + .visit_field::("flat_upper_leg_angle", Self::VT_FLAT_UPPER_LEG_ANGLE, false)? + .visit_field::("flat_lower_leg_angle", Self::VT_FLAT_LOWER_LEG_ANGLE, false)? + .visit_field::("flat_foot_angle", Self::VT_FLAT_FOOT_ANGLE, false)? + .finish(); + Ok(()) + } +} +pub struct StayAlignedSettingsResponseArgs { + pub enabled: bool, + pub standing_enabled: bool, + pub standing_upper_leg_angle: f32, + pub standing_lower_leg_angle: f32, + pub standing_foot_angle: f32, + pub sitting_enabled: bool, + pub sitting_upper_leg_angle: f32, + pub sitting_lower_leg_angle: f32, + pub sitting_foot_angle: f32, + pub flat_enabled: bool, + pub flat_upper_leg_angle: f32, + pub flat_lower_leg_angle: f32, + pub flat_foot_angle: f32, +} +impl<'a> Default for StayAlignedSettingsResponseArgs { + #[inline] + fn default() -> Self { + StayAlignedSettingsResponseArgs { + enabled: false, + standing_enabled: false, + standing_upper_leg_angle: 0.0, + standing_lower_leg_angle: 0.0, + standing_foot_angle: 0.0, + sitting_enabled: false, + sitting_upper_leg_angle: 0.0, + sitting_lower_leg_angle: 0.0, + sitting_foot_angle: 0.0, + flat_enabled: false, + flat_upper_leg_angle: 0.0, + flat_lower_leg_angle: 0.0, + flat_foot_angle: 0.0, + } + } +} + +pub struct StayAlignedSettingsResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> StayAlignedSettingsResponseBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_standing_enabled(&mut self, standing_enabled: bool) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_STANDING_ENABLED, standing_enabled, false); + } + #[inline] + pub fn add_standing_upper_leg_angle(&mut self, standing_upper_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_STANDING_UPPER_LEG_ANGLE, standing_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_standing_lower_leg_angle(&mut self, standing_lower_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_STANDING_LOWER_LEG_ANGLE, standing_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_standing_foot_angle(&mut self, standing_foot_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_STANDING_FOOT_ANGLE, standing_foot_angle, 0.0); + } + #[inline] + pub fn add_sitting_enabled(&mut self, sitting_enabled: bool) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_SITTING_ENABLED, sitting_enabled, false); + } + #[inline] + pub fn add_sitting_upper_leg_angle(&mut self, sitting_upper_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_SITTING_UPPER_LEG_ANGLE, sitting_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_sitting_lower_leg_angle(&mut self, sitting_lower_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_SITTING_LOWER_LEG_ANGLE, sitting_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_sitting_foot_angle(&mut self, sitting_foot_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_SITTING_FOOT_ANGLE, sitting_foot_angle, 0.0); + } + #[inline] + pub fn add_flat_enabled(&mut self, flat_enabled: bool) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_FLAT_ENABLED, flat_enabled, false); + } + #[inline] + pub fn add_flat_upper_leg_angle(&mut self, flat_upper_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_FLAT_UPPER_LEG_ANGLE, flat_upper_leg_angle, 0.0); + } + #[inline] + pub fn add_flat_lower_leg_angle(&mut self, flat_lower_leg_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_FLAT_LOWER_LEG_ANGLE, flat_lower_leg_angle, 0.0); + } + #[inline] + pub fn add_flat_foot_angle(&mut self, flat_foot_angle: f32) { + self.fbb_.push_slot::(StayAlignedSettingsResponse::VT_FLAT_FOOT_ANGLE, flat_foot_angle, 0.0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StayAlignedSettingsResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + StayAlignedSettingsResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for StayAlignedSettingsResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("StayAlignedSettingsResponse"); + ds.field("enabled", &self.enabled()); + ds.field("standing_enabled", &self.standing_enabled()); + ds.field("standing_upper_leg_angle", &self.standing_upper_leg_angle()); + ds.field("standing_lower_leg_angle", &self.standing_lower_leg_angle()); + ds.field("standing_foot_angle", &self.standing_foot_angle()); + ds.field("sitting_enabled", &self.sitting_enabled()); + ds.field("sitting_upper_leg_angle", &self.sitting_upper_leg_angle()); + ds.field("sitting_lower_leg_angle", &self.sitting_lower_leg_angle()); + ds.field("sitting_foot_angle", &self.sitting_foot_angle()); + ds.field("flat_enabled", &self.flat_enabled()); + ds.field("flat_upper_leg_angle", &self.flat_upper_leg_angle()); + ds.field("flat_lower_leg_angle", &self.flat_lower_leg_angle()); + ds.field("flat_foot_angle", &self.flat_foot_angle()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/steam_vrtrackers_setting_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/steam_vrtrackers_setting_generated.rs deleted file mode 100644 index 77165e29b..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/steam_vrtrackers_setting_generated.rs +++ /dev/null @@ -1,278 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum SteamVRTrackersSettingOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct SteamVRTrackersSetting<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for SteamVRTrackersSetting<'a> { - type Inner = SteamVRTrackersSetting<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> SteamVRTrackersSetting<'a> { - pub const VT_WAIST: flatbuffers::VOffsetT = 4; - pub const VT_CHEST: flatbuffers::VOffsetT = 6; - pub const VT_AUTOMATICTRACKERTOGGLE: flatbuffers::VOffsetT = 16; - pub const VT_LEFT_FOOT: flatbuffers::VOffsetT = 18; - pub const VT_RIGHT_FOOT: flatbuffers::VOffsetT = 20; - pub const VT_LEFT_KNEE: flatbuffers::VOffsetT = 22; - pub const VT_RIGHT_KNEE: flatbuffers::VOffsetT = 24; - pub const VT_LEFT_ELBOW: flatbuffers::VOffsetT = 26; - pub const VT_RIGHT_ELBOW: flatbuffers::VOffsetT = 28; - pub const VT_LEFT_HAND: flatbuffers::VOffsetT = 30; - pub const VT_RIGHT_HAND: flatbuffers::VOffsetT = 32; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SteamVRTrackersSetting { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SteamVRTrackersSettingArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = SteamVRTrackersSettingBuilder::new(_fbb); - builder.add_right_hand(args.right_hand); - builder.add_left_hand(args.left_hand); - builder.add_right_elbow(args.right_elbow); - builder.add_left_elbow(args.left_elbow); - builder.add_right_knee(args.right_knee); - builder.add_left_knee(args.left_knee); - builder.add_right_foot(args.right_foot); - builder.add_left_foot(args.left_foot); - builder.add_automaticTrackerToggle(args.automaticTrackerToggle); - builder.add_chest(args.chest); - builder.add_waist(args.waist); - builder.finish() - } - - - #[inline] - pub fn waist(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_WAIST, Some(false)).unwrap()} - } - #[inline] - pub fn chest(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_CHEST, Some(false)).unwrap()} - } - #[inline] - pub fn automaticTrackerToggle(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_AUTOMATICTRACKERTOGGLE, Some(false)).unwrap()} - } - #[inline] - pub fn left_foot(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_LEFT_FOOT, Some(false)).unwrap()} - } - #[inline] - pub fn right_foot(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_RIGHT_FOOT, Some(false)).unwrap()} - } - #[inline] - pub fn left_knee(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_LEFT_KNEE, Some(false)).unwrap()} - } - #[inline] - pub fn right_knee(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_RIGHT_KNEE, Some(false)).unwrap()} - } - #[inline] - pub fn left_elbow(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_LEFT_ELBOW, Some(false)).unwrap()} - } - #[inline] - pub fn right_elbow(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_RIGHT_ELBOW, Some(false)).unwrap()} - } - #[inline] - pub fn left_hand(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_LEFT_HAND, Some(false)).unwrap()} - } - #[inline] - pub fn right_hand(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(SteamVRTrackersSetting::VT_RIGHT_HAND, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for SteamVRTrackersSetting<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("waist", Self::VT_WAIST, false)? - .visit_field::("chest", Self::VT_CHEST, false)? - .visit_field::("automaticTrackerToggle", Self::VT_AUTOMATICTRACKERTOGGLE, false)? - .visit_field::("left_foot", Self::VT_LEFT_FOOT, false)? - .visit_field::("right_foot", Self::VT_RIGHT_FOOT, false)? - .visit_field::("left_knee", Self::VT_LEFT_KNEE, false)? - .visit_field::("right_knee", Self::VT_RIGHT_KNEE, false)? - .visit_field::("left_elbow", Self::VT_LEFT_ELBOW, false)? - .visit_field::("right_elbow", Self::VT_RIGHT_ELBOW, false)? - .visit_field::("left_hand", Self::VT_LEFT_HAND, false)? - .visit_field::("right_hand", Self::VT_RIGHT_HAND, false)? - .finish(); - Ok(()) - } -} -pub struct SteamVRTrackersSettingArgs { - pub waist: bool, - pub chest: bool, - pub automaticTrackerToggle: bool, - pub left_foot: bool, - pub right_foot: bool, - pub left_knee: bool, - pub right_knee: bool, - pub left_elbow: bool, - pub right_elbow: bool, - pub left_hand: bool, - pub right_hand: bool, -} -impl<'a> Default for SteamVRTrackersSettingArgs { - #[inline] - fn default() -> Self { - SteamVRTrackersSettingArgs { - waist: false, - chest: false, - automaticTrackerToggle: false, - left_foot: false, - right_foot: false, - left_knee: false, - right_knee: false, - left_elbow: false, - right_elbow: false, - left_hand: false, - right_hand: false, - } - } -} - -pub struct SteamVRTrackersSettingBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> SteamVRTrackersSettingBuilder<'a, 'b> { - #[inline] - pub fn add_waist(&mut self, waist: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_WAIST, waist, false); - } - #[inline] - pub fn add_chest(&mut self, chest: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_CHEST, chest, false); - } - #[inline] - pub fn add_automaticTrackerToggle(&mut self, automaticTrackerToggle: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_AUTOMATICTRACKERTOGGLE, automaticTrackerToggle, false); - } - #[inline] - pub fn add_left_foot(&mut self, left_foot: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_LEFT_FOOT, left_foot, false); - } - #[inline] - pub fn add_right_foot(&mut self, right_foot: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_RIGHT_FOOT, right_foot, false); - } - #[inline] - pub fn add_left_knee(&mut self, left_knee: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_LEFT_KNEE, left_knee, false); - } - #[inline] - pub fn add_right_knee(&mut self, right_knee: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_RIGHT_KNEE, right_knee, false); - } - #[inline] - pub fn add_left_elbow(&mut self, left_elbow: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_LEFT_ELBOW, left_elbow, false); - } - #[inline] - pub fn add_right_elbow(&mut self, right_elbow: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_RIGHT_ELBOW, right_elbow, false); - } - #[inline] - pub fn add_left_hand(&mut self, left_hand: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_LEFT_HAND, left_hand, false); - } - #[inline] - pub fn add_right_hand(&mut self, right_hand: bool) { - self.fbb_.push_slot::(SteamVRTrackersSetting::VT_RIGHT_HAND, right_hand, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SteamVRTrackersSettingBuilder<'a, 'b> { - let start = _fbb.start_table(); - SteamVRTrackersSettingBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for SteamVRTrackersSetting<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SteamVRTrackersSetting"); - ds.field("waist", &self.waist()); - ds.field("chest", &self.chest()); - ds.field("automaticTrackerToggle", &self.automaticTrackerToggle()); - ds.field("left_foot", &self.left_foot()); - ds.field("right_foot", &self.right_foot()); - ds.field("left_knee", &self.left_knee()); - ds.field("right_knee", &self.right_knee()); - ds.field("left_elbow", &self.left_elbow()); - ds.field("right_elbow", &self.right_elbow()); - ds.field("left_hand", &self.left_hand()); - ds.field("right_hand", &self.right_hand()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_request_generated.rs new file mode 100644 index 000000000..7c0f4909e --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TapDetectionSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TapDetectionSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TapDetectionSettingsRequest<'a> { + type Inner = TapDetectionSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TapDetectionSettingsRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TapDetectionSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args TapDetectionSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = TapDetectionSettingsRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for TapDetectionSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct TapDetectionSettingsRequestArgs { +} +impl<'a> Default for TapDetectionSettingsRequestArgs { + #[inline] + fn default() -> Self { + TapDetectionSettingsRequestArgs { + } + } +} + +pub struct TapDetectionSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TapDetectionSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TapDetectionSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + TapDetectionSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for TapDetectionSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TapDetectionSettingsRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_response_generated.rs similarity index 71% rename from protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_response_generated.rs index 989fd52fe..22a27a56e 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_settings_response_generated.rs @@ -9,22 +9,22 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum TapDetectionSettingsOffset {} +pub enum TapDetectionSettingsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct TapDetectionSettings<'a> { +pub struct TapDetectionSettingsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for TapDetectionSettings<'a> { - type Inner = TapDetectionSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for TapDetectionSettingsResponse<'a> { + type Inner = TapDetectionSettingsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> TapDetectionSettings<'a> { +impl<'a> TapDetectionSettingsResponse<'a> { pub const VT_FULL_RESET_DELAY: flatbuffers::VOffsetT = 4; pub const VT_FULL_RESET_ENABLED: flatbuffers::VOffsetT = 6; pub const VT_FULL_RESET_TAPS: flatbuffers::VOffsetT = 8; @@ -34,22 +34,21 @@ impl<'a> TapDetectionSettings<'a> { pub const VT_MOUNTING_RESET_DELAY: flatbuffers::VOffsetT = 16; pub const VT_MOUNTING_RESET_ENABLED: flatbuffers::VOffsetT = 18; pub const VT_MOUNTING_RESET_TAPS: flatbuffers::VOffsetT = 20; - pub const VT_SETUP_MODE: flatbuffers::VOffsetT = 22; - pub const VT_NUMBER_TRACKERS_OVER_THRESHOLD: flatbuffers::VOffsetT = 24; - pub const VT_YAW_RESET_TRACKER: flatbuffers::VOffsetT = 26; - pub const VT_FULL_RESET_TRACKER: flatbuffers::VOffsetT = 28; - pub const VT_MOUNTING_RESET_TRACKER: flatbuffers::VOffsetT = 30; + pub const VT_NUMBER_TRACKERS_OVER_THRESHOLD: flatbuffers::VOffsetT = 22; + pub const VT_YAW_RESET_TRACKER: flatbuffers::VOffsetT = 24; + pub const VT_FULL_RESET_TRACKER: flatbuffers::VOffsetT = 26; + pub const VT_MOUNTING_RESET_TRACKER: flatbuffers::VOffsetT = 28; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TapDetectionSettings { _tab: table } + TapDetectionSettingsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TapDetectionSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = TapDetectionSettingsBuilder::new(_fbb); + args: &'args TapDetectionSettingsResponseArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = TapDetectionSettingsResponseBuilder::new(_fbb); if let Some(x) = args.mounting_reset_delay { builder.add_mounting_reset_delay(x); } if let Some(x) = args.yaw_reset_delay { builder.add_yaw_reset_delay(x); } if let Some(x) = args.full_reset_delay { builder.add_full_reset_delay(x); } @@ -57,7 +56,6 @@ impl<'a> TapDetectionSettings<'a> { if let Some(x) = args.full_reset_tracker { builder.add_full_reset_tracker(x); } if let Some(x) = args.yaw_reset_tracker { builder.add_yaw_reset_tracker(x); } if let Some(x) = args.number_trackers_over_threshold { builder.add_number_trackers_over_threshold(x); } - if let Some(x) = args.setup_mode { builder.add_setup_mode(x); } if let Some(x) = args.mounting_reset_taps { builder.add_mounting_reset_taps(x); } if let Some(x) = args.mounting_reset_enabled { builder.add_mounting_reset_enabled(x); } if let Some(x) = args.yaw_reset_taps { builder.add_yaw_reset_taps(x); } @@ -73,104 +71,95 @@ impl<'a> TapDetectionSettings<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_FULL_RESET_DELAY, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_FULL_RESET_DELAY, None)} } #[inline] pub fn full_reset_enabled(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_FULL_RESET_ENABLED, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_FULL_RESET_ENABLED, None)} } #[inline] pub fn full_reset_taps(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_FULL_RESET_TAPS, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_FULL_RESET_TAPS, None)} } #[inline] pub fn yaw_reset_delay(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_YAW_RESET_DELAY, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_YAW_RESET_DELAY, None)} } #[inline] pub fn yaw_reset_enabled(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_YAW_RESET_ENABLED, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_YAW_RESET_ENABLED, None)} } #[inline] pub fn yaw_reset_taps(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_YAW_RESET_TAPS, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_YAW_RESET_TAPS, None)} } #[inline] pub fn mounting_reset_delay(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_MOUNTING_RESET_DELAY, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_DELAY, None)} } #[inline] pub fn mounting_reset_enabled(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_MOUNTING_RESET_ENABLED, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_ENABLED, None)} } #[inline] pub fn mounting_reset_taps(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_MOUNTING_RESET_TAPS, None)} - } - /// If true, disables reset behavior of tap detection and sends a - /// TapDetectionSetupNotification, each time 2 taps are detected on any tracker - #[inline] - pub fn setup_mode(&self) -> Option { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_SETUP_MODE, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TAPS, None)} } #[inline] pub fn number_trackers_over_threshold(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_NUMBER_TRACKERS_OVER_THRESHOLD, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_NUMBER_TRACKERS_OVER_THRESHOLD, None)} } #[inline] pub fn yaw_reset_tracker(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_YAW_RESET_TRACKER, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_YAW_RESET_TRACKER, None)} } #[inline] pub fn full_reset_tracker(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_FULL_RESET_TRACKER, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_FULL_RESET_TRACKER, None)} } #[inline] pub fn mounting_reset_tracker(&self) -> Option { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TapDetectionSettings::VT_MOUNTING_RESET_TRACKER, None)} + unsafe { self._tab.get::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TRACKER, None)} } } -impl flatbuffers::Verifiable for TapDetectionSettings<'_> { +impl flatbuffers::Verifiable for TapDetectionSettingsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -186,7 +175,6 @@ impl flatbuffers::Verifiable for TapDetectionSettings<'_> { .visit_field::("mounting_reset_delay", Self::VT_MOUNTING_RESET_DELAY, false)? .visit_field::("mounting_reset_enabled", Self::VT_MOUNTING_RESET_ENABLED, false)? .visit_field::("mounting_reset_taps", Self::VT_MOUNTING_RESET_TAPS, false)? - .visit_field::("setup_mode", Self::VT_SETUP_MODE, false)? .visit_field::("number_trackers_over_threshold", Self::VT_NUMBER_TRACKERS_OVER_THRESHOLD, false)? .visit_field::("yaw_reset_tracker", Self::VT_YAW_RESET_TRACKER, false)? .visit_field::("full_reset_tracker", Self::VT_FULL_RESET_TRACKER, false)? @@ -195,7 +183,7 @@ impl flatbuffers::Verifiable for TapDetectionSettings<'_> { Ok(()) } } -pub struct TapDetectionSettingsArgs { +pub struct TapDetectionSettingsResponseArgs { pub full_reset_delay: Option, pub full_reset_enabled: Option, pub full_reset_taps: Option, @@ -205,16 +193,15 @@ pub struct TapDetectionSettingsArgs { pub mounting_reset_delay: Option, pub mounting_reset_enabled: Option, pub mounting_reset_taps: Option, - pub setup_mode: Option, pub number_trackers_over_threshold: Option, pub yaw_reset_tracker: Option, pub full_reset_tracker: Option, pub mounting_reset_tracker: Option, } -impl<'a> Default for TapDetectionSettingsArgs { +impl<'a> Default for TapDetectionSettingsResponseArgs { #[inline] fn default() -> Self { - TapDetectionSettingsArgs { + TapDetectionSettingsResponseArgs { full_reset_delay: None, full_reset_enabled: None, full_reset_taps: None, @@ -224,7 +211,6 @@ impl<'a> Default for TapDetectionSettingsArgs { mounting_reset_delay: None, mounting_reset_enabled: None, mounting_reset_taps: None, - setup_mode: None, number_trackers_over_threshold: None, yaw_reset_tracker: None, full_reset_tracker: None, @@ -233,85 +219,81 @@ impl<'a> Default for TapDetectionSettingsArgs { } } -pub struct TapDetectionSettingsBuilder<'a: 'b, 'b> { +pub struct TapDetectionSettingsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> TapDetectionSettingsBuilder<'a, 'b> { +impl<'a: 'b, 'b> TapDetectionSettingsResponseBuilder<'a, 'b> { #[inline] pub fn add_full_reset_delay(&mut self, full_reset_delay: f32) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_FULL_RESET_DELAY, full_reset_delay); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_FULL_RESET_DELAY, full_reset_delay); } #[inline] pub fn add_full_reset_enabled(&mut self, full_reset_enabled: bool) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_FULL_RESET_ENABLED, full_reset_enabled); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_FULL_RESET_ENABLED, full_reset_enabled); } #[inline] pub fn add_full_reset_taps(&mut self, full_reset_taps: u8) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_FULL_RESET_TAPS, full_reset_taps); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_FULL_RESET_TAPS, full_reset_taps); } #[inline] pub fn add_yaw_reset_delay(&mut self, yaw_reset_delay: f32) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_YAW_RESET_DELAY, yaw_reset_delay); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_YAW_RESET_DELAY, yaw_reset_delay); } #[inline] pub fn add_yaw_reset_enabled(&mut self, yaw_reset_enabled: bool) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_YAW_RESET_ENABLED, yaw_reset_enabled); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_YAW_RESET_ENABLED, yaw_reset_enabled); } #[inline] pub fn add_yaw_reset_taps(&mut self, yaw_reset_taps: u8) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_YAW_RESET_TAPS, yaw_reset_taps); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_YAW_RESET_TAPS, yaw_reset_taps); } #[inline] pub fn add_mounting_reset_delay(&mut self, mounting_reset_delay: f32) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_DELAY, mounting_reset_delay); } #[inline] pub fn add_mounting_reset_enabled(&mut self, mounting_reset_enabled: bool) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_MOUNTING_RESET_ENABLED, mounting_reset_enabled); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_ENABLED, mounting_reset_enabled); } #[inline] pub fn add_mounting_reset_taps(&mut self, mounting_reset_taps: u8) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); - } - #[inline] - pub fn add_setup_mode(&mut self, setup_mode: bool) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_SETUP_MODE, setup_mode); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TAPS, mounting_reset_taps); } #[inline] pub fn add_number_trackers_over_threshold(&mut self, number_trackers_over_threshold: u8) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_NUMBER_TRACKERS_OVER_THRESHOLD, number_trackers_over_threshold); } #[inline] pub fn add_yaw_reset_tracker(&mut self, yaw_reset_tracker: super::datatypes::BodyPart) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_YAW_RESET_TRACKER, yaw_reset_tracker); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_YAW_RESET_TRACKER, yaw_reset_tracker); } #[inline] pub fn add_full_reset_tracker(&mut self, full_reset_tracker: super::datatypes::BodyPart) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_FULL_RESET_TRACKER, full_reset_tracker); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_FULL_RESET_TRACKER, full_reset_tracker); } #[inline] pub fn add_mounting_reset_tracker(&mut self, mounting_reset_tracker: super::datatypes::BodyPart) { - self.fbb_.push_slot_always::(TapDetectionSettings::VT_MOUNTING_RESET_TRACKER, mounting_reset_tracker); + self.fbb_.push_slot_always::(TapDetectionSettingsResponse::VT_MOUNTING_RESET_TRACKER, mounting_reset_tracker); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TapDetectionSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TapDetectionSettingsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - TapDetectionSettingsBuilder { + TapDetectionSettingsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for TapDetectionSettings<'_> { +impl core::fmt::Debug for TapDetectionSettingsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TapDetectionSettings"); + let mut ds = f.debug_struct("TapDetectionSettingsResponse"); ds.field("full_reset_delay", &self.full_reset_delay()); ds.field("full_reset_enabled", &self.full_reset_enabled()); ds.field("full_reset_taps", &self.full_reset_taps()); @@ -321,7 +303,6 @@ impl core::fmt::Debug for TapDetectionSettings<'_> { ds.field("mounting_reset_delay", &self.mounting_reset_delay()); ds.field("mounting_reset_enabled", &self.mounting_reset_enabled()); ds.field("mounting_reset_taps", &self.mounting_reset_taps()); - ds.field("setup_mode", &self.setup_mode()); ds.field("number_trackers_over_threshold", &self.number_trackers_over_threshold()); ds.field("yaw_reset_tracker", &self.yaw_reset_tracker()); ds.field("full_reset_tracker", &self.full_reset_tracker()); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_mode_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_mode_request_generated.rs new file mode 100644 index 000000000..2753b9175 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_mode_request_generated.rs @@ -0,0 +1,110 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TapDetectionSetupModeRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Sets the TapDetection setup mode. +pub struct TapDetectionSetupModeRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TapDetectionSetupModeRequest<'a> { + type Inner = TapDetectionSetupModeRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TapDetectionSetupModeRequest<'a> { + pub const VT_SETUP_MODE: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TapDetectionSetupModeRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TapDetectionSetupModeRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = TapDetectionSetupModeRequestBuilder::new(_fbb); + if let Some(x) = args.setup_mode { builder.add_setup_mode(x); } + builder.finish() + } + + + /// When true, TapDetection triggering a tracker will assign it instead of doing a reset. + #[inline] + pub fn setup_mode(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TapDetectionSetupModeRequest::VT_SETUP_MODE, None)} + } +} + +impl flatbuffers::Verifiable for TapDetectionSetupModeRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("setup_mode", Self::VT_SETUP_MODE, false)? + .finish(); + Ok(()) + } +} +pub struct TapDetectionSetupModeRequestArgs { + pub setup_mode: Option, +} +impl<'a> Default for TapDetectionSetupModeRequestArgs { + #[inline] + fn default() -> Self { + TapDetectionSetupModeRequestArgs { + setup_mode: None, + } + } +} + +pub struct TapDetectionSetupModeRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TapDetectionSetupModeRequestBuilder<'a, 'b> { + #[inline] + pub fn add_setup_mode(&mut self, setup_mode: bool) { + self.fbb_.push_slot_always::(TapDetectionSetupModeRequest::VT_SETUP_MODE, setup_mode); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TapDetectionSetupModeRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + TapDetectionSetupModeRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for TapDetectionSetupModeRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TapDetectionSetupModeRequest"); + ds.field("setup_mode", &self.setup_mode()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_notification_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_notification_generated.rs index d0fe0c484..0b6470f5b 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_notification_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tap_detection_setup_notification_generated.rs @@ -12,7 +12,7 @@ use super::*; pub enum TapDetectionSetupNotificationOffset {} #[derive(Copy, Clone, PartialEq)] -/// See TapDetectionSettings::setup_mode +/// Indicates which tracker got triggered by TapDetection while setup mode is enabled pub struct TapDetectionSetupNotification<'a> { pub _tab: flatbuffers::Table<'a>, } @@ -35,20 +35,20 @@ impl<'a> TapDetectionSetupNotification<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TapDetectionSetupNotificationArgs<'args> + args: &'args TapDetectionSetupNotificationArgs ) -> flatbuffers::WIPOffset> { let mut builder = TapDetectionSetupNotificationBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_tracker_id(args.tracker_id); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(TapDetectionSetupNotification::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(TapDetectionSetupNotification::VT_TRACKER_ID, Some(0)).unwrap()} } } @@ -59,19 +59,19 @@ impl flatbuffers::Verifiable for TapDetectionSetupNotification<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .finish(); Ok(()) } } -pub struct TapDetectionSetupNotificationArgs<'a> { - pub tracker_id: Option>>, +pub struct TapDetectionSetupNotificationArgs { + pub tracker_id: u16, } -impl<'a> Default for TapDetectionSetupNotificationArgs<'a> { +impl<'a> Default for TapDetectionSetupNotificationArgs { #[inline] fn default() -> Self { TapDetectionSetupNotificationArgs { - tracker_id: None, + tracker_id: 0, } } } @@ -82,8 +82,8 @@ pub struct TapDetectionSetupNotificationBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TapDetectionSetupNotificationBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TapDetectionSetupNotification::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(TapDetectionSetupNotification::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TapDetectionSetupNotificationBuilder<'a, 'b> { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/timeout_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/timeout_settings_generated.rs deleted file mode 100644 index 27911a1b2..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/timeout_settings_generated.rs +++ /dev/null @@ -1,108 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum TimeoutSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct TimeoutSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for TimeoutSettings<'a> { - type Inner = TimeoutSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> TimeoutSettings<'a> { - pub const VT_DURATION: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TimeoutSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TimeoutSettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = TimeoutSettingsBuilder::new(_fbb); - builder.add_duration(args.duration); - builder.finish() - } - - - #[inline] - pub fn duration(&self) -> f32 { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(TimeoutSettings::VT_DURATION, Some(0.0)).unwrap()} - } -} - -impl flatbuffers::Verifiable for TimeoutSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("duration", Self::VT_DURATION, false)? - .finish(); - Ok(()) - } -} -pub struct TimeoutSettingsArgs { - pub duration: f32, -} -impl<'a> Default for TimeoutSettingsArgs { - #[inline] - fn default() -> Self { - TimeoutSettingsArgs { - duration: 0.0, - } - } -} - -pub struct TimeoutSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> TimeoutSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_duration(&mut self, duration: f32) { - self.fbb_.push_slot::(TimeoutSettings::VT_DURATION, duration, 0.0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimeoutSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - TimeoutSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for TimeoutSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("TimeoutSettings"); - ds.field("duration", &self.duration()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs index 85080901c..80f2b5e93 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs @@ -43,11 +43,11 @@ impl<'a> TrackingChecklistNeedCalibration<'a> { #[inline] - pub fn trackers_id(&self) -> Option>>> { + pub fn trackers_id(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, None)} + unsafe { self._tab.get::>>(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, None)} } } @@ -58,13 +58,13 @@ impl flatbuffers::Verifiable for TrackingChecklistNeedCalibration<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .visit_field::>>("trackers_id", Self::VT_TRACKERS_ID, false)? .finish(); Ok(()) } } pub struct TrackingChecklistNeedCalibrationArgs<'a> { - pub trackers_id: Option>>>>, + pub trackers_id: Option>>, } impl<'a> Default for TrackingChecklistNeedCalibrationArgs<'a> { #[inline] @@ -81,7 +81,7 @@ pub struct TrackingChecklistNeedCalibrationBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackingChecklistNeedCalibrationBuilder<'a, 'b> { #[inline] - pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, trackers_id); } #[inline] diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs index 4a03b4bc5..1f45c1136 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs @@ -44,11 +44,11 @@ impl<'a> TrackingChecklistTrackerError<'a> { #[inline] - pub fn trackers_id(&self) -> Option>>> { + pub fn trackers_id(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(TrackingChecklistTrackerError::VT_TRACKERS_ID, None)} + unsafe { self._tab.get::>>(TrackingChecklistTrackerError::VT_TRACKERS_ID, None)} } } @@ -59,13 +59,13 @@ impl flatbuffers::Verifiable for TrackingChecklistTrackerError<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .visit_field::>>("trackers_id", Self::VT_TRACKERS_ID, false)? .finish(); Ok(()) } } pub struct TrackingChecklistTrackerErrorArgs<'a> { - pub trackers_id: Option>>>>, + pub trackers_id: Option>>, } impl<'a> Default for TrackingChecklistTrackerErrorArgs<'a> { #[inline] @@ -82,7 +82,7 @@ pub struct TrackingChecklistTrackerErrorBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackingChecklistTrackerErrorBuilder<'a, 'b> { #[inline] - pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(TrackingChecklistTrackerError::VT_TRACKERS_ID, trackers_id); } #[inline] diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs index 2163d7b8b..16087df2c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs @@ -44,11 +44,11 @@ impl<'a> TrackingChecklistTrackerReset<'a> { #[inline] - pub fn trackers_id(&self) -> Option>>> { + pub fn trackers_id(&self) -> Option> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>>>(TrackingChecklistTrackerReset::VT_TRACKERS_ID, None)} + unsafe { self._tab.get::>>(TrackingChecklistTrackerReset::VT_TRACKERS_ID, None)} } } @@ -59,13 +59,13 @@ impl flatbuffers::Verifiable for TrackingChecklistTrackerReset<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .visit_field::>>("trackers_id", Self::VT_TRACKERS_ID, false)? .finish(); Ok(()) } } pub struct TrackingChecklistTrackerResetArgs<'a> { - pub trackers_id: Option>>>>, + pub trackers_id: Option>>, } impl<'a> Default for TrackingChecklistTrackerResetArgs<'a> { #[inline] @@ -82,7 +82,7 @@ pub struct TrackingChecklistTrackerResetBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackingChecklistTrackerResetBuilder<'a, 'b> { #[inline] - pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>) { self.fbb_.push_slot_always::>(TrackingChecklistTrackerReset::VT_TRACKERS_ID, trackers_id); } #[inline] diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs index 8290acb3f..15dc8bc1c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs @@ -34,20 +34,20 @@ impl<'a> TrackingChecklistUnassignedHMD<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TrackingChecklistUnassignedHMDArgs<'args> + args: &'args TrackingChecklistUnassignedHMDArgs ) -> flatbuffers::WIPOffset> { let mut builder = TrackingChecklistUnassignedHMDBuilder::new(_fbb); - if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_tracker_id(args.tracker_id); builder.finish() } #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, None)} + unsafe { self._tab.get::(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, Some(0)).unwrap()} } } @@ -58,19 +58,19 @@ impl flatbuffers::Verifiable for TrackingChecklistUnassignedHMD<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::("tracker_id", Self::VT_TRACKER_ID, false)? .finish(); Ok(()) } } -pub struct TrackingChecklistUnassignedHMDArgs<'a> { - pub tracker_id: Option>>, +pub struct TrackingChecklistUnassignedHMDArgs { + pub tracker_id: u16, } -impl<'a> Default for TrackingChecklistUnassignedHMDArgs<'a> { +impl<'a> Default for TrackingChecklistUnassignedHMDArgs { #[inline] fn default() -> Self { TrackingChecklistUnassignedHMDArgs { - tracker_id: None, + tracker_id: 0, } } } @@ -81,8 +81,8 @@ pub struct TrackingChecklistUnassignedHMDBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackingChecklistUnassignedHMDBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: u16) { + self.fbb_.push_slot::(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id, 0); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistUnassignedHMDBuilder<'a, 'b> { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_pause_state_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_pause_state_response_generated.rs index 210e6b358..1f6b71837 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_pause_state_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_pause_state_response_generated.rs @@ -25,7 +25,7 @@ impl<'a> flatbuffers::Follow<'a> for TrackingPauseStateResponse<'a> { } impl<'a> TrackingPauseStateResponse<'a> { - pub const VT_TRACKINGPAUSED: flatbuffers::VOffsetT = 4; + pub const VT_TRACKING_PAUSED: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -37,18 +37,18 @@ impl<'a> TrackingPauseStateResponse<'a> { args: &'args TrackingPauseStateResponseArgs ) -> flatbuffers::WIPOffset> { let mut builder = TrackingPauseStateResponseBuilder::new(_fbb); - builder.add_trackingPaused(args.trackingPaused); + builder.add_tracking_paused(args.tracking_paused); builder.finish() } /// Skeleton tracking is paused if true, skeleton tracking is unpaused if false. #[inline] - pub fn trackingPaused(&self) -> bool { + pub fn tracking_paused(&self) -> bool { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(TrackingPauseStateResponse::VT_TRACKINGPAUSED, Some(false)).unwrap()} + unsafe { self._tab.get::(TrackingPauseStateResponse::VT_TRACKING_PAUSED, Some(false)).unwrap()} } } @@ -59,19 +59,19 @@ impl flatbuffers::Verifiable for TrackingPauseStateResponse<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("trackingPaused", Self::VT_TRACKINGPAUSED, false)? + .visit_field::("tracking_paused", Self::VT_TRACKING_PAUSED, false)? .finish(); Ok(()) } } pub struct TrackingPauseStateResponseArgs { - pub trackingPaused: bool, + pub tracking_paused: bool, } impl<'a> Default for TrackingPauseStateResponseArgs { #[inline] fn default() -> Self { TrackingPauseStateResponseArgs { - trackingPaused: false, + tracking_paused: false, } } } @@ -82,8 +82,8 @@ pub struct TrackingPauseStateResponseBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> TrackingPauseStateResponseBuilder<'a, 'b> { #[inline] - pub fn add_trackingPaused(&mut self, trackingPaused: bool) { - self.fbb_.push_slot::(TrackingPauseStateResponse::VT_TRACKINGPAUSED, trackingPaused, false); + pub fn add_tracking_paused(&mut self, tracking_paused: bool) { + self.fbb_.push_slot::(TrackingPauseStateResponse::VT_TRACKING_PAUSED, tracking_paused, false); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingPauseStateResponseBuilder<'a, 'b> { @@ -103,7 +103,7 @@ impl<'a: 'b, 'b> TrackingPauseStateResponseBuilder<'a, 'b> { impl core::fmt::Debug for TrackingPauseStateResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("TrackingPauseStateResponse"); - ds.field("trackingPaused", &self.trackingPaused()); + ds.field("tracking_paused", &self.tracking_paused()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/user_height_recording_status_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/user_height_recording_status_response_generated.rs index 904d49eb2..9c6331e7b 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/user_height_recording_status_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/user_height_recording_status_response_generated.rs @@ -25,7 +25,7 @@ impl<'a> flatbuffers::Follow<'a> for UserHeightRecordingStatusResponse<'a> { } impl<'a> UserHeightRecordingStatusResponse<'a> { - pub const VT_HMDHEIGHT: flatbuffers::VOffsetT = 4; + pub const VT_HMD_HEIGHT: flatbuffers::VOffsetT = 4; pub const VT_STATUS: flatbuffers::VOffsetT = 6; #[inline] @@ -38,18 +38,18 @@ impl<'a> UserHeightRecordingStatusResponse<'a> { args: &'args UserHeightRecordingStatusResponseArgs ) -> flatbuffers::WIPOffset> { let mut builder = UserHeightRecordingStatusResponseBuilder::new(_fbb); - builder.add_hmdHeight(args.hmdHeight); + builder.add_hmd_height(args.hmd_height); builder.add_status(args.status); builder.finish() } #[inline] - pub fn hmdHeight(&self) -> f32 { + pub fn hmd_height(&self) -> f32 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(UserHeightRecordingStatusResponse::VT_HMDHEIGHT, Some(0.0)).unwrap()} + unsafe { self._tab.get::(UserHeightRecordingStatusResponse::VT_HMD_HEIGHT, Some(0.0)).unwrap()} } #[inline] pub fn status(&self) -> UserHeightCalibrationStatus { @@ -67,21 +67,21 @@ impl flatbuffers::Verifiable for UserHeightRecordingStatusResponse<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("hmdHeight", Self::VT_HMDHEIGHT, false)? + .visit_field::("hmd_height", Self::VT_HMD_HEIGHT, false)? .visit_field::("status", Self::VT_STATUS, false)? .finish(); Ok(()) } } pub struct UserHeightRecordingStatusResponseArgs { - pub hmdHeight: f32, + pub hmd_height: f32, pub status: UserHeightCalibrationStatus, } impl<'a> Default for UserHeightRecordingStatusResponseArgs { #[inline] fn default() -> Self { UserHeightRecordingStatusResponseArgs { - hmdHeight: 0.0, + hmd_height: 0.0, status: UserHeightCalibrationStatus::NONE, } } @@ -93,8 +93,8 @@ pub struct UserHeightRecordingStatusResponseBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> UserHeightRecordingStatusResponseBuilder<'a, 'b> { #[inline] - pub fn add_hmdHeight(&mut self, hmdHeight: f32) { - self.fbb_.push_slot::(UserHeightRecordingStatusResponse::VT_HMDHEIGHT, hmdHeight, 0.0); + pub fn add_hmd_height(&mut self, hmd_height: f32) { + self.fbb_.push_slot::(UserHeightRecordingStatusResponse::VT_HMD_HEIGHT, hmd_height, 0.0); } #[inline] pub fn add_status(&mut self, status: UserHeightCalibrationStatus) { @@ -118,7 +118,7 @@ impl<'a: 'b, 'b> UserHeightRecordingStatusResponseBuilder<'a, 'b> { impl core::fmt::Debug for UserHeightRecordingStatusResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut ds = f.debug_struct("UserHeightRecordingStatusResponse"); - ds.field("hmdHeight", &self.hmdHeight()); + ds.field("hmd_height", &self.hmd_height()); ds.field("status", &self.status()); ds.finish() } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/velocity_settings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/velocity_settings_generated.rs deleted file mode 100644 index 836b1df1d..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/velocity_settings_generated.rs +++ /dev/null @@ -1,108 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum VelocitySettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -pub struct VelocitySettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for VelocitySettings<'a> { - type Inner = VelocitySettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> VelocitySettings<'a> { - pub const VT_SEND_DERIVED_VELOCITY: flatbuffers::VOffsetT = 4; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - VelocitySettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args VelocitySettingsArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = VelocitySettingsBuilder::new(_fbb); - builder.add_send_derived_velocity(args.send_derived_velocity); - builder.finish() - } - - - #[inline] - pub fn send_derived_velocity(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(VelocitySettings::VT_SEND_DERIVED_VELOCITY, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for VelocitySettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::("send_derived_velocity", Self::VT_SEND_DERIVED_VELOCITY, false)? - .finish(); - Ok(()) - } -} -pub struct VelocitySettingsArgs { - pub send_derived_velocity: bool, -} -impl<'a> Default for VelocitySettingsArgs { - #[inline] - fn default() -> Self { - VelocitySettingsArgs { - send_derived_velocity: false, - } - } -} - -pub struct VelocitySettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> VelocitySettingsBuilder<'a, 'b> { - #[inline] - pub fn add_send_derived_velocity(&mut self, send_derived_velocity: bool) { - self.fbb_.push_slot::(VelocitySettings::VT_SEND_DERIVED_VELOCITY, send_derived_velocity, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VelocitySettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - VelocitySettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for VelocitySettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("VelocitySettings"); - ds.field("send_derived_velocity", &self.send_derived_velocity()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_generated.rs deleted file mode 100644 index e3da4634c..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_generated.rs +++ /dev/null @@ -1,143 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum VMCOSCSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// OSC Settings specific to VMC -pub struct VMCOSCSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for VMCOSCSettings<'a> { - type Inner = VMCOSCSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> VMCOSCSettings<'a> { - pub const VT_OSC_SETTINGS: flatbuffers::VOffsetT = 4; - pub const VT_ANCHOR_HIP: flatbuffers::VOffsetT = 8; - pub const VT_MIRROR_TRACKING: flatbuffers::VOffsetT = 10; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - VMCOSCSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args VMCOSCSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = VMCOSCSettingsBuilder::new(_fbb); - if let Some(x) = args.osc_settings { builder.add_osc_settings(x); } - builder.add_mirror_tracking(args.mirror_tracking); - builder.add_anchor_hip(args.anchor_hip); - builder.finish() - } - - - #[inline] - pub fn osc_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(VMCOSCSettings::VT_OSC_SETTINGS, None)} - } - #[inline] - pub fn anchor_hip(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(VMCOSCSettings::VT_ANCHOR_HIP, Some(false)).unwrap()} - } - #[inline] - pub fn mirror_tracking(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(VMCOSCSettings::VT_MIRROR_TRACKING, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for VMCOSCSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("osc_settings", Self::VT_OSC_SETTINGS, false)? - .visit_field::("anchor_hip", Self::VT_ANCHOR_HIP, false)? - .visit_field::("mirror_tracking", Self::VT_MIRROR_TRACKING, false)? - .finish(); - Ok(()) - } -} -pub struct VMCOSCSettingsArgs<'a> { - pub osc_settings: Option>>, - pub anchor_hip: bool, - pub mirror_tracking: bool, -} -impl<'a> Default for VMCOSCSettingsArgs<'a> { - #[inline] - fn default() -> Self { - VMCOSCSettingsArgs { - osc_settings: None, - anchor_hip: false, - mirror_tracking: false, - } - } -} - -pub struct VMCOSCSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> VMCOSCSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_osc_settings(&mut self, osc_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(VMCOSCSettings::VT_OSC_SETTINGS, osc_settings); - } - #[inline] - pub fn add_anchor_hip(&mut self, anchor_hip: bool) { - self.fbb_.push_slot::(VMCOSCSettings::VT_ANCHOR_HIP, anchor_hip, false); - } - #[inline] - pub fn add_mirror_tracking(&mut self, mirror_tracking: bool) { - self.fbb_.push_slot::(VMCOSCSettings::VT_MIRROR_TRACKING, mirror_tracking, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VMCOSCSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - VMCOSCSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for VMCOSCSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("VMCOSCSettings"); - ds.field("osc_settings", &self.osc_settings()); - ds.field("anchor_hip", &self.anchor_hip()); - ds.field("mirror_tracking", &self.mirror_tracking()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_request_generated.rs new file mode 100644 index 000000000..fdc836ddb --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VMCOSCSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VMCOSCSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VMCOSCSettingsRequest<'a> { + type Inner = VMCOSCSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VMCOSCSettingsRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VMCOSCSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args VMCOSCSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = VMCOSCSettingsRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for VMCOSCSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct VMCOSCSettingsRequestArgs { +} +impl<'a> Default for VMCOSCSettingsRequestArgs { + #[inline] + fn default() -> Self { + VMCOSCSettingsRequestArgs { + } + } +} + +pub struct VMCOSCSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VMCOSCSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VMCOSCSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + VMCOSCSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VMCOSCSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VMCOSCSettingsRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_response_generated.rs new file mode 100644 index 000000000..4fb3e153b --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vmcoscsettings_response_generated.rs @@ -0,0 +1,193 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VMCOSCSettingsResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VMCOSCSettingsResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VMCOSCSettingsResponse<'a> { + type Inner = VMCOSCSettingsResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VMCOSCSettingsResponse<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_PORT_IN: flatbuffers::VOffsetT = 6; + pub const VT_PORT_OUT: flatbuffers::VOffsetT = 8; + pub const VT_ADDRESS: flatbuffers::VOffsetT = 10; + pub const VT_ANCHOR_HIP: flatbuffers::VOffsetT = 12; + pub const VT_MIRROR_TRACKING: flatbuffers::VOffsetT = 14; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VMCOSCSettingsResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VMCOSCSettingsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VMCOSCSettingsResponseBuilder::new(_fbb); + if let Some(x) = args.address { builder.add_address(x); } + builder.add_port_out(args.port_out); + builder.add_port_in(args.port_in); + builder.add_mirror_tracking(args.mirror_tracking); + builder.add_anchor_hip(args.anchor_hip); + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VMCOSCSettingsResponse::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn port_in(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VMCOSCSettingsResponse::VT_PORT_IN, Some(0)).unwrap()} + } + #[inline] + pub fn port_out(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VMCOSCSettingsResponse::VT_PORT_OUT, Some(0)).unwrap()} + } + #[inline] + pub fn address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VMCOSCSettingsResponse::VT_ADDRESS, None)} + } + #[inline] + pub fn anchor_hip(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VMCOSCSettingsResponse::VT_ANCHOR_HIP, Some(false)).unwrap()} + } + #[inline] + pub fn mirror_tracking(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VMCOSCSettingsResponse::VT_MIRROR_TRACKING, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for VMCOSCSettingsResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("port_in", Self::VT_PORT_IN, false)? + .visit_field::("port_out", Self::VT_PORT_OUT, false)? + .visit_field::>("address", Self::VT_ADDRESS, false)? + .visit_field::("anchor_hip", Self::VT_ANCHOR_HIP, false)? + .visit_field::("mirror_tracking", Self::VT_MIRROR_TRACKING, false)? + .finish(); + Ok(()) + } +} +pub struct VMCOSCSettingsResponseArgs<'a> { + pub enabled: bool, + pub port_in: u16, + pub port_out: u16, + pub address: Option>, + pub anchor_hip: bool, + pub mirror_tracking: bool, +} +impl<'a> Default for VMCOSCSettingsResponseArgs<'a> { + #[inline] + fn default() -> Self { + VMCOSCSettingsResponseArgs { + enabled: false, + port_in: 0, + port_out: 0, + address: None, + anchor_hip: false, + mirror_tracking: false, + } + } +} + +pub struct VMCOSCSettingsResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VMCOSCSettingsResponseBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(VMCOSCSettingsResponse::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_port_in(&mut self, port_in: u16) { + self.fbb_.push_slot::(VMCOSCSettingsResponse::VT_PORT_IN, port_in, 0); + } + #[inline] + pub fn add_port_out(&mut self, port_out: u16) { + self.fbb_.push_slot::(VMCOSCSettingsResponse::VT_PORT_OUT, port_out, 0); + } + #[inline] + pub fn add_address(&mut self, address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VMCOSCSettingsResponse::VT_ADDRESS, address); + } + #[inline] + pub fn add_anchor_hip(&mut self, anchor_hip: bool) { + self.fbb_.push_slot::(VMCOSCSettingsResponse::VT_ANCHOR_HIP, anchor_hip, false); + } + #[inline] + pub fn add_mirror_tracking(&mut self, mirror_tracking: bool) { + self.fbb_.push_slot::(VMCOSCSettingsResponse::VT_MIRROR_TRACKING, mirror_tracking, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VMCOSCSettingsResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + VMCOSCSettingsResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VMCOSCSettingsResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VMCOSCSettingsResponse"); + ds.field("enabled", &self.enabled()); + ds.field("port_in", &self.port_in()); + ds.field("port_out", &self.port_out()); + ds.field("address", &self.address()); + ds.field("anchor_hip", &self.anchor_hip()); + ds.field("mirror_tracking", &self.mirror_tracking()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs index 278625b50..fbb244d19 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs @@ -42,6 +42,7 @@ impl<'a> VRCConfigSettingToggleMute<'a> { } + /// Key from VRCConfigValidity #[inline] pub fn key(&self) -> Option<&'a str> { // Safety: diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs index eb78c06b3..876f3c258 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs @@ -80,6 +80,7 @@ impl<'a> VRCConfigStateChangeResponse<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(VRCConfigStateChangeResponse::VT_RECOMMENDED, None)} } + /// Just a list of keys from the VRCConfigValidity table. #[inline] pub fn muted(&self) -> Option>> { // Safety: diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscdiscovered_target_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscdiscovered_target_generated.rs new file mode 100644 index 000000000..dd37fba92 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscdiscovered_target_generated.rs @@ -0,0 +1,142 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VRCOSCDiscoveredTargetOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VRCOSCDiscoveredTarget<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VRCOSCDiscoveredTarget<'a> { + type Inner = VRCOSCDiscoveredTarget<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VRCOSCDiscoveredTarget<'a> { + pub const VT_NAME: flatbuffers::VOffsetT = 4; + pub const VT_ADDRESS: flatbuffers::VOffsetT = 6; + pub const VT_PORT_OUT: flatbuffers::VOffsetT = 8; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VRCOSCDiscoveredTarget { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VRCOSCDiscoveredTargetArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCDiscoveredTargetBuilder::new(_fbb); + if let Some(x) = args.address { builder.add_address(x); } + if let Some(x) = args.name { builder.add_name(x); } + builder.add_port_out(args.port_out); + builder.finish() + } + + + #[inline] + pub fn name(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCDiscoveredTarget::VT_NAME, None)} + } + #[inline] + pub fn address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCDiscoveredTarget::VT_ADDRESS, None)} + } + #[inline] + pub fn port_out(&self) -> u16 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCDiscoveredTarget::VT_PORT_OUT, Some(0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for VRCOSCDiscoveredTarget<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("name", Self::VT_NAME, false)? + .visit_field::>("address", Self::VT_ADDRESS, false)? + .visit_field::("port_out", Self::VT_PORT_OUT, false)? + .finish(); + Ok(()) + } +} +pub struct VRCOSCDiscoveredTargetArgs<'a> { + pub name: Option>, + pub address: Option>, + pub port_out: u16, +} +impl<'a> Default for VRCOSCDiscoveredTargetArgs<'a> { + #[inline] + fn default() -> Self { + VRCOSCDiscoveredTargetArgs { + name: None, + address: None, + port_out: 0, + } + } +} + +pub struct VRCOSCDiscoveredTargetBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VRCOSCDiscoveredTargetBuilder<'a, 'b> { + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCDiscoveredTarget::VT_NAME, name); + } + #[inline] + pub fn add_address(&mut self, address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCDiscoveredTarget::VT_ADDRESS, address); + } + #[inline] + pub fn add_port_out(&mut self, port_out: u16) { + self.fbb_.push_slot::(VRCOSCDiscoveredTarget::VT_PORT_OUT, port_out, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCDiscoveredTargetBuilder<'a, 'b> { + let start = _fbb.start_table(); + VRCOSCDiscoveredTargetBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VRCOSCDiscoveredTarget<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VRCOSCDiscoveredTarget"); + ds.field("name", &self.name()); + ds.field("address", &self.address()); + ds.field("port_out", &self.port_out()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscinput_state_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscinput_state_generated.rs new file mode 100644 index 000000000..ddcc371bc --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscinput_state_generated.rs @@ -0,0 +1,100 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_VRCOSCINPUT_STATE: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_VRCOSCINPUT_STATE: u8 = 2; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +#[allow(non_camel_case_types)] +pub const ENUM_VALUES_VRCOSCINPUT_STATE: [VRCOSCInputState; 3] = [ + VRCOSCInputState::IDLE, + VRCOSCInputState::LISTENING, + VRCOSCInputState::ERROR, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct VRCOSCInputState(pub u8); +#[allow(non_upper_case_globals)] +impl VRCOSCInputState { + pub const IDLE: Self = Self(0); + pub const LISTENING: Self = Self(1); + pub const ERROR: Self = Self(2); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::IDLE, + Self::LISTENING, + Self::ERROR, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::IDLE => Some("IDLE"), + Self::LISTENING => Some("LISTENING"), + Self::ERROR => Some("ERROR"), + _ => None, + } + } +} +impl core::fmt::Debug for VRCOSCInputState { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } +} +impl<'a> flatbuffers::Follow<'a> for VRCOSCInputState { + type Inner = Self; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = flatbuffers::read_scalar_at::(buf, loc); + Self(b) + } +} + +impl flatbuffers::Push for VRCOSCInputState { + type Output = VRCOSCInputState; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for VRCOSCInputState { + type Scalar = u8; + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } +} + +impl<'a> flatbuffers::Verifiable for VRCOSCInputState { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + u8::run_verifier(v, pos) + } +} + +impl flatbuffers::SimpleToVerifyInSlice for VRCOSCInputState {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/oscsettings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscnetwork_settings_generated.rs similarity index 59% rename from protocol/rust/src/generated/solarxr_protocol/rpc/oscsettings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscnetwork_settings_generated.rs index a8a8c28fc..74a3799ed 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/oscsettings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscnetwork_settings_generated.rs @@ -9,84 +9,73 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum OSCSettingsOffset {} +pub enum VRCOSCNetworkSettingsOffset {} #[derive(Copy, Clone, PartialEq)] -/// OSC Settings that are used in *any* osc application. -pub struct OSCSettings<'a> { +pub struct VRCOSCNetworkSettings<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for OSCSettings<'a> { - type Inner = OSCSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for VRCOSCNetworkSettings<'a> { + type Inner = VRCOSCNetworkSettings<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> OSCSettings<'a> { - pub const VT_ENABLED: flatbuffers::VOffsetT = 4; - pub const VT_PORT_IN: flatbuffers::VOffsetT = 6; - pub const VT_PORT_OUT: flatbuffers::VOffsetT = 8; - pub const VT_ADDRESS: flatbuffers::VOffsetT = 10; +impl<'a> VRCOSCNetworkSettings<'a> { + pub const VT_PORT_IN: flatbuffers::VOffsetT = 4; + pub const VT_PORT_OUT: flatbuffers::VOffsetT = 6; + pub const VT_ADDRESS: flatbuffers::VOffsetT = 8; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - OSCSettings { _tab: table } + VRCOSCNetworkSettings { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args OSCSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = OSCSettingsBuilder::new(_fbb); + args: &'args VRCOSCNetworkSettingsArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCNetworkSettingsBuilder::new(_fbb); if let Some(x) = args.address { builder.add_address(x); } builder.add_port_out(args.port_out); builder.add_port_in(args.port_in); - builder.add_enabled(args.enabled); builder.finish() } - #[inline] - pub fn enabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(OSCSettings::VT_ENABLED, Some(false)).unwrap()} - } #[inline] pub fn port_in(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(OSCSettings::VT_PORT_IN, Some(0)).unwrap()} + unsafe { self._tab.get::(VRCOSCNetworkSettings::VT_PORT_IN, Some(0)).unwrap()} } #[inline] pub fn port_out(&self) -> u16 { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::(OSCSettings::VT_PORT_OUT, Some(0)).unwrap()} + unsafe { self._tab.get::(VRCOSCNetworkSettings::VT_PORT_OUT, Some(0)).unwrap()} } #[inline] pub fn address(&self) -> Option<&'a str> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(OSCSettings::VT_ADDRESS, None)} + unsafe { self._tab.get::>(VRCOSCNetworkSettings::VT_ADDRESS, None)} } } -impl flatbuffers::Verifiable for OSCSettings<'_> { +impl flatbuffers::Verifiable for VRCOSCNetworkSettings<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::("enabled", Self::VT_ENABLED, false)? .visit_field::("port_in", Self::VT_PORT_IN, false)? .visit_field::("port_out", Self::VT_PORT_OUT, false)? .visit_field::>("address", Self::VT_ADDRESS, false)? @@ -94,17 +83,15 @@ impl flatbuffers::Verifiable for OSCSettings<'_> { Ok(()) } } -pub struct OSCSettingsArgs<'a> { - pub enabled: bool, +pub struct VRCOSCNetworkSettingsArgs<'a> { pub port_in: u16, pub port_out: u16, pub address: Option>, } -impl<'a> Default for OSCSettingsArgs<'a> { +impl<'a> Default for VRCOSCNetworkSettingsArgs<'a> { #[inline] fn default() -> Self { - OSCSettingsArgs { - enabled: false, + VRCOSCNetworkSettingsArgs { port_in: 0, port_out: 0, address: None, @@ -112,46 +99,41 @@ impl<'a> Default for OSCSettingsArgs<'a> { } } -pub struct OSCSettingsBuilder<'a: 'b, 'b> { +pub struct VRCOSCNetworkSettingsBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> OSCSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_enabled(&mut self, enabled: bool) { - self.fbb_.push_slot::(OSCSettings::VT_ENABLED, enabled, false); - } +impl<'a: 'b, 'b> VRCOSCNetworkSettingsBuilder<'a, 'b> { #[inline] pub fn add_port_in(&mut self, port_in: u16) { - self.fbb_.push_slot::(OSCSettings::VT_PORT_IN, port_in, 0); + self.fbb_.push_slot::(VRCOSCNetworkSettings::VT_PORT_IN, port_in, 0); } #[inline] pub fn add_port_out(&mut self, port_out: u16) { - self.fbb_.push_slot::(OSCSettings::VT_PORT_OUT, port_out, 0); + self.fbb_.push_slot::(VRCOSCNetworkSettings::VT_PORT_OUT, port_out, 0); } #[inline] pub fn add_address(&mut self, address: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(OSCSettings::VT_ADDRESS, address); + self.fbb_.push_slot_always::>(VRCOSCNetworkSettings::VT_ADDRESS, address); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OSCSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCNetworkSettingsBuilder<'a, 'b> { let start = _fbb.start_table(); - OSCSettingsBuilder { + VRCOSCNetworkSettingsBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for OSCSettings<'_> { +impl core::fmt::Debug for VRCOSCNetworkSettings<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("OSCSettings"); - ds.field("enabled", &self.enabled()); + let mut ds = f.debug_struct("VRCOSCNetworkSettings"); ds.field("port_in", &self.port_in()); ds.field("port_out", &self.port_out()); ds.field("address", &self.address()); diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/payload_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscosc_query_state_generated.rs similarity index 62% rename from protocol/rust/src/generated/solarxr_protocol/pub_sub/payload_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscosc_query_state_generated.rs index 3c631193a..49bd88f51 100644 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/payload_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscosc_query_state_generated.rs @@ -10,48 +10,48 @@ use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MIN_PAYLOAD: u8 = 0; +pub const ENUM_MIN_VRCOSCOSC_QUERY_STATE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_PAYLOAD: u8 = 3; +pub const ENUM_MAX_VRCOSCOSC_QUERY_STATE: u8 = 3; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_PAYLOAD: [Payload; 4] = [ - Payload::NONE, - Payload::solarxr_protocol_datatypes_StringTable, - Payload::solarxr_protocol_datatypes_Bytes, - Payload::KeyValues, +pub const ENUM_VALUES_VRCOSCOSC_QUERY_STATE: [VRCOSCOscQueryState; 4] = [ + VRCOSCOscQueryState::DISABLED, + VRCOSCOscQueryState::SEARCHING, + VRCOSCOscQueryState::FOUND, + VRCOSCOscQueryState::ERROR, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -pub struct Payload(pub u8); +pub struct VRCOSCOscQueryState(pub u8); #[allow(non_upper_case_globals)] -impl Payload { - pub const NONE: Self = Self(0); - pub const solarxr_protocol_datatypes_StringTable: Self = Self(1); - pub const solarxr_protocol_datatypes_Bytes: Self = Self(2); - pub const KeyValues: Self = Self(3); +impl VRCOSCOscQueryState { + pub const DISABLED: Self = Self(0); + pub const SEARCHING: Self = Self(1); + pub const FOUND: Self = Self(2); + pub const ERROR: Self = Self(3); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 3; pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::solarxr_protocol_datatypes_StringTable, - Self::solarxr_protocol_datatypes_Bytes, - Self::KeyValues, + Self::DISABLED, + Self::SEARCHING, + Self::FOUND, + Self::ERROR, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::NONE => Some("NONE"), - Self::solarxr_protocol_datatypes_StringTable => Some("solarxr_protocol_datatypes_StringTable"), - Self::solarxr_protocol_datatypes_Bytes => Some("solarxr_protocol_datatypes_Bytes"), - Self::KeyValues => Some("KeyValues"), + Self::DISABLED => Some("DISABLED"), + Self::SEARCHING => Some("SEARCHING"), + Self::FOUND => Some("FOUND"), + Self::ERROR => Some("ERROR"), _ => None, } } } -impl core::fmt::Debug for Payload { +impl core::fmt::Debug for VRCOSCOscQueryState { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) @@ -60,7 +60,7 @@ impl core::fmt::Debug for Payload { } } } -impl<'a> flatbuffers::Follow<'a> for Payload { +impl<'a> flatbuffers::Follow<'a> for VRCOSCOscQueryState { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { @@ -69,15 +69,15 @@ impl<'a> flatbuffers::Follow<'a> for Payload { } } -impl flatbuffers::Push for Payload { - type Output = Payload; +impl flatbuffers::Push for VRCOSCOscQueryState { + type Output = VRCOSCOscQueryState; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { flatbuffers::emplace_scalar::(dst, self.0); } } -impl flatbuffers::EndianScalar for Payload { +impl flatbuffers::EndianScalar for VRCOSCOscQueryState { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -91,7 +91,7 @@ impl flatbuffers::EndianScalar for Payload { } } -impl<'a> flatbuffers::Verifiable for Payload { +impl<'a> flatbuffers::Verifiable for VRCOSCOscQueryState { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -101,6 +101,4 @@ impl<'a> flatbuffers::Verifiable for Payload { } } -impl flatbuffers::SimpleToVerifyInSlice for Payload {} -pub struct PayloadUnionTableOffset {} - +impl flatbuffers::SimpleToVerifyInSlice for VRCOSCOscQueryState {} diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_union_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscoutput_state_generated.rs similarity index 60% rename from protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_union_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscoutput_state_generated.rs index e419b8da4..0f97b8e82 100644 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/pub_sub_union_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscoutput_state_generated.rs @@ -10,52 +10,44 @@ use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MIN_PUB_SUB_UNION: u8 = 0; +pub const ENUM_MIN_VRCOSCOUTPUT_STATE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_PUB_SUB_UNION: u8 = 4; +pub const ENUM_MAX_VRCOSCOUTPUT_STATE: u8 = 2; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_PUB_SUB_UNION: [PubSubUnion; 5] = [ - PubSubUnion::NONE, - PubSubUnion::Message, - PubSubUnion::SubscriptionRequest, - PubSubUnion::TopicHandleRequest, - PubSubUnion::TopicMapping, +pub const ENUM_VALUES_VRCOSCOUTPUT_STATE: [VRCOSCOutputState; 3] = [ + VRCOSCOutputState::IDLE, + VRCOSCOutputState::READY, + VRCOSCOutputState::ERROR, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -pub struct PubSubUnion(pub u8); +pub struct VRCOSCOutputState(pub u8); #[allow(non_upper_case_globals)] -impl PubSubUnion { - pub const NONE: Self = Self(0); - pub const Message: Self = Self(1); - pub const SubscriptionRequest: Self = Self(2); - pub const TopicHandleRequest: Self = Self(3); - pub const TopicMapping: Self = Self(4); +impl VRCOSCOutputState { + pub const IDLE: Self = Self(0); + pub const READY: Self = Self(1); + pub const ERROR: Self = Self(2); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 4; + pub const ENUM_MAX: u8 = 2; pub const ENUM_VALUES: &'static [Self] = &[ - Self::NONE, - Self::Message, - Self::SubscriptionRequest, - Self::TopicHandleRequest, - Self::TopicMapping, + Self::IDLE, + Self::READY, + Self::ERROR, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { - Self::NONE => Some("NONE"), - Self::Message => Some("Message"), - Self::SubscriptionRequest => Some("SubscriptionRequest"), - Self::TopicHandleRequest => Some("TopicHandleRequest"), - Self::TopicMapping => Some("TopicMapping"), + Self::IDLE => Some("IDLE"), + Self::READY => Some("READY"), + Self::ERROR => Some("ERROR"), _ => None, } } } -impl core::fmt::Debug for PubSubUnion { +impl core::fmt::Debug for VRCOSCOutputState { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) @@ -64,7 +56,7 @@ impl core::fmt::Debug for PubSubUnion { } } } -impl<'a> flatbuffers::Follow<'a> for PubSubUnion { +impl<'a> flatbuffers::Follow<'a> for VRCOSCOutputState { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { @@ -73,15 +65,15 @@ impl<'a> flatbuffers::Follow<'a> for PubSubUnion { } } -impl flatbuffers::Push for PubSubUnion { - type Output = PubSubUnion; +impl flatbuffers::Push for VRCOSCOutputState { + type Output = VRCOSCOutputState; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { flatbuffers::emplace_scalar::(dst, self.0); } } -impl flatbuffers::EndianScalar for PubSubUnion { +impl flatbuffers::EndianScalar for VRCOSCOutputState { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -95,7 +87,7 @@ impl flatbuffers::EndianScalar for PubSubUnion { } } -impl<'a> flatbuffers::Verifiable for PubSubUnion { +impl<'a> flatbuffers::Verifiable for VRCOSCOutputState { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -105,6 +97,4 @@ impl<'a> flatbuffers::Verifiable for PubSubUnion { } } -impl flatbuffers::SimpleToVerifyInSlice for PubSubUnion {} -pub struct PubSubUnionUnionTableOffset {} - +impl flatbuffers::SimpleToVerifyInSlice for VRCOSCOutputState {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_generated.rs deleted file mode 100644 index f7efc54ea..000000000 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_generated.rs +++ /dev/null @@ -1,143 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify -// @generated -extern crate alloc; -extern crate flatbuffers; -use alloc::boxed::Box; -use alloc::string::{String, ToString}; -use alloc::vec::Vec; -use core::mem; -use core::cmp::Ordering; -use self::flatbuffers::{EndianScalar, Follow}; -use super::*; -pub enum VRCOSCSettingsOffset {} -#[derive(Copy, Clone, PartialEq)] - -/// OSC Settings specific to VRChat -pub struct VRCOSCSettings<'a> { - pub _tab: flatbuffers::Table<'a>, -} - -impl<'a> flatbuffers::Follow<'a> for VRCOSCSettings<'a> { - type Inner = VRCOSCSettings<'a>; - #[inline] - unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - Self { _tab: flatbuffers::Table::new(buf, loc) } - } -} - -impl<'a> VRCOSCSettings<'a> { - pub const VT_OSC_SETTINGS: flatbuffers::VOffsetT = 4; - pub const VT_TRACKERS: flatbuffers::VOffsetT = 6; - pub const VT_OSCQUERY_ENABLED: flatbuffers::VOffsetT = 8; - - #[inline] - pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - VRCOSCSettings { _tab: table } - } - #[allow(unused_mut)] - pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( - _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args VRCOSCSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = VRCOSCSettingsBuilder::new(_fbb); - if let Some(x) = args.trackers { builder.add_trackers(x); } - if let Some(x) = args.osc_settings { builder.add_osc_settings(x); } - builder.add_oscquery_enabled(args.oscquery_enabled); - builder.finish() - } - - - #[inline] - pub fn osc_settings(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(VRCOSCSettings::VT_OSC_SETTINGS, None)} - } - #[inline] - pub fn trackers(&self) -> Option> { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::>(VRCOSCSettings::VT_TRACKERS, None)} - } - #[inline] - pub fn oscquery_enabled(&self) -> bool { - // Safety: - // Created from valid Table for this object - // which contains a valid value in this slot - unsafe { self._tab.get::(VRCOSCSettings::VT_OSCQUERY_ENABLED, Some(false)).unwrap()} - } -} - -impl flatbuffers::Verifiable for VRCOSCSettings<'_> { - #[inline] - fn run_verifier( - v: &mut flatbuffers::Verifier, pos: usize - ) -> Result<(), flatbuffers::InvalidFlatbuffer> { - use self::flatbuffers::Verifiable; - v.visit_table(pos)? - .visit_field::>("osc_settings", Self::VT_OSC_SETTINGS, false)? - .visit_field::>("trackers", Self::VT_TRACKERS, false)? - .visit_field::("oscquery_enabled", Self::VT_OSCQUERY_ENABLED, false)? - .finish(); - Ok(()) - } -} -pub struct VRCOSCSettingsArgs<'a> { - pub osc_settings: Option>>, - pub trackers: Option>>, - pub oscquery_enabled: bool, -} -impl<'a> Default for VRCOSCSettingsArgs<'a> { - #[inline] - fn default() -> Self { - VRCOSCSettingsArgs { - osc_settings: None, - trackers: None, - oscquery_enabled: false, - } - } -} - -pub struct VRCOSCSettingsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, -} -impl<'a: 'b, 'b> VRCOSCSettingsBuilder<'a, 'b> { - #[inline] - pub fn add_osc_settings(&mut self, osc_settings: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(VRCOSCSettings::VT_OSC_SETTINGS, osc_settings); - } - #[inline] - pub fn add_trackers(&mut self, trackers: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(VRCOSCSettings::VT_TRACKERS, trackers); - } - #[inline] - pub fn add_oscquery_enabled(&mut self, oscquery_enabled: bool) { - self.fbb_.push_slot::(VRCOSCSettings::VT_OSCQUERY_ENABLED, oscquery_enabled, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCSettingsBuilder<'a, 'b> { - let start = _fbb.start_table(); - VRCOSCSettingsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } -} - -impl core::fmt::Debug for VRCOSCSettings<'_> { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("VRCOSCSettings"); - ds.field("osc_settings", &self.osc_settings()); - ds.field("trackers", &self.trackers()); - ds.field("oscquery_enabled", &self.oscquery_enabled()); - ds.finish() - } -} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_request_generated.rs new file mode 100644 index 000000000..aa0e312e6 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VRCOSCSettingsRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VRCOSCSettingsRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VRCOSCSettingsRequest<'a> { + type Inner = VRCOSCSettingsRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VRCOSCSettingsRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VRCOSCSettingsRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args VRCOSCSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCSettingsRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for VRCOSCSettingsRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct VRCOSCSettingsRequestArgs { +} +impl<'a> Default for VRCOSCSettingsRequestArgs { + #[inline] + fn default() -> Self { + VRCOSCSettingsRequestArgs { + } + } +} + +pub struct VRCOSCSettingsRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VRCOSCSettingsRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCSettingsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + VRCOSCSettingsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VRCOSCSettingsRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VRCOSCSettingsRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_response_generated.rs new file mode 100644 index 000000000..4ed589065 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscsettings_response_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VRCOSCSettingsResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VRCOSCSettingsResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VRCOSCSettingsResponse<'a> { + type Inner = VRCOSCSettingsResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VRCOSCSettingsResponse<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_MANUAL_NETWORK: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VRCOSCSettingsResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VRCOSCSettingsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCSettingsResponseBuilder::new(_fbb); + if let Some(x) = args.manual_network { builder.add_manual_network(x); } + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCSettingsResponse::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn manual_network(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCSettingsResponse::VT_MANUAL_NETWORK, None)} + } +} + +impl flatbuffers::Verifiable for VRCOSCSettingsResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::>("manual_network", Self::VT_MANUAL_NETWORK, false)? + .finish(); + Ok(()) + } +} +pub struct VRCOSCSettingsResponseArgs<'a> { + pub enabled: bool, + pub manual_network: Option>>, +} +impl<'a> Default for VRCOSCSettingsResponseArgs<'a> { + #[inline] + fn default() -> Self { + VRCOSCSettingsResponseArgs { + enabled: false, + manual_network: None, + } + } +} + +pub struct VRCOSCSettingsResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VRCOSCSettingsResponseBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(VRCOSCSettingsResponse::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_manual_network(&mut self, manual_network: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(VRCOSCSettingsResponse::VT_MANUAL_NETWORK, manual_network); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCSettingsResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + VRCOSCSettingsResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VRCOSCSettingsResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VRCOSCSettingsResponse"); + ds.field("enabled", &self.enabled()); + ds.field("manual_network", &self.manual_network()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_change_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_change_response_generated.rs new file mode 100644 index 000000000..1284c8c8d --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_change_response_generated.rs @@ -0,0 +1,346 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VRCOSCStatusChangeResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VRCOSCStatusChangeResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VRCOSCStatusChangeResponse<'a> { + type Inner = VRCOSCStatusChangeResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VRCOSCStatusChangeResponse<'a> { + pub const VT_ENABLED: flatbuffers::VOffsetT = 4; + pub const VT_INPUT_STATE: flatbuffers::VOffsetT = 6; + pub const VT_INPUT_PORT: flatbuffers::VOffsetT = 8; + pub const VT_INPUT_ERROR: flatbuffers::VOffsetT = 10; + pub const VT_LAST_RECEIVED_INPUT_MILLIS: flatbuffers::VOffsetT = 12; + pub const VT_OUTPUT_STATE: flatbuffers::VOffsetT = 14; + pub const VT_OUTPUT_ERROR: flatbuffers::VOffsetT = 16; + pub const VT_TARGET_ADDRESS: flatbuffers::VOffsetT = 18; + pub const VT_TARGET_PORT: flatbuffers::VOffsetT = 20; + pub const VT_TARGET_SOURCE: flatbuffers::VOffsetT = 22; + pub const VT_LAST_FRAME_SENT_MILLIS: flatbuffers::VOffsetT = 24; + pub const VT_OSCQUERY_STATE: flatbuffers::VOffsetT = 26; + pub const VT_OSCQUERY_ADVERTISED_PORT: flatbuffers::VOffsetT = 28; + pub const VT_OSCQUERY_ERROR: flatbuffers::VOffsetT = 30; + pub const VT_DISCOVERED_TARGETS: flatbuffers::VOffsetT = 32; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VRCOSCStatusChangeResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VRCOSCStatusChangeResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCStatusChangeResponseBuilder::new(_fbb); + if let Some(x) = args.last_frame_sent_millis { builder.add_last_frame_sent_millis(x); } + if let Some(x) = args.last_received_input_millis { builder.add_last_received_input_millis(x); } + if let Some(x) = args.discovered_targets { builder.add_discovered_targets(x); } + if let Some(x) = args.oscquery_error { builder.add_oscquery_error(x); } + if let Some(x) = args.target_address { builder.add_target_address(x); } + if let Some(x) = args.output_error { builder.add_output_error(x); } + if let Some(x) = args.input_error { builder.add_input_error(x); } + if let Some(x) = args.oscquery_advertised_port { builder.add_oscquery_advertised_port(x); } + if let Some(x) = args.target_port { builder.add_target_port(x); } + if let Some(x) = args.input_port { builder.add_input_port(x); } + builder.add_oscquery_state(args.oscquery_state); + builder.add_target_source(args.target_source); + builder.add_output_state(args.output_state); + builder.add_input_state(args.input_state); + builder.add_enabled(args.enabled); + builder.finish() + } + + + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn input_state(&self) -> VRCOSCInputState { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_INPUT_STATE, Some(VRCOSCInputState::IDLE)).unwrap()} + } + #[inline] + pub fn input_port(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_INPUT_PORT, None)} + } + #[inline] + pub fn input_error(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCStatusChangeResponse::VT_INPUT_ERROR, None)} + } + #[inline] + pub fn last_received_input_millis(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_LAST_RECEIVED_INPUT_MILLIS, None)} + } + #[inline] + pub fn output_state(&self) -> VRCOSCOutputState { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_OUTPUT_STATE, Some(VRCOSCOutputState::IDLE)).unwrap()} + } + #[inline] + pub fn output_error(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCStatusChangeResponse::VT_OUTPUT_ERROR, None)} + } + #[inline] + pub fn target_address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCStatusChangeResponse::VT_TARGET_ADDRESS, None)} + } + #[inline] + pub fn target_port(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_TARGET_PORT, None)} + } + #[inline] + pub fn target_source(&self) -> VRCOSCTargetSource { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_TARGET_SOURCE, Some(VRCOSCTargetSource::NONE)).unwrap()} + } + #[inline] + pub fn last_frame_sent_millis(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_LAST_FRAME_SENT_MILLIS, None)} + } + #[inline] + pub fn oscquery_state(&self) -> VRCOSCOscQueryState { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_OSCQUERY_STATE, Some(VRCOSCOscQueryState::DISABLED)).unwrap()} + } + #[inline] + pub fn oscquery_advertised_port(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VRCOSCStatusChangeResponse::VT_OSCQUERY_ADVERTISED_PORT, None)} + } + #[inline] + pub fn oscquery_error(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCOSCStatusChangeResponse::VT_OSCQUERY_ERROR, None)} + } + #[inline] + pub fn discovered_targets(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(VRCOSCStatusChangeResponse::VT_DISCOVERED_TARGETS, None)} + } +} + +impl flatbuffers::Verifiable for VRCOSCStatusChangeResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("input_state", Self::VT_INPUT_STATE, false)? + .visit_field::("input_port", Self::VT_INPUT_PORT, false)? + .visit_field::>("input_error", Self::VT_INPUT_ERROR, false)? + .visit_field::("last_received_input_millis", Self::VT_LAST_RECEIVED_INPUT_MILLIS, false)? + .visit_field::("output_state", Self::VT_OUTPUT_STATE, false)? + .visit_field::>("output_error", Self::VT_OUTPUT_ERROR, false)? + .visit_field::>("target_address", Self::VT_TARGET_ADDRESS, false)? + .visit_field::("target_port", Self::VT_TARGET_PORT, false)? + .visit_field::("target_source", Self::VT_TARGET_SOURCE, false)? + .visit_field::("last_frame_sent_millis", Self::VT_LAST_FRAME_SENT_MILLIS, false)? + .visit_field::("oscquery_state", Self::VT_OSCQUERY_STATE, false)? + .visit_field::("oscquery_advertised_port", Self::VT_OSCQUERY_ADVERTISED_PORT, false)? + .visit_field::>("oscquery_error", Self::VT_OSCQUERY_ERROR, false)? + .visit_field::>>>("discovered_targets", Self::VT_DISCOVERED_TARGETS, false)? + .finish(); + Ok(()) + } +} +pub struct VRCOSCStatusChangeResponseArgs<'a> { + pub enabled: bool, + pub input_state: VRCOSCInputState, + pub input_port: Option, + pub input_error: Option>, + pub last_received_input_millis: Option, + pub output_state: VRCOSCOutputState, + pub output_error: Option>, + pub target_address: Option>, + pub target_port: Option, + pub target_source: VRCOSCTargetSource, + pub last_frame_sent_millis: Option, + pub oscquery_state: VRCOSCOscQueryState, + pub oscquery_advertised_port: Option, + pub oscquery_error: Option>, + pub discovered_targets: Option>>>>, +} +impl<'a> Default for VRCOSCStatusChangeResponseArgs<'a> { + #[inline] + fn default() -> Self { + VRCOSCStatusChangeResponseArgs { + enabled: false, + input_state: VRCOSCInputState::IDLE, + input_port: None, + input_error: None, + last_received_input_millis: None, + output_state: VRCOSCOutputState::IDLE, + output_error: None, + target_address: None, + target_port: None, + target_source: VRCOSCTargetSource::NONE, + last_frame_sent_millis: None, + oscquery_state: VRCOSCOscQueryState::DISABLED, + oscquery_advertised_port: None, + oscquery_error: None, + discovered_targets: None, + } + } +} + +pub struct VRCOSCStatusChangeResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VRCOSCStatusChangeResponseBuilder<'a, 'b> { + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(VRCOSCStatusChangeResponse::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_input_state(&mut self, input_state: VRCOSCInputState) { + self.fbb_.push_slot::(VRCOSCStatusChangeResponse::VT_INPUT_STATE, input_state, VRCOSCInputState::IDLE); + } + #[inline] + pub fn add_input_port(&mut self, input_port: u16) { + self.fbb_.push_slot_always::(VRCOSCStatusChangeResponse::VT_INPUT_PORT, input_port); + } + #[inline] + pub fn add_input_error(&mut self, input_error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCStatusChangeResponse::VT_INPUT_ERROR, input_error); + } + #[inline] + pub fn add_last_received_input_millis(&mut self, last_received_input_millis: u64) { + self.fbb_.push_slot_always::(VRCOSCStatusChangeResponse::VT_LAST_RECEIVED_INPUT_MILLIS, last_received_input_millis); + } + #[inline] + pub fn add_output_state(&mut self, output_state: VRCOSCOutputState) { + self.fbb_.push_slot::(VRCOSCStatusChangeResponse::VT_OUTPUT_STATE, output_state, VRCOSCOutputState::IDLE); + } + #[inline] + pub fn add_output_error(&mut self, output_error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCStatusChangeResponse::VT_OUTPUT_ERROR, output_error); + } + #[inline] + pub fn add_target_address(&mut self, target_address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCStatusChangeResponse::VT_TARGET_ADDRESS, target_address); + } + #[inline] + pub fn add_target_port(&mut self, target_port: u16) { + self.fbb_.push_slot_always::(VRCOSCStatusChangeResponse::VT_TARGET_PORT, target_port); + } + #[inline] + pub fn add_target_source(&mut self, target_source: VRCOSCTargetSource) { + self.fbb_.push_slot::(VRCOSCStatusChangeResponse::VT_TARGET_SOURCE, target_source, VRCOSCTargetSource::NONE); + } + #[inline] + pub fn add_last_frame_sent_millis(&mut self, last_frame_sent_millis: u64) { + self.fbb_.push_slot_always::(VRCOSCStatusChangeResponse::VT_LAST_FRAME_SENT_MILLIS, last_frame_sent_millis); + } + #[inline] + pub fn add_oscquery_state(&mut self, oscquery_state: VRCOSCOscQueryState) { + self.fbb_.push_slot::(VRCOSCStatusChangeResponse::VT_OSCQUERY_STATE, oscquery_state, VRCOSCOscQueryState::DISABLED); + } + #[inline] + pub fn add_oscquery_advertised_port(&mut self, oscquery_advertised_port: u16) { + self.fbb_.push_slot_always::(VRCOSCStatusChangeResponse::VT_OSCQUERY_ADVERTISED_PORT, oscquery_advertised_port); + } + #[inline] + pub fn add_oscquery_error(&mut self, oscquery_error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCOSCStatusChangeResponse::VT_OSCQUERY_ERROR, oscquery_error); + } + #[inline] + pub fn add_discovered_targets(&mut self, discovered_targets: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(VRCOSCStatusChangeResponse::VT_DISCOVERED_TARGETS, discovered_targets); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCStatusChangeResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + VRCOSCStatusChangeResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for VRCOSCStatusChangeResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VRCOSCStatusChangeResponse"); + ds.field("enabled", &self.enabled()); + ds.field("input_state", &self.input_state()); + ds.field("input_port", &self.input_port()); + ds.field("input_error", &self.input_error()); + ds.field("last_received_input_millis", &self.last_received_input_millis()); + ds.field("output_state", &self.output_state()); + ds.field("output_error", &self.output_error()); + ds.field("target_address", &self.target_address()); + ds.field("target_port", &self.target_port()); + ds.field("target_source", &self.target_source()); + ds.field("last_frame_sent_millis", &self.last_frame_sent_millis()); + ds.field("oscquery_state", &self.oscquery_state()); + ds.field("oscquery_advertised_port", &self.oscquery_advertised_port()); + ds.field("oscquery_error", &self.oscquery_error()); + ds.field("discovered_targets", &self.discovered_targets()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_request_generated.rs similarity index 61% rename from protocol/rust/src/generated/solarxr_protocol/rpc/status_system_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_request_generated.rs index a11ddb750..7a9ec494c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_system_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcoscstatus_request_generated.rs @@ -9,40 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum StatusSystemRequestOffset {} +pub enum VRCOSCStatusRequestOffset {} #[derive(Copy, Clone, PartialEq)] -/// Request current statuses that we have -pub struct StatusSystemRequest<'a> { +pub struct VRCOSCStatusRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for StatusSystemRequest<'a> { - type Inner = StatusSystemRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for VRCOSCStatusRequest<'a> { + type Inner = VRCOSCStatusRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> StatusSystemRequest<'a> { +impl<'a> VRCOSCStatusRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StatusSystemRequest { _tab: table } + VRCOSCStatusRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args StatusSystemRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = StatusSystemRequestBuilder::new(_fbb); + _args: &'args VRCOSCStatusRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCOSCStatusRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for StatusSystemRequest<'_> { +impl flatbuffers::Verifiable for VRCOSCStatusRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -53,39 +52,39 @@ impl flatbuffers::Verifiable for StatusSystemRequest<'_> { Ok(()) } } -pub struct StatusSystemRequestArgs { +pub struct VRCOSCStatusRequestArgs { } -impl<'a> Default for StatusSystemRequestArgs { +impl<'a> Default for VRCOSCStatusRequestArgs { #[inline] fn default() -> Self { - StatusSystemRequestArgs { + VRCOSCStatusRequestArgs { } } } -pub struct StatusSystemRequestBuilder<'a: 'b, 'b> { +pub struct VRCOSCStatusRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> StatusSystemRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> VRCOSCStatusRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusSystemRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCOSCStatusRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - StatusSystemRequestBuilder { + VRCOSCStatusRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for StatusSystemRequest<'_> { +impl core::fmt::Debug for VRCOSCStatusRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("StatusSystemRequest"); + let mut ds = f.debug_struct("VRCOSCStatusRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcosctarget_source_generated.rs similarity index 70% rename from protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrcosctarget_source_generated.rs index e81d9bf02..52772d535 100644 --- a/protocol/rust/src/generated/solarxr_protocol/pub_sub/topic_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcosctarget_source_generated.rs @@ -10,44 +10,44 @@ use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MIN_TOPIC: u8 = 0; +pub const ENUM_MIN_VRCOSCTARGET_SOURCE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_TOPIC: u8 = 2; +pub const ENUM_MAX_VRCOSCTARGET_SOURCE: u8 = 2; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_TOPIC: [Topic; 3] = [ - Topic::NONE, - Topic::TopicHandle, - Topic::TopicId, +pub const ENUM_VALUES_VRCOSCTARGET_SOURCE: [VRCOSCTargetSource; 3] = [ + VRCOSCTargetSource::NONE, + VRCOSCTargetSource::MANUAL, + VRCOSCTargetSource::DISCOVERED, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -pub struct Topic(pub u8); +pub struct VRCOSCTargetSource(pub u8); #[allow(non_upper_case_globals)] -impl Topic { +impl VRCOSCTargetSource { pub const NONE: Self = Self(0); - pub const TopicHandle: Self = Self(1); - pub const TopicId: Self = Self(2); + pub const MANUAL: Self = Self(1); + pub const DISCOVERED: Self = Self(2); pub const ENUM_MIN: u8 = 0; pub const ENUM_MAX: u8 = 2; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, - Self::TopicHandle, - Self::TopicId, + Self::MANUAL, + Self::DISCOVERED, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { match self { Self::NONE => Some("NONE"), - Self::TopicHandle => Some("TopicHandle"), - Self::TopicId => Some("TopicId"), + Self::MANUAL => Some("MANUAL"), + Self::DISCOVERED => Some("DISCOVERED"), _ => None, } } } -impl core::fmt::Debug for Topic { +impl core::fmt::Debug for VRCOSCTargetSource { fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { if let Some(name) = self.variant_name() { f.write_str(name) @@ -56,7 +56,7 @@ impl core::fmt::Debug for Topic { } } } -impl<'a> flatbuffers::Follow<'a> for Topic { +impl<'a> flatbuffers::Follow<'a> for VRCOSCTargetSource { type Inner = Self; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { @@ -65,15 +65,15 @@ impl<'a> flatbuffers::Follow<'a> for Topic { } } -impl flatbuffers::Push for Topic { - type Output = Topic; +impl flatbuffers::Push for VRCOSCTargetSource { + type Output = VRCOSCTargetSource; #[inline] unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { flatbuffers::emplace_scalar::(dst, self.0); } } -impl flatbuffers::EndianScalar for Topic { +impl flatbuffers::EndianScalar for VRCOSCTargetSource { type Scalar = u8; #[inline] fn to_little_endian(self) -> u8 { @@ -87,7 +87,7 @@ impl flatbuffers::EndianScalar for Topic { } } -impl<'a> flatbuffers::Verifiable for Topic { +impl<'a> flatbuffers::Verifiable for VRCOSCTargetSource { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -97,6 +97,4 @@ impl<'a> flatbuffers::Verifiable for Topic { } } -impl flatbuffers::SimpleToVerifyInSlice for Topic {} -pub struct TopicUnionTableOffset {} - +impl flatbuffers::SimpleToVerifyInSlice for VRCOSCTargetSource {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_request_generated.rs similarity index 62% rename from protocol/rust/src/generated/solarxr_protocol/rpc/settings_request_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_request_generated.rs index 233769567..38543fa4e 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/settings_request_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_request_generated.rs @@ -9,39 +9,39 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum SettingsRequestOffset {} +pub enum VRMSettingsRequestOffset {} #[derive(Copy, Clone, PartialEq)] -pub struct SettingsRequest<'a> { +pub struct VRMSettingsRequest<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for SettingsRequest<'a> { - type Inner = SettingsRequest<'a>; +impl<'a> flatbuffers::Follow<'a> for VRMSettingsRequest<'a> { + type Inner = VRMSettingsRequest<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> SettingsRequest<'a> { +impl<'a> VRMSettingsRequest<'a> { #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SettingsRequest { _tab: table } + VRMSettingsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - _args: &'args SettingsRequestArgs - ) -> flatbuffers::WIPOffset> { - let mut builder = SettingsRequestBuilder::new(_fbb); + _args: &'args VRMSettingsRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = VRMSettingsRequestBuilder::new(_fbb); builder.finish() } } -impl flatbuffers::Verifiable for SettingsRequest<'_> { +impl flatbuffers::Verifiable for VRMSettingsRequest<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -52,39 +52,39 @@ impl flatbuffers::Verifiable for SettingsRequest<'_> { Ok(()) } } -pub struct SettingsRequestArgs { +pub struct VRMSettingsRequestArgs { } -impl<'a> Default for SettingsRequestArgs { +impl<'a> Default for VRMSettingsRequestArgs { #[inline] fn default() -> Self { - SettingsRequestArgs { + VRMSettingsRequestArgs { } } } -pub struct SettingsRequestBuilder<'a: 'b, 'b> { +pub struct VRMSettingsRequestBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> SettingsRequestBuilder<'a, 'b> { +impl<'a: 'b, 'b> VRMSettingsRequestBuilder<'a, 'b> { #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SettingsRequestBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRMSettingsRequestBuilder<'a, 'b> { let start = _fbb.start_table(); - SettingsRequestBuilder { + VRMSettingsRequestBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for SettingsRequest<'_> { +impl core::fmt::Debug for VRMSettingsRequest<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("SettingsRequest"); + let mut ds = f.debug_struct("VRMSettingsRequest"); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_response_generated.rs similarity index 68% rename from protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_generated.rs rename to protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_response_generated.rs index 4d7b7c2a5..5eaa857f0 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrmsettings_response_generated.rs @@ -9,35 +9,34 @@ use core::mem; use core::cmp::Ordering; use self::flatbuffers::{EndianScalar, Follow}; use super::*; -pub enum VRMSettingsOffset {} +pub enum VRMSettingsResponseOffset {} #[derive(Copy, Clone, PartialEq)] -/// VRM Settings for rescaling to avatar-scale -pub struct VRMSettings<'a> { +pub struct VRMSettingsResponse<'a> { pub _tab: flatbuffers::Table<'a>, } -impl<'a> flatbuffers::Follow<'a> for VRMSettings<'a> { - type Inner = VRMSettings<'a>; +impl<'a> flatbuffers::Follow<'a> for VRMSettingsResponse<'a> { + type Inner = VRMSettingsResponse<'a>; #[inline] unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { Self { _tab: flatbuffers::Table::new(buf, loc) } } } -impl<'a> VRMSettings<'a> { +impl<'a> VRMSettingsResponse<'a> { pub const VT_VRM_JSON: flatbuffers::VOffsetT = 4; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - VRMSettings { _tab: table } + VRMSettingsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args VRMSettingsArgs<'args> - ) -> flatbuffers::WIPOffset> { - let mut builder = VRMSettingsBuilder::new(_fbb); + args: &'args VRMSettingsResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRMSettingsResponseBuilder::new(_fbb); if let Some(x) = args.vrm_json { builder.add_vrm_json(x); } builder.finish() } @@ -48,11 +47,11 @@ impl<'a> VRMSettings<'a> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(VRMSettings::VT_VRM_JSON, None)} + unsafe { self._tab.get::>(VRMSettingsResponse::VT_VRM_JSON, None)} } } -impl flatbuffers::Verifiable for VRMSettings<'_> { +impl flatbuffers::Verifiable for VRMSettingsResponse<'_> { #[inline] fn run_verifier( v: &mut flatbuffers::Verifier, pos: usize @@ -64,45 +63,45 @@ impl flatbuffers::Verifiable for VRMSettings<'_> { Ok(()) } } -pub struct VRMSettingsArgs<'a> { +pub struct VRMSettingsResponseArgs<'a> { pub vrm_json: Option>, } -impl<'a> Default for VRMSettingsArgs<'a> { +impl<'a> Default for VRMSettingsResponseArgs<'a> { #[inline] fn default() -> Self { - VRMSettingsArgs { + VRMSettingsResponseArgs { vrm_json: None, } } } -pub struct VRMSettingsBuilder<'a: 'b, 'b> { +pub struct VRMSettingsResponseBuilder<'a: 'b, 'b> { fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, start_: flatbuffers::WIPOffset, } -impl<'a: 'b, 'b> VRMSettingsBuilder<'a, 'b> { +impl<'a: 'b, 'b> VRMSettingsResponseBuilder<'a, 'b> { #[inline] pub fn add_vrm_json(&mut self, vrm_json: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(VRMSettings::VT_VRM_JSON, vrm_json); + self.fbb_.push_slot_always::>(VRMSettingsResponse::VT_VRM_JSON, vrm_json); } #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRMSettingsBuilder<'a, 'b> { + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRMSettingsResponseBuilder<'a, 'b> { let start = _fbb.start_table(); - VRMSettingsBuilder { + VRMSettingsResponseBuilder { fbb_: _fbb, start_: start, } } #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { + pub fn finish(self) -> flatbuffers::WIPOffset> { let o = self.fbb_.end_table(self.start_); flatbuffers::WIPOffset::new(o.value()) } } -impl core::fmt::Debug for VRMSettings<'_> { +impl core::fmt::Debug for VRMSettingsResponse<'_> { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let mut ds = f.debug_struct("VRMSettings"); + let mut ds = f.debug_struct("VRMSettingsResponse"); ds.field("vrm_json", &self.vrm_json()); ds.finish() } diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index ed6ec8349..2baf7acc7 100644 --- a/protocol/typescript/src/all_generated.ts +++ b/protocol/typescript/src/all_generated.ts @@ -13,22 +13,16 @@ export { DeviceDataMask, DeviceDataMaskT } from './solarxr-protocol/data-feed/de export { ServerGuards, ServerGuardsT } from './solarxr-protocol/data-feed/server/server-guards.js'; export { StayAlignedPose, StayAlignedPoseT } from './solarxr-protocol/data-feed/stay-aligned/stay-aligned-pose.js'; export { StayAlignedTracker, StayAlignedTrackerT } from './solarxr-protocol/data-feed/stay-aligned/stay-aligned-tracker.js'; -export { TrackerData, TrackerDataT } from './solarxr-protocol/data-feed/tracker/tracker-data.js'; -export { TrackerDataMask, TrackerDataMaskT } from './solarxr-protocol/data-feed/tracker/tracker-data-mask.js'; -export { TrackerInfo, TrackerInfoT } from './solarxr-protocol/data-feed/tracker/tracker-info.js'; +export { TrackerData, TrackerDataT } from './solarxr-protocol/data-feed/tracker-data/tracker-data.js'; +export { TrackerDataMask, TrackerDataMaskT } from './solarxr-protocol/data-feed/tracker-data/tracker-data-mask.js'; +export { TrackerInfo, TrackerInfoT } from './solarxr-protocol/data-feed/tracker-data/tracker-info.js'; export { BodyPart } from './solarxr-protocol/datatypes/body-part.js'; -export { Bytes, BytesT } from './solarxr-protocol/datatypes/bytes.js'; -export { DeviceId, DeviceIdT } from './solarxr-protocol/datatypes/device-id.js'; -export { DeviceIdTable, DeviceIdTableT } from './solarxr-protocol/datatypes/device-id-table.js'; -export { FilteringType } from './solarxr-protocol/datatypes/filtering-type.js'; export { FirmwareErrorCode } from './solarxr-protocol/datatypes/firmware-error-code.js'; export { HzF32, HzF32T } from './solarxr-protocol/datatypes/hz-f32.js'; export { Ipv4Address, Ipv4AddressT } from './solarxr-protocol/datatypes/ipv4-address.js'; export { LogData, LogDataT } from './solarxr-protocol/datatypes/log-data.js'; export { MagnetometerStatus } from './solarxr-protocol/datatypes/magnetometer-status.js'; -export { StringTable, StringTableT } from './solarxr-protocol/datatypes/string-table.js'; export { Temperature, TemperatureT } from './solarxr-protocol/datatypes/temperature.js'; -export { TrackerId, TrackerIdT } from './solarxr-protocol/datatypes/tracker-id.js'; export { TrackerStatus } from './solarxr-protocol/datatypes/tracker-status.js'; export { TransactionId, TransactionIdT } from './solarxr-protocol/datatypes/transaction-id.js'; export { BoardType } from './solarxr-protocol/datatypes/hardware-info/board-type.js'; @@ -41,19 +35,8 @@ export { McuType } from './solarxr-protocol/datatypes/hardware-info/mcu-type.js' export { TrackerDataType } from './solarxr-protocol/datatypes/hardware-info/tracker-data-type.js'; export { Quat, QuatT } from './solarxr-protocol/datatypes/math/quat.js'; export { Vec3f, Vec3fT } from './solarxr-protocol/datatypes/math/vec3f.js'; -export { KeyValues, KeyValuesT } from './solarxr-protocol/pub-sub/key-values.js'; -export { Message, MessageT } from './solarxr-protocol/pub-sub/message.js'; -export { Payload, unionToPayload, unionListToPayload } from './solarxr-protocol/pub-sub/payload.js'; -export { PubSubHeader, PubSubHeaderT } from './solarxr-protocol/pub-sub/pub-sub-header.js'; -export { PubSubUnion, unionToPubSubUnion, unionListToPubSubUnion } from './solarxr-protocol/pub-sub/pub-sub-union.js'; -export { SubscriptionRequest, SubscriptionRequestT } from './solarxr-protocol/pub-sub/subscription-request.js'; -export { Topic, unionToTopic, unionListToTopic } from './solarxr-protocol/pub-sub/topic.js'; -export { TopicHandle, TopicHandleT } from './solarxr-protocol/pub-sub/topic-handle.js'; -export { TopicHandleRequest, TopicHandleRequestT } from './solarxr-protocol/pub-sub/topic-handle-request.js'; -export { TopicId, TopicIdT } from './solarxr-protocol/pub-sub/topic-id.js'; -export { TopicMapping, TopicMappingT } from './solarxr-protocol/pub-sub/topic-mapping.js'; export { AddUnknownDeviceRequest, AddUnknownDeviceRequestT } from './solarxr-protocol/rpc/add-unknown-device-request.js'; -export { ArmsMountingResetMode } from './solarxr-protocol/rpc/arms-mounting-reset-mode.js'; +export { ArmsResetMode } from './solarxr-protocol/rpc/arms-reset-mode.js'; export { AssignTrackerRequest, AssignTrackerRequestT } from './solarxr-protocol/rpc/assign-tracker-request.js'; export { AutoBoneApplyRequest, AutoBoneApplyRequestT } from './solarxr-protocol/rpc/auto-bone-apply-request.js'; export { AutoBoneCancelRecordingRequest, AutoBoneCancelRecordingRequestT } from './solarxr-protocol/rpc/auto-bone-cancel-recording-request.js'; @@ -61,22 +44,29 @@ export { AutoBoneEpochResponse, AutoBoneEpochResponseT } from './solarxr-protoco export { AutoBoneProcessRequest, AutoBoneProcessRequestT } from './solarxr-protocol/rpc/auto-bone-process-request.js'; export { AutoBoneProcessStatusResponse, AutoBoneProcessStatusResponseT } from './solarxr-protocol/rpc/auto-bone-process-status-response.js'; export { AutoBoneProcessType } from './solarxr-protocol/rpc/auto-bone-process-type.js'; -export { AutoBoneSettings, AutoBoneSettingsT } from './solarxr-protocol/rpc/auto-bone-settings.js'; export { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from './solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; export { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from './solarxr-protocol/rpc/cancel-user-height-calibration.js'; +export { ChangeHIDSettingsRequest, ChangeHIDSettingsRequestT } from './solarxr-protocol/rpc/change-hidsettings-request.js'; export { ChangeKeybindRequest, ChangeKeybindRequestT } from './solarxr-protocol/rpc/change-keybind-request.js'; export { ChangeMagToggleRequest, ChangeMagToggleRequestT } from './solarxr-protocol/rpc/change-mag-toggle-request.js'; -export { ChangeSettingsRequest, ChangeSettingsRequestT } from './solarxr-protocol/rpc/change-settings-request.js'; -export { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from './solarxr-protocol/rpc/change-skeleton-config-request.js'; -export { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from './solarxr-protocol/rpc/clear-drift-compensation-request.js'; +export { ChangeOutputTrackersSettingsRequest, ChangeOutputTrackersSettingsRequestT } from './solarxr-protocol/rpc/change-output-trackers-settings-request.js'; +export { ChangeResetsSettingsRequest, ChangeResetsSettingsRequestT } from './solarxr-protocol/rpc/change-resets-settings-request.js'; +export { ChangeSkeletonProportionsRequest, ChangeSkeletonProportionsRequestT } from './solarxr-protocol/rpc/change-skeleton-proportions-request.js'; +export { ChangeSkeletonSettingsRequest, ChangeSkeletonSettingsRequestT } from './solarxr-protocol/rpc/change-skeleton-settings-request.js'; +export { ChangeStayAlignedSettingsRequest, ChangeStayAlignedSettingsRequestT } from './solarxr-protocol/rpc/change-stay-aligned-settings-request.js'; +export { ChangeTapDetectionSettingsRequest, ChangeTapDetectionSettingsRequestT } from './solarxr-protocol/rpc/change-tap-detection-settings-request.js'; +export { ChangeVMCOSCSettingsRequest, ChangeVMCOSCSettingsRequestT } from './solarxr-protocol/rpc/change-vmcoscsettings-request.js'; +export { ChangeVRCOSCSettingsRequest, ChangeVRCOSCSettingsRequestT } from './solarxr-protocol/rpc/change-vrcoscsettings-request.js'; +export { ChangeVRMSettingsRequest, ChangeVRMSettingsRequestT } from './solarxr-protocol/rpc/change-vrmsettings-request.js'; export { ClearMountingResetRequest, ClearMountingResetRequestT } from './solarxr-protocol/rpc/clear-mounting-reset-request.js'; export { CloseSerialRequest, CloseSerialRequestT } from './solarxr-protocol/rpc/close-serial-request.js'; +export { CompleteStayAlignedResponse, CompleteStayAlignedResponseT } from './solarxr-protocol/rpc/complete-stay-aligned-response.js'; export { ComputerDirectory } from './solarxr-protocol/rpc/computer-directory.js'; export { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from './solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; -export { DriftCompensationSettings, DriftCompensationSettingsT } from './solarxr-protocol/rpc/drift-compensation-settings.js'; export { EnableStayAlignedRequest, EnableStayAlignedRequestT } from './solarxr-protocol/rpc/enable-stay-aligned-request.js'; export { EnableSteamVRDriverRequest, EnableSteamVRDriverRequestT } from './solarxr-protocol/rpc/enable-steam-vrdriver-request.js'; -export { FilteringSettings, FilteringSettingsT } from './solarxr-protocol/rpc/filtering-settings.js'; +export { FilteringType } from './solarxr-protocol/rpc/filtering-type.js'; +export { FirmwareDeviceIdTable, FirmwareDeviceIdTableT } from './solarxr-protocol/rpc/firmware-device-id-table.js'; export { FirmwarePart, FirmwarePartT } from './solarxr-protocol/rpc/firmware-part.js'; export { FirmwareUpdateDeviceId, unionToFirmwareUpdateDeviceId, unionListToFirmwareUpdateDeviceId } from './solarxr-protocol/rpc/firmware-update-device-id.js'; export { FirmwareUpdateMethod, unionToFirmwareUpdateMethod, unionListToFirmwareUpdateMethod } from './solarxr-protocol/rpc/firmware-update-method.js'; @@ -85,11 +75,10 @@ export { FirmwareUpdateStatus } from './solarxr-protocol/rpc/firmware-update-sta export { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from './solarxr-protocol/rpc/firmware-update-status-response.js'; export { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from './solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; export { ForgetDeviceRequest, ForgetDeviceRequestT } from './solarxr-protocol/rpc/forget-device-request.js'; -export { HIDSettings, HIDSettingsT } from './solarxr-protocol/rpc/hidsettings.js'; +export { HIDSettingsRequest, HIDSettingsRequestT } from './solarxr-protocol/rpc/hidsettings-request.js'; +export { HIDSettingsResponse, HIDSettingsResponseT } from './solarxr-protocol/rpc/hidsettings-response.js'; export { HeartbeatRequest, HeartbeatRequestT } from './solarxr-protocol/rpc/heartbeat-request.js'; export { HeartbeatResponse, HeartbeatResponseT } from './solarxr-protocol/rpc/heartbeat-response.js'; -export { HeightRequest, HeightRequestT } from './solarxr-protocol/rpc/height-request.js'; -export { HeightResponse, HeightResponseT } from './solarxr-protocol/rpc/height-response.js'; export { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from './solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; export { InstalledInfoRequest, InstalledInfoRequestT } from './solarxr-protocol/rpc/installed-info-request.js'; export { InstalledInfoResponse, InstalledInfoResponseT } from './solarxr-protocol/rpc/installed-info-response.js'; @@ -102,13 +91,12 @@ export { LegTweaksTmpClear, LegTweaksTmpClearT } from './solarxr-protocol/rpc/le export { MagToggleRequest, MagToggleRequestT } from './solarxr-protocol/rpc/mag-toggle-request.js'; export { MagToggleResponse, MagToggleResponseT } from './solarxr-protocol/rpc/mag-toggle-response.js'; export { NewSerialDeviceResponse, NewSerialDeviceResponseT } from './solarxr-protocol/rpc/new-serial-device-response.js'; -export { OSCRouterSettings, OSCRouterSettingsT } from './solarxr-protocol/rpc/oscrouter-settings.js'; -export { OSCSettings, OSCSettingsT } from './solarxr-protocol/rpc/oscsettings.js'; -export { OSCTrackersSetting, OSCTrackersSettingT } from './solarxr-protocol/rpc/osctrackers-setting.js'; export { OTAFirmwareUpdate, OTAFirmwareUpdateT } from './solarxr-protocol/rpc/otafirmware-update.js'; export { OpenSerialRequest, OpenSerialRequestT } from './solarxr-protocol/rpc/open-serial-request.js'; export { OpenUriRequest, OpenUriRequestT } from './solarxr-protocol/rpc/open-uri-request.js'; export { OpenUriResponse, OpenUriResponseT } from './solarxr-protocol/rpc/open-uri-response.js'; +export { OutputTrackersSettingsRequest, OutputTrackersSettingsRequestT } from './solarxr-protocol/rpc/output-trackers-settings-request.js'; +export { OutputTrackersSettingsResponse, OutputTrackersSettingsResponseT } from './solarxr-protocol/rpc/output-trackers-settings-response.js'; export { OverlayDisplayModeChangeRequest, OverlayDisplayModeChangeRequestT } from './solarxr-protocol/rpc/overlay-display-mode-change-request.js'; export { OverlayDisplayModeRequest, OverlayDisplayModeRequestT } from './solarxr-protocol/rpc/overlay-display-mode-request.js'; export { OverlayDisplayModeResponse, OverlayDisplayModeResponseT } from './solarxr-protocol/rpc/overlay-display-mode-response.js'; @@ -120,7 +108,8 @@ export { ResetResponse, ResetResponseT } from './solarxr-protocol/rpc/reset-resp export { ResetStatus } from './solarxr-protocol/rpc/reset-status.js'; export { ResetStayAlignedRelaxedPoseRequest, ResetStayAlignedRelaxedPoseRequestT } from './solarxr-protocol/rpc/reset-stay-aligned-relaxed-pose-request.js'; export { ResetType } from './solarxr-protocol/rpc/reset-type.js'; -export { ResetsSettings, ResetsSettingsT } from './solarxr-protocol/rpc/resets-settings.js'; +export { ResetsSettingsRequest, ResetsSettingsRequestT } from './solarxr-protocol/rpc/resets-settings-request.js'; +export { ResetsSettingsResponse, ResetsSettingsResponseT } from './solarxr-protocol/rpc/resets-settings-response.js'; export { RpcMessage, unionToRpcMessage, unionListToRpcMessage } from './solarxr-protocol/rpc/rpc-message.js'; export { RpcMessageHeader, RpcMessageHeaderT } from './solarxr-protocol/rpc/rpc-message-header.js'; export { SaveFileNotification, SaveFileNotificationT } from './solarxr-protocol/rpc/save-file-notification.js'; @@ -139,35 +128,29 @@ export { SerialUpdateResponse, SerialUpdateResponseT } from './solarxr-protocol/ export { ServerInfosRequest, ServerInfosRequestT } from './solarxr-protocol/rpc/server-infos-request.js'; export { ServerInfosResponse, ServerInfosResponseT } from './solarxr-protocol/rpc/server-infos-response.js'; export { SetPauseTrackingRequest, SetPauseTrackingRequestT } from './solarxr-protocol/rpc/set-pause-tracking-request.js'; -export { SetWifiRequest, SetWifiRequestT } from './solarxr-protocol/rpc/set-wifi-request.js'; -export { SettingsRequest, SettingsRequestT } from './solarxr-protocol/rpc/settings-request.js'; export { SettingsResetRequest, SettingsResetRequestT } from './solarxr-protocol/rpc/settings-reset-request.js'; -export { SettingsResponse, SettingsResponseT } from './solarxr-protocol/rpc/settings-response.js'; export { SkeletonBone } from './solarxr-protocol/rpc/skeleton-bone.js'; -export { SkeletonConfigRequest, SkeletonConfigRequestT } from './solarxr-protocol/rpc/skeleton-config-request.js'; -export { SkeletonConfigResponse, SkeletonConfigResponseT } from './solarxr-protocol/rpc/skeleton-config-response.js'; +export { SkeletonFiltering, SkeletonFilteringT } from './solarxr-protocol/rpc/skeleton-filtering.js'; +export { SkeletonHeight, SkeletonHeightT } from './solarxr-protocol/rpc/skeleton-height.js'; export { SkeletonPart, SkeletonPartT } from './solarxr-protocol/rpc/skeleton-part.js'; -export { SkeletonResetAllRequest, SkeletonResetAllRequestT } from './solarxr-protocol/rpc/skeleton-reset-all-request.js'; +export { SkeletonProportionsRequest, SkeletonProportionsRequestT } from './solarxr-protocol/rpc/skeleton-proportions-request.js'; +export { SkeletonProportionsResetAllRequest, SkeletonProportionsResetAllRequestT } from './solarxr-protocol/rpc/skeleton-proportions-reset-all-request.js'; +export { SkeletonProportionsResponse, SkeletonProportionsResponseT } from './solarxr-protocol/rpc/skeleton-proportions-response.js'; +export { SkeletonRatios, SkeletonRatiosT } from './solarxr-protocol/rpc/skeleton-ratios.js'; +export { SkeletonSettingsRequest, SkeletonSettingsRequestT } from './solarxr-protocol/rpc/skeleton-settings-request.js'; +export { SkeletonSettingsResponse, SkeletonSettingsResponseT } from './solarxr-protocol/rpc/skeleton-settings-response.js'; +export { SkeletonToggles, SkeletonTogglesT } from './solarxr-protocol/rpc/skeleton-toggles.js'; export { StartUserHeightCalibration, StartUserHeightCalibrationT } from './solarxr-protocol/rpc/start-user-height-calibration.js'; export { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from './solarxr-protocol/rpc/start-wifi-provisioning-request.js'; -export { StatusData, unionToStatusData, unionListToStatusData } from './solarxr-protocol/rpc/status-data.js'; -export { StatusMessage, StatusMessageT } from './solarxr-protocol/rpc/status-message.js'; -export { StatusPublicNetwork, StatusPublicNetworkT } from './solarxr-protocol/rpc/status-public-network.js'; -export { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from './solarxr-protocol/rpc/status-steam-vrdisconnected.js'; -export { StatusSystemFixed, StatusSystemFixedT } from './solarxr-protocol/rpc/status-system-fixed.js'; -export { StatusSystemRequest, StatusSystemRequestT } from './solarxr-protocol/rpc/status-system-request.js'; -export { StatusSystemResponse, StatusSystemResponseT } from './solarxr-protocol/rpc/status-system-response.js'; -export { StatusSystemUpdate, StatusSystemUpdateT } from './solarxr-protocol/rpc/status-system-update.js'; -export { StatusTrackerError, StatusTrackerErrorT } from './solarxr-protocol/rpc/status-tracker-error.js'; -export { StatusTrackerReset, StatusTrackerResetT } from './solarxr-protocol/rpc/status-tracker-reset.js'; -export { StatusUnassignedHMD, StatusUnassignedHMDT } from './solarxr-protocol/rpc/status-unassigned-hmd.js'; +export { StayAlignedHideCorrectionRequest, StayAlignedHideCorrectionRequestT } from './solarxr-protocol/rpc/stay-aligned-hide-correction-request.js'; export { StayAlignedRelaxedPose } from './solarxr-protocol/rpc/stay-aligned-relaxed-pose.js'; -export { StayAlignedSettings, StayAlignedSettingsT } from './solarxr-protocol/rpc/stay-aligned-settings.js'; -export { SteamVRTrackersSetting, SteamVRTrackersSettingT } from './solarxr-protocol/rpc/steam-vrtrackers-setting.js'; +export { StayAlignedSettingsRequest, StayAlignedSettingsRequestT } from './solarxr-protocol/rpc/stay-aligned-settings-request.js'; +export { StayAlignedSettingsResponse, StayAlignedSettingsResponseT } from './solarxr-protocol/rpc/stay-aligned-settings-response.js'; export { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from './solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; -export { TapDetectionSettings, TapDetectionSettingsT } from './solarxr-protocol/rpc/tap-detection-settings.js'; +export { TapDetectionSettingsRequest, TapDetectionSettingsRequestT } from './solarxr-protocol/rpc/tap-detection-settings-request.js'; +export { TapDetectionSettingsResponse, TapDetectionSettingsResponseT } from './solarxr-protocol/rpc/tap-detection-settings-response.js'; +export { TapDetectionSetupModeRequest, TapDetectionSetupModeRequestT } from './solarxr-protocol/rpc/tap-detection-setup-mode-request.js'; export { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from './solarxr-protocol/rpc/tap-detection-setup-notification.js'; -export { TimeoutSettings, TimeoutSettingsT } from './solarxr-protocol/rpc/timeout-settings.js'; export { TrackingChecklistExtraData, unionToTrackingChecklistExtraData, unionListToTrackingChecklistExtraData } from './solarxr-protocol/rpc/tracking-checklist-extra-data.js'; export { TrackingChecklistNeedCalibration, TrackingChecklistNeedCalibrationT } from './solarxr-protocol/rpc/tracking-checklist-need-calibration.js'; export { TrackingChecklistPublicNetworks, TrackingChecklistPublicNetworksT } from './solarxr-protocol/rpc/tracking-checklist-public-networks.js'; @@ -185,7 +168,8 @@ export { TrackingPauseStateResponse, TrackingPauseStateResponseT } from './solar export { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from './solarxr-protocol/rpc/unknown-device-handshake-notification.js'; export { UserHeightCalibrationStatus } from './solarxr-protocol/rpc/user-height-calibration-status.js'; export { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from './solarxr-protocol/rpc/user-height-recording-status-response.js'; -export { VMCOSCSettings, VMCOSCSettingsT } from './solarxr-protocol/rpc/vmcoscsettings.js'; +export { VMCOSCSettingsRequest, VMCOSCSettingsRequestT } from './solarxr-protocol/rpc/vmcoscsettings-request.js'; +export { VMCOSCSettingsResponse, VMCOSCSettingsResponseT } from './solarxr-protocol/rpc/vmcoscsettings-response.js'; export { VRCAvatarMeasurementType } from './solarxr-protocol/rpc/vrcavatar-measurement-type.js'; export { VRCConfigRecommendedValues, VRCConfigRecommendedValuesT } from './solarxr-protocol/rpc/vrcconfig-recommended-values.js'; export { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from './solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; @@ -193,15 +177,19 @@ export { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from './s export { VRCConfigStateRequest, VRCConfigStateRequestT } from './solarxr-protocol/rpc/vrcconfig-state-request.js'; export { VRCConfigValidity, VRCConfigValidityT } from './solarxr-protocol/rpc/vrcconfig-validity.js'; export { VRCConfigValues, VRCConfigValuesT } from './solarxr-protocol/rpc/vrcconfig-values.js'; -export { VRCOSCSettings, VRCOSCSettingsT } from './solarxr-protocol/rpc/vrcoscsettings.js'; +export { VRCOSCDiscoveredTarget, VRCOSCDiscoveredTargetT } from './solarxr-protocol/rpc/vrcoscdiscovered-target.js'; +export { VRCOSCInputState } from './solarxr-protocol/rpc/vrcoscinput-state.js'; +export { VRCOSCNetworkSettings, VRCOSCNetworkSettingsT } from './solarxr-protocol/rpc/vrcoscnetwork-settings.js'; +export { VRCOSCOscQueryState } from './solarxr-protocol/rpc/vrcoscosc-query-state.js'; +export { VRCOSCOutputState } from './solarxr-protocol/rpc/vrcoscoutput-state.js'; +export { VRCOSCSettingsRequest, VRCOSCSettingsRequestT } from './solarxr-protocol/rpc/vrcoscsettings-request.js'; +export { VRCOSCSettingsResponse, VRCOSCSettingsResponseT } from './solarxr-protocol/rpc/vrcoscsettings-response.js'; +export { VRCOSCStatusChangeResponse, VRCOSCStatusChangeResponseT } from './solarxr-protocol/rpc/vrcoscstatus-change-response.js'; +export { VRCOSCStatusRequest, VRCOSCStatusRequestT } from './solarxr-protocol/rpc/vrcoscstatus-request.js'; +export { VRCOSCTargetSource } from './solarxr-protocol/rpc/vrcosctarget-source.js'; export { VRCSpineMode } from './solarxr-protocol/rpc/vrcspine-mode.js'; export { VRCTrackerModel } from './solarxr-protocol/rpc/vrctracker-model.js'; -export { VRMSettings, VRMSettingsT } from './solarxr-protocol/rpc/vrmsettings.js'; -export { VelocitySettings, VelocitySettingsT } from './solarxr-protocol/rpc/velocity-settings.js'; +export { VRMSettingsRequest, VRMSettingsRequestT } from './solarxr-protocol/rpc/vrmsettings-request.js'; +export { VRMSettingsResponse, VRMSettingsResponseT } from './solarxr-protocol/rpc/vrmsettings-response.js'; export { WifiProvisioningStatus } from './solarxr-protocol/rpc/wifi-provisioning-status.js'; export { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from './solarxr-protocol/rpc/wifi-provisioning-status-response.js'; -export { LegTweaksSettings, LegTweaksSettingsT } from './solarxr-protocol/rpc/settings/leg-tweaks-settings.js'; -export { ModelRatios, ModelRatiosT } from './solarxr-protocol/rpc/settings/model-ratios.js'; -export { ModelSettings, ModelSettingsT } from './solarxr-protocol/rpc/settings/model-settings.js'; -export { ModelToggles, ModelTogglesT } from './solarxr-protocol/rpc/settings/model-toggles.js'; -export { SkeletonHeight, SkeletonHeightT } from './solarxr-protocol/rpc/settings/skeleton-height.js'; diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts index 043a8da5c..c2d512bc7 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts @@ -3,7 +3,7 @@ import * as flatbuffers from 'flatbuffers'; import { DeviceDataMask, DeviceDataMaskT } from '../../solarxr-protocol/data-feed/device-data/device-data-mask.js'; -import { TrackerDataMask, TrackerDataMaskT } from '../../solarxr-protocol/data-feed/tracker/tracker-data-mask.js'; +import { TrackerDataMask, TrackerDataMaskT } from '../../solarxr-protocol/data-feed/tracker-data/tracker-data-mask.js'; /** diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts index 5c2fd13c9..333d32c7c 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts @@ -6,7 +6,7 @@ import { Bone, BoneT } from '../../solarxr-protocol/data-feed/bone.js'; import { DeviceData, DeviceDataT } from '../../solarxr-protocol/data-feed/device-data/device-data.js'; import { ServerGuards, ServerGuardsT } from '../../solarxr-protocol/data-feed/server/server-guards.js'; import { StayAlignedPose, StayAlignedPoseT } from '../../solarxr-protocol/data-feed/stay-aligned/stay-aligned-pose.js'; -import { TrackerData, TrackerDataT } from '../../solarxr-protocol/data-feed/tracker/tracker-data.js'; +import { TrackerData, TrackerDataT } from '../../solarxr-protocol/data-feed/tracker-data/tracker-data.js'; /** @@ -74,6 +74,9 @@ stayAlignedPose(obj?:StayAlignedPose):StayAlignedPose|null { return offset ? (obj || new StayAlignedPose()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } +/** + * gives the index of the datafeed config that initiated the update + */ index():number { const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data-mask.ts b/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data-mask.ts index 2f18870c3..1a1196d77 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data-mask.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data-mask.ts @@ -2,7 +2,7 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerDataMask, TrackerDataMaskT } from '../../../solarxr-protocol/data-feed/tracker/tracker-data-mask.js'; +import { TrackerDataMask, TrackerDataMaskT } from '../../../solarxr-protocol/data-feed/tracker-data/tracker-data-mask.js'; /** diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data.ts b/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data.ts index cf35b8de7..8cb9e711d 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/device-data/device-data.ts @@ -2,15 +2,14 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerData, TrackerDataT } from '../../../solarxr-protocol/data-feed/tracker/tracker-data.js'; -import { DeviceId, DeviceIdT } from '../../../solarxr-protocol/datatypes/device-id.js'; +import { TrackerData, TrackerDataT } from '../../../solarxr-protocol/data-feed/tracker-data/tracker-data.js'; import { HardwareInfo, HardwareInfoT } from '../../../solarxr-protocol/datatypes/hardware-info/hardware-info.js'; import { HardwareStatus, HardwareStatusT } from '../../../solarxr-protocol/datatypes/hardware-info/hardware-status.js'; /** * Describes all possible information about a hardware device. For example, a - * vive tracker is a single hardware device, and a slime tracker with two + * vive tracker is a single hardware device, and a slime tracker with two * extensions is a single hardware device but two trackers. */ export class DeviceData implements flatbuffers.IUnpackableObject { @@ -31,9 +30,9 @@ static getSizePrefixedRootAsDeviceData(bb:flatbuffers.ByteBuffer, obj?:DeviceDat return (obj || new DeviceData()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -id(obj?:DeviceId):DeviceId|null { +id():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new DeviceId()).__init(this.bb_pos + offset, this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } /** @@ -80,8 +79,8 @@ static startDeviceData(builder:flatbuffers.Builder) { builder.startObject(5); } -static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) { - builder.addFieldStruct(0, idOffset, 0); +static addId(builder:flatbuffers.Builder, id:number) { + builder.addFieldInt16(0, id, 0); } static addCustomName(builder:flatbuffers.Builder, customNameOffset:flatbuffers.Offset) { @@ -120,7 +119,7 @@ static endDeviceData(builder:flatbuffers.Builder):flatbuffers.Offset { unpack(): DeviceDataT { return new DeviceDataT( - (this.id() !== null ? this.id()!.unpack() : null), + this.id(), this.customName(), (this.hardwareInfo() !== null ? this.hardwareInfo()!.unpack() : null), (this.hardwareStatus() !== null ? this.hardwareStatus()!.unpack() : null), @@ -130,7 +129,7 @@ unpack(): DeviceDataT { unpackTo(_o: DeviceDataT): void { - _o.id = (this.id() !== null ? this.id()!.unpack() : null); + _o.id = this.id(); _o.customName = this.customName(); _o.hardwareInfo = (this.hardwareInfo() !== null ? this.hardwareInfo()!.unpack() : null); _o.hardwareStatus = (this.hardwareStatus() !== null ? this.hardwareStatus()!.unpack() : null); @@ -140,7 +139,7 @@ unpackTo(_o: DeviceDataT): void { export class DeviceDataT implements flatbuffers.IGeneratedObject { constructor( - public id: DeviceIdT|null = null, + public id: number = 0, public customName: string|Uint8Array|null = null, public hardwareInfo: HardwareInfoT|null = null, public hardwareStatus: HardwareStatusT|null = null, @@ -155,7 +154,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { const trackers = DeviceData.createTrackersVector(builder, builder.createObjectOffsetList(this.trackers)); DeviceData.startDeviceData(builder); - DeviceData.addId(builder, (this.id !== null ? this.id!.pack(builder) : 0)); + DeviceData.addId(builder, this.id); DeviceData.addCustomName(builder, customName); DeviceData.addHardwareInfo(builder, hardwareInfo); DeviceData.addHardwareStatus(builder, hardwareStatus); diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts b/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts index e02414571..83e2bd311 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts @@ -4,6 +4,12 @@ import * as flatbuffers from 'flatbuffers'; +/** + * Contains various of flags / guards that inform the GUI + * about possible actions or blocked states. + * The idea is to have one source of truth for all these rules + * that are spread accross the GUI. + */ export class ServerGuards implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; @@ -22,7 +28,7 @@ static getSizePrefixedRootAsServerGuards(bb:flatbuffers.ByteBuffer, obj?:ServerG return (obj || new ServerGuards()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -canDoMounting():boolean { +canDoMountingReset():boolean { const offset = this.bb!.__offset(this.bb_pos, 4); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } @@ -41,8 +47,8 @@ static startServerGuards(builder:flatbuffers.Builder) { builder.startObject(3); } -static addCanDoMounting(builder:flatbuffers.Builder, canDoMounting:boolean) { - builder.addFieldInt8(0, +canDoMounting, +false); +static addCanDoMountingReset(builder:flatbuffers.Builder, canDoMountingReset:boolean) { + builder.addFieldInt8(0, +canDoMountingReset, +false); } static addCanDoYawReset(builder:flatbuffers.Builder, canDoYawReset:boolean) { @@ -58,9 +64,9 @@ static endServerGuards(builder:flatbuffers.Builder):flatbuffers.Offset { return offset; } -static createServerGuards(builder:flatbuffers.Builder, canDoMounting:boolean, canDoYawReset:boolean, canDoUserHeightCalibration:boolean):flatbuffers.Offset { +static createServerGuards(builder:flatbuffers.Builder, canDoMountingReset:boolean, canDoYawReset:boolean, canDoUserHeightCalibration:boolean):flatbuffers.Offset { ServerGuards.startServerGuards(builder); - ServerGuards.addCanDoMounting(builder, canDoMounting); + ServerGuards.addCanDoMountingReset(builder, canDoMountingReset); ServerGuards.addCanDoYawReset(builder, canDoYawReset); ServerGuards.addCanDoUserHeightCalibration(builder, canDoUserHeightCalibration); return ServerGuards.endServerGuards(builder); @@ -68,7 +74,7 @@ static createServerGuards(builder:flatbuffers.Builder, canDoMounting:boolean, ca unpack(): ServerGuardsT { return new ServerGuardsT( - this.canDoMounting(), + this.canDoMountingReset(), this.canDoYawReset(), this.canDoUserHeightCalibration() ); @@ -76,7 +82,7 @@ unpack(): ServerGuardsT { unpackTo(_o: ServerGuardsT): void { - _o.canDoMounting = this.canDoMounting(); + _o.canDoMountingReset = this.canDoMountingReset(); _o.canDoYawReset = this.canDoYawReset(); _o.canDoUserHeightCalibration = this.canDoUserHeightCalibration(); } @@ -84,7 +90,7 @@ unpackTo(_o: ServerGuardsT): void { export class ServerGuardsT implements flatbuffers.IGeneratedObject { constructor( - public canDoMounting: boolean = false, + public canDoMountingReset: boolean = false, public canDoYawReset: boolean = false, public canDoUserHeightCalibration: boolean = false ){} @@ -92,7 +98,7 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { return ServerGuards.createServerGuards(builder, - this.canDoMounting, + this.canDoMountingReset, this.canDoYawReset, this.canDoUserHeightCalibration ); diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-data-mask.ts b/protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-data-mask.ts similarity index 100% rename from protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-data-mask.ts rename to protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-data-mask.ts diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-data.ts b/protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-data.ts similarity index 87% rename from protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-data.ts rename to protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-data.ts index 41de3014f..5971b18a8 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-data.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-data.ts @@ -3,9 +3,8 @@ import * as flatbuffers from 'flatbuffers'; import { StayAlignedTracker, StayAlignedTrackerT } from '../../../solarxr-protocol/data-feed/stay-aligned/stay-aligned-tracker.js'; -import { TrackerInfo, TrackerInfoT } from '../../../solarxr-protocol/data-feed/tracker/tracker-info.js'; +import { TrackerInfo, TrackerInfoT } from '../../../solarxr-protocol/data-feed/tracker-data/tracker-info.js'; import { Temperature, TemperatureT } from '../../../solarxr-protocol/datatypes/temperature.js'; -import { TrackerId, TrackerIdT } from '../../../solarxr-protocol/datatypes/tracker-id.js'; import { TrackerStatus } from '../../../solarxr-protocol/datatypes/tracker-status.js'; import { Quat, QuatT } from '../../../solarxr-protocol/datatypes/math/quat.js'; import { Vec3f, Vec3fT } from '../../../solarxr-protocol/datatypes/math/vec3f.js'; @@ -36,18 +35,23 @@ static getSizePrefixedRootAsTrackerData(bb:flatbuffers.ByteBuffer, obj?:TrackerD return (obj || new TrackerData()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +deviceId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } -info(obj?:TrackerInfo):TrackerInfo|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +info(obj?:TrackerInfo):TrackerInfo|null { + const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? (obj || new TrackerInfo()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } status():TrackerStatus { - const offset = this.bb!.__offset(this.bb_pos, 8); + const offset = this.bb!.__offset(this.bb_pos, 10); return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackerStatus.NONE; } @@ -55,15 +59,15 @@ status():TrackerStatus { * Sensor rotation after fusion */ rotation(obj?:Quat):Quat|null { - const offset = this.bb!.__offset(this.bb_pos, 10); + const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; } /** - * Position, in meters + * Position in meters in OpenVR's space (left-handed, X+ Right, Y+ Up, Z- Forward) */ position(obj?:Vec3f):Vec3f|null { - const offset = this.bb!.__offset(this.bb_pos, 12); + const offset = this.bb!.__offset(this.bb_pos, 14); return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -71,7 +75,7 @@ position(obj?:Vec3f):Vec3f|null { * Raw angular velocity, in euler angles, rad/s */ rawAngularVelocity(obj?:Vec3f):Vec3f|null { - const offset = this.bb!.__offset(this.bb_pos, 14); + const offset = this.bb!.__offset(this.bb_pos, 16); return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -79,7 +83,7 @@ rawAngularVelocity(obj?:Vec3f):Vec3f|null { * Raw acceleration, in m/s^2 */ rawAcceleration(obj?:Vec3f):Vec3f|null { - const offset = this.bb!.__offset(this.bb_pos, 16); + const offset = this.bb!.__offset(this.bb_pos, 18); return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -87,7 +91,7 @@ rawAcceleration(obj?:Vec3f):Vec3f|null { * Temperature, in degrees celsius */ temp(obj?:Temperature):Temperature|null { - const offset = this.bb!.__offset(this.bb_pos, 18); + const offset = this.bb!.__offset(this.bb_pos, 20); return offset ? (obj || new Temperature()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -95,33 +99,33 @@ temp(obj?:Temperature):Temperature|null { * Acceleration without gravity, in m/s^2 */ linearAcceleration(obj?:Vec3f):Vec3f|null { - const offset = this.bb!.__offset(this.bb_pos, 20); + const offset = this.bb!.__offset(this.bb_pos, 22); return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; } /** * Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - * In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), + * In other words, a rotation that is aligned to a reliable source of rotation (0, HMD YAW, 0), * triggered after user input (using reset buttons). * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. * Includes: mounting orientation, full, quick and mounting reset adjustments. * This rotation can be used to reconstruct a skeleton pose using forward kinematics. */ rotationReferenceAdjusted(obj?:Quat):Quat|null { - const offset = this.bb!.__offset(this.bb_pos, 22); + const offset = this.bb!.__offset(this.bb_pos, 24); return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; } /** * Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - * In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by + * In other words, a rotation that is aligned to a zero vector (0, 0, 0) by * inverting the current rotation, triggered after user input (using reset buttons). * This is a SlimeVR-specific field and computed exclusively by SlimeVR server. * Includes: only full and quick reset adjustments. * This rotation can be used in visualizations for IMU debugging. */ rotationIdentityAdjusted(obj?:Quat):Quat|null { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 26); return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -129,7 +133,7 @@ rotationIdentityAdjusted(obj?:Quat):Quat|null { * Data ticks per second, processed by SlimeVR server */ tps():number|null { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 28); return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; } @@ -137,7 +141,7 @@ tps():number|null { * Magnetic field vector, in mGauss */ rawMagneticVector(obj?:Vec3f):Vec3f|null { - const offset = this.bb!.__offset(this.bb_pos, 28); + const offset = this.bb!.__offset(this.bb_pos, 30); return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; } @@ -145,68 +149,72 @@ rawMagneticVector(obj?:Vec3f):Vec3f|null { * Stay Aligned */ stayAligned(obj?:StayAlignedTracker):StayAlignedTracker|null { - const offset = this.bb!.__offset(this.bb_pos, 30); + const offset = this.bb!.__offset(this.bb_pos, 32); return offset ? (obj || new StayAlignedTracker()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } static startTrackerData(builder:flatbuffers.Builder) { - builder.startObject(14); + builder.startObject(15); +} + +static addDeviceId(builder:flatbuffers.Builder, deviceId:number) { + builder.addFieldInt16(0, deviceId, 0); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(1, trackerId, 0); } static addInfo(builder:flatbuffers.Builder, infoOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, infoOffset, 0); + builder.addFieldOffset(2, infoOffset, 0); } static addStatus(builder:flatbuffers.Builder, status:TrackerStatus) { - builder.addFieldInt8(2, status, TrackerStatus.NONE); + builder.addFieldInt8(3, status, TrackerStatus.NONE); } static addRotation(builder:flatbuffers.Builder, rotationOffset:flatbuffers.Offset) { - builder.addFieldStruct(3, rotationOffset, 0); + builder.addFieldStruct(4, rotationOffset, 0); } static addPosition(builder:flatbuffers.Builder, positionOffset:flatbuffers.Offset) { - builder.addFieldStruct(4, positionOffset, 0); + builder.addFieldStruct(5, positionOffset, 0); } static addRawAngularVelocity(builder:flatbuffers.Builder, rawAngularVelocityOffset:flatbuffers.Offset) { - builder.addFieldStruct(5, rawAngularVelocityOffset, 0); + builder.addFieldStruct(6, rawAngularVelocityOffset, 0); } static addRawAcceleration(builder:flatbuffers.Builder, rawAccelerationOffset:flatbuffers.Offset) { - builder.addFieldStruct(6, rawAccelerationOffset, 0); + builder.addFieldStruct(7, rawAccelerationOffset, 0); } static addTemp(builder:flatbuffers.Builder, tempOffset:flatbuffers.Offset) { - builder.addFieldStruct(7, tempOffset, 0); + builder.addFieldStruct(8, tempOffset, 0); } static addLinearAcceleration(builder:flatbuffers.Builder, linearAccelerationOffset:flatbuffers.Offset) { - builder.addFieldStruct(8, linearAccelerationOffset, 0); + builder.addFieldStruct(9, linearAccelerationOffset, 0); } static addRotationReferenceAdjusted(builder:flatbuffers.Builder, rotationReferenceAdjustedOffset:flatbuffers.Offset) { - builder.addFieldStruct(9, rotationReferenceAdjustedOffset, 0); + builder.addFieldStruct(10, rotationReferenceAdjustedOffset, 0); } static addRotationIdentityAdjusted(builder:flatbuffers.Builder, rotationIdentityAdjustedOffset:flatbuffers.Offset) { - builder.addFieldStruct(10, rotationIdentityAdjustedOffset, 0); + builder.addFieldStruct(11, rotationIdentityAdjustedOffset, 0); } static addTps(builder:flatbuffers.Builder, tps:number) { - builder.addFieldInt16(11, tps, 0); + builder.addFieldInt16(12, tps, 0); } static addRawMagneticVector(builder:flatbuffers.Builder, rawMagneticVectorOffset:flatbuffers.Offset) { - builder.addFieldStruct(12, rawMagneticVectorOffset, 0); + builder.addFieldStruct(13, rawMagneticVectorOffset, 0); } static addStayAligned(builder:flatbuffers.Builder, stayAlignedOffset:flatbuffers.Offset) { - builder.addFieldOffset(13, stayAlignedOffset, 0); + builder.addFieldOffset(14, stayAlignedOffset, 0); } static endTrackerData(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -217,7 +225,8 @@ static endTrackerData(builder:flatbuffers.Builder):flatbuffers.Offset { unpack(): TrackerDataT { return new TrackerDataT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.deviceId(), + this.trackerId(), (this.info() !== null ? this.info()!.unpack() : null), this.status(), (this.rotation() !== null ? this.rotation()!.unpack() : null), @@ -236,7 +245,8 @@ unpack(): TrackerDataT { unpackTo(_o: TrackerDataT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.deviceId = this.deviceId(); + _o.trackerId = this.trackerId(); _o.info = (this.info() !== null ? this.info()!.unpack() : null); _o.status = this.status(); _o.rotation = (this.rotation() !== null ? this.rotation()!.unpack() : null); @@ -255,7 +265,8 @@ unpackTo(_o: TrackerDataT): void { export class TrackerDataT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null, + public deviceId: number = 0, + public trackerId: number = 0, public info: TrackerInfoT|null = null, public status: TrackerStatus = TrackerStatus.NONE, public rotation: QuatT|null = null, @@ -273,12 +284,12 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); const info = (this.info !== null ? this.info!.pack(builder) : 0); const stayAligned = (this.stayAligned !== null ? this.stayAligned!.pack(builder) : 0); TrackerData.startTrackerData(builder); - TrackerData.addTrackerId(builder, trackerId); + TrackerData.addDeviceId(builder, this.deviceId); + TrackerData.addTrackerId(builder, this.trackerId); TrackerData.addInfo(builder, info); TrackerData.addStatus(builder, this.status); TrackerData.addRotation(builder, (this.rotation !== null ? this.rotation!.pack(builder) : 0)); diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts b/protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-info.ts similarity index 88% rename from protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts rename to protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-info.ts index 29c386aac..442fe8cce 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/tracker/tracker-info.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/tracker-data/tracker-info.ts @@ -33,7 +33,7 @@ static getSizePrefixedRootAsTrackerInfo(bb:flatbuffers.ByteBuffer, obj?:TrackerI imuType():ImuType { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : ImuType.Other; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : ImuType.UNKNOWN; } /** @@ -45,7 +45,7 @@ bodyPart():BodyPart { } /** - * average samples per second + * Average samples per second */ pollRate(obj?:HzF32):HzF32|null { const offset = this.bb!.__offset(this.bb_pos, 8); @@ -104,51 +104,43 @@ customName(optionalEncoding?:any):string|Uint8Array|null { return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; } -/** - * Whether to allow yaw drift compensation for this tracker or not. - */ -allowDriftCompensation():boolean { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - /** * Mounting Reset orientation overrides the current `mounting_orientation` of * the tracker, this orientation is not saved and needs to be calculated * each time the server is ran */ mountingResetOrientation(obj?:Quat):Quat|null { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 22); return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; } /** - * Indicates if the tracker is actually an HMD + * Indicates if the tracker is actually a VR headset */ isHmd():boolean { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 24); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } magnetometer():MagnetometerStatus { - const offset = this.bb!.__offset(this.bb_pos, 28); + const offset = this.bb!.__offset(this.bb_pos, 26); return offset ? this.bb!.readUint8(this.bb_pos + offset) : MagnetometerStatus.NOT_SUPPORTED; } /** - * Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) + * Indicates what type of data the tracker sends (that gets transformed into a rotation) */ dataSupport():TrackerDataType { - const offset = this.bb!.__offset(this.bb_pos, 30); + const offset = this.bb!.__offset(this.bb_pos, 28); return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackerDataType.ROTATION; } static startTrackerInfo(builder:flatbuffers.Builder) { - builder.startObject(14); + builder.startObject(13); } static addImuType(builder:flatbuffers.Builder, imuType:ImuType) { - builder.addFieldInt16(0, imuType, ImuType.Other); + builder.addFieldInt16(0, imuType, ImuType.UNKNOWN); } static addBodyPart(builder:flatbuffers.Builder, bodyPart:BodyPart) { @@ -183,24 +175,20 @@ static addCustomName(builder:flatbuffers.Builder, customNameOffset:flatbuffers.O builder.addFieldOffset(8, customNameOffset, 0); } -static addAllowDriftCompensation(builder:flatbuffers.Builder, allowDriftCompensation:boolean) { - builder.addFieldInt8(9, +allowDriftCompensation, +false); -} - static addMountingResetOrientation(builder:flatbuffers.Builder, mountingResetOrientationOffset:flatbuffers.Offset) { - builder.addFieldStruct(10, mountingResetOrientationOffset, 0); + builder.addFieldStruct(9, mountingResetOrientationOffset, 0); } static addIsHmd(builder:flatbuffers.Builder, isHmd:boolean) { - builder.addFieldInt8(11, +isHmd, +false); + builder.addFieldInt8(10, +isHmd, +false); } static addMagnetometer(builder:flatbuffers.Builder, magnetometer:MagnetometerStatus) { - builder.addFieldInt8(12, magnetometer, MagnetometerStatus.NOT_SUPPORTED); + builder.addFieldInt8(11, magnetometer, MagnetometerStatus.NOT_SUPPORTED); } static addDataSupport(builder:flatbuffers.Builder, dataSupport:TrackerDataType) { - builder.addFieldInt8(13, dataSupport, TrackerDataType.ROTATION); + builder.addFieldInt8(12, dataSupport, TrackerDataType.ROTATION); } static endTrackerInfo(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -220,7 +208,6 @@ unpack(): TrackerInfoT { this.isImu(), this.displayName(), this.customName(), - this.allowDriftCompensation(), (this.mountingResetOrientation() !== null ? this.mountingResetOrientation()!.unpack() : null), this.isHmd(), this.magnetometer(), @@ -239,7 +226,6 @@ unpackTo(_o: TrackerInfoT): void { _o.isImu = this.isImu(); _o.displayName = this.displayName(); _o.customName = this.customName(); - _o.allowDriftCompensation = this.allowDriftCompensation(); _o.mountingResetOrientation = (this.mountingResetOrientation() !== null ? this.mountingResetOrientation()!.unpack() : null); _o.isHmd = this.isHmd(); _o.magnetometer = this.magnetometer(); @@ -249,7 +235,7 @@ unpackTo(_o: TrackerInfoT): void { export class TrackerInfoT implements flatbuffers.IGeneratedObject { constructor( - public imuType: ImuType = ImuType.Other, + public imuType: ImuType = ImuType.UNKNOWN, public bodyPart: BodyPart = BodyPart.NONE, public pollRate: HzF32T|null = null, public mountingOrientation: QuatT|null = null, @@ -258,7 +244,6 @@ constructor( public isImu: boolean = false, public displayName: string|Uint8Array|null = null, public customName: string|Uint8Array|null = null, - public allowDriftCompensation: boolean = false, public mountingResetOrientation: QuatT|null = null, public isHmd: boolean = false, public magnetometer: MagnetometerStatus = MagnetometerStatus.NOT_SUPPORTED, @@ -280,7 +265,6 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { TrackerInfo.addIsImu(builder, this.isImu); TrackerInfo.addDisplayName(builder, displayName); TrackerInfo.addCustomName(builder, customName); - TrackerInfo.addAllowDriftCompensation(builder, this.allowDriftCompensation); TrackerInfo.addMountingResetOrientation(builder, (this.mountingResetOrientation !== null ? this.mountingResetOrientation!.pack(builder) : 0)); TrackerInfo.addIsHmd(builder, this.isHmd); TrackerInfo.addMagnetometer(builder, this.magnetometer); diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/bytes.ts b/protocol/typescript/src/solarxr-protocol/datatypes/bytes.ts deleted file mode 100644 index 0e6eb9395..000000000 --- a/protocol/typescript/src/solarxr-protocol/datatypes/bytes.ts +++ /dev/null @@ -1,96 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class Bytes implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):Bytes { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsBytes(bb:flatbuffers.ByteBuffer, obj?:Bytes):Bytes { - return (obj || new Bytes()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsBytes(bb:flatbuffers.ByteBuffer, obj?:Bytes):Bytes { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new Bytes()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -b(index: number):number|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; -} - -bLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -bArray():Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; -} - -static startBytes(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addB(builder:flatbuffers.Builder, bOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, bOffset, 0); -} - -static createBVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { - builder.startVector(1, data.length, 1); - for (let i = data.length - 1; i >= 0; i--) { - builder.addInt8(data[i]!); - } - return builder.endVector(); -} - -static startBVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(1, numElems, 1); -} - -static endBytes(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createBytes(builder:flatbuffers.Builder, bOffset:flatbuffers.Offset):flatbuffers.Offset { - Bytes.startBytes(builder); - Bytes.addB(builder, bOffset); - return Bytes.endBytes(builder); -} - -unpack(): BytesT { - return new BytesT( - this.bb!.createScalarList(this.b.bind(this), this.bLength()) - ); -} - - -unpackTo(_o: BytesT): void { - _o.b = this.bb!.createScalarList(this.b.bind(this), this.bLength()); -} -} - -export class BytesT implements flatbuffers.IGeneratedObject { -constructor( - public b: (number)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const b = Bytes.createBVector(builder, this.b); - - return Bytes.createBytes(builder, - b - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/device-id-table.ts b/protocol/typescript/src/solarxr-protocol/datatypes/device-id-table.ts deleted file mode 100644 index e036d3b04..000000000 --- a/protocol/typescript/src/solarxr-protocol/datatypes/device-id-table.ts +++ /dev/null @@ -1,76 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { DeviceId, DeviceIdT } from '../../solarxr-protocol/datatypes/device-id.js'; - - -/** - * To be used inside unions - */ -export class DeviceIdTable implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):DeviceIdTable { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsDeviceIdTable(bb:flatbuffers.ByteBuffer, obj?:DeviceIdTable):DeviceIdTable { - return (obj || new DeviceIdTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsDeviceIdTable(bb:flatbuffers.ByteBuffer, obj?:DeviceIdTable):DeviceIdTable { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new DeviceIdTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -id(obj?:DeviceId):DeviceId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new DeviceId()).__init(this.bb_pos + offset, this.bb!) : null; -} - -static startDeviceIdTable(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) { - builder.addFieldStruct(0, idOffset, 0); -} - -static endDeviceIdTable(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createDeviceIdTable(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset):flatbuffers.Offset { - DeviceIdTable.startDeviceIdTable(builder); - DeviceIdTable.addId(builder, idOffset); - return DeviceIdTable.endDeviceIdTable(builder); -} - -unpack(): DeviceIdTableT { - return new DeviceIdTableT( - (this.id() !== null ? this.id()!.unpack() : null) - ); -} - - -unpackTo(_o: DeviceIdTableT): void { - _o.id = (this.id() !== null ? this.id()!.unpack() : null); -} -} - -export class DeviceIdTableT implements flatbuffers.IGeneratedObject { -constructor( - public id: DeviceIdT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return DeviceIdTable.createDeviceIdTable(builder, - (this.id !== null ? this.id!.pack(builder) : 0) - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/device-id.ts b/protocol/typescript/src/solarxr-protocol/datatypes/device-id.ts deleted file mode 100644 index f39f2cbe1..000000000 --- a/protocol/typescript/src/solarxr-protocol/datatypes/device-id.ts +++ /dev/null @@ -1,58 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * A unique ID for the device. IDs are not guaranteed to be the same after - * the connection is terminated. - */ -export class DeviceId implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):DeviceId { - this.bb_pos = i; - this.bb = bb; - return this; -} - -id():number { - return this.bb!.readUint8(this.bb_pos); -} - -static sizeOf():number { - return 1; -} - -static createDeviceId(builder:flatbuffers.Builder, id: number):flatbuffers.Offset { - builder.prep(1, 1); - builder.writeInt8(id); - return builder.offset(); -} - - -unpack(): DeviceIdT { - return new DeviceIdT( - this.id() - ); -} - - -unpackTo(_o: DeviceIdT): void { - _o.id = this.id(); -} -} - -export class DeviceIdT implements flatbuffers.IGeneratedObject { -constructor( - public id: number = 0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return DeviceId.createDeviceId(builder, - this.id - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-info.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-info.ts index 200268598..7db7aeb7e 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-info.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-info.ts @@ -31,7 +31,7 @@ static getSizePrefixedRootAsHardwareInfo(bb:flatbuffers.ByteBuffer, obj?:Hardwar mcuId():McuType { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : McuType.Other; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : McuType.UNKNOWN; } /** @@ -146,7 +146,7 @@ static startHardwareInfo(builder:flatbuffers.Builder) { } static addMcuId(builder:flatbuffers.Builder, mcuId:McuType) { - builder.addFieldInt16(0, mcuId, McuType.Other); + builder.addFieldInt16(0, mcuId, McuType.UNKNOWN); } static addDisplayName(builder:flatbuffers.Builder, displayNameOffset:flatbuffers.Offset) { @@ -241,7 +241,7 @@ unpackTo(_o: HardwareInfoT): void { export class HardwareInfoT implements flatbuffers.IGeneratedObject { constructor( - public mcuId: McuType = McuType.Other, + public mcuId: McuType = McuType.UNKNOWN, public displayName: string|Uint8Array|null = null, public model: string|Uint8Array|null = null, public manufacturer: string|Uint8Array|null = null, diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts index 42083136a..7bf6afd23 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/hardware-status.ts @@ -33,7 +33,7 @@ errorStatus():FirmwareErrorCode|null { } ping():number|null { - const offset = this.bb!.__offset(this.bb_pos, 8); + const offset = this.bb!.__offset(this.bb_pos, 6); return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; } @@ -41,7 +41,7 @@ ping():number|null { * "Received Signal Strength Indicator" between device and wifi adapter in dBm */ rssi():number|null { - const offset = this.bb!.__offset(this.bb_pos, 10); + const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? this.bb!.readInt16(this.bb_pos + offset) : null; } @@ -49,37 +49,37 @@ rssi():number|null { * Temperature in degrees celsius */ mcuTemp():number|null { - const offset = this.bb!.__offset(this.bb_pos, 12); + const offset = this.bb!.__offset(this.bb_pos, 10); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; } batteryVoltage():number|null { - const offset = this.bb!.__offset(this.bb_pos, 14); + const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; } batteryPctEstimate():number|null { - const offset = this.bb!.__offset(this.bb_pos, 16); + const offset = this.bb!.__offset(this.bb_pos, 14); return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } logData(obj?:LogData):LogData|null { - const offset = this.bb!.__offset(this.bb_pos, 18); + const offset = this.bb!.__offset(this.bb_pos, 16); return offset ? (obj || new LogData()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } packetLoss():number|null { - const offset = this.bb!.__offset(this.bb_pos, 20); + const offset = this.bb!.__offset(this.bb_pos, 18); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; } packetsLost():number|null { - const offset = this.bb!.__offset(this.bb_pos, 22); + const offset = this.bb!.__offset(this.bb_pos, 20); return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; } packetsReceived():number|null { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 22); return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; } @@ -87,12 +87,12 @@ packetsReceived():number|null { * Runtime estimate in microseconds */ batteryRuntimeEstimate():bigint|null { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 24); return offset ? this.bb!.readInt64(this.bb_pos + offset) : null; } static startHardwareStatus(builder:flatbuffers.Builder) { - builder.startObject(12); + builder.startObject(11); } static addErrorStatus(builder:flatbuffers.Builder, errorStatus:FirmwareErrorCode) { @@ -100,43 +100,43 @@ static addErrorStatus(builder:flatbuffers.Builder, errorStatus:FirmwareErrorCode } static addPing(builder:flatbuffers.Builder, ping:number) { - builder.addFieldInt16(2, ping, 0); + builder.addFieldInt16(1, ping, 0); } static addRssi(builder:flatbuffers.Builder, rssi:number) { - builder.addFieldInt16(3, rssi, 0); + builder.addFieldInt16(2, rssi, 0); } static addMcuTemp(builder:flatbuffers.Builder, mcuTemp:number) { - builder.addFieldFloat32(4, mcuTemp, 0); + builder.addFieldFloat32(3, mcuTemp, 0); } static addBatteryVoltage(builder:flatbuffers.Builder, batteryVoltage:number) { - builder.addFieldFloat32(5, batteryVoltage, 0); + builder.addFieldFloat32(4, batteryVoltage, 0); } static addBatteryPctEstimate(builder:flatbuffers.Builder, batteryPctEstimate:number) { - builder.addFieldInt8(6, batteryPctEstimate, 0); + builder.addFieldInt8(5, batteryPctEstimate, 0); } static addLogData(builder:flatbuffers.Builder, logDataOffset:flatbuffers.Offset) { - builder.addFieldOffset(7, logDataOffset, 0); + builder.addFieldOffset(6, logDataOffset, 0); } static addPacketLoss(builder:flatbuffers.Builder, packetLoss:number) { - builder.addFieldFloat32(8, packetLoss, 0); + builder.addFieldFloat32(7, packetLoss, 0); } static addPacketsLost(builder:flatbuffers.Builder, packetsLost:number) { - builder.addFieldInt32(9, packetsLost, 0); + builder.addFieldInt32(8, packetsLost, 0); } static addPacketsReceived(builder:flatbuffers.Builder, packetsReceived:number) { - builder.addFieldInt32(10, packetsReceived, 0); + builder.addFieldInt32(9, packetsReceived, 0); } static addBatteryRuntimeEstimate(builder:flatbuffers.Builder, batteryRuntimeEstimate:bigint) { - builder.addFieldInt64(11, batteryRuntimeEstimate, BigInt(0)); + builder.addFieldInt64(10, batteryRuntimeEstimate, BigInt(0)); } static endHardwareStatus(builder:flatbuffers.Builder):flatbuffers.Offset { diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/imu-type.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/imu-type.ts index e4e7cd669..d1ee7c273 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/imu-type.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/imu-type.ts @@ -1,7 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify export enum ImuType { - Other = 0, + UNKNOWN = 0, MPU9250 = 1, MPU6500 = 2, BNO080 = 3, diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/mcu-type.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/mcu-type.ts index f7c544aea..f78776aae 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/mcu-type.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/mcu-type.ts @@ -1,7 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify export enum McuType { - Other = 0, + UNKNOWN = 0, ESP8266 = 1, ESP32 = 2, OWOTRACK_ANDROID = 3, diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/tracker-data-type.ts b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/tracker-data-type.ts index 7bf934add..78613559d 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/tracker-data-type.ts +++ b/protocol/typescript/src/solarxr-protocol/datatypes/hardware-info/tracker-data-type.ts @@ -1,7 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify /** - * What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. + * What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. */ export enum TrackerDataType { /** diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/string-table.ts b/protocol/typescript/src/solarxr-protocol/datatypes/string-table.ts deleted file mode 100644 index e6548a07b..000000000 --- a/protocol/typescript/src/solarxr-protocol/datatypes/string-table.ts +++ /dev/null @@ -1,76 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class StringTable implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StringTable { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStringTable(bb:flatbuffers.ByteBuffer, obj?:StringTable):StringTable { - return (obj || new StringTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStringTable(bb:flatbuffers.ByteBuffer, obj?:StringTable):StringTable { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StringTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -s():string|null -s(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -s(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startStringTable(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addS(builder:flatbuffers.Builder, sOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, sOffset, 0); -} - -static endStringTable(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStringTable(builder:flatbuffers.Builder, sOffset:flatbuffers.Offset):flatbuffers.Offset { - StringTable.startStringTable(builder); - StringTable.addS(builder, sOffset); - return StringTable.endStringTable(builder); -} - -unpack(): StringTableT { - return new StringTableT( - this.s() - ); -} - - -unpackTo(_o: StringTableT): void { - _o.s = this.s(); -} -} - -export class StringTableT implements flatbuffers.IGeneratedObject { -constructor( - public s: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const s = (this.s !== null ? builder.createString(this.s!) : 0); - - return StringTable.createStringTable(builder, - s - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/tracker-id.ts b/protocol/typescript/src/solarxr-protocol/datatypes/tracker-id.ts deleted file mode 100644 index c662e32da..000000000 --- a/protocol/typescript/src/solarxr-protocol/datatypes/tracker-id.ts +++ /dev/null @@ -1,94 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { DeviceId, DeviceIdT } from '../../solarxr-protocol/datatypes/device-id.js'; - - -export class TrackerId implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TrackerId { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTrackerId(bb:flatbuffers.ByteBuffer, obj?:TrackerId):TrackerId { - return (obj || new TrackerId()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTrackerId(bb:flatbuffers.ByteBuffer, obj?:TrackerId):TrackerId { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TrackerId()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -/** - * The device the tracker is associated with. If there is no hardware device it is - * associated with, this should be `null`. - */ -deviceId(obj?:DeviceId):DeviceId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new DeviceId()).__init(this.bb_pos + offset, this.bb!) : null; -} - -/** - * There are possibly multiple trackers per device. This identifies which one. - */ -trackerNum():number { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; -} - -static startTrackerId(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addDeviceId(builder:flatbuffers.Builder, deviceIdOffset:flatbuffers.Offset) { - builder.addFieldStruct(0, deviceIdOffset, 0); -} - -static addTrackerNum(builder:flatbuffers.Builder, trackerNum:number) { - builder.addFieldInt8(1, trackerNum, 0); -} - -static endTrackerId(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createTrackerId(builder:flatbuffers.Builder, deviceIdOffset:flatbuffers.Offset, trackerNum:number):flatbuffers.Offset { - TrackerId.startTrackerId(builder); - TrackerId.addDeviceId(builder, deviceIdOffset); - TrackerId.addTrackerNum(builder, trackerNum); - return TrackerId.endTrackerId(builder); -} - -unpack(): TrackerIdT { - return new TrackerIdT( - (this.deviceId() !== null ? this.deviceId()!.unpack() : null), - this.trackerNum() - ); -} - - -unpackTo(_o: TrackerIdT): void { - _o.deviceId = (this.deviceId() !== null ? this.deviceId()!.unpack() : null); - _o.trackerNum = this.trackerNum(); -} -} - -export class TrackerIdT implements flatbuffers.IGeneratedObject { -constructor( - public deviceId: DeviceIdT|null = null, - public trackerNum: number = 0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return TrackerId.createTrackerId(builder, - (this.deviceId !== null ? this.deviceId!.pack(builder) : 0), - this.trackerNum - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/message-bundle.ts b/protocol/typescript/src/solarxr-protocol/message-bundle.ts index 3eb8c51c1..a110ff965 100644 --- a/protocol/typescript/src/solarxr-protocol/message-bundle.ts +++ b/protocol/typescript/src/solarxr-protocol/message-bundle.ts @@ -3,7 +3,6 @@ import * as flatbuffers from 'flatbuffers'; import { DataFeedMessageHeader, DataFeedMessageHeaderT } from '../solarxr-protocol/data-feed/data-feed-message-header.js'; -import { PubSubHeader, PubSubHeaderT } from '../solarxr-protocol/pub-sub/pub-sub-header.js'; import { RpcMessageHeader, RpcMessageHeaderT } from '../solarxr-protocol/rpc/rpc-message-header.js'; @@ -49,18 +48,8 @@ rpcMsgsLength():number { return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } -pubSubMsgs(index: number, obj?:PubSubHeader):PubSubHeader|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new PubSubHeader()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; -} - -pubSubMsgsLength():number { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - static startMessageBundle(builder:flatbuffers.Builder) { - builder.startObject(3); + builder.startObject(2); } static addDataFeedMsgs(builder:flatbuffers.Builder, dataFeedMsgsOffset:flatbuffers.Offset) { @@ -95,40 +84,22 @@ static startRpcMsgsVector(builder:flatbuffers.Builder, numElems:number) { builder.startVector(4, numElems, 4); } -static addPubSubMsgs(builder:flatbuffers.Builder, pubSubMsgsOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, pubSubMsgsOffset, 0); -} - -static createPubSubMsgsVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startPubSubMsgsVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - static endMessageBundle(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createMessageBundle(builder:flatbuffers.Builder, dataFeedMsgsOffset:flatbuffers.Offset, rpcMsgsOffset:flatbuffers.Offset, pubSubMsgsOffset:flatbuffers.Offset):flatbuffers.Offset { +static createMessageBundle(builder:flatbuffers.Builder, dataFeedMsgsOffset:flatbuffers.Offset, rpcMsgsOffset:flatbuffers.Offset):flatbuffers.Offset { MessageBundle.startMessageBundle(builder); MessageBundle.addDataFeedMsgs(builder, dataFeedMsgsOffset); MessageBundle.addRpcMsgs(builder, rpcMsgsOffset); - MessageBundle.addPubSubMsgs(builder, pubSubMsgsOffset); return MessageBundle.endMessageBundle(builder); } unpack(): MessageBundleT { return new MessageBundleT( this.bb!.createObjList(this.dataFeedMsgs.bind(this), this.dataFeedMsgsLength()), - this.bb!.createObjList(this.rpcMsgs.bind(this), this.rpcMsgsLength()), - this.bb!.createObjList(this.pubSubMsgs.bind(this), this.pubSubMsgsLength()) + this.bb!.createObjList(this.rpcMsgs.bind(this), this.rpcMsgsLength()) ); } @@ -136,27 +107,23 @@ unpack(): MessageBundleT { unpackTo(_o: MessageBundleT): void { _o.dataFeedMsgs = this.bb!.createObjList(this.dataFeedMsgs.bind(this), this.dataFeedMsgsLength()); _o.rpcMsgs = this.bb!.createObjList(this.rpcMsgs.bind(this), this.rpcMsgsLength()); - _o.pubSubMsgs = this.bb!.createObjList(this.pubSubMsgs.bind(this), this.pubSubMsgsLength()); } } export class MessageBundleT implements flatbuffers.IGeneratedObject { constructor( public dataFeedMsgs: (DataFeedMessageHeaderT)[] = [], - public rpcMsgs: (RpcMessageHeaderT)[] = [], - public pubSubMsgs: (PubSubHeaderT)[] = [] + public rpcMsgs: (RpcMessageHeaderT)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { const dataFeedMsgs = MessageBundle.createDataFeedMsgsVector(builder, builder.createObjectOffsetList(this.dataFeedMsgs)); const rpcMsgs = MessageBundle.createRpcMsgsVector(builder, builder.createObjectOffsetList(this.rpcMsgs)); - const pubSubMsgs = MessageBundle.createPubSubMsgsVector(builder, builder.createObjectOffsetList(this.pubSubMsgs)); return MessageBundle.createMessageBundle(builder, dataFeedMsgs, - rpcMsgs, - pubSubMsgs + rpcMsgs ); } } diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/key-values.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/key-values.ts deleted file mode 100644 index 62457ada1..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/key-values.ts +++ /dev/null @@ -1,127 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class KeyValues implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):KeyValues { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsKeyValues(bb:flatbuffers.ByteBuffer, obj?:KeyValues):KeyValues { - return (obj || new KeyValues()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsKeyValues(bb:flatbuffers.ByteBuffer, obj?:KeyValues):KeyValues { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new KeyValues()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -keys(index: number):string -keys(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array -keys(index: number,optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; -} - -keysLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -values(index: number):string -values(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array -values(index: number,optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; -} - -valuesLength():number { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -static startKeyValues(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addKeys(builder:flatbuffers.Builder, keysOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, keysOffset, 0); -} - -static createKeysVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startKeysVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static addValues(builder:flatbuffers.Builder, valuesOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, valuesOffset, 0); -} - -static createValuesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startValuesVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static endKeyValues(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createKeyValues(builder:flatbuffers.Builder, keysOffset:flatbuffers.Offset, valuesOffset:flatbuffers.Offset):flatbuffers.Offset { - KeyValues.startKeyValues(builder); - KeyValues.addKeys(builder, keysOffset); - KeyValues.addValues(builder, valuesOffset); - return KeyValues.endKeyValues(builder); -} - -unpack(): KeyValuesT { - return new KeyValuesT( - this.bb!.createScalarList(this.keys.bind(this), this.keysLength()), - this.bb!.createScalarList(this.values.bind(this), this.valuesLength()) - ); -} - - -unpackTo(_o: KeyValuesT): void { - _o.keys = this.bb!.createScalarList(this.keys.bind(this), this.keysLength()); - _o.values = this.bb!.createScalarList(this.values.bind(this), this.valuesLength()); -} -} - -export class KeyValuesT implements flatbuffers.IGeneratedObject { -constructor( - public keys: (string)[] = [], - public values: (string)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const keys = KeyValues.createKeysVector(builder, builder.createObjectOffsetList(this.keys)); - const values = KeyValues.createValuesVector(builder, builder.createObjectOffsetList(this.values)); - - return KeyValues.createKeyValues(builder, - keys, - values - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/message.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/message.ts deleted file mode 100644 index 39356746b..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/message.ts +++ /dev/null @@ -1,143 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { Bytes, BytesT } from '../../solarxr-protocol/datatypes/bytes.js'; -import { StringTable, StringTableT } from '../../solarxr-protocol/datatypes/string-table.js'; -import { KeyValues, KeyValuesT } from '../../solarxr-protocol/pub-sub/key-values.js'; -import { Payload, unionToPayload, unionListToPayload } from '../../solarxr-protocol/pub-sub/payload.js'; -import { Topic, unionToTopic, unionListToTopic } from '../../solarxr-protocol/pub-sub/topic.js'; -import { TopicHandle, TopicHandleT } from '../../solarxr-protocol/pub-sub/topic-handle.js'; -import { TopicId, TopicIdT } from '../../solarxr-protocol/pub-sub/topic-id.js'; - - -/** - * Data that is sent from publishers to subscribers - */ -export class Message implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):Message { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsMessage(bb:flatbuffers.ByteBuffer, obj?:Message):Message { - return (obj || new Message()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsMessage(bb:flatbuffers.ByteBuffer, obj?:Message):Message { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new Message()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -topicType():Topic { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : Topic.NONE; -} - -topic(obj:any):any|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; -} - -payloadType():Payload { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : Payload.NONE; -} - -payload(obj:any):any|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; -} - -static startMessage(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addTopicType(builder:flatbuffers.Builder, topicType:Topic) { - builder.addFieldInt8(0, topicType, Topic.NONE); -} - -static addTopic(builder:flatbuffers.Builder, topicOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, topicOffset, 0); -} - -static addPayloadType(builder:flatbuffers.Builder, payloadType:Payload) { - builder.addFieldInt8(2, payloadType, Payload.NONE); -} - -static addPayload(builder:flatbuffers.Builder, payloadOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, payloadOffset, 0); -} - -static endMessage(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createMessage(builder:flatbuffers.Builder, topicType:Topic, topicOffset:flatbuffers.Offset, payloadType:Payload, payloadOffset:flatbuffers.Offset):flatbuffers.Offset { - Message.startMessage(builder); - Message.addTopicType(builder, topicType); - Message.addTopic(builder, topicOffset); - Message.addPayloadType(builder, payloadType); - Message.addPayload(builder, payloadOffset); - return Message.endMessage(builder); -} - -unpack(): MessageT { - return new MessageT( - this.topicType(), - (() => { - const temp = unionToTopic(this.topicType(), this.topic.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(), - this.payloadType(), - (() => { - const temp = unionToPayload(this.payloadType(), this.payload.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })() - ); -} - - -unpackTo(_o: MessageT): void { - _o.topicType = this.topicType(); - _o.topic = (() => { - const temp = unionToTopic(this.topicType(), this.topic.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(); - _o.payloadType = this.payloadType(); - _o.payload = (() => { - const temp = unionToPayload(this.payloadType(), this.payload.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(); -} -} - -export class MessageT implements flatbuffers.IGeneratedObject { -constructor( - public topicType: Topic = Topic.NONE, - public topic: TopicHandleT|TopicIdT|null = null, - public payloadType: Payload = Payload.NONE, - public payload: BytesT|KeyValuesT|StringTableT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const topic = builder.createObjectOffset(this.topic); - const payload = builder.createObjectOffset(this.payload); - - return Message.createMessage(builder, - this.topicType, - topic, - this.payloadType, - payload - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/payload.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/payload.ts deleted file mode 100644 index 621e91258..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/payload.ts +++ /dev/null @@ -1,40 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import { Bytes, BytesT } from '../../solarxr-protocol/datatypes/bytes.js'; -import { StringTable, StringTableT } from '../../solarxr-protocol/datatypes/string-table.js'; -import { KeyValues, KeyValuesT } from '../../solarxr-protocol/pub-sub/key-values.js'; - - -export enum Payload { - NONE = 0, - solarxr_protocol_datatypes_StringTable = 1, - solarxr_protocol_datatypes_Bytes = 2, - KeyValues = 3 -} - -export function unionToPayload( - type: Payload, - accessor: (obj:Bytes|KeyValues|StringTable) => Bytes|KeyValues|StringTable|null -): Bytes|KeyValues|StringTable|null { - switch(Payload[type]) { - case 'NONE': return null; - case 'solarxr_protocol_datatypes_StringTable': return accessor(new StringTable())! as StringTable; - case 'solarxr_protocol_datatypes_Bytes': return accessor(new Bytes())! as Bytes; - case 'KeyValues': return accessor(new KeyValues())! as KeyValues; - default: return null; - } -} - -export function unionListToPayload( - type: Payload, - accessor: (index: number, obj:Bytes|KeyValues|StringTable) => Bytes|KeyValues|StringTable|null, - index: number -): Bytes|KeyValues|StringTable|null { - switch(Payload[type]) { - case 'NONE': return null; - case 'solarxr_protocol_datatypes_StringTable': return accessor(index, new StringTable())! as StringTable; - case 'solarxr_protocol_datatypes_Bytes': return accessor(index, new Bytes())! as Bytes; - case 'KeyValues': return accessor(index, new KeyValues())! as KeyValues; - default: return null; - } -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-header.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-header.ts deleted file mode 100644 index c5fc22ea8..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-header.ts +++ /dev/null @@ -1,101 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { Message, MessageT } from '../../solarxr-protocol/pub-sub/message.js'; -import { PubSubUnion, unionToPubSubUnion, unionListToPubSubUnion } from '../../solarxr-protocol/pub-sub/pub-sub-union.js'; -import { SubscriptionRequest, SubscriptionRequestT } from '../../solarxr-protocol/pub-sub/subscription-request.js'; -import { TopicHandleRequest, TopicHandleRequestT } from '../../solarxr-protocol/pub-sub/topic-handle-request.js'; -import { TopicMapping, TopicMappingT } from '../../solarxr-protocol/pub-sub/topic-mapping.js'; - - -export class PubSubHeader implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):PubSubHeader { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsPubSubHeader(bb:flatbuffers.ByteBuffer, obj?:PubSubHeader):PubSubHeader { - return (obj || new PubSubHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsPubSubHeader(bb:flatbuffers.ByteBuffer, obj?:PubSubHeader):PubSubHeader { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new PubSubHeader()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -uType():PubSubUnion { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : PubSubUnion.NONE; -} - -u(obj:any):any|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; -} - -static startPubSubHeader(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addUType(builder:flatbuffers.Builder, uType:PubSubUnion) { - builder.addFieldInt8(0, uType, PubSubUnion.NONE); -} - -static addU(builder:flatbuffers.Builder, uOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, uOffset, 0); -} - -static endPubSubHeader(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createPubSubHeader(builder:flatbuffers.Builder, uType:PubSubUnion, uOffset:flatbuffers.Offset):flatbuffers.Offset { - PubSubHeader.startPubSubHeader(builder); - PubSubHeader.addUType(builder, uType); - PubSubHeader.addU(builder, uOffset); - return PubSubHeader.endPubSubHeader(builder); -} - -unpack(): PubSubHeaderT { - return new PubSubHeaderT( - this.uType(), - (() => { - const temp = unionToPubSubUnion(this.uType(), this.u.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })() - ); -} - - -unpackTo(_o: PubSubHeaderT): void { - _o.uType = this.uType(); - _o.u = (() => { - const temp = unionToPubSubUnion(this.uType(), this.u.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(); -} -} - -export class PubSubHeaderT implements flatbuffers.IGeneratedObject { -constructor( - public uType: PubSubUnion = PubSubUnion.NONE, - public u: MessageT|SubscriptionRequestT|TopicHandleRequestT|TopicMappingT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const u = builder.createObjectOffset(this.u); - - return PubSubHeader.createPubSubHeader(builder, - this.uType, - u - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-union.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-union.ts deleted file mode 100644 index 03214a95f..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/pub-sub-union.ts +++ /dev/null @@ -1,44 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import { Message, MessageT } from '../../solarxr-protocol/pub-sub/message.js'; -import { SubscriptionRequest, SubscriptionRequestT } from '../../solarxr-protocol/pub-sub/subscription-request.js'; -import { TopicHandleRequest, TopicHandleRequestT } from '../../solarxr-protocol/pub-sub/topic-handle-request.js'; -import { TopicMapping, TopicMappingT } from '../../solarxr-protocol/pub-sub/topic-mapping.js'; - - -export enum PubSubUnion { - NONE = 0, - Message = 1, - SubscriptionRequest = 2, - TopicHandleRequest = 3, - TopicMapping = 4 -} - -export function unionToPubSubUnion( - type: PubSubUnion, - accessor: (obj:Message|SubscriptionRequest|TopicHandleRequest|TopicMapping) => Message|SubscriptionRequest|TopicHandleRequest|TopicMapping|null -): Message|SubscriptionRequest|TopicHandleRequest|TopicMapping|null { - switch(PubSubUnion[type]) { - case 'NONE': return null; - case 'Message': return accessor(new Message())! as Message; - case 'SubscriptionRequest': return accessor(new SubscriptionRequest())! as SubscriptionRequest; - case 'TopicHandleRequest': return accessor(new TopicHandleRequest())! as TopicHandleRequest; - case 'TopicMapping': return accessor(new TopicMapping())! as TopicMapping; - default: return null; - } -} - -export function unionListToPubSubUnion( - type: PubSubUnion, - accessor: (index: number, obj:Message|SubscriptionRequest|TopicHandleRequest|TopicMapping) => Message|SubscriptionRequest|TopicHandleRequest|TopicMapping|null, - index: number -): Message|SubscriptionRequest|TopicHandleRequest|TopicMapping|null { - switch(PubSubUnion[type]) { - case 'NONE': return null; - case 'Message': return accessor(index, new Message())! as Message; - case 'SubscriptionRequest': return accessor(index, new SubscriptionRequest())! as SubscriptionRequest; - case 'TopicHandleRequest': return accessor(index, new TopicHandleRequest())! as TopicHandleRequest; - case 'TopicMapping': return accessor(index, new TopicMapping())! as TopicMapping; - default: return null; - } -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/subscription-request.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/subscription-request.ts deleted file mode 100644 index 2ad82e78b..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/subscription-request.ts +++ /dev/null @@ -1,102 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { Topic, unionToTopic, unionListToTopic } from '../../solarxr-protocol/pub-sub/topic.js'; -import { TopicHandle, TopicHandleT } from '../../solarxr-protocol/pub-sub/topic-handle.js'; -import { TopicId, TopicIdT } from '../../solarxr-protocol/pub-sub/topic-id.js'; - - -/** - * Requests a subscription to `topic`. Replies with a `TopicMapping`. - */ -export class SubscriptionRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SubscriptionRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSubscriptionRequest(bb:flatbuffers.ByteBuffer, obj?:SubscriptionRequest):SubscriptionRequest { - return (obj || new SubscriptionRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSubscriptionRequest(bb:flatbuffers.ByteBuffer, obj?:SubscriptionRequest):SubscriptionRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SubscriptionRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -topicType():Topic { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : Topic.NONE; -} - -topic(obj:any):any|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; -} - -static startSubscriptionRequest(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addTopicType(builder:flatbuffers.Builder, topicType:Topic) { - builder.addFieldInt8(0, topicType, Topic.NONE); -} - -static addTopic(builder:flatbuffers.Builder, topicOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, topicOffset, 0); -} - -static endSubscriptionRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSubscriptionRequest(builder:flatbuffers.Builder, topicType:Topic, topicOffset:flatbuffers.Offset):flatbuffers.Offset { - SubscriptionRequest.startSubscriptionRequest(builder); - SubscriptionRequest.addTopicType(builder, topicType); - SubscriptionRequest.addTopic(builder, topicOffset); - return SubscriptionRequest.endSubscriptionRequest(builder); -} - -unpack(): SubscriptionRequestT { - return new SubscriptionRequestT( - this.topicType(), - (() => { - const temp = unionToTopic(this.topicType(), this.topic.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })() - ); -} - - -unpackTo(_o: SubscriptionRequestT): void { - _o.topicType = this.topicType(); - _o.topic = (() => { - const temp = unionToTopic(this.topicType(), this.topic.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(); -} -} - -export class SubscriptionRequestT implements flatbuffers.IGeneratedObject { -constructor( - public topicType: Topic = Topic.NONE, - public topic: TopicHandleT|TopicIdT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const topic = builder.createObjectOffset(this.topic); - - return SubscriptionRequest.createSubscriptionRequest(builder, - this.topicType, - topic - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle-request.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle-request.ts deleted file mode 100644 index 5d1bfaa7a..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle-request.ts +++ /dev/null @@ -1,79 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { TopicId, TopicIdT } from '../../solarxr-protocol/pub-sub/topic-id.js'; - - -/** - * Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing - * bandwidth, since `FeatureId` can be large. - */ -export class TopicHandleRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TopicHandleRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTopicHandleRequest(bb:flatbuffers.ByteBuffer, obj?:TopicHandleRequest):TopicHandleRequest { - return (obj || new TopicHandleRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTopicHandleRequest(bb:flatbuffers.ByteBuffer, obj?:TopicHandleRequest):TopicHandleRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TopicHandleRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -id(obj?:TopicId):TopicId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TopicId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startTopicHandleRequest(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, idOffset, 0); -} - -static endTopicHandleRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createTopicHandleRequest(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset):flatbuffers.Offset { - TopicHandleRequest.startTopicHandleRequest(builder); - TopicHandleRequest.addId(builder, idOffset); - return TopicHandleRequest.endTopicHandleRequest(builder); -} - -unpack(): TopicHandleRequestT { - return new TopicHandleRequestT( - (this.id() !== null ? this.id()!.unpack() : null) - ); -} - - -unpackTo(_o: TopicHandleRequestT): void { - _o.id = (this.id() !== null ? this.id()!.unpack() : null); -} -} - -export class TopicHandleRequestT implements flatbuffers.IGeneratedObject { -constructor( - public id: TopicIdT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const id = (this.id !== null ? this.id!.pack(builder) : 0); - - return TopicHandleRequest.createTopicHandleRequest(builder, - id - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle.ts deleted file mode 100644 index 2044b5c2a..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-handle.ts +++ /dev/null @@ -1,76 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * A handle for the topic, allows referencing a topic without sending a huge - * `TopicId`. - */ -export class TopicHandle implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TopicHandle { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTopicHandle(bb:flatbuffers.ByteBuffer, obj?:TopicHandle):TopicHandle { - return (obj || new TopicHandle()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTopicHandle(bb:flatbuffers.ByteBuffer, obj?:TopicHandle):TopicHandle { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TopicHandle()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -id():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; -} - -static startTopicHandle(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addId(builder:flatbuffers.Builder, id:number) { - builder.addFieldInt16(0, id, 0); -} - -static endTopicHandle(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createTopicHandle(builder:flatbuffers.Builder, id:number):flatbuffers.Offset { - TopicHandle.startTopicHandle(builder); - TopicHandle.addId(builder, id); - return TopicHandle.endTopicHandle(builder); -} - -unpack(): TopicHandleT { - return new TopicHandleT( - this.id() - ); -} - - -unpackTo(_o: TopicHandleT): void { - _o.id = this.id(); -} -} - -export class TopicHandleT implements flatbuffers.IGeneratedObject { -constructor( - public id: number = 0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return TopicHandle.createTopicHandle(builder, - this.id - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-id.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/topic-id.ts deleted file mode 100644 index fda5d7b9b..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-id.ts +++ /dev/null @@ -1,129 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * A `TopicId` identifies an application-specific category of data. Because it - * is application-specific, it is up to the application within the specified - * organization to define its semantics/meaning. - * - * For example, "bob" may have an "overlay" app with a "settings" topic for controlling - * the overlay visibility and other settings, as well as a "video feed" topic for - * allowing other applications to display video data in a wrist mounted window in VR. - */ -export class TopicId implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TopicId { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTopicId(bb:flatbuffers.ByteBuffer, obj?:TopicId):TopicId { - return (obj || new TopicId()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTopicId(bb:flatbuffers.ByteBuffer, obj?:TopicId):TopicId { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TopicId()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -/** - * The organization/developer that defines the meaning of this feature. Avoids name - * clashes. Should be something unique - same idea as java package identifier. - */ -organization():string|null -organization(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -organization(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -/** - * The name of the application/device. Should be unique within the organization. - */ -appName():string|null -appName(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -appName(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -/** - * The name of the topic. Should be unique within the application. - */ -topic():string|null -topic(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -topic(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startTopicId(builder:flatbuffers.Builder) { - builder.startObject(3); -} - -static addOrganization(builder:flatbuffers.Builder, organizationOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, organizationOffset, 0); -} - -static addAppName(builder:flatbuffers.Builder, appNameOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, appNameOffset, 0); -} - -static addTopic(builder:flatbuffers.Builder, topicOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, topicOffset, 0); -} - -static endTopicId(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createTopicId(builder:flatbuffers.Builder, organizationOffset:flatbuffers.Offset, appNameOffset:flatbuffers.Offset, topicOffset:flatbuffers.Offset):flatbuffers.Offset { - TopicId.startTopicId(builder); - TopicId.addOrganization(builder, organizationOffset); - TopicId.addAppName(builder, appNameOffset); - TopicId.addTopic(builder, topicOffset); - return TopicId.endTopicId(builder); -} - -unpack(): TopicIdT { - return new TopicIdT( - this.organization(), - this.appName(), - this.topic() - ); -} - - -unpackTo(_o: TopicIdT): void { - _o.organization = this.organization(); - _o.appName = this.appName(); - _o.topic = this.topic(); -} -} - -export class TopicIdT implements flatbuffers.IGeneratedObject { -constructor( - public organization: string|Uint8Array|null = null, - public appName: string|Uint8Array|null = null, - public topic: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const organization = (this.organization !== null ? builder.createString(this.organization!) : 0); - const appName = (this.appName !== null ? builder.createString(this.appName!) : 0); - const topic = (this.topic !== null ? builder.createString(this.topic!) : 0); - - return TopicId.createTopicId(builder, - organization, - appName, - topic - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-mapping.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/topic-mapping.ts deleted file mode 100644 index 6d7769f42..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/topic-mapping.ts +++ /dev/null @@ -1,89 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { TopicHandle, TopicHandleT } from '../../solarxr-protocol/pub-sub/topic-handle.js'; -import { TopicId, TopicIdT } from '../../solarxr-protocol/pub-sub/topic-id.js'; - - -/** - * Response for `TopicHandleRequest` or `SubscriptionRequest`. - */ -export class TopicMapping implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TopicMapping { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTopicMapping(bb:flatbuffers.ByteBuffer, obj?:TopicMapping):TopicMapping { - return (obj || new TopicMapping()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTopicMapping(bb:flatbuffers.ByteBuffer, obj?:TopicMapping):TopicMapping { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TopicMapping()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -id(obj?:TopicId):TopicId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TopicId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -handle(obj?:TopicHandle):TopicHandle|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new TopicHandle()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startTopicMapping(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, idOffset, 0); -} - -static addHandle(builder:flatbuffers.Builder, handleOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, handleOffset, 0); -} - -static endTopicMapping(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - - -unpack(): TopicMappingT { - return new TopicMappingT( - (this.id() !== null ? this.id()!.unpack() : null), - (this.handle() !== null ? this.handle()!.unpack() : null) - ); -} - - -unpackTo(_o: TopicMappingT): void { - _o.id = (this.id() !== null ? this.id()!.unpack() : null); - _o.handle = (this.handle() !== null ? this.handle()!.unpack() : null); -} -} - -export class TopicMappingT implements flatbuffers.IGeneratedObject { -constructor( - public id: TopicIdT|null = null, - public handle: TopicHandleT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const id = (this.id !== null ? this.id!.pack(builder) : 0); - const handle = (this.handle !== null ? this.handle!.pack(builder) : 0); - - TopicMapping.startTopicMapping(builder); - TopicMapping.addId(builder, id); - TopicMapping.addHandle(builder, handle); - - return TopicMapping.endTopicMapping(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/pub-sub/topic.ts b/protocol/typescript/src/solarxr-protocol/pub-sub/topic.ts deleted file mode 100644 index 697121e94..000000000 --- a/protocol/typescript/src/solarxr-protocol/pub-sub/topic.ts +++ /dev/null @@ -1,36 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import { TopicHandle, TopicHandleT } from '../../solarxr-protocol/pub-sub/topic-handle.js'; -import { TopicId, TopicIdT } from '../../solarxr-protocol/pub-sub/topic-id.js'; - - -export enum Topic { - NONE = 0, - TopicHandle = 1, - TopicId = 2 -} - -export function unionToTopic( - type: Topic, - accessor: (obj:TopicHandle|TopicId) => TopicHandle|TopicId|null -): TopicHandle|TopicId|null { - switch(Topic[type]) { - case 'NONE': return null; - case 'TopicHandle': return accessor(new TopicHandle())! as TopicHandle; - case 'TopicId': return accessor(new TopicId())! as TopicId; - default: return null; - } -} - -export function unionListToTopic( - type: Topic, - accessor: (index: number, obj:TopicHandle|TopicId) => TopicHandle|TopicId|null, - index: number -): TopicHandle|TopicId|null { - switch(Topic[type]) { - case 'NONE': return null; - case 'TopicHandle': return accessor(index, new TopicHandle())! as TopicHandle; - case 'TopicId': return accessor(index, new TopicId())! as TopicId; - default: return null; - } -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/arms-mounting-reset-mode.ts b/protocol/typescript/src/solarxr-protocol/rpc/arms-mounting-reset-mode.ts deleted file mode 100644 index a0ad14076..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/arms-mounting-reset-mode.ts +++ /dev/null @@ -1,23 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -export enum ArmsMountingResetMode { - /** - * Upper arm going back and forearm going forward - */ - BACK = 0, - - /** - * Arms going forward - */ - FORWARD = 1, - - /** - * Arms going up to the sides into a tpose - */ - TPOSE_UP = 2, - - /** - * Arms going down to the sides from a tpose - */ - TPOSE_DOWN = 3 -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/arms-reset-mode.ts b/protocol/typescript/src/solarxr-protocol/rpc/arms-reset-mode.ts new file mode 100644 index 000000000..82215b2cd --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/arms-reset-mode.ts @@ -0,0 +1,23 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum ArmsResetMode { + /** + * Down to the sides for full. Upper arm going back and forearm going forward for mounting. + */ + BACK = 0, + + /** + * Down to the sides for full. Arms going forward for mounting. + */ + FORWARD = 1, + + /** + * Down to the sides for full. T-pose for mounting. + */ + T_POSE_UP = 2, + + /** + * T-pose for full. Down to the sides for mounting. + */ + T_POSE_DOWN = 3 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/assign-tracker-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/assign-tracker-request.ts index 692e050f8..28292dace 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/assign-tracker-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/assign-tracker-request.ts @@ -3,7 +3,6 @@ import * as flatbuffers from 'flatbuffers'; import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; import { Quat, QuatT } from '../../solarxr-protocol/datatypes/math/quat.js'; @@ -25,9 +24,9 @@ static getSizePrefixedRootAsAssignTrackerRequest(bb:flatbuffers.ByteBuffer, obj? return (obj || new AssignTrackerRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } bodyPosition():BodyPart { @@ -47,17 +46,12 @@ displayName(optionalEncoding?:any):string|Uint8Array|null { return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; } -allowDriftCompensation():boolean { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - static startAssignTrackerRequest(builder:flatbuffers.Builder) { - builder.startObject(5); + builder.startObject(4); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static addBodyPosition(builder:flatbuffers.Builder, bodyPosition:BodyPart) { @@ -72,10 +66,6 @@ static addDisplayName(builder:flatbuffers.Builder, displayNameOffset:flatbuffers builder.addFieldOffset(3, displayNameOffset, 0); } -static addAllowDriftCompensation(builder:flatbuffers.Builder, allowDriftCompensation:boolean) { - builder.addFieldInt8(4, +allowDriftCompensation, +false); -} - static endAssignTrackerRequest(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -84,44 +74,39 @@ static endAssignTrackerRequest(builder:flatbuffers.Builder):flatbuffers.Offset { unpack(): AssignTrackerRequestT { return new AssignTrackerRequestT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.trackerId(), this.bodyPosition(), (this.mountingOrientation() !== null ? this.mountingOrientation()!.unpack() : null), - this.displayName(), - this.allowDriftCompensation() + this.displayName() ); } unpackTo(_o: AssignTrackerRequestT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); _o.bodyPosition = this.bodyPosition(); _o.mountingOrientation = (this.mountingOrientation() !== null ? this.mountingOrientation()!.unpack() : null); _o.displayName = this.displayName(); - _o.allowDriftCompensation = this.allowDriftCompensation(); } } export class AssignTrackerRequestT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null, + public trackerId: number = 0, public bodyPosition: BodyPart = BodyPart.NONE, public mountingOrientation: QuatT|null = null, - public displayName: string|Uint8Array|null = null, - public allowDriftCompensation: boolean = false + public displayName: string|Uint8Array|null = null ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); const displayName = (this.displayName !== null ? builder.createString(this.displayName!) : 0); AssignTrackerRequest.startAssignTrackerRequest(builder); - AssignTrackerRequest.addTrackerId(builder, trackerId); + AssignTrackerRequest.addTrackerId(builder, this.trackerId); AssignTrackerRequest.addBodyPosition(builder, this.bodyPosition); AssignTrackerRequest.addMountingOrientation(builder, (this.mountingOrientation !== null ? this.mountingOrientation!.pack(builder) : 0)); AssignTrackerRequest.addDisplayName(builder, displayName); - AssignTrackerRequest.addAllowDriftCompensation(builder, this.allowDriftCompensation); return AssignTrackerRequest.endAssignTrackerRequest(builder); } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-status-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-status-response.ts index 5b5b10b24..9c8f16577 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-status-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-status-response.ts @@ -32,7 +32,7 @@ processType():AutoBoneProcessType { * The current count. This value is -1 if there is nothing to report. */ current():number { - const offset = this.bb!.__offset(this.bb_pos, 8); + const offset = this.bb!.__offset(this.bb_pos, 6); return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; } @@ -40,7 +40,7 @@ current():number { * The total count. This value is -1 if there is nothing to report. */ total():number { - const offset = this.bb!.__offset(this.bb_pos, 10); + const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; } @@ -48,7 +48,7 @@ total():number { * True if the operation has completed with any result, successful or not. */ completed():boolean { - const offset = this.bb!.__offset(this.bb_pos, 12); + const offset = this.bb!.__offset(this.bb_pos, 10); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } @@ -56,7 +56,7 @@ completed():boolean { * True if the completed operation was successful, only observe if `completed` is true. */ success():boolean { - const offset = this.bb!.__offset(this.bb_pos, 14); + const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } @@ -64,12 +64,12 @@ success():boolean { * The time remaining in seconds. This value is -1 if there is nothing to report. */ eta():number { - const offset = this.bb!.__offset(this.bb_pos, 16); + const offset = this.bb!.__offset(this.bb_pos, 14); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } static startAutoBoneProcessStatusResponse(builder:flatbuffers.Builder) { - builder.startObject(7); + builder.startObject(6); } static addProcessType(builder:flatbuffers.Builder, processType:AutoBoneProcessType) { @@ -77,23 +77,23 @@ static addProcessType(builder:flatbuffers.Builder, processType:AutoBoneProcessTy } static addCurrent(builder:flatbuffers.Builder, current:number) { - builder.addFieldInt32(2, current, 0); + builder.addFieldInt32(1, current, 0); } static addTotal(builder:flatbuffers.Builder, total:number) { - builder.addFieldInt32(3, total, 0); + builder.addFieldInt32(2, total, 0); } static addCompleted(builder:flatbuffers.Builder, completed:boolean) { - builder.addFieldInt8(4, +completed, +false); + builder.addFieldInt8(3, +completed, +false); } static addSuccess(builder:flatbuffers.Builder, success:boolean) { - builder.addFieldInt8(5, +success, +false); + builder.addFieldInt8(4, +success, +false); } static addEta(builder:flatbuffers.Builder, eta:number) { - builder.addFieldFloat32(6, eta, 0.0); + builder.addFieldFloat32(5, eta, 0.0); } static endAutoBoneProcessStatusResponse(builder:flatbuffers.Builder):flatbuffers.Offset { diff --git a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-type.ts b/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-type.ts index 8c87dbebf..322c8ae79 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-type.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-process-type.ts @@ -4,11 +4,5 @@ export enum AutoBoneProcessType { NONE = 0, RECORD = 1, SAVE = 2, - PROCESS = 3, - - /** - * @deprecated - * Use AutoBoneApplyRequest instead - */ - APPLY = 4 + PROCESS = 3 } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-settings.ts deleted file mode 100644 index 4d697bbe3..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/auto-bone-settings.ts +++ /dev/null @@ -1,391 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt - */ -export class AutoBoneSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):AutoBoneSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsAutoBoneSettings(bb:flatbuffers.ByteBuffer, obj?:AutoBoneSettings):AutoBoneSettings { - return (obj || new AutoBoneSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsAutoBoneSettings(bb:flatbuffers.ByteBuffer, obj?:AutoBoneSettings):AutoBoneSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new AutoBoneSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -cursorIncrement():number|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -minDataDistance():number|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -maxDataDistance():number|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -numEpochs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -printEveryNumEpochs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -initialAdjustRate():number|null { - const offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -adjustRateDecay():number|null { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -slideErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -offsetSlideErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -footHeightOffsetErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -bodyProportionErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -heightErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -positionErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 28); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -positionOffsetErrorFactor():number|null { - const offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -calcInitError():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 32); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -randomizeFrameOrder():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 34); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -scaleEachStep():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 36); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -sampleCount():number|null { - const offset = this.bb!.__offset(this.bb_pos, 38); - return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; -} - -sampleRateMs():bigint|null { - const offset = this.bb!.__offset(this.bb_pos, 40); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : null; -} - -saveRecordings():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 42); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -useSkeletonHeight():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 44); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -randSeed():bigint|null { - const offset = this.bb!.__offset(this.bb_pos, 46); - return offset ? this.bb!.readInt64(this.bb_pos + offset) : null; -} - -static startAutoBoneSettings(builder:flatbuffers.Builder) { - builder.startObject(22); -} - -static addCursorIncrement(builder:flatbuffers.Builder, cursorIncrement:number) { - builder.addFieldInt32(0, cursorIncrement, 0); -} - -static addMinDataDistance(builder:flatbuffers.Builder, minDataDistance:number) { - builder.addFieldInt32(1, minDataDistance, 0); -} - -static addMaxDataDistance(builder:flatbuffers.Builder, maxDataDistance:number) { - builder.addFieldInt32(2, maxDataDistance, 0); -} - -static addNumEpochs(builder:flatbuffers.Builder, numEpochs:number) { - builder.addFieldInt32(3, numEpochs, 0); -} - -static addPrintEveryNumEpochs(builder:flatbuffers.Builder, printEveryNumEpochs:number) { - builder.addFieldInt32(4, printEveryNumEpochs, 0); -} - -static addInitialAdjustRate(builder:flatbuffers.Builder, initialAdjustRate:number) { - builder.addFieldFloat32(5, initialAdjustRate, 0); -} - -static addAdjustRateDecay(builder:flatbuffers.Builder, adjustRateDecay:number) { - builder.addFieldFloat32(6, adjustRateDecay, 0); -} - -static addSlideErrorFactor(builder:flatbuffers.Builder, slideErrorFactor:number) { - builder.addFieldFloat32(7, slideErrorFactor, 0); -} - -static addOffsetSlideErrorFactor(builder:flatbuffers.Builder, offsetSlideErrorFactor:number) { - builder.addFieldFloat32(8, offsetSlideErrorFactor, 0); -} - -static addFootHeightOffsetErrorFactor(builder:flatbuffers.Builder, footHeightOffsetErrorFactor:number) { - builder.addFieldFloat32(9, footHeightOffsetErrorFactor, 0); -} - -static addBodyProportionErrorFactor(builder:flatbuffers.Builder, bodyProportionErrorFactor:number) { - builder.addFieldFloat32(10, bodyProportionErrorFactor, 0); -} - -static addHeightErrorFactor(builder:flatbuffers.Builder, heightErrorFactor:number) { - builder.addFieldFloat32(11, heightErrorFactor, 0); -} - -static addPositionErrorFactor(builder:flatbuffers.Builder, positionErrorFactor:number) { - builder.addFieldFloat32(12, positionErrorFactor, 0); -} - -static addPositionOffsetErrorFactor(builder:flatbuffers.Builder, positionOffsetErrorFactor:number) { - builder.addFieldFloat32(13, positionOffsetErrorFactor, 0); -} - -static addCalcInitError(builder:flatbuffers.Builder, calcInitError:boolean) { - builder.addFieldInt8(14, +calcInitError, 0); -} - -static addRandomizeFrameOrder(builder:flatbuffers.Builder, randomizeFrameOrder:boolean) { - builder.addFieldInt8(15, +randomizeFrameOrder, 0); -} - -static addScaleEachStep(builder:flatbuffers.Builder, scaleEachStep:boolean) { - builder.addFieldInt8(16, +scaleEachStep, 0); -} - -static addSampleCount(builder:flatbuffers.Builder, sampleCount:number) { - builder.addFieldInt32(17, sampleCount, 0); -} - -static addSampleRateMs(builder:flatbuffers.Builder, sampleRateMs:bigint) { - builder.addFieldInt64(18, sampleRateMs, BigInt(0)); -} - -static addSaveRecordings(builder:flatbuffers.Builder, saveRecordings:boolean) { - builder.addFieldInt8(19, +saveRecordings, 0); -} - -static addUseSkeletonHeight(builder:flatbuffers.Builder, useSkeletonHeight:boolean) { - builder.addFieldInt8(20, +useSkeletonHeight, 0); -} - -static addRandSeed(builder:flatbuffers.Builder, randSeed:bigint) { - builder.addFieldInt64(21, randSeed, BigInt(0)); -} - -static endAutoBoneSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createAutoBoneSettings(builder:flatbuffers.Builder, cursorIncrement:number|null, minDataDistance:number|null, maxDataDistance:number|null, numEpochs:number|null, printEveryNumEpochs:number|null, initialAdjustRate:number|null, adjustRateDecay:number|null, slideErrorFactor:number|null, offsetSlideErrorFactor:number|null, footHeightOffsetErrorFactor:number|null, bodyProportionErrorFactor:number|null, heightErrorFactor:number|null, positionErrorFactor:number|null, positionOffsetErrorFactor:number|null, calcInitError:boolean|null, randomizeFrameOrder:boolean|null, scaleEachStep:boolean|null, sampleCount:number|null, sampleRateMs:bigint|null, saveRecordings:boolean|null, useSkeletonHeight:boolean|null, randSeed:bigint|null):flatbuffers.Offset { - AutoBoneSettings.startAutoBoneSettings(builder); - if (cursorIncrement !== null) - AutoBoneSettings.addCursorIncrement(builder, cursorIncrement); - if (minDataDistance !== null) - AutoBoneSettings.addMinDataDistance(builder, minDataDistance); - if (maxDataDistance !== null) - AutoBoneSettings.addMaxDataDistance(builder, maxDataDistance); - if (numEpochs !== null) - AutoBoneSettings.addNumEpochs(builder, numEpochs); - if (printEveryNumEpochs !== null) - AutoBoneSettings.addPrintEveryNumEpochs(builder, printEveryNumEpochs); - if (initialAdjustRate !== null) - AutoBoneSettings.addInitialAdjustRate(builder, initialAdjustRate); - if (adjustRateDecay !== null) - AutoBoneSettings.addAdjustRateDecay(builder, adjustRateDecay); - if (slideErrorFactor !== null) - AutoBoneSettings.addSlideErrorFactor(builder, slideErrorFactor); - if (offsetSlideErrorFactor !== null) - AutoBoneSettings.addOffsetSlideErrorFactor(builder, offsetSlideErrorFactor); - if (footHeightOffsetErrorFactor !== null) - AutoBoneSettings.addFootHeightOffsetErrorFactor(builder, footHeightOffsetErrorFactor); - if (bodyProportionErrorFactor !== null) - AutoBoneSettings.addBodyProportionErrorFactor(builder, bodyProportionErrorFactor); - if (heightErrorFactor !== null) - AutoBoneSettings.addHeightErrorFactor(builder, heightErrorFactor); - if (positionErrorFactor !== null) - AutoBoneSettings.addPositionErrorFactor(builder, positionErrorFactor); - if (positionOffsetErrorFactor !== null) - AutoBoneSettings.addPositionOffsetErrorFactor(builder, positionOffsetErrorFactor); - if (calcInitError !== null) - AutoBoneSettings.addCalcInitError(builder, calcInitError); - if (randomizeFrameOrder !== null) - AutoBoneSettings.addRandomizeFrameOrder(builder, randomizeFrameOrder); - if (scaleEachStep !== null) - AutoBoneSettings.addScaleEachStep(builder, scaleEachStep); - if (sampleCount !== null) - AutoBoneSettings.addSampleCount(builder, sampleCount); - if (sampleRateMs !== null) - AutoBoneSettings.addSampleRateMs(builder, sampleRateMs); - if (saveRecordings !== null) - AutoBoneSettings.addSaveRecordings(builder, saveRecordings); - if (useSkeletonHeight !== null) - AutoBoneSettings.addUseSkeletonHeight(builder, useSkeletonHeight); - if (randSeed !== null) - AutoBoneSettings.addRandSeed(builder, randSeed); - return AutoBoneSettings.endAutoBoneSettings(builder); -} - -unpack(): AutoBoneSettingsT { - return new AutoBoneSettingsT( - this.cursorIncrement(), - this.minDataDistance(), - this.maxDataDistance(), - this.numEpochs(), - this.printEveryNumEpochs(), - this.initialAdjustRate(), - this.adjustRateDecay(), - this.slideErrorFactor(), - this.offsetSlideErrorFactor(), - this.footHeightOffsetErrorFactor(), - this.bodyProportionErrorFactor(), - this.heightErrorFactor(), - this.positionErrorFactor(), - this.positionOffsetErrorFactor(), - this.calcInitError(), - this.randomizeFrameOrder(), - this.scaleEachStep(), - this.sampleCount(), - this.sampleRateMs(), - this.saveRecordings(), - this.useSkeletonHeight(), - this.randSeed() - ); -} - - -unpackTo(_o: AutoBoneSettingsT): void { - _o.cursorIncrement = this.cursorIncrement(); - _o.minDataDistance = this.minDataDistance(); - _o.maxDataDistance = this.maxDataDistance(); - _o.numEpochs = this.numEpochs(); - _o.printEveryNumEpochs = this.printEveryNumEpochs(); - _o.initialAdjustRate = this.initialAdjustRate(); - _o.adjustRateDecay = this.adjustRateDecay(); - _o.slideErrorFactor = this.slideErrorFactor(); - _o.offsetSlideErrorFactor = this.offsetSlideErrorFactor(); - _o.footHeightOffsetErrorFactor = this.footHeightOffsetErrorFactor(); - _o.bodyProportionErrorFactor = this.bodyProportionErrorFactor(); - _o.heightErrorFactor = this.heightErrorFactor(); - _o.positionErrorFactor = this.positionErrorFactor(); - _o.positionOffsetErrorFactor = this.positionOffsetErrorFactor(); - _o.calcInitError = this.calcInitError(); - _o.randomizeFrameOrder = this.randomizeFrameOrder(); - _o.scaleEachStep = this.scaleEachStep(); - _o.sampleCount = this.sampleCount(); - _o.sampleRateMs = this.sampleRateMs(); - _o.saveRecordings = this.saveRecordings(); - _o.useSkeletonHeight = this.useSkeletonHeight(); - _o.randSeed = this.randSeed(); -} -} - -export class AutoBoneSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public cursorIncrement: number|null = null, - public minDataDistance: number|null = null, - public maxDataDistance: number|null = null, - public numEpochs: number|null = null, - public printEveryNumEpochs: number|null = null, - public initialAdjustRate: number|null = null, - public adjustRateDecay: number|null = null, - public slideErrorFactor: number|null = null, - public offsetSlideErrorFactor: number|null = null, - public footHeightOffsetErrorFactor: number|null = null, - public bodyProportionErrorFactor: number|null = null, - public heightErrorFactor: number|null = null, - public positionErrorFactor: number|null = null, - public positionOffsetErrorFactor: number|null = null, - public calcInitError: boolean|null = null, - public randomizeFrameOrder: boolean|null = null, - public scaleEachStep: boolean|null = null, - public sampleCount: number|null = null, - public sampleRateMs: bigint|null = null, - public saveRecordings: boolean|null = null, - public useSkeletonHeight: boolean|null = null, - public randSeed: bigint|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return AutoBoneSettings.createAutoBoneSettings(builder, - this.cursorIncrement, - this.minDataDistance, - this.maxDataDistance, - this.numEpochs, - this.printEveryNumEpochs, - this.initialAdjustRate, - this.adjustRateDecay, - this.slideErrorFactor, - this.offsetSlideErrorFactor, - this.footHeightOffsetErrorFactor, - this.bodyProportionErrorFactor, - this.heightErrorFactor, - this.positionErrorFactor, - this.positionOffsetErrorFactor, - this.calcInitError, - this.randomizeFrameOrder, - this.scaleEachStep, - this.sampleCount, - this.sampleRateMs, - this.saveRecordings, - this.useSkeletonHeight, - this.randSeed - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-hidsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-hidsettings-request.ts new file mode 100644 index 000000000..916579657 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-hidsettings-request.ts @@ -0,0 +1,72 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ChangeHIDSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeHIDSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeHIDSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeHIDSettingsRequest):ChangeHIDSettingsRequest { + return (obj || new ChangeHIDSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeHIDSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeHIDSettingsRequest):ChangeHIDSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeHIDSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackersOverHid():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startChangeHIDSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackersOverHid(builder:flatbuffers.Builder, trackersOverHid:boolean) { + builder.addFieldInt8(0, +trackersOverHid, +false); +} + +static endChangeHIDSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeHIDSettingsRequest(builder:flatbuffers.Builder, trackersOverHid:boolean):flatbuffers.Offset { + ChangeHIDSettingsRequest.startChangeHIDSettingsRequest(builder); + ChangeHIDSettingsRequest.addTrackersOverHid(builder, trackersOverHid); + return ChangeHIDSettingsRequest.endChangeHIDSettingsRequest(builder); +} + +unpack(): ChangeHIDSettingsRequestT { + return new ChangeHIDSettingsRequestT( + this.trackersOverHid() + ); +} + + +unpackTo(_o: ChangeHIDSettingsRequestT): void { + _o.trackersOverHid = this.trackersOverHid(); +} +} + +export class ChangeHIDSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public trackersOverHid: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ChangeHIDSettingsRequest.createChangeHIDSettingsRequest(builder, + this.trackersOverHid + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-mag-toggle-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-mag-toggle-request.ts index 09318a537..b56920119 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/change-mag-toggle-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-mag-toggle-request.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** @@ -26,9 +25,9 @@ static getSizePrefixedRootAsChangeMagToggleRequest(bb:flatbuffers.ByteBuffer, ob return (obj || new ChangeMagToggleRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } enable():boolean { @@ -40,8 +39,8 @@ static startChangeMagToggleRequest(builder:flatbuffers.Builder) { builder.startObject(2); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static addEnable(builder:flatbuffers.Builder, enable:boolean) { @@ -53,39 +52,37 @@ static endChangeMagToggleRequest(builder:flatbuffers.Builder):flatbuffers.Offset return offset; } -static createChangeMagToggleRequest(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset, enable:boolean):flatbuffers.Offset { +static createChangeMagToggleRequest(builder:flatbuffers.Builder, trackerId:number, enable:boolean):flatbuffers.Offset { ChangeMagToggleRequest.startChangeMagToggleRequest(builder); - ChangeMagToggleRequest.addTrackerId(builder, trackerIdOffset); + ChangeMagToggleRequest.addTrackerId(builder, trackerId); ChangeMagToggleRequest.addEnable(builder, enable); return ChangeMagToggleRequest.endChangeMagToggleRequest(builder); } unpack(): ChangeMagToggleRequestT { return new ChangeMagToggleRequestT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.trackerId(), this.enable() ); } unpackTo(_o: ChangeMagToggleRequestT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); _o.enable = this.enable(); } } export class ChangeMagToggleRequestT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null, + public trackerId: number = 0, public enable: boolean = false ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - return ChangeMagToggleRequest.createChangeMagToggleRequest(builder, - trackerId, + this.trackerId, this.enable ); } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-output-trackers-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-output-trackers-settings-request.ts new file mode 100644 index 000000000..8f5f0123e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-output-trackers-settings-request.ts @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; + + +export class ChangeOutputTrackersSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeOutputTrackersSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeOutputTrackersSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeOutputTrackersSettingsRequest):ChangeOutputTrackersSettingsRequest { + return (obj || new ChangeOutputTrackersSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeOutputTrackersSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeOutputTrackersSettingsRequest):ChangeOutputTrackersSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeOutputTrackersSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +automaticTrackerToggle():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +trackers(index: number):BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +trackersLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +trackersArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +sendDerivedVelocity():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startChangeOutputTrackersSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addAutomaticTrackerToggle(builder:flatbuffers.Builder, automaticTrackerToggle:boolean) { + builder.addFieldInt8(0, +automaticTrackerToggle, +false); +} + +static addTrackers(builder:flatbuffers.Builder, trackersOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, trackersOffset, 0); +} + +static createTrackersVector(builder:flatbuffers.Builder, data:BodyPart[]):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startTrackersVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static addSendDerivedVelocity(builder:flatbuffers.Builder, sendDerivedVelocity:boolean) { + builder.addFieldInt8(2, +sendDerivedVelocity, +false); +} + +static endChangeOutputTrackersSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeOutputTrackersSettingsRequest(builder:flatbuffers.Builder, automaticTrackerToggle:boolean, trackersOffset:flatbuffers.Offset, sendDerivedVelocity:boolean):flatbuffers.Offset { + ChangeOutputTrackersSettingsRequest.startChangeOutputTrackersSettingsRequest(builder); + ChangeOutputTrackersSettingsRequest.addAutomaticTrackerToggle(builder, automaticTrackerToggle); + ChangeOutputTrackersSettingsRequest.addTrackers(builder, trackersOffset); + ChangeOutputTrackersSettingsRequest.addSendDerivedVelocity(builder, sendDerivedVelocity); + return ChangeOutputTrackersSettingsRequest.endChangeOutputTrackersSettingsRequest(builder); +} + +unpack(): ChangeOutputTrackersSettingsRequestT { + return new ChangeOutputTrackersSettingsRequestT( + this.automaticTrackerToggle(), + this.bb!.createScalarList(this.trackers.bind(this), this.trackersLength()), + this.sendDerivedVelocity() + ); +} + + +unpackTo(_o: ChangeOutputTrackersSettingsRequestT): void { + _o.automaticTrackerToggle = this.automaticTrackerToggle(); + _o.trackers = this.bb!.createScalarList(this.trackers.bind(this), this.trackersLength()); + _o.sendDerivedVelocity = this.sendDerivedVelocity(); +} +} + +export class ChangeOutputTrackersSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public automaticTrackerToggle: boolean = false, + public trackers: (BodyPart)[] = [], + public sendDerivedVelocity: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackers = ChangeOutputTrackersSettingsRequest.createTrackersVector(builder, this.trackers); + + return ChangeOutputTrackersSettingsRequest.createChangeOutputTrackersSettingsRequest(builder, + this.automaticTrackerToggle, + trackers, + this.sendDerivedVelocity + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-resets-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-resets-settings-request.ts new file mode 100644 index 000000000..7707ae256 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-resets-settings-request.ts @@ -0,0 +1,132 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { ArmsResetMode } from '../../solarxr-protocol/rpc/arms-reset-mode.js'; + + +export class ChangeResetsSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeResetsSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeResetsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeResetsSettingsRequest):ChangeResetsSettingsRequest { + return (obj || new ChangeResetsSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeResetsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeResetsSettingsRequest):ChangeResetsSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeResetsSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +/** + * Makes it so feet will be mounting reset when passing no BodyPart + */ +resetMountingFeet():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +armsResetMode():ArmsResetMode { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : ArmsResetMode.BACK; +} + +yawResetSmoothTime():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +saveMountingReset():boolean { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +resetHmdPitch():boolean { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startChangeResetsSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(5); +} + +static addResetMountingFeet(builder:flatbuffers.Builder, resetMountingFeet:boolean) { + builder.addFieldInt8(0, +resetMountingFeet, +false); +} + +static addArmsResetMode(builder:flatbuffers.Builder, armsResetMode:ArmsResetMode) { + builder.addFieldInt8(1, armsResetMode, ArmsResetMode.BACK); +} + +static addYawResetSmoothTime(builder:flatbuffers.Builder, yawResetSmoothTime:number) { + builder.addFieldFloat32(2, yawResetSmoothTime, 0.0); +} + +static addSaveMountingReset(builder:flatbuffers.Builder, saveMountingReset:boolean) { + builder.addFieldInt8(3, +saveMountingReset, +false); +} + +static addResetHmdPitch(builder:flatbuffers.Builder, resetHmdPitch:boolean) { + builder.addFieldInt8(4, +resetHmdPitch, +false); +} + +static endChangeResetsSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeResetsSettingsRequest(builder:flatbuffers.Builder, resetMountingFeet:boolean, armsResetMode:ArmsResetMode, yawResetSmoothTime:number, saveMountingReset:boolean, resetHmdPitch:boolean):flatbuffers.Offset { + ChangeResetsSettingsRequest.startChangeResetsSettingsRequest(builder); + ChangeResetsSettingsRequest.addResetMountingFeet(builder, resetMountingFeet); + ChangeResetsSettingsRequest.addArmsResetMode(builder, armsResetMode); + ChangeResetsSettingsRequest.addYawResetSmoothTime(builder, yawResetSmoothTime); + ChangeResetsSettingsRequest.addSaveMountingReset(builder, saveMountingReset); + ChangeResetsSettingsRequest.addResetHmdPitch(builder, resetHmdPitch); + return ChangeResetsSettingsRequest.endChangeResetsSettingsRequest(builder); +} + +unpack(): ChangeResetsSettingsRequestT { + return new ChangeResetsSettingsRequestT( + this.resetMountingFeet(), + this.armsResetMode(), + this.yawResetSmoothTime(), + this.saveMountingReset(), + this.resetHmdPitch() + ); +} + + +unpackTo(_o: ChangeResetsSettingsRequestT): void { + _o.resetMountingFeet = this.resetMountingFeet(); + _o.armsResetMode = this.armsResetMode(); + _o.yawResetSmoothTime = this.yawResetSmoothTime(); + _o.saveMountingReset = this.saveMountingReset(); + _o.resetHmdPitch = this.resetHmdPitch(); +} +} + +export class ChangeResetsSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public resetMountingFeet: boolean = false, + public armsResetMode: ArmsResetMode = ArmsResetMode.BACK, + public yawResetSmoothTime: number = 0.0, + public saveMountingReset: boolean = false, + public resetHmdPitch: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ChangeResetsSettingsRequest.createChangeResetsSettingsRequest(builder, + this.resetMountingFeet, + this.armsResetMode, + this.yawResetSmoothTime, + this.saveMountingReset, + this.resetHmdPitch + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-settings-request.ts deleted file mode 100644 index e16541c36..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/change-settings-request.ts +++ /dev/null @@ -1,281 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { AutoBoneSettings, AutoBoneSettingsT } from '../../solarxr-protocol/rpc/auto-bone-settings.js'; -import { DriftCompensationSettings, DriftCompensationSettingsT } from '../../solarxr-protocol/rpc/drift-compensation-settings.js'; -import { FilteringSettings, FilteringSettingsT } from '../../solarxr-protocol/rpc/filtering-settings.js'; -import { HIDSettings, HIDSettingsT } from '../../solarxr-protocol/rpc/hidsettings.js'; -import { OSCRouterSettings, OSCRouterSettingsT } from '../../solarxr-protocol/rpc/oscrouter-settings.js'; -import { ResetsSettings, ResetsSettingsT } from '../../solarxr-protocol/rpc/resets-settings.js'; -import { StayAlignedSettings, StayAlignedSettingsT } from '../../solarxr-protocol/rpc/stay-aligned-settings.js'; -import { SteamVRTrackersSetting, SteamVRTrackersSettingT } from '../../solarxr-protocol/rpc/steam-vrtrackers-setting.js'; -import { TapDetectionSettings, TapDetectionSettingsT } from '../../solarxr-protocol/rpc/tap-detection-settings.js'; -import { TimeoutSettings, TimeoutSettingsT } from '../../solarxr-protocol/rpc/timeout-settings.js'; -import { VMCOSCSettings, VMCOSCSettingsT } from '../../solarxr-protocol/rpc/vmcoscsettings.js'; -import { VRCOSCSettings, VRCOSCSettingsT } from '../../solarxr-protocol/rpc/vrcoscsettings.js'; -import { VRMSettings, VRMSettingsT } from '../../solarxr-protocol/rpc/vrmsettings.js'; -import { VelocitySettings, VelocitySettingsT } from '../../solarxr-protocol/rpc/velocity-settings.js'; -import { ModelSettings, ModelSettingsT } from '../../solarxr-protocol/rpc/settings/model-settings.js'; - - -export class ChangeSettingsRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ChangeSettingsRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsChangeSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSettingsRequest):ChangeSettingsRequest { - return (obj || new ChangeSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsChangeSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSettingsRequest):ChangeSettingsRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ChangeSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -steamVrTrackers(obj?:SteamVRTrackersSetting):SteamVRTrackersSetting|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new SteamVRTrackersSetting()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -filtering(obj?:FilteringSettings):FilteringSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new FilteringSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -driftCompensation(obj?:DriftCompensationSettings):DriftCompensationSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new DriftCompensationSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -oscRouter(obj?:OSCRouterSettings):OSCRouterSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? (obj || new OSCRouterSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vrcOsc(obj?:VRCOSCSettings):VRCOSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? (obj || new VRCOSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vmcOsc(obj?:VMCOSCSettings):VMCOSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? (obj || new VMCOSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -modelSettings(obj?:ModelSettings):ModelSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? (obj || new ModelSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -tapDetectionSettings(obj?:TapDetectionSettings):TapDetectionSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? (obj || new TapDetectionSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -autoBoneSettings(obj?:AutoBoneSettings):AutoBoneSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? (obj || new AutoBoneSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -resetsSettings(obj?:ResetsSettings):ResetsSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? (obj || new ResetsSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -stayAligned(obj?:StayAlignedSettings):StayAlignedSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? (obj || new StayAlignedSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -hidSettings(obj?:HIDSettings):HIDSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? (obj || new HIDSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -timeout(obj?:TimeoutSettings):TimeoutSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 28); - return offset ? (obj || new TimeoutSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -velocitySettings(obj?:VelocitySettings):VelocitySettings|null { - const offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? (obj || new VelocitySettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vrm(obj?:VRMSettings):VRMSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 32); - return offset ? (obj || new VRMSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startChangeSettingsRequest(builder:flatbuffers.Builder) { - builder.startObject(15); -} - -static addSteamVrTrackers(builder:flatbuffers.Builder, steamVrTrackersOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, steamVrTrackersOffset, 0); -} - -static addFiltering(builder:flatbuffers.Builder, filteringOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, filteringOffset, 0); -} - -static addDriftCompensation(builder:flatbuffers.Builder, driftCompensationOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, driftCompensationOffset, 0); -} - -static addOscRouter(builder:flatbuffers.Builder, oscRouterOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, oscRouterOffset, 0); -} - -static addVrcOsc(builder:flatbuffers.Builder, vrcOscOffset:flatbuffers.Offset) { - builder.addFieldOffset(4, vrcOscOffset, 0); -} - -static addVmcOsc(builder:flatbuffers.Builder, vmcOscOffset:flatbuffers.Offset) { - builder.addFieldOffset(5, vmcOscOffset, 0); -} - -static addModelSettings(builder:flatbuffers.Builder, modelSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(6, modelSettingsOffset, 0); -} - -static addTapDetectionSettings(builder:flatbuffers.Builder, tapDetectionSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(7, tapDetectionSettingsOffset, 0); -} - -static addAutoBoneSettings(builder:flatbuffers.Builder, autoBoneSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(8, autoBoneSettingsOffset, 0); -} - -static addResetsSettings(builder:flatbuffers.Builder, resetsSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(9, resetsSettingsOffset, 0); -} - -static addStayAligned(builder:flatbuffers.Builder, stayAlignedOffset:flatbuffers.Offset) { - builder.addFieldOffset(10, stayAlignedOffset, 0); -} - -static addHidSettings(builder:flatbuffers.Builder, hidSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(11, hidSettingsOffset, 0); -} - -static addTimeout(builder:flatbuffers.Builder, timeoutOffset:flatbuffers.Offset) { - builder.addFieldOffset(12, timeoutOffset, 0); -} - -static addVelocitySettings(builder:flatbuffers.Builder, velocitySettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(13, velocitySettingsOffset, 0); -} - -static addVrm(builder:flatbuffers.Builder, vrmOffset:flatbuffers.Offset) { - builder.addFieldOffset(14, vrmOffset, 0); -} - -static endChangeSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - - -unpack(): ChangeSettingsRequestT { - return new ChangeSettingsRequestT( - (this.steamVrTrackers() !== null ? this.steamVrTrackers()!.unpack() : null), - (this.filtering() !== null ? this.filtering()!.unpack() : null), - (this.driftCompensation() !== null ? this.driftCompensation()!.unpack() : null), - (this.oscRouter() !== null ? this.oscRouter()!.unpack() : null), - (this.vrcOsc() !== null ? this.vrcOsc()!.unpack() : null), - (this.vmcOsc() !== null ? this.vmcOsc()!.unpack() : null), - (this.modelSettings() !== null ? this.modelSettings()!.unpack() : null), - (this.tapDetectionSettings() !== null ? this.tapDetectionSettings()!.unpack() : null), - (this.autoBoneSettings() !== null ? this.autoBoneSettings()!.unpack() : null), - (this.resetsSettings() !== null ? this.resetsSettings()!.unpack() : null), - (this.stayAligned() !== null ? this.stayAligned()!.unpack() : null), - (this.hidSettings() !== null ? this.hidSettings()!.unpack() : null), - (this.timeout() !== null ? this.timeout()!.unpack() : null), - (this.velocitySettings() !== null ? this.velocitySettings()!.unpack() : null), - (this.vrm() !== null ? this.vrm()!.unpack() : null) - ); -} - - -unpackTo(_o: ChangeSettingsRequestT): void { - _o.steamVrTrackers = (this.steamVrTrackers() !== null ? this.steamVrTrackers()!.unpack() : null); - _o.filtering = (this.filtering() !== null ? this.filtering()!.unpack() : null); - _o.driftCompensation = (this.driftCompensation() !== null ? this.driftCompensation()!.unpack() : null); - _o.oscRouter = (this.oscRouter() !== null ? this.oscRouter()!.unpack() : null); - _o.vrcOsc = (this.vrcOsc() !== null ? this.vrcOsc()!.unpack() : null); - _o.vmcOsc = (this.vmcOsc() !== null ? this.vmcOsc()!.unpack() : null); - _o.modelSettings = (this.modelSettings() !== null ? this.modelSettings()!.unpack() : null); - _o.tapDetectionSettings = (this.tapDetectionSettings() !== null ? this.tapDetectionSettings()!.unpack() : null); - _o.autoBoneSettings = (this.autoBoneSettings() !== null ? this.autoBoneSettings()!.unpack() : null); - _o.resetsSettings = (this.resetsSettings() !== null ? this.resetsSettings()!.unpack() : null); - _o.stayAligned = (this.stayAligned() !== null ? this.stayAligned()!.unpack() : null); - _o.hidSettings = (this.hidSettings() !== null ? this.hidSettings()!.unpack() : null); - _o.timeout = (this.timeout() !== null ? this.timeout()!.unpack() : null); - _o.velocitySettings = (this.velocitySettings() !== null ? this.velocitySettings()!.unpack() : null); - _o.vrm = (this.vrm() !== null ? this.vrm()!.unpack() : null); -} -} - -export class ChangeSettingsRequestT implements flatbuffers.IGeneratedObject { -constructor( - public steamVrTrackers: SteamVRTrackersSettingT|null = null, - public filtering: FilteringSettingsT|null = null, - public driftCompensation: DriftCompensationSettingsT|null = null, - public oscRouter: OSCRouterSettingsT|null = null, - public vrcOsc: VRCOSCSettingsT|null = null, - public vmcOsc: VMCOSCSettingsT|null = null, - public modelSettings: ModelSettingsT|null = null, - public tapDetectionSettings: TapDetectionSettingsT|null = null, - public autoBoneSettings: AutoBoneSettingsT|null = null, - public resetsSettings: ResetsSettingsT|null = null, - public stayAligned: StayAlignedSettingsT|null = null, - public hidSettings: HIDSettingsT|null = null, - public timeout: TimeoutSettingsT|null = null, - public velocitySettings: VelocitySettingsT|null = null, - public vrm: VRMSettingsT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const steamVrTrackers = (this.steamVrTrackers !== null ? this.steamVrTrackers!.pack(builder) : 0); - const filtering = (this.filtering !== null ? this.filtering!.pack(builder) : 0); - const driftCompensation = (this.driftCompensation !== null ? this.driftCompensation!.pack(builder) : 0); - const oscRouter = (this.oscRouter !== null ? this.oscRouter!.pack(builder) : 0); - const vrcOsc = (this.vrcOsc !== null ? this.vrcOsc!.pack(builder) : 0); - const vmcOsc = (this.vmcOsc !== null ? this.vmcOsc!.pack(builder) : 0); - const modelSettings = (this.modelSettings !== null ? this.modelSettings!.pack(builder) : 0); - const tapDetectionSettings = (this.tapDetectionSettings !== null ? this.tapDetectionSettings!.pack(builder) : 0); - const autoBoneSettings = (this.autoBoneSettings !== null ? this.autoBoneSettings!.pack(builder) : 0); - const resetsSettings = (this.resetsSettings !== null ? this.resetsSettings!.pack(builder) : 0); - const stayAligned = (this.stayAligned !== null ? this.stayAligned!.pack(builder) : 0); - const hidSettings = (this.hidSettings !== null ? this.hidSettings!.pack(builder) : 0); - const timeout = (this.timeout !== null ? this.timeout!.pack(builder) : 0); - const velocitySettings = (this.velocitySettings !== null ? this.velocitySettings!.pack(builder) : 0); - const vrm = (this.vrm !== null ? this.vrm!.pack(builder) : 0); - - ChangeSettingsRequest.startChangeSettingsRequest(builder); - ChangeSettingsRequest.addSteamVrTrackers(builder, steamVrTrackers); - ChangeSettingsRequest.addFiltering(builder, filtering); - ChangeSettingsRequest.addDriftCompensation(builder, driftCompensation); - ChangeSettingsRequest.addOscRouter(builder, oscRouter); - ChangeSettingsRequest.addVrcOsc(builder, vrcOsc); - ChangeSettingsRequest.addVmcOsc(builder, vmcOsc); - ChangeSettingsRequest.addModelSettings(builder, modelSettings); - ChangeSettingsRequest.addTapDetectionSettings(builder, tapDetectionSettings); - ChangeSettingsRequest.addAutoBoneSettings(builder, autoBoneSettings); - ChangeSettingsRequest.addResetsSettings(builder, resetsSettings); - ChangeSettingsRequest.addStayAligned(builder, stayAligned); - ChangeSettingsRequest.addHidSettings(builder, hidSettings); - ChangeSettingsRequest.addTimeout(builder, timeout); - ChangeSettingsRequest.addVelocitySettings(builder, velocitySettings); - ChangeSettingsRequest.addVrm(builder, vrm); - - return ChangeSettingsRequest.endChangeSettingsRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-config-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-config-request.ts deleted file mode 100644 index d46a8d5b6..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-config-request.ts +++ /dev/null @@ -1,87 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { SkeletonBone } from '../../solarxr-protocol/rpc/skeleton-bone.js'; - - -export class ChangeSkeletonConfigRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ChangeSkeletonConfigRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsChangeSkeletonConfigRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonConfigRequest):ChangeSkeletonConfigRequest { - return (obj || new ChangeSkeletonConfigRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsChangeSkeletonConfigRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonConfigRequest):ChangeSkeletonConfigRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ChangeSkeletonConfigRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -bone():SkeletonBone { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : SkeletonBone.NONE; -} - -value():number { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; -} - -static startChangeSkeletonConfigRequest(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addBone(builder:flatbuffers.Builder, bone:SkeletonBone) { - builder.addFieldInt8(0, bone, SkeletonBone.NONE); -} - -static addValue(builder:flatbuffers.Builder, value:number) { - builder.addFieldFloat32(1, value, 0.0); -} - -static endChangeSkeletonConfigRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createChangeSkeletonConfigRequest(builder:flatbuffers.Builder, bone:SkeletonBone, value:number):flatbuffers.Offset { - ChangeSkeletonConfigRequest.startChangeSkeletonConfigRequest(builder); - ChangeSkeletonConfigRequest.addBone(builder, bone); - ChangeSkeletonConfigRequest.addValue(builder, value); - return ChangeSkeletonConfigRequest.endChangeSkeletonConfigRequest(builder); -} - -unpack(): ChangeSkeletonConfigRequestT { - return new ChangeSkeletonConfigRequestT( - this.bone(), - this.value() - ); -} - - -unpackTo(_o: ChangeSkeletonConfigRequestT): void { - _o.bone = this.bone(); - _o.value = this.value(); -} -} - -export class ChangeSkeletonConfigRequestT implements flatbuffers.IGeneratedObject { -constructor( - public bone: SkeletonBone = SkeletonBone.NONE, - public value: number = 0.0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return ChangeSkeletonConfigRequest.createChangeSkeletonConfigRequest(builder, - this.bone, - this.value - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-proportions-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-proportions-request.ts new file mode 100644 index 000000000..88868e105 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-proportions-request.ts @@ -0,0 +1,87 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { SkeletonBone } from '../../solarxr-protocol/rpc/skeleton-bone.js'; + + +export class ChangeSkeletonProportionsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeSkeletonProportionsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeSkeletonProportionsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonProportionsRequest):ChangeSkeletonProportionsRequest { + return (obj || new ChangeSkeletonProportionsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeSkeletonProportionsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonProportionsRequest):ChangeSkeletonProportionsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeSkeletonProportionsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +bone():SkeletonBone { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : SkeletonBone.NONE; +} + +value():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +static startChangeSkeletonProportionsRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addBone(builder:flatbuffers.Builder, bone:SkeletonBone) { + builder.addFieldInt8(0, bone, SkeletonBone.NONE); +} + +static addValue(builder:flatbuffers.Builder, value:number) { + builder.addFieldFloat32(1, value, 0.0); +} + +static endChangeSkeletonProportionsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeSkeletonProportionsRequest(builder:flatbuffers.Builder, bone:SkeletonBone, value:number):flatbuffers.Offset { + ChangeSkeletonProportionsRequest.startChangeSkeletonProportionsRequest(builder); + ChangeSkeletonProportionsRequest.addBone(builder, bone); + ChangeSkeletonProportionsRequest.addValue(builder, value); + return ChangeSkeletonProportionsRequest.endChangeSkeletonProportionsRequest(builder); +} + +unpack(): ChangeSkeletonProportionsRequestT { + return new ChangeSkeletonProportionsRequestT( + this.bone(), + this.value() + ); +} + + +unpackTo(_o: ChangeSkeletonProportionsRequestT): void { + _o.bone = this.bone(); + _o.value = this.value(); +} +} + +export class ChangeSkeletonProportionsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public bone: SkeletonBone = SkeletonBone.NONE, + public value: number = 0.0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ChangeSkeletonProportionsRequest.createChangeSkeletonProportionsRequest(builder, + this.bone, + this.value + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-settings-request.ts new file mode 100644 index 000000000..20af1e5b5 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-skeleton-settings-request.ts @@ -0,0 +1,116 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { SkeletonFiltering, SkeletonFilteringT } from '../../solarxr-protocol/rpc/skeleton-filtering.js'; +import { SkeletonHeight, SkeletonHeightT } from '../../solarxr-protocol/rpc/skeleton-height.js'; +import { SkeletonRatios, SkeletonRatiosT } from '../../solarxr-protocol/rpc/skeleton-ratios.js'; +import { SkeletonToggles, SkeletonTogglesT } from '../../solarxr-protocol/rpc/skeleton-toggles.js'; + + +export class ChangeSkeletonSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeSkeletonSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeSkeletonSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonSettingsRequest):ChangeSkeletonSettingsRequest { + return (obj || new ChangeSkeletonSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeSkeletonSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeSkeletonSettingsRequest):ChangeSkeletonSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeSkeletonSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +toggles(obj?:SkeletonToggles):SkeletonToggles|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new SkeletonToggles()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +ratios(obj?:SkeletonRatios):SkeletonRatios|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new SkeletonRatios()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +filtering(obj?:SkeletonFiltering):SkeletonFiltering|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? (obj || new SkeletonFiltering()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +skeletonHeight(obj?:SkeletonHeight):SkeletonHeight|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? (obj || new SkeletonHeight()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +static startChangeSkeletonSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(4); +} + +static addToggles(builder:flatbuffers.Builder, togglesOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, togglesOffset, 0); +} + +static addRatios(builder:flatbuffers.Builder, ratiosOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, ratiosOffset, 0); +} + +static addFiltering(builder:flatbuffers.Builder, filteringOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, filteringOffset, 0); +} + +static addSkeletonHeight(builder:flatbuffers.Builder, skeletonHeightOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, skeletonHeightOffset, 0); +} + +static endChangeSkeletonSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): ChangeSkeletonSettingsRequestT { + return new ChangeSkeletonSettingsRequestT( + (this.toggles() !== null ? this.toggles()!.unpack() : null), + (this.ratios() !== null ? this.ratios()!.unpack() : null), + (this.filtering() !== null ? this.filtering()!.unpack() : null), + (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null) + ); +} + + +unpackTo(_o: ChangeSkeletonSettingsRequestT): void { + _o.toggles = (this.toggles() !== null ? this.toggles()!.unpack() : null); + _o.ratios = (this.ratios() !== null ? this.ratios()!.unpack() : null); + _o.filtering = (this.filtering() !== null ? this.filtering()!.unpack() : null); + _o.skeletonHeight = (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null); +} +} + +export class ChangeSkeletonSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public toggles: SkeletonTogglesT|null = null, + public ratios: SkeletonRatiosT|null = null, + public filtering: SkeletonFilteringT|null = null, + public skeletonHeight: SkeletonHeightT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const toggles = (this.toggles !== null ? this.toggles!.pack(builder) : 0); + const ratios = (this.ratios !== null ? this.ratios!.pack(builder) : 0); + const filtering = (this.filtering !== null ? this.filtering!.pack(builder) : 0); + const skeletonHeight = (this.skeletonHeight !== null ? this.skeletonHeight!.pack(builder) : 0); + + ChangeSkeletonSettingsRequest.startChangeSkeletonSettingsRequest(builder); + ChangeSkeletonSettingsRequest.addToggles(builder, toggles); + ChangeSkeletonSettingsRequest.addRatios(builder, ratios); + ChangeSkeletonSettingsRequest.addFiltering(builder, filtering); + ChangeSkeletonSettingsRequest.addSkeletonHeight(builder, skeletonHeight); + + return ChangeSkeletonSettingsRequest.endChangeSkeletonSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-stay-aligned-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-stay-aligned-settings-request.ts new file mode 100644 index 000000000..b040ac88b --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-stay-aligned-settings-request.ts @@ -0,0 +1,240 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ChangeStayAlignedSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeStayAlignedSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeStayAlignedSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeStayAlignedSettingsRequest):ChangeStayAlignedSettingsRequest { + return (obj || new ChangeStayAlignedSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeStayAlignedSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeStayAlignedSettingsRequest):ChangeStayAlignedSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeStayAlignedSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +standingEnabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +standingUpperLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +standingLowerLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +standingFootAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +sittingEnabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +sittingUpperLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +sittingLowerLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +sittingFootAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +flatEnabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +flatUpperLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +flatLowerLegAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 26); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +flatFootAngle():number { + const offset = this.bb!.__offset(this.bb_pos, 28); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +static startChangeStayAlignedSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(13); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addStandingEnabled(builder:flatbuffers.Builder, standingEnabled:boolean) { + builder.addFieldInt8(1, +standingEnabled, +false); +} + +static addStandingUpperLegAngle(builder:flatbuffers.Builder, standingUpperLegAngle:number) { + builder.addFieldFloat32(2, standingUpperLegAngle, 0.0); +} + +static addStandingLowerLegAngle(builder:flatbuffers.Builder, standingLowerLegAngle:number) { + builder.addFieldFloat32(3, standingLowerLegAngle, 0.0); +} + +static addStandingFootAngle(builder:flatbuffers.Builder, standingFootAngle:number) { + builder.addFieldFloat32(4, standingFootAngle, 0.0); +} + +static addSittingEnabled(builder:flatbuffers.Builder, sittingEnabled:boolean) { + builder.addFieldInt8(5, +sittingEnabled, +false); +} + +static addSittingUpperLegAngle(builder:flatbuffers.Builder, sittingUpperLegAngle:number) { + builder.addFieldFloat32(6, sittingUpperLegAngle, 0.0); +} + +static addSittingLowerLegAngle(builder:flatbuffers.Builder, sittingLowerLegAngle:number) { + builder.addFieldFloat32(7, sittingLowerLegAngle, 0.0); +} + +static addSittingFootAngle(builder:flatbuffers.Builder, sittingFootAngle:number) { + builder.addFieldFloat32(8, sittingFootAngle, 0.0); +} + +static addFlatEnabled(builder:flatbuffers.Builder, flatEnabled:boolean) { + builder.addFieldInt8(9, +flatEnabled, +false); +} + +static addFlatUpperLegAngle(builder:flatbuffers.Builder, flatUpperLegAngle:number) { + builder.addFieldFloat32(10, flatUpperLegAngle, 0.0); +} + +static addFlatLowerLegAngle(builder:flatbuffers.Builder, flatLowerLegAngle:number) { + builder.addFieldFloat32(11, flatLowerLegAngle, 0.0); +} + +static addFlatFootAngle(builder:flatbuffers.Builder, flatFootAngle:number) { + builder.addFieldFloat32(12, flatFootAngle, 0.0); +} + +static endChangeStayAlignedSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeStayAlignedSettingsRequest(builder:flatbuffers.Builder, enabled:boolean, standingEnabled:boolean, standingUpperLegAngle:number, standingLowerLegAngle:number, standingFootAngle:number, sittingEnabled:boolean, sittingUpperLegAngle:number, sittingLowerLegAngle:number, sittingFootAngle:number, flatEnabled:boolean, flatUpperLegAngle:number, flatLowerLegAngle:number, flatFootAngle:number):flatbuffers.Offset { + ChangeStayAlignedSettingsRequest.startChangeStayAlignedSettingsRequest(builder); + ChangeStayAlignedSettingsRequest.addEnabled(builder, enabled); + ChangeStayAlignedSettingsRequest.addStandingEnabled(builder, standingEnabled); + ChangeStayAlignedSettingsRequest.addStandingUpperLegAngle(builder, standingUpperLegAngle); + ChangeStayAlignedSettingsRequest.addStandingLowerLegAngle(builder, standingLowerLegAngle); + ChangeStayAlignedSettingsRequest.addStandingFootAngle(builder, standingFootAngle); + ChangeStayAlignedSettingsRequest.addSittingEnabled(builder, sittingEnabled); + ChangeStayAlignedSettingsRequest.addSittingUpperLegAngle(builder, sittingUpperLegAngle); + ChangeStayAlignedSettingsRequest.addSittingLowerLegAngle(builder, sittingLowerLegAngle); + ChangeStayAlignedSettingsRequest.addSittingFootAngle(builder, sittingFootAngle); + ChangeStayAlignedSettingsRequest.addFlatEnabled(builder, flatEnabled); + ChangeStayAlignedSettingsRequest.addFlatUpperLegAngle(builder, flatUpperLegAngle); + ChangeStayAlignedSettingsRequest.addFlatLowerLegAngle(builder, flatLowerLegAngle); + ChangeStayAlignedSettingsRequest.addFlatFootAngle(builder, flatFootAngle); + return ChangeStayAlignedSettingsRequest.endChangeStayAlignedSettingsRequest(builder); +} + +unpack(): ChangeStayAlignedSettingsRequestT { + return new ChangeStayAlignedSettingsRequestT( + this.enabled(), + this.standingEnabled(), + this.standingUpperLegAngle(), + this.standingLowerLegAngle(), + this.standingFootAngle(), + this.sittingEnabled(), + this.sittingUpperLegAngle(), + this.sittingLowerLegAngle(), + this.sittingFootAngle(), + this.flatEnabled(), + this.flatUpperLegAngle(), + this.flatLowerLegAngle(), + this.flatFootAngle() + ); +} + + +unpackTo(_o: ChangeStayAlignedSettingsRequestT): void { + _o.enabled = this.enabled(); + _o.standingEnabled = this.standingEnabled(); + _o.standingUpperLegAngle = this.standingUpperLegAngle(); + _o.standingLowerLegAngle = this.standingLowerLegAngle(); + _o.standingFootAngle = this.standingFootAngle(); + _o.sittingEnabled = this.sittingEnabled(); + _o.sittingUpperLegAngle = this.sittingUpperLegAngle(); + _o.sittingLowerLegAngle = this.sittingLowerLegAngle(); + _o.sittingFootAngle = this.sittingFootAngle(); + _o.flatEnabled = this.flatEnabled(); + _o.flatUpperLegAngle = this.flatUpperLegAngle(); + _o.flatLowerLegAngle = this.flatLowerLegAngle(); + _o.flatFootAngle = this.flatFootAngle(); +} +} + +export class ChangeStayAlignedSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public standingEnabled: boolean = false, + public standingUpperLegAngle: number = 0.0, + public standingLowerLegAngle: number = 0.0, + public standingFootAngle: number = 0.0, + public sittingEnabled: boolean = false, + public sittingUpperLegAngle: number = 0.0, + public sittingLowerLegAngle: number = 0.0, + public sittingFootAngle: number = 0.0, + public flatEnabled: boolean = false, + public flatUpperLegAngle: number = 0.0, + public flatLowerLegAngle: number = 0.0, + public flatFootAngle: number = 0.0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ChangeStayAlignedSettingsRequest.createChangeStayAlignedSettingsRequest(builder, + this.enabled, + this.standingEnabled, + this.standingUpperLegAngle, + this.standingLowerLegAngle, + this.standingFootAngle, + this.sittingEnabled, + this.sittingUpperLegAngle, + this.sittingLowerLegAngle, + this.sittingFootAngle, + this.flatEnabled, + this.flatUpperLegAngle, + this.flatLowerLegAngle, + this.flatFootAngle + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-tap-detection-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-tap-detection-settings-request.ts new file mode 100644 index 000000000..66c5393c9 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-tap-detection-settings-request.ts @@ -0,0 +1,254 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; + + +export class ChangeTapDetectionSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeTapDetectionSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeTapDetectionSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeTapDetectionSettingsRequest):ChangeTapDetectionSettingsRequest { + return (obj || new ChangeTapDetectionSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeTapDetectionSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeTapDetectionSettingsRequest):ChangeTapDetectionSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeTapDetectionSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +fullResetDelay():number|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +fullResetEnabled():boolean|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +} + +fullResetTaps():number|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +yawResetDelay():number|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +yawResetEnabled():boolean|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +} + +yawResetTaps():number|null { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +mountingResetDelay():number|null { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +mountingResetEnabled():boolean|null { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +} + +mountingResetTaps():number|null { + const offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +numberTrackersOverThreshold():number|null { + const offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +yawResetTracker():BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +fullResetTracker():BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 26); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +mountingResetTracker():BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 28); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +static startChangeTapDetectionSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(13); +} + +static addFullResetDelay(builder:flatbuffers.Builder, fullResetDelay:number) { + builder.addFieldFloat32(0, fullResetDelay, 0); +} + +static addFullResetEnabled(builder:flatbuffers.Builder, fullResetEnabled:boolean) { + builder.addFieldInt8(1, +fullResetEnabled, 0); +} + +static addFullResetTaps(builder:flatbuffers.Builder, fullResetTaps:number) { + builder.addFieldInt8(2, fullResetTaps, 0); +} + +static addYawResetDelay(builder:flatbuffers.Builder, yawResetDelay:number) { + builder.addFieldFloat32(3, yawResetDelay, 0); +} + +static addYawResetEnabled(builder:flatbuffers.Builder, yawResetEnabled:boolean) { + builder.addFieldInt8(4, +yawResetEnabled, 0); +} + +static addYawResetTaps(builder:flatbuffers.Builder, yawResetTaps:number) { + builder.addFieldInt8(5, yawResetTaps, 0); +} + +static addMountingResetDelay(builder:flatbuffers.Builder, mountingResetDelay:number) { + builder.addFieldFloat32(6, mountingResetDelay, 0); +} + +static addMountingResetEnabled(builder:flatbuffers.Builder, mountingResetEnabled:boolean) { + builder.addFieldInt8(7, +mountingResetEnabled, 0); +} + +static addMountingResetTaps(builder:flatbuffers.Builder, mountingResetTaps:number) { + builder.addFieldInt8(8, mountingResetTaps, 0); +} + +static addNumberTrackersOverThreshold(builder:flatbuffers.Builder, numberTrackersOverThreshold:number) { + builder.addFieldInt8(9, numberTrackersOverThreshold, 0); +} + +static addYawResetTracker(builder:flatbuffers.Builder, yawResetTracker:BodyPart) { + builder.addFieldInt8(10, yawResetTracker, 0); +} + +static addFullResetTracker(builder:flatbuffers.Builder, fullResetTracker:BodyPart) { + builder.addFieldInt8(11, fullResetTracker, 0); +} + +static addMountingResetTracker(builder:flatbuffers.Builder, mountingResetTracker:BodyPart) { + builder.addFieldInt8(12, mountingResetTracker, 0); +} + +static endChangeTapDetectionSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeTapDetectionSettingsRequest(builder:flatbuffers.Builder, fullResetDelay:number|null, fullResetEnabled:boolean|null, fullResetTaps:number|null, yawResetDelay:number|null, yawResetEnabled:boolean|null, yawResetTaps:number|null, mountingResetDelay:number|null, mountingResetEnabled:boolean|null, mountingResetTaps:number|null, numberTrackersOverThreshold:number|null, yawResetTracker:BodyPart|null, fullResetTracker:BodyPart|null, mountingResetTracker:BodyPart|null):flatbuffers.Offset { + ChangeTapDetectionSettingsRequest.startChangeTapDetectionSettingsRequest(builder); + if (fullResetDelay !== null) + ChangeTapDetectionSettingsRequest.addFullResetDelay(builder, fullResetDelay); + if (fullResetEnabled !== null) + ChangeTapDetectionSettingsRequest.addFullResetEnabled(builder, fullResetEnabled); + if (fullResetTaps !== null) + ChangeTapDetectionSettingsRequest.addFullResetTaps(builder, fullResetTaps); + if (yawResetDelay !== null) + ChangeTapDetectionSettingsRequest.addYawResetDelay(builder, yawResetDelay); + if (yawResetEnabled !== null) + ChangeTapDetectionSettingsRequest.addYawResetEnabled(builder, yawResetEnabled); + if (yawResetTaps !== null) + ChangeTapDetectionSettingsRequest.addYawResetTaps(builder, yawResetTaps); + if (mountingResetDelay !== null) + ChangeTapDetectionSettingsRequest.addMountingResetDelay(builder, mountingResetDelay); + if (mountingResetEnabled !== null) + ChangeTapDetectionSettingsRequest.addMountingResetEnabled(builder, mountingResetEnabled); + if (mountingResetTaps !== null) + ChangeTapDetectionSettingsRequest.addMountingResetTaps(builder, mountingResetTaps); + if (numberTrackersOverThreshold !== null) + ChangeTapDetectionSettingsRequest.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); + if (yawResetTracker !== null) + ChangeTapDetectionSettingsRequest.addYawResetTracker(builder, yawResetTracker); + if (fullResetTracker !== null) + ChangeTapDetectionSettingsRequest.addFullResetTracker(builder, fullResetTracker); + if (mountingResetTracker !== null) + ChangeTapDetectionSettingsRequest.addMountingResetTracker(builder, mountingResetTracker); + return ChangeTapDetectionSettingsRequest.endChangeTapDetectionSettingsRequest(builder); +} + +unpack(): ChangeTapDetectionSettingsRequestT { + return new ChangeTapDetectionSettingsRequestT( + this.fullResetDelay(), + this.fullResetEnabled(), + this.fullResetTaps(), + this.yawResetDelay(), + this.yawResetEnabled(), + this.yawResetTaps(), + this.mountingResetDelay(), + this.mountingResetEnabled(), + this.mountingResetTaps(), + this.numberTrackersOverThreshold(), + this.yawResetTracker(), + this.fullResetTracker(), + this.mountingResetTracker() + ); +} + + +unpackTo(_o: ChangeTapDetectionSettingsRequestT): void { + _o.fullResetDelay = this.fullResetDelay(); + _o.fullResetEnabled = this.fullResetEnabled(); + _o.fullResetTaps = this.fullResetTaps(); + _o.yawResetDelay = this.yawResetDelay(); + _o.yawResetEnabled = this.yawResetEnabled(); + _o.yawResetTaps = this.yawResetTaps(); + _o.mountingResetDelay = this.mountingResetDelay(); + _o.mountingResetEnabled = this.mountingResetEnabled(); + _o.mountingResetTaps = this.mountingResetTaps(); + _o.numberTrackersOverThreshold = this.numberTrackersOverThreshold(); + _o.yawResetTracker = this.yawResetTracker(); + _o.fullResetTracker = this.fullResetTracker(); + _o.mountingResetTracker = this.mountingResetTracker(); +} +} + +export class ChangeTapDetectionSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public fullResetDelay: number|null = null, + public fullResetEnabled: boolean|null = null, + public fullResetTaps: number|null = null, + public yawResetDelay: number|null = null, + public yawResetEnabled: boolean|null = null, + public yawResetTaps: number|null = null, + public mountingResetDelay: number|null = null, + public mountingResetEnabled: boolean|null = null, + public mountingResetTaps: number|null = null, + public numberTrackersOverThreshold: number|null = null, + public yawResetTracker: BodyPart|null = null, + public fullResetTracker: BodyPart|null = null, + public mountingResetTracker: BodyPart|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ChangeTapDetectionSettingsRequest.createChangeTapDetectionSettingsRequest(builder, + this.fullResetDelay, + this.fullResetEnabled, + this.fullResetTaps, + this.yawResetDelay, + this.yawResetEnabled, + this.yawResetTaps, + this.mountingResetDelay, + this.mountingResetEnabled, + this.mountingResetTaps, + this.numberTrackersOverThreshold, + this.yawResetTracker, + this.fullResetTracker, + this.mountingResetTracker + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-vmcoscsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-vmcoscsettings-request.ts new file mode 100644 index 000000000..6c5429892 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-vmcoscsettings-request.ts @@ -0,0 +1,146 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ChangeVMCOSCSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeVMCOSCSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeVMCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVMCOSCSettingsRequest):ChangeVMCOSCSettingsRequest { + return (obj || new ChangeVMCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeVMCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVMCOSCSettingsRequest):ChangeVMCOSCSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeVMCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +portIn():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +portOut():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +address():string|null +address(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +address(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +anchorHip():boolean { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +mirrorTracking():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startChangeVMCOSCSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(6); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addPortIn(builder:flatbuffers.Builder, portIn:number) { + builder.addFieldInt16(1, portIn, 0); +} + +static addPortOut(builder:flatbuffers.Builder, portOut:number) { + builder.addFieldInt16(2, portOut, 0); +} + +static addAddress(builder:flatbuffers.Builder, addressOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, addressOffset, 0); +} + +static addAnchorHip(builder:flatbuffers.Builder, anchorHip:boolean) { + builder.addFieldInt8(4, +anchorHip, +false); +} + +static addMirrorTracking(builder:flatbuffers.Builder, mirrorTracking:boolean) { + builder.addFieldInt8(5, +mirrorTracking, +false); +} + +static endChangeVMCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeVMCOSCSettingsRequest(builder:flatbuffers.Builder, enabled:boolean, portIn:number, portOut:number, addressOffset:flatbuffers.Offset, anchorHip:boolean, mirrorTracking:boolean):flatbuffers.Offset { + ChangeVMCOSCSettingsRequest.startChangeVMCOSCSettingsRequest(builder); + ChangeVMCOSCSettingsRequest.addEnabled(builder, enabled); + ChangeVMCOSCSettingsRequest.addPortIn(builder, portIn); + ChangeVMCOSCSettingsRequest.addPortOut(builder, portOut); + ChangeVMCOSCSettingsRequest.addAddress(builder, addressOffset); + ChangeVMCOSCSettingsRequest.addAnchorHip(builder, anchorHip); + ChangeVMCOSCSettingsRequest.addMirrorTracking(builder, mirrorTracking); + return ChangeVMCOSCSettingsRequest.endChangeVMCOSCSettingsRequest(builder); +} + +unpack(): ChangeVMCOSCSettingsRequestT { + return new ChangeVMCOSCSettingsRequestT( + this.enabled(), + this.portIn(), + this.portOut(), + this.address(), + this.anchorHip(), + this.mirrorTracking() + ); +} + + +unpackTo(_o: ChangeVMCOSCSettingsRequestT): void { + _o.enabled = this.enabled(); + _o.portIn = this.portIn(); + _o.portOut = this.portOut(); + _o.address = this.address(); + _o.anchorHip = this.anchorHip(); + _o.mirrorTracking = this.mirrorTracking(); +} +} + +export class ChangeVMCOSCSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public portIn: number = 0, + public portOut: number = 0, + public address: string|Uint8Array|null = null, + public anchorHip: boolean = false, + public mirrorTracking: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const address = (this.address !== null ? builder.createString(this.address!) : 0); + + return ChangeVMCOSCSettingsRequest.createChangeVMCOSCSettingsRequest(builder, + this.enabled, + this.portIn, + this.portOut, + address, + this.anchorHip, + this.mirrorTracking + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-vrcoscsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-vrcoscsettings-request.ts new file mode 100644 index 000000000..6a03f202f --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-vrcoscsettings-request.ts @@ -0,0 +1,84 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { VRCOSCNetworkSettings, VRCOSCNetworkSettingsT } from '../../solarxr-protocol/rpc/vrcoscnetwork-settings.js'; + + +export class ChangeVRCOSCSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeVRCOSCSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeVRCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVRCOSCSettingsRequest):ChangeVRCOSCSettingsRequest { + return (obj || new ChangeVRCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeVRCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVRCOSCSettingsRequest):ChangeVRCOSCSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeVRCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +manualNetwork(obj?:VRCOSCNetworkSettings):VRCOSCNetworkSettings|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new VRCOSCNetworkSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +static startChangeVRCOSCSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addManualNetwork(builder:flatbuffers.Builder, manualNetworkOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, manualNetworkOffset, 0); +} + +static endChangeVRCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): ChangeVRCOSCSettingsRequestT { + return new ChangeVRCOSCSettingsRequestT( + this.enabled(), + (this.manualNetwork() !== null ? this.manualNetwork()!.unpack() : null) + ); +} + + +unpackTo(_o: ChangeVRCOSCSettingsRequestT): void { + _o.enabled = this.enabled(); + _o.manualNetwork = (this.manualNetwork() !== null ? this.manualNetwork()!.unpack() : null); +} +} + +export class ChangeVRCOSCSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public manualNetwork: VRCOSCNetworkSettingsT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const manualNetwork = (this.manualNetwork !== null ? this.manualNetwork!.pack(builder) : 0); + + ChangeVRCOSCSettingsRequest.startChangeVRCOSCSettingsRequest(builder); + ChangeVRCOSCSettingsRequest.addEnabled(builder, this.enabled); + ChangeVRCOSCSettingsRequest.addManualNetwork(builder, manualNetwork); + + return ChangeVRCOSCSettingsRequest.endChangeVRCOSCSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-vrmsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-vrmsettings-request.ts new file mode 100644 index 000000000..887ef6aaa --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-vrmsettings-request.ts @@ -0,0 +1,76 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ChangeVRMSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeVRMSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeVRMSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVRMSettingsRequest):ChangeVRMSettingsRequest { + return (obj || new ChangeVRMSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeVRMSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeVRMSettingsRequest):ChangeVRMSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeVRMSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +vrmJson():string|null +vrmJson(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +vrmJson(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startChangeVRMSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addVrmJson(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, vrmJsonOffset, 0); +} + +static endChangeVRMSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeVRMSettingsRequest(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset):flatbuffers.Offset { + ChangeVRMSettingsRequest.startChangeVRMSettingsRequest(builder); + ChangeVRMSettingsRequest.addVrmJson(builder, vrmJsonOffset); + return ChangeVRMSettingsRequest.endChangeVRMSettingsRequest(builder); +} + +unpack(): ChangeVRMSettingsRequestT { + return new ChangeVRMSettingsRequestT( + this.vrmJson() + ); +} + + +unpackTo(_o: ChangeVRMSettingsRequestT): void { + _o.vrmJson = this.vrmJson(); +} +} + +export class ChangeVRMSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor( + public vrmJson: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const vrmJson = (this.vrmJson !== null ? builder.createString(this.vrmJson!) : 0); + + return ChangeVRMSettingsRequest.createChangeVRMSettingsRequest(builder, + vrmJson + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/clear-drift-compensation-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/clear-drift-compensation-request.ts deleted file mode 100644 index dd4f7a1c9..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/clear-drift-compensation-request.ts +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class ClearDriftCompensationRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ClearDriftCompensationRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsClearDriftCompensationRequest(bb:flatbuffers.ByteBuffer, obj?:ClearDriftCompensationRequest):ClearDriftCompensationRequest { - return (obj || new ClearDriftCompensationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsClearDriftCompensationRequest(bb:flatbuffers.ByteBuffer, obj?:ClearDriftCompensationRequest):ClearDriftCompensationRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ClearDriftCompensationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startClearDriftCompensationRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endClearDriftCompensationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createClearDriftCompensationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - ClearDriftCompensationRequest.startClearDriftCompensationRequest(builder); - return ClearDriftCompensationRequest.endClearDriftCompensationRequest(builder); -} - -unpack(): ClearDriftCompensationRequestT { - return new ClearDriftCompensationRequestT(); -} - - -unpackTo(_o: ClearDriftCompensationRequestT): void {} -} - -export class ClearDriftCompensationRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return ClearDriftCompensationRequest.createClearDriftCompensationRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/complete-stay-aligned-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/complete-stay-aligned-response.ts new file mode 100644 index 000000000..7eaaceda1 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/complete-stay-aligned-response.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class CompleteStayAlignedResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):CompleteStayAlignedResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsCompleteStayAlignedResponse(bb:flatbuffers.ByteBuffer, obj?:CompleteStayAlignedResponse):CompleteStayAlignedResponse { + return (obj || new CompleteStayAlignedResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsCompleteStayAlignedResponse(bb:flatbuffers.ByteBuffer, obj?:CompleteStayAlignedResponse):CompleteStayAlignedResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new CompleteStayAlignedResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startCompleteStayAlignedResponse(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endCompleteStayAlignedResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createCompleteStayAlignedResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + CompleteStayAlignedResponse.startCompleteStayAlignedResponse(builder); + return CompleteStayAlignedResponse.endCompleteStayAlignedResponse(builder); +} + +unpack(): CompleteStayAlignedResponseT { + return new CompleteStayAlignedResponseT(); +} + + +unpackTo(_o: CompleteStayAlignedResponseT): void {} +} + +export class CompleteStayAlignedResponseT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return CompleteStayAlignedResponse.createCompleteStayAlignedResponse(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/computer-directory.ts b/protocol/typescript/src/solarxr-protocol/rpc/computer-directory.ts index bdd6295a7..66dc1a2ba 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/computer-directory.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/computer-directory.ts @@ -4,5 +4,5 @@ * Common folders often used in computers for storing files */ export enum ComputerDirectory { - Documents = 0 + DOCUMENTS = 0 } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/drift-compensation-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/drift-compensation-settings.ts deleted file mode 100644 index 38efd7edc..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/drift-compensation-settings.ts +++ /dev/null @@ -1,123 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * Settings related to IMU yaw drift compensation - */ -export class DriftCompensationSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):DriftCompensationSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsDriftCompensationSettings(bb:flatbuffers.ByteBuffer, obj?:DriftCompensationSettings):DriftCompensationSettings { - return (obj || new DriftCompensationSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsDriftCompensationSettings(bb:flatbuffers.ByteBuffer, obj?:DriftCompensationSettings):DriftCompensationSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new DriftCompensationSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -enabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -prediction():boolean { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -/** - * 0 to 1. A higher value results in more yaw drift compensation - */ -amount():number { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; -} - -/** - * Number of previous resets to take into account when calculating yaw drift - */ -maxResets():number { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; -} - -static startDriftCompensationSettings(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { - builder.addFieldInt8(0, +enabled, +false); -} - -static addPrediction(builder:flatbuffers.Builder, prediction:boolean) { - builder.addFieldInt8(1, +prediction, +false); -} - -static addAmount(builder:flatbuffers.Builder, amount:number) { - builder.addFieldFloat32(2, amount, 0.0); -} - -static addMaxResets(builder:flatbuffers.Builder, maxResets:number) { - builder.addFieldInt16(3, maxResets, 0); -} - -static endDriftCompensationSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createDriftCompensationSettings(builder:flatbuffers.Builder, enabled:boolean, prediction:boolean, amount:number, maxResets:number):flatbuffers.Offset { - DriftCompensationSettings.startDriftCompensationSettings(builder); - DriftCompensationSettings.addEnabled(builder, enabled); - DriftCompensationSettings.addPrediction(builder, prediction); - DriftCompensationSettings.addAmount(builder, amount); - DriftCompensationSettings.addMaxResets(builder, maxResets); - return DriftCompensationSettings.endDriftCompensationSettings(builder); -} - -unpack(): DriftCompensationSettingsT { - return new DriftCompensationSettingsT( - this.enabled(), - this.prediction(), - this.amount(), - this.maxResets() - ); -} - - -unpackTo(_o: DriftCompensationSettingsT): void { - _o.enabled = this.enabled(); - _o.prediction = this.prediction(); - _o.amount = this.amount(); - _o.maxResets = this.maxResets(); -} -} - -export class DriftCompensationSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public enabled: boolean = false, - public prediction: boolean = false, - public amount: number = 0.0, - public maxResets: number = 0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return DriftCompensationSettings.createDriftCompensationSettings(builder, - this.enabled, - this.prediction, - this.amount, - this.maxResets - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/datatypes/filtering-type.ts b/protocol/typescript/src/solarxr-protocol/rpc/filtering-type.ts similarity index 71% rename from protocol/typescript/src/solarxr-protocol/datatypes/filtering-type.ts rename to protocol/typescript/src/solarxr-protocol/rpc/filtering-type.ts index 06d506b8e..889b14d7e 100644 --- a/protocol/typescript/src/solarxr-protocol/datatypes/filtering-type.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/filtering-type.ts @@ -1,8 +1,5 @@ // automatically generated by the FlatBuffers compiler, do not modify -/** - * Used for filtering tracker rotations in software - */ export enum FilteringType { NONE = 0, SMOOTHING = 1, diff --git a/protocol/typescript/src/solarxr-protocol/rpc/firmware-device-id-table.ts b/protocol/typescript/src/solarxr-protocol/rpc/firmware-device-id-table.ts new file mode 100644 index 000000000..eba144d5a --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/firmware-device-id-table.ts @@ -0,0 +1,72 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class FirmwareDeviceIdTable implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):FirmwareDeviceIdTable { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsFirmwareDeviceIdTable(bb:flatbuffers.ByteBuffer, obj?:FirmwareDeviceIdTable):FirmwareDeviceIdTable { + return (obj || new FirmwareDeviceIdTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsFirmwareDeviceIdTable(bb:flatbuffers.ByteBuffer, obj?:FirmwareDeviceIdTable):FirmwareDeviceIdTable { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new FirmwareDeviceIdTable()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +id():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +static startFirmwareDeviceIdTable(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addId(builder:flatbuffers.Builder, id:number) { + builder.addFieldInt16(0, id, 0); +} + +static endFirmwareDeviceIdTable(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createFirmwareDeviceIdTable(builder:flatbuffers.Builder, id:number):flatbuffers.Offset { + FirmwareDeviceIdTable.startFirmwareDeviceIdTable(builder); + FirmwareDeviceIdTable.addId(builder, id); + return FirmwareDeviceIdTable.endFirmwareDeviceIdTable(builder); +} + +unpack(): FirmwareDeviceIdTableT { + return new FirmwareDeviceIdTableT( + this.id() + ); +} + + +unpackTo(_o: FirmwareDeviceIdTableT): void { + _o.id = this.id(); +} +} + +export class FirmwareDeviceIdTableT implements flatbuffers.IGeneratedObject { +constructor( + public id: number = 0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return FirmwareDeviceIdTable.createFirmwareDeviceIdTable(builder, + this.id + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-device-id.ts b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-device-id.ts index b6f966c1d..f9fea6996 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-device-id.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-device-id.ts @@ -1,22 +1,22 @@ // automatically generated by the FlatBuffers compiler, do not modify -import { DeviceIdTable, DeviceIdTableT } from '../../solarxr-protocol/datatypes/device-id-table.js'; +import { FirmwareDeviceIdTable, FirmwareDeviceIdTableT } from '../../solarxr-protocol/rpc/firmware-device-id-table.js'; import { SerialDevicePort, SerialDevicePortT } from '../../solarxr-protocol/rpc/serial-device-port.js'; export enum FirmwareUpdateDeviceId { NONE = 0, - solarxr_protocol_datatypes_DeviceIdTable = 1, + FirmwareDeviceIdTable = 1, SerialDevicePort = 2 } export function unionToFirmwareUpdateDeviceId( type: FirmwareUpdateDeviceId, - accessor: (obj:DeviceIdTable|SerialDevicePort) => DeviceIdTable|SerialDevicePort|null -): DeviceIdTable|SerialDevicePort|null { + accessor: (obj:FirmwareDeviceIdTable|SerialDevicePort) => FirmwareDeviceIdTable|SerialDevicePort|null +): FirmwareDeviceIdTable|SerialDevicePort|null { switch(FirmwareUpdateDeviceId[type]) { case 'NONE': return null; - case 'solarxr_protocol_datatypes_DeviceIdTable': return accessor(new DeviceIdTable())! as DeviceIdTable; + case 'FirmwareDeviceIdTable': return accessor(new FirmwareDeviceIdTable())! as FirmwareDeviceIdTable; case 'SerialDevicePort': return accessor(new SerialDevicePort())! as SerialDevicePort; default: return null; } @@ -24,12 +24,12 @@ export function unionToFirmwareUpdateDeviceId( export function unionListToFirmwareUpdateDeviceId( type: FirmwareUpdateDeviceId, - accessor: (index: number, obj:DeviceIdTable|SerialDevicePort) => DeviceIdTable|SerialDevicePort|null, + accessor: (index: number, obj:FirmwareDeviceIdTable|SerialDevicePort) => FirmwareDeviceIdTable|SerialDevicePort|null, index: number -): DeviceIdTable|SerialDevicePort|null { +): FirmwareDeviceIdTable|SerialDevicePort|null { switch(FirmwareUpdateDeviceId[type]) { case 'NONE': return null; - case 'solarxr_protocol_datatypes_DeviceIdTable': return accessor(index, new DeviceIdTable())! as DeviceIdTable; + case 'FirmwareDeviceIdTable': return accessor(index, new FirmwareDeviceIdTable())! as FirmwareDeviceIdTable; case 'SerialDevicePort': return accessor(index, new SerialDevicePort())! as SerialDevicePort; default: return null; } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status-response.ts index 8f9813d38..f8279244a 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status-response.ts @@ -2,7 +2,7 @@ import * as flatbuffers from 'flatbuffers'; -import { DeviceIdTable, DeviceIdTableT } from '../../solarxr-protocol/datatypes/device-id-table.js'; +import { FirmwareDeviceIdTable, FirmwareDeviceIdTableT } from '../../solarxr-protocol/rpc/firmware-device-id-table.js'; import { FirmwareUpdateDeviceId, unionToFirmwareUpdateDeviceId, unionListToFirmwareUpdateDeviceId } from '../../solarxr-protocol/rpc/firmware-update-device-id.js'; import { FirmwareUpdateStatus } from '../../solarxr-protocol/rpc/firmware-update-status.js'; import { SerialDevicePort, SerialDevicePortT } from '../../solarxr-protocol/rpc/serial-device-port.js'; @@ -112,7 +112,7 @@ unpackTo(_o: FirmwareUpdateStatusResponseT): void { export class FirmwareUpdateStatusResponseT implements flatbuffers.IGeneratedObject { constructor( public deviceIdType: FirmwareUpdateDeviceId = FirmwareUpdateDeviceId.NONE, - public deviceId: DeviceIdTableT|SerialDevicePortT|null = null, + public deviceId: FirmwareDeviceIdTableT|SerialDevicePortT|null = null, public status: FirmwareUpdateStatus = FirmwareUpdateStatus.DOWNLOADING, public progress: number = 0 ){} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts index d5cd25025..39426eac7 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts @@ -37,6 +37,10 @@ export enum FirmwareUpdateStatus { * The server is provisioning the tracker */ PROVISIONING = 6, + + /** + * The update process completed with success + */ DONE = 7, /** diff --git a/protocol/typescript/src/solarxr-protocol/rpc/height-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/height-request.ts deleted file mode 100644 index b38fef465..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/height-request.ts +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class HeightRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):HeightRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsHeightRequest(bb:flatbuffers.ByteBuffer, obj?:HeightRequest):HeightRequest { - return (obj || new HeightRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsHeightRequest(bb:flatbuffers.ByteBuffer, obj?:HeightRequest):HeightRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new HeightRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startHeightRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endHeightRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createHeightRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - HeightRequest.startHeightRequest(builder); - return HeightRequest.endHeightRequest(builder); -} - -unpack(): HeightRequestT { - return new HeightRequestT(); -} - - -unpackTo(_o: HeightRequestT): void {} -} - -export class HeightRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return HeightRequest.createHeightRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/height-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/height-response.ts deleted file mode 100644 index e490b57be..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/height-response.ts +++ /dev/null @@ -1,89 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * Returns the current min and max positional tracker heights - */ -export class HeightResponse implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):HeightResponse { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsHeightResponse(bb:flatbuffers.ByteBuffer, obj?:HeightResponse):HeightResponse { - return (obj || new HeightResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsHeightResponse(bb:flatbuffers.ByteBuffer, obj?:HeightResponse):HeightResponse { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new HeightResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -minHeight():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; -} - -maxHeight():number { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; -} - -static startHeightResponse(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addMinHeight(builder:flatbuffers.Builder, minHeight:number) { - builder.addFieldFloat32(0, minHeight, 0.0); -} - -static addMaxHeight(builder:flatbuffers.Builder, maxHeight:number) { - builder.addFieldFloat32(1, maxHeight, 0.0); -} - -static endHeightResponse(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createHeightResponse(builder:flatbuffers.Builder, minHeight:number, maxHeight:number):flatbuffers.Offset { - HeightResponse.startHeightResponse(builder); - HeightResponse.addMinHeight(builder, minHeight); - HeightResponse.addMaxHeight(builder, maxHeight); - return HeightResponse.endHeightResponse(builder); -} - -unpack(): HeightResponseT { - return new HeightResponseT( - this.minHeight(), - this.maxHeight() - ); -} - - -unpackTo(_o: HeightResponseT): void { - _o.minHeight = this.minHeight(); - _o.maxHeight = this.maxHeight(); -} -} - -export class HeightResponseT implements flatbuffers.IGeneratedObject { -constructor( - public minHeight: number = 0.0, - public maxHeight: number = 0.0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return HeightResponse.createHeightResponse(builder, - this.minHeight, - this.maxHeight - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-request.ts new file mode 100644 index 000000000..6c0b01ddf --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class HIDSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):HIDSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsHIDSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:HIDSettingsRequest):HIDSettingsRequest { + return (obj || new HIDSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsHIDSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:HIDSettingsRequest):HIDSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new HIDSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startHIDSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endHIDSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createHIDSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + HIDSettingsRequest.startHIDSettingsRequest(builder); + return HIDSettingsRequest.endHIDSettingsRequest(builder); +} + +unpack(): HIDSettingsRequestT { + return new HIDSettingsRequestT(); +} + + +unpackTo(_o: HIDSettingsRequestT): void {} +} + +export class HIDSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return HIDSettingsRequest.createHIDSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-response.ts new file mode 100644 index 000000000..6f0c6d8d5 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/hidsettings-response.ts @@ -0,0 +1,72 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class HIDSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):HIDSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsHIDSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:HIDSettingsResponse):HIDSettingsResponse { + return (obj || new HIDSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsHIDSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:HIDSettingsResponse):HIDSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new HIDSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackersOverHid():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startHIDSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackersOverHid(builder:flatbuffers.Builder, trackersOverHid:boolean) { + builder.addFieldInt8(0, +trackersOverHid, +false); +} + +static endHIDSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createHIDSettingsResponse(builder:flatbuffers.Builder, trackersOverHid:boolean):flatbuffers.Offset { + HIDSettingsResponse.startHIDSettingsResponse(builder); + HIDSettingsResponse.addTrackersOverHid(builder, trackersOverHid); + return HIDSettingsResponse.endHIDSettingsResponse(builder); +} + +unpack(): HIDSettingsResponseT { + return new HIDSettingsResponseT( + this.trackersOverHid() + ); +} + + +unpackTo(_o: HIDSettingsResponseT): void { + _o.trackersOverHid = this.trackersOverHid(); +} +} + +export class HIDSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public trackersOverHid: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return HIDSettingsResponse.createHIDSettingsResponse(builder, + this.trackersOverHid + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/hidsettings.ts b/protocol/typescript/src/solarxr-protocol/rpc/hidsettings.ts deleted file mode 100644 index a72fadee1..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/hidsettings.ts +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class HIDSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):HIDSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsHIDSettings(bb:flatbuffers.ByteBuffer, obj?:HIDSettings):HIDSettings { - return (obj || new HIDSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsHIDSettings(bb:flatbuffers.ByteBuffer, obj?:HIDSettings):HIDSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new HIDSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -trackersOverHid():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startHIDSettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addTrackersOverHid(builder:flatbuffers.Builder, trackersOverHid:boolean) { - builder.addFieldInt8(0, +trackersOverHid, +false); -} - -static endHIDSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createHIDSettings(builder:flatbuffers.Builder, trackersOverHid:boolean):flatbuffers.Offset { - HIDSettings.startHIDSettings(builder); - HIDSettings.addTrackersOverHid(builder, trackersOverHid); - return HIDSettings.endHIDSettings(builder); -} - -unpack(): HIDSettingsT { - return new HIDSettingsT( - this.trackersOverHid() - ); -} - - -unpackTo(_o: HIDSettingsT): void { - _o.trackersOverHid = this.trackersOverHid(); -} -} - -export class HIDSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public trackersOverHid: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return HIDSettings.createHIDSettings(builder, - this.trackersOverHid - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts index 8074d4f64..15c0d0854 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts @@ -5,6 +5,9 @@ import * as flatbuffers from 'flatbuffers'; import { KeybindId } from '../../solarxr-protocol/rpc/keybind-id.js'; +/** + * Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui + */ export class KeybindRequest implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts index a7a76ee60..b6c17149b 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts @@ -5,6 +5,9 @@ import * as flatbuffers from 'flatbuffers'; import { Keybind, KeybindT } from '../../solarxr-protocol/rpc/keybind.js'; +/** + * Returns keybinds for displaying in gui + */ export class KeybindResponse implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-request.ts index 5082ef111..d98a89961 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-request.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** @@ -26,17 +25,17 @@ static getSizePrefixedRootAsMagToggleRequest(bb:flatbuffers.ByteBuffer, obj?:Mag return (obj || new MagToggleRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } static startMagToggleRequest(builder:flatbuffers.Builder) { builder.startObject(1); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static endMagToggleRequest(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -44,35 +43,33 @@ static endMagToggleRequest(builder:flatbuffers.Builder):flatbuffers.Offset { return offset; } -static createMagToggleRequest(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { +static createMagToggleRequest(builder:flatbuffers.Builder, trackerId:number):flatbuffers.Offset { MagToggleRequest.startMagToggleRequest(builder); - MagToggleRequest.addTrackerId(builder, trackerIdOffset); + MagToggleRequest.addTrackerId(builder, trackerId); return MagToggleRequest.endMagToggleRequest(builder); } unpack(): MagToggleRequestT { return new MagToggleRequestT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + this.trackerId() ); } unpackTo(_o: MagToggleRequestT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); } } export class MagToggleRequestT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null + public trackerId: number = 0 ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - return MagToggleRequest.createMagToggleRequest(builder, - trackerId + this.trackerId ); } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-response.ts index 381b7487c..2dc3e61d8 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/mag-toggle-response.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** @@ -26,9 +25,9 @@ static getSizePrefixedRootAsMagToggleResponse(bb:flatbuffers.ByteBuffer, obj?:Ma return (obj || new MagToggleResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } enable():boolean { @@ -40,8 +39,8 @@ static startMagToggleResponse(builder:flatbuffers.Builder) { builder.startObject(2); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static addEnable(builder:flatbuffers.Builder, enable:boolean) { @@ -53,39 +52,37 @@ static endMagToggleResponse(builder:flatbuffers.Builder):flatbuffers.Offset { return offset; } -static createMagToggleResponse(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset, enable:boolean):flatbuffers.Offset { +static createMagToggleResponse(builder:flatbuffers.Builder, trackerId:number, enable:boolean):flatbuffers.Offset { MagToggleResponse.startMagToggleResponse(builder); - MagToggleResponse.addTrackerId(builder, trackerIdOffset); + MagToggleResponse.addTrackerId(builder, trackerId); MagToggleResponse.addEnable(builder, enable); return MagToggleResponse.endMagToggleResponse(builder); } unpack(): MagToggleResponseT { return new MagToggleResponseT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.trackerId(), this.enable() ); } unpackTo(_o: MagToggleResponseT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); _o.enable = this.enable(); } } export class MagToggleResponseT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null, + public trackerId: number = 0, public enable: boolean = false ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - return MagToggleResponse.createMagToggleResponse(builder, - trackerId, + this.trackerId, this.enable ); } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/oscrouter-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/oscrouter-settings.ts deleted file mode 100644 index e6da3aa24..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/oscrouter-settings.ts +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { OSCSettings, OSCSettingsT } from '../../solarxr-protocol/rpc/oscsettings.js'; - - -/** - * OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. - */ -export class OSCRouterSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):OSCRouterSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsOSCRouterSettings(bb:flatbuffers.ByteBuffer, obj?:OSCRouterSettings):OSCRouterSettings { - return (obj || new OSCRouterSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsOSCRouterSettings(bb:flatbuffers.ByteBuffer, obj?:OSCRouterSettings):OSCRouterSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new OSCRouterSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -oscSettings(obj?:OSCSettings):OSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new OSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startOSCRouterSettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addOscSettings(builder:flatbuffers.Builder, oscSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, oscSettingsOffset, 0); -} - -static endOSCRouterSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createOSCRouterSettings(builder:flatbuffers.Builder, oscSettingsOffset:flatbuffers.Offset):flatbuffers.Offset { - OSCRouterSettings.startOSCRouterSettings(builder); - OSCRouterSettings.addOscSettings(builder, oscSettingsOffset); - return OSCRouterSettings.endOSCRouterSettings(builder); -} - -unpack(): OSCRouterSettingsT { - return new OSCRouterSettingsT( - (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null) - ); -} - - -unpackTo(_o: OSCRouterSettingsT): void { - _o.oscSettings = (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null); -} -} - -export class OSCRouterSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public oscSettings: OSCSettingsT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const oscSettings = (this.oscSettings !== null ? this.oscSettings!.pack(builder) : 0); - - return OSCRouterSettings.createOSCRouterSettings(builder, - oscSettings - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/oscsettings.ts b/protocol/typescript/src/solarxr-protocol/rpc/oscsettings.ts deleted file mode 100644 index 019e6ec86..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/oscsettings.ts +++ /dev/null @@ -1,121 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * OSC Settings that are used in *any* osc application. - */ -export class OSCSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):OSCSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsOSCSettings(bb:flatbuffers.ByteBuffer, obj?:OSCSettings):OSCSettings { - return (obj || new OSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsOSCSettings(bb:flatbuffers.ByteBuffer, obj?:OSCSettings):OSCSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new OSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -enabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -portIn():number { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; -} - -portOut():number { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; -} - -address():string|null -address(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -address(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startOSCSettings(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { - builder.addFieldInt8(0, +enabled, +false); -} - -static addPortIn(builder:flatbuffers.Builder, portIn:number) { - builder.addFieldInt16(1, portIn, 0); -} - -static addPortOut(builder:flatbuffers.Builder, portOut:number) { - builder.addFieldInt16(2, portOut, 0); -} - -static addAddress(builder:flatbuffers.Builder, addressOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, addressOffset, 0); -} - -static endOSCSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createOSCSettings(builder:flatbuffers.Builder, enabled:boolean, portIn:number, portOut:number, addressOffset:flatbuffers.Offset):flatbuffers.Offset { - OSCSettings.startOSCSettings(builder); - OSCSettings.addEnabled(builder, enabled); - OSCSettings.addPortIn(builder, portIn); - OSCSettings.addPortOut(builder, portOut); - OSCSettings.addAddress(builder, addressOffset); - return OSCSettings.endOSCSettings(builder); -} - -unpack(): OSCSettingsT { - return new OSCSettingsT( - this.enabled(), - this.portIn(), - this.portOut(), - this.address() - ); -} - - -unpackTo(_o: OSCSettingsT): void { - _o.enabled = this.enabled(); - _o.portIn = this.portIn(); - _o.portOut = this.portOut(); - _o.address = this.address(); -} -} - -export class OSCSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public enabled: boolean = false, - public portIn: number = 0, - public portOut: number = 0, - public address: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const address = (this.address !== null ? builder.createString(this.address!) : 0); - - return OSCSettings.createOSCSettings(builder, - this.enabled, - this.portIn, - this.portOut, - address - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/osctrackers-setting.ts b/protocol/typescript/src/solarxr-protocol/rpc/osctrackers-setting.ts deleted file mode 100644 index 3519d494b..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/osctrackers-setting.ts +++ /dev/null @@ -1,156 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class OSCTrackersSetting implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):OSCTrackersSetting { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsOSCTrackersSetting(bb:flatbuffers.ByteBuffer, obj?:OSCTrackersSetting):OSCTrackersSetting { - return (obj || new OSCTrackersSetting()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsOSCTrackersSetting(bb:flatbuffers.ByteBuffer, obj?:OSCTrackersSetting):OSCTrackersSetting { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new OSCTrackersSetting()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -head():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -chest():boolean { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -waist():boolean { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -knees():boolean { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -feet():boolean { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -elbows():boolean { - const offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -hands():boolean { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startOSCTrackersSetting(builder:flatbuffers.Builder) { - builder.startObject(7); -} - -static addHead(builder:flatbuffers.Builder, head:boolean) { - builder.addFieldInt8(0, +head, +false); -} - -static addChest(builder:flatbuffers.Builder, chest:boolean) { - builder.addFieldInt8(1, +chest, +false); -} - -static addWaist(builder:flatbuffers.Builder, waist:boolean) { - builder.addFieldInt8(2, +waist, +false); -} - -static addKnees(builder:flatbuffers.Builder, knees:boolean) { - builder.addFieldInt8(3, +knees, +false); -} - -static addFeet(builder:flatbuffers.Builder, feet:boolean) { - builder.addFieldInt8(4, +feet, +false); -} - -static addElbows(builder:flatbuffers.Builder, elbows:boolean) { - builder.addFieldInt8(5, +elbows, +false); -} - -static addHands(builder:flatbuffers.Builder, hands:boolean) { - builder.addFieldInt8(6, +hands, +false); -} - -static endOSCTrackersSetting(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createOSCTrackersSetting(builder:flatbuffers.Builder, head:boolean, chest:boolean, waist:boolean, knees:boolean, feet:boolean, elbows:boolean, hands:boolean):flatbuffers.Offset { - OSCTrackersSetting.startOSCTrackersSetting(builder); - OSCTrackersSetting.addHead(builder, head); - OSCTrackersSetting.addChest(builder, chest); - OSCTrackersSetting.addWaist(builder, waist); - OSCTrackersSetting.addKnees(builder, knees); - OSCTrackersSetting.addFeet(builder, feet); - OSCTrackersSetting.addElbows(builder, elbows); - OSCTrackersSetting.addHands(builder, hands); - return OSCTrackersSetting.endOSCTrackersSetting(builder); -} - -unpack(): OSCTrackersSettingT { - return new OSCTrackersSettingT( - this.head(), - this.chest(), - this.waist(), - this.knees(), - this.feet(), - this.elbows(), - this.hands() - ); -} - - -unpackTo(_o: OSCTrackersSettingT): void { - _o.head = this.head(); - _o.chest = this.chest(); - _o.waist = this.waist(); - _o.knees = this.knees(); - _o.feet = this.feet(); - _o.elbows = this.elbows(); - _o.hands = this.hands(); -} -} - -export class OSCTrackersSettingT implements flatbuffers.IGeneratedObject { -constructor( - public head: boolean = false, - public chest: boolean = false, - public waist: boolean = false, - public knees: boolean = false, - public feet: boolean = false, - public elbows: boolean = false, - public hands: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return OSCTrackersSetting.createOSCTrackersSetting(builder, - this.head, - this.chest, - this.waist, - this.knees, - this.feet, - this.elbows, - this.hands - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/otafirmware-update.ts b/protocol/typescript/src/solarxr-protocol/rpc/otafirmware-update.ts index d80bec036..d15c52ec0 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/otafirmware-update.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/otafirmware-update.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { DeviceId, DeviceIdT } from '../../solarxr-protocol/datatypes/device-id.js'; import { FirmwarePart, FirmwarePartT } from '../../solarxr-protocol/rpc/firmware-part.js'; @@ -25,11 +24,11 @@ static getSizePrefixedRootAsOTAFirmwareUpdate(bb:flatbuffers.ByteBuffer, obj?:OT } /** - * id of the device, this refer to the actual DeviceId from the protocol + * Id of the device */ -deviceId(obj?:DeviceId):DeviceId|null { +deviceId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new DeviceId()).__init(this.bb_pos + offset, this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } /** @@ -44,8 +43,8 @@ static startOTAFirmwareUpdate(builder:flatbuffers.Builder) { builder.startObject(2); } -static addDeviceId(builder:flatbuffers.Builder, deviceIdOffset:flatbuffers.Offset) { - builder.addFieldStruct(0, deviceIdOffset, 0); +static addDeviceId(builder:flatbuffers.Builder, deviceId:number) { + builder.addFieldInt16(0, deviceId, 0); } static addFirmwarePart(builder:flatbuffers.Builder, firmwarePartOffset:flatbuffers.Offset) { @@ -60,21 +59,21 @@ static endOTAFirmwareUpdate(builder:flatbuffers.Builder):flatbuffers.Offset { unpack(): OTAFirmwareUpdateT { return new OTAFirmwareUpdateT( - (this.deviceId() !== null ? this.deviceId()!.unpack() : null), + this.deviceId(), (this.firmwarePart() !== null ? this.firmwarePart()!.unpack() : null) ); } unpackTo(_o: OTAFirmwareUpdateT): void { - _o.deviceId = (this.deviceId() !== null ? this.deviceId()!.unpack() : null); + _o.deviceId = this.deviceId(); _o.firmwarePart = (this.firmwarePart() !== null ? this.firmwarePart()!.unpack() : null); } } export class OTAFirmwareUpdateT implements flatbuffers.IGeneratedObject { constructor( - public deviceId: DeviceIdT|null = null, + public deviceId: number = 0, public firmwarePart: FirmwarePartT|null = null ){} @@ -83,7 +82,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { const firmwarePart = (this.firmwarePart !== null ? this.firmwarePart!.pack(builder) : 0); OTAFirmwareUpdate.startOTAFirmwareUpdate(builder); - OTAFirmwareUpdate.addDeviceId(builder, (this.deviceId !== null ? this.deviceId!.pack(builder) : 0)); + OTAFirmwareUpdate.addDeviceId(builder, this.deviceId); OTAFirmwareUpdate.addFirmwarePart(builder, firmwarePart); return OTAFirmwareUpdate.endOTAFirmwareUpdate(builder); diff --git a/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-request.ts new file mode 100644 index 000000000..0227edec8 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class OutputTrackersSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):OutputTrackersSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsOutputTrackersSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:OutputTrackersSettingsRequest):OutputTrackersSettingsRequest { + return (obj || new OutputTrackersSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsOutputTrackersSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:OutputTrackersSettingsRequest):OutputTrackersSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new OutputTrackersSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startOutputTrackersSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endOutputTrackersSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createOutputTrackersSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + OutputTrackersSettingsRequest.startOutputTrackersSettingsRequest(builder); + return OutputTrackersSettingsRequest.endOutputTrackersSettingsRequest(builder); +} + +unpack(): OutputTrackersSettingsRequestT { + return new OutputTrackersSettingsRequestT(); +} + + +unpackTo(_o: OutputTrackersSettingsRequestT): void {} +} + +export class OutputTrackersSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return OutputTrackersSettingsRequest.createOutputTrackersSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-response.ts new file mode 100644 index 000000000..24fe6eeac --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/output-trackers-settings-response.ts @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; + + +export class OutputTrackersSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):OutputTrackersSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsOutputTrackersSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:OutputTrackersSettingsResponse):OutputTrackersSettingsResponse { + return (obj || new OutputTrackersSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsOutputTrackersSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:OutputTrackersSettingsResponse):OutputTrackersSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new OutputTrackersSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +automaticTrackerToggle():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +trackers(index: number):BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +trackersLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +trackersArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +sendDerivedVelocity():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startOutputTrackersSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addAutomaticTrackerToggle(builder:flatbuffers.Builder, automaticTrackerToggle:boolean) { + builder.addFieldInt8(0, +automaticTrackerToggle, +false); +} + +static addTrackers(builder:flatbuffers.Builder, trackersOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, trackersOffset, 0); +} + +static createTrackersVector(builder:flatbuffers.Builder, data:BodyPart[]):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startTrackersVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static addSendDerivedVelocity(builder:flatbuffers.Builder, sendDerivedVelocity:boolean) { + builder.addFieldInt8(2, +sendDerivedVelocity, +false); +} + +static endOutputTrackersSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createOutputTrackersSettingsResponse(builder:flatbuffers.Builder, automaticTrackerToggle:boolean, trackersOffset:flatbuffers.Offset, sendDerivedVelocity:boolean):flatbuffers.Offset { + OutputTrackersSettingsResponse.startOutputTrackersSettingsResponse(builder); + OutputTrackersSettingsResponse.addAutomaticTrackerToggle(builder, automaticTrackerToggle); + OutputTrackersSettingsResponse.addTrackers(builder, trackersOffset); + OutputTrackersSettingsResponse.addSendDerivedVelocity(builder, sendDerivedVelocity); + return OutputTrackersSettingsResponse.endOutputTrackersSettingsResponse(builder); +} + +unpack(): OutputTrackersSettingsResponseT { + return new OutputTrackersSettingsResponseT( + this.automaticTrackerToggle(), + this.bb!.createScalarList(this.trackers.bind(this), this.trackersLength()), + this.sendDerivedVelocity() + ); +} + + +unpackTo(_o: OutputTrackersSettingsResponseT): void { + _o.automaticTrackerToggle = this.automaticTrackerToggle(); + _o.trackers = this.bb!.createScalarList(this.trackers.bind(this), this.trackersLength()); + _o.sendDerivedVelocity = this.sendDerivedVelocity(); +} +} + +export class OutputTrackersSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public automaticTrackerToggle: boolean = false, + public trackers: (BodyPart)[] = [], + public sendDerivedVelocity: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackers = OutputTrackersSettingsResponse.createTrackersVector(builder, this.trackers); + + return OutputTrackersSettingsResponse.createOutputTrackersSettingsResponse(builder, + this.automaticTrackerToggle, + trackers, + this.sendDerivedVelocity + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/reset-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/reset-request.ts index e67723b66..4223f9885 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/reset-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/reset-request.ts @@ -26,7 +26,7 @@ static getSizePrefixedRootAsResetRequest(bb:flatbuffers.ByteBuffer, obj?:ResetRe resetType():ResetType { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : ResetType.Yaw; + return offset ? this.bb!.readUint8(this.bb_pos + offset) : ResetType.YAW; } /** @@ -57,7 +57,7 @@ static startResetRequest(builder:flatbuffers.Builder) { } static addResetType(builder:flatbuffers.Builder, resetType:ResetType) { - builder.addFieldInt8(0, resetType, ResetType.Yaw); + builder.addFieldInt8(0, resetType, ResetType.YAW); } static addBodyParts(builder:flatbuffers.Builder, bodyPartsOffset:flatbuffers.Offset) { @@ -112,7 +112,7 @@ unpackTo(_o: ResetRequestT): void { export class ResetRequestT implements flatbuffers.IGeneratedObject { constructor( - public resetType: ResetType = ResetType.Yaw, + public resetType: ResetType = ResetType.YAW, public bodyParts: (BodyPart)[] = [], public delay: number|null = null ){} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts index 0349ed659..5a298d4fb 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts @@ -27,7 +27,7 @@ static getSizePrefixedRootAsResetResponse(bb:flatbuffers.ByteBuffer, obj?:ResetR resetType():ResetType { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : ResetType.Yaw; + return offset ? this.bb!.readUint8(this.bb_pos + offset) : ResetType.YAW; } status():ResetStatus { @@ -36,7 +36,7 @@ status():ResetStatus { } /** - * Should return the body parts reseted / being reset + * Should return the body parts reset / being reset */ bodyParts(index: number):BodyPart|null { const offset = this.bb!.__offset(this.bb_pos, 8); @@ -55,8 +55,7 @@ bodyPartsArray():Uint8Array|null { /** * gives the time in seconds passed since the start of the reset - * is 0 when status == FINISHED - * starts at 0 + * Starts at 0. Should be equal to 'duration' when status == FINISHED */ progress():number { const offset = this.bb!.__offset(this.bb_pos, 10); @@ -73,7 +72,7 @@ static startResetResponse(builder:flatbuffers.Builder) { } static addResetType(builder:flatbuffers.Builder, resetType:ResetType) { - builder.addFieldInt8(0, resetType, ResetType.Yaw); + builder.addFieldInt8(0, resetType, ResetType.YAW); } static addStatus(builder:flatbuffers.Builder, status:ResetStatus) { @@ -141,7 +140,7 @@ unpackTo(_o: ResetResponseT): void { export class ResetResponseT implements flatbuffers.IGeneratedObject { constructor( - public resetType: ResetType = ResetType.Yaw, + public resetType: ResetType = ResetType.YAW, public status: ResetStatus = ResetStatus.STARTED, public bodyParts: (BodyPart)[] = [], public progress: number = 0, diff --git a/protocol/typescript/src/solarxr-protocol/rpc/reset-type.ts b/protocol/typescript/src/solarxr-protocol/rpc/reset-type.ts index 61c35e2d5..ad3da63ed 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/reset-type.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/reset-type.ts @@ -1,11 +1,18 @@ // automatically generated by the FlatBuffers compiler, do not modify export enum ResetType { - Yaw = 0, - Full = 1, + /** + * Resets the yaw (horizontal) axis + */ + YAW = 0, + + /** + * Resets all axes + */ + FULL = 1, /** * Second pose for calibrating mounting rotation */ - Mounting = 2 + MOUNTING = 2 } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/resets-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/resets-settings-request.ts new file mode 100644 index 000000000..b01ef3ce8 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/resets-settings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ResetsSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ResetsSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsResetsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ResetsSettingsRequest):ResetsSettingsRequest { + return (obj || new ResetsSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsResetsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:ResetsSettingsRequest):ResetsSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ResetsSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startResetsSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endResetsSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createResetsSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + ResetsSettingsRequest.startResetsSettingsRequest(builder); + return ResetsSettingsRequest.endResetsSettingsRequest(builder); +} + +unpack(): ResetsSettingsRequestT { + return new ResetsSettingsRequestT(); +} + + +unpackTo(_o: ResetsSettingsRequestT): void {} +} + +export class ResetsSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ResetsSettingsRequest.createResetsSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/resets-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/resets-settings-response.ts similarity index 51% rename from protocol/typescript/src/solarxr-protocol/rpc/resets-settings.ts rename to protocol/typescript/src/solarxr-protocol/rpc/resets-settings-response.ts index 804f79301..26ac075c7 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/resets-settings.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/resets-settings-response.ts @@ -2,35 +2,38 @@ import * as flatbuffers from 'flatbuffers'; -import { ArmsMountingResetMode } from '../../solarxr-protocol/rpc/arms-mounting-reset-mode.js'; +import { ArmsResetMode } from '../../solarxr-protocol/rpc/arms-reset-mode.js'; -export class ResetsSettings implements flatbuffers.IUnpackableObject { +export class ResetsSettingsResponse implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ResetsSettings { + __init(i:number, bb:flatbuffers.ByteBuffer):ResetsSettingsResponse { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsResetsSettings(bb:flatbuffers.ByteBuffer, obj?:ResetsSettings):ResetsSettings { - return (obj || new ResetsSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsResetsSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:ResetsSettingsResponse):ResetsSettingsResponse { + return (obj || new ResetsSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsResetsSettings(bb:flatbuffers.ByteBuffer, obj?:ResetsSettings):ResetsSettings { +static getSizePrefixedRootAsResetsSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:ResetsSettingsResponse):ResetsSettingsResponse { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ResetsSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new ResetsSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } +/** + * Makes it so feet will be mounting reset when passing no BodyPart + */ resetMountingFeet():boolean { const offset = this.bb!.__offset(this.bb_pos, 4); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } -armsMountingResetMode():ArmsMountingResetMode { +armsResetMode():ArmsResetMode { const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : ArmsMountingResetMode.BACK; + return offset ? this.bb!.readUint8(this.bb_pos + offset) : ArmsResetMode.BACK; } yawResetSmoothTime():number { @@ -48,7 +51,7 @@ resetHmdPitch():boolean { return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } -static startResetsSettings(builder:flatbuffers.Builder) { +static startResetsSettingsResponse(builder:flatbuffers.Builder) { builder.startObject(5); } @@ -56,8 +59,8 @@ static addResetMountingFeet(builder:flatbuffers.Builder, resetMountingFeet:boole builder.addFieldInt8(0, +resetMountingFeet, +false); } -static addArmsMountingResetMode(builder:flatbuffers.Builder, armsMountingResetMode:ArmsMountingResetMode) { - builder.addFieldInt8(1, armsMountingResetMode, ArmsMountingResetMode.BACK); +static addArmsResetMode(builder:flatbuffers.Builder, armsResetMode:ArmsResetMode) { + builder.addFieldInt8(1, armsResetMode, ArmsResetMode.BACK); } static addYawResetSmoothTime(builder:flatbuffers.Builder, yawResetSmoothTime:number) { @@ -72,25 +75,25 @@ static addResetHmdPitch(builder:flatbuffers.Builder, resetHmdPitch:boolean) { builder.addFieldInt8(4, +resetHmdPitch, +false); } -static endResetsSettings(builder:flatbuffers.Builder):flatbuffers.Offset { +static endResetsSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createResetsSettings(builder:flatbuffers.Builder, resetMountingFeet:boolean, armsMountingResetMode:ArmsMountingResetMode, yawResetSmoothTime:number, saveMountingReset:boolean, resetHmdPitch:boolean):flatbuffers.Offset { - ResetsSettings.startResetsSettings(builder); - ResetsSettings.addResetMountingFeet(builder, resetMountingFeet); - ResetsSettings.addArmsMountingResetMode(builder, armsMountingResetMode); - ResetsSettings.addYawResetSmoothTime(builder, yawResetSmoothTime); - ResetsSettings.addSaveMountingReset(builder, saveMountingReset); - ResetsSettings.addResetHmdPitch(builder, resetHmdPitch); - return ResetsSettings.endResetsSettings(builder); +static createResetsSettingsResponse(builder:flatbuffers.Builder, resetMountingFeet:boolean, armsResetMode:ArmsResetMode, yawResetSmoothTime:number, saveMountingReset:boolean, resetHmdPitch:boolean):flatbuffers.Offset { + ResetsSettingsResponse.startResetsSettingsResponse(builder); + ResetsSettingsResponse.addResetMountingFeet(builder, resetMountingFeet); + ResetsSettingsResponse.addArmsResetMode(builder, armsResetMode); + ResetsSettingsResponse.addYawResetSmoothTime(builder, yawResetSmoothTime); + ResetsSettingsResponse.addSaveMountingReset(builder, saveMountingReset); + ResetsSettingsResponse.addResetHmdPitch(builder, resetHmdPitch); + return ResetsSettingsResponse.endResetsSettingsResponse(builder); } -unpack(): ResetsSettingsT { - return new ResetsSettingsT( +unpack(): ResetsSettingsResponseT { + return new ResetsSettingsResponseT( this.resetMountingFeet(), - this.armsMountingResetMode(), + this.armsResetMode(), this.yawResetSmoothTime(), this.saveMountingReset(), this.resetHmdPitch() @@ -98,19 +101,19 @@ unpack(): ResetsSettingsT { } -unpackTo(_o: ResetsSettingsT): void { +unpackTo(_o: ResetsSettingsResponseT): void { _o.resetMountingFeet = this.resetMountingFeet(); - _o.armsMountingResetMode = this.armsMountingResetMode(); + _o.armsResetMode = this.armsResetMode(); _o.yawResetSmoothTime = this.yawResetSmoothTime(); _o.saveMountingReset = this.saveMountingReset(); _o.resetHmdPitch = this.resetHmdPitch(); } } -export class ResetsSettingsT implements flatbuffers.IGeneratedObject { +export class ResetsSettingsResponseT implements flatbuffers.IGeneratedObject { constructor( public resetMountingFeet: boolean = false, - public armsMountingResetMode: ArmsMountingResetMode = ArmsMountingResetMode.BACK, + public armsResetMode: ArmsResetMode = ArmsResetMode.BACK, public yawResetSmoothTime: number = 0.0, public saveMountingReset: boolean = false, public resetHmdPitch: boolean = false @@ -118,9 +121,9 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return ResetsSettings.createResetsSettings(builder, + return ResetsSettingsResponse.createResetsSettingsResponse(builder, this.resetMountingFeet, - this.armsMountingResetMode, + this.armsResetMode, this.yawResetSmoothTime, this.saveMountingReset, this.resetHmdPitch diff --git a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts index 0332a3750..b99b1f775 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -12,13 +12,21 @@ import { AutoBoneProcessRequest, AutoBoneProcessRequestT } from '../../solarxr-p import { AutoBoneProcessStatusResponse, AutoBoneProcessStatusResponseT } from '../../solarxr-protocol/rpc/auto-bone-process-status-response.js'; import { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from '../../solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; import { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from '../../solarxr-protocol/rpc/cancel-user-height-calibration.js'; +import { ChangeHIDSettingsRequest, ChangeHIDSettingsRequestT } from '../../solarxr-protocol/rpc/change-hidsettings-request.js'; import { ChangeKeybindRequest, ChangeKeybindRequestT } from '../../solarxr-protocol/rpc/change-keybind-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; -import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; -import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; -import { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from '../../solarxr-protocol/rpc/clear-drift-compensation-request.js'; +import { ChangeOutputTrackersSettingsRequest, ChangeOutputTrackersSettingsRequestT } from '../../solarxr-protocol/rpc/change-output-trackers-settings-request.js'; +import { ChangeResetsSettingsRequest, ChangeResetsSettingsRequestT } from '../../solarxr-protocol/rpc/change-resets-settings-request.js'; +import { ChangeSkeletonProportionsRequest, ChangeSkeletonProportionsRequestT } from '../../solarxr-protocol/rpc/change-skeleton-proportions-request.js'; +import { ChangeSkeletonSettingsRequest, ChangeSkeletonSettingsRequestT } from '../../solarxr-protocol/rpc/change-skeleton-settings-request.js'; +import { ChangeStayAlignedSettingsRequest, ChangeStayAlignedSettingsRequestT } from '../../solarxr-protocol/rpc/change-stay-aligned-settings-request.js'; +import { ChangeTapDetectionSettingsRequest, ChangeTapDetectionSettingsRequestT } from '../../solarxr-protocol/rpc/change-tap-detection-settings-request.js'; +import { ChangeVMCOSCSettingsRequest, ChangeVMCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/change-vmcoscsettings-request.js'; +import { ChangeVRCOSCSettingsRequest, ChangeVRCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/change-vrcoscsettings-request.js'; +import { ChangeVRMSettingsRequest, ChangeVRMSettingsRequestT } from '../../solarxr-protocol/rpc/change-vrmsettings-request.js'; import { ClearMountingResetRequest, ClearMountingResetRequestT } from '../../solarxr-protocol/rpc/clear-mounting-reset-request.js'; import { CloseSerialRequest, CloseSerialRequestT } from '../../solarxr-protocol/rpc/close-serial-request.js'; +import { CompleteStayAlignedResponse, CompleteStayAlignedResponseT } from '../../solarxr-protocol/rpc/complete-stay-aligned-response.js'; import { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; import { EnableStayAlignedRequest, EnableStayAlignedRequestT } from '../../solarxr-protocol/rpc/enable-stay-aligned-request.js'; import { EnableSteamVRDriverRequest, EnableSteamVRDriverRequestT } from '../../solarxr-protocol/rpc/enable-steam-vrdriver-request.js'; @@ -26,10 +34,10 @@ import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-pro import { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from '../../solarxr-protocol/rpc/firmware-update-status-response.js'; import { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from '../../solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; import { ForgetDeviceRequest, ForgetDeviceRequestT } from '../../solarxr-protocol/rpc/forget-device-request.js'; +import { HIDSettingsRequest, HIDSettingsRequestT } from '../../solarxr-protocol/rpc/hidsettings-request.js'; +import { HIDSettingsResponse, HIDSettingsResponseT } from '../../solarxr-protocol/rpc/hidsettings-response.js'; import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/heartbeat-request.js'; import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; -import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; -import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; import { InstalledInfoRequest, InstalledInfoRequestT } from '../../solarxr-protocol/rpc/installed-info-request.js'; import { InstalledInfoResponse, InstalledInfoResponseT } from '../../solarxr-protocol/rpc/installed-info-response.js'; @@ -43,6 +51,8 @@ import { NewSerialDeviceResponse, NewSerialDeviceResponseT } from '../../solarxr import { OpenSerialRequest, OpenSerialRequestT } from '../../solarxr-protocol/rpc/open-serial-request.js'; import { OpenUriRequest, OpenUriRequestT } from '../../solarxr-protocol/rpc/open-uri-request.js'; import { OpenUriResponse, OpenUriResponseT } from '../../solarxr-protocol/rpc/open-uri-response.js'; +import { OutputTrackersSettingsRequest, OutputTrackersSettingsRequestT } from '../../solarxr-protocol/rpc/output-trackers-settings-request.js'; +import { OutputTrackersSettingsResponse, OutputTrackersSettingsResponseT } from '../../solarxr-protocol/rpc/output-trackers-settings-response.js'; import { OverlayDisplayModeChangeRequest, OverlayDisplayModeChangeRequestT } from '../../solarxr-protocol/rpc/overlay-display-mode-change-request.js'; import { OverlayDisplayModeRequest, OverlayDisplayModeRequestT } from '../../solarxr-protocol/rpc/overlay-display-mode-request.js'; import { OverlayDisplayModeResponse, OverlayDisplayModeResponseT } from '../../solarxr-protocol/rpc/overlay-display-mode-response.js'; @@ -52,6 +62,8 @@ import { RecordBVHStatusRequest, RecordBVHStatusRequestT } from '../../solarxr-p import { ResetRequest, ResetRequestT } from '../../solarxr-protocol/rpc/reset-request.js'; import { ResetResponse, ResetResponseT } from '../../solarxr-protocol/rpc/reset-response.js'; import { ResetStayAlignedRelaxedPoseRequest, ResetStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/reset-stay-aligned-relaxed-pose-request.js'; +import { ResetsSettingsRequest, ResetsSettingsRequestT } from '../../solarxr-protocol/rpc/resets-settings-request.js'; +import { ResetsSettingsResponse, ResetsSettingsResponseT } from '../../solarxr-protocol/rpc/resets-settings-response.js'; import { RpcMessage, unionToRpcMessage, unionListToRpcMessage } from '../../solarxr-protocol/rpc/rpc-message.js'; import { SaveFileNotification, SaveFileNotificationT } from '../../solarxr-protocol/rpc/save-file-notification.js'; import { SerialDevicesRequest, SerialDevicesRequestT } from '../../solarxr-protocol/rpc/serial-devices-request.js'; @@ -65,20 +77,21 @@ import { SerialUpdateResponse, SerialUpdateResponseT } from '../../solarxr-proto import { ServerInfosRequest, ServerInfosRequestT } from '../../solarxr-protocol/rpc/server-infos-request.js'; import { ServerInfosResponse, ServerInfosResponseT } from '../../solarxr-protocol/rpc/server-infos-response.js'; import { SetPauseTrackingRequest, SetPauseTrackingRequestT } from '../../solarxr-protocol/rpc/set-pause-tracking-request.js'; -import { SetWifiRequest, SetWifiRequestT } from '../../solarxr-protocol/rpc/set-wifi-request.js'; -import { SettingsRequest, SettingsRequestT } from '../../solarxr-protocol/rpc/settings-request.js'; import { SettingsResetRequest, SettingsResetRequestT } from '../../solarxr-protocol/rpc/settings-reset-request.js'; -import { SettingsResponse, SettingsResponseT } from '../../solarxr-protocol/rpc/settings-response.js'; -import { SkeletonConfigRequest, SkeletonConfigRequestT } from '../../solarxr-protocol/rpc/skeleton-config-request.js'; -import { SkeletonConfigResponse, SkeletonConfigResponseT } from '../../solarxr-protocol/rpc/skeleton-config-response.js'; -import { SkeletonResetAllRequest, SkeletonResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-reset-all-request.js'; +import { SkeletonProportionsRequest, SkeletonProportionsRequestT } from '../../solarxr-protocol/rpc/skeleton-proportions-request.js'; +import { SkeletonProportionsResetAllRequest, SkeletonProportionsResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-proportions-reset-all-request.js'; +import { SkeletonProportionsResponse, SkeletonProportionsResponseT } from '../../solarxr-protocol/rpc/skeleton-proportions-response.js'; +import { SkeletonSettingsRequest, SkeletonSettingsRequestT } from '../../solarxr-protocol/rpc/skeleton-settings-request.js'; +import { SkeletonSettingsResponse, SkeletonSettingsResponseT } from '../../solarxr-protocol/rpc/skeleton-settings-response.js'; import { StartUserHeightCalibration, StartUserHeightCalibrationT } from '../../solarxr-protocol/rpc/start-user-height-calibration.js'; import { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/start-wifi-provisioning-request.js'; -import { StatusSystemFixed, StatusSystemFixedT } from '../../solarxr-protocol/rpc/status-system-fixed.js'; -import { StatusSystemRequest, StatusSystemRequestT } from '../../solarxr-protocol/rpc/status-system-request.js'; -import { StatusSystemResponse, StatusSystemResponseT } from '../../solarxr-protocol/rpc/status-system-response.js'; -import { StatusSystemUpdate, StatusSystemUpdateT } from '../../solarxr-protocol/rpc/status-system-update.js'; +import { StayAlignedHideCorrectionRequest, StayAlignedHideCorrectionRequestT } from '../../solarxr-protocol/rpc/stay-aligned-hide-correction-request.js'; +import { StayAlignedSettingsRequest, StayAlignedSettingsRequestT } from '../../solarxr-protocol/rpc/stay-aligned-settings-request.js'; +import { StayAlignedSettingsResponse, StayAlignedSettingsResponseT } from '../../solarxr-protocol/rpc/stay-aligned-settings-response.js'; import { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; +import { TapDetectionSettingsRequest, TapDetectionSettingsRequestT } from '../../solarxr-protocol/rpc/tap-detection-settings-request.js'; +import { TapDetectionSettingsResponse, TapDetectionSettingsResponseT } from '../../solarxr-protocol/rpc/tap-detection-settings-response.js'; +import { TapDetectionSetupModeRequest, TapDetectionSetupModeRequestT } from '../../solarxr-protocol/rpc/tap-detection-setup-mode-request.js'; import { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from '../../solarxr-protocol/rpc/tap-detection-setup-notification.js'; import { TrackingChecklistRequest, TrackingChecklistRequestT } from '../../solarxr-protocol/rpc/tracking-checklist-request.js'; import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../solarxr-protocol/rpc/tracking-checklist-response.js'; @@ -86,9 +99,17 @@ import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../sol import { TrackingPauseStateResponse, TrackingPauseStateResponseT } from '../../solarxr-protocol/rpc/tracking-pause-state-response.js'; import { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-device-handshake-notification.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-response.js'; +import { VMCOSCSettingsRequest, VMCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/vmcoscsettings-request.js'; +import { VMCOSCSettingsResponse, VMCOSCSettingsResponseT } from '../../solarxr-protocol/rpc/vmcoscsettings-response.js'; import { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; import { VRCConfigStateRequest, VRCConfigStateRequestT } from '../../solarxr-protocol/rpc/vrcconfig-state-request.js'; +import { VRCOSCSettingsRequest, VRCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/vrcoscsettings-request.js'; +import { VRCOSCSettingsResponse, VRCOSCSettingsResponseT } from '../../solarxr-protocol/rpc/vrcoscsettings-response.js'; +import { VRCOSCStatusChangeResponse, VRCOSCStatusChangeResponseT } from '../../solarxr-protocol/rpc/vrcoscstatus-change-response.js'; +import { VRCOSCStatusRequest, VRCOSCStatusRequestT } from '../../solarxr-protocol/rpc/vrcoscstatus-request.js'; +import { VRMSettingsRequest, VRMSettingsRequestT } from '../../solarxr-protocol/rpc/vrmsettings-request.js'; +import { VRMSettingsResponse, VRMSettingsResponseT } from '../../solarxr-protocol/rpc/vrmsettings-response.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -111,8 +132,8 @@ static getSizePrefixedRootAsRpcMessageHeader(bb:flatbuffers.ByteBuffer, obj?:Rpc } /** - * For a request, this identifies the request. For a response, this corresponds - * to the request that it is responding to. + * For a request, this identifies the request. + * For a response, this corresponds to the request that it is responding to. */ txId(obj?:TransactionId):TransactionId|null { const offset = this.bb!.__offset(this.bb_pos, 4); @@ -186,7 +207,7 @@ export class RpcMessageHeaderT implements flatbuffers.IGeneratedObject { constructor( public txId: TransactionIdT|null = null, public messageType: RpcMessage = RpcMessage.NONE, - public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|ChangeKeybindRequestT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|EnableSteamVRDriverRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|IgnoreTrackingChecklistStepRequestT|InstalledInfoRequestT|InstalledInfoResponseT|KeybindRequestT|KeybindResponseT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|OpenUriRequestT|OpenUriResponseT|OverlayDisplayModeChangeRequestT|OverlayDisplayModeRequestT|OverlayDisplayModeResponseT|RecordBVHRequestT|RecordBVHStatusRequestT|RecordBVHStatusT|ResetRequestT|ResetResponseT|ResetStayAlignedRelaxedPoseRequestT|SaveFileNotificationT|SerialDevicesRequestT|SerialDevicesResponseT|SerialTrackerCustomCommandRequestT|SerialTrackerFactoryResetRequestT|SerialTrackerGetInfoRequestT|SerialTrackerGetWifiScanRequestT|SerialTrackerRebootRequestT|SerialUpdateResponseT|ServerInfosRequestT|ServerInfosResponseT|SetPauseTrackingRequestT|SetWifiRequestT|SettingsRequestT|SettingsResetRequestT|SettingsResponseT|SkeletonConfigRequestT|SkeletonConfigResponseT|SkeletonResetAllRequestT|StartUserHeightCalibrationT|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|WifiProvisioningStatusResponseT|null = null + public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|ChangeHIDSettingsRequestT|ChangeKeybindRequestT|ChangeMagToggleRequestT|ChangeOutputTrackersSettingsRequestT|ChangeResetsSettingsRequestT|ChangeSkeletonProportionsRequestT|ChangeSkeletonSettingsRequestT|ChangeStayAlignedSettingsRequestT|ChangeTapDetectionSettingsRequestT|ChangeVMCOSCSettingsRequestT|ChangeVRCOSCSettingsRequestT|ChangeVRMSettingsRequestT|ClearMountingResetRequestT|CloseSerialRequestT|CompleteStayAlignedResponseT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|EnableSteamVRDriverRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HIDSettingsRequestT|HIDSettingsResponseT|HeartbeatRequestT|HeartbeatResponseT|IgnoreTrackingChecklistStepRequestT|InstalledInfoRequestT|InstalledInfoResponseT|KeybindRequestT|KeybindResponseT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|OpenUriRequestT|OpenUriResponseT|OutputTrackersSettingsRequestT|OutputTrackersSettingsResponseT|OverlayDisplayModeChangeRequestT|OverlayDisplayModeRequestT|OverlayDisplayModeResponseT|RecordBVHRequestT|RecordBVHStatusRequestT|RecordBVHStatusT|ResetRequestT|ResetResponseT|ResetStayAlignedRelaxedPoseRequestT|ResetsSettingsRequestT|ResetsSettingsResponseT|SaveFileNotificationT|SerialDevicesRequestT|SerialDevicesResponseT|SerialTrackerCustomCommandRequestT|SerialTrackerFactoryResetRequestT|SerialTrackerGetInfoRequestT|SerialTrackerGetWifiScanRequestT|SerialTrackerRebootRequestT|SerialUpdateResponseT|ServerInfosRequestT|ServerInfosResponseT|SetPauseTrackingRequestT|SettingsResetRequestT|SkeletonProportionsRequestT|SkeletonProportionsResetAllRequestT|SkeletonProportionsResponseT|SkeletonSettingsRequestT|SkeletonSettingsResponseT|StartUserHeightCalibrationT|StartWifiProvisioningRequestT|StayAlignedHideCorrectionRequestT|StayAlignedSettingsRequestT|StayAlignedSettingsResponseT|StopWifiProvisioningRequestT|TapDetectionSettingsRequestT|TapDetectionSettingsResponseT|TapDetectionSetupModeRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VMCOSCSettingsRequestT|VMCOSCSettingsResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|VRCOSCSettingsRequestT|VRCOSCSettingsResponseT|VRCOSCStatusChangeResponseT|VRCOSCStatusRequestT|VRMSettingsRequestT|VRMSettingsResponseT|WifiProvisioningStatusResponseT|null = null ){} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts index 5c6dfff43..3ca8e048e 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -9,13 +9,21 @@ import { AutoBoneProcessRequest, AutoBoneProcessRequestT } from '../../solarxr-p import { AutoBoneProcessStatusResponse, AutoBoneProcessStatusResponseT } from '../../solarxr-protocol/rpc/auto-bone-process-status-response.js'; import { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from '../../solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; import { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from '../../solarxr-protocol/rpc/cancel-user-height-calibration.js'; +import { ChangeHIDSettingsRequest, ChangeHIDSettingsRequestT } from '../../solarxr-protocol/rpc/change-hidsettings-request.js'; import { ChangeKeybindRequest, ChangeKeybindRequestT } from '../../solarxr-protocol/rpc/change-keybind-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; -import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; -import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; -import { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from '../../solarxr-protocol/rpc/clear-drift-compensation-request.js'; +import { ChangeOutputTrackersSettingsRequest, ChangeOutputTrackersSettingsRequestT } from '../../solarxr-protocol/rpc/change-output-trackers-settings-request.js'; +import { ChangeResetsSettingsRequest, ChangeResetsSettingsRequestT } from '../../solarxr-protocol/rpc/change-resets-settings-request.js'; +import { ChangeSkeletonProportionsRequest, ChangeSkeletonProportionsRequestT } from '../../solarxr-protocol/rpc/change-skeleton-proportions-request.js'; +import { ChangeSkeletonSettingsRequest, ChangeSkeletonSettingsRequestT } from '../../solarxr-protocol/rpc/change-skeleton-settings-request.js'; +import { ChangeStayAlignedSettingsRequest, ChangeStayAlignedSettingsRequestT } from '../../solarxr-protocol/rpc/change-stay-aligned-settings-request.js'; +import { ChangeTapDetectionSettingsRequest, ChangeTapDetectionSettingsRequestT } from '../../solarxr-protocol/rpc/change-tap-detection-settings-request.js'; +import { ChangeVMCOSCSettingsRequest, ChangeVMCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/change-vmcoscsettings-request.js'; +import { ChangeVRCOSCSettingsRequest, ChangeVRCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/change-vrcoscsettings-request.js'; +import { ChangeVRMSettingsRequest, ChangeVRMSettingsRequestT } from '../../solarxr-protocol/rpc/change-vrmsettings-request.js'; import { ClearMountingResetRequest, ClearMountingResetRequestT } from '../../solarxr-protocol/rpc/clear-mounting-reset-request.js'; import { CloseSerialRequest, CloseSerialRequestT } from '../../solarxr-protocol/rpc/close-serial-request.js'; +import { CompleteStayAlignedResponse, CompleteStayAlignedResponseT } from '../../solarxr-protocol/rpc/complete-stay-aligned-response.js'; import { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; import { EnableStayAlignedRequest, EnableStayAlignedRequestT } from '../../solarxr-protocol/rpc/enable-stay-aligned-request.js'; import { EnableSteamVRDriverRequest, EnableSteamVRDriverRequestT } from '../../solarxr-protocol/rpc/enable-steam-vrdriver-request.js'; @@ -23,10 +31,10 @@ import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-pro import { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from '../../solarxr-protocol/rpc/firmware-update-status-response.js'; import { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from '../../solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; import { ForgetDeviceRequest, ForgetDeviceRequestT } from '../../solarxr-protocol/rpc/forget-device-request.js'; +import { HIDSettingsRequest, HIDSettingsRequestT } from '../../solarxr-protocol/rpc/hidsettings-request.js'; +import { HIDSettingsResponse, HIDSettingsResponseT } from '../../solarxr-protocol/rpc/hidsettings-response.js'; import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/heartbeat-request.js'; import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; -import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; -import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; import { InstalledInfoRequest, InstalledInfoRequestT } from '../../solarxr-protocol/rpc/installed-info-request.js'; import { InstalledInfoResponse, InstalledInfoResponseT } from '../../solarxr-protocol/rpc/installed-info-response.js'; @@ -40,6 +48,8 @@ import { NewSerialDeviceResponse, NewSerialDeviceResponseT } from '../../solarxr import { OpenSerialRequest, OpenSerialRequestT } from '../../solarxr-protocol/rpc/open-serial-request.js'; import { OpenUriRequest, OpenUriRequestT } from '../../solarxr-protocol/rpc/open-uri-request.js'; import { OpenUriResponse, OpenUriResponseT } from '../../solarxr-protocol/rpc/open-uri-response.js'; +import { OutputTrackersSettingsRequest, OutputTrackersSettingsRequestT } from '../../solarxr-protocol/rpc/output-trackers-settings-request.js'; +import { OutputTrackersSettingsResponse, OutputTrackersSettingsResponseT } from '../../solarxr-protocol/rpc/output-trackers-settings-response.js'; import { OverlayDisplayModeChangeRequest, OverlayDisplayModeChangeRequestT } from '../../solarxr-protocol/rpc/overlay-display-mode-change-request.js'; import { OverlayDisplayModeRequest, OverlayDisplayModeRequestT } from '../../solarxr-protocol/rpc/overlay-display-mode-request.js'; import { OverlayDisplayModeResponse, OverlayDisplayModeResponseT } from '../../solarxr-protocol/rpc/overlay-display-mode-response.js'; @@ -49,6 +59,8 @@ import { RecordBVHStatusRequest, RecordBVHStatusRequestT } from '../../solarxr-p import { ResetRequest, ResetRequestT } from '../../solarxr-protocol/rpc/reset-request.js'; import { ResetResponse, ResetResponseT } from '../../solarxr-protocol/rpc/reset-response.js'; import { ResetStayAlignedRelaxedPoseRequest, ResetStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/reset-stay-aligned-relaxed-pose-request.js'; +import { ResetsSettingsRequest, ResetsSettingsRequestT } from '../../solarxr-protocol/rpc/resets-settings-request.js'; +import { ResetsSettingsResponse, ResetsSettingsResponseT } from '../../solarxr-protocol/rpc/resets-settings-response.js'; import { SaveFileNotification, SaveFileNotificationT } from '../../solarxr-protocol/rpc/save-file-notification.js'; import { SerialDevicesRequest, SerialDevicesRequestT } from '../../solarxr-protocol/rpc/serial-devices-request.js'; import { SerialDevicesResponse, SerialDevicesResponseT } from '../../solarxr-protocol/rpc/serial-devices-response.js'; @@ -61,20 +73,21 @@ import { SerialUpdateResponse, SerialUpdateResponseT } from '../../solarxr-proto import { ServerInfosRequest, ServerInfosRequestT } from '../../solarxr-protocol/rpc/server-infos-request.js'; import { ServerInfosResponse, ServerInfosResponseT } from '../../solarxr-protocol/rpc/server-infos-response.js'; import { SetPauseTrackingRequest, SetPauseTrackingRequestT } from '../../solarxr-protocol/rpc/set-pause-tracking-request.js'; -import { SetWifiRequest, SetWifiRequestT } from '../../solarxr-protocol/rpc/set-wifi-request.js'; -import { SettingsRequest, SettingsRequestT } from '../../solarxr-protocol/rpc/settings-request.js'; import { SettingsResetRequest, SettingsResetRequestT } from '../../solarxr-protocol/rpc/settings-reset-request.js'; -import { SettingsResponse, SettingsResponseT } from '../../solarxr-protocol/rpc/settings-response.js'; -import { SkeletonConfigRequest, SkeletonConfigRequestT } from '../../solarxr-protocol/rpc/skeleton-config-request.js'; -import { SkeletonConfigResponse, SkeletonConfigResponseT } from '../../solarxr-protocol/rpc/skeleton-config-response.js'; -import { SkeletonResetAllRequest, SkeletonResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-reset-all-request.js'; +import { SkeletonProportionsRequest, SkeletonProportionsRequestT } from '../../solarxr-protocol/rpc/skeleton-proportions-request.js'; +import { SkeletonProportionsResetAllRequest, SkeletonProportionsResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-proportions-reset-all-request.js'; +import { SkeletonProportionsResponse, SkeletonProportionsResponseT } from '../../solarxr-protocol/rpc/skeleton-proportions-response.js'; +import { SkeletonSettingsRequest, SkeletonSettingsRequestT } from '../../solarxr-protocol/rpc/skeleton-settings-request.js'; +import { SkeletonSettingsResponse, SkeletonSettingsResponseT } from '../../solarxr-protocol/rpc/skeleton-settings-response.js'; import { StartUserHeightCalibration, StartUserHeightCalibrationT } from '../../solarxr-protocol/rpc/start-user-height-calibration.js'; import { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/start-wifi-provisioning-request.js'; -import { StatusSystemFixed, StatusSystemFixedT } from '../../solarxr-protocol/rpc/status-system-fixed.js'; -import { StatusSystemRequest, StatusSystemRequestT } from '../../solarxr-protocol/rpc/status-system-request.js'; -import { StatusSystemResponse, StatusSystemResponseT } from '../../solarxr-protocol/rpc/status-system-response.js'; -import { StatusSystemUpdate, StatusSystemUpdateT } from '../../solarxr-protocol/rpc/status-system-update.js'; +import { StayAlignedHideCorrectionRequest, StayAlignedHideCorrectionRequestT } from '../../solarxr-protocol/rpc/stay-aligned-hide-correction-request.js'; +import { StayAlignedSettingsRequest, StayAlignedSettingsRequestT } from '../../solarxr-protocol/rpc/stay-aligned-settings-request.js'; +import { StayAlignedSettingsResponse, StayAlignedSettingsResponseT } from '../../solarxr-protocol/rpc/stay-aligned-settings-response.js'; import { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; +import { TapDetectionSettingsRequest, TapDetectionSettingsRequestT } from '../../solarxr-protocol/rpc/tap-detection-settings-request.js'; +import { TapDetectionSettingsResponse, TapDetectionSettingsResponseT } from '../../solarxr-protocol/rpc/tap-detection-settings-response.js'; +import { TapDetectionSetupModeRequest, TapDetectionSetupModeRequestT } from '../../solarxr-protocol/rpc/tap-detection-setup-mode-request.js'; import { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from '../../solarxr-protocol/rpc/tap-detection-setup-notification.js'; import { TrackingChecklistRequest, TrackingChecklistRequestT } from '../../solarxr-protocol/rpc/tracking-checklist-request.js'; import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../solarxr-protocol/rpc/tracking-checklist-response.js'; @@ -82,9 +95,17 @@ import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../sol import { TrackingPauseStateResponse, TrackingPauseStateResponseT } from '../../solarxr-protocol/rpc/tracking-pause-state-response.js'; import { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-device-handshake-notification.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-response.js'; +import { VMCOSCSettingsRequest, VMCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/vmcoscsettings-request.js'; +import { VMCOSCSettingsResponse, VMCOSCSettingsResponseT } from '../../solarxr-protocol/rpc/vmcoscsettings-response.js'; import { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; import { VRCConfigStateRequest, VRCConfigStateRequestT } from '../../solarxr-protocol/rpc/vrcconfig-state-request.js'; +import { VRCOSCSettingsRequest, VRCOSCSettingsRequestT } from '../../solarxr-protocol/rpc/vrcoscsettings-request.js'; +import { VRCOSCSettingsResponse, VRCOSCSettingsResponseT } from '../../solarxr-protocol/rpc/vrcoscsettings-response.js'; +import { VRCOSCStatusChangeResponse, VRCOSCStatusChangeResponseT } from '../../solarxr-protocol/rpc/vrcoscstatus-change-response.js'; +import { VRCOSCStatusRequest, VRCOSCStatusRequestT } from '../../solarxr-protocol/rpc/vrcoscstatus-request.js'; +import { VRMSettingsRequest, VRMSettingsRequestT } from '../../solarxr-protocol/rpc/vrmsettings-request.js'; +import { VRMSettingsResponse, VRMSettingsResponseT } from '../../solarxr-protocol/rpc/vrmsettings-response.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -95,93 +116,114 @@ export enum RpcMessage { ResetRequest = 3, ResetResponse = 4, AssignTrackerRequest = 5, - SettingsRequest = 6, - SettingsResponse = 7, - ChangeSettingsRequest = 8, - ClearDriftCompensationRequest = 9, - RecordBVHRequest = 10, - RecordBVHStatus = 11, - SkeletonConfigRequest = 12, - ChangeSkeletonConfigRequest = 13, - SkeletonResetAllRequest = 14, - SkeletonConfigResponse = 15, - OpenSerialRequest = 16, - CloseSerialRequest = 17, - SetWifiRequest = 18, - SerialUpdateResponse = 19, - AutoBoneProcessRequest = 20, - AutoBoneProcessStatusResponse = 21, - AutoBoneEpochResponse = 22, - OverlayDisplayModeRequest = 23, - OverlayDisplayModeChangeRequest = 24, - OverlayDisplayModeResponse = 25, - SerialTrackerRebootRequest = 26, - SerialTrackerGetInfoRequest = 27, - SerialTrackerFactoryResetRequest = 28, - SerialDevicesRequest = 29, - SerialDevicesResponse = 30, - NewSerialDeviceResponse = 31, - StartWifiProvisioningRequest = 32, - StopWifiProvisioningRequest = 33, - WifiProvisioningStatusResponse = 34, - ServerInfosRequest = 35, - ServerInfosResponse = 36, - LegTweaksTmpChange = 37, - LegTweaksTmpClear = 38, - TapDetectionSetupNotification = 39, - SetPauseTrackingRequest = 40, - StatusSystemRequest = 41, - StatusSystemResponse = 42, - StatusSystemUpdate = 43, - StatusSystemFixed = 44, - ClearMountingResetRequest = 45, - HeightRequest = 46, - HeightResponse = 47, - AutoBoneApplyRequest = 48, - AutoBoneStopRecordingRequest = 49, - AutoBoneCancelRecordingRequest = 50, - SaveFileNotification = 51, - TrackingPauseStateRequest = 52, - TrackingPauseStateResponse = 53, - SerialTrackerGetWifiScanRequest = 54, - UnknownDeviceHandshakeNotification = 55, - AddUnknownDeviceRequest = 56, - ForgetDeviceRequest = 57, - FirmwareUpdateRequest = 58, - FirmwareUpdateStatusResponse = 59, - FirmwareUpdateStopQueuesRequest = 60, - SettingsResetRequest = 61, - MagToggleRequest = 62, - MagToggleResponse = 63, - ChangeMagToggleRequest = 64, - RecordBVHStatusRequest = 65, - VRCConfigStateRequest = 66, - VRCConfigStateChangeResponse = 67, - EnableStayAlignedRequest = 68, - DetectStayAlignedRelaxedPoseRequest = 69, - ResetStayAlignedRelaxedPoseRequest = 70, - SerialTrackerCustomCommandRequest = 71, - VRCConfigSettingToggleMute = 72, - TrackingChecklistRequest = 73, - TrackingChecklistResponse = 74, - IgnoreTrackingChecklistStepRequest = 75, - StartUserHeightCalibration = 76, - CancelUserHeightCalibration = 77, - UserHeightRecordingStatusResponse = 78, - KeybindRequest = 79, - ChangeKeybindRequest = 80, - KeybindResponse = 81, - InstalledInfoRequest = 82, - InstalledInfoResponse = 83, - OpenUriRequest = 84, - OpenUriResponse = 85, - EnableSteamVRDriverRequest = 86 + OutputTrackersSettingsRequest = 6, + OutputTrackersSettingsResponse = 7, + ChangeOutputTrackersSettingsRequest = 8, + VMCOSCSettingsRequest = 9, + VMCOSCSettingsResponse = 10, + ChangeVMCOSCSettingsRequest = 11, + VRMSettingsRequest = 12, + VRMSettingsResponse = 13, + ChangeVRMSettingsRequest = 14, + SkeletonSettingsRequest = 15, + SkeletonSettingsResponse = 16, + ChangeSkeletonSettingsRequest = 17, + TapDetectionSettingsRequest = 18, + TapDetectionSettingsResponse = 19, + ChangeTapDetectionSettingsRequest = 20, + TapDetectionSetupModeRequest = 21, + ResetsSettingsRequest = 22, + ResetsSettingsResponse = 23, + ChangeResetsSettingsRequest = 24, + StayAlignedSettingsRequest = 25, + StayAlignedSettingsResponse = 26, + ChangeStayAlignedSettingsRequest = 27, + CompleteStayAlignedResponse = 28, + StayAlignedHideCorrectionRequest = 29, + HIDSettingsRequest = 30, + HIDSettingsResponse = 31, + ChangeHIDSettingsRequest = 32, + RecordBVHRequest = 33, + RecordBVHStatus = 34, + SkeletonProportionsRequest = 35, + ChangeSkeletonProportionsRequest = 36, + SkeletonProportionsResetAllRequest = 37, + SkeletonProportionsResponse = 38, + OpenSerialRequest = 39, + CloseSerialRequest = 40, + SerialUpdateResponse = 41, + AutoBoneProcessRequest = 42, + AutoBoneProcessStatusResponse = 43, + AutoBoneEpochResponse = 44, + OverlayDisplayModeRequest = 45, + OverlayDisplayModeChangeRequest = 46, + OverlayDisplayModeResponse = 47, + SerialTrackerRebootRequest = 48, + SerialTrackerGetInfoRequest = 49, + SerialTrackerFactoryResetRequest = 50, + SerialDevicesRequest = 51, + SerialDevicesResponse = 52, + NewSerialDeviceResponse = 53, + StartWifiProvisioningRequest = 54, + StopWifiProvisioningRequest = 55, + WifiProvisioningStatusResponse = 56, + ServerInfosRequest = 57, + ServerInfosResponse = 58, + LegTweaksTmpChange = 59, + LegTweaksTmpClear = 60, + TapDetectionSetupNotification = 61, + SetPauseTrackingRequest = 62, + ClearMountingResetRequest = 63, + AutoBoneApplyRequest = 64, + AutoBoneStopRecordingRequest = 65, + AutoBoneCancelRecordingRequest = 66, + SaveFileNotification = 67, + TrackingPauseStateRequest = 68, + TrackingPauseStateResponse = 69, + SerialTrackerGetWifiScanRequest = 70, + UnknownDeviceHandshakeNotification = 71, + AddUnknownDeviceRequest = 72, + ForgetDeviceRequest = 73, + FirmwareUpdateRequest = 74, + FirmwareUpdateStatusResponse = 75, + FirmwareUpdateStopQueuesRequest = 76, + SettingsResetRequest = 77, + MagToggleRequest = 78, + MagToggleResponse = 79, + ChangeMagToggleRequest = 80, + RecordBVHStatusRequest = 81, + VRCConfigStateRequest = 82, + VRCConfigStateChangeResponse = 83, + EnableStayAlignedRequest = 84, + DetectStayAlignedRelaxedPoseRequest = 85, + ResetStayAlignedRelaxedPoseRequest = 86, + SerialTrackerCustomCommandRequest = 87, + VRCConfigSettingToggleMute = 88, + TrackingChecklistRequest = 89, + TrackingChecklistResponse = 90, + IgnoreTrackingChecklistStepRequest = 91, + StartUserHeightCalibration = 92, + CancelUserHeightCalibration = 93, + UserHeightRecordingStatusResponse = 94, + VRCOSCSettingsRequest = 95, + VRCOSCSettingsResponse = 96, + ChangeVRCOSCSettingsRequest = 97, + VRCOSCStatusRequest = 98, + VRCOSCStatusChangeResponse = 99, + KeybindRequest = 100, + ChangeKeybindRequest = 101, + KeybindResponse = 102, + InstalledInfoRequest = 103, + InstalledInfoResponse = 104, + OpenUriRequest = 105, + OpenUriResponse = 106, + EnableSteamVRDriverRequest = 107 } export function unionToRpcMessage( type: RpcMessage, - accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { + accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse|null +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -189,19 +231,41 @@ export function unionToRpcMessage( case 'ResetRequest': return accessor(new ResetRequest())! as ResetRequest; case 'ResetResponse': return accessor(new ResetResponse())! as ResetResponse; case 'AssignTrackerRequest': return accessor(new AssignTrackerRequest())! as AssignTrackerRequest; - case 'SettingsRequest': return accessor(new SettingsRequest())! as SettingsRequest; - case 'SettingsResponse': return accessor(new SettingsResponse())! as SettingsResponse; - case 'ChangeSettingsRequest': return accessor(new ChangeSettingsRequest())! as ChangeSettingsRequest; - case 'ClearDriftCompensationRequest': return accessor(new ClearDriftCompensationRequest())! as ClearDriftCompensationRequest; + case 'OutputTrackersSettingsRequest': return accessor(new OutputTrackersSettingsRequest())! as OutputTrackersSettingsRequest; + case 'OutputTrackersSettingsResponse': return accessor(new OutputTrackersSettingsResponse())! as OutputTrackersSettingsResponse; + case 'ChangeOutputTrackersSettingsRequest': return accessor(new ChangeOutputTrackersSettingsRequest())! as ChangeOutputTrackersSettingsRequest; + case 'VMCOSCSettingsRequest': return accessor(new VMCOSCSettingsRequest())! as VMCOSCSettingsRequest; + case 'VMCOSCSettingsResponse': return accessor(new VMCOSCSettingsResponse())! as VMCOSCSettingsResponse; + case 'ChangeVMCOSCSettingsRequest': return accessor(new ChangeVMCOSCSettingsRequest())! as ChangeVMCOSCSettingsRequest; + case 'VRMSettingsRequest': return accessor(new VRMSettingsRequest())! as VRMSettingsRequest; + case 'VRMSettingsResponse': return accessor(new VRMSettingsResponse())! as VRMSettingsResponse; + case 'ChangeVRMSettingsRequest': return accessor(new ChangeVRMSettingsRequest())! as ChangeVRMSettingsRequest; + case 'SkeletonSettingsRequest': return accessor(new SkeletonSettingsRequest())! as SkeletonSettingsRequest; + case 'SkeletonSettingsResponse': return accessor(new SkeletonSettingsResponse())! as SkeletonSettingsResponse; + case 'ChangeSkeletonSettingsRequest': return accessor(new ChangeSkeletonSettingsRequest())! as ChangeSkeletonSettingsRequest; + case 'TapDetectionSettingsRequest': return accessor(new TapDetectionSettingsRequest())! as TapDetectionSettingsRequest; + case 'TapDetectionSettingsResponse': return accessor(new TapDetectionSettingsResponse())! as TapDetectionSettingsResponse; + case 'ChangeTapDetectionSettingsRequest': return accessor(new ChangeTapDetectionSettingsRequest())! as ChangeTapDetectionSettingsRequest; + case 'TapDetectionSetupModeRequest': return accessor(new TapDetectionSetupModeRequest())! as TapDetectionSetupModeRequest; + case 'ResetsSettingsRequest': return accessor(new ResetsSettingsRequest())! as ResetsSettingsRequest; + case 'ResetsSettingsResponse': return accessor(new ResetsSettingsResponse())! as ResetsSettingsResponse; + case 'ChangeResetsSettingsRequest': return accessor(new ChangeResetsSettingsRequest())! as ChangeResetsSettingsRequest; + case 'StayAlignedSettingsRequest': return accessor(new StayAlignedSettingsRequest())! as StayAlignedSettingsRequest; + case 'StayAlignedSettingsResponse': return accessor(new StayAlignedSettingsResponse())! as StayAlignedSettingsResponse; + case 'ChangeStayAlignedSettingsRequest': return accessor(new ChangeStayAlignedSettingsRequest())! as ChangeStayAlignedSettingsRequest; + case 'CompleteStayAlignedResponse': return accessor(new CompleteStayAlignedResponse())! as CompleteStayAlignedResponse; + case 'StayAlignedHideCorrectionRequest': return accessor(new StayAlignedHideCorrectionRequest())! as StayAlignedHideCorrectionRequest; + case 'HIDSettingsRequest': return accessor(new HIDSettingsRequest())! as HIDSettingsRequest; + case 'HIDSettingsResponse': return accessor(new HIDSettingsResponse())! as HIDSettingsResponse; + case 'ChangeHIDSettingsRequest': return accessor(new ChangeHIDSettingsRequest())! as ChangeHIDSettingsRequest; case 'RecordBVHRequest': return accessor(new RecordBVHRequest())! as RecordBVHRequest; case 'RecordBVHStatus': return accessor(new RecordBVHStatus())! as RecordBVHStatus; - case 'SkeletonConfigRequest': return accessor(new SkeletonConfigRequest())! as SkeletonConfigRequest; - case 'ChangeSkeletonConfigRequest': return accessor(new ChangeSkeletonConfigRequest())! as ChangeSkeletonConfigRequest; - case 'SkeletonResetAllRequest': return accessor(new SkeletonResetAllRequest())! as SkeletonResetAllRequest; - case 'SkeletonConfigResponse': return accessor(new SkeletonConfigResponse())! as SkeletonConfigResponse; + case 'SkeletonProportionsRequest': return accessor(new SkeletonProportionsRequest())! as SkeletonProportionsRequest; + case 'ChangeSkeletonProportionsRequest': return accessor(new ChangeSkeletonProportionsRequest())! as ChangeSkeletonProportionsRequest; + case 'SkeletonProportionsResetAllRequest': return accessor(new SkeletonProportionsResetAllRequest())! as SkeletonProportionsResetAllRequest; + case 'SkeletonProportionsResponse': return accessor(new SkeletonProportionsResponse())! as SkeletonProportionsResponse; case 'OpenSerialRequest': return accessor(new OpenSerialRequest())! as OpenSerialRequest; case 'CloseSerialRequest': return accessor(new CloseSerialRequest())! as CloseSerialRequest; - case 'SetWifiRequest': return accessor(new SetWifiRequest())! as SetWifiRequest; case 'SerialUpdateResponse': return accessor(new SerialUpdateResponse())! as SerialUpdateResponse; case 'AutoBoneProcessRequest': return accessor(new AutoBoneProcessRequest())! as AutoBoneProcessRequest; case 'AutoBoneProcessStatusResponse': return accessor(new AutoBoneProcessStatusResponse())! as AutoBoneProcessStatusResponse; @@ -224,13 +288,7 @@ export function unionToRpcMessage( case 'LegTweaksTmpClear': return accessor(new LegTweaksTmpClear())! as LegTweaksTmpClear; case 'TapDetectionSetupNotification': return accessor(new TapDetectionSetupNotification())! as TapDetectionSetupNotification; case 'SetPauseTrackingRequest': return accessor(new SetPauseTrackingRequest())! as SetPauseTrackingRequest; - case 'StatusSystemRequest': return accessor(new StatusSystemRequest())! as StatusSystemRequest; - case 'StatusSystemResponse': return accessor(new StatusSystemResponse())! as StatusSystemResponse; - case 'StatusSystemUpdate': return accessor(new StatusSystemUpdate())! as StatusSystemUpdate; - case 'StatusSystemFixed': return accessor(new StatusSystemFixed())! as StatusSystemFixed; case 'ClearMountingResetRequest': return accessor(new ClearMountingResetRequest())! as ClearMountingResetRequest; - case 'HeightRequest': return accessor(new HeightRequest())! as HeightRequest; - case 'HeightResponse': return accessor(new HeightResponse())! as HeightResponse; case 'AutoBoneApplyRequest': return accessor(new AutoBoneApplyRequest())! as AutoBoneApplyRequest; case 'AutoBoneStopRecordingRequest': return accessor(new AutoBoneStopRecordingRequest())! as AutoBoneStopRecordingRequest; case 'AutoBoneCancelRecordingRequest': return accessor(new AutoBoneCancelRecordingRequest())! as AutoBoneCancelRecordingRequest; @@ -262,6 +320,11 @@ export function unionToRpcMessage( case 'StartUserHeightCalibration': return accessor(new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'VRCOSCSettingsRequest': return accessor(new VRCOSCSettingsRequest())! as VRCOSCSettingsRequest; + case 'VRCOSCSettingsResponse': return accessor(new VRCOSCSettingsResponse())! as VRCOSCSettingsResponse; + case 'ChangeVRCOSCSettingsRequest': return accessor(new ChangeVRCOSCSettingsRequest())! as ChangeVRCOSCSettingsRequest; + case 'VRCOSCStatusRequest': return accessor(new VRCOSCStatusRequest())! as VRCOSCStatusRequest; + case 'VRCOSCStatusChangeResponse': return accessor(new VRCOSCStatusChangeResponse())! as VRCOSCStatusChangeResponse; case 'KeybindRequest': return accessor(new KeybindRequest())! as KeybindRequest; case 'ChangeKeybindRequest': return accessor(new ChangeKeybindRequest())! as ChangeKeybindRequest; case 'KeybindResponse': return accessor(new KeybindResponse())! as KeybindResponse; @@ -276,9 +339,9 @@ export function unionToRpcMessage( export function unionListToRpcMessage( type: RpcMessage, - accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, + accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse|null, index: number -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeHIDSettingsRequest|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeOutputTrackersSettingsRequest|ChangeResetsSettingsRequest|ChangeSkeletonProportionsRequest|ChangeSkeletonSettingsRequest|ChangeStayAlignedSettingsRequest|ChangeTapDetectionSettingsRequest|ChangeVMCOSCSettingsRequest|ChangeVRCOSCSettingsRequest|ChangeVRMSettingsRequest|ClearMountingResetRequest|CloseSerialRequest|CompleteStayAlignedResponse|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|EnableSteamVRDriverRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDSettingsRequest|HIDSettingsResponse|HeartbeatRequest|HeartbeatResponse|IgnoreTrackingChecklistStepRequest|InstalledInfoRequest|InstalledInfoResponse|KeybindRequest|KeybindResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OpenUriRequest|OpenUriResponse|OutputTrackersSettingsRequest|OutputTrackersSettingsResponse|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|ResetsSettingsRequest|ResetsSettingsResponse|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SettingsResetRequest|SkeletonProportionsRequest|SkeletonProportionsResetAllRequest|SkeletonProportionsResponse|SkeletonSettingsRequest|SkeletonSettingsResponse|StartUserHeightCalibration|StartWifiProvisioningRequest|StayAlignedHideCorrectionRequest|StayAlignedSettingsRequest|StayAlignedSettingsResponse|StopWifiProvisioningRequest|TapDetectionSettingsRequest|TapDetectionSettingsResponse|TapDetectionSetupModeRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VMCOSCSettingsRequest|VMCOSCSettingsResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VRCOSCSettingsRequest|VRCOSCSettingsResponse|VRCOSCStatusChangeResponse|VRCOSCStatusRequest|VRMSettingsRequest|VRMSettingsResponse|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -286,19 +349,41 @@ export function unionListToRpcMessage( case 'ResetRequest': return accessor(index, new ResetRequest())! as ResetRequest; case 'ResetResponse': return accessor(index, new ResetResponse())! as ResetResponse; case 'AssignTrackerRequest': return accessor(index, new AssignTrackerRequest())! as AssignTrackerRequest; - case 'SettingsRequest': return accessor(index, new SettingsRequest())! as SettingsRequest; - case 'SettingsResponse': return accessor(index, new SettingsResponse())! as SettingsResponse; - case 'ChangeSettingsRequest': return accessor(index, new ChangeSettingsRequest())! as ChangeSettingsRequest; - case 'ClearDriftCompensationRequest': return accessor(index, new ClearDriftCompensationRequest())! as ClearDriftCompensationRequest; + case 'OutputTrackersSettingsRequest': return accessor(index, new OutputTrackersSettingsRequest())! as OutputTrackersSettingsRequest; + case 'OutputTrackersSettingsResponse': return accessor(index, new OutputTrackersSettingsResponse())! as OutputTrackersSettingsResponse; + case 'ChangeOutputTrackersSettingsRequest': return accessor(index, new ChangeOutputTrackersSettingsRequest())! as ChangeOutputTrackersSettingsRequest; + case 'VMCOSCSettingsRequest': return accessor(index, new VMCOSCSettingsRequest())! as VMCOSCSettingsRequest; + case 'VMCOSCSettingsResponse': return accessor(index, new VMCOSCSettingsResponse())! as VMCOSCSettingsResponse; + case 'ChangeVMCOSCSettingsRequest': return accessor(index, new ChangeVMCOSCSettingsRequest())! as ChangeVMCOSCSettingsRequest; + case 'VRMSettingsRequest': return accessor(index, new VRMSettingsRequest())! as VRMSettingsRequest; + case 'VRMSettingsResponse': return accessor(index, new VRMSettingsResponse())! as VRMSettingsResponse; + case 'ChangeVRMSettingsRequest': return accessor(index, new ChangeVRMSettingsRequest())! as ChangeVRMSettingsRequest; + case 'SkeletonSettingsRequest': return accessor(index, new SkeletonSettingsRequest())! as SkeletonSettingsRequest; + case 'SkeletonSettingsResponse': return accessor(index, new SkeletonSettingsResponse())! as SkeletonSettingsResponse; + case 'ChangeSkeletonSettingsRequest': return accessor(index, new ChangeSkeletonSettingsRequest())! as ChangeSkeletonSettingsRequest; + case 'TapDetectionSettingsRequest': return accessor(index, new TapDetectionSettingsRequest())! as TapDetectionSettingsRequest; + case 'TapDetectionSettingsResponse': return accessor(index, new TapDetectionSettingsResponse())! as TapDetectionSettingsResponse; + case 'ChangeTapDetectionSettingsRequest': return accessor(index, new ChangeTapDetectionSettingsRequest())! as ChangeTapDetectionSettingsRequest; + case 'TapDetectionSetupModeRequest': return accessor(index, new TapDetectionSetupModeRequest())! as TapDetectionSetupModeRequest; + case 'ResetsSettingsRequest': return accessor(index, new ResetsSettingsRequest())! as ResetsSettingsRequest; + case 'ResetsSettingsResponse': return accessor(index, new ResetsSettingsResponse())! as ResetsSettingsResponse; + case 'ChangeResetsSettingsRequest': return accessor(index, new ChangeResetsSettingsRequest())! as ChangeResetsSettingsRequest; + case 'StayAlignedSettingsRequest': return accessor(index, new StayAlignedSettingsRequest())! as StayAlignedSettingsRequest; + case 'StayAlignedSettingsResponse': return accessor(index, new StayAlignedSettingsResponse())! as StayAlignedSettingsResponse; + case 'ChangeStayAlignedSettingsRequest': return accessor(index, new ChangeStayAlignedSettingsRequest())! as ChangeStayAlignedSettingsRequest; + case 'CompleteStayAlignedResponse': return accessor(index, new CompleteStayAlignedResponse())! as CompleteStayAlignedResponse; + case 'StayAlignedHideCorrectionRequest': return accessor(index, new StayAlignedHideCorrectionRequest())! as StayAlignedHideCorrectionRequest; + case 'HIDSettingsRequest': return accessor(index, new HIDSettingsRequest())! as HIDSettingsRequest; + case 'HIDSettingsResponse': return accessor(index, new HIDSettingsResponse())! as HIDSettingsResponse; + case 'ChangeHIDSettingsRequest': return accessor(index, new ChangeHIDSettingsRequest())! as ChangeHIDSettingsRequest; case 'RecordBVHRequest': return accessor(index, new RecordBVHRequest())! as RecordBVHRequest; case 'RecordBVHStatus': return accessor(index, new RecordBVHStatus())! as RecordBVHStatus; - case 'SkeletonConfigRequest': return accessor(index, new SkeletonConfigRequest())! as SkeletonConfigRequest; - case 'ChangeSkeletonConfigRequest': return accessor(index, new ChangeSkeletonConfigRequest())! as ChangeSkeletonConfigRequest; - case 'SkeletonResetAllRequest': return accessor(index, new SkeletonResetAllRequest())! as SkeletonResetAllRequest; - case 'SkeletonConfigResponse': return accessor(index, new SkeletonConfigResponse())! as SkeletonConfigResponse; + case 'SkeletonProportionsRequest': return accessor(index, new SkeletonProportionsRequest())! as SkeletonProportionsRequest; + case 'ChangeSkeletonProportionsRequest': return accessor(index, new ChangeSkeletonProportionsRequest())! as ChangeSkeletonProportionsRequest; + case 'SkeletonProportionsResetAllRequest': return accessor(index, new SkeletonProportionsResetAllRequest())! as SkeletonProportionsResetAllRequest; + case 'SkeletonProportionsResponse': return accessor(index, new SkeletonProportionsResponse())! as SkeletonProportionsResponse; case 'OpenSerialRequest': return accessor(index, new OpenSerialRequest())! as OpenSerialRequest; case 'CloseSerialRequest': return accessor(index, new CloseSerialRequest())! as CloseSerialRequest; - case 'SetWifiRequest': return accessor(index, new SetWifiRequest())! as SetWifiRequest; case 'SerialUpdateResponse': return accessor(index, new SerialUpdateResponse())! as SerialUpdateResponse; case 'AutoBoneProcessRequest': return accessor(index, new AutoBoneProcessRequest())! as AutoBoneProcessRequest; case 'AutoBoneProcessStatusResponse': return accessor(index, new AutoBoneProcessStatusResponse())! as AutoBoneProcessStatusResponse; @@ -321,13 +406,7 @@ export function unionListToRpcMessage( case 'LegTweaksTmpClear': return accessor(index, new LegTweaksTmpClear())! as LegTweaksTmpClear; case 'TapDetectionSetupNotification': return accessor(index, new TapDetectionSetupNotification())! as TapDetectionSetupNotification; case 'SetPauseTrackingRequest': return accessor(index, new SetPauseTrackingRequest())! as SetPauseTrackingRequest; - case 'StatusSystemRequest': return accessor(index, new StatusSystemRequest())! as StatusSystemRequest; - case 'StatusSystemResponse': return accessor(index, new StatusSystemResponse())! as StatusSystemResponse; - case 'StatusSystemUpdate': return accessor(index, new StatusSystemUpdate())! as StatusSystemUpdate; - case 'StatusSystemFixed': return accessor(index, new StatusSystemFixed())! as StatusSystemFixed; case 'ClearMountingResetRequest': return accessor(index, new ClearMountingResetRequest())! as ClearMountingResetRequest; - case 'HeightRequest': return accessor(index, new HeightRequest())! as HeightRequest; - case 'HeightResponse': return accessor(index, new HeightResponse())! as HeightResponse; case 'AutoBoneApplyRequest': return accessor(index, new AutoBoneApplyRequest())! as AutoBoneApplyRequest; case 'AutoBoneStopRecordingRequest': return accessor(index, new AutoBoneStopRecordingRequest())! as AutoBoneStopRecordingRequest; case 'AutoBoneCancelRecordingRequest': return accessor(index, new AutoBoneCancelRecordingRequest())! as AutoBoneCancelRecordingRequest; @@ -359,6 +438,11 @@ export function unionListToRpcMessage( case 'StartUserHeightCalibration': return accessor(index, new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(index, new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(index, new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'VRCOSCSettingsRequest': return accessor(index, new VRCOSCSettingsRequest())! as VRCOSCSettingsRequest; + case 'VRCOSCSettingsResponse': return accessor(index, new VRCOSCSettingsResponse())! as VRCOSCSettingsResponse; + case 'ChangeVRCOSCSettingsRequest': return accessor(index, new ChangeVRCOSCSettingsRequest())! as ChangeVRCOSCSettingsRequest; + case 'VRCOSCStatusRequest': return accessor(index, new VRCOSCStatusRequest())! as VRCOSCStatusRequest; + case 'VRCOSCStatusChangeResponse': return accessor(index, new VRCOSCStatusChangeResponse())! as VRCOSCStatusChangeResponse; case 'KeybindRequest': return accessor(index, new KeybindRequest())! as KeybindRequest; case 'ChangeKeybindRequest': return accessor(index, new ChangeKeybindRequest())! as ChangeKeybindRequest; case 'KeybindResponse': return accessor(index, new KeybindResponse())! as KeybindResponse; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/save-file-notification.ts b/protocol/typescript/src/solarxr-protocol/rpc/save-file-notification.ts index 619e524e8..ec1705f57 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/save-file-notification.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/save-file-notification.ts @@ -45,7 +45,7 @@ dataArray():Uint8Array|null { } /** - * MIME type of file if one exists, use `file_extension` otherwise + * MIME type of file if one exists, use `extension` otherwise */ mimeType():string|null mimeType(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null @@ -57,9 +57,9 @@ mimeType(optionalEncoding?:any):string|Uint8Array|null { /** * Use MIME type preferably if one exists */ -fileExtension():string|null -fileExtension(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -fileExtension(optionalEncoding?:any):string|Uint8Array|null { +extension():string|null +extension(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +extension(optionalEncoding?:any):string|Uint8Array|null { const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; } @@ -106,8 +106,8 @@ static addMimeType(builder:flatbuffers.Builder, mimeTypeOffset:flatbuffers.Offse builder.addFieldOffset(1, mimeTypeOffset, 0); } -static addFileExtension(builder:flatbuffers.Builder, fileExtensionOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, fileExtensionOffset, 0); +static addExtension(builder:flatbuffers.Builder, extensionOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, extensionOffset, 0); } static addExpectedDir(builder:flatbuffers.Builder, expectedDir:ComputerDirectory) { @@ -123,11 +123,11 @@ static endSaveFileNotification(builder:flatbuffers.Builder):flatbuffers.Offset { return offset; } -static createSaveFileNotification(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset, mimeTypeOffset:flatbuffers.Offset, fileExtensionOffset:flatbuffers.Offset, expectedDir:ComputerDirectory|null, expectedFilenameOffset:flatbuffers.Offset):flatbuffers.Offset { +static createSaveFileNotification(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset, mimeTypeOffset:flatbuffers.Offset, extensionOffset:flatbuffers.Offset, expectedDir:ComputerDirectory|null, expectedFilenameOffset:flatbuffers.Offset):flatbuffers.Offset { SaveFileNotification.startSaveFileNotification(builder); SaveFileNotification.addData(builder, dataOffset); SaveFileNotification.addMimeType(builder, mimeTypeOffset); - SaveFileNotification.addFileExtension(builder, fileExtensionOffset); + SaveFileNotification.addExtension(builder, extensionOffset); if (expectedDir !== null) SaveFileNotification.addExpectedDir(builder, expectedDir); SaveFileNotification.addExpectedFilename(builder, expectedFilenameOffset); @@ -138,7 +138,7 @@ unpack(): SaveFileNotificationT { return new SaveFileNotificationT( this.bb!.createScalarList(this.data.bind(this), this.dataLength()), this.mimeType(), - this.fileExtension(), + this.extension(), this.expectedDir(), this.expectedFilename() ); @@ -148,7 +148,7 @@ unpack(): SaveFileNotificationT { unpackTo(_o: SaveFileNotificationT): void { _o.data = this.bb!.createScalarList(this.data.bind(this), this.dataLength()); _o.mimeType = this.mimeType(); - _o.fileExtension = this.fileExtension(); + _o.extension = this.extension(); _o.expectedDir = this.expectedDir(); _o.expectedFilename = this.expectedFilename(); } @@ -158,7 +158,7 @@ export class SaveFileNotificationT implements flatbuffers.IGeneratedObject { constructor( public data: (number)[] = [], public mimeType: string|Uint8Array|null = null, - public fileExtension: string|Uint8Array|null = null, + public extension: string|Uint8Array|null = null, public expectedDir: ComputerDirectory|null = null, public expectedFilename: string|Uint8Array|null = null ){} @@ -167,13 +167,13 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { const data = SaveFileNotification.createDataVector(builder, this.data); const mimeType = (this.mimeType !== null ? builder.createString(this.mimeType!) : 0); - const fileExtension = (this.fileExtension !== null ? builder.createString(this.fileExtension!) : 0); + const extension = (this.extension !== null ? builder.createString(this.extension!) : 0); const expectedFilename = (this.expectedFilename !== null ? builder.createString(this.expectedFilename!) : 0); return SaveFileNotification.createSaveFileNotification(builder, data, mimeType, - fileExtension, + extension, this.expectedDir, expectedFilename ); diff --git a/protocol/typescript/src/solarxr-protocol/rpc/set-wifi-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/set-wifi-request.ts deleted file mode 100644 index d6ee4d931..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/set-wifi-request.ts +++ /dev/null @@ -1,93 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class SetWifiRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SetWifiRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSetWifiRequest(bb:flatbuffers.ByteBuffer, obj?:SetWifiRequest):SetWifiRequest { - return (obj || new SetWifiRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSetWifiRequest(bb:flatbuffers.ByteBuffer, obj?:SetWifiRequest):SetWifiRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SetWifiRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -ssid():string|null -ssid(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -ssid(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -password():string|null -password(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -password(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startSetWifiRequest(builder:flatbuffers.Builder) { - builder.startObject(2); -} - -static addSsid(builder:flatbuffers.Builder, ssidOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, ssidOffset, 0); -} - -static addPassword(builder:flatbuffers.Builder, passwordOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, passwordOffset, 0); -} - -static endSetWifiRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSetWifiRequest(builder:flatbuffers.Builder, ssidOffset:flatbuffers.Offset, passwordOffset:flatbuffers.Offset):flatbuffers.Offset { - SetWifiRequest.startSetWifiRequest(builder); - SetWifiRequest.addSsid(builder, ssidOffset); - SetWifiRequest.addPassword(builder, passwordOffset); - return SetWifiRequest.endSetWifiRequest(builder); -} - -unpack(): SetWifiRequestT { - return new SetWifiRequestT( - this.ssid(), - this.password() - ); -} - - -unpackTo(_o: SetWifiRequestT): void { - _o.ssid = this.ssid(); - _o.password = this.password(); -} -} - -export class SetWifiRequestT implements flatbuffers.IGeneratedObject { -constructor( - public ssid: string|Uint8Array|null = null, - public password: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const ssid = (this.ssid !== null ? builder.createString(this.ssid!) : 0); - const password = (this.password !== null ? builder.createString(this.password!) : 0); - - return SetWifiRequest.createSetWifiRequest(builder, - ssid, - password - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings-request.ts deleted file mode 100644 index b7bf2a3ba..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings-request.ts +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class SettingsRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SettingsRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:SettingsRequest):SettingsRequest { - return (obj || new SettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:SettingsRequest):SettingsRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startSettingsRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - SettingsRequest.startSettingsRequest(builder); - return SettingsRequest.endSettingsRequest(builder); -} - -unpack(): SettingsRequestT { - return new SettingsRequestT(); -} - - -unpackTo(_o: SettingsRequestT): void {} -} - -export class SettingsRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return SettingsRequest.createSettingsRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings-reset-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings-reset-request.ts index b7179aad4..58c155bed 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings-reset-request.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/settings-reset-request.ts @@ -4,6 +4,9 @@ import * as flatbuffers from 'flatbuffers'; +/** + * Resets the server settings + */ export class SettingsResetRequest implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings-response.ts deleted file mode 100644 index 4cbaf3d56..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings-response.ts +++ /dev/null @@ -1,281 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { AutoBoneSettings, AutoBoneSettingsT } from '../../solarxr-protocol/rpc/auto-bone-settings.js'; -import { DriftCompensationSettings, DriftCompensationSettingsT } from '../../solarxr-protocol/rpc/drift-compensation-settings.js'; -import { FilteringSettings, FilteringSettingsT } from '../../solarxr-protocol/rpc/filtering-settings.js'; -import { HIDSettings, HIDSettingsT } from '../../solarxr-protocol/rpc/hidsettings.js'; -import { OSCRouterSettings, OSCRouterSettingsT } from '../../solarxr-protocol/rpc/oscrouter-settings.js'; -import { ResetsSettings, ResetsSettingsT } from '../../solarxr-protocol/rpc/resets-settings.js'; -import { StayAlignedSettings, StayAlignedSettingsT } from '../../solarxr-protocol/rpc/stay-aligned-settings.js'; -import { SteamVRTrackersSetting, SteamVRTrackersSettingT } from '../../solarxr-protocol/rpc/steam-vrtrackers-setting.js'; -import { TapDetectionSettings, TapDetectionSettingsT } from '../../solarxr-protocol/rpc/tap-detection-settings.js'; -import { TimeoutSettings, TimeoutSettingsT } from '../../solarxr-protocol/rpc/timeout-settings.js'; -import { VMCOSCSettings, VMCOSCSettingsT } from '../../solarxr-protocol/rpc/vmcoscsettings.js'; -import { VRCOSCSettings, VRCOSCSettingsT } from '../../solarxr-protocol/rpc/vrcoscsettings.js'; -import { VRMSettings, VRMSettingsT } from '../../solarxr-protocol/rpc/vrmsettings.js'; -import { VelocitySettings, VelocitySettingsT } from '../../solarxr-protocol/rpc/velocity-settings.js'; -import { ModelSettings, ModelSettingsT } from '../../solarxr-protocol/rpc/settings/model-settings.js'; - - -export class SettingsResponse implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SettingsResponse { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:SettingsResponse):SettingsResponse { - return (obj || new SettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:SettingsResponse):SettingsResponse { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -steamVrTrackers(obj?:SteamVRTrackersSetting):SteamVRTrackersSetting|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new SteamVRTrackersSetting()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -filtering(obj?:FilteringSettings):FilteringSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new FilteringSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -driftCompensation(obj?:DriftCompensationSettings):DriftCompensationSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new DriftCompensationSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -oscRouter(obj?:OSCRouterSettings):OSCRouterSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? (obj || new OSCRouterSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vrcOsc(obj?:VRCOSCSettings):VRCOSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? (obj || new VRCOSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vmcOsc(obj?:VMCOSCSettings):VMCOSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? (obj || new VMCOSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -modelSettings(obj?:ModelSettings):ModelSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? (obj || new ModelSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -tapDetectionSettings(obj?:TapDetectionSettings):TapDetectionSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? (obj || new TapDetectionSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -autoBoneSettings(obj?:AutoBoneSettings):AutoBoneSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? (obj || new AutoBoneSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -resetsSettings(obj?:ResetsSettings):ResetsSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? (obj || new ResetsSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -stayAligned(obj?:StayAlignedSettings):StayAlignedSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? (obj || new StayAlignedSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -hidSettings(obj?:HIDSettings):HIDSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? (obj || new HIDSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -timeout(obj?:TimeoutSettings):TimeoutSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 28); - return offset ? (obj || new TimeoutSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -velocitySettings(obj?:VelocitySettings):VelocitySettings|null { - const offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? (obj || new VelocitySettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -vrm(obj?:VRMSettings):VRMSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 32); - return offset ? (obj || new VRMSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startSettingsResponse(builder:flatbuffers.Builder) { - builder.startObject(15); -} - -static addSteamVrTrackers(builder:flatbuffers.Builder, steamVrTrackersOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, steamVrTrackersOffset, 0); -} - -static addFiltering(builder:flatbuffers.Builder, filteringOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, filteringOffset, 0); -} - -static addDriftCompensation(builder:flatbuffers.Builder, driftCompensationOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, driftCompensationOffset, 0); -} - -static addOscRouter(builder:flatbuffers.Builder, oscRouterOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, oscRouterOffset, 0); -} - -static addVrcOsc(builder:flatbuffers.Builder, vrcOscOffset:flatbuffers.Offset) { - builder.addFieldOffset(4, vrcOscOffset, 0); -} - -static addVmcOsc(builder:flatbuffers.Builder, vmcOscOffset:flatbuffers.Offset) { - builder.addFieldOffset(5, vmcOscOffset, 0); -} - -static addModelSettings(builder:flatbuffers.Builder, modelSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(6, modelSettingsOffset, 0); -} - -static addTapDetectionSettings(builder:flatbuffers.Builder, tapDetectionSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(7, tapDetectionSettingsOffset, 0); -} - -static addAutoBoneSettings(builder:flatbuffers.Builder, autoBoneSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(8, autoBoneSettingsOffset, 0); -} - -static addResetsSettings(builder:flatbuffers.Builder, resetsSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(9, resetsSettingsOffset, 0); -} - -static addStayAligned(builder:flatbuffers.Builder, stayAlignedOffset:flatbuffers.Offset) { - builder.addFieldOffset(10, stayAlignedOffset, 0); -} - -static addHidSettings(builder:flatbuffers.Builder, hidSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(11, hidSettingsOffset, 0); -} - -static addTimeout(builder:flatbuffers.Builder, timeoutOffset:flatbuffers.Offset) { - builder.addFieldOffset(12, timeoutOffset, 0); -} - -static addVelocitySettings(builder:flatbuffers.Builder, velocitySettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(13, velocitySettingsOffset, 0); -} - -static addVrm(builder:flatbuffers.Builder, vrmOffset:flatbuffers.Offset) { - builder.addFieldOffset(14, vrmOffset, 0); -} - -static endSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - - -unpack(): SettingsResponseT { - return new SettingsResponseT( - (this.steamVrTrackers() !== null ? this.steamVrTrackers()!.unpack() : null), - (this.filtering() !== null ? this.filtering()!.unpack() : null), - (this.driftCompensation() !== null ? this.driftCompensation()!.unpack() : null), - (this.oscRouter() !== null ? this.oscRouter()!.unpack() : null), - (this.vrcOsc() !== null ? this.vrcOsc()!.unpack() : null), - (this.vmcOsc() !== null ? this.vmcOsc()!.unpack() : null), - (this.modelSettings() !== null ? this.modelSettings()!.unpack() : null), - (this.tapDetectionSettings() !== null ? this.tapDetectionSettings()!.unpack() : null), - (this.autoBoneSettings() !== null ? this.autoBoneSettings()!.unpack() : null), - (this.resetsSettings() !== null ? this.resetsSettings()!.unpack() : null), - (this.stayAligned() !== null ? this.stayAligned()!.unpack() : null), - (this.hidSettings() !== null ? this.hidSettings()!.unpack() : null), - (this.timeout() !== null ? this.timeout()!.unpack() : null), - (this.velocitySettings() !== null ? this.velocitySettings()!.unpack() : null), - (this.vrm() !== null ? this.vrm()!.unpack() : null) - ); -} - - -unpackTo(_o: SettingsResponseT): void { - _o.steamVrTrackers = (this.steamVrTrackers() !== null ? this.steamVrTrackers()!.unpack() : null); - _o.filtering = (this.filtering() !== null ? this.filtering()!.unpack() : null); - _o.driftCompensation = (this.driftCompensation() !== null ? this.driftCompensation()!.unpack() : null); - _o.oscRouter = (this.oscRouter() !== null ? this.oscRouter()!.unpack() : null); - _o.vrcOsc = (this.vrcOsc() !== null ? this.vrcOsc()!.unpack() : null); - _o.vmcOsc = (this.vmcOsc() !== null ? this.vmcOsc()!.unpack() : null); - _o.modelSettings = (this.modelSettings() !== null ? this.modelSettings()!.unpack() : null); - _o.tapDetectionSettings = (this.tapDetectionSettings() !== null ? this.tapDetectionSettings()!.unpack() : null); - _o.autoBoneSettings = (this.autoBoneSettings() !== null ? this.autoBoneSettings()!.unpack() : null); - _o.resetsSettings = (this.resetsSettings() !== null ? this.resetsSettings()!.unpack() : null); - _o.stayAligned = (this.stayAligned() !== null ? this.stayAligned()!.unpack() : null); - _o.hidSettings = (this.hidSettings() !== null ? this.hidSettings()!.unpack() : null); - _o.timeout = (this.timeout() !== null ? this.timeout()!.unpack() : null); - _o.velocitySettings = (this.velocitySettings() !== null ? this.velocitySettings()!.unpack() : null); - _o.vrm = (this.vrm() !== null ? this.vrm()!.unpack() : null); -} -} - -export class SettingsResponseT implements flatbuffers.IGeneratedObject { -constructor( - public steamVrTrackers: SteamVRTrackersSettingT|null = null, - public filtering: FilteringSettingsT|null = null, - public driftCompensation: DriftCompensationSettingsT|null = null, - public oscRouter: OSCRouterSettingsT|null = null, - public vrcOsc: VRCOSCSettingsT|null = null, - public vmcOsc: VMCOSCSettingsT|null = null, - public modelSettings: ModelSettingsT|null = null, - public tapDetectionSettings: TapDetectionSettingsT|null = null, - public autoBoneSettings: AutoBoneSettingsT|null = null, - public resetsSettings: ResetsSettingsT|null = null, - public stayAligned: StayAlignedSettingsT|null = null, - public hidSettings: HIDSettingsT|null = null, - public timeout: TimeoutSettingsT|null = null, - public velocitySettings: VelocitySettingsT|null = null, - public vrm: VRMSettingsT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const steamVrTrackers = (this.steamVrTrackers !== null ? this.steamVrTrackers!.pack(builder) : 0); - const filtering = (this.filtering !== null ? this.filtering!.pack(builder) : 0); - const driftCompensation = (this.driftCompensation !== null ? this.driftCompensation!.pack(builder) : 0); - const oscRouter = (this.oscRouter !== null ? this.oscRouter!.pack(builder) : 0); - const vrcOsc = (this.vrcOsc !== null ? this.vrcOsc!.pack(builder) : 0); - const vmcOsc = (this.vmcOsc !== null ? this.vmcOsc!.pack(builder) : 0); - const modelSettings = (this.modelSettings !== null ? this.modelSettings!.pack(builder) : 0); - const tapDetectionSettings = (this.tapDetectionSettings !== null ? this.tapDetectionSettings!.pack(builder) : 0); - const autoBoneSettings = (this.autoBoneSettings !== null ? this.autoBoneSettings!.pack(builder) : 0); - const resetsSettings = (this.resetsSettings !== null ? this.resetsSettings!.pack(builder) : 0); - const stayAligned = (this.stayAligned !== null ? this.stayAligned!.pack(builder) : 0); - const hidSettings = (this.hidSettings !== null ? this.hidSettings!.pack(builder) : 0); - const timeout = (this.timeout !== null ? this.timeout!.pack(builder) : 0); - const velocitySettings = (this.velocitySettings !== null ? this.velocitySettings!.pack(builder) : 0); - const vrm = (this.vrm !== null ? this.vrm!.pack(builder) : 0); - - SettingsResponse.startSettingsResponse(builder); - SettingsResponse.addSteamVrTrackers(builder, steamVrTrackers); - SettingsResponse.addFiltering(builder, filtering); - SettingsResponse.addDriftCompensation(builder, driftCompensation); - SettingsResponse.addOscRouter(builder, oscRouter); - SettingsResponse.addVrcOsc(builder, vrcOsc); - SettingsResponse.addVmcOsc(builder, vmcOsc); - SettingsResponse.addModelSettings(builder, modelSettings); - SettingsResponse.addTapDetectionSettings(builder, tapDetectionSettings); - SettingsResponse.addAutoBoneSettings(builder, autoBoneSettings); - SettingsResponse.addResetsSettings(builder, resetsSettings); - SettingsResponse.addStayAligned(builder, stayAligned); - SettingsResponse.addHidSettings(builder, hidSettings); - SettingsResponse.addTimeout(builder, timeout); - SettingsResponse.addVelocitySettings(builder, velocitySettings); - SettingsResponse.addVrm(builder, vrm); - - return SettingsResponse.endSettingsResponse(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings/leg-tweaks-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings/leg-tweaks-settings.ts deleted file mode 100644 index 43a066a2c..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings/leg-tweaks-settings.ts +++ /dev/null @@ -1,73 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class LegTweaksSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):LegTweaksSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsLegTweaksSettings(bb:flatbuffers.ByteBuffer, obj?:LegTweaksSettings):LegTweaksSettings { - return (obj || new LegTweaksSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsLegTweaksSettings(bb:flatbuffers.ByteBuffer, obj?:LegTweaksSettings):LegTweaksSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new LegTweaksSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -correctionStrength():number|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -static startLegTweaksSettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addCorrectionStrength(builder:flatbuffers.Builder, correctionStrength:number) { - builder.addFieldFloat32(0, correctionStrength, 0); -} - -static endLegTweaksSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createLegTweaksSettings(builder:flatbuffers.Builder, correctionStrength:number|null):flatbuffers.Offset { - LegTweaksSettings.startLegTweaksSettings(builder); - if (correctionStrength !== null) - LegTweaksSettings.addCorrectionStrength(builder, correctionStrength); - return LegTweaksSettings.endLegTweaksSettings(builder); -} - -unpack(): LegTweaksSettingsT { - return new LegTweaksSettingsT( - this.correctionStrength() - ); -} - - -unpackTo(_o: LegTweaksSettingsT): void { - _o.correctionStrength = this.correctionStrength(); -} -} - -export class LegTweaksSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public correctionStrength: number|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return LegTweaksSettings.createLegTweaksSettings(builder, - this.correctionStrength - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-ratios.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings/model-ratios.ts deleted file mode 100644 index 878e91639..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-ratios.ts +++ /dev/null @@ -1,176 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * Settings for the skeletal model that are ratios. - * These values range from 0 to 1. - */ -export class ModelRatios implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ModelRatios { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsModelRatios(bb:flatbuffers.ByteBuffer, obj?:ModelRatios):ModelRatios { - return (obj || new ModelRatios()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsModelRatios(bb:flatbuffers.ByteBuffer, obj?:ModelRatios):ModelRatios { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ModelRatios()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -imputeWaistFromChestHip():number|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -imputeWaistFromChestLegs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -imputeHipFromChestLegs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -imputeHipFromWaistLegs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -/** - * Hip's yaw and roll is set to the average of legs when 1.0 - */ -interpHipLegs():number|null { - const offset = this.bb!.__offset(this.bb_pos, 12); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -/** - * Knee trackers' yaw and roll is set to the lower leg's when 1.0 - */ -interpKneeTrackerAnkle():number|null { - const offset = this.bb!.__offset(this.bb_pos, 14); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -/** - * Upper leg's yaw and roll is set to the lower leg's when 1.0 - */ -interpKneeAnkle():number|null { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; -} - -static startModelRatios(builder:flatbuffers.Builder) { - builder.startObject(7); -} - -static addImputeWaistFromChestHip(builder:flatbuffers.Builder, imputeWaistFromChestHip:number) { - builder.addFieldFloat32(0, imputeWaistFromChestHip, 0); -} - -static addImputeWaistFromChestLegs(builder:flatbuffers.Builder, imputeWaistFromChestLegs:number) { - builder.addFieldFloat32(1, imputeWaistFromChestLegs, 0); -} - -static addImputeHipFromChestLegs(builder:flatbuffers.Builder, imputeHipFromChestLegs:number) { - builder.addFieldFloat32(2, imputeHipFromChestLegs, 0); -} - -static addImputeHipFromWaistLegs(builder:flatbuffers.Builder, imputeHipFromWaistLegs:number) { - builder.addFieldFloat32(3, imputeHipFromWaistLegs, 0); -} - -static addInterpHipLegs(builder:flatbuffers.Builder, interpHipLegs:number) { - builder.addFieldFloat32(4, interpHipLegs, 0); -} - -static addInterpKneeTrackerAnkle(builder:flatbuffers.Builder, interpKneeTrackerAnkle:number) { - builder.addFieldFloat32(5, interpKneeTrackerAnkle, 0); -} - -static addInterpKneeAnkle(builder:flatbuffers.Builder, interpKneeAnkle:number) { - builder.addFieldFloat32(6, interpKneeAnkle, 0); -} - -static endModelRatios(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createModelRatios(builder:flatbuffers.Builder, imputeWaistFromChestHip:number|null, imputeWaistFromChestLegs:number|null, imputeHipFromChestLegs:number|null, imputeHipFromWaistLegs:number|null, interpHipLegs:number|null, interpKneeTrackerAnkle:number|null, interpKneeAnkle:number|null):flatbuffers.Offset { - ModelRatios.startModelRatios(builder); - if (imputeWaistFromChestHip !== null) - ModelRatios.addImputeWaistFromChestHip(builder, imputeWaistFromChestHip); - if (imputeWaistFromChestLegs !== null) - ModelRatios.addImputeWaistFromChestLegs(builder, imputeWaistFromChestLegs); - if (imputeHipFromChestLegs !== null) - ModelRatios.addImputeHipFromChestLegs(builder, imputeHipFromChestLegs); - if (imputeHipFromWaistLegs !== null) - ModelRatios.addImputeHipFromWaistLegs(builder, imputeHipFromWaistLegs); - if (interpHipLegs !== null) - ModelRatios.addInterpHipLegs(builder, interpHipLegs); - if (interpKneeTrackerAnkle !== null) - ModelRatios.addInterpKneeTrackerAnkle(builder, interpKneeTrackerAnkle); - if (interpKneeAnkle !== null) - ModelRatios.addInterpKneeAnkle(builder, interpKneeAnkle); - return ModelRatios.endModelRatios(builder); -} - -unpack(): ModelRatiosT { - return new ModelRatiosT( - this.imputeWaistFromChestHip(), - this.imputeWaistFromChestLegs(), - this.imputeHipFromChestLegs(), - this.imputeHipFromWaistLegs(), - this.interpHipLegs(), - this.interpKneeTrackerAnkle(), - this.interpKneeAnkle() - ); -} - - -unpackTo(_o: ModelRatiosT): void { - _o.imputeWaistFromChestHip = this.imputeWaistFromChestHip(); - _o.imputeWaistFromChestLegs = this.imputeWaistFromChestLegs(); - _o.imputeHipFromChestLegs = this.imputeHipFromChestLegs(); - _o.imputeHipFromWaistLegs = this.imputeHipFromWaistLegs(); - _o.interpHipLegs = this.interpHipLegs(); - _o.interpKneeTrackerAnkle = this.interpKneeTrackerAnkle(); - _o.interpKneeAnkle = this.interpKneeAnkle(); -} -} - -export class ModelRatiosT implements flatbuffers.IGeneratedObject { -constructor( - public imputeWaistFromChestHip: number|null = null, - public imputeWaistFromChestLegs: number|null = null, - public imputeHipFromChestLegs: number|null = null, - public imputeHipFromWaistLegs: number|null = null, - public interpHipLegs: number|null = null, - public interpKneeTrackerAnkle: number|null = null, - public interpKneeAnkle: number|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return ModelRatios.createModelRatios(builder, - this.imputeWaistFromChestHip, - this.imputeWaistFromChestLegs, - this.imputeHipFromChestLegs, - this.imputeHipFromWaistLegs, - this.interpHipLegs, - this.interpKneeTrackerAnkle, - this.interpKneeAnkle - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/settings/model-settings.ts deleted file mode 100644 index 666487072..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-settings.ts +++ /dev/null @@ -1,119 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { LegTweaksSettings, LegTweaksSettingsT } from '../../../solarxr-protocol/rpc/settings/leg-tweaks-settings.js'; -import { ModelRatios, ModelRatiosT } from '../../../solarxr-protocol/rpc/settings/model-ratios.js'; -import { ModelToggles, ModelTogglesT } from '../../../solarxr-protocol/rpc/settings/model-toggles.js'; -import { SkeletonHeight, SkeletonHeightT } from '../../../solarxr-protocol/rpc/settings/skeleton-height.js'; - - -/** - * Settings for the skeletal model. - */ -export class ModelSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ModelSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsModelSettings(bb:flatbuffers.ByteBuffer, obj?:ModelSettings):ModelSettings { - return (obj || new ModelSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsModelSettings(bb:flatbuffers.ByteBuffer, obj?:ModelSettings):ModelSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ModelSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -toggles(obj?:ModelToggles):ModelToggles|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new ModelToggles()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -ratios(obj?:ModelRatios):ModelRatios|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new ModelRatios()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -legTweaks(obj?:LegTweaksSettings):LegTweaksSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? (obj || new LegTweaksSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -skeletonHeight(obj?:SkeletonHeight):SkeletonHeight|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? (obj || new SkeletonHeight()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startModelSettings(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addToggles(builder:flatbuffers.Builder, togglesOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, togglesOffset, 0); -} - -static addRatios(builder:flatbuffers.Builder, ratiosOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, ratiosOffset, 0); -} - -static addLegTweaks(builder:flatbuffers.Builder, legTweaksOffset:flatbuffers.Offset) { - builder.addFieldOffset(2, legTweaksOffset, 0); -} - -static addSkeletonHeight(builder:flatbuffers.Builder, skeletonHeightOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, skeletonHeightOffset, 0); -} - -static endModelSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - - -unpack(): ModelSettingsT { - return new ModelSettingsT( - (this.toggles() !== null ? this.toggles()!.unpack() : null), - (this.ratios() !== null ? this.ratios()!.unpack() : null), - (this.legTweaks() !== null ? this.legTweaks()!.unpack() : null), - (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null) - ); -} - - -unpackTo(_o: ModelSettingsT): void { - _o.toggles = (this.toggles() !== null ? this.toggles()!.unpack() : null); - _o.ratios = (this.ratios() !== null ? this.ratios()!.unpack() : null); - _o.legTweaks = (this.legTweaks() !== null ? this.legTweaks()!.unpack() : null); - _o.skeletonHeight = (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null); -} -} - -export class ModelSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public toggles: ModelTogglesT|null = null, - public ratios: ModelRatiosT|null = null, - public legTweaks: LegTweaksSettingsT|null = null, - public skeletonHeight: SkeletonHeightT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const toggles = (this.toggles !== null ? this.toggles!.pack(builder) : 0); - const ratios = (this.ratios !== null ? this.ratios!.pack(builder) : 0); - const legTweaks = (this.legTweaks !== null ? this.legTweaks!.pack(builder) : 0); - const skeletonHeight = (this.skeletonHeight !== null ? this.skeletonHeight!.pack(builder) : 0); - - ModelSettings.startModelSettings(builder); - ModelSettings.addToggles(builder, toggles); - ModelSettings.addRatios(builder, ratios); - ModelSettings.addLegTweaks(builder, legTweaks); - ModelSettings.addSkeletonHeight(builder, skeletonHeight); - - return ModelSettings.endModelSettings(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-request.ts deleted file mode 100644 index 3ab139fc7..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-request.ts +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class SkeletonConfigRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonConfigRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSkeletonConfigRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonConfigRequest):SkeletonConfigRequest { - return (obj || new SkeletonConfigRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSkeletonConfigRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonConfigRequest):SkeletonConfigRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SkeletonConfigRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startSkeletonConfigRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endSkeletonConfigRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSkeletonConfigRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - SkeletonConfigRequest.startSkeletonConfigRequest(builder); - return SkeletonConfigRequest.endSkeletonConfigRequest(builder); -} - -unpack(): SkeletonConfigRequestT { - return new SkeletonConfigRequestT(); -} - - -unpackTo(_o: SkeletonConfigRequestT): void {} -} - -export class SkeletonConfigRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return SkeletonConfigRequest.createSkeletonConfigRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/filtering-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-filtering.ts similarity index 50% rename from protocol/typescript/src/solarxr-protocol/rpc/filtering-settings.ts rename to protocol/typescript/src/solarxr-protocol/rpc/skeleton-filtering.ts index e7705646c..b505aae13 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/filtering-settings.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-filtering.ts @@ -2,25 +2,28 @@ import * as flatbuffers from 'flatbuffers'; -import { FilteringType } from '../../solarxr-protocol/datatypes/filtering-type.js'; +import { FilteringType } from '../../solarxr-protocol/rpc/filtering-type.js'; -export class FilteringSettings implements flatbuffers.IUnpackableObject { +/** + * Filtering (e.g smoothing) applied to the skeleton's movements + */ +export class SkeletonFiltering implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):FilteringSettings { + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonFiltering { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsFilteringSettings(bb:flatbuffers.ByteBuffer, obj?:FilteringSettings):FilteringSettings { - return (obj || new FilteringSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsSkeletonFiltering(bb:flatbuffers.ByteBuffer, obj?:SkeletonFiltering):SkeletonFiltering { + return (obj || new SkeletonFiltering()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsFilteringSettings(bb:flatbuffers.ByteBuffer, obj?:FilteringSettings):FilteringSettings { +static getSizePrefixedRootAsSkeletonFiltering(bb:flatbuffers.ByteBuffer, obj?:SkeletonFiltering):SkeletonFiltering { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new FilteringSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new SkeletonFiltering()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } type():FilteringType { @@ -29,14 +32,14 @@ type():FilteringType { } /** - * 0 to 1. A higher value results in more smoothing or prediction + * A higher value results in more filtering (0 to 1). */ amount():number { const offset = this.bb!.__offset(this.bb_pos, 6); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } -static startFilteringSettings(builder:flatbuffers.Builder) { +static startSkeletonFiltering(builder:flatbuffers.Builder) { builder.startObject(2); } @@ -48,33 +51,33 @@ static addAmount(builder:flatbuffers.Builder, amount:number) { builder.addFieldFloat32(1, amount, 0.0); } -static endFilteringSettings(builder:flatbuffers.Builder):flatbuffers.Offset { +static endSkeletonFiltering(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createFilteringSettings(builder:flatbuffers.Builder, type:FilteringType, amount:number):flatbuffers.Offset { - FilteringSettings.startFilteringSettings(builder); - FilteringSettings.addType(builder, type); - FilteringSettings.addAmount(builder, amount); - return FilteringSettings.endFilteringSettings(builder); +static createSkeletonFiltering(builder:flatbuffers.Builder, type:FilteringType, amount:number):flatbuffers.Offset { + SkeletonFiltering.startSkeletonFiltering(builder); + SkeletonFiltering.addType(builder, type); + SkeletonFiltering.addAmount(builder, amount); + return SkeletonFiltering.endSkeletonFiltering(builder); } -unpack(): FilteringSettingsT { - return new FilteringSettingsT( +unpack(): SkeletonFilteringT { + return new SkeletonFilteringT( this.type(), this.amount() ); } -unpackTo(_o: FilteringSettingsT): void { +unpackTo(_o: SkeletonFilteringT): void { _o.type = this.type(); _o.amount = this.amount(); } } -export class FilteringSettingsT implements flatbuffers.IGeneratedObject { +export class SkeletonFilteringT implements flatbuffers.IGeneratedObject { constructor( public type: FilteringType = FilteringType.NONE, public amount: number = 0.0 @@ -82,7 +85,7 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return FilteringSettings.createFilteringSettings(builder, + return SkeletonFiltering.createSkeletonFiltering(builder, this.type, this.amount ); diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings/skeleton-height.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-height.ts similarity index 97% rename from protocol/typescript/src/solarxr-protocol/rpc/settings/skeleton-height.ts rename to protocol/typescript/src/solarxr-protocol/rpc/skeleton-height.ts index f2b493bb1..b1808bdac 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings/skeleton-height.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-height.ts @@ -4,6 +4,9 @@ import * as flatbuffers from 'flatbuffers'; +/** + * Data used to compute the skeleton's height. + */ export class SkeletonHeight implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-request.ts new file mode 100644 index 000000000..ef5d84a96 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class SkeletonProportionsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonProportionsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsSkeletonProportionsRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsRequest):SkeletonProportionsRequest { + return (obj || new SkeletonProportionsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsSkeletonProportionsRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsRequest):SkeletonProportionsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new SkeletonProportionsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startSkeletonProportionsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endSkeletonProportionsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createSkeletonProportionsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + SkeletonProportionsRequest.startSkeletonProportionsRequest(builder); + return SkeletonProportionsRequest.endSkeletonProportionsRequest(builder); +} + +unpack(): SkeletonProportionsRequestT { + return new SkeletonProportionsRequestT(); +} + + +unpackTo(_o: SkeletonProportionsRequestT): void {} +} + +export class SkeletonProportionsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return SkeletonProportionsRequest.createSkeletonProportionsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-reset-all-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-reset-all-request.ts new file mode 100644 index 000000000..e935ca5a4 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-reset-all-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class SkeletonProportionsResetAllRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonProportionsResetAllRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsSkeletonProportionsResetAllRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsResetAllRequest):SkeletonProportionsResetAllRequest { + return (obj || new SkeletonProportionsResetAllRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsSkeletonProportionsResetAllRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsResetAllRequest):SkeletonProportionsResetAllRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new SkeletonProportionsResetAllRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startSkeletonProportionsResetAllRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endSkeletonProportionsResetAllRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createSkeletonProportionsResetAllRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + SkeletonProportionsResetAllRequest.startSkeletonProportionsResetAllRequest(builder); + return SkeletonProportionsResetAllRequest.endSkeletonProportionsResetAllRequest(builder); +} + +unpack(): SkeletonProportionsResetAllRequestT { + return new SkeletonProportionsResetAllRequestT(); +} + + +unpackTo(_o: SkeletonProportionsResetAllRequestT): void {} +} + +export class SkeletonProportionsResetAllRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return SkeletonProportionsResetAllRequest.createSkeletonProportionsResetAllRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-response.ts similarity index 56% rename from protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-response.ts rename to protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-response.ts index f03ecc50c..aab32f485 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-config-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-proportions-response.ts @@ -5,22 +5,22 @@ import * as flatbuffers from 'flatbuffers'; import { SkeletonPart, SkeletonPartT } from '../../solarxr-protocol/rpc/skeleton-part.js'; -export class SkeletonConfigResponse implements flatbuffers.IUnpackableObject { +export class SkeletonProportionsResponse implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonConfigResponse { + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonProportionsResponse { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsSkeletonConfigResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonConfigResponse):SkeletonConfigResponse { - return (obj || new SkeletonConfigResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsSkeletonProportionsResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsResponse):SkeletonProportionsResponse { + return (obj || new SkeletonProportionsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsSkeletonConfigResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonConfigResponse):SkeletonConfigResponse { +static getSizePrefixedRootAsSkeletonProportionsResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonProportionsResponse):SkeletonProportionsResponse { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SkeletonConfigResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new SkeletonProportionsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } skeletonParts(index: number, obj?:SkeletonPart):SkeletonPart|null { @@ -38,7 +38,7 @@ userHeight():number { return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } -static startSkeletonConfigResponse(builder:flatbuffers.Builder) { +static startSkeletonProportionsResponse(builder:flatbuffers.Builder) { builder.startObject(2); } @@ -62,33 +62,33 @@ static addUserHeight(builder:flatbuffers.Builder, userHeight:number) { builder.addFieldFloat32(1, userHeight, 0.0); } -static endSkeletonConfigResponse(builder:flatbuffers.Builder):flatbuffers.Offset { +static endSkeletonProportionsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createSkeletonConfigResponse(builder:flatbuffers.Builder, skeletonPartsOffset:flatbuffers.Offset, userHeight:number):flatbuffers.Offset { - SkeletonConfigResponse.startSkeletonConfigResponse(builder); - SkeletonConfigResponse.addSkeletonParts(builder, skeletonPartsOffset); - SkeletonConfigResponse.addUserHeight(builder, userHeight); - return SkeletonConfigResponse.endSkeletonConfigResponse(builder); +static createSkeletonProportionsResponse(builder:flatbuffers.Builder, skeletonPartsOffset:flatbuffers.Offset, userHeight:number):flatbuffers.Offset { + SkeletonProportionsResponse.startSkeletonProportionsResponse(builder); + SkeletonProportionsResponse.addSkeletonParts(builder, skeletonPartsOffset); + SkeletonProportionsResponse.addUserHeight(builder, userHeight); + return SkeletonProportionsResponse.endSkeletonProportionsResponse(builder); } -unpack(): SkeletonConfigResponseT { - return new SkeletonConfigResponseT( +unpack(): SkeletonProportionsResponseT { + return new SkeletonProportionsResponseT( this.bb!.createObjList(this.skeletonParts.bind(this), this.skeletonPartsLength()), this.userHeight() ); } -unpackTo(_o: SkeletonConfigResponseT): void { +unpackTo(_o: SkeletonProportionsResponseT): void { _o.skeletonParts = this.bb!.createObjList(this.skeletonParts.bind(this), this.skeletonPartsLength()); _o.userHeight = this.userHeight(); } } -export class SkeletonConfigResponseT implements flatbuffers.IGeneratedObject { +export class SkeletonProportionsResponseT implements flatbuffers.IGeneratedObject { constructor( public skeletonParts: (SkeletonPartT)[] = [], public userHeight: number = 0.0 @@ -96,9 +96,9 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const skeletonParts = SkeletonConfigResponse.createSkeletonPartsVector(builder, builder.createObjectOffsetList(this.skeletonParts)); + const skeletonParts = SkeletonProportionsResponse.createSkeletonPartsVector(builder, builder.createObjectOffsetList(this.skeletonParts)); - return SkeletonConfigResponse.createSkeletonConfigResponse(builder, + return SkeletonProportionsResponse.createSkeletonProportionsResponse(builder, skeletonParts, this.userHeight ); diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-ratios.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-ratios.ts new file mode 100644 index 000000000..24590c27a --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-ratios.ts @@ -0,0 +1,169 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +/** + * Ratios for the skeletal model. Accepted values for them range from 0 to 1 + */ +export class SkeletonRatios implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonRatios { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsSkeletonRatios(bb:flatbuffers.ByteBuffer, obj?:SkeletonRatios):SkeletonRatios { + return (obj || new SkeletonRatios()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsSkeletonRatios(bb:flatbuffers.ByteBuffer, obj?:SkeletonRatios):SkeletonRatios { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new SkeletonRatios()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +/** + * Compute missing spine bones as a ratio of the next available upper and lower bones. + */ +imputeSpineFromUpperLower():number|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +/** + * Computes the curvature between 2 adjacent missing spine bones. Higher = more curvature. + */ +imputeSpineCurvature():number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +/** + * How much to average the hip's yaw and roll with the upper legs'. + */ +interpHipLegs():number|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +/** + * How much to average the knee trackers' yaw and roll with the lower legs'. + */ +interpKneeTrackerAnkle():number|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +/** + * How much to average the upper leg's yaw and roll with the lower legs'. + */ +interpKneeAnkle():number|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +/** + * Strength of skating correction. Enabled via SkeletonToggles.skating_correction + */ +skatingCorrectionStrength():number|null { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +static startSkeletonRatios(builder:flatbuffers.Builder) { + builder.startObject(6); +} + +static addImputeSpineFromUpperLower(builder:flatbuffers.Builder, imputeSpineFromUpperLower:number) { + builder.addFieldFloat32(0, imputeSpineFromUpperLower, 0); +} + +static addImputeSpineCurvature(builder:flatbuffers.Builder, imputeSpineCurvature:number) { + builder.addFieldFloat32(1, imputeSpineCurvature, 0); +} + +static addInterpHipLegs(builder:flatbuffers.Builder, interpHipLegs:number) { + builder.addFieldFloat32(2, interpHipLegs, 0); +} + +static addInterpKneeTrackerAnkle(builder:flatbuffers.Builder, interpKneeTrackerAnkle:number) { + builder.addFieldFloat32(3, interpKneeTrackerAnkle, 0); +} + +static addInterpKneeAnkle(builder:flatbuffers.Builder, interpKneeAnkle:number) { + builder.addFieldFloat32(4, interpKneeAnkle, 0); +} + +static addSkatingCorrectionStrength(builder:flatbuffers.Builder, skatingCorrectionStrength:number) { + builder.addFieldFloat32(5, skatingCorrectionStrength, 0); +} + +static endSkeletonRatios(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createSkeletonRatios(builder:flatbuffers.Builder, imputeSpineFromUpperLower:number|null, imputeSpineCurvature:number|null, interpHipLegs:number|null, interpKneeTrackerAnkle:number|null, interpKneeAnkle:number|null, skatingCorrectionStrength:number|null):flatbuffers.Offset { + SkeletonRatios.startSkeletonRatios(builder); + if (imputeSpineFromUpperLower !== null) + SkeletonRatios.addImputeSpineFromUpperLower(builder, imputeSpineFromUpperLower); + if (imputeSpineCurvature !== null) + SkeletonRatios.addImputeSpineCurvature(builder, imputeSpineCurvature); + if (interpHipLegs !== null) + SkeletonRatios.addInterpHipLegs(builder, interpHipLegs); + if (interpKneeTrackerAnkle !== null) + SkeletonRatios.addInterpKneeTrackerAnkle(builder, interpKneeTrackerAnkle); + if (interpKneeAnkle !== null) + SkeletonRatios.addInterpKneeAnkle(builder, interpKneeAnkle); + if (skatingCorrectionStrength !== null) + SkeletonRatios.addSkatingCorrectionStrength(builder, skatingCorrectionStrength); + return SkeletonRatios.endSkeletonRatios(builder); +} + +unpack(): SkeletonRatiosT { + return new SkeletonRatiosT( + this.imputeSpineFromUpperLower(), + this.imputeSpineCurvature(), + this.interpHipLegs(), + this.interpKneeTrackerAnkle(), + this.interpKneeAnkle(), + this.skatingCorrectionStrength() + ); +} + + +unpackTo(_o: SkeletonRatiosT): void { + _o.imputeSpineFromUpperLower = this.imputeSpineFromUpperLower(); + _o.imputeSpineCurvature = this.imputeSpineCurvature(); + _o.interpHipLegs = this.interpHipLegs(); + _o.interpKneeTrackerAnkle = this.interpKneeTrackerAnkle(); + _o.interpKneeAnkle = this.interpKneeAnkle(); + _o.skatingCorrectionStrength = this.skatingCorrectionStrength(); +} +} + +export class SkeletonRatiosT implements flatbuffers.IGeneratedObject { +constructor( + public imputeSpineFromUpperLower: number|null = null, + public imputeSpineCurvature: number|null = null, + public interpHipLegs: number|null = null, + public interpKneeTrackerAnkle: number|null = null, + public interpKneeAnkle: number|null = null, + public skatingCorrectionStrength: number|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return SkeletonRatios.createSkeletonRatios(builder, + this.imputeSpineFromUpperLower, + this.imputeSpineCurvature, + this.interpHipLegs, + this.interpKneeTrackerAnkle, + this.interpKneeAnkle, + this.skatingCorrectionStrength + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-reset-all-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-reset-all-request.ts deleted file mode 100644 index 7108758a6..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-reset-all-request.ts +++ /dev/null @@ -1,54 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class SkeletonResetAllRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonResetAllRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSkeletonResetAllRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonResetAllRequest):SkeletonResetAllRequest { - return (obj || new SkeletonResetAllRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSkeletonResetAllRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonResetAllRequest):SkeletonResetAllRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SkeletonResetAllRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startSkeletonResetAllRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endSkeletonResetAllRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSkeletonResetAllRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - SkeletonResetAllRequest.startSkeletonResetAllRequest(builder); - return SkeletonResetAllRequest.endSkeletonResetAllRequest(builder); -} - -unpack(): SkeletonResetAllRequestT { - return new SkeletonResetAllRequestT(); -} - - -unpackTo(_o: SkeletonResetAllRequestT): void {} -} - -export class SkeletonResetAllRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return SkeletonResetAllRequest.createSkeletonResetAllRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-request.ts new file mode 100644 index 000000000..48d570b90 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class SkeletonSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsSkeletonSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonSettingsRequest):SkeletonSettingsRequest { + return (obj || new SkeletonSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsSkeletonSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:SkeletonSettingsRequest):SkeletonSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new SkeletonSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startSkeletonSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endSkeletonSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createSkeletonSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + SkeletonSettingsRequest.startSkeletonSettingsRequest(builder); + return SkeletonSettingsRequest.endSkeletonSettingsRequest(builder); +} + +unpack(): SkeletonSettingsRequestT { + return new SkeletonSettingsRequestT(); +} + + +unpackTo(_o: SkeletonSettingsRequestT): void {} +} + +export class SkeletonSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return SkeletonSettingsRequest.createSkeletonSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-response.ts new file mode 100644 index 000000000..b96dc86b2 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-settings-response.ts @@ -0,0 +1,116 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { SkeletonFiltering, SkeletonFilteringT } from '../../solarxr-protocol/rpc/skeleton-filtering.js'; +import { SkeletonHeight, SkeletonHeightT } from '../../solarxr-protocol/rpc/skeleton-height.js'; +import { SkeletonRatios, SkeletonRatiosT } from '../../solarxr-protocol/rpc/skeleton-ratios.js'; +import { SkeletonToggles, SkeletonTogglesT } from '../../solarxr-protocol/rpc/skeleton-toggles.js'; + + +export class SkeletonSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsSkeletonSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonSettingsResponse):SkeletonSettingsResponse { + return (obj || new SkeletonSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsSkeletonSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:SkeletonSettingsResponse):SkeletonSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new SkeletonSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +toggles(obj?:SkeletonToggles):SkeletonToggles|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new SkeletonToggles()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +ratios(obj?:SkeletonRatios):SkeletonRatios|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new SkeletonRatios()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +filtering(obj?:SkeletonFiltering):SkeletonFiltering|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? (obj || new SkeletonFiltering()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +skeletonHeight(obj?:SkeletonHeight):SkeletonHeight|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? (obj || new SkeletonHeight()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +static startSkeletonSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(4); +} + +static addToggles(builder:flatbuffers.Builder, togglesOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, togglesOffset, 0); +} + +static addRatios(builder:flatbuffers.Builder, ratiosOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, ratiosOffset, 0); +} + +static addFiltering(builder:flatbuffers.Builder, filteringOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, filteringOffset, 0); +} + +static addSkeletonHeight(builder:flatbuffers.Builder, skeletonHeightOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, skeletonHeightOffset, 0); +} + +static endSkeletonSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): SkeletonSettingsResponseT { + return new SkeletonSettingsResponseT( + (this.toggles() !== null ? this.toggles()!.unpack() : null), + (this.ratios() !== null ? this.ratios()!.unpack() : null), + (this.filtering() !== null ? this.filtering()!.unpack() : null), + (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null) + ); +} + + +unpackTo(_o: SkeletonSettingsResponseT): void { + _o.toggles = (this.toggles() !== null ? this.toggles()!.unpack() : null); + _o.ratios = (this.ratios() !== null ? this.ratios()!.unpack() : null); + _o.filtering = (this.filtering() !== null ? this.filtering()!.unpack() : null); + _o.skeletonHeight = (this.skeletonHeight() !== null ? this.skeletonHeight()!.unpack() : null); +} +} + +export class SkeletonSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public toggles: SkeletonTogglesT|null = null, + public ratios: SkeletonRatiosT|null = null, + public filtering: SkeletonFilteringT|null = null, + public skeletonHeight: SkeletonHeightT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const toggles = (this.toggles !== null ? this.toggles!.pack(builder) : 0); + const ratios = (this.ratios !== null ? this.ratios!.pack(builder) : 0); + const filtering = (this.filtering !== null ? this.filtering!.pack(builder) : 0); + const skeletonHeight = (this.skeletonHeight !== null ? this.skeletonHeight!.pack(builder) : 0); + + SkeletonSettingsResponse.startSkeletonSettingsResponse(builder); + SkeletonSettingsResponse.addToggles(builder, toggles); + SkeletonSettingsResponse.addRatios(builder, ratios); + SkeletonSettingsResponse.addFiltering(builder, filtering); + SkeletonSettingsResponse.addSkeletonHeight(builder, skeletonHeight); + + return SkeletonSettingsResponse.endSkeletonSettingsResponse(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-toggles.ts b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-toggles.ts similarity index 50% rename from protocol/typescript/src/solarxr-protocol/rpc/settings/model-toggles.ts rename to protocol/typescript/src/solarxr-protocol/rpc/skeleton-toggles.ts index 1064d0ed1..c4b424161 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/settings/model-toggles.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/skeleton-toggles.ts @@ -5,177 +5,141 @@ import * as flatbuffers from 'flatbuffers'; /** - * Settings for the skeletal model that are toggles. + * Toggles for the skeletal model. */ -export class ModelToggles implements flatbuffers.IUnpackableObject { +export class SkeletonToggles implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):ModelToggles { + __init(i:number, bb:flatbuffers.ByteBuffer):SkeletonToggles { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsModelToggles(bb:flatbuffers.ByteBuffer, obj?:ModelToggles):ModelToggles { - return (obj || new ModelToggles()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsSkeletonToggles(bb:flatbuffers.ByteBuffer, obj?:SkeletonToggles):SkeletonToggles { + return (obj || new SkeletonToggles()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsModelToggles(bb:flatbuffers.ByteBuffer, obj?:ModelToggles):ModelToggles { +static getSizePrefixedRootAsSkeletonToggles(bb:flatbuffers.ByteBuffer, obj?:SkeletonToggles):SkeletonToggles { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new ModelToggles()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -extendedSpine():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -extendedPelvis():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - -extendedKnee():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; + return (obj || new SkeletonToggles()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } forceArmsFromHmd():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 10); + const offset = this.bb!.__offset(this.bb_pos, 4); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } floorClip():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 12); + const offset = this.bb!.__offset(this.bb_pos, 6); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } skatingCorrection():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 14); + const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } toeSnap():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 18); + const offset = this.bb!.__offset(this.bb_pos, 10); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } footPlant():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 20); + const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } selfLocalization():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 22); + const offset = this.bb!.__offset(this.bb_pos, 14); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } usePosition():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 16); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } enforceConstraints():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 18); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } correctConstraints():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 28); + const offset = this.bb!.__offset(this.bb_pos, 20); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; } -static startModelToggles(builder:flatbuffers.Builder) { - builder.startObject(13); -} - -static addExtendedSpine(builder:flatbuffers.Builder, extendedSpine:boolean) { - builder.addFieldInt8(0, +extendedSpine, 0); -} - -static addExtendedPelvis(builder:flatbuffers.Builder, extendedPelvis:boolean) { - builder.addFieldInt8(1, +extendedPelvis, 0); -} - -static addExtendedKnee(builder:flatbuffers.Builder, extendedKnee:boolean) { - builder.addFieldInt8(2, +extendedKnee, 0); +static startSkeletonToggles(builder:flatbuffers.Builder) { + builder.startObject(9); } static addForceArmsFromHmd(builder:flatbuffers.Builder, forceArmsFromHmd:boolean) { - builder.addFieldInt8(3, +forceArmsFromHmd, 0); + builder.addFieldInt8(0, +forceArmsFromHmd, 0); } static addFloorClip(builder:flatbuffers.Builder, floorClip:boolean) { - builder.addFieldInt8(4, +floorClip, 0); + builder.addFieldInt8(1, +floorClip, 0); } static addSkatingCorrection(builder:flatbuffers.Builder, skatingCorrection:boolean) { - builder.addFieldInt8(5, +skatingCorrection, 0); + builder.addFieldInt8(2, +skatingCorrection, 0); } static addToeSnap(builder:flatbuffers.Builder, toeSnap:boolean) { - builder.addFieldInt8(7, +toeSnap, 0); + builder.addFieldInt8(3, +toeSnap, 0); } static addFootPlant(builder:flatbuffers.Builder, footPlant:boolean) { - builder.addFieldInt8(8, +footPlant, 0); + builder.addFieldInt8(4, +footPlant, 0); } static addSelfLocalization(builder:flatbuffers.Builder, selfLocalization:boolean) { - builder.addFieldInt8(9, +selfLocalization, 0); + builder.addFieldInt8(5, +selfLocalization, 0); } static addUsePosition(builder:flatbuffers.Builder, usePosition:boolean) { - builder.addFieldInt8(10, +usePosition, 0); + builder.addFieldInt8(6, +usePosition, 0); } static addEnforceConstraints(builder:flatbuffers.Builder, enforceConstraints:boolean) { - builder.addFieldInt8(11, +enforceConstraints, 0); + builder.addFieldInt8(7, +enforceConstraints, 0); } static addCorrectConstraints(builder:flatbuffers.Builder, correctConstraints:boolean) { - builder.addFieldInt8(12, +correctConstraints, 0); + builder.addFieldInt8(8, +correctConstraints, 0); } -static endModelToggles(builder:flatbuffers.Builder):flatbuffers.Offset { +static endSkeletonToggles(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createModelToggles(builder:flatbuffers.Builder, extendedSpine:boolean|null, extendedPelvis:boolean|null, extendedKnee:boolean|null, forceArmsFromHmd:boolean|null, floorClip:boolean|null, skatingCorrection:boolean|null, toeSnap:boolean|null, footPlant:boolean|null, selfLocalization:boolean|null, usePosition:boolean|null, enforceConstraints:boolean|null, correctConstraints:boolean|null):flatbuffers.Offset { - ModelToggles.startModelToggles(builder); - if (extendedSpine !== null) - ModelToggles.addExtendedSpine(builder, extendedSpine); - if (extendedPelvis !== null) - ModelToggles.addExtendedPelvis(builder, extendedPelvis); - if (extendedKnee !== null) - ModelToggles.addExtendedKnee(builder, extendedKnee); +static createSkeletonToggles(builder:flatbuffers.Builder, forceArmsFromHmd:boolean|null, floorClip:boolean|null, skatingCorrection:boolean|null, toeSnap:boolean|null, footPlant:boolean|null, selfLocalization:boolean|null, usePosition:boolean|null, enforceConstraints:boolean|null, correctConstraints:boolean|null):flatbuffers.Offset { + SkeletonToggles.startSkeletonToggles(builder); if (forceArmsFromHmd !== null) - ModelToggles.addForceArmsFromHmd(builder, forceArmsFromHmd); + SkeletonToggles.addForceArmsFromHmd(builder, forceArmsFromHmd); if (floorClip !== null) - ModelToggles.addFloorClip(builder, floorClip); + SkeletonToggles.addFloorClip(builder, floorClip); if (skatingCorrection !== null) - ModelToggles.addSkatingCorrection(builder, skatingCorrection); + SkeletonToggles.addSkatingCorrection(builder, skatingCorrection); if (toeSnap !== null) - ModelToggles.addToeSnap(builder, toeSnap); + SkeletonToggles.addToeSnap(builder, toeSnap); if (footPlant !== null) - ModelToggles.addFootPlant(builder, footPlant); + SkeletonToggles.addFootPlant(builder, footPlant); if (selfLocalization !== null) - ModelToggles.addSelfLocalization(builder, selfLocalization); + SkeletonToggles.addSelfLocalization(builder, selfLocalization); if (usePosition !== null) - ModelToggles.addUsePosition(builder, usePosition); + SkeletonToggles.addUsePosition(builder, usePosition); if (enforceConstraints !== null) - ModelToggles.addEnforceConstraints(builder, enforceConstraints); + SkeletonToggles.addEnforceConstraints(builder, enforceConstraints); if (correctConstraints !== null) - ModelToggles.addCorrectConstraints(builder, correctConstraints); - return ModelToggles.endModelToggles(builder); + SkeletonToggles.addCorrectConstraints(builder, correctConstraints); + return SkeletonToggles.endSkeletonToggles(builder); } -unpack(): ModelTogglesT { - return new ModelTogglesT( - this.extendedSpine(), - this.extendedPelvis(), - this.extendedKnee(), +unpack(): SkeletonTogglesT { + return new SkeletonTogglesT( this.forceArmsFromHmd(), this.floorClip(), this.skatingCorrection(), @@ -189,10 +153,7 @@ unpack(): ModelTogglesT { } -unpackTo(_o: ModelTogglesT): void { - _o.extendedSpine = this.extendedSpine(); - _o.extendedPelvis = this.extendedPelvis(); - _o.extendedKnee = this.extendedKnee(); +unpackTo(_o: SkeletonTogglesT): void { _o.forceArmsFromHmd = this.forceArmsFromHmd(); _o.floorClip = this.floorClip(); _o.skatingCorrection = this.skatingCorrection(); @@ -205,11 +166,8 @@ unpackTo(_o: ModelTogglesT): void { } } -export class ModelTogglesT implements flatbuffers.IGeneratedObject { +export class SkeletonTogglesT implements flatbuffers.IGeneratedObject { constructor( - public extendedSpine: boolean|null = null, - public extendedPelvis: boolean|null = null, - public extendedKnee: boolean|null = null, public forceArmsFromHmd: boolean|null = null, public floorClip: boolean|null = null, public skatingCorrection: boolean|null = null, @@ -223,10 +181,7 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return ModelToggles.createModelToggles(builder, - this.extendedSpine, - this.extendedPelvis, - this.extendedKnee, + return SkeletonToggles.createSkeletonToggles(builder, this.forceArmsFromHmd, this.floorClip, this.skatingCorrection, diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts deleted file mode 100644 index e84f22ed6..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts +++ /dev/null @@ -1,48 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import { StatusPublicNetwork, StatusPublicNetworkT } from '../../solarxr-protocol/rpc/status-public-network.js'; -import { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/status-steam-vrdisconnected.js'; -import { StatusTrackerError, StatusTrackerErrorT } from '../../solarxr-protocol/rpc/status-tracker-error.js'; -import { StatusTrackerReset, StatusTrackerResetT } from '../../solarxr-protocol/rpc/status-tracker-reset.js'; -import { StatusUnassignedHMD, StatusUnassignedHMDT } from '../../solarxr-protocol/rpc/status-unassigned-hmd.js'; - - -export enum StatusData { - NONE = 0, - StatusTrackerReset = 1, - StatusTrackerError = 2, - StatusSteamVRDisconnected = 3, - StatusUnassignedHMD = 4, - StatusPublicNetwork = 5 -} - -export function unionToStatusData( - type: StatusData, - accessor: (obj:StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null -): StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null { - switch(StatusData[type]) { - case 'NONE': return null; - case 'StatusTrackerReset': return accessor(new StatusTrackerReset())! as StatusTrackerReset; - case 'StatusTrackerError': return accessor(new StatusTrackerError())! as StatusTrackerError; - case 'StatusSteamVRDisconnected': return accessor(new StatusSteamVRDisconnected())! as StatusSteamVRDisconnected; - case 'StatusUnassignedHMD': return accessor(new StatusUnassignedHMD())! as StatusUnassignedHMD; - case 'StatusPublicNetwork': return accessor(new StatusPublicNetwork())! as StatusPublicNetwork; - default: return null; - } -} - -export function unionListToStatusData( - type: StatusData, - accessor: (index: number, obj:StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null, - index: number -): StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null { - switch(StatusData[type]) { - case 'NONE': return null; - case 'StatusTrackerReset': return accessor(index, new StatusTrackerReset())! as StatusTrackerReset; - case 'StatusTrackerError': return accessor(index, new StatusTrackerError())! as StatusTrackerError; - case 'StatusSteamVRDisconnected': return accessor(index, new StatusSteamVRDisconnected())! as StatusSteamVRDisconnected; - case 'StatusUnassignedHMD': return accessor(index, new StatusUnassignedHMD())! as StatusUnassignedHMD; - case 'StatusPublicNetwork': return accessor(index, new StatusPublicNetwork())! as StatusPublicNetwork; - default: return null; - } -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts deleted file mode 100644 index 2e3d7b952..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts +++ /dev/null @@ -1,140 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { StatusData, unionToStatusData, unionListToStatusData } from '../../solarxr-protocol/rpc/status-data.js'; -import { StatusPublicNetwork, StatusPublicNetworkT } from '../../solarxr-protocol/rpc/status-public-network.js'; -import { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/status-steam-vrdisconnected.js'; -import { StatusTrackerError, StatusTrackerErrorT } from '../../solarxr-protocol/rpc/status-tracker-error.js'; -import { StatusTrackerReset, StatusTrackerResetT } from '../../solarxr-protocol/rpc/status-tracker-reset.js'; -import { StatusUnassignedHMD, StatusUnassignedHMDT } from '../../solarxr-protocol/rpc/status-unassigned-hmd.js'; - - -/** - * An status is some kind of warning sent by the server, it's mainly made for - * showing problems with the server and need attention from the user. - */ -export class StatusMessage implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusMessage { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusMessage(bb:flatbuffers.ByteBuffer, obj?:StatusMessage):StatusMessage { - return (obj || new StatusMessage()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusMessage(bb:flatbuffers.ByteBuffer, obj?:StatusMessage):StatusMessage { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusMessage()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -/** - * The status ID - */ -id():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; -} - -/** - * This should be prioritized in the GUI in some way if true - */ -prioritized():boolean { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -dataType():StatusData { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? this.bb!.readUint8(this.bb_pos + offset) : StatusData.NONE; -} - -data(obj:any):any|null { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; -} - -static startStatusMessage(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addId(builder:flatbuffers.Builder, id:number) { - builder.addFieldInt32(0, id, 0); -} - -static addPrioritized(builder:flatbuffers.Builder, prioritized:boolean) { - builder.addFieldInt8(1, +prioritized, +false); -} - -static addDataType(builder:flatbuffers.Builder, dataType:StatusData) { - builder.addFieldInt8(2, dataType, StatusData.NONE); -} - -static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) { - builder.addFieldOffset(3, dataOffset, 0); -} - -static endStatusMessage(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusMessage(builder:flatbuffers.Builder, id:number, prioritized:boolean, dataType:StatusData, dataOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusMessage.startStatusMessage(builder); - StatusMessage.addId(builder, id); - StatusMessage.addPrioritized(builder, prioritized); - StatusMessage.addDataType(builder, dataType); - StatusMessage.addData(builder, dataOffset); - return StatusMessage.endStatusMessage(builder); -} - -unpack(): StatusMessageT { - return new StatusMessageT( - this.id(), - this.prioritized(), - this.dataType(), - (() => { - const temp = unionToStatusData(this.dataType(), this.data.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })() - ); -} - - -unpackTo(_o: StatusMessageT): void { - _o.id = this.id(); - _o.prioritized = this.prioritized(); - _o.dataType = this.dataType(); - _o.data = (() => { - const temp = unionToStatusData(this.dataType(), this.data.bind(this)); - if(temp === null) { return null; } - return temp.unpack() - })(); -} -} - -export class StatusMessageT implements flatbuffers.IGeneratedObject { -constructor( - public id: number = 0, - public prioritized: boolean = false, - public dataType: StatusData = StatusData.NONE, - public data: StatusPublicNetworkT|StatusSteamVRDisconnectedT|StatusTrackerErrorT|StatusTrackerResetT|StatusUnassignedHMDT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const data = builder.createObjectOffset(this.data); - - return StatusMessage.createStatusMessage(builder, - this.id, - this.prioritized, - this.dataType, - data - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts deleted file mode 100644 index cec668f2a..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts +++ /dev/null @@ -1,99 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * When the server detects a public network profile - */ -export class StatusPublicNetwork implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusPublicNetwork { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusPublicNetwork(bb:flatbuffers.ByteBuffer, obj?:StatusPublicNetwork):StatusPublicNetwork { - return (obj || new StatusPublicNetwork()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusPublicNetwork(bb:flatbuffers.ByteBuffer, obj?:StatusPublicNetwork):StatusPublicNetwork { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusPublicNetwork()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -/** - * names of the adapters set to public - */ -adapters(index: number):string -adapters(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array -adapters(index: number,optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; -} - -adaptersLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -static startStatusPublicNetwork(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addAdapters(builder:flatbuffers.Builder, adaptersOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, adaptersOffset, 0); -} - -static createAdaptersVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startAdaptersVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static endStatusPublicNetwork(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusPublicNetwork(builder:flatbuffers.Builder, adaptersOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusPublicNetwork.startStatusPublicNetwork(builder); - StatusPublicNetwork.addAdapters(builder, adaptersOffset); - return StatusPublicNetwork.endStatusPublicNetwork(builder); -} - -unpack(): StatusPublicNetworkT { - return new StatusPublicNetworkT( - this.bb!.createScalarList(this.adapters.bind(this), this.adaptersLength()) - ); -} - - -unpackTo(_o: StatusPublicNetworkT): void { - _o.adapters = this.bb!.createScalarList(this.adapters.bind(this), this.adaptersLength()); -} -} - -export class StatusPublicNetworkT implements flatbuffers.IGeneratedObject { -constructor( - public adapters: (string)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const adapters = StatusPublicNetwork.createAdaptersVector(builder, builder.createObjectOffsetList(this.adapters)); - - return StatusPublicNetwork.createStatusPublicNetwork(builder, - adapters - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-steam-vrdisconnected.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-steam-vrdisconnected.ts deleted file mode 100644 index 54c7aa6f6..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-steam-vrdisconnected.ts +++ /dev/null @@ -1,82 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * SteamVR bridge is disconnected - */ -export class StatusSteamVRDisconnected implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusSteamVRDisconnected { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusSteamVRDisconnected(bb:flatbuffers.ByteBuffer, obj?:StatusSteamVRDisconnected):StatusSteamVRDisconnected { - return (obj || new StatusSteamVRDisconnected()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusSteamVRDisconnected(bb:flatbuffers.ByteBuffer, obj?:StatusSteamVRDisconnected):StatusSteamVRDisconnected { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusSteamVRDisconnected()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -/** - * Name of bridge in the server's config - */ -bridgeSettingsName():string|null -bridgeSettingsName(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -bridgeSettingsName(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startStatusSteamVRDisconnected(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addBridgeSettingsName(builder:flatbuffers.Builder, bridgeSettingsNameOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, bridgeSettingsNameOffset, 0); -} - -static endStatusSteamVRDisconnected(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusSteamVRDisconnected(builder:flatbuffers.Builder, bridgeSettingsNameOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusSteamVRDisconnected.startStatusSteamVRDisconnected(builder); - StatusSteamVRDisconnected.addBridgeSettingsName(builder, bridgeSettingsNameOffset); - return StatusSteamVRDisconnected.endStatusSteamVRDisconnected(builder); -} - -unpack(): StatusSteamVRDisconnectedT { - return new StatusSteamVRDisconnectedT( - this.bridgeSettingsName() - ); -} - - -unpackTo(_o: StatusSteamVRDisconnectedT): void { - _o.bridgeSettingsName = this.bridgeSettingsName(); -} -} - -export class StatusSteamVRDisconnectedT implements flatbuffers.IGeneratedObject { -constructor( - public bridgeSettingsName: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const bridgeSettingsName = (this.bridgeSettingsName !== null ? builder.createString(this.bridgeSettingsName!) : 0); - - return StatusSteamVRDisconnected.createStatusSteamVRDisconnected(builder, - bridgeSettingsName - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-system-fixed.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-system-fixed.ts deleted file mode 100644 index 2945e3ee3..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-system-fixed.ts +++ /dev/null @@ -1,75 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * When an status is fixed and it's removed, it's ID is sent - */ -export class StatusSystemFixed implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusSystemFixed { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusSystemFixed(bb:flatbuffers.ByteBuffer, obj?:StatusSystemFixed):StatusSystemFixed { - return (obj || new StatusSystemFixed()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusSystemFixed(bb:flatbuffers.ByteBuffer, obj?:StatusSystemFixed):StatusSystemFixed { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusSystemFixed()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -fixedStatusId():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; -} - -static startStatusSystemFixed(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addFixedStatusId(builder:flatbuffers.Builder, fixedStatusId:number) { - builder.addFieldInt32(0, fixedStatusId, 0); -} - -static endStatusSystemFixed(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusSystemFixed(builder:flatbuffers.Builder, fixedStatusId:number):flatbuffers.Offset { - StatusSystemFixed.startStatusSystemFixed(builder); - StatusSystemFixed.addFixedStatusId(builder, fixedStatusId); - return StatusSystemFixed.endStatusSystemFixed(builder); -} - -unpack(): StatusSystemFixedT { - return new StatusSystemFixedT( - this.fixedStatusId() - ); -} - - -unpackTo(_o: StatusSystemFixedT): void { - _o.fixedStatusId = this.fixedStatusId(); -} -} - -export class StatusSystemFixedT implements flatbuffers.IGeneratedObject { -constructor( - public fixedStatusId: number = 0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return StatusSystemFixed.createStatusSystemFixed(builder, - this.fixedStatusId - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-system-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-system-request.ts deleted file mode 100644 index 1feb037b9..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-system-request.ts +++ /dev/null @@ -1,57 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * Request current statuses that we have - */ -export class StatusSystemRequest implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusSystemRequest { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusSystemRequest(bb:flatbuffers.ByteBuffer, obj?:StatusSystemRequest):StatusSystemRequest { - return (obj || new StatusSystemRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusSystemRequest(bb:flatbuffers.ByteBuffer, obj?:StatusSystemRequest):StatusSystemRequest { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusSystemRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startStatusSystemRequest(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endStatusSystemRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusSystemRequest(builder:flatbuffers.Builder):flatbuffers.Offset { - StatusSystemRequest.startStatusSystemRequest(builder); - return StatusSystemRequest.endStatusSystemRequest(builder); -} - -unpack(): StatusSystemRequestT { - return new StatusSystemRequestT(); -} - - -unpackTo(_o: StatusSystemRequestT): void {} -} - -export class StatusSystemRequestT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return StatusSystemRequest.createStatusSystemRequest(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-system-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-system-response.ts deleted file mode 100644 index 07028843b..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-system-response.ts +++ /dev/null @@ -1,95 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { StatusMessage, StatusMessageT } from '../../solarxr-protocol/rpc/status-message.js'; - - -/** - * Response containing all current valid statuses - */ -export class StatusSystemResponse implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusSystemResponse { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusSystemResponse(bb:flatbuffers.ByteBuffer, obj?:StatusSystemResponse):StatusSystemResponse { - return (obj || new StatusSystemResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusSystemResponse(bb:flatbuffers.ByteBuffer, obj?:StatusSystemResponse):StatusSystemResponse { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusSystemResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -currentStatuses(index: number, obj?:StatusMessage):StatusMessage|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new StatusMessage()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; -} - -currentStatusesLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -static startStatusSystemResponse(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addCurrentStatuses(builder:flatbuffers.Builder, currentStatusesOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, currentStatusesOffset, 0); -} - -static createCurrentStatusesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startCurrentStatusesVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static endStatusSystemResponse(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusSystemResponse(builder:flatbuffers.Builder, currentStatusesOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusSystemResponse.startStatusSystemResponse(builder); - StatusSystemResponse.addCurrentStatuses(builder, currentStatusesOffset); - return StatusSystemResponse.endStatusSystemResponse(builder); -} - -unpack(): StatusSystemResponseT { - return new StatusSystemResponseT( - this.bb!.createObjList(this.currentStatuses.bind(this), this.currentStatusesLength()) - ); -} - - -unpackTo(_o: StatusSystemResponseT): void { - _o.currentStatuses = this.bb!.createObjList(this.currentStatuses.bind(this), this.currentStatusesLength()); -} -} - -export class StatusSystemResponseT implements flatbuffers.IGeneratedObject { -constructor( - public currentStatuses: (StatusMessageT)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const currentStatuses = StatusSystemResponse.createCurrentStatusesVector(builder, builder.createObjectOffsetList(this.currentStatuses)); - - return StatusSystemResponse.createStatusSystemResponse(builder, - currentStatuses - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-system-update.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-system-update.ts deleted file mode 100644 index 063833e5f..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-system-update.ts +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { StatusMessage, StatusMessageT } from '../../solarxr-protocol/rpc/status-message.js'; - - -/** - * When a new status appears, it's sent alone - */ -export class StatusSystemUpdate implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusSystemUpdate { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusSystemUpdate(bb:flatbuffers.ByteBuffer, obj?:StatusSystemUpdate):StatusSystemUpdate { - return (obj || new StatusSystemUpdate()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusSystemUpdate(bb:flatbuffers.ByteBuffer, obj?:StatusSystemUpdate):StatusSystemUpdate { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusSystemUpdate()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -newStatus(obj?:StatusMessage):StatusMessage|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new StatusMessage()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startStatusSystemUpdate(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addNewStatus(builder:flatbuffers.Builder, newStatusOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, newStatusOffset, 0); -} - -static endStatusSystemUpdate(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusSystemUpdate(builder:flatbuffers.Builder, newStatusOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusSystemUpdate.startStatusSystemUpdate(builder); - StatusSystemUpdate.addNewStatus(builder, newStatusOffset); - return StatusSystemUpdate.endStatusSystemUpdate(builder); -} - -unpack(): StatusSystemUpdateT { - return new StatusSystemUpdateT( - (this.newStatus() !== null ? this.newStatus()!.unpack() : null) - ); -} - - -unpackTo(_o: StatusSystemUpdateT): void { - _o.newStatus = (this.newStatus() !== null ? this.newStatus()!.unpack() : null); -} -} - -export class StatusSystemUpdateT implements flatbuffers.IGeneratedObject { -constructor( - public newStatus: StatusMessageT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const newStatus = (this.newStatus !== null ? this.newStatus!.pack(builder) : 0); - - return StatusSystemUpdate.createStatusSystemUpdate(builder, - newStatus - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts deleted file mode 100644 index 0c3afe501..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts +++ /dev/null @@ -1,95 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; - - -/** - * Trackers with error state - */ -export class StatusTrackerError implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusTrackerError { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusTrackerError(bb:flatbuffers.ByteBuffer, obj?:StatusTrackerError):StatusTrackerError { - return (obj || new StatusTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusTrackerError(bb:flatbuffers.ByteBuffer, obj?:StatusTrackerError):StatusTrackerError { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -trackerId(index: number, obj?:TrackerId):TrackerId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; -} - -trackerIdLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -static startStatusTrackerError(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); -} - -static createTrackerIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startTrackerIdVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static endStatusTrackerError(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusTrackerError(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusTrackerError.startStatusTrackerError(builder); - StatusTrackerError.addTrackerId(builder, trackerIdOffset); - return StatusTrackerError.endStatusTrackerError(builder); -} - -unpack(): StatusTrackerErrorT { - return new StatusTrackerErrorT( - this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()) - ); -} - - -unpackTo(_o: StatusTrackerErrorT): void { - _o.trackerId = this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()); -} -} - -export class StatusTrackerErrorT implements flatbuffers.IGeneratedObject { -constructor( - public trackerId: (TrackerIdT)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = StatusTrackerError.createTrackerIdVector(builder, builder.createObjectOffsetList(this.trackerId)); - - return StatusTrackerError.createStatusTrackerError(builder, - trackerId - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts deleted file mode 100644 index 725018058..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts +++ /dev/null @@ -1,95 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; - - -/** - * Tracker requires full reset - */ -export class StatusTrackerReset implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusTrackerReset { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusTrackerReset(bb:flatbuffers.ByteBuffer, obj?:StatusTrackerReset):StatusTrackerReset { - return (obj || new StatusTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusTrackerReset(bb:flatbuffers.ByteBuffer, obj?:StatusTrackerReset):StatusTrackerReset { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -trackerId(index: number, obj?:TrackerId):TrackerId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; -} - -trackerIdLength():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; -} - -static startStatusTrackerReset(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); -} - -static createTrackerIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); - for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); - } - return builder.endVector(); -} - -static startTrackerIdVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); -} - -static endStatusTrackerReset(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusTrackerReset(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusTrackerReset.startStatusTrackerReset(builder); - StatusTrackerReset.addTrackerId(builder, trackerIdOffset); - return StatusTrackerReset.endStatusTrackerReset(builder); -} - -unpack(): StatusTrackerResetT { - return new StatusTrackerResetT( - this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()) - ); -} - - -unpackTo(_o: StatusTrackerResetT): void { - _o.trackerId = this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()); -} -} - -export class StatusTrackerResetT implements flatbuffers.IGeneratedObject { -constructor( - public trackerId: (TrackerIdT)[] = [] -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = StatusTrackerReset.createTrackerIdVector(builder, builder.createObjectOffsetList(this.trackerId)); - - return StatusTrackerReset.createStatusTrackerReset(builder, - trackerId - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-unassigned-hmd.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-unassigned-hmd.ts deleted file mode 100644 index 390f6aa21..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-unassigned-hmd.ts +++ /dev/null @@ -1,78 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; - - -/** - * There is an available HMD tracker and it's not assigned to head - */ -export class StatusUnassignedHMD implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StatusUnassignedHMD { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsStatusUnassignedHMD(bb:flatbuffers.ByteBuffer, obj?:StatusUnassignedHMD):StatusUnassignedHMD { - return (obj || new StatusUnassignedHMD()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsStatusUnassignedHMD(bb:flatbuffers.ByteBuffer, obj?:StatusUnassignedHMD):StatusUnassignedHMD { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StatusUnassignedHMD()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -trackerId(obj?:TrackerId):TrackerId|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -static startStatusUnassignedHMD(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); -} - -static endStatusUnassignedHMD(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createStatusUnassignedHMD(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { - StatusUnassignedHMD.startStatusUnassignedHMD(builder); - StatusUnassignedHMD.addTrackerId(builder, trackerIdOffset); - return StatusUnassignedHMD.endStatusUnassignedHMD(builder); -} - -unpack(): StatusUnassignedHMDT { - return new StatusUnassignedHMDT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) - ); -} - - -unpackTo(_o: StatusUnassignedHMDT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); -} -} - -export class StatusUnassignedHMDT implements flatbuffers.IGeneratedObject { -constructor( - public trackerId: TrackerIdT|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - - return StatusUnassignedHMD.createStatusUnassignedHMD(builder, - trackerId - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-hide-correction-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-hide-correction-request.ts new file mode 100644 index 000000000..4d15d3ac9 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-hide-correction-request.ts @@ -0,0 +1,72 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class StayAlignedHideCorrectionRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):StayAlignedHideCorrectionRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsStayAlignedHideCorrectionRequest(bb:flatbuffers.ByteBuffer, obj?:StayAlignedHideCorrectionRequest):StayAlignedHideCorrectionRequest { + return (obj || new StayAlignedHideCorrectionRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsStayAlignedHideCorrectionRequest(bb:flatbuffers.ByteBuffer, obj?:StayAlignedHideCorrectionRequest):StayAlignedHideCorrectionRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new StayAlignedHideCorrectionRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +hideCorrection():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startStayAlignedHideCorrectionRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addHideCorrection(builder:flatbuffers.Builder, hideCorrection:boolean) { + builder.addFieldInt8(0, +hideCorrection, +false); +} + +static endStayAlignedHideCorrectionRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createStayAlignedHideCorrectionRequest(builder:flatbuffers.Builder, hideCorrection:boolean):flatbuffers.Offset { + StayAlignedHideCorrectionRequest.startStayAlignedHideCorrectionRequest(builder); + StayAlignedHideCorrectionRequest.addHideCorrection(builder, hideCorrection); + return StayAlignedHideCorrectionRequest.endStayAlignedHideCorrectionRequest(builder); +} + +unpack(): StayAlignedHideCorrectionRequestT { + return new StayAlignedHideCorrectionRequestT( + this.hideCorrection() + ); +} + + +unpackTo(_o: StayAlignedHideCorrectionRequestT): void { + _o.hideCorrection = this.hideCorrection(); +} +} + +export class StayAlignedHideCorrectionRequestT implements flatbuffers.IGeneratedObject { +constructor( + public hideCorrection: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return StayAlignedHideCorrectionRequest.createStayAlignedHideCorrectionRequest(builder, + this.hideCorrection + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-request.ts new file mode 100644 index 000000000..b5cb215b0 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class StayAlignedSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):StayAlignedSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsStayAlignedSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettingsRequest):StayAlignedSettingsRequest { + return (obj || new StayAlignedSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsStayAlignedSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettingsRequest):StayAlignedSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new StayAlignedSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startStayAlignedSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endStayAlignedSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createStayAlignedSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + StayAlignedSettingsRequest.startStayAlignedSettingsRequest(builder); + return StayAlignedSettingsRequest.endStayAlignedSettingsRequest(builder); +} + +unpack(): StayAlignedSettingsRequestT { + return new StayAlignedSettingsRequestT(); +} + + +unpackTo(_o: StayAlignedSettingsRequestT): void {} +} + +export class StayAlignedSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return StayAlignedSettingsRequest.createStayAlignedSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-response.ts similarity index 54% rename from protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings.ts rename to protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-response.ts index 8eb24f610..3bbbba802 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/stay-aligned-settings-response.ts @@ -4,22 +4,22 @@ import * as flatbuffers from 'flatbuffers'; -export class StayAlignedSettings implements flatbuffers.IUnpackableObject { +export class StayAlignedSettingsResponse implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):StayAlignedSettings { + __init(i:number, bb:flatbuffers.ByteBuffer):StayAlignedSettingsResponse { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsStayAlignedSettings(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettings):StayAlignedSettings { - return (obj || new StayAlignedSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsStayAlignedSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettingsResponse):StayAlignedSettingsResponse { + return (obj || new StayAlignedSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsStayAlignedSettings(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettings):StayAlignedSettings { +static getSizePrefixedRootAsStayAlignedSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:StayAlignedSettingsResponse):StayAlignedSettingsResponse { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new StayAlignedSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new StayAlignedSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } enabled():boolean { @@ -27,180 +27,148 @@ enabled():boolean { return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } -extraYawCorrection():boolean { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -hideYawCorrection():boolean { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - standingEnabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 10); + const offset = this.bb!.__offset(this.bb_pos, 6); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } standingUpperLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 12); + const offset = this.bb!.__offset(this.bb_pos, 8); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } standingLowerLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 14); + const offset = this.bb!.__offset(this.bb_pos, 10); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } standingFootAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 16); + const offset = this.bb!.__offset(this.bb_pos, 12); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } sittingEnabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 18); + const offset = this.bb!.__offset(this.bb_pos, 14); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } sittingUpperLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 20); + const offset = this.bb!.__offset(this.bb_pos, 16); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } sittingLowerLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 22); + const offset = this.bb!.__offset(this.bb_pos, 18); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } sittingFootAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 20); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } flatEnabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 22); return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } flatUpperLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 28); + const offset = this.bb!.__offset(this.bb_pos, 24); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } flatLowerLegAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 30); + const offset = this.bb!.__offset(this.bb_pos, 26); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } flatFootAngle():number { - const offset = this.bb!.__offset(this.bb_pos, 32); + const offset = this.bb!.__offset(this.bb_pos, 28); return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; } -setupComplete():boolean { - const offset = this.bb!.__offset(this.bb_pos, 34); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startStayAlignedSettings(builder:flatbuffers.Builder) { - builder.startObject(16); +static startStayAlignedSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(13); } static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { builder.addFieldInt8(0, +enabled, +false); } -static addExtraYawCorrection(builder:flatbuffers.Builder, extraYawCorrection:boolean) { - builder.addFieldInt8(1, +extraYawCorrection, +false); -} - -static addHideYawCorrection(builder:flatbuffers.Builder, hideYawCorrection:boolean) { - builder.addFieldInt8(2, +hideYawCorrection, +false); -} - static addStandingEnabled(builder:flatbuffers.Builder, standingEnabled:boolean) { - builder.addFieldInt8(3, +standingEnabled, +false); + builder.addFieldInt8(1, +standingEnabled, +false); } static addStandingUpperLegAngle(builder:flatbuffers.Builder, standingUpperLegAngle:number) { - builder.addFieldFloat32(4, standingUpperLegAngle, 0.0); + builder.addFieldFloat32(2, standingUpperLegAngle, 0.0); } static addStandingLowerLegAngle(builder:flatbuffers.Builder, standingLowerLegAngle:number) { - builder.addFieldFloat32(5, standingLowerLegAngle, 0.0); + builder.addFieldFloat32(3, standingLowerLegAngle, 0.0); } static addStandingFootAngle(builder:flatbuffers.Builder, standingFootAngle:number) { - builder.addFieldFloat32(6, standingFootAngle, 0.0); + builder.addFieldFloat32(4, standingFootAngle, 0.0); } static addSittingEnabled(builder:flatbuffers.Builder, sittingEnabled:boolean) { - builder.addFieldInt8(7, +sittingEnabled, +false); + builder.addFieldInt8(5, +sittingEnabled, +false); } static addSittingUpperLegAngle(builder:flatbuffers.Builder, sittingUpperLegAngle:number) { - builder.addFieldFloat32(8, sittingUpperLegAngle, 0.0); + builder.addFieldFloat32(6, sittingUpperLegAngle, 0.0); } static addSittingLowerLegAngle(builder:flatbuffers.Builder, sittingLowerLegAngle:number) { - builder.addFieldFloat32(9, sittingLowerLegAngle, 0.0); + builder.addFieldFloat32(7, sittingLowerLegAngle, 0.0); } static addSittingFootAngle(builder:flatbuffers.Builder, sittingFootAngle:number) { - builder.addFieldFloat32(10, sittingFootAngle, 0.0); + builder.addFieldFloat32(8, sittingFootAngle, 0.0); } static addFlatEnabled(builder:flatbuffers.Builder, flatEnabled:boolean) { - builder.addFieldInt8(11, +flatEnabled, +false); + builder.addFieldInt8(9, +flatEnabled, +false); } static addFlatUpperLegAngle(builder:flatbuffers.Builder, flatUpperLegAngle:number) { - builder.addFieldFloat32(12, flatUpperLegAngle, 0.0); + builder.addFieldFloat32(10, flatUpperLegAngle, 0.0); } static addFlatLowerLegAngle(builder:flatbuffers.Builder, flatLowerLegAngle:number) { - builder.addFieldFloat32(13, flatLowerLegAngle, 0.0); + builder.addFieldFloat32(11, flatLowerLegAngle, 0.0); } static addFlatFootAngle(builder:flatbuffers.Builder, flatFootAngle:number) { - builder.addFieldFloat32(14, flatFootAngle, 0.0); -} - -static addSetupComplete(builder:flatbuffers.Builder, setupComplete:boolean) { - builder.addFieldInt8(15, +setupComplete, +false); + builder.addFieldFloat32(12, flatFootAngle, 0.0); } -static endStayAlignedSettings(builder:flatbuffers.Builder):flatbuffers.Offset { +static endStayAlignedSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createStayAlignedSettings(builder:flatbuffers.Builder, enabled:boolean, extraYawCorrection:boolean, hideYawCorrection:boolean, standingEnabled:boolean, standingUpperLegAngle:number, standingLowerLegAngle:number, standingFootAngle:number, sittingEnabled:boolean, sittingUpperLegAngle:number, sittingLowerLegAngle:number, sittingFootAngle:number, flatEnabled:boolean, flatUpperLegAngle:number, flatLowerLegAngle:number, flatFootAngle:number, setupComplete:boolean):flatbuffers.Offset { - StayAlignedSettings.startStayAlignedSettings(builder); - StayAlignedSettings.addEnabled(builder, enabled); - StayAlignedSettings.addExtraYawCorrection(builder, extraYawCorrection); - StayAlignedSettings.addHideYawCorrection(builder, hideYawCorrection); - StayAlignedSettings.addStandingEnabled(builder, standingEnabled); - StayAlignedSettings.addStandingUpperLegAngle(builder, standingUpperLegAngle); - StayAlignedSettings.addStandingLowerLegAngle(builder, standingLowerLegAngle); - StayAlignedSettings.addStandingFootAngle(builder, standingFootAngle); - StayAlignedSettings.addSittingEnabled(builder, sittingEnabled); - StayAlignedSettings.addSittingUpperLegAngle(builder, sittingUpperLegAngle); - StayAlignedSettings.addSittingLowerLegAngle(builder, sittingLowerLegAngle); - StayAlignedSettings.addSittingFootAngle(builder, sittingFootAngle); - StayAlignedSettings.addFlatEnabled(builder, flatEnabled); - StayAlignedSettings.addFlatUpperLegAngle(builder, flatUpperLegAngle); - StayAlignedSettings.addFlatLowerLegAngle(builder, flatLowerLegAngle); - StayAlignedSettings.addFlatFootAngle(builder, flatFootAngle); - StayAlignedSettings.addSetupComplete(builder, setupComplete); - return StayAlignedSettings.endStayAlignedSettings(builder); -} - -unpack(): StayAlignedSettingsT { - return new StayAlignedSettingsT( +static createStayAlignedSettingsResponse(builder:flatbuffers.Builder, enabled:boolean, standingEnabled:boolean, standingUpperLegAngle:number, standingLowerLegAngle:number, standingFootAngle:number, sittingEnabled:boolean, sittingUpperLegAngle:number, sittingLowerLegAngle:number, sittingFootAngle:number, flatEnabled:boolean, flatUpperLegAngle:number, flatLowerLegAngle:number, flatFootAngle:number):flatbuffers.Offset { + StayAlignedSettingsResponse.startStayAlignedSettingsResponse(builder); + StayAlignedSettingsResponse.addEnabled(builder, enabled); + StayAlignedSettingsResponse.addStandingEnabled(builder, standingEnabled); + StayAlignedSettingsResponse.addStandingUpperLegAngle(builder, standingUpperLegAngle); + StayAlignedSettingsResponse.addStandingLowerLegAngle(builder, standingLowerLegAngle); + StayAlignedSettingsResponse.addStandingFootAngle(builder, standingFootAngle); + StayAlignedSettingsResponse.addSittingEnabled(builder, sittingEnabled); + StayAlignedSettingsResponse.addSittingUpperLegAngle(builder, sittingUpperLegAngle); + StayAlignedSettingsResponse.addSittingLowerLegAngle(builder, sittingLowerLegAngle); + StayAlignedSettingsResponse.addSittingFootAngle(builder, sittingFootAngle); + StayAlignedSettingsResponse.addFlatEnabled(builder, flatEnabled); + StayAlignedSettingsResponse.addFlatUpperLegAngle(builder, flatUpperLegAngle); + StayAlignedSettingsResponse.addFlatLowerLegAngle(builder, flatLowerLegAngle); + StayAlignedSettingsResponse.addFlatFootAngle(builder, flatFootAngle); + return StayAlignedSettingsResponse.endStayAlignedSettingsResponse(builder); +} + +unpack(): StayAlignedSettingsResponseT { + return new StayAlignedSettingsResponseT( this.enabled(), - this.extraYawCorrection(), - this.hideYawCorrection(), this.standingEnabled(), this.standingUpperLegAngle(), this.standingLowerLegAngle(), @@ -212,16 +180,13 @@ unpack(): StayAlignedSettingsT { this.flatEnabled(), this.flatUpperLegAngle(), this.flatLowerLegAngle(), - this.flatFootAngle(), - this.setupComplete() + this.flatFootAngle() ); } -unpackTo(_o: StayAlignedSettingsT): void { +unpackTo(_o: StayAlignedSettingsResponseT): void { _o.enabled = this.enabled(); - _o.extraYawCorrection = this.extraYawCorrection(); - _o.hideYawCorrection = this.hideYawCorrection(); _o.standingEnabled = this.standingEnabled(); _o.standingUpperLegAngle = this.standingUpperLegAngle(); _o.standingLowerLegAngle = this.standingLowerLegAngle(); @@ -234,15 +199,12 @@ unpackTo(_o: StayAlignedSettingsT): void { _o.flatUpperLegAngle = this.flatUpperLegAngle(); _o.flatLowerLegAngle = this.flatLowerLegAngle(); _o.flatFootAngle = this.flatFootAngle(); - _o.setupComplete = this.setupComplete(); } } -export class StayAlignedSettingsT implements flatbuffers.IGeneratedObject { +export class StayAlignedSettingsResponseT implements flatbuffers.IGeneratedObject { constructor( public enabled: boolean = false, - public extraYawCorrection: boolean = false, - public hideYawCorrection: boolean = false, public standingEnabled: boolean = false, public standingUpperLegAngle: number = 0.0, public standingLowerLegAngle: number = 0.0, @@ -254,16 +216,13 @@ constructor( public flatEnabled: boolean = false, public flatUpperLegAngle: number = 0.0, public flatLowerLegAngle: number = 0.0, - public flatFootAngle: number = 0.0, - public setupComplete: boolean = false + public flatFootAngle: number = 0.0 ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return StayAlignedSettings.createStayAlignedSettings(builder, + return StayAlignedSettingsResponse.createStayAlignedSettingsResponse(builder, this.enabled, - this.extraYawCorrection, - this.hideYawCorrection, this.standingEnabled, this.standingUpperLegAngle, this.standingLowerLegAngle, @@ -275,8 +234,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { this.flatEnabled, this.flatUpperLegAngle, this.flatLowerLegAngle, - this.flatFootAngle, - this.setupComplete + this.flatFootAngle ); } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/steam-vrtrackers-setting.ts b/protocol/typescript/src/solarxr-protocol/rpc/steam-vrtrackers-setting.ts deleted file mode 100644 index 6824ea930..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/steam-vrtrackers-setting.ts +++ /dev/null @@ -1,212 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class SteamVRTrackersSetting implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):SteamVRTrackersSetting { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsSteamVRTrackersSetting(bb:flatbuffers.ByteBuffer, obj?:SteamVRTrackersSetting):SteamVRTrackersSetting { - return (obj || new SteamVRTrackersSetting()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsSteamVRTrackersSetting(bb:flatbuffers.ByteBuffer, obj?:SteamVRTrackersSetting):SteamVRTrackersSetting { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new SteamVRTrackersSetting()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -waist():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -chest():boolean { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -automaticTrackerToggle():boolean { - const offset = this.bb!.__offset(this.bb_pos, 16); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -leftFoot():boolean { - const offset = this.bb!.__offset(this.bb_pos, 18); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -rightFoot():boolean { - const offset = this.bb!.__offset(this.bb_pos, 20); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -leftKnee():boolean { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -rightKnee():boolean { - const offset = this.bb!.__offset(this.bb_pos, 24); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -leftElbow():boolean { - const offset = this.bb!.__offset(this.bb_pos, 26); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -rightElbow():boolean { - const offset = this.bb!.__offset(this.bb_pos, 28); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -leftHand():boolean { - const offset = this.bb!.__offset(this.bb_pos, 30); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -rightHand():boolean { - const offset = this.bb!.__offset(this.bb_pos, 32); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startSteamVRTrackersSetting(builder:flatbuffers.Builder) { - builder.startObject(15); -} - -static addWaist(builder:flatbuffers.Builder, waist:boolean) { - builder.addFieldInt8(0, +waist, +false); -} - -static addChest(builder:flatbuffers.Builder, chest:boolean) { - builder.addFieldInt8(1, +chest, +false); -} - -static addAutomaticTrackerToggle(builder:flatbuffers.Builder, automaticTrackerToggle:boolean) { - builder.addFieldInt8(6, +automaticTrackerToggle, +false); -} - -static addLeftFoot(builder:flatbuffers.Builder, leftFoot:boolean) { - builder.addFieldInt8(7, +leftFoot, +false); -} - -static addRightFoot(builder:flatbuffers.Builder, rightFoot:boolean) { - builder.addFieldInt8(8, +rightFoot, +false); -} - -static addLeftKnee(builder:flatbuffers.Builder, leftKnee:boolean) { - builder.addFieldInt8(9, +leftKnee, +false); -} - -static addRightKnee(builder:flatbuffers.Builder, rightKnee:boolean) { - builder.addFieldInt8(10, +rightKnee, +false); -} - -static addLeftElbow(builder:flatbuffers.Builder, leftElbow:boolean) { - builder.addFieldInt8(11, +leftElbow, +false); -} - -static addRightElbow(builder:flatbuffers.Builder, rightElbow:boolean) { - builder.addFieldInt8(12, +rightElbow, +false); -} - -static addLeftHand(builder:flatbuffers.Builder, leftHand:boolean) { - builder.addFieldInt8(13, +leftHand, +false); -} - -static addRightHand(builder:flatbuffers.Builder, rightHand:boolean) { - builder.addFieldInt8(14, +rightHand, +false); -} - -static endSteamVRTrackersSetting(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createSteamVRTrackersSetting(builder:flatbuffers.Builder, waist:boolean, chest:boolean, automaticTrackerToggle:boolean, leftFoot:boolean, rightFoot:boolean, leftKnee:boolean, rightKnee:boolean, leftElbow:boolean, rightElbow:boolean, leftHand:boolean, rightHand:boolean):flatbuffers.Offset { - SteamVRTrackersSetting.startSteamVRTrackersSetting(builder); - SteamVRTrackersSetting.addWaist(builder, waist); - SteamVRTrackersSetting.addChest(builder, chest); - SteamVRTrackersSetting.addAutomaticTrackerToggle(builder, automaticTrackerToggle); - SteamVRTrackersSetting.addLeftFoot(builder, leftFoot); - SteamVRTrackersSetting.addRightFoot(builder, rightFoot); - SteamVRTrackersSetting.addLeftKnee(builder, leftKnee); - SteamVRTrackersSetting.addRightKnee(builder, rightKnee); - SteamVRTrackersSetting.addLeftElbow(builder, leftElbow); - SteamVRTrackersSetting.addRightElbow(builder, rightElbow); - SteamVRTrackersSetting.addLeftHand(builder, leftHand); - SteamVRTrackersSetting.addRightHand(builder, rightHand); - return SteamVRTrackersSetting.endSteamVRTrackersSetting(builder); -} - -unpack(): SteamVRTrackersSettingT { - return new SteamVRTrackersSettingT( - this.waist(), - this.chest(), - this.automaticTrackerToggle(), - this.leftFoot(), - this.rightFoot(), - this.leftKnee(), - this.rightKnee(), - this.leftElbow(), - this.rightElbow(), - this.leftHand(), - this.rightHand() - ); -} - - -unpackTo(_o: SteamVRTrackersSettingT): void { - _o.waist = this.waist(); - _o.chest = this.chest(); - _o.automaticTrackerToggle = this.automaticTrackerToggle(); - _o.leftFoot = this.leftFoot(); - _o.rightFoot = this.rightFoot(); - _o.leftKnee = this.leftKnee(); - _o.rightKnee = this.rightKnee(); - _o.leftElbow = this.leftElbow(); - _o.rightElbow = this.rightElbow(); - _o.leftHand = this.leftHand(); - _o.rightHand = this.rightHand(); -} -} - -export class SteamVRTrackersSettingT implements flatbuffers.IGeneratedObject { -constructor( - public waist: boolean = false, - public chest: boolean = false, - public automaticTrackerToggle: boolean = false, - public leftFoot: boolean = false, - public rightFoot: boolean = false, - public leftKnee: boolean = false, - public rightKnee: boolean = false, - public leftElbow: boolean = false, - public rightElbow: boolean = false, - public leftHand: boolean = false, - public rightHand: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return SteamVRTrackersSetting.createSteamVRTrackersSetting(builder, - this.waist, - this.chest, - this.automaticTrackerToggle, - this.leftFoot, - this.rightFoot, - this.leftKnee, - this.rightKnee, - this.leftElbow, - this.rightElbow, - this.leftHand, - this.rightHand - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-request.ts new file mode 100644 index 000000000..af91dbd9e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class TapDetectionSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TapDetectionSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTapDetectionSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettingsRequest):TapDetectionSettingsRequest { + return (obj || new TapDetectionSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTapDetectionSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettingsRequest):TapDetectionSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TapDetectionSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startTapDetectionSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endTapDetectionSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTapDetectionSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + TapDetectionSettingsRequest.startTapDetectionSettingsRequest(builder); + return TapDetectionSettingsRequest.endTapDetectionSettingsRequest(builder); +} + +unpack(): TapDetectionSettingsRequestT { + return new TapDetectionSettingsRequestT(); +} + + +unpackTo(_o: TapDetectionSettingsRequestT): void {} +} + +export class TapDetectionSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return TapDetectionSettingsRequest.createTapDetectionSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-response.ts similarity index 66% rename from protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings.ts rename to protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-response.ts index 45446e20e..4f10626a2 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-settings-response.ts @@ -5,22 +5,22 @@ import * as flatbuffers from 'flatbuffers'; import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; -export class TapDetectionSettings implements flatbuffers.IUnpackableObject { +export class TapDetectionSettingsResponse implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TapDetectionSettings { + __init(i:number, bb:flatbuffers.ByteBuffer):TapDetectionSettingsResponse { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsTapDetectionSettings(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettings):TapDetectionSettings { - return (obj || new TapDetectionSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsTapDetectionSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettingsResponse):TapDetectionSettingsResponse { + return (obj || new TapDetectionSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsTapDetectionSettings(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettings):TapDetectionSettings { +static getSizePrefixedRootAsTapDetectionSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSettingsResponse):TapDetectionSettingsResponse { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TapDetectionSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new TapDetectionSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } fullResetDelay():number|null { @@ -68,37 +68,28 @@ mountingResetTaps():number|null { return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } -/** - * If true, disables reset behavior of tap detection and sends a - * TapDetectionSetupNotification, each time 2 taps are detected on any tracker - */ -setupMode():boolean|null { - const offset = this.bb!.__offset(this.bb_pos, 22); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; -} - numberTrackersOverThreshold():number|null { - const offset = this.bb!.__offset(this.bb_pos, 24); + const offset = this.bb!.__offset(this.bb_pos, 22); return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } yawResetTracker():BodyPart|null { - const offset = this.bb!.__offset(this.bb_pos, 26); + const offset = this.bb!.__offset(this.bb_pos, 24); return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } fullResetTracker():BodyPart|null { - const offset = this.bb!.__offset(this.bb_pos, 28); + const offset = this.bb!.__offset(this.bb_pos, 26); return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } mountingResetTracker():BodyPart|null { - const offset = this.bb!.__offset(this.bb_pos, 30); + const offset = this.bb!.__offset(this.bb_pos, 28); return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; } -static startTapDetectionSettings(builder:flatbuffers.Builder) { - builder.startObject(14); +static startTapDetectionSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(13); } static addFullResetDelay(builder:flatbuffers.Builder, fullResetDelay:number) { @@ -137,66 +128,60 @@ static addMountingResetTaps(builder:flatbuffers.Builder, mountingResetTaps:numbe builder.addFieldInt8(8, mountingResetTaps, 0); } -static addSetupMode(builder:flatbuffers.Builder, setupMode:boolean) { - builder.addFieldInt8(9, +setupMode, 0); -} - static addNumberTrackersOverThreshold(builder:flatbuffers.Builder, numberTrackersOverThreshold:number) { - builder.addFieldInt8(10, numberTrackersOverThreshold, 0); + builder.addFieldInt8(9, numberTrackersOverThreshold, 0); } static addYawResetTracker(builder:flatbuffers.Builder, yawResetTracker:BodyPart) { - builder.addFieldInt8(11, yawResetTracker, 0); + builder.addFieldInt8(10, yawResetTracker, 0); } static addFullResetTracker(builder:flatbuffers.Builder, fullResetTracker:BodyPart) { - builder.addFieldInt8(12, fullResetTracker, 0); + builder.addFieldInt8(11, fullResetTracker, 0); } static addMountingResetTracker(builder:flatbuffers.Builder, mountingResetTracker:BodyPart) { - builder.addFieldInt8(13, mountingResetTracker, 0); + builder.addFieldInt8(12, mountingResetTracker, 0); } -static endTapDetectionSettings(builder:flatbuffers.Builder):flatbuffers.Offset { +static endTapDetectionSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createTapDetectionSettings(builder:flatbuffers.Builder, fullResetDelay:number|null, fullResetEnabled:boolean|null, fullResetTaps:number|null, yawResetDelay:number|null, yawResetEnabled:boolean|null, yawResetTaps:number|null, mountingResetDelay:number|null, mountingResetEnabled:boolean|null, mountingResetTaps:number|null, setupMode:boolean|null, numberTrackersOverThreshold:number|null, yawResetTracker:BodyPart|null, fullResetTracker:BodyPart|null, mountingResetTracker:BodyPart|null):flatbuffers.Offset { - TapDetectionSettings.startTapDetectionSettings(builder); +static createTapDetectionSettingsResponse(builder:flatbuffers.Builder, fullResetDelay:number|null, fullResetEnabled:boolean|null, fullResetTaps:number|null, yawResetDelay:number|null, yawResetEnabled:boolean|null, yawResetTaps:number|null, mountingResetDelay:number|null, mountingResetEnabled:boolean|null, mountingResetTaps:number|null, numberTrackersOverThreshold:number|null, yawResetTracker:BodyPart|null, fullResetTracker:BodyPart|null, mountingResetTracker:BodyPart|null):flatbuffers.Offset { + TapDetectionSettingsResponse.startTapDetectionSettingsResponse(builder); if (fullResetDelay !== null) - TapDetectionSettings.addFullResetDelay(builder, fullResetDelay); + TapDetectionSettingsResponse.addFullResetDelay(builder, fullResetDelay); if (fullResetEnabled !== null) - TapDetectionSettings.addFullResetEnabled(builder, fullResetEnabled); + TapDetectionSettingsResponse.addFullResetEnabled(builder, fullResetEnabled); if (fullResetTaps !== null) - TapDetectionSettings.addFullResetTaps(builder, fullResetTaps); + TapDetectionSettingsResponse.addFullResetTaps(builder, fullResetTaps); if (yawResetDelay !== null) - TapDetectionSettings.addYawResetDelay(builder, yawResetDelay); + TapDetectionSettingsResponse.addYawResetDelay(builder, yawResetDelay); if (yawResetEnabled !== null) - TapDetectionSettings.addYawResetEnabled(builder, yawResetEnabled); + TapDetectionSettingsResponse.addYawResetEnabled(builder, yawResetEnabled); if (yawResetTaps !== null) - TapDetectionSettings.addYawResetTaps(builder, yawResetTaps); + TapDetectionSettingsResponse.addYawResetTaps(builder, yawResetTaps); if (mountingResetDelay !== null) - TapDetectionSettings.addMountingResetDelay(builder, mountingResetDelay); + TapDetectionSettingsResponse.addMountingResetDelay(builder, mountingResetDelay); if (mountingResetEnabled !== null) - TapDetectionSettings.addMountingResetEnabled(builder, mountingResetEnabled); + TapDetectionSettingsResponse.addMountingResetEnabled(builder, mountingResetEnabled); if (mountingResetTaps !== null) - TapDetectionSettings.addMountingResetTaps(builder, mountingResetTaps); - if (setupMode !== null) - TapDetectionSettings.addSetupMode(builder, setupMode); + TapDetectionSettingsResponse.addMountingResetTaps(builder, mountingResetTaps); if (numberTrackersOverThreshold !== null) - TapDetectionSettings.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); + TapDetectionSettingsResponse.addNumberTrackersOverThreshold(builder, numberTrackersOverThreshold); if (yawResetTracker !== null) - TapDetectionSettings.addYawResetTracker(builder, yawResetTracker); + TapDetectionSettingsResponse.addYawResetTracker(builder, yawResetTracker); if (fullResetTracker !== null) - TapDetectionSettings.addFullResetTracker(builder, fullResetTracker); + TapDetectionSettingsResponse.addFullResetTracker(builder, fullResetTracker); if (mountingResetTracker !== null) - TapDetectionSettings.addMountingResetTracker(builder, mountingResetTracker); - return TapDetectionSettings.endTapDetectionSettings(builder); + TapDetectionSettingsResponse.addMountingResetTracker(builder, mountingResetTracker); + return TapDetectionSettingsResponse.endTapDetectionSettingsResponse(builder); } -unpack(): TapDetectionSettingsT { - return new TapDetectionSettingsT( +unpack(): TapDetectionSettingsResponseT { + return new TapDetectionSettingsResponseT( this.fullResetDelay(), this.fullResetEnabled(), this.fullResetTaps(), @@ -206,7 +191,6 @@ unpack(): TapDetectionSettingsT { this.mountingResetDelay(), this.mountingResetEnabled(), this.mountingResetTaps(), - this.setupMode(), this.numberTrackersOverThreshold(), this.yawResetTracker(), this.fullResetTracker(), @@ -215,7 +199,7 @@ unpack(): TapDetectionSettingsT { } -unpackTo(_o: TapDetectionSettingsT): void { +unpackTo(_o: TapDetectionSettingsResponseT): void { _o.fullResetDelay = this.fullResetDelay(); _o.fullResetEnabled = this.fullResetEnabled(); _o.fullResetTaps = this.fullResetTaps(); @@ -225,7 +209,6 @@ unpackTo(_o: TapDetectionSettingsT): void { _o.mountingResetDelay = this.mountingResetDelay(); _o.mountingResetEnabled = this.mountingResetEnabled(); _o.mountingResetTaps = this.mountingResetTaps(); - _o.setupMode = this.setupMode(); _o.numberTrackersOverThreshold = this.numberTrackersOverThreshold(); _o.yawResetTracker = this.yawResetTracker(); _o.fullResetTracker = this.fullResetTracker(); @@ -233,7 +216,7 @@ unpackTo(_o: TapDetectionSettingsT): void { } } -export class TapDetectionSettingsT implements flatbuffers.IGeneratedObject { +export class TapDetectionSettingsResponseT implements flatbuffers.IGeneratedObject { constructor( public fullResetDelay: number|null = null, public fullResetEnabled: boolean|null = null, @@ -244,7 +227,6 @@ constructor( public mountingResetDelay: number|null = null, public mountingResetEnabled: boolean|null = null, public mountingResetTaps: number|null = null, - public setupMode: boolean|null = null, public numberTrackersOverThreshold: number|null = null, public yawResetTracker: BodyPart|null = null, public fullResetTracker: BodyPart|null = null, @@ -253,7 +235,7 @@ constructor( pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return TapDetectionSettings.createTapDetectionSettings(builder, + return TapDetectionSettingsResponse.createTapDetectionSettingsResponse(builder, this.fullResetDelay, this.fullResetEnabled, this.fullResetTaps, @@ -263,7 +245,6 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { this.mountingResetDelay, this.mountingResetEnabled, this.mountingResetTaps, - this.setupMode, this.numberTrackersOverThreshold, this.yawResetTracker, this.fullResetTracker, diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-mode-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-mode-request.ts new file mode 100644 index 000000000..dded35fe8 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-mode-request.ts @@ -0,0 +1,79 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +/** + * Sets the TapDetection setup mode. + */ +export class TapDetectionSetupModeRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TapDetectionSetupModeRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTapDetectionSetupModeRequest(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSetupModeRequest):TapDetectionSetupModeRequest { + return (obj || new TapDetectionSetupModeRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTapDetectionSetupModeRequest(bb:flatbuffers.ByteBuffer, obj?:TapDetectionSetupModeRequest):TapDetectionSetupModeRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TapDetectionSetupModeRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +/** + * When true, TapDetection triggering a tracker will assign it instead of doing a reset. + */ +setupMode():boolean|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +} + +static startTapDetectionSetupModeRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addSetupMode(builder:flatbuffers.Builder, setupMode:boolean) { + builder.addFieldInt8(0, +setupMode, 0); +} + +static endTapDetectionSetupModeRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTapDetectionSetupModeRequest(builder:flatbuffers.Builder, setupMode:boolean|null):flatbuffers.Offset { + TapDetectionSetupModeRequest.startTapDetectionSetupModeRequest(builder); + if (setupMode !== null) + TapDetectionSetupModeRequest.addSetupMode(builder, setupMode); + return TapDetectionSetupModeRequest.endTapDetectionSetupModeRequest(builder); +} + +unpack(): TapDetectionSetupModeRequestT { + return new TapDetectionSetupModeRequestT( + this.setupMode() + ); +} + + +unpackTo(_o: TapDetectionSetupModeRequestT): void { + _o.setupMode = this.setupMode(); +} +} + +export class TapDetectionSetupModeRequestT implements flatbuffers.IGeneratedObject { +constructor( + public setupMode: boolean|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return TapDetectionSetupModeRequest.createTapDetectionSetupModeRequest(builder, + this.setupMode + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-notification.ts b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-notification.ts index 51b9dcb57..90a7c3553 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-notification.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tap-detection-setup-notification.ts @@ -2,11 +2,10 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** - * See TapDetectionSettings::setup_mode + * Indicates which tracker got triggered by TapDetection while setup mode is enabled */ export class TapDetectionSetupNotification implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; @@ -26,17 +25,17 @@ static getSizePrefixedRootAsTapDetectionSetupNotification(bb:flatbuffers.ByteBuf return (obj || new TapDetectionSetupNotification()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } static startTapDetectionSetupNotification(builder:flatbuffers.Builder) { builder.startObject(1); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static endTapDetectionSetupNotification(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -44,35 +43,33 @@ static endTapDetectionSetupNotification(builder:flatbuffers.Builder):flatbuffers return offset; } -static createTapDetectionSetupNotification(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { +static createTapDetectionSetupNotification(builder:flatbuffers.Builder, trackerId:number):flatbuffers.Offset { TapDetectionSetupNotification.startTapDetectionSetupNotification(builder); - TapDetectionSetupNotification.addTrackerId(builder, trackerIdOffset); + TapDetectionSetupNotification.addTrackerId(builder, trackerId); return TapDetectionSetupNotification.endTapDetectionSetupNotification(builder); } unpack(): TapDetectionSetupNotificationT { return new TapDetectionSetupNotificationT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + this.trackerId() ); } unpackTo(_o: TapDetectionSetupNotificationT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); } } export class TapDetectionSetupNotificationT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null + public trackerId: number = 0 ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - return TapDetectionSetupNotification.createTapDetectionSetupNotification(builder, - trackerId + this.trackerId ); } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/timeout-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/timeout-settings.ts deleted file mode 100644 index 875d6e4ec..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/timeout-settings.ts +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class TimeoutSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):TimeoutSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsTimeoutSettings(bb:flatbuffers.ByteBuffer, obj?:TimeoutSettings):TimeoutSettings { - return (obj || new TimeoutSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsTimeoutSettings(bb:flatbuffers.ByteBuffer, obj?:TimeoutSettings):TimeoutSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new TimeoutSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -duration():number { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; -} - -static startTimeoutSettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addDuration(builder:flatbuffers.Builder, duration:number) { - builder.addFieldFloat32(0, duration, 0.0); -} - -static endTimeoutSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createTimeoutSettings(builder:flatbuffers.Builder, duration:number):flatbuffers.Offset { - TimeoutSettings.startTimeoutSettings(builder); - TimeoutSettings.addDuration(builder, duration); - return TimeoutSettings.endTimeoutSettings(builder); -} - -unpack(): TimeoutSettingsT { - return new TimeoutSettingsT( - this.duration() - ); -} - - -unpackTo(_o: TimeoutSettingsT): void { - _o.duration = this.duration(); -} -} - -export class TimeoutSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public duration: number = 0.0 -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return TimeoutSettings.createTimeoutSettings(builder, - this.duration - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts index ce890c72d..2907127b7 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; export class TrackingChecklistNeedCalibration implements flatbuffers.IUnpackableObject { @@ -23,9 +22,9 @@ static getSizePrefixedRootAsTrackingChecklistNeedCalibration(bb:flatbuffers.Byte return (obj || new TrackingChecklistNeedCalibration()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackersId(index: number, obj?:TrackerId):TrackerId|null { +trackersId(index: number):number|null { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb!.__vector(this.bb_pos + offset) + index * 2) : 0; } trackersIdLength():number { @@ -33,6 +32,11 @@ trackersIdLength():number { return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } +trackersIdArray():Uint16Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? new Uint16Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + static startTrackingChecklistNeedCalibration(builder:flatbuffers.Builder) { builder.startObject(1); } @@ -41,16 +45,21 @@ static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.O builder.addFieldOffset(0, trackersIdOffset, 0); } -static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array):flatbuffers.Offset; +/** + * @deprecated This Uint8Array overload will be removed in the future. + */ +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array|Uint8Array):flatbuffers.Offset { + builder.startVector(2, data.length, 2); for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); + builder.addInt16(data[i]!); } return builder.endVector(); } static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); + builder.startVector(2, numElems, 2); } static endTrackingChecklistNeedCalibration(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -66,24 +75,24 @@ static createTrackingChecklistNeedCalibration(builder:flatbuffers.Builder, track unpack(): TrackingChecklistNeedCalibrationT { return new TrackingChecklistNeedCalibrationT( - this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()) ); } unpackTo(_o: TrackingChecklistNeedCalibrationT): void { - _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); + _o.trackersId = this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()); } } export class TrackingChecklistNeedCalibrationT implements flatbuffers.IGeneratedObject { constructor( - public trackersId: (TrackerIdT)[] = [] + public trackersId: (number)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackersId = TrackingChecklistNeedCalibration.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + const trackersId = TrackingChecklistNeedCalibration.createTrackersIdVector(builder, this.trackersId); return TrackingChecklistNeedCalibration.createTrackingChecklistNeedCalibration(builder, trackersId diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts index 1a2f049ce..651851510 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** @@ -26,9 +25,9 @@ static getSizePrefixedRootAsTrackingChecklistTrackerError(bb:flatbuffers.ByteBuf return (obj || new TrackingChecklistTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackersId(index: number, obj?:TrackerId):TrackerId|null { +trackersId(index: number):number|null { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb!.__vector(this.bb_pos + offset) + index * 2) : 0; } trackersIdLength():number { @@ -36,6 +35,11 @@ trackersIdLength():number { return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } +trackersIdArray():Uint16Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? new Uint16Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + static startTrackingChecklistTrackerError(builder:flatbuffers.Builder) { builder.startObject(1); } @@ -44,16 +48,21 @@ static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.O builder.addFieldOffset(0, trackersIdOffset, 0); } -static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array):flatbuffers.Offset; +/** + * @deprecated This Uint8Array overload will be removed in the future. + */ +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array|Uint8Array):flatbuffers.Offset { + builder.startVector(2, data.length, 2); for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); + builder.addInt16(data[i]!); } return builder.endVector(); } static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); + builder.startVector(2, numElems, 2); } static endTrackingChecklistTrackerError(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -69,24 +78,24 @@ static createTrackingChecklistTrackerError(builder:flatbuffers.Builder, trackers unpack(): TrackingChecklistTrackerErrorT { return new TrackingChecklistTrackerErrorT( - this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()) ); } unpackTo(_o: TrackingChecklistTrackerErrorT): void { - _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); + _o.trackersId = this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()); } } export class TrackingChecklistTrackerErrorT implements flatbuffers.IGeneratedObject { constructor( - public trackersId: (TrackerIdT)[] = [] + public trackersId: (number)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackersId = TrackingChecklistTrackerError.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + const trackersId = TrackingChecklistTrackerError.createTrackersIdVector(builder, this.trackersId); return TrackingChecklistTrackerError.createTrackingChecklistTrackerError(builder, trackersId diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts index 1b0143b3f..0ba64b7d6 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; /** @@ -26,9 +25,9 @@ static getSizePrefixedRootAsTrackingChecklistTrackerReset(bb:flatbuffers.ByteBuf return (obj || new TrackingChecklistTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackersId(index: number, obj?:TrackerId):TrackerId|null { +trackersId(index: number):number|null { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb!.__vector(this.bb_pos + offset) + index * 2) : 0; } trackersIdLength():number { @@ -36,6 +35,11 @@ trackersIdLength():number { return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } +trackersIdArray():Uint16Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? new Uint16Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + static startTrackingChecklistTrackerReset(builder:flatbuffers.Builder) { builder.startObject(1); } @@ -44,16 +48,21 @@ static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.O builder.addFieldOffset(0, trackersIdOffset, 0); } -static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { - builder.startVector(4, data.length, 4); +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array):flatbuffers.Offset; +/** + * @deprecated This Uint8Array overload will be removed in the future. + */ +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset; +static createTrackersIdVector(builder:flatbuffers.Builder, data:number[]|Uint16Array|Uint8Array):flatbuffers.Offset { + builder.startVector(2, data.length, 2); for (let i = data.length - 1; i >= 0; i--) { - builder.addOffset(data[i]!); + builder.addInt16(data[i]!); } return builder.endVector(); } static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { - builder.startVector(4, numElems, 4); + builder.startVector(2, numElems, 2); } static endTrackingChecklistTrackerReset(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -69,24 +78,24 @@ static createTrackingChecklistTrackerReset(builder:flatbuffers.Builder, trackers unpack(): TrackingChecklistTrackerResetT { return new TrackingChecklistTrackerResetT( - this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()) ); } unpackTo(_o: TrackingChecklistTrackerResetT): void { - _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); + _o.trackersId = this.bb!.createScalarList(this.trackersId.bind(this), this.trackersIdLength()); } } export class TrackingChecklistTrackerResetT implements flatbuffers.IGeneratedObject { constructor( - public trackersId: (TrackerIdT)[] = [] + public trackersId: (number)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackersId = TrackingChecklistTrackerReset.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + const trackersId = TrackingChecklistTrackerReset.createTrackersIdVector(builder, this.trackersId); return TrackingChecklistTrackerReset.createTrackingChecklistTrackerReset(builder, trackersId diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts index 2b521833c..e3d3db6ed 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts @@ -2,7 +2,6 @@ import * as flatbuffers from 'flatbuffers'; -import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; export class TrackingChecklistUnassignedHMD implements flatbuffers.IUnpackableObject { @@ -23,17 +22,17 @@ static getSizePrefixedRootAsTrackingChecklistUnassignedHMD(bb:flatbuffers.ByteBu return (obj || new TrackingChecklistUnassignedHMD()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId():number { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; } static startTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder) { builder.startObject(1); } -static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, trackerIdOffset, 0); +static addTrackerId(builder:flatbuffers.Builder, trackerId:number) { + builder.addFieldInt16(0, trackerId, 0); } static endTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder):flatbuffers.Offset { @@ -41,35 +40,33 @@ static endTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder):flatbuffer return offset; } -static createTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { +static createTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder, trackerId:number):flatbuffers.Offset { TrackingChecklistUnassignedHMD.startTrackingChecklistUnassignedHMD(builder); - TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerIdOffset); + TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerId); return TrackingChecklistUnassignedHMD.endTrackingChecklistUnassignedHMD(builder); } unpack(): TrackingChecklistUnassignedHMDT { return new TrackingChecklistUnassignedHMDT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + this.trackerId() ); } unpackTo(_o: TrackingChecklistUnassignedHMDT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.trackerId(); } } export class TrackingChecklistUnassignedHMDT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null + public trackerId: number = 0 ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); - return TrackingChecklistUnassignedHMD.createTrackingChecklistUnassignedHMD(builder, - trackerId + this.trackerId ); } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/velocity-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/velocity-settings.ts deleted file mode 100644 index 560451a0c..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/velocity-settings.ts +++ /dev/null @@ -1,72 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -export class VelocitySettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):VelocitySettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsVelocitySettings(bb:flatbuffers.ByteBuffer, obj?:VelocitySettings):VelocitySettings { - return (obj || new VelocitySettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsVelocitySettings(bb:flatbuffers.ByteBuffer, obj?:VelocitySettings):VelocitySettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new VelocitySettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -sendDerivedVelocity():boolean { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startVelocitySettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addSendDerivedVelocity(builder:flatbuffers.Builder, sendDerivedVelocity:boolean) { - builder.addFieldInt8(0, +sendDerivedVelocity, +false); -} - -static endVelocitySettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createVelocitySettings(builder:flatbuffers.Builder, sendDerivedVelocity:boolean):flatbuffers.Offset { - VelocitySettings.startVelocitySettings(builder); - VelocitySettings.addSendDerivedVelocity(builder, sendDerivedVelocity); - return VelocitySettings.endVelocitySettings(builder); -} - -unpack(): VelocitySettingsT { - return new VelocitySettingsT( - this.sendDerivedVelocity() - ); -} - - -unpackTo(_o: VelocitySettingsT): void { - _o.sendDerivedVelocity = this.sendDerivedVelocity(); -} -} - -export class VelocitySettingsT implements flatbuffers.IGeneratedObject { -constructor( - public sendDerivedVelocity: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return VelocitySettings.createVelocitySettings(builder, - this.sendDerivedVelocity - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-request.ts new file mode 100644 index 000000000..673d91f61 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VMCOSCSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VMCOSCSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVMCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettingsRequest):VMCOSCSettingsRequest { + return (obj || new VMCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVMCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettingsRequest):VMCOSCSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VMCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startVMCOSCSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endVMCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVMCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + VMCOSCSettingsRequest.startVMCOSCSettingsRequest(builder); + return VMCOSCSettingsRequest.endVMCOSCSettingsRequest(builder); +} + +unpack(): VMCOSCSettingsRequestT { + return new VMCOSCSettingsRequestT(); +} + + +unpackTo(_o: VMCOSCSettingsRequestT): void {} +} + +export class VMCOSCSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return VMCOSCSettingsRequest.createVMCOSCSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-response.ts new file mode 100644 index 000000000..5be628e10 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings-response.ts @@ -0,0 +1,146 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VMCOSCSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VMCOSCSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVMCOSCSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettingsResponse):VMCOSCSettingsResponse { + return (obj || new VMCOSCSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVMCOSCSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettingsResponse):VMCOSCSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VMCOSCSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +portIn():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +portOut():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +address():string|null +address(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +address(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +anchorHip():boolean { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +mirrorTracking():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startVMCOSCSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(6); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addPortIn(builder:flatbuffers.Builder, portIn:number) { + builder.addFieldInt16(1, portIn, 0); +} + +static addPortOut(builder:flatbuffers.Builder, portOut:number) { + builder.addFieldInt16(2, portOut, 0); +} + +static addAddress(builder:flatbuffers.Builder, addressOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, addressOffset, 0); +} + +static addAnchorHip(builder:flatbuffers.Builder, anchorHip:boolean) { + builder.addFieldInt8(4, +anchorHip, +false); +} + +static addMirrorTracking(builder:flatbuffers.Builder, mirrorTracking:boolean) { + builder.addFieldInt8(5, +mirrorTracking, +false); +} + +static endVMCOSCSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVMCOSCSettingsResponse(builder:flatbuffers.Builder, enabled:boolean, portIn:number, portOut:number, addressOffset:flatbuffers.Offset, anchorHip:boolean, mirrorTracking:boolean):flatbuffers.Offset { + VMCOSCSettingsResponse.startVMCOSCSettingsResponse(builder); + VMCOSCSettingsResponse.addEnabled(builder, enabled); + VMCOSCSettingsResponse.addPortIn(builder, portIn); + VMCOSCSettingsResponse.addPortOut(builder, portOut); + VMCOSCSettingsResponse.addAddress(builder, addressOffset); + VMCOSCSettingsResponse.addAnchorHip(builder, anchorHip); + VMCOSCSettingsResponse.addMirrorTracking(builder, mirrorTracking); + return VMCOSCSettingsResponse.endVMCOSCSettingsResponse(builder); +} + +unpack(): VMCOSCSettingsResponseT { + return new VMCOSCSettingsResponseT( + this.enabled(), + this.portIn(), + this.portOut(), + this.address(), + this.anchorHip(), + this.mirrorTracking() + ); +} + + +unpackTo(_o: VMCOSCSettingsResponseT): void { + _o.enabled = this.enabled(); + _o.portIn = this.portIn(); + _o.portOut = this.portOut(); + _o.address = this.address(); + _o.anchorHip = this.anchorHip(); + _o.mirrorTracking = this.mirrorTracking(); +} +} + +export class VMCOSCSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public portIn: number = 0, + public portOut: number = 0, + public address: string|Uint8Array|null = null, + public anchorHip: boolean = false, + public mirrorTracking: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const address = (this.address !== null ? builder.createString(this.address!) : 0); + + return VMCOSCSettingsResponse.createVMCOSCSettingsResponse(builder, + this.enabled, + this.portIn, + this.portOut, + address, + this.anchorHip, + this.mirrorTracking + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings.ts b/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings.ts deleted file mode 100644 index 09b333775..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/vmcoscsettings.ts +++ /dev/null @@ -1,106 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { OSCSettings, OSCSettingsT } from '../../solarxr-protocol/rpc/oscsettings.js'; - - -/** - * OSC Settings specific to VMC - */ -export class VMCOSCSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):VMCOSCSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsVMCOSCSettings(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettings):VMCOSCSettings { - return (obj || new VMCOSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsVMCOSCSettings(bb:flatbuffers.ByteBuffer, obj?:VMCOSCSettings):VMCOSCSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new VMCOSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -oscSettings(obj?:OSCSettings):OSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new OSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -anchorHip():boolean { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -mirrorTracking():boolean { - const offset = this.bb!.__offset(this.bb_pos, 10); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startVMCOSCSettings(builder:flatbuffers.Builder) { - builder.startObject(4); -} - -static addOscSettings(builder:flatbuffers.Builder, oscSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, oscSettingsOffset, 0); -} - -static addAnchorHip(builder:flatbuffers.Builder, anchorHip:boolean) { - builder.addFieldInt8(2, +anchorHip, +false); -} - -static addMirrorTracking(builder:flatbuffers.Builder, mirrorTracking:boolean) { - builder.addFieldInt8(3, +mirrorTracking, +false); -} - -static endVMCOSCSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createVMCOSCSettings(builder:flatbuffers.Builder, oscSettingsOffset:flatbuffers.Offset, anchorHip:boolean, mirrorTracking:boolean):flatbuffers.Offset { - VMCOSCSettings.startVMCOSCSettings(builder); - VMCOSCSettings.addOscSettings(builder, oscSettingsOffset); - VMCOSCSettings.addAnchorHip(builder, anchorHip); - VMCOSCSettings.addMirrorTracking(builder, mirrorTracking); - return VMCOSCSettings.endVMCOSCSettings(builder); -} - -unpack(): VMCOSCSettingsT { - return new VMCOSCSettingsT( - (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null), - this.anchorHip(), - this.mirrorTracking() - ); -} - - -unpackTo(_o: VMCOSCSettingsT): void { - _o.oscSettings = (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null); - _o.anchorHip = this.anchorHip(); - _o.mirrorTracking = this.mirrorTracking(); -} -} - -export class VMCOSCSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public oscSettings: OSCSettingsT|null = null, - public anchorHip: boolean = false, - public mirrorTracking: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const oscSettings = (this.oscSettings !== null ? this.oscSettings!.pack(builder) : 0); - - return VMCOSCSettings.createVMCOSCSettings(builder, - oscSettings, - this.anchorHip, - this.mirrorTracking - ); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts index f86256d84..25f08311d 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts @@ -22,6 +22,9 @@ static getSizePrefixedRootAsVRCConfigSettingToggleMute(bb:flatbuffers.ByteBuffer return (obj || new VRCConfigSettingToggleMute()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } +/** + * Key from VRCConfigValidity + */ key():string|null key(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null key(optionalEncoding?:any):string|Uint8Array|null { diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts index 4ecfa3358..88d44c321 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts @@ -49,6 +49,9 @@ recommended(obj?:VRCConfigRecommendedValues):VRCConfigRecommendedValues|null { return offset ? (obj || new VRCConfigRecommendedValues()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } +/** + * Just a list of keys from the VRCConfigValidity table. + */ muted(index: number):string muted(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array muted(index: number,optionalEncoding?:any):string|Uint8Array|null { diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscdiscovered-target.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscdiscovered-target.ts new file mode 100644 index 000000000..33b109b00 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscdiscovered-target.ts @@ -0,0 +1,107 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRCOSCDiscoveredTarget implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCDiscoveredTarget { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCDiscoveredTarget(bb:flatbuffers.ByteBuffer, obj?:VRCOSCDiscoveredTarget):VRCOSCDiscoveredTarget { + return (obj || new VRCOSCDiscoveredTarget()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCDiscoveredTarget(bb:flatbuffers.ByteBuffer, obj?:VRCOSCDiscoveredTarget):VRCOSCDiscoveredTarget { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCDiscoveredTarget()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +name():string|null +name(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +name(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +address():string|null +address(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +address(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +portOut():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +static startVRCOSCDiscoveredTarget(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, nameOffset, 0); +} + +static addAddress(builder:flatbuffers.Builder, addressOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, addressOffset, 0); +} + +static addPortOut(builder:flatbuffers.Builder, portOut:number) { + builder.addFieldInt16(2, portOut, 0); +} + +static endVRCOSCDiscoveredTarget(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCOSCDiscoveredTarget(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset, addressOffset:flatbuffers.Offset, portOut:number):flatbuffers.Offset { + VRCOSCDiscoveredTarget.startVRCOSCDiscoveredTarget(builder); + VRCOSCDiscoveredTarget.addName(builder, nameOffset); + VRCOSCDiscoveredTarget.addAddress(builder, addressOffset); + VRCOSCDiscoveredTarget.addPortOut(builder, portOut); + return VRCOSCDiscoveredTarget.endVRCOSCDiscoveredTarget(builder); +} + +unpack(): VRCOSCDiscoveredTargetT { + return new VRCOSCDiscoveredTargetT( + this.name(), + this.address(), + this.portOut() + ); +} + + +unpackTo(_o: VRCOSCDiscoveredTargetT): void { + _o.name = this.name(); + _o.address = this.address(); + _o.portOut = this.portOut(); +} +} + +export class VRCOSCDiscoveredTargetT implements flatbuffers.IGeneratedObject { +constructor( + public name: string|Uint8Array|null = null, + public address: string|Uint8Array|null = null, + public portOut: number = 0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const name = (this.name !== null ? builder.createString(this.name!) : 0); + const address = (this.address !== null ? builder.createString(this.address!) : 0); + + return VRCOSCDiscoveredTarget.createVRCOSCDiscoveredTarget(builder, + name, + address, + this.portOut + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscinput-state.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscinput-state.ts new file mode 100644 index 000000000..1221cbc67 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscinput-state.ts @@ -0,0 +1,7 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum VRCOSCInputState { + IDLE = 0, + LISTENING = 1, + ERROR = 2 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscnetwork-settings.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscnetwork-settings.ts new file mode 100644 index 000000000..2625f54e4 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscnetwork-settings.ts @@ -0,0 +1,104 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRCOSCNetworkSettings implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCNetworkSettings { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCNetworkSettings(bb:flatbuffers.ByteBuffer, obj?:VRCOSCNetworkSettings):VRCOSCNetworkSettings { + return (obj || new VRCOSCNetworkSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCNetworkSettings(bb:flatbuffers.ByteBuffer, obj?:VRCOSCNetworkSettings):VRCOSCNetworkSettings { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCNetworkSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +portIn():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +portOut():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +address():string|null +address(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +address(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startVRCOSCNetworkSettings(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addPortIn(builder:flatbuffers.Builder, portIn:number) { + builder.addFieldInt16(0, portIn, 0); +} + +static addPortOut(builder:flatbuffers.Builder, portOut:number) { + builder.addFieldInt16(1, portOut, 0); +} + +static addAddress(builder:flatbuffers.Builder, addressOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, addressOffset, 0); +} + +static endVRCOSCNetworkSettings(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCOSCNetworkSettings(builder:flatbuffers.Builder, portIn:number, portOut:number, addressOffset:flatbuffers.Offset):flatbuffers.Offset { + VRCOSCNetworkSettings.startVRCOSCNetworkSettings(builder); + VRCOSCNetworkSettings.addPortIn(builder, portIn); + VRCOSCNetworkSettings.addPortOut(builder, portOut); + VRCOSCNetworkSettings.addAddress(builder, addressOffset); + return VRCOSCNetworkSettings.endVRCOSCNetworkSettings(builder); +} + +unpack(): VRCOSCNetworkSettingsT { + return new VRCOSCNetworkSettingsT( + this.portIn(), + this.portOut(), + this.address() + ); +} + + +unpackTo(_o: VRCOSCNetworkSettingsT): void { + _o.portIn = this.portIn(); + _o.portOut = this.portOut(); + _o.address = this.address(); +} +} + +export class VRCOSCNetworkSettingsT implements flatbuffers.IGeneratedObject { +constructor( + public portIn: number = 0, + public portOut: number = 0, + public address: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const address = (this.address !== null ? builder.createString(this.address!) : 0); + + return VRCOSCNetworkSettings.createVRCOSCNetworkSettings(builder, + this.portIn, + this.portOut, + address + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscosc-query-state.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscosc-query-state.ts new file mode 100644 index 000000000..018bf4f86 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscosc-query-state.ts @@ -0,0 +1,8 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum VRCOSCOscQueryState { + DISABLED = 0, + SEARCHING = 1, + FOUND = 2, + ERROR = 3 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscoutput-state.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscoutput-state.ts new file mode 100644 index 000000000..40b9d63ad --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscoutput-state.ts @@ -0,0 +1,7 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum VRCOSCOutputState { + IDLE = 0, + READY = 1, + ERROR = 2 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-request.ts new file mode 100644 index 000000000..aefb987c0 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRCOSCSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettingsRequest):VRCOSCSettingsRequest { + return (obj || new VRCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettingsRequest):VRCOSCSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startVRCOSCSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endVRCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCOSCSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + VRCOSCSettingsRequest.startVRCOSCSettingsRequest(builder); + return VRCOSCSettingsRequest.endVRCOSCSettingsRequest(builder); +} + +unpack(): VRCOSCSettingsRequestT { + return new VRCOSCSettingsRequestT(); +} + + +unpackTo(_o: VRCOSCSettingsRequestT): void {} +} + +export class VRCOSCSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return VRCOSCSettingsRequest.createVRCOSCSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-response.ts new file mode 100644 index 000000000..b18cf4c51 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings-response.ts @@ -0,0 +1,84 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { VRCOSCNetworkSettings, VRCOSCNetworkSettingsT } from '../../solarxr-protocol/rpc/vrcoscnetwork-settings.js'; + + +export class VRCOSCSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettingsResponse):VRCOSCSettingsResponse { + return (obj || new VRCOSCSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettingsResponse):VRCOSCSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +manualNetwork(obj?:VRCOSCNetworkSettings):VRCOSCNetworkSettings|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new VRCOSCNetworkSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +static startVRCOSCSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addManualNetwork(builder:flatbuffers.Builder, manualNetworkOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, manualNetworkOffset, 0); +} + +static endVRCOSCSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): VRCOSCSettingsResponseT { + return new VRCOSCSettingsResponseT( + this.enabled(), + (this.manualNetwork() !== null ? this.manualNetwork()!.unpack() : null) + ); +} + + +unpackTo(_o: VRCOSCSettingsResponseT): void { + _o.enabled = this.enabled(); + _o.manualNetwork = (this.manualNetwork() !== null ? this.manualNetwork()!.unpack() : null); +} +} + +export class VRCOSCSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public manualNetwork: VRCOSCNetworkSettingsT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const manualNetwork = (this.manualNetwork !== null ? this.manualNetwork!.pack(builder) : 0); + + VRCOSCSettingsResponse.startVRCOSCSettingsResponse(builder); + VRCOSCSettingsResponse.addEnabled(builder, this.enabled); + VRCOSCSettingsResponse.addManualNetwork(builder, manualNetwork); + + return VRCOSCSettingsResponse.endVRCOSCSettingsResponse(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings.ts deleted file mode 100644 index 3342da901..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscsettings.ts +++ /dev/null @@ -1,102 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - -import { OSCSettings, OSCSettingsT } from '../../solarxr-protocol/rpc/oscsettings.js'; -import { OSCTrackersSetting, OSCTrackersSettingT } from '../../solarxr-protocol/rpc/osctrackers-setting.js'; - - -/** - * OSC Settings specific to VRChat - */ -export class VRCOSCSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsVRCOSCSettings(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettings):VRCOSCSettings { - return (obj || new VRCOSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsVRCOSCSettings(bb:flatbuffers.ByteBuffer, obj?:VRCOSCSettings):VRCOSCSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new VRCOSCSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -oscSettings(obj?:OSCSettings):OSCSettings|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new OSCSettings()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -trackers(obj?:OSCTrackersSetting):OSCTrackersSetting|null { - const offset = this.bb!.__offset(this.bb_pos, 6); - return offset ? (obj || new OSCTrackersSetting()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; -} - -oscqueryEnabled():boolean { - const offset = this.bb!.__offset(this.bb_pos, 8); - return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; -} - -static startVRCOSCSettings(builder:flatbuffers.Builder) { - builder.startObject(3); -} - -static addOscSettings(builder:flatbuffers.Builder, oscSettingsOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, oscSettingsOffset, 0); -} - -static addTrackers(builder:flatbuffers.Builder, trackersOffset:flatbuffers.Offset) { - builder.addFieldOffset(1, trackersOffset, 0); -} - -static addOscqueryEnabled(builder:flatbuffers.Builder, oscqueryEnabled:boolean) { - builder.addFieldInt8(2, +oscqueryEnabled, +false); -} - -static endVRCOSCSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - - -unpack(): VRCOSCSettingsT { - return new VRCOSCSettingsT( - (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null), - (this.trackers() !== null ? this.trackers()!.unpack() : null), - this.oscqueryEnabled() - ); -} - - -unpackTo(_o: VRCOSCSettingsT): void { - _o.oscSettings = (this.oscSettings() !== null ? this.oscSettings()!.unpack() : null); - _o.trackers = (this.trackers() !== null ? this.trackers()!.unpack() : null); - _o.oscqueryEnabled = this.oscqueryEnabled(); -} -} - -export class VRCOSCSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public oscSettings: OSCSettingsT|null = null, - public trackers: OSCTrackersSettingT|null = null, - public oscqueryEnabled: boolean = false -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const oscSettings = (this.oscSettings !== null ? this.oscSettings!.pack(builder) : 0); - const trackers = (this.trackers !== null ? this.trackers!.pack(builder) : 0); - - VRCOSCSettings.startVRCOSCSettings(builder); - VRCOSCSettings.addOscSettings(builder, oscSettings); - VRCOSCSettings.addTrackers(builder, trackers); - VRCOSCSettings.addOscqueryEnabled(builder, this.oscqueryEnabled); - - return VRCOSCSettings.endVRCOSCSettings(builder); -} -} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-change-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-change-response.ts new file mode 100644 index 000000000..5d8aa65f4 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-change-response.ts @@ -0,0 +1,309 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { VRCOSCDiscoveredTarget, VRCOSCDiscoveredTargetT } from '../../solarxr-protocol/rpc/vrcoscdiscovered-target.js'; +import { VRCOSCInputState } from '../../solarxr-protocol/rpc/vrcoscinput-state.js'; +import { VRCOSCOscQueryState } from '../../solarxr-protocol/rpc/vrcoscosc-query-state.js'; +import { VRCOSCOutputState } from '../../solarxr-protocol/rpc/vrcoscoutput-state.js'; +import { VRCOSCTargetSource } from '../../solarxr-protocol/rpc/vrcosctarget-source.js'; + + +export class VRCOSCStatusChangeResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCStatusChangeResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCStatusChangeResponse(bb:flatbuffers.ByteBuffer, obj?:VRCOSCStatusChangeResponse):VRCOSCStatusChangeResponse { + return (obj || new VRCOSCStatusChangeResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCStatusChangeResponse(bb:flatbuffers.ByteBuffer, obj?:VRCOSCStatusChangeResponse):VRCOSCStatusChangeResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCStatusChangeResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +inputState():VRCOSCInputState { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : VRCOSCInputState.IDLE; +} + +inputPort():number|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; +} + +inputError():string|null +inputError(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +inputError(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +lastReceivedInputMillis():bigint|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : null; +} + +outputState():VRCOSCOutputState { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : VRCOSCOutputState.IDLE; +} + +outputError():string|null +outputError(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +outputError(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +targetAddress():string|null +targetAddress(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +targetAddress(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +targetPort():number|null { + const offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; +} + +targetSource():VRCOSCTargetSource { + const offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : VRCOSCTargetSource.NONE; +} + +lastFrameSentMillis():bigint|null { + const offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : null; +} + +oscqueryState():VRCOSCOscQueryState { + const offset = this.bb!.__offset(this.bb_pos, 26); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : VRCOSCOscQueryState.DISABLED; +} + +oscqueryAdvertisedPort():number|null { + const offset = this.bb!.__offset(this.bb_pos, 28); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; +} + +oscqueryError():string|null +oscqueryError(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +oscqueryError(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 30); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +discoveredTargets(index: number, obj?:VRCOSCDiscoveredTarget):VRCOSCDiscoveredTarget|null { + const offset = this.bb!.__offset(this.bb_pos, 32); + return offset ? (obj || new VRCOSCDiscoveredTarget()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +discoveredTargetsLength():number { + const offset = this.bb!.__offset(this.bb_pos, 32); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startVRCOSCStatusChangeResponse(builder:flatbuffers.Builder) { + builder.startObject(15); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(0, +enabled, +false); +} + +static addInputState(builder:flatbuffers.Builder, inputState:VRCOSCInputState) { + builder.addFieldInt8(1, inputState, VRCOSCInputState.IDLE); +} + +static addInputPort(builder:flatbuffers.Builder, inputPort:number) { + builder.addFieldInt16(2, inputPort, 0); +} + +static addInputError(builder:flatbuffers.Builder, inputErrorOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, inputErrorOffset, 0); +} + +static addLastReceivedInputMillis(builder:flatbuffers.Builder, lastReceivedInputMillis:bigint) { + builder.addFieldInt64(4, lastReceivedInputMillis, BigInt(0)); +} + +static addOutputState(builder:flatbuffers.Builder, outputState:VRCOSCOutputState) { + builder.addFieldInt8(5, outputState, VRCOSCOutputState.IDLE); +} + +static addOutputError(builder:flatbuffers.Builder, outputErrorOffset:flatbuffers.Offset) { + builder.addFieldOffset(6, outputErrorOffset, 0); +} + +static addTargetAddress(builder:flatbuffers.Builder, targetAddressOffset:flatbuffers.Offset) { + builder.addFieldOffset(7, targetAddressOffset, 0); +} + +static addTargetPort(builder:flatbuffers.Builder, targetPort:number) { + builder.addFieldInt16(8, targetPort, 0); +} + +static addTargetSource(builder:flatbuffers.Builder, targetSource:VRCOSCTargetSource) { + builder.addFieldInt8(9, targetSource, VRCOSCTargetSource.NONE); +} + +static addLastFrameSentMillis(builder:flatbuffers.Builder, lastFrameSentMillis:bigint) { + builder.addFieldInt64(10, lastFrameSentMillis, BigInt(0)); +} + +static addOscqueryState(builder:flatbuffers.Builder, oscqueryState:VRCOSCOscQueryState) { + builder.addFieldInt8(11, oscqueryState, VRCOSCOscQueryState.DISABLED); +} + +static addOscqueryAdvertisedPort(builder:flatbuffers.Builder, oscqueryAdvertisedPort:number) { + builder.addFieldInt16(12, oscqueryAdvertisedPort, 0); +} + +static addOscqueryError(builder:flatbuffers.Builder, oscqueryErrorOffset:flatbuffers.Offset) { + builder.addFieldOffset(13, oscqueryErrorOffset, 0); +} + +static addDiscoveredTargets(builder:flatbuffers.Builder, discoveredTargetsOffset:flatbuffers.Offset) { + builder.addFieldOffset(14, discoveredTargetsOffset, 0); +} + +static createDiscoveredTargetsVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startDiscoveredTargetsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endVRCOSCStatusChangeResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCOSCStatusChangeResponse(builder:flatbuffers.Builder, enabled:boolean, inputState:VRCOSCInputState, inputPort:number|null, inputErrorOffset:flatbuffers.Offset, lastReceivedInputMillis:bigint|null, outputState:VRCOSCOutputState, outputErrorOffset:flatbuffers.Offset, targetAddressOffset:flatbuffers.Offset, targetPort:number|null, targetSource:VRCOSCTargetSource, lastFrameSentMillis:bigint|null, oscqueryState:VRCOSCOscQueryState, oscqueryAdvertisedPort:number|null, oscqueryErrorOffset:flatbuffers.Offset, discoveredTargetsOffset:flatbuffers.Offset):flatbuffers.Offset { + VRCOSCStatusChangeResponse.startVRCOSCStatusChangeResponse(builder); + VRCOSCStatusChangeResponse.addEnabled(builder, enabled); + VRCOSCStatusChangeResponse.addInputState(builder, inputState); + if (inputPort !== null) + VRCOSCStatusChangeResponse.addInputPort(builder, inputPort); + VRCOSCStatusChangeResponse.addInputError(builder, inputErrorOffset); + if (lastReceivedInputMillis !== null) + VRCOSCStatusChangeResponse.addLastReceivedInputMillis(builder, lastReceivedInputMillis); + VRCOSCStatusChangeResponse.addOutputState(builder, outputState); + VRCOSCStatusChangeResponse.addOutputError(builder, outputErrorOffset); + VRCOSCStatusChangeResponse.addTargetAddress(builder, targetAddressOffset); + if (targetPort !== null) + VRCOSCStatusChangeResponse.addTargetPort(builder, targetPort); + VRCOSCStatusChangeResponse.addTargetSource(builder, targetSource); + if (lastFrameSentMillis !== null) + VRCOSCStatusChangeResponse.addLastFrameSentMillis(builder, lastFrameSentMillis); + VRCOSCStatusChangeResponse.addOscqueryState(builder, oscqueryState); + if (oscqueryAdvertisedPort !== null) + VRCOSCStatusChangeResponse.addOscqueryAdvertisedPort(builder, oscqueryAdvertisedPort); + VRCOSCStatusChangeResponse.addOscqueryError(builder, oscqueryErrorOffset); + VRCOSCStatusChangeResponse.addDiscoveredTargets(builder, discoveredTargetsOffset); + return VRCOSCStatusChangeResponse.endVRCOSCStatusChangeResponse(builder); +} + +unpack(): VRCOSCStatusChangeResponseT { + return new VRCOSCStatusChangeResponseT( + this.enabled(), + this.inputState(), + this.inputPort(), + this.inputError(), + this.lastReceivedInputMillis(), + this.outputState(), + this.outputError(), + this.targetAddress(), + this.targetPort(), + this.targetSource(), + this.lastFrameSentMillis(), + this.oscqueryState(), + this.oscqueryAdvertisedPort(), + this.oscqueryError(), + this.bb!.createObjList(this.discoveredTargets.bind(this), this.discoveredTargetsLength()) + ); +} + + +unpackTo(_o: VRCOSCStatusChangeResponseT): void { + _o.enabled = this.enabled(); + _o.inputState = this.inputState(); + _o.inputPort = this.inputPort(); + _o.inputError = this.inputError(); + _o.lastReceivedInputMillis = this.lastReceivedInputMillis(); + _o.outputState = this.outputState(); + _o.outputError = this.outputError(); + _o.targetAddress = this.targetAddress(); + _o.targetPort = this.targetPort(); + _o.targetSource = this.targetSource(); + _o.lastFrameSentMillis = this.lastFrameSentMillis(); + _o.oscqueryState = this.oscqueryState(); + _o.oscqueryAdvertisedPort = this.oscqueryAdvertisedPort(); + _o.oscqueryError = this.oscqueryError(); + _o.discoveredTargets = this.bb!.createObjList(this.discoveredTargets.bind(this), this.discoveredTargetsLength()); +} +} + +export class VRCOSCStatusChangeResponseT implements flatbuffers.IGeneratedObject { +constructor( + public enabled: boolean = false, + public inputState: VRCOSCInputState = VRCOSCInputState.IDLE, + public inputPort: number|null = null, + public inputError: string|Uint8Array|null = null, + public lastReceivedInputMillis: bigint|null = null, + public outputState: VRCOSCOutputState = VRCOSCOutputState.IDLE, + public outputError: string|Uint8Array|null = null, + public targetAddress: string|Uint8Array|null = null, + public targetPort: number|null = null, + public targetSource: VRCOSCTargetSource = VRCOSCTargetSource.NONE, + public lastFrameSentMillis: bigint|null = null, + public oscqueryState: VRCOSCOscQueryState = VRCOSCOscQueryState.DISABLED, + public oscqueryAdvertisedPort: number|null = null, + public oscqueryError: string|Uint8Array|null = null, + public discoveredTargets: (VRCOSCDiscoveredTargetT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const inputError = (this.inputError !== null ? builder.createString(this.inputError!) : 0); + const outputError = (this.outputError !== null ? builder.createString(this.outputError!) : 0); + const targetAddress = (this.targetAddress !== null ? builder.createString(this.targetAddress!) : 0); + const oscqueryError = (this.oscqueryError !== null ? builder.createString(this.oscqueryError!) : 0); + const discoveredTargets = VRCOSCStatusChangeResponse.createDiscoveredTargetsVector(builder, builder.createObjectOffsetList(this.discoveredTargets)); + + return VRCOSCStatusChangeResponse.createVRCOSCStatusChangeResponse(builder, + this.enabled, + this.inputState, + this.inputPort, + inputError, + this.lastReceivedInputMillis, + this.outputState, + outputError, + targetAddress, + this.targetPort, + this.targetSource, + this.lastFrameSentMillis, + this.oscqueryState, + this.oscqueryAdvertisedPort, + oscqueryError, + discoveredTargets + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-request.ts new file mode 100644 index 000000000..2dc6a360c --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcoscstatus-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRCOSCStatusRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCOSCStatusRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCOSCStatusRequest(bb:flatbuffers.ByteBuffer, obj?:VRCOSCStatusRequest):VRCOSCStatusRequest { + return (obj || new VRCOSCStatusRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCOSCStatusRequest(bb:flatbuffers.ByteBuffer, obj?:VRCOSCStatusRequest):VRCOSCStatusRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCOSCStatusRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startVRCOSCStatusRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endVRCOSCStatusRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCOSCStatusRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + VRCOSCStatusRequest.startVRCOSCStatusRequest(builder); + return VRCOSCStatusRequest.endVRCOSCStatusRequest(builder); +} + +unpack(): VRCOSCStatusRequestT { + return new VRCOSCStatusRequestT(); +} + + +unpackTo(_o: VRCOSCStatusRequestT): void {} +} + +export class VRCOSCStatusRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return VRCOSCStatusRequest.createVRCOSCStatusRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcosctarget-source.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcosctarget-source.ts new file mode 100644 index 000000000..b4c994b02 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcosctarget-source.ts @@ -0,0 +1,7 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum VRCOSCTargetSource { + NONE = 0, + MANUAL = 1, + DISCOVERED = 2 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-request.ts new file mode 100644 index 000000000..2fc41fde5 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRMSettingsRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRMSettingsRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRMSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VRMSettingsRequest):VRMSettingsRequest { + return (obj || new VRMSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRMSettingsRequest(bb:flatbuffers.ByteBuffer, obj?:VRMSettingsRequest):VRMSettingsRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRMSettingsRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startVRMSettingsRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endVRMSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRMSettingsRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + VRMSettingsRequest.startVRMSettingsRequest(builder); + return VRMSettingsRequest.endVRMSettingsRequest(builder); +} + +unpack(): VRMSettingsRequestT { + return new VRMSettingsRequestT(); +} + + +unpackTo(_o: VRMSettingsRequestT): void {} +} + +export class VRMSettingsRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return VRMSettingsRequest.createVRMSettingsRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-response.ts new file mode 100644 index 000000000..0d7cc0ea7 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings-response.ts @@ -0,0 +1,76 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRMSettingsResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRMSettingsResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRMSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VRMSettingsResponse):VRMSettingsResponse { + return (obj || new VRMSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRMSettingsResponse(bb:flatbuffers.ByteBuffer, obj?:VRMSettingsResponse):VRMSettingsResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRMSettingsResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +vrmJson():string|null +vrmJson(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +vrmJson(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startVRMSettingsResponse(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addVrmJson(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, vrmJsonOffset, 0); +} + +static endVRMSettingsResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRMSettingsResponse(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset):flatbuffers.Offset { + VRMSettingsResponse.startVRMSettingsResponse(builder); + VRMSettingsResponse.addVrmJson(builder, vrmJsonOffset); + return VRMSettingsResponse.endVRMSettingsResponse(builder); +} + +unpack(): VRMSettingsResponseT { + return new VRMSettingsResponseT( + this.vrmJson() + ); +} + + +unpackTo(_o: VRMSettingsResponseT): void { + _o.vrmJson = this.vrmJson(); +} +} + +export class VRMSettingsResponseT implements flatbuffers.IGeneratedObject { +constructor( + public vrmJson: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const vrmJson = (this.vrmJson !== null ? builder.createString(this.vrmJson!) : 0); + + return VRMSettingsResponse.createVRMSettingsResponse(builder, + vrmJson + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings.ts deleted file mode 100644 index 3ebb681aa..000000000 --- a/protocol/typescript/src/solarxr-protocol/rpc/vrmsettings.ts +++ /dev/null @@ -1,79 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -import * as flatbuffers from 'flatbuffers'; - - - -/** - * VRM Settings for rescaling to avatar-scale - */ -export class VRMSettings implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):VRMSettings { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsVRMSettings(bb:flatbuffers.ByteBuffer, obj?:VRMSettings):VRMSettings { - return (obj || new VRMSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsVRMSettings(bb:flatbuffers.ByteBuffer, obj?:VRMSettings):VRMSettings { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new VRMSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -vrmJson():string|null -vrmJson(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null -vrmJson(optionalEncoding?:any):string|Uint8Array|null { - const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; -} - -static startVRMSettings(builder:flatbuffers.Builder) { - builder.startObject(1); -} - -static addVrmJson(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset) { - builder.addFieldOffset(0, vrmJsonOffset, 0); -} - -static endVRMSettings(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createVRMSettings(builder:flatbuffers.Builder, vrmJsonOffset:flatbuffers.Offset):flatbuffers.Offset { - VRMSettings.startVRMSettings(builder); - VRMSettings.addVrmJson(builder, vrmJsonOffset); - return VRMSettings.endVRMSettings(builder); -} - -unpack(): VRMSettingsT { - return new VRMSettingsT( - this.vrmJson() - ); -} - - -unpackTo(_o: VRMSettingsT): void { - _o.vrmJson = this.vrmJson(); -} -} - -export class VRMSettingsT implements flatbuffers.IGeneratedObject { -constructor( - public vrmJson: string|Uint8Array|null = null -){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const vrmJson = (this.vrmJson !== null ? builder.createString(this.vrmJson!) : 0); - - return VRMSettings.createVRMSettings(builder, - vrmJson - ); -} -} diff --git a/schema/all.fbs b/schema/all.fbs index 3f8dd8f20..d53c9fedc 100644 --- a/schema/all.fbs +++ b/schema/all.fbs @@ -1,8 +1,7 @@ // Pass only this file to flatc, it will include the rest. include "data_feed/data_feed.fbs"; -include "rpc.fbs"; -include "pub_sub/pub_sub.fbs"; +include "rpc/rpc.fbs"; namespace solarxr_protocol; @@ -19,11 +18,6 @@ namespace solarxr_protocol; // to wrap any scalar or list types in those unions in structs, because unions // only support tables, structs, or strings. Luckily, this has no impact on the // size of the flatbuffer. -// -// One other convention to be aware of: If a table is only there to wrap something -// trivially (such as a union or an enum), and I couldn't think of a better name, -// I append `W` for "wrapper" to it. LMK if you thing there is a better naming -// convention. /// MessageBundle contains all of the messages for the data feed system and the @@ -34,5 +28,4 @@ namespace solarxr_protocol; table MessageBundle { data_feed_msgs: [solarxr_protocol.data_feed.DataFeedMessageHeader]; rpc_msgs: [solarxr_protocol.rpc.RpcMessageHeader]; - pub_sub_msgs: [solarxr_protocol.pub_sub.PubSubHeader]; } diff --git a/schema/data_feed/data_feed.fbs b/schema/data_feed/data_feed.fbs index 949fac49d..8df29ed28 100644 --- a/schema/data_feed/data_feed.fbs +++ b/schema/data_feed/data_feed.fbs @@ -24,7 +24,7 @@ include "datatypes/hardware_info.fbs"; include "datatypes/datatypes.fbs"; -include "tracker.fbs"; +include "tracker_data.fbs"; include "device_data.fbs"; include "bone.fbs"; include "stay_aligned.fbs"; @@ -32,7 +32,6 @@ include "server.fbs"; namespace solarxr_protocol.data_feed; - union DataFeedMessage { PollDataFeed, StartDataFeed, @@ -46,14 +45,12 @@ table DataFeedMessageHeader { message: DataFeedMessage; } - /// Requests for a single `Update` to be sent. This is helpful when getting /// initial info about the device. table PollDataFeed { config: DataFeedConfig; } - /// Requests for the other party to send `data_feeds`. /// For example, GUI requests for position data to be sent from server. /// @@ -63,11 +60,9 @@ table PollDataFeed { /// /// Multiple data feeds are useful to get data at different frequencies. table StartDataFeed { - // TODO: Should we add a feed id so we can detect if the feed was actually started? data_feeds: [DataFeedConfig]; } - /// All of the data components related to a single data feed. A data feed is comprised /// of device data, and tracker data. /// @@ -78,18 +73,15 @@ table StartDataFeed { table DataFeedUpdate { // In the future, we may add an `id` field to disambiguate different `DataFeeds` devices: [solarxr_protocol.data_feed.device_data.DeviceData]; - synthetic_trackers: [solarxr_protocol.data_feed.tracker.TrackerData]; + synthetic_trackers: [solarxr_protocol.data_feed.tracker_data.TrackerData]; /// This must represent a set, where there is no more than one bone for a `BodyPart`. bones: [solarxr_protocol.data_feed.Bone]; stay_aligned_pose: solarxr_protocol.data_feed.stay_aligned.StayAlignedPose; - - // gives the index of the datafeed config that initiated the update + /// gives the index of the datafeed config that initiated the update index: uint8; - server_guards: solarxr_protocol.data_feed.server.ServerGuards; } - /// All information related to the configuration of a data feed. This may be sent /// as part of a `StartFeed`. table DataFeedConfig { @@ -97,8 +89,8 @@ table DataFeedConfig { /// ignored when used for a `PollDataFeed`. minimum_time_since_last: uint16 = 0; data_mask: solarxr_protocol.data_feed.device_data.DeviceDataMask; - synthetic_trackers_mask: solarxr_protocol.data_feed.tracker.TrackerDataMask; - bone_mask: bool; // TODO: decide if we want to make this a vec of `BodyPart` + synthetic_trackers_mask: solarxr_protocol.data_feed.tracker_data.TrackerDataMask; + bone_mask: bool; stay_aligned_pose_mask: bool; server_guards_mask: bool; } diff --git a/schema/data_feed/device_data.fbs b/schema/data_feed/device_data.fbs index 7949272eb..09d298937 100644 --- a/schema/data_feed/device_data.fbs +++ b/schema/data_feed/device_data.fbs @@ -1,10 +1,9 @@ -include "data_feed/tracker.fbs"; +include "data_feed/tracker_data.fbs"; include "datatypes/datatypes.fbs"; include "datatypes/hardware_info.fbs"; namespace solarxr_protocol.data_feed.device_data; - /// A mask of values to be reported in subsequent DeviceStatus. Values set to `false` /// or `null` will not reported. By default, all fields are false/null. /// @@ -13,18 +12,18 @@ namespace solarxr_protocol.data_feed.device_data; /// has the choice to disconnect due to missing data. table DeviceDataMask { /// Which tracker data should be sent in this data feed - tracker_data: solarxr_protocol.data_feed.tracker.TrackerDataMask; + tracker_data: solarxr_protocol.data_feed.tracker_data.TrackerDataMask; /// true if device data should be sent in this data feed device_data: bool; } /// Describes all possible information about a hardware device. For example, a -/// vive tracker is a single hardware device, and a slime tracker with two +/// vive tracker is a single hardware device, and a slime tracker with two /// extensions is a single hardware device but two trackers. table DeviceData { // We could technically treat the ID as another component, but I feel like it // should be required to be here. - id: solarxr_protocol.datatypes.DeviceId; + id: uint16; // Everything here is optional and controlled by the device itself /// The dynamically changeable name of the device. This might be set by the @@ -37,5 +36,5 @@ table DeviceData { hardware_status: solarxr_protocol.datatypes.hardware_info.HardwareStatus; /// Info about all trackers attached to this device - trackers: [solarxr_protocol.data_feed.tracker.TrackerData]; + trackers: [solarxr_protocol.data_feed.tracker_data.TrackerData]; } diff --git a/schema/data_feed/server.fbs b/schema/data_feed/server.fbs index 1db962f1d..e106c2a36 100644 --- a/schema/data_feed/server.fbs +++ b/schema/data_feed/server.fbs @@ -1,13 +1,11 @@ namespace solarxr_protocol.data_feed.server; -// Contains various of flags / guards that inform the gui -// about possible actions or blocked states -// idea is to have one source of truth for all these rules -// that are rn spread accross the gui. We should bring those -// here over time +/// Contains various of flags / guards that inform the GUI +/// about possible actions or blocked states. +/// The idea is to have one source of truth for all these rules +/// that are spread accross the GUI. table ServerGuards { - // Tell the gui if you can do a mounting reset - canDoMounting: bool; - canDoYawReset: bool; - canDoUserHeightCalibration: bool; + can_do_mounting_reset: bool; + can_do_yaw_reset: bool; + can_do_user_height_calibration: bool; } diff --git a/schema/data_feed/tracker.fbs b/schema/data_feed/tracker_data.fbs similarity index 86% rename from schema/data_feed/tracker.fbs rename to schema/data_feed/tracker_data.fbs index a5ffd48b3..92c57a6ec 100644 --- a/schema/data_feed/tracker.fbs +++ b/schema/data_feed/tracker_data.fbs @@ -2,7 +2,7 @@ include "datatypes/math.fbs"; include "datatypes/datatypes.fbs"; include "stay_aligned.fbs"; -namespace solarxr_protocol.data_feed.tracker; +namespace solarxr_protocol.data_feed.tracker_data; /// Describes all possible information about a tracker. A tracker is anything that /// provides kinematic data about a particular body part. @@ -10,18 +10,16 @@ namespace solarxr_protocol.data_feed.tracker; /// Trackers may be synthetic/computed or instead part of an actual hardware device. /// There can be multiple trackers per hardware device. table TrackerData { - tracker_id: solarxr_protocol.datatypes.TrackerId; + device_id: uint16; + tracker_id: uint16; - info: TrackerInfo; + // Everything below is optional and controlled by `TrackerDataMask` + info: TrackerInfo; status: solarxr_protocol.datatypes.TrackerStatus; - - // Everything here is optional and controlled by `TrackerDataMask` - /// Sensor rotation after fusion rotation: solarxr_protocol.datatypes.math.Quat; - /// Position, in meters - // TODO: With respect to what space? + /// Position in meters in OpenVR's space (left-handed, X+ Right, Y+ Up, Z- Forward) position: solarxr_protocol.datatypes.math.Vec3f; /// Raw angular velocity, in euler angles, rad/s raw_angular_velocity: solarxr_protocol.datatypes.math.Vec3f; @@ -31,28 +29,24 @@ table TrackerData { temp: solarxr_protocol.datatypes.Temperature; /// Acceleration without gravity, in m/s^2 linear_acceleration: solarxr_protocol.datatypes.math.Vec3f; - /// Reference-adjusted rotation for IMU-only trackers (VR HMD yaw is used as a reset reference). - /// In other words, a rotation that is aligned to a reliable source of rotation ((0, VR HMD YAW, 0)), + /// In other words, a rotation that is aligned to a reliable source of rotation (0, HMD YAW, 0), /// triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: mounting orientation, full, quick and mounting reset adjustments. /// This rotation can be used to reconstruct a skeleton pose using forward kinematics. rotation_reference_adjusted: solarxr_protocol.datatypes.math.Quat; /// Zero-reference-adjusted rotation for IMU-only trackers (identity quaternion is used as a reset reference). - /// In other words, a rotation that is aligned to a zero vector ((0, 0, 0)) by + /// In other words, a rotation that is aligned to a zero vector (0, 0, 0) by /// inverting the current rotation, triggered after user input (using reset buttons). /// This is a SlimeVR-specific field and computed exclusively by SlimeVR server. /// Includes: only full and quick reset adjustments. /// This rotation can be used in visualizations for IMU debugging. rotation_identity_adjusted: solarxr_protocol.datatypes.math.Quat; - /// Data ticks per second, processed by SlimeVR server tps: uint16 = null; - /// Magnetic field vector, in mGauss raw_magnetic_vector: solarxr_protocol.datatypes.math.Vec3f; - /// Stay Aligned stay_aligned: solarxr_protocol.data_feed.stay_aligned.StayAlignedTracker; } @@ -79,39 +73,27 @@ table TrackerInfo { imu_type: solarxr_protocol.datatypes.hardware_info.ImuType; /// The user-assigned role of the tracker. body_part: solarxr_protocol.datatypes.BodyPart; - /// average samples per second + /// Average samples per second poll_rate: solarxr_protocol.datatypes.HzF32; /// The orientation of the tracker when mounted on the body mounting_orientation: solarxr_protocol.datatypes.math.Quat; - /// Should the tracker's settings be editable by the user editable: bool; - /// Indicates if the tracker is computed (solved position and rotation) is_computed: bool; - /// Indicates if the tracker is using an IMU for its tracking data is_imu: bool; - /// A human-friendly name to display as the name of the tracker. display_name: string; - /// name to display as the name of the tracker set by the user custom_name: string; - - /// Whether to allow yaw drift compensation for this tracker or not. - allow_drift_compensation: bool; - /// Mounting Reset orientation overrides the current `mounting_orientation` of /// the tracker, this orientation is not saved and needs to be calculated /// each time the server is ran mounting_reset_orientation: solarxr_protocol.datatypes.math.Quat; - - /// Indicates if the tracker is actually an HMD + /// Indicates if the tracker is actually a VR headset is_hmd: bool; - magnetometer: solarxr_protocol.datatypes.MagnetometerStatus; - - /// Indicates what type of data the tracker sends (note: it always ends up being rotation in the end) + /// Indicates what type of data the tracker sends (that gets transformed into a rotation) data_support: solarxr_protocol.datatypes.hardware_info.TrackerDataType; } diff --git a/schema/datatypes/datatypes.fbs b/schema/datatypes/datatypes.fbs index bb3886122..d3f3a8576 100644 --- a/schema/datatypes/datatypes.fbs +++ b/schema/datatypes/datatypes.fbs @@ -1,53 +1,24 @@ -namespace solarxr_protocol.datatypes; - -// /// Trivially wraps a string, for use in a union -// struct StringW { -// s: string -// } +/// This file contains datatypes that are shared across several places in SolarXR +/// If a datatype is only used in one place, it should be placed there. +namespace solarxr_protocol.datatypes; /// Frequency as 32 bit float struct HzF32 { f: float32; } - struct TransactionId { /// This is expected to overflow, networking logic should handle this case. id: uint32; } - -/// A unique ID for the device. IDs are not guaranteed to be the same after -/// the connection is terminated. -struct DeviceId { - id: uint8; -} - -/// To be used inside unions -table DeviceIdTable { - id: DeviceId; -} - - -// TODO: Should this be a struct? -// TODO: Should we disassociate trackers from their devices and just have `tracker_num`? -table TrackerId { - /// The device the tracker is associated with. If there is no hardware device it is - /// associated with, this should be `null`. - device_id: solarxr_protocol.datatypes.DeviceId; - /// There are possibly multiple trackers per device. This identifies which one. - tracker_num: uint8; -} - - /// General purpose logging datatype table LogData { message: string; data: [uint8]; } - /// A list of error codes for error conditions on the device enum FirmwareErrorCode: uint8 { Other = 0, @@ -56,15 +27,6 @@ enum FirmwareErrorCode: uint8 { ImuError, } - -/// Used for filtering tracker rotations in software -enum FilteringType: uint8 { - NONE = 0, - SMOOTHING = 1, - PREDICTION = 2 -} - - /// Possible tracker roles /// They're not perfect match for SteamVR tracker roles, /// because we support more possible roles. Host can @@ -94,7 +56,6 @@ enum TrackerRole: uint8 { GENERIC_CONTROLLER = 21, } - /// Different parts of the body. Maps to each possible non-tracker bone in the skeleton. /// These are *NOT* the trackers. enum BodyPart: uint8 { @@ -174,14 +135,6 @@ struct Ipv4Address { addr: uint32; } -table Bytes { - b: [uint8]; -} - -table StringTable { - s: string; -} - enum MagnetometerStatus: uint8 { NOT_SUPPORTED = 0, DISABLED = 1, diff --git a/schema/datatypes/hardware_info.fbs b/schema/datatypes/hardware_info.fbs index 9efc21cfb..7e02bbb75 100644 --- a/schema/datatypes/hardware_info.fbs +++ b/schema/datatypes/hardware_info.fbs @@ -2,11 +2,8 @@ include "datatypes.fbs"; namespace solarxr_protocol.datatypes.hardware_info; -// Note: Currently firmware only reports ESP8266 or if the device uses ESP-IDF, so -// the hardware protocol will have no way of differentiating between ESP32 and other -// variants. This should be considered a "firmware bug", do not rely on this behavior. enum McuType: uint16 { - Other = 0, + UNKNOWN = 0, ESP8266, ESP32, OWOTRACK_ANDROID, @@ -21,7 +18,7 @@ enum McuType: uint16 { } enum ImuType: uint16 { - Other = 0, + UNKNOWN = 0, MPU9250, MPU6500, BNO080, @@ -75,7 +72,7 @@ enum BoardType: uint16 { DEV_RESERVED = 250, } -/// What kind of data the tracker supports.The received data gets computed into a Quaternion rotation in any case. +/// What kind of data the tracker supports. The received data gets transformed into a Quaternion rotation in any case. enum TrackerDataType: uint8 { /// Rotation (e.g: IMUs or computed rotations in firmware) ROTATION = 0, @@ -89,15 +86,13 @@ enum TrackerDataType: uint8 { /// associated with the endpoint that we are communicating with. If it doesn't take /// up the full set of bytes, it is aligned towards the least significant bits. struct HardwareAddress { - // Fixed size arrays not supported, so we use a uint64 (8 bytes), but the mac addr - // is actually 6 bytes. + // Fixed size arrays not supported, so we use a uint64 (8 bytes), but the mac addr is actually 6 bytes. addr: uint64; } /// Mostly static info about the device's hardware/firmware. table HardwareInfo { mcu_id: McuType; - /// A human-friendly name to display as the name of the device. display_name: string; /// A human-friendly string for the device model. @@ -106,35 +101,26 @@ table HardwareInfo { manufacturer: string; /// The hardware version of the device. For example, pcb version. hardware_revision: string; - /// The version of the slimevr firmware that the device is running. firmware_version: string; hardware_address: HardwareAddress; - ip_address: solarxr_protocol.datatypes.Ipv4Address; - /// A board type string that can be used to name a board. if possible you should use official board type board_type: string; - /// An enum listing all the board types supported by the firmware official_board_type: BoardType; - /// A unique identifier for the device. Depending on the type of device it can be the MAC address, /// the IP address, or some other unique identifier like what USB device it is. hardware_identifier: string; - /// The version of the protocol it's using to communicate with server network_protocol_version: uint16 = null; - /// The build date of the slimevr firmware that the device is running. YYYY-MM-DD firmware_date: string; } - /// Mostly-dynamic status info about a tracked device's firmware table HardwareStatus { error_status: solarxr_protocol.datatypes.FirmwareErrorCode = null; - tps: uint8 = null (deprecated); ping: uint16 = null; /// "Received Signal Strength Indicator" between device and wifi adapter in dBm rssi: int16 = null; @@ -143,7 +129,6 @@ table HardwareStatus { battery_voltage: float32 = null; battery_pct_estimate: uint8 = null; log_data: solarxr_protocol.datatypes.LogData; - packet_loss: float32 = null; packets_lost: int32 = null; packets_received: int32 = null; diff --git a/schema/datatypes/math.fbs b/schema/datatypes/math.fbs index 795efd5db..b8c3dfa1a 100644 --- a/schema/datatypes/math.fbs +++ b/schema/datatypes/math.fbs @@ -1,6 +1,5 @@ namespace solarxr_protocol.datatypes.math; - struct Quat { x: float32; y: float32; @@ -8,7 +7,6 @@ struct Quat { w: float32; } - struct Vec3f { x: float32; y: float32; diff --git a/schema/pub_sub/pub_sub.fbs b/schema/pub_sub/pub_sub.fbs deleted file mode 100644 index 7edd8433a..000000000 --- a/schema/pub_sub/pub_sub.fbs +++ /dev/null @@ -1,53 +0,0 @@ -/// Pub/Sub protocol. -/// -/// This protocol provides the pub-sub messaging pattern. This pattern is better suited -/// to communication between multiple applications because apps may have various -/// versions, are non-standardized, and may or may not be present. Unlike -/// Request/Response, no transactional state is needed on the server, and the meaning -/// of payloads can be determined in a decentralized manner via the topic system. -/// -/// Solar-XR still provides provides discovery and routing of the message, but the -/// actual message payload is application specific, and Solar-XR makes few if any -/// assumptions on its meaning. -/// -/// Example use case: -/// SlimeVR overlay has a visibility toggle, and the SlimeVR gui wishes to allow users -/// to control this in its GUI. So the GUI sends a key-value pair to the "settings" -/// topic of the SlimeVR overlay. The SlimeVR server will use this topic identifier to -/// forward the message payload to any application that is subscribed to that topic. -/// The server doesn't understand the meaning of the payload - all it sees is the topic -/// id, and the key-value pairs. The state of the overlay visibility isn't even held in -/// the server at all - all of that is maintained by the vr overlay application. - -include "topic.fbs"; -include "datatypes/datatypes.fbs"; - -namespace solarxr_protocol.pub_sub; - -union PubSubUnion { - Message, - SubscriptionRequest, - TopicHandleRequest, - TopicMapping, -} - -table PubSubHeader { - u: PubSubUnion; -} - -union Payload { - solarxr_protocol.datatypes.StringTable, - solarxr_protocol.datatypes.Bytes, - KeyValues, -} - -/// Data that is sent from publishers to subscribers -table Message { - topic: Topic; - payload: Payload; -} - -table KeyValues { - keys: [string]; - values: [string]; -} diff --git a/schema/pub_sub/topic.fbs b/schema/pub_sub/topic.fbs deleted file mode 100644 index 998575fcb..000000000 --- a/schema/pub_sub/topic.fbs +++ /dev/null @@ -1,46 +0,0 @@ -namespace solarxr_protocol.pub_sub; - -/// A `TopicId` identifies an application-specific category of data. Because it -/// is application-specific, it is up to the application within the specified -/// organization to define its semantics/meaning. -/// -/// For example, "bob" may have an "overlay" app with a "settings" topic for controlling -/// the overlay visibility and other settings, as well as a "video feed" topic for -/// allowing other applications to display video data in a wrist mounted window in VR. -table TopicId { - /// The organization/developer that defines the meaning of this feature. Avoids name - /// clashes. Should be something unique - same idea as java package identifier. - organization: string; - /// The name of the application/device. Should be unique within the organization. - app_name: string; - /// The name of the topic. Should be unique within the application. - topic: string; -} - -/// A handle for the topic, allows referencing a topic without sending a huge -/// `TopicId`. -table TopicHandle { - id: uint16; -} - -union Topic { - TopicHandle, - TopicId, -} - -/// Response for `TopicHandleRequest` or `SubscriptionRequest`. -table TopicMapping { - id: TopicId; - handle: TopicHandle; -} - -/// Request to get the `FeatureHandle` from a `FeatureId`. This is useful for reducing -/// bandwidth, since `FeatureId` can be large. -table TopicHandleRequest { - id: TopicId; -} - -/// Requests a subscription to `topic`. Replies with a `TopicMapping`. -table SubscriptionRequest { - topic: Topic; -} diff --git a/schema/rpc.fbs b/schema/rpc.fbs deleted file mode 100644 index 8509ecea5..000000000 --- a/schema/rpc.fbs +++ /dev/null @@ -1,1170 +0,0 @@ -/// This file contains all messages related to the RPC system. Unlike the data feed -/// system, the RPC system is focused on providing a reliable RPC communication pattern. -/// -/// It can be used either for sending commands to mutate state, or reliably sending -/// evented updates of data that should be guaranteed to be observed, such as a user -/// initiated button push. - -include "datatypes/datatypes.fbs"; -include "settings/model.fbs"; - -namespace solarxr_protocol.rpc; - - -union RpcMessage { - HeartbeatRequest, - HeartbeatResponse, - ResetRequest, - ResetResponse, - AssignTrackerRequest, - SettingsRequest, - SettingsResponse, - ChangeSettingsRequest, - ClearDriftCompensationRequest, - RecordBVHRequest, - RecordBVHStatus, - SkeletonConfigRequest, - ChangeSkeletonConfigRequest, - SkeletonResetAllRequest, - SkeletonConfigResponse, - OpenSerialRequest, - CloseSerialRequest, - SetWifiRequest, - SerialUpdateResponse, - AutoBoneProcessRequest, - AutoBoneProcessStatusResponse, - AutoBoneEpochResponse, - OverlayDisplayModeRequest, - OverlayDisplayModeChangeRequest, - OverlayDisplayModeResponse, - SerialTrackerRebootRequest, - SerialTrackerGetInfoRequest, - SerialTrackerFactoryResetRequest, - SerialDevicesRequest, - SerialDevicesResponse, - NewSerialDeviceResponse, - StartWifiProvisioningRequest, - StopWifiProvisioningRequest, - WifiProvisioningStatusResponse, - ServerInfosRequest, - ServerInfosResponse, - LegTweaksTmpChange, - LegTweaksTmpClear, - TapDetectionSetupNotification, - SetPauseTrackingRequest, - // DEPRECATED - StatusSystemRequest, - // DEPRECATED - StatusSystemResponse, - // DEPRECATED - StatusSystemUpdate, - // DEPRECATED - StatusSystemFixed, - ClearMountingResetRequest, - // DEPRECATED - HeightRequest, - // DEPRECATED - HeightResponse, - AutoBoneApplyRequest, - AutoBoneStopRecordingRequest, - AutoBoneCancelRecordingRequest, - SaveFileNotification, - TrackingPauseStateRequest, - TrackingPauseStateResponse, - SerialTrackerGetWifiScanRequest, - UnknownDeviceHandshakeNotification, - AddUnknownDeviceRequest, - ForgetDeviceRequest, - FirmwareUpdateRequest, - FirmwareUpdateStatusResponse, - FirmwareUpdateStopQueuesRequest, - SettingsResetRequest, - MagToggleRequest, - MagToggleResponse, - ChangeMagToggleRequest, - RecordBVHStatusRequest, - VRCConfigStateRequest, - VRCConfigStateChangeResponse, - EnableStayAlignedRequest, - DetectStayAlignedRelaxedPoseRequest, - ResetStayAlignedRelaxedPoseRequest, - SerialTrackerCustomCommandRequest, - VRCConfigSettingToggleMute, - TrackingChecklistRequest, - TrackingChecklistResponse, - IgnoreTrackingChecklistStepRequest, - StartUserHeightCalibration, - CancelUserHeightCalibration, - UserHeightRecordingStatusResponse, - KeybindRequest, - ChangeKeybindRequest, - KeybindResponse, - InstalledInfoRequest, - InstalledInfoResponse, - OpenUriRequest, - OpenUriResponse, - EnableSteamVRDriverRequest, -} - -enum KeybindId: uint8 { - FULL_RESET = 0, - YAW_RESET = 1, - MOUNTING_RESET = 2, - PAUSE_TRACKING = 3, - FEET_MOUNTING_RESET = 4 -} - -table Keybind { - keybind_id: KeybindId; - keybind_name_id: string; - keybind_value: string; - keybind_delay: float; -} - -// Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui -table KeybindRequest { - keybind_id: KeybindId; -} - -// Returns keybinds for displaying in gui -table KeybindResponse { - keybind: [Keybind]; - default_keybinds: [Keybind]; -} - -table ChangeKeybindRequest { - keybind: Keybind; -} - -table OpenUriRequest { -} - -table OpenUriResponse { - success: bool; -} - - - -table RpcMessageHeader { - /// For a request, this identifies the request. For a response, this corresponds - /// to the request that it is responding to. - tx_id: solarxr_protocol.datatypes.TransactionId; - message: RpcMessage; -} - -table InstalledInfoRequest {} - -table InstalledInfoResponse { - isUdevInstalled: bool; - isWayland: bool; -} - - -table HeartbeatRequest {} - -table HeartbeatResponse {} - - -enum ResetType: uint8 { - Yaw, - Full, - /// Second pose for calibrating mounting rotation - Mounting, -} - - -enum ResetStatus: uint8 { - STARTED, - FINISHED, -} - -table ResetRequest { - reset_type: ResetType; - /// Which body parts to reset. Server handles it if empty (usually all) - body_parts: [solarxr_protocol.datatypes.BodyPart]; - delay: float = null; -} -table ResetResponse { - reset_type: ResetType; - status: ResetStatus; - - /// Should return the body parts reseted / being reset - body_parts: [solarxr_protocol.datatypes.BodyPart]; - - /// gives the time in seconds passed since the start of the reset - /// is 0 when status == FINISHED - /// starts at 0 - progress: int; - duration: int; -} - - - -table AssignTrackerRequest { - tracker_id: solarxr_protocol.datatypes.TrackerId; - body_position: solarxr_protocol.datatypes.BodyPart; - mounting_orientation: solarxr_protocol.datatypes.math.Quat; - display_name: string; - allow_drift_compensation: bool; -} - -table ClearDriftCompensationRequest {} - -// ---- Settings ---- - -table SettingsRequest {} - -table SettingsResponse { - steam_vr_trackers: SteamVRTrackersSetting; - filtering: FilteringSettings; - drift_compensation: DriftCompensationSettings; - osc_router: OSCRouterSettings; - vrc_osc: VRCOSCSettings; - vmc_osc: VMCOSCSettings; - model_settings: solarxr_protocol.rpc.settings.ModelSettings; - tap_detection_settings: TapDetectionSettings; - auto_bone_settings: AutoBoneSettings; - resets_settings: ResetsSettings; - stay_aligned: StayAlignedSettings; - hid_settings: HIDSettings; - timeout: TimeoutSettings; - velocity_settings: VelocitySettings; - vrm: VRMSettings; -} - -table ChangeSettingsRequest { - steam_vr_trackers: SteamVRTrackersSetting; - filtering: FilteringSettings; - drift_compensation: DriftCompensationSettings; - osc_router: OSCRouterSettings; - vrc_osc: VRCOSCSettings; - vmc_osc: VMCOSCSettings; - model_settings: solarxr_protocol.rpc.settings.ModelSettings; - tap_detection_settings: TapDetectionSettings; - auto_bone_settings: AutoBoneSettings; - resets_settings: ResetsSettings; - stay_aligned: StayAlignedSettings; - hid_settings: HIDSettings; - timeout: TimeoutSettings; - velocity_settings: VelocitySettings; - vrm: VRMSettings; -} - - -table SteamVRTrackersSetting { - waist: bool; - chest: bool; - /// use individual foot toggles - feet: bool (deprecated); - /// use individual knee toggles - knees: bool (deprecated); - /// use individual elbow toggles - elbows: bool (deprecated); - /// use individual hand toggles - hands: bool (deprecated); - automaticTrackerToggle: bool; - - left_foot: bool; - right_foot: bool; - - left_knee: bool; - right_knee: bool; - - left_elbow: bool; - right_elbow: bool; - - left_hand: bool; - right_hand: bool; -} - -table FilteringSettings { - type: solarxr_protocol.datatypes.FilteringType; - /// 0 to 1. A higher value results in more smoothing or prediction - amount: float32; -} - -/// Settings related to IMU yaw drift compensation -table DriftCompensationSettings { - enabled: bool; - prediction: bool; - /// 0 to 1. A higher value results in more yaw drift compensation - amount: float32; - /// Number of previous resets to take into account when calculating yaw drift - max_resets: uint16; -} - -/// OSC router forwards messages it receives, to allow the usage of multiple OSC programs for the same app. -table OSCRouterSettings { - osc_settings: OSCSettings; -} - -/// OSC Settings specific to VRChat -table VRCOSCSettings { - osc_settings: OSCSettings; - trackers: OSCTrackersSetting; - oscquery_enabled: bool; -} - -/// OSC Settings specific to VMC -table VMCOSCSettings { - osc_settings: OSCSettings; - vrm_json: string (deprecated); - anchor_hip: bool; - mirror_tracking: bool; -} - -/// VRM Settings for rescaling to avatar-scale -table VRMSettings { - vrm_json: string; -} - -/// OSC Settings that are used in *any* osc application. -table OSCSettings { - enabled: bool; - port_in: uint16; - port_out: uint16; - address: string; -} - -table OSCTrackersSetting { - head: bool; - chest: bool; - waist: bool; - knees: bool; - feet: bool; - elbows: bool; - hands: bool; -} - -table TapDetectionSettings { - full_reset_delay: float = null; - full_reset_enabled: bool = null; - full_reset_taps: uint8 = null; - yaw_reset_delay: float = null; - yaw_reset_enabled: bool = null; - yaw_reset_taps: uint8 = null; - mounting_reset_delay: float = null; - mounting_reset_enabled: bool = null; - mounting_reset_taps: uint8 = null; - /// If true, disables reset behavior of tap detection and sends a - /// TapDetectionSetupNotification, each time 2 taps are detected on any tracker - setup_mode: bool = null; - number_trackers_over_threshold: uint8 = null; - yaw_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; - full_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; - mounting_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; - -} - -enum ArmsMountingResetMode: uint8 { - /// Upper arm going back and forearm going forward - BACK, - /// Arms going forward - FORWARD, - /// Arms going up to the sides into a tpose - TPOSE_UP, - /// Arms going down to the sides from a tpose - TPOSE_DOWN -} - -table ResetsSettings { - reset_mounting_feet: bool; - arms_mounting_reset_mode: ArmsMountingResetMode; - yaw_reset_smooth_time: float32; - save_mounting_reset: bool; - reset_hmd_pitch: bool; -} - -table StayAlignedSettings { - enabled: bool; - extraYawCorrection: bool; - hideYawCorrection: bool; - standingEnabled: bool; - standingUpperLegAngle: float32; - standingLowerLegAngle: float32; - standingFootAngle: float32; - sittingEnabled: bool; - sittingUpperLegAngle: float32; - sittingLowerLegAngle: float32; - sittingFootAngle: float32; - flatEnabled: bool; - flatUpperLegAngle: float32; - flatLowerLegAngle: float32; - flatFootAngle: float32; - setupComplete: bool; -} - -table HIDSettings { - trackersOverHID: bool; -} - -table TimeoutSettings { - duration: float32; -} - -table VelocitySettings { - send_derived_velocity: bool; -} - -/// See TapDetectionSettings::setup_mode -table TapDetectionSetupNotification { - tracker_id: solarxr_protocol.datatypes.TrackerId; -} - -table RecordBVHRequest { - stop: bool; - /// Path sent when starting the recording, if null the recording won't happen. - /// Has different behavior depending if its a file path or a directory path. - path: string; -} - -table RecordBVHStatus { - recording: bool; -} - -table RecordBVHStatusRequest {} - -enum SkeletonBone: uint8 { - NONE = 0, - HEAD = 1, - NECK = 2, - CHEST = 3, - CHEST_OFFSET = 4, - WAIST = 5, - HIP = 6, - HIP_OFFSET = 7, - HIPS_WIDTH = 8, - UPPER_LEG = 9, - LOWER_LEG = 10, - FOOT_LENGTH = 11, - FOOT_SHIFT = 12, - SKELETON_OFFSET = 13, - SHOULDERS_DISTANCE = 14, - SHOULDERS_WIDTH = 15, - UPPER_ARM = 16, - LOWER_ARM = 17, - HAND_Y = 18, - HAND_Z = 19, - ELBOW_OFFSET = 20, - UPPER_CHEST = 21, -} - -table SkeletonPart { - bone: SkeletonBone; - value: float; -} - -table SkeletonConfigRequest {} -table SkeletonConfigResponse { - skeleton_parts: [SkeletonPart]; - user_height: float; -} - -table SkeletonResetAllRequest {} - -table ChangeSkeletonConfigRequest { - bone: SkeletonBone; - value: float; -} - -enum SerialDeviceType: uint8 { - ESP_TRACKER = 0, - HID_RECEIVER = 1, - HID_TRACKER = 2, -} - -table SerialDevice { - port: string; - name: string; - type: SerialDeviceType; -} - -table OpenSerialRequest { - /// Automatically pick the first serial device available - auto: bool; - port: string; -} - -table CloseSerialRequest {} -table SetWifiRequest (deprecated) { - ssid: string; - password: string; -} -table SerialUpdateResponse { - log: string; - closed: bool; - device: SerialDevice; -} - -/// Reboots the tracker connected to the serial monitor -table SerialTrackerRebootRequest {} - -/// Sends the GET INFO cmd to the current tracker on the serial monitor -table SerialTrackerGetInfoRequest {} - -/// Sends the FRST cmd to the currently connected Tracker over the Serial Monitor -table SerialTrackerFactoryResetRequest {} - -/// Sends a custom cmd to the currently connected Tracker over the Serial Monitor -table SerialTrackerCustomCommandRequest { - command: string; -} - -table SerialDevicesRequest {} - -table SerialDevicesResponse { - devices: [SerialDevice]; -} - - -table NewSerialDeviceResponse { - device: SerialDevice; -} - -table StartWifiProvisioningRequest { - ssid: string; - password: string; - port: string; -} - -table StopWifiProvisioningRequest {} - -enum WifiProvisioningStatus: uint8 { - NONE = 0, - SERIAL_INIT = 1, - PROVISIONING = 2, - CONNECTING = 3, - CONNECTION_ERROR = 4, - LOOKING_FOR_SERVER = 5, - COULD_NOT_FIND_SERVER = 6, - DONE = 7, - OBTAINING_MAC_ADDRESS = 8, - NO_SERIAL_LOGS_ERROR = 9, - NO_SERIAL_DEVICE_FOUND = 10, -} - -table WifiProvisioningStatusResponse { - status: WifiProvisioningStatus; -} - -enum AutoBoneProcessType: uint8 { - NONE = 0, - RECORD = 1, - SAVE = 2, - PROCESS = 3, - /// @deprecated - /// Use AutoBoneApplyRequest instead - APPLY = 4 (deprecated), -} - -table AutoBoneProcessRequest { - process_type: AutoBoneProcessType; -} - -table AutoBoneProcessStatusResponse { - process_type: AutoBoneProcessType; - message: string (deprecated); - /// The current count. This value is -1 if there is nothing to report. - current: uint32; - /// The total count. This value is -1 if there is nothing to report. - total: uint32; - /// True if the operation has completed with any result, successful or not. - completed: bool; - /// True if the completed operation was successful, only observe if `completed` is true. - success: bool; - /// The time remaining in seconds. This value is -1 if there is nothing to report. - eta: float32; -} - -table AutoBoneEpochResponse { - current_epoch: uint32; - total_epochs: uint32; - /// The current error value. This can be any positive number, where lower is better. - epoch_error: float32; - /// A list of the current estimated body proportions. - adjusted_skeleton_parts: [SkeletonPart]; -} - -/// https://github.com/SlimeVR/SlimeVR-Server/blob/v0.8.3/server/src/main/java/dev/slimevr/config/AutoBoneConfig.kt -table AutoBoneSettings { - cursor_increment: int32 = null; - min_data_distance: int32 = null; - max_data_distance: int32 = null; - num_epochs: int32 = null; - print_every_num_epochs: int32 = null; - initial_adjust_rate: float32 = null; - adjust_rate_decay: float32 = null; - slide_error_factor: float32 = null; - offset_slide_error_factor: float32 = null; - foot_height_offset_error_factor: float32 = null; - body_proportion_error_factor: float32 = null; - height_error_factor: float32 = null; - position_error_factor: float32 = null; - position_offset_error_factor: float32 = null; - calc_init_error: bool = null; - randomize_frame_order: bool = null; - scale_each_step: bool = null; - sample_count: int32 = null; - sample_rate_ms: int64 = null; - save_recordings: bool = null; - use_skeleton_height: bool = null; - rand_seed: int64 = null; -} - -table HeightRequest (deprecated) {} - -/// Returns the current min and max positional tracker heights -table HeightResponse (deprecated) { - min_height: float32; - max_height: float32; -} - -/// Applies the estimated proportions -table AutoBoneApplyRequest {} - -/// Stops the current recording, using it as far as it has been recorded -table AutoBoneStopRecordingRequest {} - -/// Cancels the current recording, aborting the process and discarding the data -table AutoBoneCancelRecordingRequest {} - -// ---- Overlay ---- - -/// Requests the current state of `OverlayDisplayModeResponse`. -table OverlayDisplayModeRequest {} - -/// Changes the state of the overlay's display mode. -table OverlayDisplayModeChangeRequest { - is_visible: bool = null; - is_mirrored: bool = null; -} - -/// The current state of the overlay's display mode. -table OverlayDisplayModeResponse { - is_visible: bool; - is_mirrored: bool; -} - -/// Allows to ask generic infos about the server, -/// like the local ip address, the version of the server, the java version, -/// the current working dir and other information we might want to show in the gui -/// for information/debug purposes -table ServerInfosRequest {} - -/// Holds the Server information, this is a basic table holding various information about the currently running server -/// like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more -/// infos we might want to add in the future. (like java version, working dir, server version ....) -/// This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance -table ServerInfosResponse { - localIp: string; -} - -// TODO: Should we extend this to more types of temp settings in the future? -/// Makes a temporary change to legtweaks. This is not saved to disk, and can be -/// cleared with `LegTweaksTmpClear` -table LegTweaksTmpChange { - floor_clip: bool = null; - skating_correction: bool = null; - toe_snap: bool = null; - foot_plant: bool = null; -} - -/// Clears the legtweaks temporary state back to what the config has. -/// Setting a field to `true` will reset that field. -table LegTweaksTmpClear { - floor_clip: bool = false; - skating_correction: bool = false; - toe_snap: bool = false; - foot_plant: bool = false; -} - -// DEPRECATED -union StatusData { - StatusTrackerReset, - StatusTrackerError, - StatusSteamVRDisconnected, - StatusUnassignedHMD, - StatusPublicNetwork, -} - -// DEPRECATED -/// Tracker requires full reset -table StatusTrackerReset { - tracker_id: [solarxr_protocol.datatypes.TrackerId]; -} - -// DEPRECATED -/// Trackers with error state -table StatusTrackerError { - tracker_id: [solarxr_protocol.datatypes.TrackerId]; -} - -// DEPRECATED -/// SteamVR bridge is disconnected -table StatusSteamVRDisconnected { - /// Name of bridge in the server's config - bridge_settings_name: string; -} - -// DEPRECATED -/// There is an available HMD tracker and it's not assigned to head -table StatusUnassignedHMD { - tracker_id: solarxr_protocol.datatypes.TrackerId; -} - -// DEPRECATED -/// Request current statuses that we have -table StatusSystemRequest {} - -// DEPRECATED -/// Response containing all current valid statuses -table StatusSystemResponse { - current_statuses: [StatusMessage]; -} - -// DEPRECATED -/// When a new status appears, it's sent alone -table StatusSystemUpdate { - new_status: StatusMessage; -} - -// DEPRECATED -/// When an status is fixed and it's removed, it's ID is sent -table StatusSystemFixed { - fixed_status_id: uint32; -} - -// DEPRECATED -/// When the server detects a public network profile -table StatusPublicNetwork { - /// names of the adapters set to public - adapters: [string]; -} - -/// An status is some kind of warning sent by the server, it's mainly made for -/// showing problems with the server and need attention from the user. -table StatusMessage { - /// The status ID - id: uint32; - /// This should be prioritized in the GUI in some way if true - prioritized: bool = false; - data: StatusData; -} - -table SetPauseTrackingRequest { - /// Pauses skeleton tracking if true, resumes skeleton tracking if false. - pauseTracking: bool; -} - -/// Clears mounting reset data, defaulting to the manually set mounting orientations -table ClearMountingResetRequest {} - -/// Common folders often used in computers for storing files -enum ComputerDirectory: uint8 { - Documents, -} - -/// Used for the server to save a file and have it prompt in the user side -table SaveFileNotification { - /// Binary data of the file - data: [uint8]; - /// MIME type of file if one exists, use `file_extension` otherwise - mime_type: string; - /// Use MIME type preferably if one exists - file_extension: string; - /// Directory recommended to save the file on - expected_dir: ComputerDirectory = null; - /// Recommended filename - expected_filename: string; -} - -// ------------ Firmware tool ------------- - - -enum FirmwareUpdateStatus: uint8 { - /// The server is downloading the firmware - DOWNLOADING, - - /// The server is waiting for the tracker to be rebooted by the user - /// Note that is is not the same as REBOOTING - NEED_MANUAL_REBOOT, - - /// The server tries to authenticate with the MCU - AUTHENTICATING, - - /// The server is uploading the firmware to the Device - UPLOADING, - - /// The serial flasher tries to sync with the MCU - /// You can use this event to prompt the user to press the boot btn - SYNCING_WITH_MCU, - - /// The MCU is rebooting - REBOOTING, - - /// The server is provisioning the tracker - PROVISIONING, - - // The update process completed with success - DONE, - - /// Could not find the device - ERROR_DEVICE_NOT_FOUND, - - /// The operation timed out, > 1min - ERROR_TIMEOUT, - - /// The firmware download failed - ERROR_DOWNLOAD_FAILED, - - /// The server could not authenticate with the MCU - ERROR_AUTHENTICATION_FAILED, - - /// Could not upload the firmware to the MCU - ERROR_UPLOAD_FAILED, - - /// The provision of the tracker failed, usually wifi credentials - ERROR_PROVISIONING_FAILED, - - /// An unsupported Flashing method was used - ERROR_UNSUPPORTED_METHOD, - - ERROR_UNKNOWN, -} - -table SerialDevicePort { - port: string; -} - -union FirmwareUpdateDeviceId { - solarxr_protocol.datatypes.DeviceIdTable, - SerialDevicePort, -} - -table FirmwarePart { - /// Url of the firmware bin to download - url: string; - - /// Offset of the firmware, used when flashing to the mcu, it indicates where to write this file in memory - /// Will be ignored in the case of OTA flashing - offset: uint; - - /// Checksum of the file - digest: string; -} - -union FirmwareUpdateMethod { - OTAFirmwareUpdate, - SerialFirmwareUpdate -} - -table FirmwareUpdateRequest { - method: FirmwareUpdateMethod; -} - -table OTAFirmwareUpdate { - /// id of the device, this refer to the actual DeviceId from the protocol - device_id: solarxr_protocol.datatypes.DeviceId; - - /// A table containing the url and offset of the firmware bin file - firmware_part: FirmwarePart; -} - -table SerialFirmwareUpdate { - /// id of the device, this refer to a serial port id - device_id: SerialDevicePort; - - /// Will make the server ask for the tracker to be manually rebooted by the user - /// after the tracker is done flashing - needManualReboot: bool; - - /// Credentials to provision after the flashing - /// Only used with Serial flashing, because OTA is already connected to the wifi - ssid: string; - password: string; - - /// A list of urls and offsets of the different firmware files to flash - firmware_part: [FirmwarePart]; -} - -table FirmwareUpdateStatusResponse { - device_id: FirmwareUpdateDeviceId; - status: FirmwareUpdateStatus; - - /// from 0 to 100 - progress: int8; -} - -// This will cancel all pending updates -table FirmwareUpdateStopQueuesRequest {} - -/// Requests the current state of tracking pause -table TrackingPauseStateRequest {} - -table TrackingPauseStateResponse { - /// Skeleton tracking is paused if true, skeleton tracking is unpaused if false. - trackingPaused: bool; -} - -/// Sends the GET WIFISCAN cmd to the current tracker on the serial monitor -table SerialTrackerGetWifiScanRequest {} - -/// Server notifies connection of an unknown device. -/// If the notification is no longer sent, it means the device connected to another -/// server, got connected to this server or it was turned off. -table UnknownDeviceHandshakeNotification { - mac_address: string; -} - -table AddUnknownDeviceRequest { - mac_address: string; -} - -table ForgetDeviceRequest { - mac_address: string; -} - -table SettingsResetRequest {} - -/// If no tracker ID is given, it's the setting for every tracker/device -table MagToggleRequest { - tracker_id: solarxr_protocol.datatypes.TrackerId; -} - -/// If no tracker ID is given, it's the setting for every tracker/device -table MagToggleResponse { - tracker_id: solarxr_protocol.datatypes.TrackerId; - enable: bool; -} - -/// If no tracker ID is given, it's the setting for every tracker/device -table ChangeMagToggleRequest { - tracker_id: solarxr_protocol.datatypes.TrackerId; - enable: bool; -} - - -// ------------- VRC Config State ----------------- - -enum VRCTrackerModel: uint8 { - UNKNOWN = 0, - SPHERE = 1, - SYSTEM = 2, - BOX = 3, - AXIS = 4, -} - -enum VRCSpineMode: uint8 { - UNKNOWN = 0, - LOCK_HIP = 1, - LOCK_HEAD = 2, - LOCK_BOTH = 3, -} - -enum VRCAvatarMeasurementType: uint8 { - UNKNOWN = 0, - HEIGHT = 1, - ARM_SPAN = 2 -} - - -table VRCConfigValidity { - legacy_mode_ok: bool; - shoulder_tracking_ok: bool; - user_height_ok: bool; - calibration_range_ok: bool; - calibration_visuals_ok: bool; - tracker_model_ok: bool; - spine_mode_ok: bool; - avatar_measurement_type_ok: bool; - shoulder_width_compensation_ok: bool; -} - -table VRCConfigValues { - legacy_mode: bool; - shoulder_tracking_disabled: bool; - user_height: float; - calibration_range: float; - calibration_visuals: bool; - tracker_model: VRCTrackerModel; - spine_mode: VRCSpineMode; - avatar_measurement_type: VRCAvatarMeasurementType; - shoulder_width_compensation: bool; -} - -table VRCConfigRecommendedValues { - legacy_mode: bool; - shoulder_tracking_disabled: bool; - user_height: float; - calibration_range: float; - calibration_visuals: bool; - tracker_model: VRCTrackerModel; - spine_mode: [VRCSpineMode]; - avatar_measurement_type: VRCAvatarMeasurementType; - shoulder_width_compensation: bool; -} - -table VRCConfigStateRequest {} - -/// Sent every time the vrchat config state gets updated -/// used to display vrchat missconfig settings to the user -table VRCConfigStateChangeResponse { - is_supported: bool; - validity: VRCConfigValidity; - state: VRCConfigValues; - recommended: VRCConfigRecommendedValues; - // Just a list of keys from the VRCConfigValidity table. - // didnt want to make it a full table, because it would be another pain to maintain. Strings are fine for that. - // copium - muted: [string]; -} - -// Mute or unmute a vrc setting warning from its key -table VRCConfigSettingToggleMute { - // Key from VRCConfigValidity - key: string; -} - - -// ------------- Tracking checklist system ----------------- - -enum TrackingChecklistStepId : uint8 { - UNKNOWN = 0, - TRACKERS_REST_CALIBRATION = 1, - FULL_RESET = 2, - VRCHAT_SETTINGS = 3, - STEAMVR_DISCONNECTED = 4, - UNASSIGNED_HMD = 5, - TRACKER_ERROR = 6, - NETWORK_PROFILE_PUBLIC = 7, - MOUNTING_CALIBRATION = 8, - FEET_MOUNTING_CALIBRATION = 9, - STAY_ALIGNED_CONFIGURED = 10, - STEAMVR_HANDS_ENABLED = 11, - STANDABLE_INSTALLED = 12, -} - -enum TrackingChecklistStepVisibility : uint8 { - ALWAYS, - WHEN_INVALID, -} - -/// Trackers that need a reset -table TrackingChecklistTrackerReset { - trackers_id: [solarxr_protocol.datatypes.TrackerId]; -} - -/// Trackers with error state -table TrackingChecklistTrackerError { - trackers_id: [solarxr_protocol.datatypes.TrackerId]; -} - -table TrackingChecklistNeedCalibration { - trackers_id: [solarxr_protocol.datatypes.TrackerId]; -} - -table TrackingChecklistSteamVRDisconnected { - /// Name of bridge in the server's config - bridge_settings_name: string; - /// Is the driver installed? - driver_installed: bool; - /// Has the driver been blocked due to SteamVR's "safe mode"? - driver_blocked_by_safe_mode: bool; - /// Is the driver enabled in SteamVR settings? - driver_enabled: bool; -} - -table EnableSteamVRDriverRequest {} - -table TrackingChecklistUnassignedHMD { - tracker_id: solarxr_protocol.datatypes.TrackerId; -} - -table TrackingChecklistPublicNetworks { - adapters: [string]; -} - -union TrackingChecklistExtraData { - TrackingChecklistTrackerReset, - TrackingChecklistTrackerError, - TrackingChecklistSteamVRDisconnected, - TrackingChecklistUnassignedHMD, - TrackingChecklistNeedCalibration, - TrackingChecklistPublicNetworks -} - -table TrackingChecklistStep { - id: TrackingChecklistStepId; - valid: bool; - // Can hide a step, usefull for step that might not be able to be either be valid or invalid - enabled: bool; - visibility: TrackingChecklistStepVisibility; - // For cases where we dont know for sure if the user should do it or no - // Like start steamvr -> we dont know if they should do it as they might want to use standalone - optional: bool; - // Tell if this step can be put in the ignore list - ignorable: bool; - extra_data: TrackingChecklistExtraData; -} - -table TrackingChecklistRequest {} - -table TrackingChecklistResponse { - // the order of the steps mater - // and steps should be unique - steps: [TrackingChecklistStep]; - // A list of the step ids that will not show up in the ui - // we keep this as a way to re-enable the step from the ui if needed - ignored_steps: [TrackingChecklistStepId]; -} - -// Allows to ignore/unignore check list steps -table IgnoreTrackingChecklistStepRequest { - step_id: TrackingChecklistStepId; - ignore: bool; -} - -// ------------- Stay Aligned ----------------- - -table EnableStayAlignedRequest { - enable: bool; -} - -enum StayAlignedRelaxedPose: uint8 { - STANDING = 0, - SITTING = 1, - FLAT = 2 -} - -table DetectStayAlignedRelaxedPoseRequest { - pose: StayAlignedRelaxedPose; -} - -table ResetStayAlignedRelaxedPoseRequest { - pose: StayAlignedRelaxedPose; -} - - -// -------------- User Height Calibaration -------------- - -table StartUserHeightCalibration {} - -table CancelUserHeightCalibration {} - -enum UserHeightCalibrationStatus: uint8 { - NONE = 0, - RECORDING_FLOOR = 1, - WAITING_FOR_CONTROLLER_PITCH = 2, - WAITING_FOR_RISE = 3, - WAITING_FOR_FW_LOOK = 4, - RECORDING_HEIGHT = 5, - DONE = 6, - ERROR_TOO_HIGH = 7, - ERROR_TOO_SMALL = 8, - ERROR_TIMEOUT = 9 -} - -table UserHeightRecordingStatusResponse { - hmdHeight: float; - status: UserHeightCalibrationStatus; -} diff --git a/schema/rpc/autobone.fbs b/schema/rpc/autobone.fbs new file mode 100644 index 000000000..02b2b70cf --- /dev/null +++ b/schema/rpc/autobone.fbs @@ -0,0 +1,44 @@ +namespace solarxr_protocol.rpc; + +enum AutoBoneProcessType: uint8 { + NONE = 0, + RECORD = 1, + SAVE = 2, + PROCESS = 3, +} + +table AutoBoneProcessRequest { + process_type: AutoBoneProcessType; +} + +table AutoBoneProcessStatusResponse { + process_type: AutoBoneProcessType; + /// The current count. This value is -1 if there is nothing to report. + current: uint32; + /// The total count. This value is -1 if there is nothing to report. + total: uint32; + /// True if the operation has completed with any result, successful or not. + completed: bool; + /// True if the completed operation was successful, only observe if `completed` is true. + success: bool; + /// The time remaining in seconds. This value is -1 if there is nothing to report. + eta: float32; +} + +table AutoBoneEpochResponse { + current_epoch: uint32; + total_epochs: uint32; + /// The current error value. This can be any positive number, where lower is better. + epoch_error: float32; + /// A list of the current estimated body proportions. + adjusted_skeleton_parts: [SkeletonPart]; +} + +/// Applies the estimated proportions +table AutoBoneApplyRequest {} + +/// Stops the current recording, using it as far as it has been recorded +table AutoBoneStopRecordingRequest {} + +/// Cancels the current recording, aborting the process and discarding the data +table AutoBoneCancelRecordingRequest {} \ No newline at end of file diff --git a/schema/rpc/bvh.fbs b/schema/rpc/bvh.fbs new file mode 100644 index 000000000..02b240791 --- /dev/null +++ b/schema/rpc/bvh.fbs @@ -0,0 +1,13 @@ +namespace solarxr_protocol.rpc; + +table RecordBVHRequest { + stop: bool; + /// Path sent when starting the recording, if null the recording won't happen. + /// Has different behavior depending if its a file path or a directory path. + path: string; +} + +table RecordBVHStatus { + recording: bool; +} +table RecordBVHStatusRequest {} \ No newline at end of file diff --git a/schema/rpc/device.fbs b/schema/rpc/device.fbs new file mode 100644 index 000000000..5507e2299 --- /dev/null +++ b/schema/rpc/device.fbs @@ -0,0 +1,16 @@ +namespace solarxr_protocol.rpc; + +/// Server notifies connection of an unknown device. +/// If the notification is no longer sent, it means the device connected to another +/// server, got connected to this server or it was turned off. +table UnknownDeviceHandshakeNotification { + mac_address: string; +} + +table AddUnknownDeviceRequest { + mac_address: string; +} + +table ForgetDeviceRequest { + mac_address: string; +} diff --git a/schema/rpc/firmware.fbs b/schema/rpc/firmware.fbs new file mode 100644 index 000000000..efc9246bf --- /dev/null +++ b/schema/rpc/firmware.fbs @@ -0,0 +1,100 @@ +namespace solarxr_protocol.rpc; + +enum FirmwareUpdateStatus: uint8 { + /// The server is downloading the firmware + DOWNLOADING, + /// The server is waiting for the tracker to be rebooted by the user + /// Note that is is not the same as REBOOTING + NEED_MANUAL_REBOOT, + /// The server tries to authenticate with the MCU + AUTHENTICATING, + /// The server is uploading the firmware to the Device + UPLOADING, + /// The serial flasher tries to sync with the MCU + /// You can use this event to prompt the user to press the boot btn + SYNCING_WITH_MCU, + /// The MCU is rebooting + REBOOTING, + /// The server is provisioning the tracker + PROVISIONING, + /// The update process completed with success + DONE, + /// Could not find the device + ERROR_DEVICE_NOT_FOUND, + /// The operation timed out, > 1min + ERROR_TIMEOUT, + /// The firmware download failed + ERROR_DOWNLOAD_FAILED, + /// The server could not authenticate with the MCU + ERROR_AUTHENTICATION_FAILED, + /// Could not upload the firmware to the MCU + ERROR_UPLOAD_FAILED, + /// The provision of the tracker failed, usually wifi credentials + ERROR_PROVISIONING_FAILED, + /// An unsupported Flashing method was used + ERROR_UNSUPPORTED_METHOD, + ERROR_UNKNOWN, +} + +table SerialDevicePort { + port: string; +} + +table FirmwareDeviceIdTable { + id: uint16; +} + +union FirmwareUpdateDeviceId { + FirmwareDeviceIdTable, + SerialDevicePort, +} + +table FirmwarePart { + /// Url of the firmware bin to download + url: string; + /// Offset of the firmware, used when flashing to the mcu, it indicates where to write this file in memory + /// Will be ignored in the case of OTA flashing + offset: uint; + /// Checksum of the file + digest: string; +} + +union FirmwareUpdateMethod { + OTAFirmwareUpdate, + SerialFirmwareUpdate +} + +table FirmwareUpdateRequest { + method: FirmwareUpdateMethod; +} + +table OTAFirmwareUpdate { + /// Id of the device + device_id: uint16; + /// A table containing the url and offset of the firmware bin file + firmware_part: FirmwarePart; +} + +table SerialFirmwareUpdate { + /// id of the device, this refer to a serial port id + device_id: SerialDevicePort; + /// Will make the server ask for the tracker to be manually rebooted by the user + /// after the tracker is done flashing + need_manual_reboot: bool; + /// Credentials to provision after the flashing + /// Only used with Serial flashing, because OTA is already connected to the wifi + ssid: string; + password: string; + /// A list of urls and offsets of the different firmware files to flash + firmware_part: [FirmwarePart]; +} + +table FirmwareUpdateStatusResponse { + device_id: FirmwareUpdateDeviceId; + status: FirmwareUpdateStatus; + /// from 0 to 100 + progress: int8; +} + +// This will cancel all pending updates +table FirmwareUpdateStopQueuesRequest {} \ No newline at end of file diff --git a/schema/rpc/height_calibration.fbs b/schema/rpc/height_calibration.fbs new file mode 100644 index 000000000..b8385b050 --- /dev/null +++ b/schema/rpc/height_calibration.fbs @@ -0,0 +1,23 @@ +namespace solarxr_protocol.rpc; + +table StartUserHeightCalibration {} + +table CancelUserHeightCalibration {} + +enum UserHeightCalibrationStatus: uint8 { + NONE = 0, + RECORDING_FLOOR = 1, + WAITING_FOR_CONTROLLER_PITCH = 2, + WAITING_FOR_RISE = 3, + WAITING_FOR_FW_LOOK = 4, + RECORDING_HEIGHT = 5, + DONE = 6, + ERROR_TOO_HIGH = 7, + ERROR_TOO_SMALL = 8, + ERROR_TIMEOUT = 9 +} + +table UserHeightRecordingStatusResponse { + hmd_height: float; + status: UserHeightCalibrationStatus; +} diff --git a/schema/rpc/keybinding.fbs b/schema/rpc/keybinding.fbs new file mode 100644 index 000000000..de9880555 --- /dev/null +++ b/schema/rpc/keybinding.fbs @@ -0,0 +1,31 @@ +namespace solarxr_protocol.rpc; + +enum KeybindId: uint8 { + FULL_RESET = 0, + YAW_RESET = 1, + MOUNTING_RESET = 2, + PAUSE_TRACKING = 3, + FEET_MOUNTING_RESET = 4 +} + +table Keybind { + keybind_id: KeybindId; + keybind_name_id: string; + keybind_value: string; + keybind_delay: float; +} + +/// Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui +table KeybindRequest { + keybind_id: KeybindId; +} + +/// Returns keybinds for displaying in gui +table KeybindResponse { + keybind: [Keybind]; + default_keybinds: [Keybind]; +} + +table ChangeKeybindRequest { + keybind: Keybind; +} \ No newline at end of file diff --git a/schema/rpc/overlay.fbs b/schema/rpc/overlay.fbs new file mode 100644 index 000000000..d2f78d36e --- /dev/null +++ b/schema/rpc/overlay.fbs @@ -0,0 +1,16 @@ +namespace solarxr_protocol.rpc; + +/// Requests the current state of `OverlayDisplayModeResponse`. +table OverlayDisplayModeRequest {} + +/// Changes the state of the overlay's display mode. +table OverlayDisplayModeChangeRequest { + is_visible: bool = null; + is_mirrored: bool = null; +} + +/// The current state of the overlay's display mode. +table OverlayDisplayModeResponse { + is_visible: bool; + is_mirrored: bool; +} \ No newline at end of file diff --git a/schema/rpc/provisioning.fbs b/schema/rpc/provisioning.fbs new file mode 100644 index 000000000..528c934ab --- /dev/null +++ b/schema/rpc/provisioning.fbs @@ -0,0 +1,27 @@ +namespace solarxr_protocol.rpc; + +table StartWifiProvisioningRequest { + ssid: string; + password: string; + port: string; +} + +table StopWifiProvisioningRequest {} + +enum WifiProvisioningStatus: uint8 { + NONE = 0, + SERIAL_INIT = 1, + PROVISIONING = 2, + CONNECTING = 3, + CONNECTION_ERROR = 4, + LOOKING_FOR_SERVER = 5, + COULD_NOT_FIND_SERVER = 6, + DONE = 7, + OBTAINING_MAC_ADDRESS = 8, + NO_SERIAL_LOGS_ERROR = 9, + NO_SERIAL_DEVICE_FOUND = 10, +} + +table WifiProvisioningStatusResponse { + status: WifiProvisioningStatus; +} \ No newline at end of file diff --git a/schema/rpc/resets.fbs b/schema/rpc/resets.fbs new file mode 100644 index 000000000..b5fa94e01 --- /dev/null +++ b/schema/rpc/resets.fbs @@ -0,0 +1,66 @@ +namespace solarxr_protocol.rpc; + +enum ResetType: uint8 { + /// Resets the yaw (horizontal) axis + YAW, + /// Resets all axes + FULL, + /// Second pose for calibrating mounting rotation + MOUNTING, +} + +enum ResetStatus: uint8 { + STARTED, + FINISHED, +} + +table ResetRequest { + reset_type: ResetType; + /// Which body parts to reset. Server handles it if empty (usually all) + body_parts: [solarxr_protocol.datatypes.BodyPart]; + delay: float = null; +} + +table ResetResponse { + reset_type: ResetType; + status: ResetStatus; + /// Should return the body parts reset / being reset + body_parts: [solarxr_protocol.datatypes.BodyPart]; + /// gives the time in seconds passed since the start of the reset + /// Starts at 0. Should be equal to 'duration' when status == FINISHED + progress: int; + duration: int; +} + +/// Clears mounting reset data, defaulting to the manually set mounting orientations +table ClearMountingResetRequest {} + +enum ArmsResetMode: uint8 { + /// Down to the sides for full. Upper arm going back and forearm going forward for mounting. + BACK, + /// Down to the sides for full. Arms going forward for mounting. + FORWARD, + /// Down to the sides for full. T-pose for mounting. + T_POSE_UP, + /// T-pose for full. Down to the sides for mounting. + T_POSE_DOWN +} + +// Resets settings request and response +table ResetsSettingsRequest {} +table ResetsSettingsResponse { + /// Makes it so feet will be mounting reset when passing no BodyPart + reset_mounting_feet: bool; + arms_reset_mode: ArmsResetMode; + yaw_reset_smooth_time: float32; + save_mounting_reset: bool; + reset_hmd_pitch: bool; +} +table ChangeResetsSettingsRequest { + /// Makes it so feet will be mounting reset when passing no BodyPart + reset_mounting_feet: bool; + arms_reset_mode: ArmsResetMode; + yaw_reset_smooth_time: float32; + save_mounting_reset: bool; + reset_hmd_pitch: bool; +} diff --git a/schema/rpc/rpc.fbs b/schema/rpc/rpc.fbs new file mode 100644 index 000000000..a58215eca --- /dev/null +++ b/schema/rpc/rpc.fbs @@ -0,0 +1,193 @@ +/// This file contains all messages related to the RPC system. Unlike the data feed +/// system, the RPC system is focused on providing a reliable RPC communication pattern. +/// +/// It can be used either for sending commands to mutate state, or reliably sending +/// evented updates of data that should be guaranteed to be observed, such as a user +/// initiated button push. + +include "../datatypes/datatypes.fbs"; +include "autobone.fbs"; +include "bvh.fbs"; +include "device.fbs"; +include "firmware.fbs"; +include "height_calibration.fbs"; +include "keybinding.fbs"; +include "overlay.fbs"; +include "provisioning.fbs"; +include "resets.fbs"; +include "serial.fbs"; +include "skeleton.fbs"; +include "stay_aligned.fbs"; +include "tracker.fbs"; +include "tracking_checklist.fbs"; +include "vmc.fbs"; +include "vrchat.fbs"; +include "vrcosc.fbs"; + +namespace solarxr_protocol.rpc; + +union RpcMessage { + HeartbeatRequest, + HeartbeatResponse, + ResetRequest, + ResetResponse, + AssignTrackerRequest, + OutputTrackersSettingsRequest, + OutputTrackersSettingsResponse, + ChangeOutputTrackersSettingsRequest, + VMCOSCSettingsRequest, + VMCOSCSettingsResponse, + ChangeVMCOSCSettingsRequest, + VRMSettingsRequest, + VRMSettingsResponse, + ChangeVRMSettingsRequest, + SkeletonSettingsRequest, + SkeletonSettingsResponse, + ChangeSkeletonSettingsRequest, + TapDetectionSettingsRequest, + TapDetectionSettingsResponse, + ChangeTapDetectionSettingsRequest, + TapDetectionSetupModeRequest, + ResetsSettingsRequest, + ResetsSettingsResponse, + ChangeResetsSettingsRequest, + StayAlignedSettingsRequest, + StayAlignedSettingsResponse, + ChangeStayAlignedSettingsRequest, + CompleteStayAlignedResponse, + StayAlignedHideCorrectionRequest, + HIDSettingsRequest, + HIDSettingsResponse, + ChangeHIDSettingsRequest, + RecordBVHRequest, + RecordBVHStatus, + SkeletonProportionsRequest, + ChangeSkeletonProportionsRequest, + SkeletonProportionsResetAllRequest, + SkeletonProportionsResponse, + OpenSerialRequest, + CloseSerialRequest, + SerialUpdateResponse, + AutoBoneProcessRequest, + AutoBoneProcessStatusResponse, + AutoBoneEpochResponse, + OverlayDisplayModeRequest, + OverlayDisplayModeChangeRequest, + OverlayDisplayModeResponse, + SerialTrackerRebootRequest, + SerialTrackerGetInfoRequest, + SerialTrackerFactoryResetRequest, + SerialDevicesRequest, + SerialDevicesResponse, + NewSerialDeviceResponse, + StartWifiProvisioningRequest, + StopWifiProvisioningRequest, + WifiProvisioningStatusResponse, + ServerInfosRequest, + ServerInfosResponse, + LegTweaksTmpChange, + LegTweaksTmpClear, + TapDetectionSetupNotification, + SetPauseTrackingRequest, + ClearMountingResetRequest, + AutoBoneApplyRequest, + AutoBoneStopRecordingRequest, + AutoBoneCancelRecordingRequest, + SaveFileNotification, + TrackingPauseStateRequest, + TrackingPauseStateResponse, + SerialTrackerGetWifiScanRequest, + UnknownDeviceHandshakeNotification, + AddUnknownDeviceRequest, + ForgetDeviceRequest, + FirmwareUpdateRequest, + FirmwareUpdateStatusResponse, + FirmwareUpdateStopQueuesRequest, + SettingsResetRequest, + MagToggleRequest, + MagToggleResponse, + ChangeMagToggleRequest, + RecordBVHStatusRequest, + VRCConfigStateRequest, + VRCConfigStateChangeResponse, + EnableStayAlignedRequest, + DetectStayAlignedRelaxedPoseRequest, + ResetStayAlignedRelaxedPoseRequest, + SerialTrackerCustomCommandRequest, + VRCConfigSettingToggleMute, + TrackingChecklistRequest, + TrackingChecklistResponse, + IgnoreTrackingChecklistStepRequest, + StartUserHeightCalibration, + CancelUserHeightCalibration, + UserHeightRecordingStatusResponse, + VRCOSCSettingsRequest, + VRCOSCSettingsResponse, + ChangeVRCOSCSettingsRequest, + VRCOSCStatusRequest, + VRCOSCStatusChangeResponse, + KeybindRequest, + ChangeKeybindRequest, + KeybindResponse, + InstalledInfoRequest, + InstalledInfoResponse, + OpenUriRequest, + OpenUriResponse, + EnableSteamVRDriverRequest, +} + +table RpcMessageHeader { + /// For a request, this identifies the request. + /// For a response, this corresponds to the request that it is responding to. + tx_id: solarxr_protocol.datatypes.TransactionId; + message: RpcMessage; +} + +table HeartbeatRequest {} +table HeartbeatResponse {} + +/// Resets the server settings +table SettingsResetRequest {} + +table OpenUriRequest {} +table OpenUriResponse { + success: bool; +} + +table InstalledInfoRequest {} +table InstalledInfoResponse { + is_udev_installed: bool; + is_wayland: bool; +} + +/// Allows to ask generic infos about the server, +/// like the local ip address, the version of the server, the java version, +/// the current working dir and other information we might want to show in the gui +/// for information/debug purposes +table ServerInfosRequest {} +/// Holds the Server information, this is a basic table holding various information about the currently running server +/// like its local ip address (useful for standalone users so they can specify the ip of the server more easily) and any more +/// infos we might want to add in the future. (like java version, working dir, server version ....) +/// This only holds the local ip for now. But there will be other information added as we chose to display them on the gui for instance +table ServerInfosResponse { + local_ip: string; +} + +/// Common folders often used in computers for storing files +enum ComputerDirectory: uint8 { + DOCUMENTS, +} + +/// Used for the server to save a file and have it prompt in the user side +table SaveFileNotification { + /// Binary data of the file + data: [uint8]; + /// MIME type of file if one exists, use `extension` otherwise + mime_type: string; + /// Use MIME type preferably if one exists + extension: string; + /// Directory recommended to save the file on + expected_dir: ComputerDirectory = null; + /// Recommended filename + expected_filename: string; +} diff --git a/schema/rpc/serial.fbs b/schema/rpc/serial.fbs new file mode 100644 index 000000000..c45c9948e --- /dev/null +++ b/schema/rpc/serial.fbs @@ -0,0 +1,62 @@ +namespace solarxr_protocol.rpc; + +enum SerialDeviceType: uint8 { + ESP_TRACKER = 0, + HID_RECEIVER = 1, + HID_TRACKER = 2, +} + +table SerialDevice { + port: string; + name: string; + type: SerialDeviceType; +} + +table OpenSerialRequest { + /// Automatically pick the first serial device available + auto: bool; + port: string; +} + +table CloseSerialRequest {} + +table SerialUpdateResponse { + log: string; + closed: bool; + device: SerialDevice; +} + +/// Reboots the tracker connected to the serial monitor +table SerialTrackerRebootRequest {} + +/// Sends the GET INFO cmd to the current tracker on the serial monitor +table SerialTrackerGetInfoRequest {} + +/// Sends the FRST cmd to the currently connected Tracker over the Serial Monitor +table SerialTrackerFactoryResetRequest {} + +/// Sends a custom cmd to the currently connected Tracker over the Serial Monitor +table SerialTrackerCustomCommandRequest { + command: string; +} + +table SerialDevicesRequest {} + +table SerialDevicesResponse { + devices: [SerialDevice]; +} + +table NewSerialDeviceResponse { + device: SerialDevice; +} + +/// Sends the GET WIFISCAN cmd to the current tracker on the serial monitor +table SerialTrackerGetWifiScanRequest {} + +table HIDSettingsRequest {} +table HIDSettingsResponse { + trackers_over_hid: bool; +} +table ChangeHIDSettingsRequest { + trackers_over_hid: bool; +} \ No newline at end of file diff --git a/schema/rpc/skeleton.fbs b/schema/rpc/skeleton.fbs new file mode 100644 index 000000000..e2f2d338d --- /dev/null +++ b/schema/rpc/skeleton.fbs @@ -0,0 +1,149 @@ +namespace solarxr_protocol.rpc; + +enum SkeletonBone: uint8 { + NONE = 0, + HEAD = 1, + NECK = 2, + CHEST = 3, + CHEST_OFFSET = 4, + WAIST = 5, + HIP = 6, + HIP_OFFSET = 7, + HIPS_WIDTH = 8, + UPPER_LEG = 9, + LOWER_LEG = 10, + FOOT_LENGTH = 11, + FOOT_SHIFT = 12, + SKELETON_OFFSET = 13, + SHOULDERS_DISTANCE = 14, + SHOULDERS_WIDTH = 15, + UPPER_ARM = 16, + LOWER_ARM = 17, + HAND_Y = 18, + HAND_Z = 19, + ELBOW_OFFSET = 20, + UPPER_CHEST = 21, +} + +table SkeletonPart { + bone: SkeletonBone; + value: float; +} + +table SkeletonProportionsRequest {} +table SkeletonProportionsResponse { + skeleton_parts: [SkeletonPart]; + user_height: float; +} +table ChangeSkeletonProportionsRequest { + bone: SkeletonBone; + value: float; +} + +table SkeletonProportionsResetAllRequest {} + +/// Makes a temporary change to legtweaks. This is not saved to disk, and can be +/// cleared with `LegTweaksTmpClear` +table LegTweaksTmpChange { + floor_clip: bool = null; + skating_correction: bool = null; + toe_snap: bool = null; + foot_plant: bool = null; +} + +/// Clears the legtweaks temporary state back to what the config has. +/// Setting a field to `true` will reset that field. +table LegTweaksTmpClear { + floor_clip: bool = false; + skating_correction: bool = false; + toe_snap: bool = false; + foot_plant: bool = false; +} + +table SetPauseTrackingRequest { + /// Pauses skeleton tracking if true, resumes skeleton tracking if false. + pause_tracking: bool; +} + +/// Requests the current state of tracking pause +table TrackingPauseStateRequest {} +table TrackingPauseStateResponse { + /// Skeleton tracking is paused if true, skeleton tracking is unpaused if false. + tracking_paused: bool; +} + +/// Toggles for the skeletal model. +table SkeletonToggles { + force_arms_from_hmd: bool = null; + floor_clip: bool = null; + skating_correction: bool = null; + toe_snap: bool = null; + foot_plant: bool = null; + self_localization: bool = null; + use_position: bool = null; + enforce_constraints: bool = null; + correct_constraints: bool = null; +} + +/// Ratios for the skeletal model. Accepted values for them range from 0 to 1 +table SkeletonRatios { + /// Compute missing spine bones as a ratio of the next available upper and lower bones. + impute_spine_from_upper_lower: float32 = null; + /// Computes the curvature between 2 adjacent missing spine bones. Higher = more curvature. + impute_spine_curvature: float32 = null; + /// How much to average the hip's yaw and roll with the upper legs'. + interp_hip_legs: float32 = null; + /// How much to average the knee trackers' yaw and roll with the lower legs'. + interp_knee_tracker_ankle: float32 = null; + /// How much to average the upper leg's yaw and roll with the lower legs'. + interp_knee_ankle: float32 = null; + /// Strength of skating correction. Enabled via SkeletonToggles.skating_correction + skating_correction_strength: float32 = null; +} + +enum FilteringType: uint8 { + NONE = 0, + SMOOTHING = 1, + PREDICTION = 2 +} + +/// Filtering (e.g smoothing) applied to the skeleton's movements +table SkeletonFiltering { + type: FilteringType; + /// A higher value results in more filtering (0 to 1). + amount: float32; +} + +/// Data used to compute the skeleton's height. +table SkeletonHeight { + hmd_height: float32 = null; + floor_height: float32 = null; +} + +// Skeleton settings request and response +table SkeletonSettingsRequest {} +table SkeletonSettingsResponse { + toggles: SkeletonToggles; + ratios: SkeletonRatios; + filtering: SkeletonFiltering; + skeleton_height: SkeletonHeight; +} +table ChangeSkeletonSettingsRequest { + toggles: SkeletonToggles; + ratios: SkeletonRatios; + filtering: SkeletonFiltering; + skeleton_height: SkeletonHeight; +} + +// Output Trackers settings request and response +table OutputTrackersSettingsRequest {} +table OutputTrackersSettingsResponse { + automatic_tracker_toggle: bool; + trackers: [solarxr_protocol.datatypes.BodyPart]; + send_derived_velocity: bool; +} +table ChangeOutputTrackersSettingsRequest { + automatic_tracker_toggle: bool; + trackers: [solarxr_protocol.datatypes.BodyPart]; + send_derived_velocity: bool; +} \ No newline at end of file diff --git a/schema/rpc/stay_aligned.fbs b/schema/rpc/stay_aligned.fbs new file mode 100644 index 000000000..de4240ac6 --- /dev/null +++ b/schema/rpc/stay_aligned.fbs @@ -0,0 +1,57 @@ +namespace solarxr_protocol.rpc; + +table EnableStayAlignedRequest { + enable: bool; +} + +enum StayAlignedRelaxedPose: uint8 { + STANDING = 0, + SITTING = 1, + FLAT = 2 +} + +table DetectStayAlignedRelaxedPoseRequest { + pose: StayAlignedRelaxedPose; +} + +table ResetStayAlignedRelaxedPoseRequest { + pose: StayAlignedRelaxedPose; +} + +table StayAlignedSettingsRequest {} +table StayAlignedSettingsResponse { + enabled: bool; + standing_enabled: bool; + standing_upper_leg_angle: float32; + standing_lower_leg_angle: float32; + standing_foot_angle: float32; + sitting_enabled: bool; + sitting_upper_leg_angle: float32; + sitting_lower_leg_angle: float32; + sitting_foot_angle: float32; + flat_enabled: bool; + flat_upper_leg_angle: float32; + flat_lower_leg_angle: float32; + flat_foot_angle: float32; +} +table ChangeStayAlignedSettingsRequest { + enabled: bool; + standing_enabled: bool; + standing_upper_leg_angle: float32; + standing_lower_leg_angle: float32; + standing_foot_angle: float32; + sitting_enabled: bool; + sitting_upper_leg_angle: float32; + sitting_lower_leg_angle: float32; + sitting_foot_angle: float32; + flat_enabled: bool; + flat_upper_leg_angle: float32; + flat_lower_leg_angle: float32; + flat_foot_angle: float32; +} + +table CompleteStayAlignedResponse {} + +table StayAlignedHideCorrectionRequest { + hide_correction: bool; +} diff --git a/schema/rpc/tracker.fbs b/schema/rpc/tracker.fbs new file mode 100644 index 000000000..c5611ea7f --- /dev/null +++ b/schema/rpc/tracker.fbs @@ -0,0 +1,71 @@ +include "../datatypes/datatypes.fbs"; + +namespace solarxr_protocol.rpc; + +table AssignTrackerRequest { + tracker_id: uint16; + body_position: solarxr_protocol.datatypes.BodyPart; + mounting_orientation: solarxr_protocol.datatypes.math.Quat; + display_name: string; +} + +// Tap Detection settings request and response +table TapDetectionSettingsRequest {} +table TapDetectionSettingsResponse { + full_reset_delay: float = null; + full_reset_enabled: bool = null; + full_reset_taps: uint8 = null; + yaw_reset_delay: float = null; + yaw_reset_enabled: bool = null; + yaw_reset_taps: uint8 = null; + mounting_reset_delay: float = null; + mounting_reset_enabled: bool = null; + mounting_reset_taps: uint8 = null; + number_trackers_over_threshold: uint8 = null; + yaw_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; + full_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; + mounting_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; +} +table ChangeTapDetectionSettingsRequest { + full_reset_delay: float = null; + full_reset_enabled: bool = null; + full_reset_taps: uint8 = null; + yaw_reset_delay: float = null; + yaw_reset_enabled: bool = null; + yaw_reset_taps: uint8 = null; + mounting_reset_delay: float = null; + mounting_reset_enabled: bool = null; + mounting_reset_taps: uint8 = null; + number_trackers_over_threshold: uint8 = null; + yaw_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; + full_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; + mounting_reset_tracker: solarxr_protocol.datatypes.BodyPart = null; +} + +/// Sets the TapDetection setup mode. +table TapDetectionSetupModeRequest { + /// When true, TapDetection triggering a tracker will assign it instead of doing a reset. + setup_mode: bool = null; +} + +/// Indicates which tracker got triggered by TapDetection while setup mode is enabled +table TapDetectionSetupNotification { + tracker_id: uint16; +} + +/// If no tracker ID is given, it's the setting for every tracker/device +table MagToggleRequest { + tracker_id: uint16; +} + +/// If no tracker ID is given, it's the setting for every tracker/device +table MagToggleResponse { + tracker_id: uint16; + enable: bool; +} + +/// If no tracker ID is given, it's the setting for every tracker/device +table ChangeMagToggleRequest { + tracker_id: uint16; + enable: bool; +} diff --git a/schema/rpc/tracking_checklist.fbs b/schema/rpc/tracking_checklist.fbs new file mode 100644 index 000000000..55a373502 --- /dev/null +++ b/schema/rpc/tracking_checklist.fbs @@ -0,0 +1,97 @@ +namespace solarxr_protocol.rpc; + +enum TrackingChecklistStepId : uint8 { + UNKNOWN = 0, + TRACKERS_REST_CALIBRATION = 1, + FULL_RESET = 2, + VRCHAT_SETTINGS = 3, + STEAMVR_DISCONNECTED = 4, + UNASSIGNED_HMD = 5, + TRACKER_ERROR = 6, + NETWORK_PROFILE_PUBLIC = 7, + MOUNTING_CALIBRATION = 8, + FEET_MOUNTING_CALIBRATION = 9, + STAY_ALIGNED_CONFIGURED = 10, + STEAMVR_HANDS_ENABLED = 11, + STANDABLE_INSTALLED = 12, +} + +enum TrackingChecklistStepVisibility : uint8 { + ALWAYS, + WHEN_INVALID, +} + +/// Trackers that need a reset +table TrackingChecklistTrackerReset { + trackers_id: [uint16]; +} + +/// Trackers with error state +table TrackingChecklistTrackerError { + trackers_id: [uint16]; +} + +table TrackingChecklistNeedCalibration { + trackers_id: [uint16]; +} + +table TrackingChecklistSteamVRDisconnected { + /// Name of bridge in the server's config + bridge_settings_name: string; + /// Is the driver installed? + driver_installed: bool; + /// Has the driver been blocked due to SteamVR's "safe mode"? + driver_blocked_by_safe_mode: bool; + /// Is the driver enabled in SteamVR settings? + driver_enabled: bool; +} + +table EnableSteamVRDriverRequest {} + +table TrackingChecklistUnassignedHMD { + tracker_id: uint16; +} + +table TrackingChecklistPublicNetworks { + adapters: [string]; +} + +union TrackingChecklistExtraData { + TrackingChecklistTrackerReset, + TrackingChecklistTrackerError, + TrackingChecklistSteamVRDisconnected, + TrackingChecklistUnassignedHMD, + TrackingChecklistNeedCalibration, + TrackingChecklistPublicNetworks +} + +table TrackingChecklistStep { + id: TrackingChecklistStepId; + valid: bool; + // Can hide a step, usefull for step that might not be able to be either be valid or invalid + enabled: bool; + visibility: TrackingChecklistStepVisibility; + // For cases where we dont know for sure if the user should do it or no + // Like start steamvr -> we dont know if they should do it as they might want to use standalone + optional: bool; + // Tell if this step can be put in the ignore list + ignorable: bool; + extra_data: TrackingChecklistExtraData; +} + +table TrackingChecklistRequest {} + +table TrackingChecklistResponse { + // the order of the steps mater + // and steps should be unique + steps: [TrackingChecklistStep]; + // A list of the step ids that will not show up in the ui + // we keep this as a way to re-enable the step from the ui if needed + ignored_steps: [TrackingChecklistStepId]; +} + +// Allows to ignore/unignore check list steps +table IgnoreTrackingChecklistStepRequest { + step_id: TrackingChecklistStepId; + ignore: bool; +} \ No newline at end of file diff --git a/schema/rpc/vmc.fbs b/schema/rpc/vmc.fbs new file mode 100644 index 000000000..31deb1d28 --- /dev/null +++ b/schema/rpc/vmc.fbs @@ -0,0 +1,29 @@ +namespace solarxr_protocol.rpc; + +// VMC settings request and response +table VMCOSCSettingsRequest {} +table VMCOSCSettingsResponse { + enabled: bool; + port_in: uint16; + port_out: uint16; + address: string; + anchor_hip: bool; + mirror_tracking: bool; +} +table ChangeVMCOSCSettingsRequest { + enabled: bool; + port_in: uint16; + port_out: uint16; + address: string; + anchor_hip: bool; + mirror_tracking: bool; +} + +// VRM settings request and response +table VRMSettingsRequest {} +table VRMSettingsResponse { + vrm_json: string; +} +table ChangeVRMSettingsRequest { + vrm_json: string; +} \ No newline at end of file diff --git a/schema/rpc/vrchat.fbs b/schema/rpc/vrchat.fbs new file mode 100644 index 000000000..379112f96 --- /dev/null +++ b/schema/rpc/vrchat.fbs @@ -0,0 +1,79 @@ +namespace solarxr_protocol.rpc; + +enum VRCTrackerModel: uint8 { + UNKNOWN = 0, + SPHERE = 1, + SYSTEM = 2, + BOX = 3, + AXIS = 4, +} + +enum VRCSpineMode: uint8 { + UNKNOWN = 0, + LOCK_HIP = 1, + LOCK_HEAD = 2, + LOCK_BOTH = 3, +} + +enum VRCAvatarMeasurementType: uint8 { + UNKNOWN = 0, + HEIGHT = 1, + ARM_SPAN = 2 +} + +table VRCConfigValidity { + legacy_mode_ok: bool; + shoulder_tracking_ok: bool; + user_height_ok: bool; + calibration_range_ok: bool; + calibration_visuals_ok: bool; + tracker_model_ok: bool; + spine_mode_ok: bool; + avatar_measurement_type_ok: bool; + shoulder_width_compensation_ok: bool; +} + +table VRCConfigValues { + legacy_mode: bool; + shoulder_tracking_disabled: bool; + user_height: float; + calibration_range: float; + calibration_visuals: bool; + tracker_model: VRCTrackerModel; + spine_mode: VRCSpineMode; + avatar_measurement_type: VRCAvatarMeasurementType; + shoulder_width_compensation: bool; +} + +table VRCConfigRecommendedValues { + legacy_mode: bool; + shoulder_tracking_disabled: bool; + user_height: float; + calibration_range: float; + calibration_visuals: bool; + tracker_model: VRCTrackerModel; + spine_mode: [VRCSpineMode]; + avatar_measurement_type: VRCAvatarMeasurementType; + shoulder_width_compensation: bool; +} + +table VRCConfigStateRequest {} + +/// Sent every time the vrchat config state gets updated +/// used to display vrchat missconfig settings to the user +table VRCConfigStateChangeResponse { + is_supported: bool; + validity: VRCConfigValidity; + state: VRCConfigValues; + recommended: VRCConfigRecommendedValues; + /// Just a list of keys from the VRCConfigValidity table. + // Didnt want to make it a full table, because it would be another pain to maintain. Strings are fine for that. + // copium + muted: [string]; +} + +// Mute or unmute a vrc setting warning from its key +table VRCConfigSettingToggleMute { + /// Key from VRCConfigValidity + key: string; +} \ No newline at end of file diff --git a/schema/rpc/vrcosc.fbs b/schema/rpc/vrcosc.fbs new file mode 100644 index 000000000..fea1585d0 --- /dev/null +++ b/schema/rpc/vrcosc.fbs @@ -0,0 +1,69 @@ +namespace solarxr_protocol.rpc; + +table VRCOSCNetworkSettings { + port_in: uint16; + port_out: uint16; + address: string; +} + +table VRCOSCDiscoveredTarget { + name: string; + address: string; + port_out: uint16; +} + +enum VRCOSCInputState : ubyte { + IDLE = 0, + LISTENING, + ERROR, +} + +enum VRCOSCOutputState : ubyte { + IDLE = 0, + READY, + ERROR, +} + +enum VRCOSCTargetSource : ubyte { + NONE = 0, + MANUAL, + DISCOVERED, +} + +enum VRCOSCOscQueryState : ubyte { + DISABLED = 0, + SEARCHING, + FOUND, + ERROR, +} + +// VRChat OSC status request and response +table VRCOSCStatusRequest {} +table VRCOSCStatusChangeResponse { + enabled: bool; + input_state: VRCOSCInputState; + input_port: uint16 = null; + input_error: string; + last_received_input_millis: uint64 = null; + output_state: VRCOSCOutputState; + output_error: string; + target_address: string; + target_port: uint16 = null; + target_source: VRCOSCTargetSource; + last_frame_sent_millis: uint64 = null; + oscquery_state: VRCOSCOscQueryState; + oscquery_advertised_port: uint16 = null; + oscquery_error: string; + discovered_targets: [VRCOSCDiscoveredTarget]; +} + +// VRChat OSC settings request and response +table VRCOSCSettingsRequest {} +table VRCOSCSettingsResponse { + enabled: bool; + manual_network: VRCOSCNetworkSettings; +} +table ChangeVRCOSCSettingsRequest { + enabled: bool; + manual_network: VRCOSCNetworkSettings; +} \ No newline at end of file diff --git a/schema/settings/model.fbs b/schema/settings/model.fbs deleted file mode 100644 index 519375593..000000000 --- a/schema/settings/model.fbs +++ /dev/null @@ -1,53 +0,0 @@ -namespace solarxr_protocol.rpc.settings; - -/// Settings for the skeletal model that are toggles. -table ModelToggles { - extended_spine: bool = null; - extended_pelvis: bool = null; - extended_knee: bool = null; - force_arms_from_hmd: bool = null; - floor_clip: bool = null; - skating_correction: bool = null; - vive_emulation: bool = null (deprecated); - toe_snap: bool = null; - foot_plant: bool = null; - self_localization: bool = null; - use_position: bool = null; - enforce_constraints: bool = null; - correct_constraints: bool = null; -} - -/// Settings for the skeletal model that are ratios. -/// These values range from 0 to 1. -table ModelRatios { - // Guesses missing bones from other bones - // impute_affected_from_A_toB (where 0.0 is A and 1.0 is B) - impute_waist_from_chest_hip: float32 = null; - impute_waist_from_chest_legs: float32 = null; - impute_hip_from_chest_legs: float32 = null; - impute_hip_from_waist_legs: float32 = null; - /// Hip's yaw and roll is set to the average of legs when 1.0 - interp_hip_legs: float32 = null; - /// Knee trackers' yaw and roll is set to the lower leg's when 1.0 - interp_knee_tracker_ankle: float32 = null; - /// Upper leg's yaw and roll is set to the lower leg's when 1.0 - interp_knee_ankle: float32 = null; -} - -// Settings for leg tweaks -table LegTweaksSettings { - correction_strength: float32 = null; -} - -table SkeletonHeight { - hmd_height: float32 = null; - floor_height: float32 = null; -} - -/// Settings for the skeletal model. -table ModelSettings { - toggles: ModelToggles; - ratios: ModelRatios; - leg_tweaks: LegTweaksSettings; - skeleton_height: SkeletonHeight; -} diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 000000000..64ce73ae5 --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,18 @@ +rootProject.name = "solarxr-protocol-dev" + +pluginManagement { + repositories { + gradlePluginPortal() + mavenCentral() + } + plugins { + kotlin("jvm") version "2.3.10" + kotlin("multiplatform") version "2.3.10" + } +} + +include(":generated") +project(":generated").projectDir = file("protocol/kotlin") + +include(":codegen") +project(":codegen").projectDir = file("kotlin-codegen")