From 15aee0b011d0715b97499ffd97d568b3c797e366 Mon Sep 17 00:00:00 2001 From: Sapphire Date: Sun, 17 May 2026 00:21:31 -0500 Subject: [PATCH] Add messages for creating and manipulating created trackers --- .../generated/all_generated.h | 495 +++++++++++++++++- .../rpc/AddTrackerRequest.java | 118 +++++ .../rpc/AddTrackerRequestT.java | 64 +++ .../rpc/AddTrackerResponse.java | 64 +++ .../rpc/AddTrackerResponseT.java | 22 + .../src/solarxr_protocol/rpc/RpcMessage.java | 7 +- .../rpc/RpcMessageHeader.java | 20 + .../solarxr_protocol/rpc/RpcMessageUnion.java | 10 + .../rpc/UpdateTrackerBattery.java | 79 +++ .../rpc/UpdateTrackerBatteryT.java | 34 ++ .../rpc/UpdateTrackerPose.java | 82 +++ .../rpc/UpdateTrackerPoseT.java | 40 ++ .../rpc/UpdateTrackerStatus.java | 69 +++ .../rpc/UpdateTrackerStatusT.java | 28 + .../solarxr_protocol/rpc/AddTrackerRequest.kt | 115 ++++ .../rpc/AddTrackerResponse.kt | 60 +++ .../src/solarxr_protocol/rpc/RpcMessage.kt | 7 +- .../rpc/UpdateTrackerBattery.kt | 77 +++ .../solarxr_protocol/rpc/UpdateTrackerPose.kt | 94 ++++ .../rpc/UpdateTrackerStatus.kt | 66 +++ protocol/rust/src/generated/mod.rs | 10 + .../rpc/add_tracker_request_generated.rs | 228 ++++++++ .../rpc/add_tracker_response_generated.rs | 110 ++++ .../rpc/rpc_message_generated.rs | 26 +- .../rpc/rpc_message_header_generated.rs | 115 ++++ .../rpc/update_tracker_battery_generated.rs | 145 +++++ .../rpc/update_tracker_pose_generated.rs | 164 ++++++ .../rpc/update_tracker_status_generated.rs | 127 +++++ protocol/typescript/src/all_generated.ts | 5 + .../rpc/add-tracker-request.ts | 185 +++++++ .../rpc/add-tracker-response.ts | 81 +++ .../rpc/rpc-message-header.ts | 7 +- .../src/solarxr-protocol/rpc/rpc-message.ts | 30 +- .../rpc/update-tracker-battery.ts | 110 ++++ .../rpc/update-tracker-pose.ts | 125 +++++ .../rpc/update-tracker-status.ts | 94 ++++ schema/rpc.fbs | 54 ++ 37 files changed, 3151 insertions(+), 16 deletions(-) create mode 100644 protocol/java/src/solarxr_protocol/rpc/AddTrackerRequest.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/AddTrackerRequestT.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/AddTrackerResponse.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/AddTrackerResponseT.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBattery.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBatteryT.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPose.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPoseT.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatus.java create mode 100644 protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatusT.java create mode 100644 protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerRequest.kt create mode 100644 protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerResponse.kt create mode 100644 protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerBattery.kt create mode 100644 protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerPose.kt create mode 100644 protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerStatus.kt create mode 100644 protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_request_generated.rs create mode 100644 protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_response_generated.rs create mode 100644 protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_battery_generated.rs create mode 100644 protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_pose_generated.rs create mode 100644 protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_status_generated.rs create mode 100644 protocol/typescript/src/solarxr-protocol/rpc/add-tracker-request.ts create mode 100644 protocol/typescript/src/solarxr-protocol/rpc/add-tracker-response.ts create mode 100644 protocol/typescript/src/solarxr-protocol/rpc/update-tracker-battery.ts create mode 100644 protocol/typescript/src/solarxr-protocol/rpc/update-tracker-pose.ts create mode 100644 protocol/typescript/src/solarxr-protocol/rpc/update-tracker-status.ts diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index 43baeb5a..e927c236 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -524,6 +524,21 @@ struct CancelUserHeightCalibrationBuilder; struct UserHeightRecordingStatusResponse; struct UserHeightRecordingStatusResponseBuilder; +struct AddTrackerRequest; +struct AddTrackerRequestBuilder; + +struct AddTrackerResponse; +struct AddTrackerResponseBuilder; + +struct UpdateTrackerPose; +struct UpdateTrackerPoseBuilder; + +struct UpdateTrackerStatus; +struct UpdateTrackerStatusBuilder; + +struct UpdateTrackerBattery; +struct UpdateTrackerBatteryBuilder; + } // namespace rpc namespace pub_sub { @@ -1421,11 +1436,16 @@ enum class RpcMessage : uint8_t { OpenUriRequest = 84, OpenUriResponse = 85, EnableSteamVRDriverRequest = 86, + AddTrackerRequest = 87, + AddTrackerResponse = 88, + UpdateTrackerPose = 89, + UpdateTrackerStatus = 90, + UpdateTrackerBattery = 91, MIN = NONE, - MAX = EnableSteamVRDriverRequest + MAX = UpdateTrackerBattery }; -inline const RpcMessage (&EnumValuesRpcMessage())[87] { +inline const RpcMessage (&EnumValuesRpcMessage())[92] { static const RpcMessage values[] = { RpcMessage::NONE, RpcMessage::HeartbeatRequest, @@ -1513,13 +1533,18 @@ inline const RpcMessage (&EnumValuesRpcMessage())[87] { RpcMessage::InstalledInfoResponse, RpcMessage::OpenUriRequest, RpcMessage::OpenUriResponse, - RpcMessage::EnableSteamVRDriverRequest + RpcMessage::EnableSteamVRDriverRequest, + RpcMessage::AddTrackerRequest, + RpcMessage::AddTrackerResponse, + RpcMessage::UpdateTrackerPose, + RpcMessage::UpdateTrackerStatus, + RpcMessage::UpdateTrackerBattery }; return values; } inline const char * const *EnumNamesRpcMessage() { - static const char * const names[88] = { + static const char * const names[93] = { "NONE", "HeartbeatRequest", "HeartbeatResponse", @@ -1607,13 +1632,18 @@ inline const char * const *EnumNamesRpcMessage() { "OpenUriRequest", "OpenUriResponse", "EnableSteamVRDriverRequest", + "AddTrackerRequest", + "AddTrackerResponse", + "UpdateTrackerPose", + "UpdateTrackerStatus", + "UpdateTrackerBattery", nullptr }; return names; } inline const char *EnumNameRpcMessage(RpcMessage e) { - if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::EnableSteamVRDriverRequest)) return ""; + if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::UpdateTrackerBattery)) return ""; const size_t index = static_cast(e); return EnumNamesRpcMessage()[index]; } @@ -1966,6 +1996,26 @@ template<> struct RpcMessageTraits struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AddTrackerRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::AddTrackerResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UpdateTrackerPose; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UpdateTrackerStatus; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UpdateTrackerBattery; +}; + bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); @@ -6536,6 +6586,21 @@ struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::rpc::EnableSteamVRDriverRequest *message_as_EnableSteamVRDriverRequest() const { return message_type() == solarxr_protocol::rpc::RpcMessage::EnableSteamVRDriverRequest ? static_cast(message()) : nullptr; } + const solarxr_protocol::rpc::AddTrackerRequest *message_as_AddTrackerRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AddTrackerRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::AddTrackerResponse *message_as_AddTrackerResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::AddTrackerResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::UpdateTrackerPose *message_as_UpdateTrackerPose() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UpdateTrackerPose ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::UpdateTrackerStatus *message_as_UpdateTrackerStatus() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UpdateTrackerStatus ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::UpdateTrackerBattery *message_as_UpdateTrackerBattery() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UpdateTrackerBattery ? static_cast(message()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TX_ID, 4) && @@ -6890,6 +6955,26 @@ template<> inline const solarxr_protocol::rpc::EnableSteamVRDriverRequest *RpcMe return message_as_EnableSteamVRDriverRequest(); } +template<> inline const solarxr_protocol::rpc::AddTrackerRequest *RpcMessageHeader::message_as() const { + return message_as_AddTrackerRequest(); +} + +template<> inline const solarxr_protocol::rpc::AddTrackerResponse *RpcMessageHeader::message_as() const { + return message_as_AddTrackerResponse(); +} + +template<> inline const solarxr_protocol::rpc::UpdateTrackerPose *RpcMessageHeader::message_as() const { + return message_as_UpdateTrackerPose(); +} + +template<> inline const solarxr_protocol::rpc::UpdateTrackerStatus *RpcMessageHeader::message_as() const { + return message_as_UpdateTrackerStatus(); +} + +template<> inline const solarxr_protocol::rpc::UpdateTrackerBattery *RpcMessageHeader::message_as() const { + return message_as_UpdateTrackerBattery(); +} + struct RpcMessageHeaderBuilder { typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -14274,6 +14359,386 @@ inline flatbuffers::Offset CreateUserHeightRe return builder_.Finish(); } +/// Request the server to add a tracker. +struct AddTrackerRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AddTrackerRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_DISPLAY_NAME = 6, + VT_MANUFACTURER = 8, + VT_TRACKS_ROTATION = 10, + VT_TRACKS_ACCELERATION = 12, + VT_TRACKS_POSITION = 14, + VT_ROLE_HINT = 16, + VT_IS_HMD = 18 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const flatbuffers::String *display_name() const { + return GetPointer(VT_DISPLAY_NAME); + } + const flatbuffers::String *manufacturer() const { + return GetPointer(VT_MANUFACTURER); + } + bool tracks_rotation() const { + return GetField(VT_TRACKS_ROTATION, 0) != 0; + } + bool tracks_acceleration() const { + return GetField(VT_TRACKS_ACCELERATION, 0) != 0; + } + bool tracks_position() const { + return GetField(VT_TRACKS_POSITION, 0) != 0; + } + flatbuffers::Optional role_hint() const { + return GetOptional(VT_ROLE_HINT); + } + bool is_hmd() const { + return GetField(VT_IS_HMD, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_DISPLAY_NAME) && + verifier.VerifyString(display_name()) && + VerifyOffset(verifier, VT_MANUFACTURER) && + verifier.VerifyString(manufacturer()) && + VerifyField(verifier, VT_TRACKS_ROTATION, 1) && + VerifyField(verifier, VT_TRACKS_ACCELERATION, 1) && + VerifyField(verifier, VT_TRACKS_POSITION, 1) && + VerifyField(verifier, VT_ROLE_HINT, 1) && + VerifyField(verifier, VT_IS_HMD, 1) && + verifier.EndTable(); + } +}; + +struct AddTrackerRequestBuilder { + typedef AddTrackerRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(AddTrackerRequest::VT_NAME, name); + } + void add_display_name(flatbuffers::Offset display_name) { + fbb_.AddOffset(AddTrackerRequest::VT_DISPLAY_NAME, display_name); + } + void add_manufacturer(flatbuffers::Offset manufacturer) { + fbb_.AddOffset(AddTrackerRequest::VT_MANUFACTURER, manufacturer); + } + void add_tracks_rotation(bool tracks_rotation) { + fbb_.AddElement(AddTrackerRequest::VT_TRACKS_ROTATION, static_cast(tracks_rotation), 0); + } + void add_tracks_acceleration(bool tracks_acceleration) { + fbb_.AddElement(AddTrackerRequest::VT_TRACKS_ACCELERATION, static_cast(tracks_acceleration), 0); + } + void add_tracks_position(bool tracks_position) { + fbb_.AddElement(AddTrackerRequest::VT_TRACKS_POSITION, static_cast(tracks_position), 0); + } + void add_role_hint(solarxr_protocol::datatypes::BodyPart role_hint) { + fbb_.AddElement(AddTrackerRequest::VT_ROLE_HINT, static_cast(role_hint)); + } + void add_is_hmd(bool is_hmd) { + fbb_.AddElement(AddTrackerRequest::VT_IS_HMD, static_cast(is_hmd), 0); + } + explicit AddTrackerRequestBuilder(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 CreateAddTrackerRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset display_name = 0, + flatbuffers::Offset manufacturer = 0, + bool tracks_rotation = false, + bool tracks_acceleration = false, + bool tracks_position = false, + flatbuffers::Optional role_hint = flatbuffers::nullopt, + bool is_hmd = false) { + AddTrackerRequestBuilder builder_(_fbb); + builder_.add_manufacturer(manufacturer); + builder_.add_display_name(display_name); + builder_.add_name(name); + builder_.add_is_hmd(is_hmd); + if(role_hint) { builder_.add_role_hint(*role_hint); } + builder_.add_tracks_position(tracks_position); + builder_.add_tracks_acceleration(tracks_acceleration); + builder_.add_tracks_rotation(tracks_rotation); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateAddTrackerRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const char *display_name = nullptr, + const char *manufacturer = nullptr, + bool tracks_rotation = false, + bool tracks_acceleration = false, + bool tracks_position = false, + flatbuffers::Optional role_hint = flatbuffers::nullopt, + bool is_hmd = false) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0; + auto manufacturer__ = manufacturer ? _fbb.CreateString(manufacturer) : 0; + return solarxr_protocol::rpc::CreateAddTrackerRequest( + _fbb, + name__, + display_name__, + manufacturer__, + tracks_rotation, + tracks_acceleration, + tracks_position, + role_hint, + is_hmd); +} + +/// Response to AddTrackerRequest. Use the transaction ID to check what this is a response to. +struct AddTrackerResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AddTrackerResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4 + }; + /// The ID of the newly created tracker. + 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(); + } +}; + +struct AddTrackerResponseBuilder { + typedef AddTrackerResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tracker_id(flatbuffers::Offset tracker_id) { + fbb_.AddOffset(AddTrackerResponse::VT_TRACKER_ID, tracker_id); + } + explicit AddTrackerResponseBuilder(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 CreateAddTrackerResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset tracker_id = 0) { + AddTrackerResponseBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); + return builder_.Finish(); +} + +/// Update the pose of a tracker created over SolarXR. +/// This will be ignored if the tracker was not created via SolarXR. +struct UpdateTrackerPose FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UpdateTrackerPoseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4, + VT_ROTATION = 6, + VT_POSITION = 8, + VT_RAW_ACCELERATION = 10 + }; + const solarxr_protocol::datatypes::TrackerId *tracker_id() const { + return GetPointer(VT_TRACKER_ID); + } + /// Sensor rotation after fusion + const solarxr_protocol::datatypes::math::Quat *rotation() const { + return GetStruct(VT_ROTATION); + } + /// Position, in meters + const solarxr_protocol::datatypes::math::Vec3f *position() const { + return GetStruct(VT_POSITION); + } + /// Raw acceleration, in m/s^2 + const solarxr_protocol::datatypes::math::Vec3f *raw_acceleration() const { + return GetStruct(VT_RAW_ACCELERATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TRACKER_ID) && + verifier.VerifyTable(tracker_id()) && + VerifyField(verifier, VT_ROTATION, 4) && + VerifyField(verifier, VT_POSITION, 4) && + VerifyField(verifier, VT_RAW_ACCELERATION, 4) && + verifier.EndTable(); + } +}; + +struct UpdateTrackerPoseBuilder { + typedef UpdateTrackerPose Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tracker_id(flatbuffers::Offset tracker_id) { + fbb_.AddOffset(UpdateTrackerPose::VT_TRACKER_ID, tracker_id); + } + void add_rotation(const solarxr_protocol::datatypes::math::Quat *rotation) { + fbb_.AddStruct(UpdateTrackerPose::VT_ROTATION, rotation); + } + void add_position(const solarxr_protocol::datatypes::math::Vec3f *position) { + fbb_.AddStruct(UpdateTrackerPose::VT_POSITION, position); + } + void add_raw_acceleration(const solarxr_protocol::datatypes::math::Vec3f *raw_acceleration) { + fbb_.AddStruct(UpdateTrackerPose::VT_RAW_ACCELERATION, raw_acceleration); + } + explicit UpdateTrackerPoseBuilder(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 CreateUpdateTrackerPose( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset tracker_id = 0, + const solarxr_protocol::datatypes::math::Quat *rotation = nullptr, + const solarxr_protocol::datatypes::math::Vec3f *position = nullptr, + const solarxr_protocol::datatypes::math::Vec3f *raw_acceleration = nullptr) { + UpdateTrackerPoseBuilder builder_(_fbb); + builder_.add_raw_acceleration(raw_acceleration); + builder_.add_position(position); + builder_.add_rotation(rotation); + builder_.add_tracker_id(tracker_id); + return builder_.Finish(); +} + +/// Set the status of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +struct UpdateTrackerStatus FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UpdateTrackerStatusBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4, + VT_STATUS = 6 + }; + const solarxr_protocol::datatypes::TrackerId *tracker_id() const { + return GetPointer(VT_TRACKER_ID); + } + solarxr_protocol::datatypes::TrackerStatus status() const { + return static_cast(GetField(VT_STATUS, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TRACKER_ID) && + verifier.VerifyTable(tracker_id()) && + VerifyField(verifier, VT_STATUS, 1) && + verifier.EndTable(); + } +}; + +struct UpdateTrackerStatusBuilder { + typedef UpdateTrackerStatus Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tracker_id(flatbuffers::Offset tracker_id) { + fbb_.AddOffset(UpdateTrackerStatus::VT_TRACKER_ID, tracker_id); + } + void add_status(solarxr_protocol::datatypes::TrackerStatus status) { + fbb_.AddElement(UpdateTrackerStatus::VT_STATUS, static_cast(status), 0); + } + explicit UpdateTrackerStatusBuilder(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 CreateUpdateTrackerStatus( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset tracker_id = 0, + solarxr_protocol::datatypes::TrackerStatus status = solarxr_protocol::datatypes::TrackerStatus::NONE) { + UpdateTrackerStatusBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); + builder_.add_status(status); + return builder_.Finish(); +} + +/// Set the battery life of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +struct UpdateTrackerBattery FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UpdateTrackerBatteryBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4, + VT_BATTERY_PERCENTAGE = 6, + VT_CHARGING = 8 + }; + const solarxr_protocol::datatypes::TrackerId *tracker_id() const { + return GetPointer(VT_TRACKER_ID); + } + /// 0.0f..=100.0f + float battery_percentage() const { + return GetField(VT_BATTERY_PERCENTAGE, 0.0f); + } + bool charging() const { + return GetField(VT_CHARGING, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TRACKER_ID) && + verifier.VerifyTable(tracker_id()) && + VerifyField(verifier, VT_BATTERY_PERCENTAGE, 4) && + VerifyField(verifier, VT_CHARGING, 1) && + verifier.EndTable(); + } +}; + +struct UpdateTrackerBatteryBuilder { + typedef UpdateTrackerBattery Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tracker_id(flatbuffers::Offset tracker_id) { + fbb_.AddOffset(UpdateTrackerBattery::VT_TRACKER_ID, tracker_id); + } + void add_battery_percentage(float battery_percentage) { + fbb_.AddElement(UpdateTrackerBattery::VT_BATTERY_PERCENTAGE, battery_percentage, 0.0f); + } + void add_charging(bool charging) { + fbb_.AddElement(UpdateTrackerBattery::VT_CHARGING, static_cast(charging), 0); + } + explicit UpdateTrackerBatteryBuilder(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 CreateUpdateTrackerBattery( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset tracker_id = 0, + float battery_percentage = 0.0f, + bool charging = false) { + UpdateTrackerBatteryBuilder builder_(_fbb); + builder_.add_battery_percentage(battery_percentage); + builder_.add_tracker_id(tracker_id); + builder_.add_charging(charging); + return builder_.Finish(); +} + } // namespace rpc namespace pub_sub { @@ -15351,6 +15816,26 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::AddTrackerRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::AddTrackerResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::UpdateTrackerPose: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::UpdateTrackerStatus: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::UpdateTrackerBattery: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequest.java b/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequest.java new file mode 100644 index 00000000..73b59021 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequest.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.*; + +/** + * Request the server to add a tracker. + */ +@SuppressWarnings("unused") +public final class AddTrackerRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static AddTrackerRequest getRootAsAddTrackerRequest(ByteBuffer _bb) { return getRootAsAddTrackerRequest(_bb, new AddTrackerRequest()); } + public static AddTrackerRequest getRootAsAddTrackerRequest(ByteBuffer _bb, AddTrackerRequest 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 AddTrackerRequest __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 displayName() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer displayNameAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer displayNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + public String manufacturer() { int o = __offset(8); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer manufacturerAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } + public ByteBuffer manufacturerInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } + public boolean tracksRotation() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean tracksAcceleration() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean tracksPosition() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean hasRoleHint() { return 0 != __offset(16); } + public int roleHint() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean isHmd() { int o = __offset(18); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createAddTrackerRequest(FlatBufferBuilder builder, + int nameOffset, + int displayNameOffset, + int manufacturerOffset, + boolean tracksRotation, + boolean tracksAcceleration, + boolean tracksPosition, + int roleHint, + boolean isHmd) { + builder.startTable(8); + AddTrackerRequest.addManufacturer(builder, manufacturerOffset); + AddTrackerRequest.addDisplayName(builder, displayNameOffset); + AddTrackerRequest.addName(builder, nameOffset); + AddTrackerRequest.addIsHmd(builder, isHmd); + AddTrackerRequest.addRoleHint(builder, roleHint); + AddTrackerRequest.addTracksPosition(builder, tracksPosition); + AddTrackerRequest.addTracksAcceleration(builder, tracksAcceleration); + AddTrackerRequest.addTracksRotation(builder, tracksRotation); + return AddTrackerRequest.endAddTrackerRequest(builder); + } + + public static void startAddTrackerRequest(FlatBufferBuilder builder) { builder.startTable(8); } + public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(0, nameOffset, 0); } + public static void addDisplayName(FlatBufferBuilder builder, int displayNameOffset) { builder.addOffset(1, displayNameOffset, 0); } + public static void addManufacturer(FlatBufferBuilder builder, int manufacturerOffset) { builder.addOffset(2, manufacturerOffset, 0); } + public static void addTracksRotation(FlatBufferBuilder builder, boolean tracksRotation) { builder.addBoolean(3, tracksRotation, false); } + public static void addTracksAcceleration(FlatBufferBuilder builder, boolean tracksAcceleration) { builder.addBoolean(4, tracksAcceleration, false); } + public static void addTracksPosition(FlatBufferBuilder builder, boolean tracksPosition) { builder.addBoolean(5, tracksPosition, false); } + public static void addRoleHint(FlatBufferBuilder builder, int roleHint) { builder.addByte(6, (byte) roleHint, (byte) 0); } + public static void addIsHmd(FlatBufferBuilder builder, boolean isHmd) { builder.addBoolean(7, isHmd, false); } + public static int endAddTrackerRequest(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 AddTrackerRequest get(int j) { return get(new AddTrackerRequest(), j); } + public AddTrackerRequest get(AddTrackerRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public AddTrackerRequestT unpack() { + AddTrackerRequestT _o = new AddTrackerRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(AddTrackerRequestT _o) { + String _oName = name(); + _o.setName(_oName); + String _oDisplayName = displayName(); + _o.setDisplayName(_oDisplayName); + String _oManufacturer = manufacturer(); + _o.setManufacturer(_oManufacturer); + boolean _oTracksRotation = tracksRotation(); + _o.setTracksRotation(_oTracksRotation); + boolean _oTracksAcceleration = tracksAcceleration(); + _o.setTracksAcceleration(_oTracksAcceleration); + boolean _oTracksPosition = tracksPosition(); + _o.setTracksPosition(_oTracksPosition); + Integer _oRoleHint = hasRoleHint() ? roleHint() : null; + _o.setRoleHint(_oRoleHint); + boolean _oIsHmd = isHmd(); + _o.setIsHmd(_oIsHmd); + } + public static int pack(FlatBufferBuilder builder, AddTrackerRequestT _o) { + if (_o == null) return 0; + int _name = _o.getName() == null ? 0 : builder.createString(_o.getName()); + int _displayName = _o.getDisplayName() == null ? 0 : builder.createString(_o.getDisplayName()); + int _manufacturer = _o.getManufacturer() == null ? 0 : builder.createString(_o.getManufacturer()); + return createAddTrackerRequest( + builder, + _name, + _displayName, + _manufacturer, + _o.getTracksRotation(), + _o.getTracksAcceleration(), + _o.getTracksPosition(), + _o.getRoleHint(), + _o.getIsHmd()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequestT.java b/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequestT.java new file mode 100644 index 00000000..bcf68136 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/AddTrackerRequestT.java @@ -0,0 +1,64 @@ +// 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 AddTrackerRequestT { + private String name; + private String displayName; + private String manufacturer; + private boolean tracksRotation; + private boolean tracksAcceleration; + private boolean tracksPosition; + private Integer roleHint; + private boolean isHmd; + + public String getName() { return name; } + + public void setName(String name) { this.name = name; } + + public String getDisplayName() { return displayName; } + + public void setDisplayName(String displayName) { this.displayName = displayName; } + + public String getManufacturer() { return manufacturer; } + + public void setManufacturer(String manufacturer) { this.manufacturer = manufacturer; } + + public boolean getTracksRotation() { return tracksRotation; } + + public void setTracksRotation(boolean tracksRotation) { this.tracksRotation = tracksRotation; } + + public boolean getTracksAcceleration() { return tracksAcceleration; } + + public void setTracksAcceleration(boolean tracksAcceleration) { this.tracksAcceleration = tracksAcceleration; } + + public boolean getTracksPosition() { return tracksPosition; } + + public void setTracksPosition(boolean tracksPosition) { this.tracksPosition = tracksPosition; } + + public Integer getRoleHint() { return roleHint; } + + public void setRoleHint(Integer roleHint) { this.roleHint = roleHint; } + + public boolean getIsHmd() { return isHmd; } + + public void setIsHmd(boolean isHmd) { this.isHmd = isHmd; } + + + public AddTrackerRequestT() { + this.name = null; + this.displayName = null; + this.manufacturer = null; + this.tracksRotation = false; + this.tracksAcceleration = false; + this.tracksPosition = false; + this.roleHint = null; + this.isHmd = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponse.java b/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponse.java new file mode 100644 index 00000000..cabf83cf --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponse.java @@ -0,0 +1,64 @@ +// 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 to AddTrackerRequest. Use the transaction ID to check what this is a response to. + */ +@SuppressWarnings("unused") +public final class AddTrackerResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static AddTrackerResponse getRootAsAddTrackerResponse(ByteBuffer _bb) { return getRootAsAddTrackerResponse(_bb, new AddTrackerResponse()); } + public static AddTrackerResponse getRootAsAddTrackerResponse(ByteBuffer _bb, AddTrackerResponse 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 AddTrackerResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + /** + * The ID of the newly created tracker. + */ + 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 createAddTrackerResponse(FlatBufferBuilder builder, + int trackerIdOffset) { + builder.startTable(1); + AddTrackerResponse.addTrackerId(builder, trackerIdOffset); + return AddTrackerResponse.endAddTrackerResponse(builder); + } + + public static void startAddTrackerResponse(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static int endAddTrackerResponse(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 AddTrackerResponse get(int j) { return get(new AddTrackerResponse(), j); } + public AddTrackerResponse get(AddTrackerResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public AddTrackerResponseT unpack() { + AddTrackerResponseT _o = new AddTrackerResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(AddTrackerResponseT _o) { + if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); + else _o.setTrackerId(null); + } + public static int pack(FlatBufferBuilder builder, AddTrackerResponseT _o) { + if (_o == null) return 0; + int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + return createAddTrackerResponse( + builder, + _trackerId); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponseT.java b/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponseT.java new file mode 100644 index 00000000..8b6a8907 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/AddTrackerResponseT.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 AddTrackerResponseT { + 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 AddTrackerResponseT() { + this.trackerId = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index 5a8bc48f..9f2852dd 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -92,8 +92,13 @@ private RpcMessage() { } public static final byte OpenUriRequest = 84; public static final byte OpenUriResponse = 85; public static final byte EnableSteamVRDriverRequest = 86; + public static final byte AddTrackerRequest = 87; + public static final byte AddTrackerResponse = 88; + public static final byte UpdateTrackerPose = 89; + public static final byte UpdateTrackerStatus = 90; + public static final byte UpdateTrackerBattery = 91; - 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", "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", "AddTrackerRequest", "AddTrackerResponse", "UpdateTrackerPose", "UpdateTrackerStatus", "UpdateTrackerBattery", }; 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 619cf461..081c0683 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -396,6 +396,26 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.EnableSteamVRDriverRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.EnableSteamVRDriverRequest) _oMessageValue).unpack() : null); break; + case solarxr_protocol.rpc.RpcMessage.AddTrackerRequest: + _oMessageValue = message(new solarxr_protocol.rpc.AddTrackerRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.AddTrackerRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.AddTrackerResponse: + _oMessageValue = message(new solarxr_protocol.rpc.AddTrackerResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.AddTrackerResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.UpdateTrackerPose: + _oMessageValue = message(new solarxr_protocol.rpc.UpdateTrackerPose()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UpdateTrackerPose) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.UpdateTrackerStatus: + _oMessageValue = message(new solarxr_protocol.rpc.UpdateTrackerStatus()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UpdateTrackerStatus) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.UpdateTrackerBattery: + _oMessageValue = message(new solarxr_protocol.rpc.UpdateTrackerBattery()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UpdateTrackerBattery) _oMessageValue).unpack() : null); + break; default: break; } _o.setMessage(_oMessage); diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java index 58617afb..97cb1a4b 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -107,6 +107,11 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.OpenUriRequestT asOpenUriRequest() { return (solarxr_protocol.rpc.OpenUriRequestT) value; } public solarxr_protocol.rpc.OpenUriResponseT asOpenUriResponse() { return (solarxr_protocol.rpc.OpenUriResponseT) value; } public solarxr_protocol.rpc.EnableSteamVRDriverRequestT asEnableSteamVRDriverRequest() { return (solarxr_protocol.rpc.EnableSteamVRDriverRequestT) value; } + public solarxr_protocol.rpc.AddTrackerRequestT asAddTrackerRequest() { return (solarxr_protocol.rpc.AddTrackerRequestT) value; } + public solarxr_protocol.rpc.AddTrackerResponseT asAddTrackerResponse() { return (solarxr_protocol.rpc.AddTrackerResponseT) value; } + public solarxr_protocol.rpc.UpdateTrackerPoseT asUpdateTrackerPose() { return (solarxr_protocol.rpc.UpdateTrackerPoseT) value; } + public solarxr_protocol.rpc.UpdateTrackerStatusT asUpdateTrackerStatus() { return (solarxr_protocol.rpc.UpdateTrackerStatusT) value; } + public solarxr_protocol.rpc.UpdateTrackerBatteryT asUpdateTrackerBattery() { return (solarxr_protocol.rpc.UpdateTrackerBatteryT) value; } public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { switch (_o.type) { @@ -196,6 +201,11 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.OpenUriRequest: return solarxr_protocol.rpc.OpenUriRequest.pack(builder, _o.asOpenUriRequest()); case RpcMessage.OpenUriResponse: return solarxr_protocol.rpc.OpenUriResponse.pack(builder, _o.asOpenUriResponse()); case RpcMessage.EnableSteamVRDriverRequest: return solarxr_protocol.rpc.EnableSteamVRDriverRequest.pack(builder, _o.asEnableSteamVRDriverRequest()); + case RpcMessage.AddTrackerRequest: return solarxr_protocol.rpc.AddTrackerRequest.pack(builder, _o.asAddTrackerRequest()); + case RpcMessage.AddTrackerResponse: return solarxr_protocol.rpc.AddTrackerResponse.pack(builder, _o.asAddTrackerResponse()); + case RpcMessage.UpdateTrackerPose: return solarxr_protocol.rpc.UpdateTrackerPose.pack(builder, _o.asUpdateTrackerPose()); + case RpcMessage.UpdateTrackerStatus: return solarxr_protocol.rpc.UpdateTrackerStatus.pack(builder, _o.asUpdateTrackerStatus()); + case RpcMessage.UpdateTrackerBattery: return solarxr_protocol.rpc.UpdateTrackerBattery.pack(builder, _o.asUpdateTrackerBattery()); default: return 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBattery.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBattery.java new file mode 100644 index 00000000..8b458bb6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBattery.java @@ -0,0 +1,79 @@ +// 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.*; + +/** + * Set the battery life of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +@SuppressWarnings("unused") +public final class UpdateTrackerBattery extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static UpdateTrackerBattery getRootAsUpdateTrackerBattery(ByteBuffer _bb) { return getRootAsUpdateTrackerBattery(_bb, new UpdateTrackerBattery()); } + public static UpdateTrackerBattery getRootAsUpdateTrackerBattery(ByteBuffer _bb, UpdateTrackerBattery 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 UpdateTrackerBattery __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; } + /** + * 0.0f..=100.0f + */ + public float batteryPercentage() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean charging() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createUpdateTrackerBattery(FlatBufferBuilder builder, + int trackerIdOffset, + float batteryPercentage, + boolean charging) { + builder.startTable(3); + UpdateTrackerBattery.addBatteryPercentage(builder, batteryPercentage); + UpdateTrackerBattery.addTrackerId(builder, trackerIdOffset); + UpdateTrackerBattery.addCharging(builder, charging); + return UpdateTrackerBattery.endUpdateTrackerBattery(builder); + } + + public static void startUpdateTrackerBattery(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addBatteryPercentage(FlatBufferBuilder builder, float batteryPercentage) { builder.addFloat(1, batteryPercentage, 0.0f); } + public static void addCharging(FlatBufferBuilder builder, boolean charging) { builder.addBoolean(2, charging, false); } + public static int endUpdateTrackerBattery(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 UpdateTrackerBattery get(int j) { return get(new UpdateTrackerBattery(), j); } + public UpdateTrackerBattery get(UpdateTrackerBattery obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public UpdateTrackerBatteryT unpack() { + UpdateTrackerBatteryT _o = new UpdateTrackerBatteryT(); + unpackTo(_o); + return _o; + } + public void unpackTo(UpdateTrackerBatteryT _o) { + if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); + else _o.setTrackerId(null); + float _oBatteryPercentage = batteryPercentage(); + _o.setBatteryPercentage(_oBatteryPercentage); + boolean _oCharging = charging(); + _o.setCharging(_oCharging); + } + public static int pack(FlatBufferBuilder builder, UpdateTrackerBatteryT _o) { + if (_o == null) return 0; + int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + return createUpdateTrackerBattery( + builder, + _trackerId, + _o.getBatteryPercentage(), + _o.getCharging()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBatteryT.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBatteryT.java new file mode 100644 index 00000000..86a5316d --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerBatteryT.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 UpdateTrackerBatteryT { + private solarxr_protocol.datatypes.TrackerIdT trackerId; + private float batteryPercentage; + private boolean charging; + + public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + + public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + + public float getBatteryPercentage() { return batteryPercentage; } + + public void setBatteryPercentage(float batteryPercentage) { this.batteryPercentage = batteryPercentage; } + + public boolean getCharging() { return charging; } + + public void setCharging(boolean charging) { this.charging = charging; } + + + public UpdateTrackerBatteryT() { + this.trackerId = null; + this.batteryPercentage = 0.0f; + this.charging = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPose.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPose.java new file mode 100644 index 00000000..fb5c7531 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPose.java @@ -0,0 +1,82 @@ +// 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.*; + +/** + * Update the pose of a tracker created over SolarXR. + * This will be ignored if the tracker was not created via SolarXR. + */ +@SuppressWarnings("unused") +public final class UpdateTrackerPose extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static UpdateTrackerPose getRootAsUpdateTrackerPose(ByteBuffer _bb) { return getRootAsUpdateTrackerPose(_bb, new UpdateTrackerPose()); } + public static UpdateTrackerPose getRootAsUpdateTrackerPose(ByteBuffer _bb, UpdateTrackerPose 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 UpdateTrackerPose __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; } + /** + * 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(6); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + /** + * Position, in meters + */ + 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(8); 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(10); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + + public static void startUpdateTrackerPose(FlatBufferBuilder builder) { builder.startTable(4); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addRotation(FlatBufferBuilder builder, int rotationOffset) { builder.addStruct(1, rotationOffset, 0); } + public static void addPosition(FlatBufferBuilder builder, int positionOffset) { builder.addStruct(2, positionOffset, 0); } + public static void addRawAcceleration(FlatBufferBuilder builder, int rawAccelerationOffset) { builder.addStruct(3, rawAccelerationOffset, 0); } + public static int endUpdateTrackerPose(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 UpdateTrackerPose get(int j) { return get(new UpdateTrackerPose(), j); } + public UpdateTrackerPose get(UpdateTrackerPose obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public UpdateTrackerPoseT unpack() { + UpdateTrackerPoseT _o = new UpdateTrackerPoseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(UpdateTrackerPoseT _o) { + if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); + else _o.setTrackerId(null); + if (rotation() != null) rotation().unpackTo(_o.getRotation()); + else _o.setRotation(null); + if (position() != null) position().unpackTo(_o.getPosition()); + else _o.setPosition(null); + if (rawAcceleration() != null) rawAcceleration().unpackTo(_o.getRawAcceleration()); + else _o.setRawAcceleration(null); + } + public static int pack(FlatBufferBuilder builder, UpdateTrackerPoseT _o) { + if (_o == null) return 0; + int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + startUpdateTrackerPose(builder); + addTrackerId(builder, _trackerId); + addRotation(builder, solarxr_protocol.datatypes.math.Quat.pack(builder, _o.getRotation())); + addPosition(builder, solarxr_protocol.datatypes.math.Vec3f.pack(builder, _o.getPosition())); + addRawAcceleration(builder, solarxr_protocol.datatypes.math.Vec3f.pack(builder, _o.getRawAcceleration())); + return endUpdateTrackerPose(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPoseT.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPoseT.java new file mode 100644 index 00000000..595d12f9 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerPoseT.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 UpdateTrackerPoseT { + private solarxr_protocol.datatypes.TrackerIdT trackerId; + private solarxr_protocol.datatypes.math.QuatT rotation; + private solarxr_protocol.datatypes.math.Vec3fT position; + private solarxr_protocol.datatypes.math.Vec3fT rawAcceleration; + + public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + + public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + + public solarxr_protocol.datatypes.math.QuatT getRotation() { return rotation; } + + public void setRotation(solarxr_protocol.datatypes.math.QuatT rotation) { this.rotation = rotation; } + + public solarxr_protocol.datatypes.math.Vec3fT getPosition() { return position; } + + public void setPosition(solarxr_protocol.datatypes.math.Vec3fT position) { this.position = position; } + + public solarxr_protocol.datatypes.math.Vec3fT getRawAcceleration() { return rawAcceleration; } + + public void setRawAcceleration(solarxr_protocol.datatypes.math.Vec3fT rawAcceleration) { this.rawAcceleration = rawAcceleration; } + + + public UpdateTrackerPoseT() { + this.trackerId = null; + this.rotation = new solarxr_protocol.datatypes.math.QuatT(); + this.position = new solarxr_protocol.datatypes.math.Vec3fT(); + this.rawAcceleration = new solarxr_protocol.datatypes.math.Vec3fT(); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatus.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatus.java new file mode 100644 index 00000000..71bcc049 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatus.java @@ -0,0 +1,69 @@ +// 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.*; + +/** + * Set the status of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +@SuppressWarnings("unused") +public final class UpdateTrackerStatus extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static UpdateTrackerStatus getRootAsUpdateTrackerStatus(ByteBuffer _bb) { return getRootAsUpdateTrackerStatus(_bb, new UpdateTrackerStatus()); } + public static UpdateTrackerStatus getRootAsUpdateTrackerStatus(ByteBuffer _bb, UpdateTrackerStatus 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 UpdateTrackerStatus __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 status() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + + public static int createUpdateTrackerStatus(FlatBufferBuilder builder, + int trackerIdOffset, + int status) { + builder.startTable(2); + UpdateTrackerStatus.addTrackerId(builder, trackerIdOffset); + UpdateTrackerStatus.addStatus(builder, status); + return UpdateTrackerStatus.endUpdateTrackerStatus(builder); + } + + public static void startUpdateTrackerStatus(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static void addStatus(FlatBufferBuilder builder, int status) { builder.addByte(1, (byte) status, (byte) 0); } + public static int endUpdateTrackerStatus(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 UpdateTrackerStatus get(int j) { return get(new UpdateTrackerStatus(), j); } + public UpdateTrackerStatus get(UpdateTrackerStatus obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public UpdateTrackerStatusT unpack() { + UpdateTrackerStatusT _o = new UpdateTrackerStatusT(); + unpackTo(_o); + return _o; + } + public void unpackTo(UpdateTrackerStatusT _o) { + if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); + else _o.setTrackerId(null); + int _oStatus = status(); + _o.setStatus(_oStatus); + } + public static int pack(FlatBufferBuilder builder, UpdateTrackerStatusT _o) { + if (_o == null) return 0; + int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + return createUpdateTrackerStatus( + builder, + _trackerId, + _o.getStatus()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatusT.java b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatusT.java new file mode 100644 index 00000000..d760b919 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UpdateTrackerStatusT.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 UpdateTrackerStatusT { + private solarxr_protocol.datatypes.TrackerIdT trackerId; + private int status; + + public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + + public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + + public int getStatus() { return status; } + + public void setStatus(int status) { this.status = status; } + + + public UpdateTrackerStatusT() { + this.trackerId = null; + this.status = 0; + } +} + diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerRequest.kt new file mode 100644 index 00000000..18557113 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerRequest.kt @@ -0,0 +1,115 @@ +// 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 the server to add a tracker. + */ +@Suppress("unused") +class AddTrackerRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : AddTrackerRequest { + __init(_i, _bb) + return this + } + val name : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val nameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun nameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + 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) + val manufacturer : String? + get() { + val o = __offset(8) + return if (o != 0) __string(o + bb_pos) else null + } + val manufacturerAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) + fun manufacturerInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) + val tracksRotation : Boolean + get() { + val o = __offset(10) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val tracksAcceleration : Boolean + get() { + val o = __offset(12) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val tracksPosition : Boolean + get() { + val o = __offset(14) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val roleHint : UByte? + get() { + val o = __offset(16) + return if(o != 0) bb.get(o + bb_pos).toUByte() else null + } + val isHmd : 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 getRootAsAddTrackerRequest(_bb: ByteBuffer): AddTrackerRequest = getRootAsAddTrackerRequest(_bb, AddTrackerRequest()) + @JvmStatic + fun getRootAsAddTrackerRequest(_bb: ByteBuffer, obj: AddTrackerRequest): AddTrackerRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createAddTrackerRequest(builder: FlatBufferBuilder, nameOffset: Int, displayNameOffset: Int, manufacturerOffset: Int, tracksRotation: Boolean, tracksAcceleration: Boolean, tracksPosition: Boolean, roleHint: UByte?, isHmd: Boolean) : Int { + builder.startTable(8) + addManufacturer(builder, manufacturerOffset) + addDisplayName(builder, displayNameOffset) + addName(builder, nameOffset) + addIsHmd(builder, isHmd) + roleHint?.run { addRoleHint(builder, roleHint) } + addTracksPosition(builder, tracksPosition) + addTracksAcceleration(builder, tracksAcceleration) + addTracksRotation(builder, tracksRotation) + return endAddTrackerRequest(builder) + } + @JvmStatic + fun startAddTrackerRequest(builder: FlatBufferBuilder) = builder.startTable(8) + @JvmStatic + fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(0, name, 0) + @JvmStatic + fun addDisplayName(builder: FlatBufferBuilder, displayName: Int) = builder.addOffset(1, displayName, 0) + @JvmStatic + fun addManufacturer(builder: FlatBufferBuilder, manufacturer: Int) = builder.addOffset(2, manufacturer, 0) + @JvmStatic + fun addTracksRotation(builder: FlatBufferBuilder, tracksRotation: Boolean) = builder.addBoolean(3, tracksRotation, false) + @JvmStatic + fun addTracksAcceleration(builder: FlatBufferBuilder, tracksAcceleration: Boolean) = builder.addBoolean(4, tracksAcceleration, false) + @JvmStatic + fun addTracksPosition(builder: FlatBufferBuilder, tracksPosition: Boolean) = builder.addBoolean(5, tracksPosition, false) + @JvmStatic + fun addRoleHint(builder: FlatBufferBuilder, roleHint: UByte) = builder.addByte(6, roleHint.toByte(), 0) + @JvmStatic + fun addIsHmd(builder: FlatBufferBuilder, isHmd: Boolean) = builder.addBoolean(7, isHmd, false) + @JvmStatic + fun endAddTrackerRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerResponse.kt new file mode 100644 index 00000000..09ad807b --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/AddTrackerResponse.kt @@ -0,0 +1,60 @@ +// 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 to AddTrackerRequest. Use the transaction ID to check what this is a response to. + */ +@Suppress("unused") +class AddTrackerResponse : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : AddTrackerResponse { + __init(_i, _bb) + return this + } + /** + * The ID of the newly created tracker. + */ + 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 getRootAsAddTrackerResponse(_bb: ByteBuffer): AddTrackerResponse = getRootAsAddTrackerResponse(_bb, AddTrackerResponse()) + @JvmStatic + fun getRootAsAddTrackerResponse(_bb: ByteBuffer, obj: AddTrackerResponse): AddTrackerResponse { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createAddTrackerResponse(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { + builder.startTable(1) + addTrackerId(builder, trackerIdOffset) + return endAddTrackerResponse(builder) + } + @JvmStatic + fun startAddTrackerResponse(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) + @JvmStatic + fun endAddTrackerResponse(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt index 54cc2345..7d56bd58 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt @@ -92,7 +92,12 @@ class RpcMessage private constructor() { const val OpenUriRequest: UByte = 84u const val OpenUriResponse: UByte = 85u const val EnableSteamVRDriverRequest: UByte = 86u - val names : Array = arrayOf("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") + const val AddTrackerRequest: UByte = 87u + const val AddTrackerResponse: UByte = 88u + const val UpdateTrackerPose: UByte = 89u + const val UpdateTrackerStatus: UByte = 90u + const val UpdateTrackerBattery: UByte = 91u + val names : Array = arrayOf("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", "AddTrackerRequest", "AddTrackerResponse", "UpdateTrackerPose", "UpdateTrackerStatus", "UpdateTrackerBattery") @JvmStatic fun name(e: Int) : String = names[e] } diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerBattery.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerBattery.kt new file mode 100644 index 00000000..fef7992d --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerBattery.kt @@ -0,0 +1,77 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Set the battery life of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +@Suppress("unused") +class UpdateTrackerBattery : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : UpdateTrackerBattery { + __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 + } + } + /** + * 0.0f..=100.0f + */ + val batteryPercentage : Float + get() { + val o = __offset(6) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + val charging : 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 getRootAsUpdateTrackerBattery(_bb: ByteBuffer): UpdateTrackerBattery = getRootAsUpdateTrackerBattery(_bb, UpdateTrackerBattery()) + @JvmStatic + fun getRootAsUpdateTrackerBattery(_bb: ByteBuffer, obj: UpdateTrackerBattery): UpdateTrackerBattery { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createUpdateTrackerBattery(builder: FlatBufferBuilder, trackerIdOffset: Int, batteryPercentage: Float, charging: Boolean) : Int { + builder.startTable(3) + addBatteryPercentage(builder, batteryPercentage) + addTrackerId(builder, trackerIdOffset) + addCharging(builder, charging) + return endUpdateTrackerBattery(builder) + } + @JvmStatic + fun startUpdateTrackerBattery(builder: FlatBufferBuilder) = builder.startTable(3) + @JvmStatic + fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) + @JvmStatic + fun addBatteryPercentage(builder: FlatBufferBuilder, batteryPercentage: Float) = builder.addFloat(1, batteryPercentage, 0.0) + @JvmStatic + fun addCharging(builder: FlatBufferBuilder, charging: Boolean) = builder.addBoolean(2, charging, false) + @JvmStatic + fun endUpdateTrackerBattery(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerPose.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerPose.kt new file mode 100644 index 00000000..e0663b99 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerPose.kt @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Update the pose of a tracker created over SolarXR. + * This will be ignored if the tracker was not created via SolarXR. + */ +@Suppress("unused") +class UpdateTrackerPose : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : UpdateTrackerPose { + __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 + } + } + /** + * 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(6) + 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(8) + 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(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 getRootAsUpdateTrackerPose(_bb: ByteBuffer): UpdateTrackerPose = getRootAsUpdateTrackerPose(_bb, UpdateTrackerPose()) + @JvmStatic + fun getRootAsUpdateTrackerPose(_bb: ByteBuffer, obj: UpdateTrackerPose): UpdateTrackerPose { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun startUpdateTrackerPose(builder: FlatBufferBuilder) = builder.startTable(4) + @JvmStatic + fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) + @JvmStatic + fun addRotation(builder: FlatBufferBuilder, rotation: Int) = builder.addStruct(1, rotation, 0) + @JvmStatic + fun addPosition(builder: FlatBufferBuilder, position: Int) = builder.addStruct(2, position, 0) + @JvmStatic + fun addRawAcceleration(builder: FlatBufferBuilder, rawAcceleration: Int) = builder.addStruct(3, rawAcceleration, 0) + @JvmStatic + fun endUpdateTrackerPose(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerStatus.kt new file mode 100644 index 00000000..53aeadb0 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/UpdateTrackerStatus.kt @@ -0,0 +1,66 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Set the status of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +@Suppress("unused") +class UpdateTrackerStatus : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : UpdateTrackerStatus { + __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 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 getRootAsUpdateTrackerStatus(_bb: ByteBuffer): UpdateTrackerStatus = getRootAsUpdateTrackerStatus(_bb, UpdateTrackerStatus()) + @JvmStatic + fun getRootAsUpdateTrackerStatus(_bb: ByteBuffer, obj: UpdateTrackerStatus): UpdateTrackerStatus { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createUpdateTrackerStatus(builder: FlatBufferBuilder, trackerIdOffset: Int, status: UByte) : Int { + builder.startTable(2) + addTrackerId(builder, trackerIdOffset) + addStatus(builder, status) + return endUpdateTrackerStatus(builder) + } + @JvmStatic + fun startUpdateTrackerStatus(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) + @JvmStatic + fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(1, status.toByte(), 0) + @JvmStatic + fun endUpdateTrackerStatus(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 d141950c..91d202f7 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -442,6 +442,16 @@ pub mod solarxr_protocol { 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 add_tracker_request_generated; + pub use self::add_tracker_request_generated::*; + mod add_tracker_response_generated; + pub use self::add_tracker_response_generated::*; + mod update_tracker_pose_generated; + pub use self::update_tracker_pose_generated::*; + mod update_tracker_status_generated; + pub use self::update_tracker_status_generated::*; + mod update_tracker_battery_generated; + pub use self::update_tracker_battery_generated::*; } // rpc mod message_bundle_generated; pub use self::message_bundle_generated::*; diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_request_generated.rs new file mode 100644 index 00000000..dbcfd369 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_request_generated.rs @@ -0,0 +1,228 @@ +// 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 AddTrackerRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Request the server to add a tracker. +pub struct AddTrackerRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for AddTrackerRequest<'a> { + type Inner = AddTrackerRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> AddTrackerRequest<'a> { + pub const VT_NAME: flatbuffers::VOffsetT = 4; + pub const VT_DISPLAY_NAME: flatbuffers::VOffsetT = 6; + pub const VT_MANUFACTURER: flatbuffers::VOffsetT = 8; + pub const VT_TRACKS_ROTATION: flatbuffers::VOffsetT = 10; + pub const VT_TRACKS_ACCELERATION: flatbuffers::VOffsetT = 12; + pub const VT_TRACKS_POSITION: flatbuffers::VOffsetT = 14; + pub const VT_ROLE_HINT: flatbuffers::VOffsetT = 16; + pub const VT_IS_HMD: flatbuffers::VOffsetT = 18; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + AddTrackerRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args AddTrackerRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = AddTrackerRequestBuilder::new(_fbb); + if let Some(x) = args.manufacturer { builder.add_manufacturer(x); } + if let Some(x) = args.display_name { builder.add_display_name(x); } + if let Some(x) = args.name { builder.add_name(x); } + builder.add_is_hmd(args.is_hmd); + if let Some(x) = args.role_hint { builder.add_role_hint(x); } + builder.add_tracks_position(args.tracks_position); + builder.add_tracks_acceleration(args.tracks_acceleration); + builder.add_tracks_rotation(args.tracks_rotation); + 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::>(AddTrackerRequest::VT_NAME, None)} + } + #[inline] + pub fn display_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::>(AddTrackerRequest::VT_DISPLAY_NAME, None)} + } + #[inline] + pub fn manufacturer(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(AddTrackerRequest::VT_MANUFACTURER, None)} + } + #[inline] + pub fn tracks_rotation(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(AddTrackerRequest::VT_TRACKS_ROTATION, Some(false)).unwrap()} + } + #[inline] + pub fn tracks_acceleration(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(AddTrackerRequest::VT_TRACKS_ACCELERATION, Some(false)).unwrap()} + } + #[inline] + pub fn tracks_position(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(AddTrackerRequest::VT_TRACKS_POSITION, Some(false)).unwrap()} + } + #[inline] + pub fn role_hint(&self) -> Option { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(AddTrackerRequest::VT_ROLE_HINT, None)} + } + #[inline] + pub fn is_hmd(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(AddTrackerRequest::VT_IS_HMD, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for AddTrackerRequest<'_> { + #[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::>("display_name", Self::VT_DISPLAY_NAME, false)? + .visit_field::>("manufacturer", Self::VT_MANUFACTURER, false)? + .visit_field::("tracks_rotation", Self::VT_TRACKS_ROTATION, false)? + .visit_field::("tracks_acceleration", Self::VT_TRACKS_ACCELERATION, false)? + .visit_field::("tracks_position", Self::VT_TRACKS_POSITION, false)? + .visit_field::("role_hint", Self::VT_ROLE_HINT, false)? + .visit_field::("is_hmd", Self::VT_IS_HMD, false)? + .finish(); + Ok(()) + } +} +pub struct AddTrackerRequestArgs<'a> { + pub name: Option>, + pub display_name: Option>, + pub manufacturer: Option>, + pub tracks_rotation: bool, + pub tracks_acceleration: bool, + pub tracks_position: bool, + pub role_hint: Option, + pub is_hmd: bool, +} +impl<'a> Default for AddTrackerRequestArgs<'a> { + #[inline] + fn default() -> Self { + AddTrackerRequestArgs { + name: None, + display_name: None, + manufacturer: None, + tracks_rotation: false, + tracks_acceleration: false, + tracks_position: false, + role_hint: None, + is_hmd: false, + } + } +} + +pub struct AddTrackerRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> AddTrackerRequestBuilder<'a, 'b> { + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(AddTrackerRequest::VT_NAME, name); + } + #[inline] + pub fn add_display_name(&mut self, display_name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(AddTrackerRequest::VT_DISPLAY_NAME, display_name); + } + #[inline] + pub fn add_manufacturer(&mut self, manufacturer: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(AddTrackerRequest::VT_MANUFACTURER, manufacturer); + } + #[inline] + pub fn add_tracks_rotation(&mut self, tracks_rotation: bool) { + self.fbb_.push_slot::(AddTrackerRequest::VT_TRACKS_ROTATION, tracks_rotation, false); + } + #[inline] + pub fn add_tracks_acceleration(&mut self, tracks_acceleration: bool) { + self.fbb_.push_slot::(AddTrackerRequest::VT_TRACKS_ACCELERATION, tracks_acceleration, false); + } + #[inline] + pub fn add_tracks_position(&mut self, tracks_position: bool) { + self.fbb_.push_slot::(AddTrackerRequest::VT_TRACKS_POSITION, tracks_position, false); + } + #[inline] + pub fn add_role_hint(&mut self, role_hint: super::datatypes::BodyPart) { + self.fbb_.push_slot_always::(AddTrackerRequest::VT_ROLE_HINT, role_hint); + } + #[inline] + pub fn add_is_hmd(&mut self, is_hmd: bool) { + self.fbb_.push_slot::(AddTrackerRequest::VT_IS_HMD, is_hmd, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AddTrackerRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + AddTrackerRequestBuilder { + 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 AddTrackerRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("AddTrackerRequest"); + ds.field("name", &self.name()); + ds.field("display_name", &self.display_name()); + ds.field("manufacturer", &self.manufacturer()); + ds.field("tracks_rotation", &self.tracks_rotation()); + ds.field("tracks_acceleration", &self.tracks_acceleration()); + ds.field("tracks_position", &self.tracks_position()); + ds.field("role_hint", &self.role_hint()); + ds.field("is_hmd", &self.is_hmd()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_response_generated.rs new file mode 100644 index 00000000..48d8e305 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/add_tracker_response_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 AddTrackerResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Response to AddTrackerRequest. Use the transaction ID to check what this is a response to. +pub struct AddTrackerResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for AddTrackerResponse<'a> { + type Inner = AddTrackerResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> AddTrackerResponse<'a> { + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + AddTrackerResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args AddTrackerResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = AddTrackerResponseBuilder::new(_fbb); + if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.finish() + } + + + /// The ID of the newly created tracker. + #[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::>(AddTrackerResponse::VT_TRACKER_ID, None)} + } +} + +impl flatbuffers::Verifiable for AddTrackerResponse<'_> { + #[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 AddTrackerResponseArgs<'a> { + pub tracker_id: Option>>, +} +impl<'a> Default for AddTrackerResponseArgs<'a> { + #[inline] + fn default() -> Self { + AddTrackerResponseArgs { + tracker_id: None, + } + } +} + +pub struct AddTrackerResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> AddTrackerResponseBuilder<'a, 'b> { + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(AddTrackerResponse::VT_TRACKER_ID, tracker_id); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AddTrackerResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + AddTrackerResponseBuilder { + 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 AddTrackerResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("AddTrackerResponse"); + ds.field("tracker_id", &self.tracker_id()); + ds.finish() + } +} 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 71ce97ba..67b23b59 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,10 +12,10 @@ 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 = 91; #[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; 92] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, @@ -103,6 +103,11 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 87] = [ RpcMessage::OpenUriRequest, RpcMessage::OpenUriResponse, RpcMessage::EnableSteamVRDriverRequest, + RpcMessage::AddTrackerRequest, + RpcMessage::AddTrackerResponse, + RpcMessage::UpdateTrackerPose, + RpcMessage::UpdateTrackerStatus, + RpcMessage::UpdateTrackerBattery, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -197,9 +202,14 @@ impl RpcMessage { pub const OpenUriRequest: Self = Self(84); pub const OpenUriResponse: Self = Self(85); pub const EnableSteamVRDriverRequest: Self = Self(86); + pub const AddTrackerRequest: Self = Self(87); + pub const AddTrackerResponse: Self = Self(88); + pub const UpdateTrackerPose: Self = Self(89); + pub const UpdateTrackerStatus: Self = Self(90); + pub const UpdateTrackerBattery: Self = Self(91); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 86; + pub const ENUM_MAX: u8 = 91; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -288,6 +298,11 @@ impl RpcMessage { Self::OpenUriRequest, Self::OpenUriResponse, Self::EnableSteamVRDriverRequest, + Self::AddTrackerRequest, + Self::AddTrackerResponse, + Self::UpdateTrackerPose, + Self::UpdateTrackerStatus, + Self::UpdateTrackerBattery, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -379,6 +394,11 @@ impl RpcMessage { Self::OpenUriRequest => Some("OpenUriRequest"), Self::OpenUriResponse => Some("OpenUriResponse"), Self::EnableSteamVRDriverRequest => Some("EnableSteamVRDriverRequest"), + Self::AddTrackerRequest => Some("AddTrackerRequest"), + Self::AddTrackerResponse => Some("AddTrackerResponse"), + Self::UpdateTrackerPose => Some("UpdateTrackerPose"), + Self::UpdateTrackerStatus => Some("UpdateTrackerStatus"), + Self::UpdateTrackerBattery => Some("UpdateTrackerBattery"), _ => None, } } 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 ca504d34..4d996883 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 @@ -1359,6 +1359,81 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_add_tracker_request(&self) -> Option> { + if self.message_type() == RpcMessage::AddTrackerRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { AddTrackerRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_add_tracker_response(&self) -> Option> { + if self.message_type() == RpcMessage::AddTrackerResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { AddTrackerResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_update_tracker_pose(&self) -> Option> { + if self.message_type() == RpcMessage::UpdateTrackerPose { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { UpdateTrackerPose::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_update_tracker_status(&self) -> Option> { + if self.message_type() == RpcMessage::UpdateTrackerStatus { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { UpdateTrackerStatus::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_update_tracker_battery(&self) -> Option> { + if self.message_type() == RpcMessage::UpdateTrackerBattery { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { UpdateTrackerBattery::init_from_table(t) } + }) + } else { + None + } + } + } impl flatbuffers::Verifiable for RpcMessageHeader<'_> { @@ -1457,6 +1532,11 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::OpenUriRequest => v.verify_union_variant::>("RpcMessage::OpenUriRequest", pos), RpcMessage::OpenUriResponse => v.verify_union_variant::>("RpcMessage::OpenUriResponse", pos), RpcMessage::EnableSteamVRDriverRequest => v.verify_union_variant::>("RpcMessage::EnableSteamVRDriverRequest", pos), + RpcMessage::AddTrackerRequest => v.verify_union_variant::>("RpcMessage::AddTrackerRequest", pos), + RpcMessage::AddTrackerResponse => v.verify_union_variant::>("RpcMessage::AddTrackerResponse", pos), + RpcMessage::UpdateTrackerPose => v.verify_union_variant::>("RpcMessage::UpdateTrackerPose", pos), + RpcMessage::UpdateTrackerStatus => v.verify_union_variant::>("RpcMessage::UpdateTrackerStatus", pos), + RpcMessage::UpdateTrackerBattery => v.verify_union_variant::>("RpcMessage::UpdateTrackerBattery", pos), _ => Ok(()), } })? @@ -2120,6 +2200,41 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::AddTrackerRequest => { + if let Some(x) = self.message_as_add_tracker_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::AddTrackerResponse => { + if let Some(x) = self.message_as_add_tracker_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::UpdateTrackerPose => { + if let Some(x) = self.message_as_update_tracker_pose() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::UpdateTrackerStatus => { + if let Some(x) = self.message_as_update_tracker_status() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::UpdateTrackerBattery => { + if let Some(x) = self.message_as_update_tracker_battery() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, _ => { let x: Option<()> = None; ds.field("message", &x) diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_battery_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_battery_generated.rs new file mode 100644 index 00000000..06c65dd0 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_battery_generated.rs @@ -0,0 +1,145 @@ +// 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 UpdateTrackerBatteryOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Set the battery life of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +pub struct UpdateTrackerBattery<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for UpdateTrackerBattery<'a> { + type Inner = UpdateTrackerBattery<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> UpdateTrackerBattery<'a> { + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; + pub const VT_BATTERY_PERCENTAGE: flatbuffers::VOffsetT = 6; + pub const VT_CHARGING: flatbuffers::VOffsetT = 8; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + UpdateTrackerBattery { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args UpdateTrackerBatteryArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = UpdateTrackerBatteryBuilder::new(_fbb); + builder.add_battery_percentage(args.battery_percentage); + if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_charging(args.charging); + 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::>(UpdateTrackerBattery::VT_TRACKER_ID, None)} + } + /// 0.0f..=100.0f + #[inline] + pub fn battery_percentage(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerBattery::VT_BATTERY_PERCENTAGE, Some(0.0)).unwrap()} + } + #[inline] + pub fn charging(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerBattery::VT_CHARGING, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for UpdateTrackerBattery<'_> { + #[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)? + .visit_field::("battery_percentage", Self::VT_BATTERY_PERCENTAGE, false)? + .visit_field::("charging", Self::VT_CHARGING, false)? + .finish(); + Ok(()) + } +} +pub struct UpdateTrackerBatteryArgs<'a> { + pub tracker_id: Option>>, + pub battery_percentage: f32, + pub charging: bool, +} +impl<'a> Default for UpdateTrackerBatteryArgs<'a> { + #[inline] + fn default() -> Self { + UpdateTrackerBatteryArgs { + tracker_id: None, + battery_percentage: 0.0, + charging: false, + } + } +} + +pub struct UpdateTrackerBatteryBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> UpdateTrackerBatteryBuilder<'a, 'b> { + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(UpdateTrackerBattery::VT_TRACKER_ID, tracker_id); + } + #[inline] + pub fn add_battery_percentage(&mut self, battery_percentage: f32) { + self.fbb_.push_slot::(UpdateTrackerBattery::VT_BATTERY_PERCENTAGE, battery_percentage, 0.0); + } + #[inline] + pub fn add_charging(&mut self, charging: bool) { + self.fbb_.push_slot::(UpdateTrackerBattery::VT_CHARGING, charging, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UpdateTrackerBatteryBuilder<'a, 'b> { + let start = _fbb.start_table(); + UpdateTrackerBatteryBuilder { + 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 UpdateTrackerBattery<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("UpdateTrackerBattery"); + ds.field("tracker_id", &self.tracker_id()); + ds.field("battery_percentage", &self.battery_percentage()); + ds.field("charging", &self.charging()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_pose_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_pose_generated.rs new file mode 100644 index 00000000..516648ee --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_pose_generated.rs @@ -0,0 +1,164 @@ +// 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 UpdateTrackerPoseOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Update the pose of a tracker created over SolarXR. +/// This will be ignored if the tracker was not created via SolarXR. +pub struct UpdateTrackerPose<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for UpdateTrackerPose<'a> { + type Inner = UpdateTrackerPose<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> UpdateTrackerPose<'a> { + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; + pub const VT_ROTATION: flatbuffers::VOffsetT = 6; + pub const VT_POSITION: flatbuffers::VOffsetT = 8; + pub const VT_RAW_ACCELERATION: flatbuffers::VOffsetT = 10; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + UpdateTrackerPose { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args UpdateTrackerPoseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = UpdateTrackerPoseBuilder::new(_fbb); + if let Some(x) = args.raw_acceleration { builder.add_raw_acceleration(x); } + 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.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::>(UpdateTrackerPose::VT_TRACKER_ID, None)} + } + /// Sensor rotation after fusion + #[inline] + pub fn rotation(&self) -> Option<&'a super::datatypes::math::Quat> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerPose::VT_ROTATION, None)} + } + /// Position, in meters + #[inline] + pub fn position(&self) -> Option<&'a super::datatypes::math::Vec3f> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerPose::VT_POSITION, None)} + } + /// Raw acceleration, in m/s^2 + #[inline] + pub fn raw_acceleration(&self) -> Option<&'a super::datatypes::math::Vec3f> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerPose::VT_RAW_ACCELERATION, None)} + } +} + +impl flatbuffers::Verifiable for UpdateTrackerPose<'_> { + #[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)? + .visit_field::("rotation", Self::VT_ROTATION, false)? + .visit_field::("position", Self::VT_POSITION, false)? + .visit_field::("raw_acceleration", Self::VT_RAW_ACCELERATION, false)? + .finish(); + Ok(()) + } +} +pub struct UpdateTrackerPoseArgs<'a> { + pub tracker_id: Option>>, + pub rotation: Option<&'a super::datatypes::math::Quat>, + pub position: Option<&'a super::datatypes::math::Vec3f>, + pub raw_acceleration: Option<&'a super::datatypes::math::Vec3f>, +} +impl<'a> Default for UpdateTrackerPoseArgs<'a> { + #[inline] + fn default() -> Self { + UpdateTrackerPoseArgs { + tracker_id: None, + rotation: None, + position: None, + raw_acceleration: None, + } + } +} + +pub struct UpdateTrackerPoseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> UpdateTrackerPoseBuilder<'a, 'b> { + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(UpdateTrackerPose::VT_TRACKER_ID, tracker_id); + } + #[inline] + pub fn add_rotation(&mut self, rotation: &super::datatypes::math::Quat) { + self.fbb_.push_slot_always::<&super::datatypes::math::Quat>(UpdateTrackerPose::VT_ROTATION, rotation); + } + #[inline] + pub fn add_position(&mut self, position: &super::datatypes::math::Vec3f) { + self.fbb_.push_slot_always::<&super::datatypes::math::Vec3f>(UpdateTrackerPose::VT_POSITION, position); + } + #[inline] + pub fn add_raw_acceleration(&mut self, raw_acceleration: &super::datatypes::math::Vec3f) { + self.fbb_.push_slot_always::<&super::datatypes::math::Vec3f>(UpdateTrackerPose::VT_RAW_ACCELERATION, raw_acceleration); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UpdateTrackerPoseBuilder<'a, 'b> { + let start = _fbb.start_table(); + UpdateTrackerPoseBuilder { + 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 UpdateTrackerPose<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("UpdateTrackerPose"); + ds.field("tracker_id", &self.tracker_id()); + ds.field("rotation", &self.rotation()); + ds.field("position", &self.position()); + ds.field("raw_acceleration", &self.raw_acceleration()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_status_generated.rs new file mode 100644 index 00000000..a8acef63 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/update_tracker_status_generated.rs @@ -0,0 +1,127 @@ +// 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 UpdateTrackerStatusOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Set the status of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +pub struct UpdateTrackerStatus<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for UpdateTrackerStatus<'a> { + type Inner = UpdateTrackerStatus<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> UpdateTrackerStatus<'a> { + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; + pub const VT_STATUS: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + UpdateTrackerStatus { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args UpdateTrackerStatusArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = UpdateTrackerStatusBuilder::new(_fbb); + if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.add_status(args.status); + 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::>(UpdateTrackerStatus::VT_TRACKER_ID, None)} + } + #[inline] + pub fn status(&self) -> super::datatypes::TrackerStatus { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(UpdateTrackerStatus::VT_STATUS, Some(super::datatypes::TrackerStatus::NONE)).unwrap()} + } +} + +impl flatbuffers::Verifiable for UpdateTrackerStatus<'_> { + #[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)? + .visit_field::("status", Self::VT_STATUS, false)? + .finish(); + Ok(()) + } +} +pub struct UpdateTrackerStatusArgs<'a> { + pub tracker_id: Option>>, + pub status: super::datatypes::TrackerStatus, +} +impl<'a> Default for UpdateTrackerStatusArgs<'a> { + #[inline] + fn default() -> Self { + UpdateTrackerStatusArgs { + tracker_id: None, + status: super::datatypes::TrackerStatus::NONE, + } + } +} + +pub struct UpdateTrackerStatusBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> UpdateTrackerStatusBuilder<'a, 'b> { + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(UpdateTrackerStatus::VT_TRACKER_ID, tracker_id); + } + #[inline] + pub fn add_status(&mut self, status: super::datatypes::TrackerStatus) { + self.fbb_.push_slot::(UpdateTrackerStatus::VT_STATUS, status, super::datatypes::TrackerStatus::NONE); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UpdateTrackerStatusBuilder<'a, 'b> { + let start = _fbb.start_table(); + UpdateTrackerStatusBuilder { + 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 UpdateTrackerStatus<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("UpdateTrackerStatus"); + ds.field("tracker_id", &self.tracker_id()); + ds.field("status", &self.status()); + ds.finish() + } +} diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index b4cfba79..8f2d2277 100644 --- a/protocol/typescript/src/all_generated.ts +++ b/protocol/typescript/src/all_generated.ts @@ -52,6 +52,8 @@ export { TopicHandle, TopicHandleT } from './solarxr-protocol/pub-sub/topic-hand 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 { AddTrackerRequest, AddTrackerRequestT } from './solarxr-protocol/rpc/add-tracker-request.js'; +export { AddTrackerResponse, AddTrackerResponseT } from './solarxr-protocol/rpc/add-tracker-response.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 { AssignTrackerRequest, AssignTrackerRequestT } from './solarxr-protocol/rpc/assign-tracker-request.js'; @@ -182,6 +184,9 @@ export { TrackingChecklistUnassignedHMD, TrackingChecklistUnassignedHMDT } from export { TrackingPauseStateRequest, TrackingPauseStateRequestT } from './solarxr-protocol/rpc/tracking-pause-state-request.js'; export { TrackingPauseStateResponse, TrackingPauseStateResponseT } from './solarxr-protocol/rpc/tracking-pause-state-response.js'; export { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from './solarxr-protocol/rpc/unknown-device-handshake-notification.js'; +export { UpdateTrackerBattery, UpdateTrackerBatteryT } from './solarxr-protocol/rpc/update-tracker-battery.js'; +export { UpdateTrackerPose, UpdateTrackerPoseT } from './solarxr-protocol/rpc/update-tracker-pose.js'; +export { UpdateTrackerStatus, UpdateTrackerStatusT } from './solarxr-protocol/rpc/update-tracker-status.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'; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-request.ts new file mode 100644 index 00000000..75f0f93f --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-request.ts @@ -0,0 +1,185 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; + + +/** + * Request the server to add a tracker. + */ +export class AddTrackerRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):AddTrackerRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsAddTrackerRequest(bb:flatbuffers.ByteBuffer, obj?:AddTrackerRequest):AddTrackerRequest { + return (obj || new AddTrackerRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsAddTrackerRequest(bb:flatbuffers.ByteBuffer, obj?:AddTrackerRequest):AddTrackerRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new AddTrackerRequest()).__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; +} + +displayName():string|null +displayName(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +displayName(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; +} + +manufacturer():string|null +manufacturer(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +manufacturer(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; +} + +tracksRotation():boolean { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +tracksAcceleration():boolean { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +tracksPosition():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +roleHint():BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +isHmd():boolean { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startAddTrackerRequest(builder:flatbuffers.Builder) { + builder.startObject(8); +} + +static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, nameOffset, 0); +} + +static addDisplayName(builder:flatbuffers.Builder, displayNameOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, displayNameOffset, 0); +} + +static addManufacturer(builder:flatbuffers.Builder, manufacturerOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, manufacturerOffset, 0); +} + +static addTracksRotation(builder:flatbuffers.Builder, tracksRotation:boolean) { + builder.addFieldInt8(3, +tracksRotation, +false); +} + +static addTracksAcceleration(builder:flatbuffers.Builder, tracksAcceleration:boolean) { + builder.addFieldInt8(4, +tracksAcceleration, +false); +} + +static addTracksPosition(builder:flatbuffers.Builder, tracksPosition:boolean) { + builder.addFieldInt8(5, +tracksPosition, +false); +} + +static addRoleHint(builder:flatbuffers.Builder, roleHint:BodyPart) { + builder.addFieldInt8(6, roleHint, 0); +} + +static addIsHmd(builder:flatbuffers.Builder, isHmd:boolean) { + builder.addFieldInt8(7, +isHmd, +false); +} + +static endAddTrackerRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createAddTrackerRequest(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset, displayNameOffset:flatbuffers.Offset, manufacturerOffset:flatbuffers.Offset, tracksRotation:boolean, tracksAcceleration:boolean, tracksPosition:boolean, roleHint:BodyPart|null, isHmd:boolean):flatbuffers.Offset { + AddTrackerRequest.startAddTrackerRequest(builder); + AddTrackerRequest.addName(builder, nameOffset); + AddTrackerRequest.addDisplayName(builder, displayNameOffset); + AddTrackerRequest.addManufacturer(builder, manufacturerOffset); + AddTrackerRequest.addTracksRotation(builder, tracksRotation); + AddTrackerRequest.addTracksAcceleration(builder, tracksAcceleration); + AddTrackerRequest.addTracksPosition(builder, tracksPosition); + if (roleHint !== null) + AddTrackerRequest.addRoleHint(builder, roleHint); + AddTrackerRequest.addIsHmd(builder, isHmd); + return AddTrackerRequest.endAddTrackerRequest(builder); +} + +unpack(): AddTrackerRequestT { + return new AddTrackerRequestT( + this.name(), + this.displayName(), + this.manufacturer(), + this.tracksRotation(), + this.tracksAcceleration(), + this.tracksPosition(), + this.roleHint(), + this.isHmd() + ); +} + + +unpackTo(_o: AddTrackerRequestT): void { + _o.name = this.name(); + _o.displayName = this.displayName(); + _o.manufacturer = this.manufacturer(); + _o.tracksRotation = this.tracksRotation(); + _o.tracksAcceleration = this.tracksAcceleration(); + _o.tracksPosition = this.tracksPosition(); + _o.roleHint = this.roleHint(); + _o.isHmd = this.isHmd(); +} +} + +export class AddTrackerRequestT implements flatbuffers.IGeneratedObject { +constructor( + public name: string|Uint8Array|null = null, + public displayName: string|Uint8Array|null = null, + public manufacturer: string|Uint8Array|null = null, + public tracksRotation: boolean = false, + public tracksAcceleration: boolean = false, + public tracksPosition: boolean = false, + public roleHint: BodyPart|null = null, + public isHmd: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const name = (this.name !== null ? builder.createString(this.name!) : 0); + const displayName = (this.displayName !== null ? builder.createString(this.displayName!) : 0); + const manufacturer = (this.manufacturer !== null ? builder.createString(this.manufacturer!) : 0); + + return AddTrackerRequest.createAddTrackerRequest(builder, + name, + displayName, + manufacturer, + this.tracksRotation, + this.tracksAcceleration, + this.tracksPosition, + this.roleHint, + this.isHmd + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-response.ts new file mode 100644 index 00000000..f4bb0c1e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/add-tracker-response.ts @@ -0,0 +1,81 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +/** + * Response to AddTrackerRequest. Use the transaction ID to check what this is a response to. + */ +export class AddTrackerResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):AddTrackerResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsAddTrackerResponse(bb:flatbuffers.ByteBuffer, obj?:AddTrackerResponse):AddTrackerResponse { + return (obj || new AddTrackerResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsAddTrackerResponse(bb:flatbuffers.ByteBuffer, obj?:AddTrackerResponse):AddTrackerResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new AddTrackerResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +/** + * The ID of the newly created tracker. + */ +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 startAddTrackerResponse(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackerIdOffset, 0); +} + +static endAddTrackerResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createAddTrackerResponse(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { + AddTrackerResponse.startAddTrackerResponse(builder); + AddTrackerResponse.addTrackerId(builder, trackerIdOffset); + return AddTrackerResponse.endAddTrackerResponse(builder); +} + +unpack(): AddTrackerResponseT { + return new AddTrackerResponseT( + (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + ); +} + + +unpackTo(_o: AddTrackerResponseT): void { + _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); +} +} + +export class AddTrackerResponseT 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 AddTrackerResponse.createAddTrackerResponse(builder, + trackerId + ); +} +} 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 0332a375..b6135ddf 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -3,6 +3,8 @@ import * as flatbuffers from 'flatbuffers'; import { TransactionId, TransactionIdT } from '../../solarxr-protocol/datatypes/transaction-id.js'; +import { AddTrackerRequest, AddTrackerRequestT } from '../../solarxr-protocol/rpc/add-tracker-request.js'; +import { AddTrackerResponse, AddTrackerResponseT } from '../../solarxr-protocol/rpc/add-tracker-response.js'; import { AddUnknownDeviceRequest, AddUnknownDeviceRequestT } from '../../solarxr-protocol/rpc/add-unknown-device-request.js'; import { AssignTrackerRequest, AssignTrackerRequestT } from '../../solarxr-protocol/rpc/assign-tracker-request.js'; import { AutoBoneApplyRequest, AutoBoneApplyRequestT } from '../../solarxr-protocol/rpc/auto-bone-apply-request.js'; @@ -85,6 +87,9 @@ import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../sol import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../solarxr-protocol/rpc/tracking-pause-state-request.js'; 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 { UpdateTrackerBattery, UpdateTrackerBatteryT } from '../../solarxr-protocol/rpc/update-tracker-battery.js'; +import { UpdateTrackerPose, UpdateTrackerPoseT } from '../../solarxr-protocol/rpc/update-tracker-pose.js'; +import { UpdateTrackerStatus, UpdateTrackerStatusT } from '../../solarxr-protocol/rpc/update-tracker-status.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-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'; @@ -186,7 +191,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: AddTrackerRequestT|AddTrackerResponseT|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|UpdateTrackerBatteryT|UpdateTrackerPoseT|UpdateTrackerStatusT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|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 5c6dfff4..8b22b5f3 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -1,5 +1,7 @@ // automatically generated by the FlatBuffers compiler, do not modify +import { AddTrackerRequest, AddTrackerRequestT } from '../../solarxr-protocol/rpc/add-tracker-request.js'; +import { AddTrackerResponse, AddTrackerResponseT } from '../../solarxr-protocol/rpc/add-tracker-response.js'; import { AddUnknownDeviceRequest, AddUnknownDeviceRequestT } from '../../solarxr-protocol/rpc/add-unknown-device-request.js'; import { AssignTrackerRequest, AssignTrackerRequestT } from '../../solarxr-protocol/rpc/assign-tracker-request.js'; import { AutoBoneApplyRequest, AutoBoneApplyRequestT } from '../../solarxr-protocol/rpc/auto-bone-apply-request.js'; @@ -81,6 +83,9 @@ import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../sol import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../solarxr-protocol/rpc/tracking-pause-state-request.js'; 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 { UpdateTrackerBattery, UpdateTrackerBatteryT } from '../../solarxr-protocol/rpc/update-tracker-battery.js'; +import { UpdateTrackerPose, UpdateTrackerPoseT } from '../../solarxr-protocol/rpc/update-tracker-pose.js'; +import { UpdateTrackerStatus, UpdateTrackerStatusT } from '../../solarxr-protocol/rpc/update-tracker-status.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-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'; @@ -175,13 +180,18 @@ export enum RpcMessage { InstalledInfoResponse = 83, OpenUriRequest = 84, OpenUriResponse = 85, - EnableSteamVRDriverRequest = 86 + EnableSteamVRDriverRequest = 86, + AddTrackerRequest = 87, + AddTrackerResponse = 88, + UpdateTrackerPose = 89, + UpdateTrackerStatus = 90, + UpdateTrackerBattery = 91 } 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:AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null +): AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -270,15 +280,20 @@ export function unionToRpcMessage( case 'OpenUriRequest': return accessor(new OpenUriRequest())! as OpenUriRequest; case 'OpenUriResponse': return accessor(new OpenUriResponse())! as OpenUriResponse; case 'EnableSteamVRDriverRequest': return accessor(new EnableSteamVRDriverRequest())! as EnableSteamVRDriverRequest; + case 'AddTrackerRequest': return accessor(new AddTrackerRequest())! as AddTrackerRequest; + case 'AddTrackerResponse': return accessor(new AddTrackerResponse())! as AddTrackerResponse; + case 'UpdateTrackerPose': return accessor(new UpdateTrackerPose())! as UpdateTrackerPose; + case 'UpdateTrackerStatus': return accessor(new UpdateTrackerStatus())! as UpdateTrackerStatus; + case 'UpdateTrackerBattery': return accessor(new UpdateTrackerBattery())! as UpdateTrackerBattery; default: return null; } } 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:AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|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 { +): AddTrackerRequest|AddTrackerResponse|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|UpdateTrackerBattery|UpdateTrackerPose|UpdateTrackerStatus|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -367,6 +382,11 @@ export function unionListToRpcMessage( case 'OpenUriRequest': return accessor(index, new OpenUriRequest())! as OpenUriRequest; case 'OpenUriResponse': return accessor(index, new OpenUriResponse())! as OpenUriResponse; case 'EnableSteamVRDriverRequest': return accessor(index, new EnableSteamVRDriverRequest())! as EnableSteamVRDriverRequest; + case 'AddTrackerRequest': return accessor(index, new AddTrackerRequest())! as AddTrackerRequest; + case 'AddTrackerResponse': return accessor(index, new AddTrackerResponse())! as AddTrackerResponse; + case 'UpdateTrackerPose': return accessor(index, new UpdateTrackerPose())! as UpdateTrackerPose; + case 'UpdateTrackerStatus': return accessor(index, new UpdateTrackerStatus())! as UpdateTrackerStatus; + case 'UpdateTrackerBattery': return accessor(index, new UpdateTrackerBattery())! as UpdateTrackerBattery; default: return null; } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-battery.ts b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-battery.ts new file mode 100644 index 00000000..9b95115c --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-battery.ts @@ -0,0 +1,110 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +/** + * Set the battery life of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +export class UpdateTrackerBattery implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):UpdateTrackerBattery { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsUpdateTrackerBattery(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerBattery):UpdateTrackerBattery { + return (obj || new UpdateTrackerBattery()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsUpdateTrackerBattery(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerBattery):UpdateTrackerBattery { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new UpdateTrackerBattery()).__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; +} + +/** + * 0.0f..=100.0f + */ +batteryPercentage():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +charging():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startUpdateTrackerBattery(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackerIdOffset, 0); +} + +static addBatteryPercentage(builder:flatbuffers.Builder, batteryPercentage:number) { + builder.addFieldFloat32(1, batteryPercentage, 0.0); +} + +static addCharging(builder:flatbuffers.Builder, charging:boolean) { + builder.addFieldInt8(2, +charging, +false); +} + +static endUpdateTrackerBattery(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createUpdateTrackerBattery(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset, batteryPercentage:number, charging:boolean):flatbuffers.Offset { + UpdateTrackerBattery.startUpdateTrackerBattery(builder); + UpdateTrackerBattery.addTrackerId(builder, trackerIdOffset); + UpdateTrackerBattery.addBatteryPercentage(builder, batteryPercentage); + UpdateTrackerBattery.addCharging(builder, charging); + return UpdateTrackerBattery.endUpdateTrackerBattery(builder); +} + +unpack(): UpdateTrackerBatteryT { + return new UpdateTrackerBatteryT( + (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.batteryPercentage(), + this.charging() + ); +} + + +unpackTo(_o: UpdateTrackerBatteryT): void { + _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.batteryPercentage = this.batteryPercentage(); + _o.charging = this.charging(); +} +} + +export class UpdateTrackerBatteryT implements flatbuffers.IGeneratedObject { +constructor( + public trackerId: TrackerIdT|null = null, + public batteryPercentage: number = 0.0, + public charging: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); + + return UpdateTrackerBattery.createUpdateTrackerBattery(builder, + trackerId, + this.batteryPercentage, + this.charging + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-pose.ts b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-pose.ts new file mode 100644 index 00000000..35c52318 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-pose.ts @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; +import { Quat, QuatT } from '../../solarxr-protocol/datatypes/math/quat.js'; +import { Vec3f, Vec3fT } from '../../solarxr-protocol/datatypes/math/vec3f.js'; + + +/** + * Update the pose of a tracker created over SolarXR. + * This will be ignored if the tracker was not created via SolarXR. + */ +export class UpdateTrackerPose implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):UpdateTrackerPose { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsUpdateTrackerPose(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerPose):UpdateTrackerPose { + return (obj || new UpdateTrackerPose()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsUpdateTrackerPose(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerPose):UpdateTrackerPose { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new UpdateTrackerPose()).__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; +} + +/** + * Sensor rotation after fusion + */ +rotation(obj?:Quat):Quat|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; +} + +/** + * Position, in meters + */ +position(obj?:Vec3f):Vec3f|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; +} + +/** + * Raw acceleration, in m/s^2 + */ +rawAcceleration(obj?:Vec3f):Vec3f|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; +} + +static startUpdateTrackerPose(builder:flatbuffers.Builder) { + builder.startObject(4); +} + +static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackerIdOffset, 0); +} + +static addRotation(builder:flatbuffers.Builder, rotationOffset:flatbuffers.Offset) { + builder.addFieldStruct(1, rotationOffset, 0); +} + +static addPosition(builder:flatbuffers.Builder, positionOffset:flatbuffers.Offset) { + builder.addFieldStruct(2, positionOffset, 0); +} + +static addRawAcceleration(builder:flatbuffers.Builder, rawAccelerationOffset:flatbuffers.Offset) { + builder.addFieldStruct(3, rawAccelerationOffset, 0); +} + +static endUpdateTrackerPose(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): UpdateTrackerPoseT { + return new UpdateTrackerPoseT( + (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + (this.rotation() !== null ? this.rotation()!.unpack() : null), + (this.position() !== null ? this.position()!.unpack() : null), + (this.rawAcceleration() !== null ? this.rawAcceleration()!.unpack() : null) + ); +} + + +unpackTo(_o: UpdateTrackerPoseT): void { + _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.rotation = (this.rotation() !== null ? this.rotation()!.unpack() : null); + _o.position = (this.position() !== null ? this.position()!.unpack() : null); + _o.rawAcceleration = (this.rawAcceleration() !== null ? this.rawAcceleration()!.unpack() : null); +} +} + +export class UpdateTrackerPoseT implements flatbuffers.IGeneratedObject { +constructor( + public trackerId: TrackerIdT|null = null, + public rotation: QuatT|null = null, + public position: Vec3fT|null = null, + public rawAcceleration: Vec3fT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); + + UpdateTrackerPose.startUpdateTrackerPose(builder); + UpdateTrackerPose.addTrackerId(builder, trackerId); + UpdateTrackerPose.addRotation(builder, (this.rotation !== null ? this.rotation!.pack(builder) : 0)); + UpdateTrackerPose.addPosition(builder, (this.position !== null ? this.position!.pack(builder) : 0)); + UpdateTrackerPose.addRawAcceleration(builder, (this.rawAcceleration !== null ? this.rawAcceleration!.pack(builder) : 0)); + + return UpdateTrackerPose.endUpdateTrackerPose(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-status.ts b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-status.ts new file mode 100644 index 00000000..b31249f7 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/update-tracker-status.ts @@ -0,0 +1,94 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; +import { TrackerStatus } from '../../solarxr-protocol/datatypes/tracker-status.js'; + + +/** + * Set the status of a tracker. + * This will be ignored if the tracker was not created via SolarXR. + */ +export class UpdateTrackerStatus implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):UpdateTrackerStatus { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsUpdateTrackerStatus(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerStatus):UpdateTrackerStatus { + return (obj || new UpdateTrackerStatus()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsUpdateTrackerStatus(bb:flatbuffers.ByteBuffer, obj?:UpdateTrackerStatus):UpdateTrackerStatus { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new UpdateTrackerStatus()).__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; +} + +status():TrackerStatus { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackerStatus.NONE; +} + +static startUpdateTrackerStatus(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackerIdOffset, 0); +} + +static addStatus(builder:flatbuffers.Builder, status:TrackerStatus) { + builder.addFieldInt8(1, status, TrackerStatus.NONE); +} + +static endUpdateTrackerStatus(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createUpdateTrackerStatus(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset, status:TrackerStatus):flatbuffers.Offset { + UpdateTrackerStatus.startUpdateTrackerStatus(builder); + UpdateTrackerStatus.addTrackerId(builder, trackerIdOffset); + UpdateTrackerStatus.addStatus(builder, status); + return UpdateTrackerStatus.endUpdateTrackerStatus(builder); +} + +unpack(): UpdateTrackerStatusT { + return new UpdateTrackerStatusT( + (this.trackerId() !== null ? this.trackerId()!.unpack() : null), + this.status() + ); +} + + +unpackTo(_o: UpdateTrackerStatusT): void { + _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.status = this.status(); +} +} + +export class UpdateTrackerStatusT implements flatbuffers.IGeneratedObject { +constructor( + public trackerId: TrackerIdT|null = null, + public status: TrackerStatus = TrackerStatus.NONE +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); + + return UpdateTrackerStatus.createUpdateTrackerStatus(builder, + trackerId, + this.status + ); +} +} diff --git a/schema/rpc.fbs b/schema/rpc.fbs index 5941a900..a25bfb54 100644 --- a/schema/rpc.fbs +++ b/schema/rpc.fbs @@ -104,6 +104,11 @@ union RpcMessage { OpenUriRequest, OpenUriResponse, EnableSteamVRDriverRequest, + AddTrackerRequest, + AddTrackerResponse, + UpdateTrackerPose, + UpdateTrackerStatus, + UpdateTrackerBattery, } enum KeybindId: uint8 { @@ -1158,3 +1163,52 @@ table UserHeightRecordingStatusResponse { hmdHeight: float; status: UserHeightCalibrationStatus; } + +// -------------- External devices -------------- + +/// Request the server to add a tracker. +table AddTrackerRequest { + name: string; + display_name: string; + manufacturer: string; + tracks_rotation: bool; + tracks_acceleration: bool; + tracks_position: bool; + role_hint: solarxr_protocol.datatypes.BodyPart = null; + is_hmd: bool = false; +} + +/// Response to AddTrackerRequest. Use the transaction ID to check what this is a response to. +table AddTrackerResponse { + /// The ID of the newly created tracker. + tracker_id: solarxr_protocol.datatypes.TrackerId; +} + +/// Update the pose of a tracker created over SolarXR. +/// This will be ignored if the tracker was not created via SolarXR. +table UpdateTrackerPose { + tracker_id: solarxr_protocol.datatypes.TrackerId; + /// Sensor rotation after fusion + rotation: solarxr_protocol.datatypes.math.Quat; + /// Position, in meters + // TODO: With respect to what space? + position: solarxr_protocol.datatypes.math.Vec3f; + /// Raw acceleration, in m/s^2 + raw_acceleration: solarxr_protocol.datatypes.math.Vec3f; +} + +/// Set the status of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +table UpdateTrackerStatus { + tracker_id: solarxr_protocol.datatypes.TrackerId; + status: solarxr_protocol.datatypes.TrackerStatus; +} + +/// Set the battery life of a tracker. +/// This will be ignored if the tracker was not created via SolarXR. +table UpdateTrackerBattery { + tracker_id: solarxr_protocol.datatypes.TrackerId; + /// 0.0f..=100.0f + battery_percentage: float32; + charging: bool; +}