diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index 9b200b93..77bc373d 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -102,6 +102,13 @@ struct DeviceDataBuilder; struct Bone; struct BoneBuilder; +namespace server { + +struct ServerGuards; +struct ServerGuardsBuilder; + +} // namespace server + struct DataFeedMessageHeader; struct DataFeedMessageHeaderBuilder; @@ -427,6 +434,39 @@ struct VRCConfigStateRequestBuilder; struct VRCConfigStateChangeResponse; struct VRCConfigStateChangeResponseBuilder; +struct VRCConfigSettingToggleMute; +struct VRCConfigSettingToggleMuteBuilder; + +struct TrackingChecklistTrackerReset; +struct TrackingChecklistTrackerResetBuilder; + +struct TrackingChecklistTrackerError; +struct TrackingChecklistTrackerErrorBuilder; + +struct TrackingChecklistNeedCalibration; +struct TrackingChecklistNeedCalibrationBuilder; + +struct TrackingChecklistSteamVRDisconnected; +struct TrackingChecklistSteamVRDisconnectedBuilder; + +struct TrackingChecklistUnassignedHMD; +struct TrackingChecklistUnassignedHMDBuilder; + +struct TrackingChecklistPublicNetworks; +struct TrackingChecklistPublicNetworksBuilder; + +struct TrackingChecklistStep; +struct TrackingChecklistStepBuilder; + +struct TrackingChecklistRequest; +struct TrackingChecklistRequestBuilder; + +struct TrackingChecklistResponse; +struct TrackingChecklistResponseBuilder; + +struct IgnoreTrackingChecklistStepRequest; +struct IgnoreTrackingChecklistStepRequestBuilder; + struct EnableStayAlignedRequest; struct EnableStayAlignedRequestBuilder; @@ -1300,11 +1340,15 @@ enum class RpcMessage : uint8_t { DetectStayAlignedRelaxedPoseRequest = 69, ResetStayAlignedRelaxedPoseRequest = 70, SerialTrackerCustomCommandRequest = 71, + VRCConfigSettingToggleMute = 72, + TrackingChecklistRequest = 73, + TrackingChecklistResponse = 74, + IgnoreTrackingChecklistStepRequest = 75, MIN = NONE, - MAX = SerialTrackerCustomCommandRequest + MAX = IgnoreTrackingChecklistStepRequest }; -inline const RpcMessage (&EnumValuesRpcMessage())[72] { +inline const RpcMessage (&EnumValuesRpcMessage())[76] { static const RpcMessage values[] = { RpcMessage::NONE, RpcMessage::HeartbeatRequest, @@ -1377,13 +1421,17 @@ inline const RpcMessage (&EnumValuesRpcMessage())[72] { RpcMessage::EnableStayAlignedRequest, RpcMessage::DetectStayAlignedRelaxedPoseRequest, RpcMessage::ResetStayAlignedRelaxedPoseRequest, - RpcMessage::SerialTrackerCustomCommandRequest + RpcMessage::SerialTrackerCustomCommandRequest, + RpcMessage::VRCConfigSettingToggleMute, + RpcMessage::TrackingChecklistRequest, + RpcMessage::TrackingChecklistResponse, + RpcMessage::IgnoreTrackingChecklistStepRequest }; return values; } inline const char * const *EnumNamesRpcMessage() { - static const char * const names[73] = { + static const char * const names[77] = { "NONE", "HeartbeatRequest", "HeartbeatResponse", @@ -1456,13 +1504,17 @@ inline const char * const *EnumNamesRpcMessage() { "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", + "VRCConfigSettingToggleMute", + "TrackingChecklistRequest", + "TrackingChecklistResponse", + "IgnoreTrackingChecklistStepRequest", nullptr }; return names; } inline const char *EnumNameRpcMessage(RpcMessage e) { - if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::SerialTrackerCustomCommandRequest)) return ""; + if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::IgnoreTrackingChecklistStepRequest)) return ""; const size_t index = static_cast(e); return EnumNamesRpcMessage()[index]; } @@ -1755,6 +1807,22 @@ template<> struct RpcMessageTraits struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VRCConfigSettingToggleMute; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingChecklistRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::TrackingChecklistResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::IgnoreTrackingChecklistStepRequest; +}; + bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); @@ -2173,7 +2241,7 @@ enum class FirmwareUpdateStatus : uint8_t { ERROR_DOWNLOAD_FAILED = 10, /// The server could not authenticate with the MCU ERROR_AUTHENTICATION_FAILED = 11, - /// Could not upload the firmware to the MUC + /// Could not upload the firmware to the MCU ERROR_UPLOAD_FAILED = 12, /// The provision of the tracker failed, usually wifi credentials ERROR_PROVISIONING_FAILED = 13, @@ -2439,6 +2507,169 @@ inline const char *EnumNameVRCAvatarMeasurementType(VRCAvatarMeasurementType e) return EnumNamesVRCAvatarMeasurementType()[index]; } +enum class TrackingChecklistStepId : uint8_t { + UNKNOWN = 0, + TRACKERS_REST_CALIBRATION = 1, + FULL_RESET = 2, + VRCHAT_SETTINGS = 3, + STEAMVR_DISCONNECTED = 4, + UNASSIGNED_HMD = 5, + TRACKER_ERROR = 6, + NETWORK_PROFILE_PUBLIC = 7, + MOUNTING_CALIBRATION = 8, + FEET_MOUNTING_CALIBRATION = 9, + STAY_ALIGNED_CONFIGURED = 10, + MIN = UNKNOWN, + MAX = STAY_ALIGNED_CONFIGURED +}; + +inline const TrackingChecklistStepId (&EnumValuesTrackingChecklistStepId())[11] { + static const TrackingChecklistStepId values[] = { + TrackingChecklistStepId::UNKNOWN, + TrackingChecklistStepId::TRACKERS_REST_CALIBRATION, + TrackingChecklistStepId::FULL_RESET, + TrackingChecklistStepId::VRCHAT_SETTINGS, + TrackingChecklistStepId::STEAMVR_DISCONNECTED, + TrackingChecklistStepId::UNASSIGNED_HMD, + TrackingChecklistStepId::TRACKER_ERROR, + TrackingChecklistStepId::NETWORK_PROFILE_PUBLIC, + TrackingChecklistStepId::MOUNTING_CALIBRATION, + TrackingChecklistStepId::FEET_MOUNTING_CALIBRATION, + TrackingChecklistStepId::STAY_ALIGNED_CONFIGURED + }; + return values; +} + +inline const char * const *EnumNamesTrackingChecklistStepId() { + static const char * const names[12] = { + "UNKNOWN", + "TRACKERS_REST_CALIBRATION", + "FULL_RESET", + "VRCHAT_SETTINGS", + "STEAMVR_DISCONNECTED", + "UNASSIGNED_HMD", + "TRACKER_ERROR", + "NETWORK_PROFILE_PUBLIC", + "MOUNTING_CALIBRATION", + "FEET_MOUNTING_CALIBRATION", + "STAY_ALIGNED_CONFIGURED", + nullptr + }; + return names; +} + +inline const char *EnumNameTrackingChecklistStepId(TrackingChecklistStepId e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistStepId::UNKNOWN, TrackingChecklistStepId::STAY_ALIGNED_CONFIGURED)) return ""; + const size_t index = static_cast(e); + return EnumNamesTrackingChecklistStepId()[index]; +} + +enum class TrackingChecklistStepVisibility : uint8_t { + ALWAYS = 0, + WHEN_INVALID = 1, + MIN = ALWAYS, + MAX = WHEN_INVALID +}; + +inline const TrackingChecklistStepVisibility (&EnumValuesTrackingChecklistStepVisibility())[2] { + static const TrackingChecklistStepVisibility values[] = { + TrackingChecklistStepVisibility::ALWAYS, + TrackingChecklistStepVisibility::WHEN_INVALID + }; + return values; +} + +inline const char * const *EnumNamesTrackingChecklistStepVisibility() { + static const char * const names[3] = { + "ALWAYS", + "WHEN_INVALID", + nullptr + }; + return names; +} + +inline const char *EnumNameTrackingChecklistStepVisibility(TrackingChecklistStepVisibility e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistStepVisibility::ALWAYS, TrackingChecklistStepVisibility::WHEN_INVALID)) return ""; + const size_t index = static_cast(e); + return EnumNamesTrackingChecklistStepVisibility()[index]; +} + +enum class TrackingChecklistExtraData : uint8_t { + NONE = 0, + TrackingChecklistTrackerReset = 1, + TrackingChecklistTrackerError = 2, + TrackingChecklistSteamVRDisconnected = 3, + TrackingChecklistUnassignedHMD = 4, + TrackingChecklistNeedCalibration = 5, + TrackingChecklistPublicNetworks = 6, + MIN = NONE, + MAX = TrackingChecklistPublicNetworks +}; + +inline const TrackingChecklistExtraData (&EnumValuesTrackingChecklistExtraData())[7] { + static const TrackingChecklistExtraData values[] = { + TrackingChecklistExtraData::NONE, + TrackingChecklistExtraData::TrackingChecklistTrackerReset, + TrackingChecklistExtraData::TrackingChecklistTrackerError, + TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected, + TrackingChecklistExtraData::TrackingChecklistUnassignedHMD, + TrackingChecklistExtraData::TrackingChecklistNeedCalibration, + TrackingChecklistExtraData::TrackingChecklistPublicNetworks + }; + return values; +} + +inline const char * const *EnumNamesTrackingChecklistExtraData() { + static const char * const names[8] = { + "NONE", + "TrackingChecklistTrackerReset", + "TrackingChecklistTrackerError", + "TrackingChecklistSteamVRDisconnected", + "TrackingChecklistUnassignedHMD", + "TrackingChecklistNeedCalibration", + "TrackingChecklistPublicNetworks", + nullptr + }; + return names; +} + +inline const char *EnumNameTrackingChecklistExtraData(TrackingChecklistExtraData e) { + if (flatbuffers::IsOutRange(e, TrackingChecklistExtraData::NONE, TrackingChecklistExtraData::TrackingChecklistPublicNetworks)) return ""; + const size_t index = static_cast(e); + return EnumNamesTrackingChecklistExtraData()[index]; +} + +template struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::NONE; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerReset; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistTrackerError; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistUnassignedHMD; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistNeedCalibration; +}; + +template<> struct TrackingChecklistExtraDataTraits { + static const TrackingChecklistExtraData enum_value = TrackingChecklistExtraData::TrackingChecklistPublicNetworks; +}; + +bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type); +bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + enum class StayAlignedRelaxedPose : uint8_t { STANDING = 0, SITTING = 1, @@ -4503,6 +4734,61 @@ inline flatbuffers::Offset CreateBone( return builder_.Finish(); } +namespace server { + +struct ServerGuards FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ServerGuardsBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CANDOMOUNTING = 4, + VT_CANDOYAWRESET = 6 + }; + bool canDoMounting() const { + return GetField(VT_CANDOMOUNTING, 0) != 0; + } + bool canDoYawReset() const { + return GetField(VT_CANDOYAWRESET, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_CANDOMOUNTING, 1) && + VerifyField(verifier, VT_CANDOYAWRESET, 1) && + verifier.EndTable(); + } +}; + +struct ServerGuardsBuilder { + typedef ServerGuards Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_canDoMounting(bool canDoMounting) { + fbb_.AddElement(ServerGuards::VT_CANDOMOUNTING, static_cast(canDoMounting), 0); + } + void add_canDoYawReset(bool canDoYawReset) { + fbb_.AddElement(ServerGuards::VT_CANDOYAWRESET, static_cast(canDoYawReset), 0); + } + explicit ServerGuardsBuilder(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 CreateServerGuards( + flatbuffers::FlatBufferBuilder &_fbb, + bool canDoMounting = false, + bool canDoYawReset = false) { + ServerGuardsBuilder builder_(_fbb); + builder_.add_canDoYawReset(canDoYawReset); + builder_.add_canDoMounting(canDoMounting); + return builder_.Finish(); +} + +} // namespace server + struct DataFeedMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef DataFeedMessageHeaderBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -4702,7 +4988,8 @@ struct DataFeedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_SYNTHETIC_TRACKERS = 6, VT_BONES = 8, VT_STAY_ALIGNED_POSE = 10, - VT_INDEX = 12 + VT_INDEX = 12, + VT_SERVER_GUARDS = 14 }; const flatbuffers::Vector> *devices() const { return GetPointer> *>(VT_DEVICES); @@ -4720,6 +5007,9 @@ struct DataFeedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { uint8_t index() const { return GetField(VT_INDEX, 0); } + const solarxr_protocol::data_feed::server::ServerGuards *server_guards() const { + return GetPointer(VT_SERVER_GUARDS); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_DEVICES) && @@ -4734,6 +5024,8 @@ struct DataFeedUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VerifyOffset(verifier, VT_STAY_ALIGNED_POSE) && verifier.VerifyTable(stay_aligned_pose()) && VerifyField(verifier, VT_INDEX, 1) && + VerifyOffset(verifier, VT_SERVER_GUARDS) && + verifier.VerifyTable(server_guards()) && verifier.EndTable(); } }; @@ -4757,6 +5049,9 @@ struct DataFeedUpdateBuilder { void add_index(uint8_t index) { fbb_.AddElement(DataFeedUpdate::VT_INDEX, index, 0); } + void add_server_guards(flatbuffers::Offset server_guards) { + fbb_.AddOffset(DataFeedUpdate::VT_SERVER_GUARDS, server_guards); + } explicit DataFeedUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -4774,8 +5069,10 @@ inline flatbuffers::Offset CreateDataFeedUpdate( flatbuffers::Offset>> synthetic_trackers = 0, flatbuffers::Offset>> bones = 0, flatbuffers::Offset stay_aligned_pose = 0, - uint8_t index = 0) { + uint8_t index = 0, + flatbuffers::Offset server_guards = 0) { DataFeedUpdateBuilder builder_(_fbb); + builder_.add_server_guards(server_guards); builder_.add_stay_aligned_pose(stay_aligned_pose); builder_.add_bones(bones); builder_.add_synthetic_trackers(synthetic_trackers); @@ -4790,7 +5087,8 @@ inline flatbuffers::Offset CreateDataFeedUpdateDirect( const std::vector> *synthetic_trackers = nullptr, const std::vector> *bones = nullptr, flatbuffers::Offset stay_aligned_pose = 0, - uint8_t index = 0) { + uint8_t index = 0, + flatbuffers::Offset server_guards = 0) { auto devices__ = devices ? _fbb.CreateVector>(*devices) : 0; auto synthetic_trackers__ = synthetic_trackers ? _fbb.CreateVector>(*synthetic_trackers) : 0; auto bones__ = bones ? _fbb.CreateVector>(*bones) : 0; @@ -4800,7 +5098,8 @@ inline flatbuffers::Offset CreateDataFeedUpdateDirect( synthetic_trackers__, bones__, stay_aligned_pose, - index); + index, + server_guards); } /// All information related to the configuration of a data feed. This may be sent @@ -4812,7 +5111,8 @@ struct DataFeedConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_DATA_MASK = 6, VT_SYNTHETIC_TRACKERS_MASK = 8, VT_BONE_MASK = 10, - VT_STAY_ALIGNED_POSE_MASK = 12 + VT_STAY_ALIGNED_POSE_MASK = 12, + VT_SERVER_GUARDS_MASK = 14 }; /// Minimum delay in milliseconds between new data updates. This value will be /// ignored when used for a `PollDataFeed`. @@ -4831,6 +5131,9 @@ struct DataFeedConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { bool stay_aligned_pose_mask() const { return GetField(VT_STAY_ALIGNED_POSE_MASK, 0) != 0; } + bool server_guards_mask() const { + return GetField(VT_SERVER_GUARDS_MASK, 0) != 0; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_MINIMUM_TIME_SINCE_LAST, 2) && @@ -4840,6 +5143,7 @@ struct DataFeedConfig FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { verifier.VerifyTable(synthetic_trackers_mask()) && VerifyField(verifier, VT_BONE_MASK, 1) && VerifyField(verifier, VT_STAY_ALIGNED_POSE_MASK, 1) && + VerifyField(verifier, VT_SERVER_GUARDS_MASK, 1) && verifier.EndTable(); } }; @@ -4863,6 +5167,9 @@ struct DataFeedConfigBuilder { void add_stay_aligned_pose_mask(bool stay_aligned_pose_mask) { fbb_.AddElement(DataFeedConfig::VT_STAY_ALIGNED_POSE_MASK, static_cast(stay_aligned_pose_mask), 0); } + void add_server_guards_mask(bool server_guards_mask) { + fbb_.AddElement(DataFeedConfig::VT_SERVER_GUARDS_MASK, static_cast(server_guards_mask), 0); + } explicit DataFeedConfigBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -4880,11 +5187,13 @@ inline flatbuffers::Offset CreateDataFeedConfig( flatbuffers::Offset data_mask = 0, flatbuffers::Offset synthetic_trackers_mask = 0, bool bone_mask = false, - bool stay_aligned_pose_mask = false) { + bool stay_aligned_pose_mask = false, + bool server_guards_mask = false) { DataFeedConfigBuilder builder_(_fbb); builder_.add_synthetic_trackers_mask(synthetic_trackers_mask); builder_.add_data_mask(data_mask); builder_.add_minimum_time_since_last(minimum_time_since_last); + builder_.add_server_guards_mask(server_guards_mask); builder_.add_stay_aligned_pose_mask(stay_aligned_pose_mask); builder_.add_bone_mask(bone_mask); return builder_.Finish(); @@ -5555,6 +5864,18 @@ struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest *message_as_SerialTrackerCustomCommandRequest() const { return message_type() == solarxr_protocol::rpc::RpcMessage::SerialTrackerCustomCommandRequest ? static_cast(message()) : nullptr; } + const solarxr_protocol::rpc::VRCConfigSettingToggleMute *message_as_VRCConfigSettingToggleMute() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VRCConfigSettingToggleMute ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistRequest *message_as_TrackingChecklistRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistResponse *message_as_TrackingChecklistResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::TrackingChecklistResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *message_as_IgnoreTrackingChecklistStepRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::IgnoreTrackingChecklistStepRequest ? static_cast(message()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TX_ID, 4) && @@ -5849,6 +6170,22 @@ template<> inline const solarxr_protocol::rpc::SerialTrackerCustomCommandRequest return message_as_SerialTrackerCustomCommandRequest(); } +template<> inline const solarxr_protocol::rpc::VRCConfigSettingToggleMute *RpcMessageHeader::message_as() const { + return message_as_VRCConfigSettingToggleMute(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistRequest *RpcMessageHeader::message_as() const { + return message_as_TrackingChecklistRequest(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistResponse *RpcMessageHeader::message_as() const { + return message_as_TrackingChecklistResponse(); +} + +template<> inline const solarxr_protocol::rpc::IgnoreTrackingChecklistStepRequest *RpcMessageHeader::message_as() const { + return message_as_IgnoreTrackingChecklistStepRequest(); +} + struct RpcMessageHeaderBuilder { typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -6011,7 +6348,10 @@ struct ResetResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef ResetResponseBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_RESET_TYPE = 4, - VT_STATUS = 6 + VT_STATUS = 6, + VT_BODY_PARTS = 8, + VT_PROGRESS = 10, + VT_DURATION = 12 }; solarxr_protocol::rpc::ResetType reset_type() const { return static_cast(GetField(VT_RESET_TYPE, 0)); @@ -6019,10 +6359,27 @@ struct ResetResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { solarxr_protocol::rpc::ResetStatus status() const { return static_cast(GetField(VT_STATUS, 0)); } + /// Should return the body parts reseted / being reset + const flatbuffers::Vector *body_parts() const { + return GetPointer *>(VT_BODY_PARTS); + } + /// gives the time in seconds passed since the start of the reset + /// is 0 when status == FINISHED + /// starts at 0 + int32_t progress() const { + return GetField(VT_PROGRESS, 0); + } + int32_t duration() const { + return GetField(VT_DURATION, 0); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_RESET_TYPE, 1) && VerifyField(verifier, VT_STATUS, 1) && + VerifyOffset(verifier, VT_BODY_PARTS) && + verifier.VerifyVector(body_parts()) && + VerifyField(verifier, VT_PROGRESS, 4) && + VerifyField(verifier, VT_DURATION, 4) && verifier.EndTable(); } }; @@ -6037,6 +6394,15 @@ struct ResetResponseBuilder { void add_status(solarxr_protocol::rpc::ResetStatus status) { fbb_.AddElement(ResetResponse::VT_STATUS, static_cast(status), 0); } + void add_body_parts(flatbuffers::Offset> body_parts) { + fbb_.AddOffset(ResetResponse::VT_BODY_PARTS, body_parts); + } + void add_progress(int32_t progress) { + fbb_.AddElement(ResetResponse::VT_PROGRESS, progress, 0); + } + void add_duration(int32_t duration) { + fbb_.AddElement(ResetResponse::VT_DURATION, duration, 0); + } explicit ResetResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -6051,13 +6417,36 @@ struct ResetResponseBuilder { inline flatbuffers::Offset CreateResetResponse( flatbuffers::FlatBufferBuilder &_fbb, solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, - solarxr_protocol::rpc::ResetStatus status = solarxr_protocol::rpc::ResetStatus::STARTED) { + solarxr_protocol::rpc::ResetStatus status = solarxr_protocol::rpc::ResetStatus::STARTED, + flatbuffers::Offset> body_parts = 0, + int32_t progress = 0, + int32_t duration = 0) { ResetResponseBuilder builder_(_fbb); + builder_.add_duration(duration); + builder_.add_progress(progress); + builder_.add_body_parts(body_parts); builder_.add_status(status); builder_.add_reset_type(reset_type); return builder_.Finish(); } +inline flatbuffers::Offset CreateResetResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::ResetType reset_type = solarxr_protocol::rpc::ResetType::Yaw, + solarxr_protocol::rpc::ResetStatus status = solarxr_protocol::rpc::ResetStatus::STARTED, + const std::vector *body_parts = nullptr, + int32_t progress = 0, + int32_t duration = 0) { + auto body_parts__ = body_parts ? _fbb.CreateVector(*body_parts) : 0; + return solarxr_protocol::rpc::CreateResetResponse( + _fbb, + reset_type, + status, + body_parts__, + progress, + duration); +} + struct AssignTrackerRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef AssignTrackerRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -9713,13 +10102,14 @@ struct StatusTrackerReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TRACKER_ID = 4 }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); + const flatbuffers::Vector> *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.VerifyVector(tracker_id()) && + verifier.VerifyVectorOfTables(tracker_id()) && verifier.EndTable(); } }; @@ -9728,7 +10118,7 @@ struct StatusTrackerResetBuilder { typedef StatusTrackerReset Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { + void add_tracker_id(flatbuffers::Offset>> tracker_id) { fbb_.AddOffset(StatusTrackerReset::VT_TRACKER_ID, tracker_id); } explicit StatusTrackerResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -9744,25 +10134,35 @@ struct StatusTrackerResetBuilder { inline flatbuffers::Offset CreateStatusTrackerReset( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { + flatbuffers::Offset>> tracker_id = 0) { StatusTrackerResetBuilder builder_(_fbb); builder_.add_tracker_id(tracker_id); return builder_.Finish(); } -/// Tracker has error state +inline flatbuffers::Offset CreateStatusTrackerResetDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *tracker_id = nullptr) { + auto tracker_id__ = tracker_id ? _fbb.CreateVector>(*tracker_id) : 0; + return solarxr_protocol::rpc::CreateStatusTrackerReset( + _fbb, + tracker_id__); +} + +/// Trackers with error state struct StatusTrackerError FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef StatusTrackerErrorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_TRACKER_ID = 4 }; - const solarxr_protocol::datatypes::TrackerId *tracker_id() const { - return GetPointer(VT_TRACKER_ID); + const flatbuffers::Vector> *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.VerifyVector(tracker_id()) && + verifier.VerifyVectorOfTables(tracker_id()) && verifier.EndTable(); } }; @@ -9771,7 +10171,7 @@ struct StatusTrackerErrorBuilder { typedef StatusTrackerError Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_tracker_id(flatbuffers::Offset tracker_id) { + void add_tracker_id(flatbuffers::Offset>> tracker_id) { fbb_.AddOffset(StatusTrackerError::VT_TRACKER_ID, tracker_id); } explicit StatusTrackerErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -9787,12 +10187,21 @@ struct StatusTrackerErrorBuilder { inline flatbuffers::Offset CreateStatusTrackerError( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset tracker_id = 0) { + flatbuffers::Offset>> tracker_id = 0) { StatusTrackerErrorBuilder builder_(_fbb); builder_.add_tracker_id(tracker_id); return builder_.Finish(); } +inline flatbuffers::Offset CreateStatusTrackerErrorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *tracker_id = nullptr) { + auto tracker_id__ = tracker_id ? _fbb.CreateVector>(*tracker_id) : 0; + return solarxr_protocol::rpc::CreateStatusTrackerError( + _fbb, + tracker_id__); +} + /// SteamVR bridge is disconnected struct StatusSteamVRDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef StatusSteamVRDisconnectedBuilder Builder; @@ -11749,7 +12158,8 @@ struct VRCConfigStateChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffer VT_IS_SUPPORTED = 4, VT_VALIDITY = 6, VT_STATE = 8, - VT_RECOMMENDED = 10 + VT_RECOMMENDED = 10, + VT_MUTED = 12 }; bool is_supported() const { return GetField(VT_IS_SUPPORTED, 0) != 0; @@ -11763,6 +12173,9 @@ struct VRCConfigStateChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffer const solarxr_protocol::rpc::VRCConfigRecommendedValues *recommended() const { return GetPointer(VT_RECOMMENDED); } + const flatbuffers::Vector> *muted() const { + return GetPointer> *>(VT_MUTED); + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_IS_SUPPORTED, 1) && @@ -11772,6 +12185,9 @@ struct VRCConfigStateChangeResponse FLATBUFFERS_FINAL_CLASS : private flatbuffer verifier.VerifyTable(state()) && VerifyOffset(verifier, VT_RECOMMENDED) && verifier.VerifyTable(recommended()) && + VerifyOffset(verifier, VT_MUTED) && + verifier.VerifyVector(muted()) && + verifier.VerifyVectorOfStrings(muted()) && verifier.EndTable(); } }; @@ -11792,6 +12208,9 @@ struct VRCConfigStateChangeResponseBuilder { void add_recommended(flatbuffers::Offset recommended) { fbb_.AddOffset(VRCConfigStateChangeResponse::VT_RECOMMENDED, recommended); } + void add_muted(flatbuffers::Offset>> muted) { + fbb_.AddOffset(VRCConfigStateChangeResponse::VT_MUTED, muted); + } explicit VRCConfigStateChangeResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); @@ -11808,8 +12227,10 @@ inline flatbuffers::Offset CreateVRCConfigStateCha bool is_supported = false, flatbuffers::Offset validity = 0, flatbuffers::Offset state = 0, - flatbuffers::Offset recommended = 0) { + flatbuffers::Offset recommended = 0, + flatbuffers::Offset>> muted = 0) { VRCConfigStateChangeResponseBuilder builder_(_fbb); + builder_.add_muted(muted); builder_.add_recommended(recommended); builder_.add_state(state); builder_.add_validity(validity); @@ -11817,148 +12238,821 @@ inline flatbuffers::Offset CreateVRCConfigStateCha return builder_.Finish(); } -struct EnableStayAlignedRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef EnableStayAlignedRequestBuilder Builder; +inline flatbuffers::Offset CreateVRCConfigStateChangeResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + bool is_supported = false, + flatbuffers::Offset validity = 0, + flatbuffers::Offset state = 0, + flatbuffers::Offset recommended = 0, + const std::vector> *muted = nullptr) { + auto muted__ = muted ? _fbb.CreateVector>(*muted) : 0; + return solarxr_protocol::rpc::CreateVRCConfigStateChangeResponse( + _fbb, + is_supported, + validity, + state, + recommended, + muted__); +} + +struct VRCConfigSettingToggleMute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VRCConfigSettingToggleMuteBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ENABLE = 4 + VT_KEY = 4 }; - bool enable() const { - return GetField(VT_ENABLE, 0) != 0; + const flatbuffers::String *key() const { + return GetPointer(VT_KEY); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ENABLE, 1) && + VerifyOffset(verifier, VT_KEY) && + verifier.VerifyString(key()) && verifier.EndTable(); } }; -struct EnableStayAlignedRequestBuilder { - typedef EnableStayAlignedRequest Table; +struct VRCConfigSettingToggleMuteBuilder { + typedef VRCConfigSettingToggleMute Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_enable(bool enable) { - fbb_.AddElement(EnableStayAlignedRequest::VT_ENABLE, static_cast(enable), 0); + void add_key(flatbuffers::Offset key) { + fbb_.AddOffset(VRCConfigSettingToggleMute::VT_KEY, key); } - explicit EnableStayAlignedRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit VRCConfigSettingToggleMuteBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateEnableStayAlignedRequest( +inline flatbuffers::Offset CreateVRCConfigSettingToggleMute( flatbuffers::FlatBufferBuilder &_fbb, - bool enable = false) { - EnableStayAlignedRequestBuilder builder_(_fbb); - builder_.add_enable(enable); + flatbuffers::Offset key = 0) { + VRCConfigSettingToggleMuteBuilder builder_(_fbb); + builder_.add_key(key); return builder_.Finish(); } -struct DetectStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef DetectStayAlignedRelaxedPoseRequestBuilder Builder; +inline flatbuffers::Offset CreateVRCConfigSettingToggleMuteDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *key = nullptr) { + auto key__ = key ? _fbb.CreateString(key) : 0; + return solarxr_protocol::rpc::CreateVRCConfigSettingToggleMute( + _fbb, + key__); +} + +/// Trackers that need a reset +struct TrackingChecklistTrackerReset FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistTrackerResetBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_POSE = 4 + VT_TRACKERS_ID = 4 }; - solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { - return static_cast(GetField(VT_POSE, 0)); + const flatbuffers::Vector> *trackers_id() const { + return GetPointer> *>(VT_TRACKERS_ID); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_POSE, 1) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && + verifier.VerifyVectorOfTables(trackers_id()) && verifier.EndTable(); } }; -struct DetectStayAlignedRelaxedPoseRequestBuilder { - typedef DetectStayAlignedRelaxedPoseRequest Table; +struct TrackingChecklistTrackerResetBuilder { + typedef TrackingChecklistTrackerReset Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { - fbb_.AddElement(DetectStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); + void add_trackers_id(flatbuffers::Offset>> trackers_id) { + fbb_.AddOffset(TrackingChecklistTrackerReset::VT_TRACKERS_ID, trackers_id); } - explicit DetectStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistTrackerResetBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateDetectStayAlignedRelaxedPoseRequest( +inline flatbuffers::Offset CreateTrackingChecklistTrackerReset( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { - DetectStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); - builder_.add_pose(pose); + flatbuffers::Offset>> trackers_id = 0) { + TrackingChecklistTrackerResetBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); return builder_.Finish(); } -struct ResetStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef ResetStayAlignedRelaxedPoseRequestBuilder Builder; +inline flatbuffers::Offset CreateTrackingChecklistTrackerResetDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistTrackerReset( + _fbb, + trackers_id__); +} + +/// Trackers with error state +struct TrackingChecklistTrackerError FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistTrackerErrorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_POSE = 4 + VT_TRACKERS_ID = 4 }; - solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { - return static_cast(GetField(VT_POSE, 0)); + const flatbuffers::Vector> *trackers_id() const { + return GetPointer> *>(VT_TRACKERS_ID); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_POSE, 1) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && + verifier.VerifyVectorOfTables(trackers_id()) && verifier.EndTable(); } }; -struct ResetStayAlignedRelaxedPoseRequestBuilder { - typedef ResetStayAlignedRelaxedPoseRequest Table; +struct TrackingChecklistTrackerErrorBuilder { + typedef TrackingChecklistTrackerError Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { - fbb_.AddElement(ResetStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); + void add_trackers_id(flatbuffers::Offset>> trackers_id) { + fbb_.AddOffset(TrackingChecklistTrackerError::VT_TRACKERS_ID, trackers_id); } - explicit ResetStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + explicit TrackingChecklistTrackerErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - flatbuffers::Offset Finish() { + flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = flatbuffers::Offset(end); + auto o = flatbuffers::Offset(end); return o; } }; -inline flatbuffers::Offset CreateResetStayAlignedRelaxedPoseRequest( +inline flatbuffers::Offset CreateTrackingChecklistTrackerError( flatbuffers::FlatBufferBuilder &_fbb, - solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { - ResetStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); - builder_.add_pose(pose); + flatbuffers::Offset>> trackers_id = 0) { + TrackingChecklistTrackerErrorBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); return builder_.Finish(); } -} // namespace rpc - -namespace pub_sub { +inline flatbuffers::Offset CreateTrackingChecklistTrackerErrorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistTrackerError( + _fbb, + trackers_id__); +} -/// A `TopicId` identifies an application-specific category of data. Because it -/// is application-specific, it is up to the application within the specified -/// organization to define its semantics/meaning. -/// -/// For example, "bob" may have an "overlay" app with a "settings" topic for controlling -/// the overlay visibility and other settings, as well as a "video feed" topic for -/// allowing other applications to display video data in a wrist mounted window in VR. -struct TopicId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { - typedef TopicIdBuilder Builder; +struct TrackingChecklistNeedCalibration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistNeedCalibrationBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { - VT_ORGANIZATION = 4, - VT_APP_NAME = 6, - VT_TOPIC = 8 + VT_TRACKERS_ID = 4 }; - /// The organization/developer that defines the meaning of this feature. Avoids name + const flatbuffers::Vector> *trackers_id() const { + return GetPointer> *>(VT_TRACKERS_ID); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TRACKERS_ID) && + verifier.VerifyVector(trackers_id()) && + verifier.VerifyVectorOfTables(trackers_id()) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistNeedCalibrationBuilder { + typedef TrackingChecklistNeedCalibration Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_trackers_id(flatbuffers::Offset>> trackers_id) { + fbb_.AddOffset(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, trackers_id); + } + explicit TrackingChecklistNeedCalibrationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistNeedCalibration( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> trackers_id = 0) { + TrackingChecklistNeedCalibrationBuilder builder_(_fbb); + builder_.add_trackers_id(trackers_id); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTrackingChecklistNeedCalibrationDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *trackers_id = nullptr) { + auto trackers_id__ = trackers_id ? _fbb.CreateVector>(*trackers_id) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistNeedCalibration( + _fbb, + trackers_id__); +} + +struct TrackingChecklistSteamVRDisconnected FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistSteamVRDisconnectedBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BRIDGE_SETTINGS_NAME = 4 + }; + /// Name of bridge in the server's config + const flatbuffers::String *bridge_settings_name() const { + return GetPointer(VT_BRIDGE_SETTINGS_NAME); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BRIDGE_SETTINGS_NAME) && + verifier.VerifyString(bridge_settings_name()) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistSteamVRDisconnectedBuilder { + typedef TrackingChecklistSteamVRDisconnected Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_bridge_settings_name(flatbuffers::Offset bridge_settings_name) { + fbb_.AddOffset(TrackingChecklistSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); + } + explicit TrackingChecklistSteamVRDisconnectedBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnected( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset bridge_settings_name = 0) { + TrackingChecklistSteamVRDisconnectedBuilder builder_(_fbb); + builder_.add_bridge_settings_name(bridge_settings_name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTrackingChecklistSteamVRDisconnectedDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *bridge_settings_name = nullptr) { + auto bridge_settings_name__ = bridge_settings_name ? _fbb.CreateString(bridge_settings_name) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistSteamVRDisconnected( + _fbb, + bridge_settings_name__); +} + +struct TrackingChecklistUnassignedHMD FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistUnassignedHMDBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_TRACKER_ID = 4 + }; + const solarxr_protocol::datatypes::TrackerId *tracker_id() const { + return GetPointer(VT_TRACKER_ID); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_TRACKER_ID) && + verifier.VerifyTable(tracker_id()) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistUnassignedHMDBuilder { + typedef TrackingChecklistUnassignedHMD Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_tracker_id(flatbuffers::Offset tracker_id) { + fbb_.AddOffset(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id); + } + explicit TrackingChecklistUnassignedHMDBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistUnassignedHMD( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset tracker_id = 0) { + TrackingChecklistUnassignedHMDBuilder builder_(_fbb); + builder_.add_tracker_id(tracker_id); + return builder_.Finish(); +} + +struct TrackingChecklistPublicNetworks FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistPublicNetworksBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ADAPTERS = 4 + }; + const flatbuffers::Vector> *adapters() const { + return GetPointer> *>(VT_ADAPTERS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ADAPTERS) && + verifier.VerifyVector(adapters()) && + verifier.VerifyVectorOfStrings(adapters()) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistPublicNetworksBuilder { + typedef TrackingChecklistPublicNetworks Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_adapters(flatbuffers::Offset>> adapters) { + fbb_.AddOffset(TrackingChecklistPublicNetworks::VT_ADAPTERS, adapters); + } + explicit TrackingChecklistPublicNetworksBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistPublicNetworks( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> adapters = 0) { + TrackingChecklistPublicNetworksBuilder builder_(_fbb); + builder_.add_adapters(adapters); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTrackingChecklistPublicNetworksDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *adapters = nullptr) { + auto adapters__ = adapters ? _fbb.CreateVector>(*adapters) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistPublicNetworks( + _fbb, + adapters__); +} + +struct TrackingChecklistStep FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistStepBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_VALID = 6, + VT_ENABLED = 8, + VT_VISIBILITY = 10, + VT_OPTIONAL = 12, + VT_IGNORABLE = 14, + VT_EXTRA_DATA_TYPE = 16, + VT_EXTRA_DATA = 18 + }; + solarxr_protocol::rpc::TrackingChecklistStepId id() const { + return static_cast(GetField(VT_ID, 0)); + } + bool valid() const { + return GetField(VT_VALID, 0) != 0; + } + bool enabled() const { + return GetField(VT_ENABLED, 0) != 0; + } + solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility() const { + return static_cast(GetField(VT_VISIBILITY, 0)); + } + bool optional() const { + return GetField(VT_OPTIONAL, 0) != 0; + } + bool ignorable() const { + return GetField(VT_IGNORABLE, 0) != 0; + } + solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type() const { + return static_cast(GetField(VT_EXTRA_DATA_TYPE, 0)); + } + const void *extra_data() const { + return GetPointer(VT_EXTRA_DATA); + } + template const T *extra_data_as() const; + const solarxr_protocol::rpc::TrackingChecklistTrackerReset *extra_data_as_TrackingChecklistTrackerReset() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerReset ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistTrackerError *extra_data_as_TrackingChecklistTrackerError() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistTrackerError ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *extra_data_as_TrackingChecklistSteamVRDisconnected() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *extra_data_as_TrackingChecklistUnassignedHMD() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistUnassignedHMD ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *extra_data_as_TrackingChecklistNeedCalibration() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistNeedCalibration ? static_cast(extra_data()) : nullptr; + } + const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *extra_data_as_TrackingChecklistPublicNetworks() const { + return extra_data_type() == solarxr_protocol::rpc::TrackingChecklistExtraData::TrackingChecklistPublicNetworks ? static_cast(extra_data()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 1) && + VerifyField(verifier, VT_VALID, 1) && + VerifyField(verifier, VT_ENABLED, 1) && + VerifyField(verifier, VT_VISIBILITY, 1) && + VerifyField(verifier, VT_OPTIONAL, 1) && + VerifyField(verifier, VT_IGNORABLE, 1) && + VerifyField(verifier, VT_EXTRA_DATA_TYPE, 1) && + VerifyOffset(verifier, VT_EXTRA_DATA) && + VerifyTrackingChecklistExtraData(verifier, extra_data(), extra_data_type()) && + verifier.EndTable(); + } +}; + +template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerReset *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistTrackerReset(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistTrackerError *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistTrackerError(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistSteamVRDisconnected *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistSteamVRDisconnected(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistUnassignedHMD *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistUnassignedHMD(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistNeedCalibration *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistNeedCalibration(); +} + +template<> inline const solarxr_protocol::rpc::TrackingChecklistPublicNetworks *TrackingChecklistStep::extra_data_as() const { + return extra_data_as_TrackingChecklistPublicNetworks(); +} + +struct TrackingChecklistStepBuilder { + typedef TrackingChecklistStep Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(solarxr_protocol::rpc::TrackingChecklistStepId id) { + fbb_.AddElement(TrackingChecklistStep::VT_ID, static_cast(id), 0); + } + void add_valid(bool valid) { + fbb_.AddElement(TrackingChecklistStep::VT_VALID, static_cast(valid), 0); + } + void add_enabled(bool enabled) { + fbb_.AddElement(TrackingChecklistStep::VT_ENABLED, static_cast(enabled), 0); + } + void add_visibility(solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility) { + fbb_.AddElement(TrackingChecklistStep::VT_VISIBILITY, static_cast(visibility), 0); + } + void add_optional(bool optional) { + fbb_.AddElement(TrackingChecklistStep::VT_OPTIONAL, static_cast(optional), 0); + } + void add_ignorable(bool ignorable) { + fbb_.AddElement(TrackingChecklistStep::VT_IGNORABLE, static_cast(ignorable), 0); + } + void add_extra_data_type(solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type) { + fbb_.AddElement(TrackingChecklistStep::VT_EXTRA_DATA_TYPE, static_cast(extra_data_type), 0); + } + void add_extra_data(flatbuffers::Offset extra_data) { + fbb_.AddOffset(TrackingChecklistStep::VT_EXTRA_DATA, extra_data); + } + explicit TrackingChecklistStepBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistStep( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::TrackingChecklistStepId id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, + bool valid = false, + bool enabled = false, + solarxr_protocol::rpc::TrackingChecklistStepVisibility visibility = solarxr_protocol::rpc::TrackingChecklistStepVisibility::ALWAYS, + bool optional = false, + bool ignorable = false, + solarxr_protocol::rpc::TrackingChecklistExtraData extra_data_type = solarxr_protocol::rpc::TrackingChecklistExtraData::NONE, + flatbuffers::Offset extra_data = 0) { + TrackingChecklistStepBuilder builder_(_fbb); + builder_.add_extra_data(extra_data); + builder_.add_extra_data_type(extra_data_type); + builder_.add_ignorable(ignorable); + builder_.add_optional(optional); + builder_.add_visibility(visibility); + builder_.add_enabled(enabled); + builder_.add_valid(valid); + builder_.add_id(id); + return builder_.Finish(); +} + +struct TrackingChecklistRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistRequestBuilder { + typedef TrackingChecklistRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit TrackingChecklistRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + TrackingChecklistRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct TrackingChecklistResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TrackingChecklistResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_STEPS = 4, + VT_IGNORED_STEPS = 6 + }; + const flatbuffers::Vector> *steps() const { + return GetPointer> *>(VT_STEPS); + } + const flatbuffers::Vector *ignored_steps() const { + return GetPointer *>(VT_IGNORED_STEPS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_STEPS) && + verifier.VerifyVector(steps()) && + verifier.VerifyVectorOfTables(steps()) && + VerifyOffset(verifier, VT_IGNORED_STEPS) && + verifier.VerifyVector(ignored_steps()) && + verifier.EndTable(); + } +}; + +struct TrackingChecklistResponseBuilder { + typedef TrackingChecklistResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_steps(flatbuffers::Offset>> steps) { + fbb_.AddOffset(TrackingChecklistResponse::VT_STEPS, steps); + } + void add_ignored_steps(flatbuffers::Offset> ignored_steps) { + fbb_.AddOffset(TrackingChecklistResponse::VT_IGNORED_STEPS, ignored_steps); + } + explicit TrackingChecklistResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTrackingChecklistResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> steps = 0, + flatbuffers::Offset> ignored_steps = 0) { + TrackingChecklistResponseBuilder builder_(_fbb); + builder_.add_ignored_steps(ignored_steps); + builder_.add_steps(steps); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTrackingChecklistResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *steps = nullptr, + const std::vector *ignored_steps = nullptr) { + auto steps__ = steps ? _fbb.CreateVector>(*steps) : 0; + auto ignored_steps__ = ignored_steps ? _fbb.CreateVector(*ignored_steps) : 0; + return solarxr_protocol::rpc::CreateTrackingChecklistResponse( + _fbb, + steps__, + ignored_steps__); +} + +struct IgnoreTrackingChecklistStepRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef IgnoreTrackingChecklistStepRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_STEP_ID = 4, + VT_IGNORE = 6 + }; + solarxr_protocol::rpc::TrackingChecklistStepId step_id() const { + return static_cast(GetField(VT_STEP_ID, 0)); + } + bool ignore() const { + return GetField(VT_IGNORE, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_STEP_ID, 1) && + VerifyField(verifier, VT_IGNORE, 1) && + verifier.EndTable(); + } +}; + +struct IgnoreTrackingChecklistStepRequestBuilder { + typedef IgnoreTrackingChecklistStepRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_step_id(solarxr_protocol::rpc::TrackingChecklistStepId step_id) { + fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_STEP_ID, static_cast(step_id), 0); + } + void add_ignore(bool ignore) { + fbb_.AddElement(IgnoreTrackingChecklistStepRequest::VT_IGNORE, static_cast(ignore), 0); + } + explicit IgnoreTrackingChecklistStepRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateIgnoreTrackingChecklistStepRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::TrackingChecklistStepId step_id = solarxr_protocol::rpc::TrackingChecklistStepId::UNKNOWN, + bool ignore = false) { + IgnoreTrackingChecklistStepRequestBuilder builder_(_fbb); + builder_.add_ignore(ignore); + builder_.add_step_id(step_id); + return builder_.Finish(); +} + +struct EnableStayAlignedRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef EnableStayAlignedRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ENABLE = 4 + }; + bool enable() const { + return GetField(VT_ENABLE, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ENABLE, 1) && + verifier.EndTable(); + } +}; + +struct EnableStayAlignedRequestBuilder { + typedef EnableStayAlignedRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_enable(bool enable) { + fbb_.AddElement(EnableStayAlignedRequest::VT_ENABLE, static_cast(enable), 0); + } + explicit EnableStayAlignedRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateEnableStayAlignedRequest( + flatbuffers::FlatBufferBuilder &_fbb, + bool enable = false) { + EnableStayAlignedRequestBuilder builder_(_fbb); + builder_.add_enable(enable); + return builder_.Finish(); +} + +struct DetectStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef DetectStayAlignedRelaxedPoseRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POSE = 4 + }; + solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { + return static_cast(GetField(VT_POSE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POSE, 1) && + verifier.EndTable(); + } +}; + +struct DetectStayAlignedRelaxedPoseRequestBuilder { + typedef DetectStayAlignedRelaxedPoseRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { + fbb_.AddElement(DetectStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); + } + explicit DetectStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateDetectStayAlignedRelaxedPoseRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { + DetectStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); + builder_.add_pose(pose); + return builder_.Finish(); +} + +struct ResetStayAlignedRelaxedPoseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResetStayAlignedRelaxedPoseRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POSE = 4 + }; + solarxr_protocol::rpc::StayAlignedRelaxedPose pose() const { + return static_cast(GetField(VT_POSE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POSE, 1) && + verifier.EndTable(); + } +}; + +struct ResetStayAlignedRelaxedPoseRequestBuilder { + typedef ResetStayAlignedRelaxedPoseRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pose(solarxr_protocol::rpc::StayAlignedRelaxedPose pose) { + fbb_.AddElement(ResetStayAlignedRelaxedPoseRequest::VT_POSE, static_cast(pose), 0); + } + explicit ResetStayAlignedRelaxedPoseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateResetStayAlignedRelaxedPoseRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::StayAlignedRelaxedPose pose = solarxr_protocol::rpc::StayAlignedRelaxedPose::STANDING) { + ResetStayAlignedRelaxedPoseRequestBuilder builder_(_fbb); + builder_.add_pose(pose); + return builder_.Finish(); +} + +} // namespace rpc + +namespace pub_sub { + +/// A `TopicId` identifies an application-specific category of data. Because it +/// is application-specific, it is up to the application within the specified +/// organization to define its semantics/meaning. +/// +/// For example, "bob" may have an "overlay" app with a "settings" topic for controlling +/// the overlay visibility and other settings, as well as a "video feed" topic for +/// allowing other applications to display video data in a wrist mounted window in VR. +struct TopicId FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TopicIdBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ORGANIZATION = 4, + VT_APP_NAME = 6, + VT_TOPIC = 8 + }; + /// The organization/developer that defines the meaning of this feature. Avoids name /// clashes. Should be something unique - same idea as java package identifier. const flatbuffers::String *organization() const { return GetPointer(VT_ORGANIZATION); @@ -12608,6 +13702,10 @@ namespace device_data { } // namespace device_data +namespace server { + +} // namespace server + } // namespace data_feed namespace rpc { @@ -12953,6 +14051,22 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::VRCConfigSettingToggleMute: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::TrackingChecklistRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::TrackingChecklistResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::IgnoreTrackingChecklistStepRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } @@ -13068,6 +14182,51 @@ inline bool VerifyFirmwareUpdateMethodVector(flatbuffers::Verifier &verifier, co return true; } +inline bool VerifyTrackingChecklistExtraData(flatbuffers::Verifier &verifier, const void *obj, TrackingChecklistExtraData type) { + switch (type) { + case TrackingChecklistExtraData::NONE: { + return true; + } + case TrackingChecklistExtraData::TrackingChecklistTrackerReset: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistTrackerError: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistUnassignedHMD: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistNeedCalibration: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case TrackingChecklistExtraData::TrackingChecklistPublicNetworks: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyTrackingChecklistExtraDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyTrackingChecklistExtraData( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + } // namespace rpc namespace pub_sub { diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java index ead67c21..fbb2cc16 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java @@ -30,28 +30,32 @@ public final class DataFeedConfig extends Table { public solarxr_protocol.data_feed.tracker.TrackerDataMask syntheticTrackersMask(solarxr_protocol.data_feed.tracker.TrackerDataMask obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public boolean boneMask() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public boolean stayAlignedPoseMask() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean serverGuardsMask() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } public static int createDataFeedConfig(FlatBufferBuilder builder, int minimumTimeSinceLast, int dataMaskOffset, int syntheticTrackersMaskOffset, boolean boneMask, - boolean stayAlignedPoseMask) { - builder.startTable(5); + boolean stayAlignedPoseMask, + boolean serverGuardsMask) { + builder.startTable(6); DataFeedConfig.addSyntheticTrackersMask(builder, syntheticTrackersMaskOffset); DataFeedConfig.addDataMask(builder, dataMaskOffset); DataFeedConfig.addMinimumTimeSinceLast(builder, minimumTimeSinceLast); + DataFeedConfig.addServerGuardsMask(builder, serverGuardsMask); DataFeedConfig.addStayAlignedPoseMask(builder, stayAlignedPoseMask); DataFeedConfig.addBoneMask(builder, boneMask); return DataFeedConfig.endDataFeedConfig(builder); } - public static void startDataFeedConfig(FlatBufferBuilder builder) { builder.startTable(5); } + public static void startDataFeedConfig(FlatBufferBuilder builder) { builder.startTable(6); } public static void addMinimumTimeSinceLast(FlatBufferBuilder builder, int minimumTimeSinceLast) { builder.addShort(0, (short) minimumTimeSinceLast, (short) 0); } public static void addDataMask(FlatBufferBuilder builder, int dataMaskOffset) { builder.addOffset(1, dataMaskOffset, 0); } public static void addSyntheticTrackersMask(FlatBufferBuilder builder, int syntheticTrackersMaskOffset) { builder.addOffset(2, syntheticTrackersMaskOffset, 0); } public static void addBoneMask(FlatBufferBuilder builder, boolean boneMask) { builder.addBoolean(3, boneMask, false); } public static void addStayAlignedPoseMask(FlatBufferBuilder builder, boolean stayAlignedPoseMask) { builder.addBoolean(4, stayAlignedPoseMask, false); } + public static void addServerGuardsMask(FlatBufferBuilder builder, boolean serverGuardsMask) { builder.addBoolean(5, serverGuardsMask, false); } public static int endDataFeedConfig(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -79,6 +83,8 @@ public void unpackTo(DataFeedConfigT _o) { _o.setBoneMask(_oBoneMask); boolean _oStayAlignedPoseMask = stayAlignedPoseMask(); _o.setStayAlignedPoseMask(_oStayAlignedPoseMask); + boolean _oServerGuardsMask = serverGuardsMask(); + _o.setServerGuardsMask(_oServerGuardsMask); } public static int pack(FlatBufferBuilder builder, DataFeedConfigT _o) { if (_o == null) return 0; @@ -90,7 +96,8 @@ public static int pack(FlatBufferBuilder builder, DataFeedConfigT _o) { _dataMask, _syntheticTrackersMask, _o.getBoneMask(), - _o.getStayAlignedPoseMask()); + _o.getStayAlignedPoseMask(), + _o.getServerGuardsMask()); } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java index 1b0910a0..918d3c85 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java @@ -13,6 +13,7 @@ public class DataFeedConfigT { private solarxr_protocol.data_feed.tracker.TrackerDataMaskT syntheticTrackersMask; private boolean boneMask; private boolean stayAlignedPoseMask; + private boolean serverGuardsMask; public int getMinimumTimeSinceLast() { return minimumTimeSinceLast; } @@ -34,6 +35,10 @@ public class DataFeedConfigT { public void setStayAlignedPoseMask(boolean stayAlignedPoseMask) { this.stayAlignedPoseMask = stayAlignedPoseMask; } + public boolean getServerGuardsMask() { return serverGuardsMask; } + + public void setServerGuardsMask(boolean serverGuardsMask) { this.serverGuardsMask = serverGuardsMask; } + public DataFeedConfigT() { this.minimumTimeSinceLast = 0; @@ -41,6 +46,7 @@ public DataFeedConfigT() { this.syntheticTrackersMask = null; this.boneMask = false; this.stayAlignedPoseMask = false; + this.serverGuardsMask = false; } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java index c9ccd8d9..9d8a51b3 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java @@ -45,14 +45,18 @@ public final class DataFeedUpdate extends Table { public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose() { return stayAlignedPose(new solarxr_protocol.data_feed.stay_aligned.StayAlignedPose()); } public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose(solarxr_protocol.data_feed.stay_aligned.StayAlignedPose obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public int index() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public solarxr_protocol.data_feed.server.ServerGuards serverGuards() { return serverGuards(new solarxr_protocol.data_feed.server.ServerGuards()); } + public solarxr_protocol.data_feed.server.ServerGuards serverGuards(solarxr_protocol.data_feed.server.ServerGuards obj) { int o = __offset(14); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public static int createDataFeedUpdate(FlatBufferBuilder builder, int devicesOffset, int syntheticTrackersOffset, int bonesOffset, int stayAlignedPoseOffset, - int index) { - builder.startTable(5); + int index, + int serverGuardsOffset) { + builder.startTable(6); + DataFeedUpdate.addServerGuards(builder, serverGuardsOffset); DataFeedUpdate.addStayAlignedPose(builder, stayAlignedPoseOffset); DataFeedUpdate.addBones(builder, bonesOffset); DataFeedUpdate.addSyntheticTrackers(builder, syntheticTrackersOffset); @@ -61,7 +65,7 @@ public static int createDataFeedUpdate(FlatBufferBuilder builder, return DataFeedUpdate.endDataFeedUpdate(builder); } - public static void startDataFeedUpdate(FlatBufferBuilder builder) { builder.startTable(5); } + public static void startDataFeedUpdate(FlatBufferBuilder builder) { builder.startTable(6); } public static void addDevices(FlatBufferBuilder builder, int devicesOffset) { builder.addOffset(0, devicesOffset, 0); } public static int createDevicesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } public static void startDevicesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } @@ -73,6 +77,7 @@ public static int createDataFeedUpdate(FlatBufferBuilder builder, public static void startBonesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static void addStayAlignedPose(FlatBufferBuilder builder, int stayAlignedPoseOffset) { builder.addOffset(3, stayAlignedPoseOffset, 0); } public static void addIndex(FlatBufferBuilder builder, int index) { builder.addByte(4, (byte) index, (byte) 0); } + public static void addServerGuards(FlatBufferBuilder builder, int serverGuardsOffset) { builder.addOffset(5, serverGuardsOffset, 0); } public static int endDataFeedUpdate(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -103,6 +108,8 @@ public void unpackTo(DataFeedUpdateT _o) { else _o.setStayAlignedPose(null); int _oIndex = index(); _o.setIndex(_oIndex); + if (serverGuards() != null) _o.setServerGuards(serverGuards().unpack()); + else _o.setServerGuards(null); } public static int pack(FlatBufferBuilder builder, DataFeedUpdateT _o) { if (_o == null) return 0; @@ -128,13 +135,15 @@ public static int pack(FlatBufferBuilder builder, DataFeedUpdateT _o) { _bones = createBonesVector(builder, __bones); } int _stayAlignedPose = _o.getStayAlignedPose() == null ? 0 : solarxr_protocol.data_feed.stay_aligned.StayAlignedPose.pack(builder, _o.getStayAlignedPose()); + int _serverGuards = _o.getServerGuards() == null ? 0 : solarxr_protocol.data_feed.server.ServerGuards.pack(builder, _o.getServerGuards()); return createDataFeedUpdate( builder, _devices, _syntheticTrackers, _bones, _stayAlignedPose, - _o.getIndex()); + _o.getIndex(), + _serverGuards); } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java index d143a5a0..a80e0eb2 100644 --- a/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java +++ b/protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java @@ -13,6 +13,7 @@ public class DataFeedUpdateT { private solarxr_protocol.data_feed.BoneT[] bones; private solarxr_protocol.data_feed.stay_aligned.StayAlignedPoseT stayAlignedPose; private int index; + private solarxr_protocol.data_feed.server.ServerGuardsT serverGuards; public solarxr_protocol.data_feed.device_data.DeviceDataT[] getDevices() { return devices; } @@ -34,6 +35,10 @@ public class DataFeedUpdateT { public void setIndex(int index) { this.index = index; } + public solarxr_protocol.data_feed.server.ServerGuardsT getServerGuards() { return serverGuards; } + + public void setServerGuards(solarxr_protocol.data_feed.server.ServerGuardsT serverGuards) { this.serverGuards = serverGuards; } + public DataFeedUpdateT() { this.devices = null; @@ -41,6 +46,7 @@ public DataFeedUpdateT() { this.bones = null; this.stayAlignedPose = null; this.index = 0; + this.serverGuards = null; } } diff --git a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java new file mode 100644 index 00000000..a5eb2e11 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuards.java @@ -0,0 +1,63 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.data_feed.server; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ServerGuards extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ServerGuards getRootAsServerGuards(ByteBuffer _bb) { return getRootAsServerGuards(_bb, new ServerGuards()); } + public static ServerGuards getRootAsServerGuards(ByteBuffer _bb, ServerGuards 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 ServerGuards __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public boolean canDoMounting() { int o = __offset(4); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean canDoYawReset() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createServerGuards(FlatBufferBuilder builder, + boolean canDoMounting, + boolean canDoYawReset) { + builder.startTable(2); + ServerGuards.addCanDoYawReset(builder, canDoYawReset); + ServerGuards.addCanDoMounting(builder, canDoMounting); + return ServerGuards.endServerGuards(builder); + } + + public static void startServerGuards(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addCanDoMounting(FlatBufferBuilder builder, boolean canDoMounting) { builder.addBoolean(0, canDoMounting, false); } + public static void addCanDoYawReset(FlatBufferBuilder builder, boolean canDoYawReset) { builder.addBoolean(1, canDoYawReset, false); } + public static int endServerGuards(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 ServerGuards get(int j) { return get(new ServerGuards(), j); } + public ServerGuards get(ServerGuards obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ServerGuardsT unpack() { + ServerGuardsT _o = new ServerGuardsT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ServerGuardsT _o) { + boolean _oCanDoMounting = canDoMounting(); + _o.setCanDoMounting(_oCanDoMounting); + boolean _oCanDoYawReset = canDoYawReset(); + _o.setCanDoYawReset(_oCanDoYawReset); + } + public static int pack(FlatBufferBuilder builder, ServerGuardsT _o) { + if (_o == null) return 0; + return createServerGuards( + builder, + _o.getCanDoMounting(), + _o.getCanDoYawReset()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java new file mode 100644 index 00000000..84263182 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/data_feed/server/ServerGuardsT.java @@ -0,0 +1,28 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.data_feed.server; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ServerGuardsT { + private boolean canDoMounting; + private boolean canDoYawReset; + + public boolean getCanDoMounting() { return canDoMounting; } + + public void setCanDoMounting(boolean canDoMounting) { this.canDoMounting = canDoMounting; } + + public boolean getCanDoYawReset() { return canDoYawReset; } + + public void setCanDoYawReset(boolean canDoYawReset) { this.canDoYawReset = canDoYawReset; } + + + public ServerGuardsT() { + this.canDoMounting = false; + this.canDoYawReset = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java index af4c96fe..84e65739 100644 --- a/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java +++ b/protocol/java/src/solarxr_protocol/rpc/FirmwareUpdateStatus.java @@ -53,7 +53,7 @@ private FirmwareUpdateStatus() { } */ public static final int ERROR_AUTHENTICATION_FAILED = 11; /** - * Could not upload the firmware to the MUC + * Could not upload the firmware to the MCU */ public static final int ERROR_UPLOAD_FAILED = 12; /** diff --git a/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.java b/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.java new file mode 100644 index 00000000..bc76601f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.java @@ -0,0 +1,63 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class IgnoreTrackingChecklistStepRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static IgnoreTrackingChecklistStepRequest getRootAsIgnoreTrackingChecklistStepRequest(ByteBuffer _bb) { return getRootAsIgnoreTrackingChecklistStepRequest(_bb, new IgnoreTrackingChecklistStepRequest()); } + public static IgnoreTrackingChecklistStepRequest getRootAsIgnoreTrackingChecklistStepRequest(ByteBuffer _bb, IgnoreTrackingChecklistStepRequest 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 IgnoreTrackingChecklistStepRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int stepId() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean ignore() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + + public static int createIgnoreTrackingChecklistStepRequest(FlatBufferBuilder builder, + int stepId, + boolean ignore) { + builder.startTable(2); + IgnoreTrackingChecklistStepRequest.addIgnore(builder, ignore); + IgnoreTrackingChecklistStepRequest.addStepId(builder, stepId); + return IgnoreTrackingChecklistStepRequest.endIgnoreTrackingChecklistStepRequest(builder); + } + + public static void startIgnoreTrackingChecklistStepRequest(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addStepId(FlatBufferBuilder builder, int stepId) { builder.addByte(0, (byte) stepId, (byte) 0); } + public static void addIgnore(FlatBufferBuilder builder, boolean ignore) { builder.addBoolean(1, ignore, false); } + public static int endIgnoreTrackingChecklistStepRequest(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 IgnoreTrackingChecklistStepRequest get(int j) { return get(new IgnoreTrackingChecklistStepRequest(), j); } + public IgnoreTrackingChecklistStepRequest get(IgnoreTrackingChecklistStepRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public IgnoreTrackingChecklistStepRequestT unpack() { + IgnoreTrackingChecklistStepRequestT _o = new IgnoreTrackingChecklistStepRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(IgnoreTrackingChecklistStepRequestT _o) { + int _oStepId = stepId(); + _o.setStepId(_oStepId); + boolean _oIgnore = ignore(); + _o.setIgnore(_oIgnore); + } + public static int pack(FlatBufferBuilder builder, IgnoreTrackingChecklistStepRequestT _o) { + if (_o == null) return 0; + return createIgnoreTrackingChecklistStepRequest( + builder, + _o.getStepId(), + _o.getIgnore()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequestT.java b/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequestT.java new file mode 100644 index 00000000..aff752fc --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequestT.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 IgnoreTrackingChecklistStepRequestT { + private int stepId; + private boolean ignore; + + public int getStepId() { return stepId; } + + public void setStepId(int stepId) { this.stepId = stepId; } + + public boolean getIgnore() { return ignore; } + + public void setIgnore(boolean ignore) { this.ignore = ignore; } + + + public IgnoreTrackingChecklistStepRequestT() { + this.stepId = 0; + this.ignore = false; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java b/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java index 23a56dc7..64662104 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetResponse.java @@ -17,19 +17,47 @@ public final class ResetResponse extends Table { public int resetType() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } public int status() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + /** + * Should return the body parts reseted / being reset + */ + public int bodyParts(int j) { int o = __offset(8); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int bodyPartsLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; } + public ByteVector bodyPartsVector() { return bodyPartsVector(new ByteVector()); } + public ByteVector bodyPartsVector(ByteVector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer bodyPartsAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } + public ByteBuffer bodyPartsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } + /** + * gives the time in seconds passed since the start of the reset + * is 0 when status == FINISHED + * starts at 0 + */ + public int progress() { int o = __offset(10); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public int duration() { int o = __offset(12); return o != 0 ? bb.getInt(o + bb_pos) : 0; } public static int createResetResponse(FlatBufferBuilder builder, int resetType, - int status) { - builder.startTable(2); + int status, + int bodyPartsOffset, + int progress, + int duration) { + builder.startTable(5); + ResetResponse.addDuration(builder, duration); + ResetResponse.addProgress(builder, progress); + ResetResponse.addBodyParts(builder, bodyPartsOffset); ResetResponse.addStatus(builder, status); ResetResponse.addResetType(builder, resetType); return ResetResponse.endResetResponse(builder); } - public static void startResetResponse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void startResetResponse(FlatBufferBuilder builder) { builder.startTable(5); } public static void addResetType(FlatBufferBuilder builder, int resetType) { builder.addByte(0, (byte) resetType, (byte) 0); } public static void addStatus(FlatBufferBuilder builder, int status) { builder.addByte(1, (byte) status, (byte) 0); } + public static void addBodyParts(FlatBufferBuilder builder, int bodyPartsOffset) { builder.addOffset(2, bodyPartsOffset, 0); } + public static int createBodyPartsVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createBodyPartsVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startBodyPartsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addProgress(FlatBufferBuilder builder, int progress) { builder.addInt(3, progress, 0); } + public static void addDuration(FlatBufferBuilder builder, int duration) { builder.addInt(4, duration, 0); } public static int endResetResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -51,13 +79,30 @@ public void unpackTo(ResetResponseT _o) { _o.setResetType(_oResetType); int _oStatus = status(); _o.setStatus(_oStatus); + int[] _oBodyParts = new int[bodyPartsLength()]; + for (int _j = 0; _j < bodyPartsLength(); ++_j) {_oBodyParts[_j] = bodyParts(_j);} + _o.setBodyParts(_oBodyParts); + int _oProgress = progress(); + _o.setProgress(_oProgress); + int _oDuration = duration(); + _o.setDuration(_oDuration); } public static int pack(FlatBufferBuilder builder, ResetResponseT _o) { if (_o == null) return 0; + int _bodyParts = 0; + if (_o.getBodyParts() != null) { + byte[] __bodyParts = new byte[_o.getBodyParts().length]; + int _j = 0; + for (int _e : _o.getBodyParts()) { __bodyParts[_j] = (byte) _e; _j++;} + _bodyParts = createBodyPartsVector(builder, __bodyParts); + } return createResetResponse( builder, _o.getResetType(), - _o.getStatus()); + _o.getStatus(), + _bodyParts, + _o.getProgress(), + _o.getDuration()); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ResetResponseT.java b/protocol/java/src/solarxr_protocol/rpc/ResetResponseT.java index eed7e36b..9f7c1860 100644 --- a/protocol/java/src/solarxr_protocol/rpc/ResetResponseT.java +++ b/protocol/java/src/solarxr_protocol/rpc/ResetResponseT.java @@ -10,6 +10,9 @@ public class ResetResponseT { private int resetType; private int status; + private int[] bodyParts; + private int progress; + private int duration; public int getResetType() { return resetType; } @@ -19,10 +22,25 @@ public class ResetResponseT { public void setStatus(int status) { this.status = status; } + public int[] getBodyParts() { return bodyParts; } + + public void setBodyParts(int[] bodyParts) { this.bodyParts = bodyParts; } + + public int getProgress() { return progress; } + + public void setProgress(int progress) { this.progress = progress; } + + public int getDuration() { return duration; } + + public void setDuration(int duration) { this.duration = duration; } + public ResetResponseT() { this.resetType = 0; this.status = 0; + this.bodyParts = null; + this.progress = 0; + this.duration = 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index bc1b48dd..304c5ea4 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -77,8 +77,12 @@ private RpcMessage() { } public static final byte DetectStayAlignedRelaxedPoseRequest = 69; public static final byte ResetStayAlignedRelaxedPoseRequest = 70; public static final byte SerialTrackerCustomCommandRequest = 71; + public static final byte VRCConfigSettingToggleMute = 72; + public static final byte TrackingChecklistRequest = 73; + public static final byte TrackingChecklistResponse = 74; + public static final byte IgnoreTrackingChecklistStepRequest = 75; - public static final 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", }; + 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", }; 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 da58b857..f51b95cf 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -336,6 +336,22 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.SerialTrackerCustomCommandRequest()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.SerialTrackerCustomCommandRequest) _oMessageValue).unpack() : null); break; + case solarxr_protocol.rpc.RpcMessage.VRCConfigSettingToggleMute: + _oMessageValue = message(new solarxr_protocol.rpc.VRCConfigSettingToggleMute()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VRCConfigSettingToggleMute) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.TrackingChecklistRequest: + _oMessageValue = message(new solarxr_protocol.rpc.TrackingChecklistRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.TrackingChecklistRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.TrackingChecklistResponse: + _oMessageValue = message(new solarxr_protocol.rpc.TrackingChecklistResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.TrackingChecklistResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.IgnoreTrackingChecklistStepRequest: + _oMessageValue = message(new solarxr_protocol.rpc.IgnoreTrackingChecklistStepRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.IgnoreTrackingChecklistStepRequest) _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 6da58fbc..3316339f 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -92,6 +92,10 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.DetectStayAlignedRelaxedPoseRequestT asDetectStayAlignedRelaxedPoseRequest() { return (solarxr_protocol.rpc.DetectStayAlignedRelaxedPoseRequestT) value; } public solarxr_protocol.rpc.ResetStayAlignedRelaxedPoseRequestT asResetStayAlignedRelaxedPoseRequest() { return (solarxr_protocol.rpc.ResetStayAlignedRelaxedPoseRequestT) value; } public solarxr_protocol.rpc.SerialTrackerCustomCommandRequestT asSerialTrackerCustomCommandRequest() { return (solarxr_protocol.rpc.SerialTrackerCustomCommandRequestT) value; } + public solarxr_protocol.rpc.VRCConfigSettingToggleMuteT asVRCConfigSettingToggleMute() { return (solarxr_protocol.rpc.VRCConfigSettingToggleMuteT) value; } + public solarxr_protocol.rpc.TrackingChecklistRequestT asTrackingChecklistRequest() { return (solarxr_protocol.rpc.TrackingChecklistRequestT) value; } + public solarxr_protocol.rpc.TrackingChecklistResponseT asTrackingChecklistResponse() { return (solarxr_protocol.rpc.TrackingChecklistResponseT) value; } + public solarxr_protocol.rpc.IgnoreTrackingChecklistStepRequestT asIgnoreTrackingChecklistStepRequest() { return (solarxr_protocol.rpc.IgnoreTrackingChecklistStepRequestT) value; } public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { switch (_o.type) { @@ -166,6 +170,10 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.DetectStayAlignedRelaxedPoseRequest: return solarxr_protocol.rpc.DetectStayAlignedRelaxedPoseRequest.pack(builder, _o.asDetectStayAlignedRelaxedPoseRequest()); case RpcMessage.ResetStayAlignedRelaxedPoseRequest: return solarxr_protocol.rpc.ResetStayAlignedRelaxedPoseRequest.pack(builder, _o.asResetStayAlignedRelaxedPoseRequest()); case RpcMessage.SerialTrackerCustomCommandRequest: return solarxr_protocol.rpc.SerialTrackerCustomCommandRequest.pack(builder, _o.asSerialTrackerCustomCommandRequest()); + case RpcMessage.VRCConfigSettingToggleMute: return solarxr_protocol.rpc.VRCConfigSettingToggleMute.pack(builder, _o.asVRCConfigSettingToggleMute()); + case RpcMessage.TrackingChecklistRequest: return solarxr_protocol.rpc.TrackingChecklistRequest.pack(builder, _o.asTrackingChecklistRequest()); + case RpcMessage.TrackingChecklistResponse: return solarxr_protocol.rpc.TrackingChecklistResponse.pack(builder, _o.asTrackingChecklistResponse()); + case RpcMessage.IgnoreTrackingChecklistStepRequest: return solarxr_protocol.rpc.IgnoreTrackingChecklistStepRequest.pack(builder, _o.asIgnoreTrackingChecklistStepRequest()); default: return 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java index 964655f4..85e330b2 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java +++ b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerError.java @@ -8,7 +8,7 @@ import com.google.flatbuffers.*; /** - * Tracker has error state + * Trackers with error state */ @SuppressWarnings("unused") public final class StatusTrackerError extends Table { @@ -18,8 +18,11 @@ public final class StatusTrackerError extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public StatusTrackerError __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.datatypes.TrackerId trackerId(int j) { return trackerId(new solarxr_protocol.datatypes.TrackerId(), j); } + public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackerIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector() { return trackerIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } + public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public static int createStatusTrackerError(FlatBufferBuilder builder, int trackerIdOffset) { @@ -30,6 +33,8 @@ public static int createStatusTrackerError(FlatBufferBuilder builder, public static void startStatusTrackerError(FlatBufferBuilder builder) { builder.startTable(1); } public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static int createTrackerIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startTrackerIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static int endStatusTrackerError(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -47,12 +52,19 @@ public StatusTrackerErrorT unpack() { return _o; } public void unpackTo(StatusTrackerErrorT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + solarxr_protocol.datatypes.TrackerIdT[] _oTrackerId = new solarxr_protocol.datatypes.TrackerIdT[trackerIdLength()]; + for (int _j = 0; _j < trackerIdLength(); ++_j) {_oTrackerId[_j] = (trackerId(_j) != null ? trackerId(_j).unpack() : null);} + _o.setTrackerId(_oTrackerId); } public static int pack(FlatBufferBuilder builder, StatusTrackerErrorT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + int _trackerId = 0; + if (_o.getTrackerId() != null) { + int[] __trackerId = new int[_o.getTrackerId().length]; + int _j = 0; + for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackerId()) { __trackerId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} + _trackerId = createTrackerIdVector(builder, __trackerId); + } return createStatusTrackerError( builder, _trackerId); diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java index f3e8d4c9..b682e9af 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java +++ b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerErrorT.java @@ -8,11 +8,11 @@ import com.google.flatbuffers.*; public class StatusTrackerErrorT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private solarxr_protocol.datatypes.TrackerIdT[] trackerId; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public solarxr_protocol.datatypes.TrackerIdT[] getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT[] trackerId) { this.trackerId = trackerId; } public StatusTrackerErrorT() { diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java index 8df87217..299cd5ab 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java +++ b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerReset.java @@ -18,8 +18,11 @@ public final class StatusTrackerReset extends Table { public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } public StatusTrackerReset __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } - public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } - public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public solarxr_protocol.datatypes.TrackerId trackerId(int j) { return trackerId(new solarxr_protocol.datatypes.TrackerId(), j); } + public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackerIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector() { return trackerIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } + public solarxr_protocol.datatypes.TrackerId.Vector trackerIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public static int createStatusTrackerReset(FlatBufferBuilder builder, int trackerIdOffset) { @@ -30,6 +33,8 @@ public static int createStatusTrackerReset(FlatBufferBuilder builder, public static void startStatusTrackerReset(FlatBufferBuilder builder) { builder.startTable(1); } public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static int createTrackerIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startTrackerIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static int endStatusTrackerReset(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -47,12 +52,19 @@ public StatusTrackerResetT unpack() { return _o; } public void unpackTo(StatusTrackerResetT _o) { - if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); - else _o.setTrackerId(null); + solarxr_protocol.datatypes.TrackerIdT[] _oTrackerId = new solarxr_protocol.datatypes.TrackerIdT[trackerIdLength()]; + for (int _j = 0; _j < trackerIdLength(); ++_j) {_oTrackerId[_j] = (trackerId(_j) != null ? trackerId(_j).unpack() : null);} + _o.setTrackerId(_oTrackerId); } public static int pack(FlatBufferBuilder builder, StatusTrackerResetT _o) { if (_o == null) return 0; - int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + int _trackerId = 0; + if (_o.getTrackerId() != null) { + int[] __trackerId = new int[_o.getTrackerId().length]; + int _j = 0; + for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackerId()) { __trackerId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} + _trackerId = createTrackerIdVector(builder, __trackerId); + } return createStatusTrackerReset( builder, _trackerId); diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java index 270b2f4c..35c5d98b 100644 --- a/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java +++ b/protocol/java/src/solarxr_protocol/rpc/StatusTrackerResetT.java @@ -8,11 +8,11 @@ import com.google.flatbuffers.*; public class StatusTrackerResetT { - private solarxr_protocol.datatypes.TrackerIdT trackerId; + private solarxr_protocol.datatypes.TrackerIdT[] trackerId; - public solarxr_protocol.datatypes.TrackerIdT getTrackerId() { return trackerId; } + public solarxr_protocol.datatypes.TrackerIdT[] getTrackerId() { return trackerId; } - public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT trackerId) { this.trackerId = trackerId; } + public void setTrackerId(solarxr_protocol.datatypes.TrackerIdT[] trackerId) { this.trackerId = trackerId; } public StatusTrackerResetT() { diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraData.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraData.java new file mode 100644 index 00000000..1be25dc0 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraData.java @@ -0,0 +1,20 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class TrackingChecklistExtraData { + private TrackingChecklistExtraData() { } + public static final byte NONE = 0; + public static final byte TrackingChecklistTrackerReset = 1; + public static final byte TrackingChecklistTrackerError = 2; + public static final byte TrackingChecklistSteamVRDisconnected = 3; + public static final byte TrackingChecklistUnassignedHMD = 4; + public static final byte TrackingChecklistNeedCalibration = 5; + public static final byte TrackingChecklistPublicNetworks = 6; + + public static final String[] names = { "NONE", "TrackingChecklistTrackerReset", "TrackingChecklistTrackerError", "TrackingChecklistSteamVRDisconnected", "TrackingChecklistUnassignedHMD", "TrackingChecklistNeedCalibration", "TrackingChecklistPublicNetworks", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraDataUnion.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraDataUnion.java new file mode 100644 index 00000000..eee855f0 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistExtraDataUnion.java @@ -0,0 +1,43 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import com.google.flatbuffers.FlatBufferBuilder; + +public class TrackingChecklistExtraDataUnion { + private byte type; + private Object value; + + public byte getType() { return type; } + + public void setType(byte type) { this.type = type; } + + public Object getValue() { return value; } + + public void setValue(Object value) { this.value = value; } + + public TrackingChecklistExtraDataUnion() { + this.type = TrackingChecklistExtraData.NONE; + this.value = null; + } + + public solarxr_protocol.rpc.TrackingChecklistTrackerResetT asTrackingChecklistTrackerReset() { return (solarxr_protocol.rpc.TrackingChecklistTrackerResetT) value; } + public solarxr_protocol.rpc.TrackingChecklistTrackerErrorT asTrackingChecklistTrackerError() { return (solarxr_protocol.rpc.TrackingChecklistTrackerErrorT) value; } + public solarxr_protocol.rpc.TrackingChecklistSteamVRDisconnectedT asTrackingChecklistSteamVRDisconnected() { return (solarxr_protocol.rpc.TrackingChecklistSteamVRDisconnectedT) value; } + public solarxr_protocol.rpc.TrackingChecklistUnassignedHMDT asTrackingChecklistUnassignedHMD() { return (solarxr_protocol.rpc.TrackingChecklistUnassignedHMDT) value; } + public solarxr_protocol.rpc.TrackingChecklistNeedCalibrationT asTrackingChecklistNeedCalibration() { return (solarxr_protocol.rpc.TrackingChecklistNeedCalibrationT) value; } + public solarxr_protocol.rpc.TrackingChecklistPublicNetworksT asTrackingChecklistPublicNetworks() { return (solarxr_protocol.rpc.TrackingChecklistPublicNetworksT) value; } + + public static int pack(FlatBufferBuilder builder, TrackingChecklistExtraDataUnion _o) { + switch (_o.type) { + case TrackingChecklistExtraData.TrackingChecklistTrackerReset: return solarxr_protocol.rpc.TrackingChecklistTrackerReset.pack(builder, _o.asTrackingChecklistTrackerReset()); + case TrackingChecklistExtraData.TrackingChecklistTrackerError: return solarxr_protocol.rpc.TrackingChecklistTrackerError.pack(builder, _o.asTrackingChecklistTrackerError()); + case TrackingChecklistExtraData.TrackingChecklistSteamVRDisconnected: return solarxr_protocol.rpc.TrackingChecklistSteamVRDisconnected.pack(builder, _o.asTrackingChecklistSteamVRDisconnected()); + case TrackingChecklistExtraData.TrackingChecklistUnassignedHMD: return solarxr_protocol.rpc.TrackingChecklistUnassignedHMD.pack(builder, _o.asTrackingChecklistUnassignedHMD()); + case TrackingChecklistExtraData.TrackingChecklistNeedCalibration: return solarxr_protocol.rpc.TrackingChecklistNeedCalibration.pack(builder, _o.asTrackingChecklistNeedCalibration()); + case TrackingChecklistExtraData.TrackingChecklistPublicNetworks: return solarxr_protocol.rpc.TrackingChecklistPublicNetworks.pack(builder, _o.asTrackingChecklistPublicNetworks()); + default: return 0; + } + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java new file mode 100644 index 00000000..fc57351d --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.java @@ -0,0 +1,70 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistNeedCalibration extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistNeedCalibration getRootAsTrackingChecklistNeedCalibration(ByteBuffer _bb) { return getRootAsTrackingChecklistNeedCalibration(_bb, new TrackingChecklistNeedCalibration()); } + public static TrackingChecklistNeedCalibration getRootAsTrackingChecklistNeedCalibration(ByteBuffer _bb, TrackingChecklistNeedCalibration 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 TrackingChecklistNeedCalibration __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } + public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createTrackingChecklistNeedCalibration(FlatBufferBuilder builder, + int trackersIdOffset) { + builder.startTable(1); + TrackingChecklistNeedCalibration.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistNeedCalibration.endTrackingChecklistNeedCalibration(builder); + } + + public static void startTrackingChecklistNeedCalibration(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endTrackingChecklistNeedCalibration(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 TrackingChecklistNeedCalibration get(int j) { return get(new TrackingChecklistNeedCalibration(), j); } + public TrackingChecklistNeedCalibration get(TrackingChecklistNeedCalibration obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistNeedCalibrationT unpack() { + TrackingChecklistNeedCalibrationT _o = new TrackingChecklistNeedCalibrationT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistNeedCalibrationT _o) { + solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + _o.setTrackersId(_oTrackersId); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistNeedCalibrationT _o) { + if (_o == null) return 0; + int _trackersId = 0; + if (_o.getTrackersId() != null) { + int[] __trackersId = new int[_o.getTrackersId().length]; + int _j = 0; + for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} + _trackersId = createTrackersIdVector(builder, __trackersId); + } + return createTrackingChecklistNeedCalibration( + builder, + _trackersId); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.java new file mode 100644 index 00000000..e6a1fa7f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibrationT.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 TrackingChecklistNeedCalibrationT { + private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + + public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + + public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + + + public TrackingChecklistNeedCalibrationT() { + this.trackersId = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.java new file mode 100644 index 00000000..86834538 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.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.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistPublicNetworks extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistPublicNetworks getRootAsTrackingChecklistPublicNetworks(ByteBuffer _bb) { return getRootAsTrackingChecklistPublicNetworks(_bb, new TrackingChecklistPublicNetworks()); } + public static TrackingChecklistPublicNetworks getRootAsTrackingChecklistPublicNetworks(ByteBuffer _bb, TrackingChecklistPublicNetworks 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 TrackingChecklistPublicNetworks __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String adapters(int j) { int o = __offset(4); return o != 0 ? __string(__vector(o) + j * 4) : null; } + public int adaptersLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public StringVector adaptersVector() { return adaptersVector(new StringVector()); } + public StringVector adaptersVector(StringVector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createTrackingChecklistPublicNetworks(FlatBufferBuilder builder, + int adaptersOffset) { + builder.startTable(1); + TrackingChecklistPublicNetworks.addAdapters(builder, adaptersOffset); + return TrackingChecklistPublicNetworks.endTrackingChecklistPublicNetworks(builder); + } + + public static void startTrackingChecklistPublicNetworks(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addAdapters(FlatBufferBuilder builder, int adaptersOffset) { builder.addOffset(0, adaptersOffset, 0); } + public static int createAdaptersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startAdaptersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endTrackingChecklistPublicNetworks(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 TrackingChecklistPublicNetworks get(int j) { return get(new TrackingChecklistPublicNetworks(), j); } + public TrackingChecklistPublicNetworks get(TrackingChecklistPublicNetworks obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistPublicNetworksT unpack() { + TrackingChecklistPublicNetworksT _o = new TrackingChecklistPublicNetworksT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistPublicNetworksT _o) { + String[] _oAdapters = new String[adaptersLength()]; + for (int _j = 0; _j < adaptersLength(); ++_j) {_oAdapters[_j] = adapters(_j);} + _o.setAdapters(_oAdapters); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistPublicNetworksT _o) { + if (_o == null) return 0; + int _adapters = 0; + if (_o.getAdapters() != null) { + int[] __adapters = new int[_o.getAdapters().length]; + int _j = 0; + for (String _e : _o.getAdapters()) { __adapters[_j] = builder.createString(_e); _j++;} + _adapters = createAdaptersVector(builder, __adapters); + } + return createTrackingChecklistPublicNetworks( + builder, + _adapters); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworksT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworksT.java new file mode 100644 index 00000000..4406a335 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworksT.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 TrackingChecklistPublicNetworksT { + private String[] adapters; + + public String[] getAdapters() { return adapters; } + + public void setAdapters(String[] adapters) { this.adapters = adapters; } + + + public TrackingChecklistPublicNetworksT() { + this.adapters = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequest.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequest.java new file mode 100644 index 00000000..273af491 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequest.java @@ -0,0 +1,44 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistRequest getRootAsTrackingChecklistRequest(ByteBuffer _bb) { return getRootAsTrackingChecklistRequest(_bb, new TrackingChecklistRequest()); } + public static TrackingChecklistRequest getRootAsTrackingChecklistRequest(ByteBuffer _bb, TrackingChecklistRequest 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 TrackingChecklistRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startTrackingChecklistRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endTrackingChecklistRequest(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 TrackingChecklistRequest get(int j) { return get(new TrackingChecklistRequest(), j); } + public TrackingChecklistRequest get(TrackingChecklistRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistRequestT unpack() { + TrackingChecklistRequestT _o = new TrackingChecklistRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistRequestT _o) { + if (_o == null) return 0; + startTrackingChecklistRequest(builder); + return endTrackingChecklistRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequestT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequestT.java new file mode 100644 index 00000000..bc78f230 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistRequestT.java @@ -0,0 +1,16 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class TrackingChecklistRequestT { + + + public TrackingChecklistRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponse.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponse.java new file mode 100644 index 00000000..fbd118fb --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponse.java @@ -0,0 +1,93 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistResponse getRootAsTrackingChecklistResponse(ByteBuffer _bb) { return getRootAsTrackingChecklistResponse(_bb, new TrackingChecklistResponse()); } + public static TrackingChecklistResponse getRootAsTrackingChecklistResponse(ByteBuffer _bb, TrackingChecklistResponse 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 TrackingChecklistResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.rpc.TrackingChecklistStep steps(int j) { return steps(new solarxr_protocol.rpc.TrackingChecklistStep(), j); } + public solarxr_protocol.rpc.TrackingChecklistStep steps(solarxr_protocol.rpc.TrackingChecklistStep obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int stepsLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.rpc.TrackingChecklistStep.Vector stepsVector() { return stepsVector(new solarxr_protocol.rpc.TrackingChecklistStep.Vector()); } + public solarxr_protocol.rpc.TrackingChecklistStep.Vector stepsVector(solarxr_protocol.rpc.TrackingChecklistStep.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + public int ignoredSteps(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int ignoredStepsLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } + public ByteVector ignoredStepsVector() { return ignoredStepsVector(new ByteVector()); } + public ByteVector ignoredStepsVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer ignoredStepsAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer ignoredStepsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + + public static int createTrackingChecklistResponse(FlatBufferBuilder builder, + int stepsOffset, + int ignoredStepsOffset) { + builder.startTable(2); + TrackingChecklistResponse.addIgnoredSteps(builder, ignoredStepsOffset); + TrackingChecklistResponse.addSteps(builder, stepsOffset); + return TrackingChecklistResponse.endTrackingChecklistResponse(builder); + } + + public static void startTrackingChecklistResponse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addSteps(FlatBufferBuilder builder, int stepsOffset) { builder.addOffset(0, stepsOffset, 0); } + public static int createStepsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startStepsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static void addIgnoredSteps(FlatBufferBuilder builder, int ignoredStepsOffset) { builder.addOffset(1, ignoredStepsOffset, 0); } + public static int createIgnoredStepsVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createIgnoredStepsVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startIgnoredStepsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static int endTrackingChecklistResponse(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 TrackingChecklistResponse get(int j) { return get(new TrackingChecklistResponse(), j); } + public TrackingChecklistResponse get(TrackingChecklistResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistResponseT unpack() { + TrackingChecklistResponseT _o = new TrackingChecklistResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistResponseT _o) { + solarxr_protocol.rpc.TrackingChecklistStepT[] _oSteps = new solarxr_protocol.rpc.TrackingChecklistStepT[stepsLength()]; + for (int _j = 0; _j < stepsLength(); ++_j) {_oSteps[_j] = (steps(_j) != null ? steps(_j).unpack() : null);} + _o.setSteps(_oSteps); + int[] _oIgnoredSteps = new int[ignoredStepsLength()]; + for (int _j = 0; _j < ignoredStepsLength(); ++_j) {_oIgnoredSteps[_j] = ignoredSteps(_j);} + _o.setIgnoredSteps(_oIgnoredSteps); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistResponseT _o) { + if (_o == null) return 0; + int _steps = 0; + if (_o.getSteps() != null) { + int[] __steps = new int[_o.getSteps().length]; + int _j = 0; + for (solarxr_protocol.rpc.TrackingChecklistStepT _e : _o.getSteps()) { __steps[_j] = solarxr_protocol.rpc.TrackingChecklistStep.pack(builder, _e); _j++;} + _steps = createStepsVector(builder, __steps); + } + int _ignoredSteps = 0; + if (_o.getIgnoredSteps() != null) { + byte[] __ignoredSteps = new byte[_o.getIgnoredSteps().length]; + int _j = 0; + for (int _e : _o.getIgnoredSteps()) { __ignoredSteps[_j] = (byte) _e; _j++;} + _ignoredSteps = createIgnoredStepsVector(builder, __ignoredSteps); + } + return createTrackingChecklistResponse( + builder, + _steps, + _ignoredSteps); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponseT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponseT.java new file mode 100644 index 00000000..0855ce96 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistResponseT.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 TrackingChecklistResponseT { + private solarxr_protocol.rpc.TrackingChecklistStepT[] steps; + private int[] ignoredSteps; + + public solarxr_protocol.rpc.TrackingChecklistStepT[] getSteps() { return steps; } + + public void setSteps(solarxr_protocol.rpc.TrackingChecklistStepT[] steps) { this.steps = steps; } + + public int[] getIgnoredSteps() { return ignoredSteps; } + + public void setIgnoredSteps(int[] ignoredSteps) { this.ignoredSteps = ignoredSteps; } + + + public TrackingChecklistResponseT() { + this.steps = null; + this.ignoredSteps = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.java new file mode 100644 index 00000000..56875002 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.java @@ -0,0 +1,62 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistSteamVRDisconnected extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistSteamVRDisconnected getRootAsTrackingChecklistSteamVRDisconnected(ByteBuffer _bb) { return getRootAsTrackingChecklistSteamVRDisconnected(_bb, new TrackingChecklistSteamVRDisconnected()); } + public static TrackingChecklistSteamVRDisconnected getRootAsTrackingChecklistSteamVRDisconnected(ByteBuffer _bb, TrackingChecklistSteamVRDisconnected 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 TrackingChecklistSteamVRDisconnected __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + /** + * Name of bridge in the server's config + */ + public String bridgeSettingsName() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer bridgeSettingsNameAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer bridgeSettingsNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + + public static int createTrackingChecklistSteamVRDisconnected(FlatBufferBuilder builder, + int bridgeSettingsNameOffset) { + builder.startTable(1); + TrackingChecklistSteamVRDisconnected.addBridgeSettingsName(builder, bridgeSettingsNameOffset); + return TrackingChecklistSteamVRDisconnected.endTrackingChecklistSteamVRDisconnected(builder); + } + + public static void startTrackingChecklistSteamVRDisconnected(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addBridgeSettingsName(FlatBufferBuilder builder, int bridgeSettingsNameOffset) { builder.addOffset(0, bridgeSettingsNameOffset, 0); } + public static int endTrackingChecklistSteamVRDisconnected(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 TrackingChecklistSteamVRDisconnected get(int j) { return get(new TrackingChecklistSteamVRDisconnected(), j); } + public TrackingChecklistSteamVRDisconnected get(TrackingChecklistSteamVRDisconnected obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistSteamVRDisconnectedT unpack() { + TrackingChecklistSteamVRDisconnectedT _o = new TrackingChecklistSteamVRDisconnectedT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistSteamVRDisconnectedT _o) { + String _oBridgeSettingsName = bridgeSettingsName(); + _o.setBridgeSettingsName(_oBridgeSettingsName); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistSteamVRDisconnectedT _o) { + if (_o == null) return 0; + int _bridgeSettingsName = _o.getBridgeSettingsName() == null ? 0 : builder.createString(_o.getBridgeSettingsName()); + return createTrackingChecklistSteamVRDisconnected( + builder, + _bridgeSettingsName); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnectedT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnectedT.java new file mode 100644 index 00000000..8283b75a --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnectedT.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 TrackingChecklistSteamVRDisconnectedT { + private String bridgeSettingsName; + + public String getBridgeSettingsName() { return bridgeSettingsName; } + + public void setBridgeSettingsName(String bridgeSettingsName) { this.bridgeSettingsName = bridgeSettingsName; } + + + public TrackingChecklistSteamVRDisconnectedT() { + this.bridgeSettingsName = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStep.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStep.java new file mode 100644 index 00000000..69f56387 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStep.java @@ -0,0 +1,135 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistStep extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistStep getRootAsTrackingChecklistStep(ByteBuffer _bb) { return getRootAsTrackingChecklistStep(_bb, new TrackingChecklistStep()); } + public static TrackingChecklistStep getRootAsTrackingChecklistStep(ByteBuffer _bb, TrackingChecklistStep 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 TrackingChecklistStep __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int id() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean valid() { int o = __offset(6); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean enabled() { int o = __offset(8); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public int visibility() { int o = __offset(10); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean optional() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public boolean ignorable() { int o = __offset(14); return o != 0 ? 0!=bb.get(o + bb_pos) : false; } + public byte extraDataType() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) : 0; } + public Table extraData(Table obj) { int o = __offset(18); return o != 0 ? __union(obj, o + bb_pos) : null; } + + public static int createTrackingChecklistStep(FlatBufferBuilder builder, + int id, + boolean valid, + boolean enabled, + int visibility, + boolean optional, + boolean ignorable, + byte extraDataType, + int extraDataOffset) { + builder.startTable(8); + TrackingChecklistStep.addExtraData(builder, extraDataOffset); + TrackingChecklistStep.addExtraDataType(builder, extraDataType); + TrackingChecklistStep.addIgnorable(builder, ignorable); + TrackingChecklistStep.addOptional(builder, optional); + TrackingChecklistStep.addVisibility(builder, visibility); + TrackingChecklistStep.addEnabled(builder, enabled); + TrackingChecklistStep.addValid(builder, valid); + TrackingChecklistStep.addId(builder, id); + return TrackingChecklistStep.endTrackingChecklistStep(builder); + } + + public static void startTrackingChecklistStep(FlatBufferBuilder builder) { builder.startTable(8); } + public static void addId(FlatBufferBuilder builder, int id) { builder.addByte(0, (byte) id, (byte) 0); } + public static void addValid(FlatBufferBuilder builder, boolean valid) { builder.addBoolean(1, valid, false); } + public static void addEnabled(FlatBufferBuilder builder, boolean enabled) { builder.addBoolean(2, enabled, false); } + public static void addVisibility(FlatBufferBuilder builder, int visibility) { builder.addByte(3, (byte) visibility, (byte) 0); } + public static void addOptional(FlatBufferBuilder builder, boolean optional) { builder.addBoolean(4, optional, false); } + public static void addIgnorable(FlatBufferBuilder builder, boolean ignorable) { builder.addBoolean(5, ignorable, false); } + public static void addExtraDataType(FlatBufferBuilder builder, byte extraDataType) { builder.addByte(6, extraDataType, 0); } + public static void addExtraData(FlatBufferBuilder builder, int extraDataOffset) { builder.addOffset(7, extraDataOffset, 0); } + public static int endTrackingChecklistStep(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 TrackingChecklistStep get(int j) { return get(new TrackingChecklistStep(), j); } + public TrackingChecklistStep get(TrackingChecklistStep obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistStepT unpack() { + TrackingChecklistStepT _o = new TrackingChecklistStepT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistStepT _o) { + int _oId = id(); + _o.setId(_oId); + boolean _oValid = valid(); + _o.setValid(_oValid); + boolean _oEnabled = enabled(); + _o.setEnabled(_oEnabled); + int _oVisibility = visibility(); + _o.setVisibility(_oVisibility); + boolean _oOptional = optional(); + _o.setOptional(_oOptional); + boolean _oIgnorable = ignorable(); + _o.setIgnorable(_oIgnorable); + solarxr_protocol.rpc.TrackingChecklistExtraDataUnion _oExtraData = new solarxr_protocol.rpc.TrackingChecklistExtraDataUnion(); + byte _oExtraDataType = extraDataType(); + _oExtraData.setType(_oExtraDataType); + Table _oExtraDataValue; + switch (_oExtraDataType) { + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistTrackerReset: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistTrackerReset()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistTrackerReset) _oExtraDataValue).unpack() : null); + break; + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistTrackerError: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistTrackerError()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistTrackerError) _oExtraDataValue).unpack() : null); + break; + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistSteamVRDisconnected: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistSteamVRDisconnected()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistSteamVRDisconnected) _oExtraDataValue).unpack() : null); + break; + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistUnassignedHMD: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistUnassignedHMD()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistUnassignedHMD) _oExtraDataValue).unpack() : null); + break; + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistNeedCalibration: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistNeedCalibration()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistNeedCalibration) _oExtraDataValue).unpack() : null); + break; + case solarxr_protocol.rpc.TrackingChecklistExtraData.TrackingChecklistPublicNetworks: + _oExtraDataValue = extraData(new solarxr_protocol.rpc.TrackingChecklistPublicNetworks()); + _oExtraData.setValue(_oExtraDataValue != null ? ((solarxr_protocol.rpc.TrackingChecklistPublicNetworks) _oExtraDataValue).unpack() : null); + break; + default: break; + } + _o.setExtraData(_oExtraData); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistStepT _o) { + if (_o == null) return 0; + byte _extraDataType = _o.getExtraData() == null ? solarxr_protocol.rpc.TrackingChecklistExtraData.NONE : _o.getExtraData().getType(); + int _extraData = _o.getExtraData() == null ? 0 : solarxr_protocol.rpc.TrackingChecklistExtraDataUnion.pack(builder, _o.getExtraData()); + return createTrackingChecklistStep( + builder, + _o.getId(), + _o.getValid(), + _o.getEnabled(), + _o.getVisibility(), + _o.getOptional(), + _o.getIgnorable(), + _extraDataType, + _extraData); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepId.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepId.java new file mode 100644 index 00000000..d07ac349 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepId.java @@ -0,0 +1,24 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class TrackingChecklistStepId { + private TrackingChecklistStepId() { } + public static final int UNKNOWN = 0; + public static final int TRACKERS_REST_CALIBRATION = 1; + public static final int FULL_RESET = 2; + public static final int VRCHAT_SETTINGS = 3; + public static final int STEAMVR_DISCONNECTED = 4; + public static final int UNASSIGNED_HMD = 5; + public static final int TRACKER_ERROR = 6; + public static final int NETWORK_PROFILE_PUBLIC = 7; + public static final int MOUNTING_CALIBRATION = 8; + public static final int FEET_MOUNTING_CALIBRATION = 9; + public static final int STAY_ALIGNED_CONFIGURED = 10; + + public static final String[] names = { "UNKNOWN", "TRACKERS_REST_CALIBRATION", "FULL_RESET", "VRCHAT_SETTINGS", "STEAMVR_DISCONNECTED", "UNASSIGNED_HMD", "TRACKER_ERROR", "NETWORK_PROFILE_PUBLIC", "MOUNTING_CALIBRATION", "FEET_MOUNTING_CALIBRATION", "STAY_ALIGNED_CONFIGURED", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepT.java new file mode 100644 index 00000000..8d4e00c3 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepT.java @@ -0,0 +1,58 @@ +// 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 TrackingChecklistStepT { + private int id; + private boolean valid; + private boolean enabled; + private int visibility; + private boolean optional; + private boolean ignorable; + private solarxr_protocol.rpc.TrackingChecklistExtraDataUnion extraData; + + public int getId() { return id; } + + public void setId(int id) { this.id = id; } + + public boolean getValid() { return valid; } + + public void setValid(boolean valid) { this.valid = valid; } + + public boolean getEnabled() { return enabled; } + + public void setEnabled(boolean enabled) { this.enabled = enabled; } + + public int getVisibility() { return visibility; } + + public void setVisibility(int visibility) { this.visibility = visibility; } + + public boolean getOptional() { return optional; } + + public void setOptional(boolean optional) { this.optional = optional; } + + public boolean getIgnorable() { return ignorable; } + + public void setIgnorable(boolean ignorable) { this.ignorable = ignorable; } + + public solarxr_protocol.rpc.TrackingChecklistExtraDataUnion getExtraData() { return extraData; } + + public void setExtraData(solarxr_protocol.rpc.TrackingChecklistExtraDataUnion extraData) { this.extraData = extraData; } + + + public TrackingChecklistStepT() { + this.id = 0; + this.valid = false; + this.enabled = false; + this.visibility = 0; + this.optional = false; + this.ignorable = false; + this.extraData = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.java new file mode 100644 index 00000000..432af8d5 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.java @@ -0,0 +1,15 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class TrackingChecklistStepVisibility { + private TrackingChecklistStepVisibility() { } + public static final int ALWAYS = 0; + public static final int WHEN_INVALID = 1; + + public static final String[] names = { "ALWAYS", "WHEN_INVALID", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java new file mode 100644 index 00000000..c5060bf5 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.java @@ -0,0 +1,73 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Trackers with error state + */ +@SuppressWarnings("unused") +public final class TrackingChecklistTrackerError extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistTrackerError getRootAsTrackingChecklistTrackerError(ByteBuffer _bb) { return getRootAsTrackingChecklistTrackerError(_bb, new TrackingChecklistTrackerError()); } + public static TrackingChecklistTrackerError getRootAsTrackingChecklistTrackerError(ByteBuffer _bb, TrackingChecklistTrackerError 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 TrackingChecklistTrackerError __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } + public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createTrackingChecklistTrackerError(FlatBufferBuilder builder, + int trackersIdOffset) { + builder.startTable(1); + TrackingChecklistTrackerError.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistTrackerError.endTrackingChecklistTrackerError(builder); + } + + public static void startTrackingChecklistTrackerError(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endTrackingChecklistTrackerError(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 TrackingChecklistTrackerError get(int j) { return get(new TrackingChecklistTrackerError(), j); } + public TrackingChecklistTrackerError get(TrackingChecklistTrackerError obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistTrackerErrorT unpack() { + TrackingChecklistTrackerErrorT _o = new TrackingChecklistTrackerErrorT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistTrackerErrorT _o) { + solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + _o.setTrackersId(_oTrackersId); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistTrackerErrorT _o) { + if (_o == null) return 0; + int _trackersId = 0; + if (_o.getTrackersId() != null) { + int[] __trackersId = new int[_o.getTrackersId().length]; + int _j = 0; + for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} + _trackersId = createTrackersIdVector(builder, __trackersId); + } + return createTrackingChecklistTrackerError( + builder, + _trackersId); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.java new file mode 100644 index 00000000..61f4f1a8 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerErrorT.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 TrackingChecklistTrackerErrorT { + private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + + public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + + public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + + + public TrackingChecklistTrackerErrorT() { + this.trackersId = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java new file mode 100644 index 00000000..836a99ea --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.java @@ -0,0 +1,73 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Trackers that need a reset + */ +@SuppressWarnings("unused") +public final class TrackingChecklistTrackerReset extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistTrackerReset getRootAsTrackingChecklistTrackerReset(ByteBuffer _bb) { return getRootAsTrackingChecklistTrackerReset(_bb, new TrackingChecklistTrackerReset()); } + public static TrackingChecklistTrackerReset getRootAsTrackingChecklistTrackerReset(ByteBuffer _bb, TrackingChecklistTrackerReset 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 TrackingChecklistTrackerReset __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.datatypes.TrackerId trackersId(int j) { return trackersId(new solarxr_protocol.datatypes.TrackerId(), j); } + public solarxr_protocol.datatypes.TrackerId trackersId(solarxr_protocol.datatypes.TrackerId obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int trackersIdLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector() { return trackersIdVector(new solarxr_protocol.datatypes.TrackerId.Vector()); } + public solarxr_protocol.datatypes.TrackerId.Vector trackersIdVector(solarxr_protocol.datatypes.TrackerId.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createTrackingChecklistTrackerReset(FlatBufferBuilder builder, + int trackersIdOffset) { + builder.startTable(1); + TrackingChecklistTrackerReset.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistTrackerReset.endTrackingChecklistTrackerReset(builder); + } + + public static void startTrackingChecklistTrackerReset(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackersId(FlatBufferBuilder builder, int trackersIdOffset) { builder.addOffset(0, trackersIdOffset, 0); } + public static int createTrackersIdVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startTrackersIdVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endTrackingChecklistTrackerReset(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 TrackingChecklistTrackerReset get(int j) { return get(new TrackingChecklistTrackerReset(), j); } + public TrackingChecklistTrackerReset get(TrackingChecklistTrackerReset obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistTrackerResetT unpack() { + TrackingChecklistTrackerResetT _o = new TrackingChecklistTrackerResetT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistTrackerResetT _o) { + solarxr_protocol.datatypes.TrackerIdT[] _oTrackersId = new solarxr_protocol.datatypes.TrackerIdT[trackersIdLength()]; + for (int _j = 0; _j < trackersIdLength(); ++_j) {_oTrackersId[_j] = (trackersId(_j) != null ? trackersId(_j).unpack() : null);} + _o.setTrackersId(_oTrackersId); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistTrackerResetT _o) { + if (_o == null) return 0; + int _trackersId = 0; + if (_o.getTrackersId() != null) { + int[] __trackersId = new int[_o.getTrackersId().length]; + int _j = 0; + for (solarxr_protocol.datatypes.TrackerIdT _e : _o.getTrackersId()) { __trackersId[_j] = solarxr_protocol.datatypes.TrackerId.pack(builder, _e); _j++;} + _trackersId = createTrackersIdVector(builder, __trackersId); + } + return createTrackingChecklistTrackerReset( + builder, + _trackersId); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.java new file mode 100644 index 00000000..3f132a3f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistTrackerResetT.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 TrackingChecklistTrackerResetT { + private solarxr_protocol.datatypes.TrackerIdT[] trackersId; + + public solarxr_protocol.datatypes.TrackerIdT[] getTrackersId() { return trackersId; } + + public void setTrackersId(solarxr_protocol.datatypes.TrackerIdT[] trackersId) { this.trackersId = trackersId; } + + + public TrackingChecklistTrackerResetT() { + this.trackersId = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java new file mode 100644 index 00000000..2510c4f3 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.java @@ -0,0 +1,58 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TrackingChecklistUnassignedHMD extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static TrackingChecklistUnassignedHMD getRootAsTrackingChecklistUnassignedHMD(ByteBuffer _bb) { return getRootAsTrackingChecklistUnassignedHMD(_bb, new TrackingChecklistUnassignedHMD()); } + public static TrackingChecklistUnassignedHMD getRootAsTrackingChecklistUnassignedHMD(ByteBuffer _bb, TrackingChecklistUnassignedHMD 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 TrackingChecklistUnassignedHMD __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.datatypes.TrackerId trackerId() { return trackerId(new solarxr_protocol.datatypes.TrackerId()); } + public solarxr_protocol.datatypes.TrackerId trackerId(solarxr_protocol.datatypes.TrackerId obj) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + + public static int createTrackingChecklistUnassignedHMD(FlatBufferBuilder builder, + int trackerIdOffset) { + builder.startTable(1); + TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerIdOffset); + return TrackingChecklistUnassignedHMD.endTrackingChecklistUnassignedHMD(builder); + } + + public static void startTrackingChecklistUnassignedHMD(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addTrackerId(FlatBufferBuilder builder, int trackerIdOffset) { builder.addOffset(0, trackerIdOffset, 0); } + public static int endTrackingChecklistUnassignedHMD(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 TrackingChecklistUnassignedHMD get(int j) { return get(new TrackingChecklistUnassignedHMD(), j); } + public TrackingChecklistUnassignedHMD get(TrackingChecklistUnassignedHMD obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public TrackingChecklistUnassignedHMDT unpack() { + TrackingChecklistUnassignedHMDT _o = new TrackingChecklistUnassignedHMDT(); + unpackTo(_o); + return _o; + } + public void unpackTo(TrackingChecklistUnassignedHMDT _o) { + if (trackerId() != null) _o.setTrackerId(trackerId().unpack()); + else _o.setTrackerId(null); + } + public static int pack(FlatBufferBuilder builder, TrackingChecklistUnassignedHMDT _o) { + if (_o == null) return 0; + int _trackerId = _o.getTrackerId() == null ? 0 : solarxr_protocol.datatypes.TrackerId.pack(builder, _o.getTrackerId()); + return createTrackingChecklistUnassignedHMD( + builder, + _trackerId); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.java new file mode 100644 index 00000000..6b2fd232 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMDT.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 TrackingChecklistUnassignedHMDT { + 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 TrackingChecklistUnassignedHMDT() { + this.trackerId = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java new file mode 100644 index 00000000..bbf861fe --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.java @@ -0,0 +1,59 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VRCConfigSettingToggleMute extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VRCConfigSettingToggleMute getRootAsVRCConfigSettingToggleMute(ByteBuffer _bb) { return getRootAsVRCConfigSettingToggleMute(_bb, new VRCConfigSettingToggleMute()); } + public static VRCConfigSettingToggleMute getRootAsVRCConfigSettingToggleMute(ByteBuffer _bb, VRCConfigSettingToggleMute 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 VRCConfigSettingToggleMute __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String key() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer keyAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer keyInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + + public static int createVRCConfigSettingToggleMute(FlatBufferBuilder builder, + int keyOffset) { + builder.startTable(1); + VRCConfigSettingToggleMute.addKey(builder, keyOffset); + return VRCConfigSettingToggleMute.endVRCConfigSettingToggleMute(builder); + } + + public static void startVRCConfigSettingToggleMute(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addKey(FlatBufferBuilder builder, int keyOffset) { builder.addOffset(0, keyOffset, 0); } + public static int endVRCConfigSettingToggleMute(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 VRCConfigSettingToggleMute get(int j) { return get(new VRCConfigSettingToggleMute(), j); } + public VRCConfigSettingToggleMute get(VRCConfigSettingToggleMute obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VRCConfigSettingToggleMuteT unpack() { + VRCConfigSettingToggleMuteT _o = new VRCConfigSettingToggleMuteT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VRCConfigSettingToggleMuteT _o) { + String _oKey = key(); + _o.setKey(_oKey); + } + public static int pack(FlatBufferBuilder builder, VRCConfigSettingToggleMuteT _o) { + if (_o == null) return 0; + int _key = _o.getKey() == null ? 0 : builder.createString(_o.getKey()); + return createVRCConfigSettingToggleMute( + builder, + _key); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMuteT.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMuteT.java new file mode 100644 index 00000000..4f93311f --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigSettingToggleMuteT.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 VRCConfigSettingToggleMuteT { + private String key; + + public String getKey() { return key; } + + public void setKey(String key) { this.key = key; } + + + public VRCConfigSettingToggleMuteT() { + this.key = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java index e84deb86..7dd8a38b 100644 --- a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.java @@ -26,13 +26,19 @@ public final class VRCConfigStateChangeResponse extends Table { public solarxr_protocol.rpc.VRCConfigValues state(solarxr_protocol.rpc.VRCConfigValues obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } public solarxr_protocol.rpc.VRCConfigRecommendedValues recommended() { return recommended(new solarxr_protocol.rpc.VRCConfigRecommendedValues()); } public solarxr_protocol.rpc.VRCConfigRecommendedValues recommended(solarxr_protocol.rpc.VRCConfigRecommendedValues obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public String muted(int j) { int o = __offset(12); return o != 0 ? __string(__vector(o) + j * 4) : null; } + public int mutedLength() { int o = __offset(12); return o != 0 ? __vector_len(o) : 0; } + public StringVector mutedVector() { return mutedVector(new StringVector()); } + public StringVector mutedVector(StringVector obj) { int o = __offset(12); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } public static int createVRCConfigStateChangeResponse(FlatBufferBuilder builder, boolean isSupported, int validityOffset, int stateOffset, - int recommendedOffset) { - builder.startTable(4); + int recommendedOffset, + int mutedOffset) { + builder.startTable(5); + VRCConfigStateChangeResponse.addMuted(builder, mutedOffset); VRCConfigStateChangeResponse.addRecommended(builder, recommendedOffset); VRCConfigStateChangeResponse.addState(builder, stateOffset); VRCConfigStateChangeResponse.addValidity(builder, validityOffset); @@ -40,11 +46,14 @@ public static int createVRCConfigStateChangeResponse(FlatBufferBuilder builder, return VRCConfigStateChangeResponse.endVRCConfigStateChangeResponse(builder); } - public static void startVRCConfigStateChangeResponse(FlatBufferBuilder builder) { builder.startTable(4); } + public static void startVRCConfigStateChangeResponse(FlatBufferBuilder builder) { builder.startTable(5); } public static void addIsSupported(FlatBufferBuilder builder, boolean isSupported) { builder.addBoolean(0, isSupported, false); } public static void addValidity(FlatBufferBuilder builder, int validityOffset) { builder.addOffset(1, validityOffset, 0); } public static void addState(FlatBufferBuilder builder, int stateOffset) { builder.addOffset(2, stateOffset, 0); } public static void addRecommended(FlatBufferBuilder builder, int recommendedOffset) { builder.addOffset(3, recommendedOffset, 0); } + public static void addMuted(FlatBufferBuilder builder, int mutedOffset) { builder.addOffset(4, mutedOffset, 0); } + public static int createMutedVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startMutedVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } public static int endVRCConfigStateChangeResponse(FlatBufferBuilder builder) { int o = builder.endTable(); return o; @@ -70,18 +79,29 @@ public void unpackTo(VRCConfigStateChangeResponseT _o) { else _o.setState(null); if (recommended() != null) _o.setRecommended(recommended().unpack()); else _o.setRecommended(null); + String[] _oMuted = new String[mutedLength()]; + for (int _j = 0; _j < mutedLength(); ++_j) {_oMuted[_j] = muted(_j);} + _o.setMuted(_oMuted); } public static int pack(FlatBufferBuilder builder, VRCConfigStateChangeResponseT _o) { if (_o == null) return 0; int _validity = _o.getValidity() == null ? 0 : solarxr_protocol.rpc.VRCConfigValidity.pack(builder, _o.getValidity()); int _state = _o.getState() == null ? 0 : solarxr_protocol.rpc.VRCConfigValues.pack(builder, _o.getState()); int _recommended = _o.getRecommended() == null ? 0 : solarxr_protocol.rpc.VRCConfigRecommendedValues.pack(builder, _o.getRecommended()); + int _muted = 0; + if (_o.getMuted() != null) { + int[] __muted = new int[_o.getMuted().length]; + int _j = 0; + for (String _e : _o.getMuted()) { __muted[_j] = builder.createString(_e); _j++;} + _muted = createMutedVector(builder, __muted); + } return createVRCConfigStateChangeResponse( builder, _o.getIsSupported(), _validity, _state, - _recommended); + _recommended, + _muted); } } diff --git a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponseT.java b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponseT.java index 744362cd..12d40593 100644 --- a/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponseT.java +++ b/protocol/java/src/solarxr_protocol/rpc/VRCConfigStateChangeResponseT.java @@ -12,6 +12,7 @@ public class VRCConfigStateChangeResponseT { private solarxr_protocol.rpc.VRCConfigValidityT validity; private solarxr_protocol.rpc.VRCConfigValuesT state; private solarxr_protocol.rpc.VRCConfigRecommendedValuesT recommended; + private String[] muted; public boolean getIsSupported() { return isSupported; } @@ -29,12 +30,17 @@ public class VRCConfigStateChangeResponseT { public void setRecommended(solarxr_protocol.rpc.VRCConfigRecommendedValuesT recommended) { this.recommended = recommended; } + public String[] getMuted() { return muted; } + + public void setMuted(String[] muted) { this.muted = muted; } + public VRCConfigStateChangeResponseT() { this.isSupported = false; this.validity = null; this.state = null; this.recommended = null; + this.muted = null; } } diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt index 251deb95..09e0a026 100644 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt +++ b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedConfig.kt @@ -57,6 +57,11 @@ class DataFeedConfig : Table() { val o = __offset(12) return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false } + val serverGuardsMask : Boolean + get() { + val o = __offset(14) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -68,17 +73,18 @@ class DataFeedConfig : Table() { return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) } @JvmStatic - fun createDataFeedConfig(builder: FlatBufferBuilder, minimumTimeSinceLast: UShort, dataMaskOffset: Int, syntheticTrackersMaskOffset: Int, boneMask: Boolean, stayAlignedPoseMask: Boolean) : Int { - builder.startTable(5) + fun createDataFeedConfig(builder: FlatBufferBuilder, minimumTimeSinceLast: UShort, dataMaskOffset: Int, syntheticTrackersMaskOffset: Int, boneMask: Boolean, stayAlignedPoseMask: Boolean, serverGuardsMask: Boolean) : Int { + builder.startTable(6) addSyntheticTrackersMask(builder, syntheticTrackersMaskOffset) addDataMask(builder, dataMaskOffset) addMinimumTimeSinceLast(builder, minimumTimeSinceLast) + addServerGuardsMask(builder, serverGuardsMask) addStayAlignedPoseMask(builder, stayAlignedPoseMask) addBoneMask(builder, boneMask) return endDataFeedConfig(builder) } @JvmStatic - fun startDataFeedConfig(builder: FlatBufferBuilder) = builder.startTable(5) + fun startDataFeedConfig(builder: FlatBufferBuilder) = builder.startTable(6) @JvmStatic fun addMinimumTimeSinceLast(builder: FlatBufferBuilder, minimumTimeSinceLast: UShort) = builder.addShort(0, minimumTimeSinceLast.toShort(), 0) @JvmStatic @@ -90,6 +96,8 @@ class DataFeedConfig : Table() { @JvmStatic fun addStayAlignedPoseMask(builder: FlatBufferBuilder, stayAlignedPoseMask: Boolean) = builder.addBoolean(4, stayAlignedPoseMask, false) @JvmStatic + fun addServerGuardsMask(builder: FlatBufferBuilder, serverGuardsMask: Boolean) = builder.addBoolean(5, serverGuardsMask, false) + @JvmStatic fun endDataFeedConfig(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt index 1860e799..57d5b4e8 100644 --- a/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt +++ b/protocol/kotlin/src/solarxr_protocol/data_feed/DataFeedUpdate.kt @@ -81,6 +81,15 @@ class DataFeedUpdate : Table() { val o = __offset(12) return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u } + val serverGuards : solarxr_protocol.data_feed.server.ServerGuards? get() = serverGuards(solarxr_protocol.data_feed.server.ServerGuards()) + fun serverGuards(obj: solarxr_protocol.data_feed.server.ServerGuards) : solarxr_protocol.data_feed.server.ServerGuards? { + val o = __offset(14) + return if (o != 0) { + obj.__assign(__indirect(o + bb_pos), bb) + } else { + null + } + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -92,8 +101,9 @@ class DataFeedUpdate : Table() { return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) } @JvmStatic - fun createDataFeedUpdate(builder: FlatBufferBuilder, devicesOffset: Int, syntheticTrackersOffset: Int, bonesOffset: Int, stayAlignedPoseOffset: Int, index: UByte) : Int { - builder.startTable(5) + fun createDataFeedUpdate(builder: FlatBufferBuilder, devicesOffset: Int, syntheticTrackersOffset: Int, bonesOffset: Int, stayAlignedPoseOffset: Int, index: UByte, serverGuardsOffset: Int) : Int { + builder.startTable(6) + addServerGuards(builder, serverGuardsOffset) addStayAlignedPose(builder, stayAlignedPoseOffset) addBones(builder, bonesOffset) addSyntheticTrackers(builder, syntheticTrackersOffset) @@ -102,7 +112,7 @@ class DataFeedUpdate : Table() { return endDataFeedUpdate(builder) } @JvmStatic - fun startDataFeedUpdate(builder: FlatBufferBuilder) = builder.startTable(5) + fun startDataFeedUpdate(builder: FlatBufferBuilder) = builder.startTable(6) @JvmStatic fun addDevices(builder: FlatBufferBuilder, devices: Int) = builder.addOffset(0, devices, 0) @JvmStatic @@ -144,6 +154,8 @@ class DataFeedUpdate : Table() { @JvmStatic fun addIndex(builder: FlatBufferBuilder, index: UByte) = builder.addByte(4, index.toByte(), 0) @JvmStatic + fun addServerGuards(builder: FlatBufferBuilder, serverGuards: Int) = builder.addOffset(5, serverGuards, 0) + @JvmStatic fun endDataFeedUpdate(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt b/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt new file mode 100644 index 00000000..680ec7c2 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/data_feed/server/ServerGuards.kt @@ -0,0 +1,58 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.data_feed.server + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class ServerGuards : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : ServerGuards { + __init(_i, _bb) + return this + } + val canDoMounting : Boolean + get() { + val o = __offset(4) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val canDoYawReset : Boolean + get() { + val o = __offset(6) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsServerGuards(_bb: ByteBuffer): ServerGuards = getRootAsServerGuards(_bb, ServerGuards()) + @JvmStatic + fun getRootAsServerGuards(_bb: ByteBuffer, obj: ServerGuards): ServerGuards { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createServerGuards(builder: FlatBufferBuilder, canDoMounting: Boolean, canDoYawReset: Boolean) : Int { + builder.startTable(2) + addCanDoYawReset(builder, canDoYawReset) + addCanDoMounting(builder, canDoMounting) + return endServerGuards(builder) + } + @JvmStatic + fun startServerGuards(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addCanDoMounting(builder: FlatBufferBuilder, canDoMounting: Boolean) = builder.addBoolean(0, canDoMounting, false) + @JvmStatic + fun addCanDoYawReset(builder: FlatBufferBuilder, canDoYawReset: Boolean) = builder.addBoolean(1, canDoYawReset, false) + @JvmStatic + fun endServerGuards(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt index 921e576c..9cb44291 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/FirmwareUpdateStatus.kt @@ -53,7 +53,7 @@ class FirmwareUpdateStatus private constructor() { */ const val ERRORAUTHENTICATIONFAILED: UByte = 11u /** - * Could not upload the firmware to the MUC + * Could not upload the firmware to the MCU */ const val ERRORUPLOADFAILED: UByte = 12u /** diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt new file mode 100644 index 00000000..29d07ec8 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/IgnoreTrackingChecklistStepRequest.kt @@ -0,0 +1,58 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class IgnoreTrackingChecklistStepRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : IgnoreTrackingChecklistStepRequest { + __init(_i, _bb) + return this + } + val stepId : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val ignore : Boolean + get() { + val o = __offset(6) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsIgnoreTrackingChecklistStepRequest(_bb: ByteBuffer): IgnoreTrackingChecklistStepRequest = getRootAsIgnoreTrackingChecklistStepRequest(_bb, IgnoreTrackingChecklistStepRequest()) + @JvmStatic + fun getRootAsIgnoreTrackingChecklistStepRequest(_bb: ByteBuffer, obj: IgnoreTrackingChecklistStepRequest): IgnoreTrackingChecklistStepRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder, stepId: UByte, ignore: Boolean) : Int { + builder.startTable(2) + addIgnore(builder, ignore) + addStepId(builder, stepId) + return endIgnoreTrackingChecklistStepRequest(builder) + } + @JvmStatic + fun startIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addStepId(builder: FlatBufferBuilder, stepId: UByte) = builder.addByte(0, stepId.toByte(), 0) + @JvmStatic + fun addIgnore(builder: FlatBufferBuilder, ignore: Boolean) = builder.addBoolean(1, ignore, false) + @JvmStatic + fun endIgnoreTrackingChecklistStepRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt index 687153f1..d96a2b0c 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/ResetResponse.kt @@ -26,6 +26,38 @@ class ResetResponse : Table() { val o = __offset(6) return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u } + /** + * Should return the body parts reseted / being reset + */ + fun bodyParts(j: Int) : UByte { + val o = __offset(8) + return if (o != 0) { + bb.get(__vector(o) + j * 1).toUByte() + } else { + 0u + } + } + val bodyPartsLength : Int + get() { + val o = __offset(8); return if (o != 0) __vector_len(o) else 0 + } + val bodyPartsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) + fun bodyPartsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) + /** + * gives the time in seconds passed since the start of the reset + * is 0 when status == FINISHED + * starts at 0 + */ + val progress : Int + get() { + val o = __offset(10) + return if(o != 0) bb.getInt(o + bb_pos) else 0 + } + val duration : Int + get() { + val o = __offset(12) + return if(o != 0) bb.getInt(o + bb_pos) else 0 + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -37,19 +69,38 @@ class ResetResponse : Table() { return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) } @JvmStatic - fun createResetResponse(builder: FlatBufferBuilder, resetType: UByte, status: UByte) : Int { - builder.startTable(2) + fun createResetResponse(builder: FlatBufferBuilder, resetType: UByte, status: UByte, bodyPartsOffset: Int, progress: Int, duration: Int) : Int { + builder.startTable(5) + addDuration(builder, duration) + addProgress(builder, progress) + addBodyParts(builder, bodyPartsOffset) addStatus(builder, status) addResetType(builder, resetType) return endResetResponse(builder) } @JvmStatic - fun startResetResponse(builder: FlatBufferBuilder) = builder.startTable(2) + fun startResetResponse(builder: FlatBufferBuilder) = builder.startTable(5) @JvmStatic fun addResetType(builder: FlatBufferBuilder, resetType: UByte) = builder.addByte(0, resetType.toByte(), 0) @JvmStatic fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(1, status.toByte(), 0) @JvmStatic + fun addBodyParts(builder: FlatBufferBuilder, bodyParts: Int) = builder.addOffset(2, bodyParts, 0) + @JvmStatic + fun createBodyPartsVector(builder: FlatBufferBuilder, data: UByteArray) : Int { + builder.startVector(1, data.size, 1) + for (i in data.size - 1 downTo 0) { + builder.addByte(data[i].toByte()) + } + return builder.endVector() + } + @JvmStatic + fun startBodyPartsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) + @JvmStatic + fun addProgress(builder: FlatBufferBuilder, progress: Int) = builder.addInt(3, progress, 0) + @JvmStatic + fun addDuration(builder: FlatBufferBuilder, duration: Int) = builder.addInt(4, duration, 0) + @JvmStatic fun endResetResponse(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt index 534da0ad..e0c8d76c 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt @@ -77,7 +77,11 @@ class RpcMessage private constructor() { const val DetectStayAlignedRelaxedPoseRequest: UByte = 69u const val ResetStayAlignedRelaxedPoseRequest: UByte = 70u const val SerialTrackerCustomCommandRequest: UByte = 71u - 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") + const val VRCConfigSettingToggleMute: UByte = 72u + const val TrackingChecklistRequest: UByte = 73u + const val TrackingChecklistResponse: UByte = 74u + const val IgnoreTrackingChecklistStepRequest: UByte = 75u + 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") @JvmStatic fun name(e: Int) : String = names[e] } diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt index 71edd6e4..cf044044 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerError.kt @@ -7,7 +7,7 @@ import kotlin.math.sign import com.google.flatbuffers.* /** - * Tracker has error state + * Trackers with error state */ @Suppress("unused") class StatusTrackerError : Table() { @@ -19,15 +19,19 @@ class StatusTrackerError : Table() { __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? { + fun trackerId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackerId(solarxr_protocol.datatypes.TrackerId(), j) + fun trackerId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { val o = __offset(4) return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) + obj.__assign(__indirect(__vector(o) + j * 4), bb) } else { null } } + val trackerIdLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -49,6 +53,16 @@ class StatusTrackerError : Table() { @JvmStatic fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) @JvmStatic + fun createTrackerIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startTrackerIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic fun endStatusTrackerError(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt index e5526773..c912d612 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/StatusTrackerReset.kt @@ -19,15 +19,19 @@ class StatusTrackerReset : Table() { __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? { + fun trackerId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackerId(solarxr_protocol.datatypes.TrackerId(), j) + fun trackerId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { val o = __offset(4) return if (o != 0) { - obj.__assign(__indirect(o + bb_pos), bb) + obj.__assign(__indirect(__vector(o) + j * 4), bb) } else { null } } + val trackerIdLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -49,6 +53,16 @@ class StatusTrackerReset : Table() { @JvmStatic fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) @JvmStatic + fun createTrackerIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startTrackerIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic fun endStatusTrackerReset(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt new file mode 100644 index 00000000..13ef0e6b --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistExtraData.kt @@ -0,0 +1,19 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class TrackingChecklistExtraData private constructor() { + companion object { + const val NONE: UByte = 0u + const val TrackingChecklistTrackerReset: UByte = 1u + const val TrackingChecklistTrackerError: UByte = 2u + const val TrackingChecklistSteamVRDisconnected: UByte = 3u + const val TrackingChecklistUnassignedHMD: UByte = 4u + const val TrackingChecklistNeedCalibration: UByte = 5u + const val TrackingChecklistPublicNetworks: UByte = 6u + val names : Array = arrayOf("NONE", "TrackingChecklistTrackerReset", "TrackingChecklistTrackerError", "TrackingChecklistSteamVRDisconnected", "TrackingChecklistUnassignedHMD", "TrackingChecklistNeedCalibration", "TrackingChecklistPublicNetworks") + @JvmStatic + fun name(e: Int) : String = names[e] + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt new file mode 100644 index 00000000..cb43b152 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistNeedCalibration.kt @@ -0,0 +1,68 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistNeedCalibration : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistNeedCalibration { + __init(_i, _bb) + return this + } + fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) + fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val trackersIdLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistNeedCalibration(_bb: ByteBuffer): TrackingChecklistNeedCalibration = getRootAsTrackingChecklistNeedCalibration(_bb, TrackingChecklistNeedCalibration()) + @JvmStatic + fun getRootAsTrackingChecklistNeedCalibration(_bb: ByteBuffer, obj: TrackingChecklistNeedCalibration): TrackingChecklistNeedCalibration { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistNeedCalibration(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { + builder.startTable(1) + addTrackersId(builder, trackersIdOffset) + return endTrackingChecklistNeedCalibration(builder) + } + @JvmStatic + fun startTrackingChecklistNeedCalibration(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) + @JvmStatic + fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endTrackingChecklistNeedCalibration(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt new file mode 100644 index 00000000..c9d59f3f --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistPublicNetworks.kt @@ -0,0 +1,67 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistPublicNetworks : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistPublicNetworks { + __init(_i, _bb) + return this + } + fun adapters(j: Int) : String? { + val o = __offset(4) + return if (o != 0) { + __string(__vector(o) + j * 4) + } else { + null + } + } + val adaptersLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistPublicNetworks(_bb: ByteBuffer): TrackingChecklistPublicNetworks = getRootAsTrackingChecklistPublicNetworks(_bb, TrackingChecklistPublicNetworks()) + @JvmStatic + fun getRootAsTrackingChecklistPublicNetworks(_bb: ByteBuffer, obj: TrackingChecklistPublicNetworks): TrackingChecklistPublicNetworks { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistPublicNetworks(builder: FlatBufferBuilder, adaptersOffset: Int) : Int { + builder.startTable(1) + addAdapters(builder, adaptersOffset) + return endTrackingChecklistPublicNetworks(builder) + } + @JvmStatic + fun startTrackingChecklistPublicNetworks(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addAdapters(builder: FlatBufferBuilder, adapters: Int) = builder.addOffset(0, adapters, 0) + @JvmStatic + fun createAdaptersVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startAdaptersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endTrackingChecklistPublicNetworks(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt new file mode 100644 index 00000000..3dbc280d --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistRequest.kt @@ -0,0 +1,37 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistRequest { + __init(_i, _bb) + return this + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistRequest(_bb: ByteBuffer): TrackingChecklistRequest = getRootAsTrackingChecklistRequest(_bb, TrackingChecklistRequest()) + @JvmStatic + fun getRootAsTrackingChecklistRequest(_bb: ByteBuffer, obj: TrackingChecklistRequest): TrackingChecklistRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun startTrackingChecklistRequest(builder: FlatBufferBuilder) = builder.startTable(0) + @JvmStatic + fun endTrackingChecklistRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt new file mode 100644 index 00000000..40d2bae3 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistResponse.kt @@ -0,0 +1,95 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistResponse : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistResponse { + __init(_i, _bb) + return this + } + fun steps(j: Int) : solarxr_protocol.rpc.TrackingChecklistStep? = steps(solarxr_protocol.rpc.TrackingChecklistStep(), j) + fun steps(obj: solarxr_protocol.rpc.TrackingChecklistStep, j: Int) : solarxr_protocol.rpc.TrackingChecklistStep? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val stepsLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + fun ignoredSteps(j: Int) : UByte { + val o = __offset(6) + return if (o != 0) { + bb.get(__vector(o) + j * 1).toUByte() + } else { + 0u + } + } + val ignoredStepsLength : Int + get() { + val o = __offset(6); return if (o != 0) __vector_len(o) else 0 + } + val ignoredStepsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun ignoredStepsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistResponse(_bb: ByteBuffer): TrackingChecklistResponse = getRootAsTrackingChecklistResponse(_bb, TrackingChecklistResponse()) + @JvmStatic + fun getRootAsTrackingChecklistResponse(_bb: ByteBuffer, obj: TrackingChecklistResponse): TrackingChecklistResponse { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistResponse(builder: FlatBufferBuilder, stepsOffset: Int, ignoredStepsOffset: Int) : Int { + builder.startTable(2) + addIgnoredSteps(builder, ignoredStepsOffset) + addSteps(builder, stepsOffset) + return endTrackingChecklistResponse(builder) + } + @JvmStatic + fun startTrackingChecklistResponse(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addSteps(builder: FlatBufferBuilder, steps: Int) = builder.addOffset(0, steps, 0) + @JvmStatic + fun createStepsVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startStepsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun addIgnoredSteps(builder: FlatBufferBuilder, ignoredSteps: Int) = builder.addOffset(1, ignoredSteps, 0) + @JvmStatic + fun createIgnoredStepsVector(builder: FlatBufferBuilder, data: UByteArray) : Int { + builder.startVector(1, data.size, 1) + for (i in data.size - 1 downTo 0) { + builder.addByte(data[i].toByte()) + } + return builder.endVector() + } + @JvmStatic + fun startIgnoredStepsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) + @JvmStatic + fun endTrackingChecklistResponse(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.kt new file mode 100644 index 00000000..3337c8ec --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistSteamVRDisconnected.kt @@ -0,0 +1,55 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistSteamVRDisconnected : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistSteamVRDisconnected { + __init(_i, _bb) + return this + } + /** + * Name of bridge in the server's config + */ + val bridgeSettingsName : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val bridgeSettingsNameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun bridgeSettingsNameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistSteamVRDisconnected(_bb: ByteBuffer): TrackingChecklistSteamVRDisconnected = getRootAsTrackingChecklistSteamVRDisconnected(_bb, TrackingChecklistSteamVRDisconnected()) + @JvmStatic + fun getRootAsTrackingChecklistSteamVRDisconnected(_bb: ByteBuffer, obj: TrackingChecklistSteamVRDisconnected): TrackingChecklistSteamVRDisconnected { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistSteamVRDisconnected(builder: FlatBufferBuilder, bridgeSettingsNameOffset: Int) : Int { + builder.startTable(1) + addBridgeSettingsName(builder, bridgeSettingsNameOffset) + return endTrackingChecklistSteamVRDisconnected(builder) + } + @JvmStatic + fun startTrackingChecklistSteamVRDisconnected(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addBridgeSettingsName(builder: FlatBufferBuilder, bridgeSettingsName: Int) = builder.addOffset(0, bridgeSettingsName, 0) + @JvmStatic + fun endTrackingChecklistSteamVRDisconnected(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt new file mode 100644 index 00000000..01a0cd07 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStep.kt @@ -0,0 +1,104 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistStep : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistStep { + __init(_i, _bb) + return this + } + val id : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val valid : Boolean + get() { + val o = __offset(6) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val enabled : Boolean + get() { + val o = __offset(8) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val visibility : UByte + get() { + val o = __offset(10) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val optional : Boolean + get() { + val o = __offset(12) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val ignorable : Boolean + get() { + val o = __offset(14) + return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false + } + val extraDataType : UByte + get() { + val o = __offset(16) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + fun extraData(obj: Table) : Table? { + val o = __offset(18); return if (o != 0) __union(obj, o + bb_pos) else null + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistStep(_bb: ByteBuffer): TrackingChecklistStep = getRootAsTrackingChecklistStep(_bb, TrackingChecklistStep()) + @JvmStatic + fun getRootAsTrackingChecklistStep(_bb: ByteBuffer, obj: TrackingChecklistStep): TrackingChecklistStep { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistStep(builder: FlatBufferBuilder, id: UByte, valid: Boolean, enabled: Boolean, visibility: UByte, optional: Boolean, ignorable: Boolean, extraDataType: UByte, extraDataOffset: Int) : Int { + builder.startTable(8) + addExtraData(builder, extraDataOffset) + addExtraDataType(builder, extraDataType) + addIgnorable(builder, ignorable) + addOptional(builder, optional) + addVisibility(builder, visibility) + addEnabled(builder, enabled) + addValid(builder, valid) + addId(builder, id) + return endTrackingChecklistStep(builder) + } + @JvmStatic + fun startTrackingChecklistStep(builder: FlatBufferBuilder) = builder.startTable(8) + @JvmStatic + fun addId(builder: FlatBufferBuilder, id: UByte) = builder.addByte(0, id.toByte(), 0) + @JvmStatic + fun addValid(builder: FlatBufferBuilder, valid: Boolean) = builder.addBoolean(1, valid, false) + @JvmStatic + fun addEnabled(builder: FlatBufferBuilder, enabled: Boolean) = builder.addBoolean(2, enabled, false) + @JvmStatic + fun addVisibility(builder: FlatBufferBuilder, visibility: UByte) = builder.addByte(3, visibility.toByte(), 0) + @JvmStatic + fun addOptional(builder: FlatBufferBuilder, optional: Boolean) = builder.addBoolean(4, optional, false) + @JvmStatic + fun addIgnorable(builder: FlatBufferBuilder, ignorable: Boolean) = builder.addBoolean(5, ignorable, false) + @JvmStatic + fun addExtraDataType(builder: FlatBufferBuilder, extraDataType: UByte) = builder.addByte(6, extraDataType.toByte(), 0) + @JvmStatic + fun addExtraData(builder: FlatBufferBuilder, extraData: Int) = builder.addOffset(7, extraData, 0) + @JvmStatic + fun endTrackingChecklistStep(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepId.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepId.kt new file mode 100644 index 00000000..495c0e91 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepId.kt @@ -0,0 +1,23 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class TrackingChecklistStepId private constructor() { + companion object { + const val UNKNOWN: UByte = 0u + const val TRACKERSRESTCALIBRATION: UByte = 1u + const val FULLRESET: UByte = 2u + const val VRCHATSETTINGS: UByte = 3u + const val STEAMVRDISCONNECTED: UByte = 4u + const val UNASSIGNEDHMD: UByte = 5u + const val TRACKERERROR: UByte = 6u + const val NETWORKPROFILEPUBLIC: UByte = 7u + const val MOUNTINGCALIBRATION: UByte = 8u + const val FEETMOUNTINGCALIBRATION: UByte = 9u + const val STAYALIGNEDCONFIGURED: UByte = 10u + val names : Array = arrayOf("UNKNOWN", "TRACKERS_REST_CALIBRATION", "FULL_RESET", "VRCHAT_SETTINGS", "STEAMVR_DISCONNECTED", "UNASSIGNED_HMD", "TRACKER_ERROR", "NETWORK_PROFILE_PUBLIC", "MOUNTING_CALIBRATION", "FEET_MOUNTING_CALIBRATION", "STAY_ALIGNED_CONFIGURED") + @JvmStatic + fun name(e: Int) : String = names[e] + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt new file mode 100644 index 00000000..8e9164be --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistStepVisibility.kt @@ -0,0 +1,14 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class TrackingChecklistStepVisibility private constructor() { + companion object { + const val ALWAYS: UByte = 0u + const val WHENINVALID: UByte = 1u + val names : Array = arrayOf("ALWAYS", "WHEN_INVALID") + @JvmStatic + fun name(e: Int) : String = names[e] + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt new file mode 100644 index 00000000..84962e66 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerError.kt @@ -0,0 +1,71 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Trackers with error state + */ +@Suppress("unused") +class TrackingChecklistTrackerError : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistTrackerError { + __init(_i, _bb) + return this + } + fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) + fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val trackersIdLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistTrackerError(_bb: ByteBuffer): TrackingChecklistTrackerError = getRootAsTrackingChecklistTrackerError(_bb, TrackingChecklistTrackerError()) + @JvmStatic + fun getRootAsTrackingChecklistTrackerError(_bb: ByteBuffer, obj: TrackingChecklistTrackerError): TrackingChecklistTrackerError { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistTrackerError(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { + builder.startTable(1) + addTrackersId(builder, trackersIdOffset) + return endTrackingChecklistTrackerError(builder) + } + @JvmStatic + fun startTrackingChecklistTrackerError(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) + @JvmStatic + fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endTrackingChecklistTrackerError(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt new file mode 100644 index 00000000..f3979fb8 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistTrackerReset.kt @@ -0,0 +1,71 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Trackers that need a reset + */ +@Suppress("unused") +class TrackingChecklistTrackerReset : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistTrackerReset { + __init(_i, _bb) + return this + } + fun trackersId(j: Int) : solarxr_protocol.datatypes.TrackerId? = trackersId(solarxr_protocol.datatypes.TrackerId(), j) + fun trackersId(obj: solarxr_protocol.datatypes.TrackerId, j: Int) : solarxr_protocol.datatypes.TrackerId? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val trackersIdLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistTrackerReset(_bb: ByteBuffer): TrackingChecklistTrackerReset = getRootAsTrackingChecklistTrackerReset(_bb, TrackingChecklistTrackerReset()) + @JvmStatic + fun getRootAsTrackingChecklistTrackerReset(_bb: ByteBuffer, obj: TrackingChecklistTrackerReset): TrackingChecklistTrackerReset { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistTrackerReset(builder: FlatBufferBuilder, trackersIdOffset: Int) : Int { + builder.startTable(1) + addTrackersId(builder, trackersIdOffset) + return endTrackingChecklistTrackerReset(builder) + } + @JvmStatic + fun startTrackingChecklistTrackerReset(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addTrackersId(builder: FlatBufferBuilder, trackersId: Int) = builder.addOffset(0, trackersId, 0) + @JvmStatic + fun createTrackersIdVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startTrackersIdVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endTrackingChecklistTrackerReset(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt new file mode 100644 index 00000000..1f4fae3b --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/TrackingChecklistUnassignedHMD.kt @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class TrackingChecklistUnassignedHMD : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : TrackingChecklistUnassignedHMD { + __init(_i, _bb) + return this + } + val trackerId : solarxr_protocol.datatypes.TrackerId? get() = trackerId(solarxr_protocol.datatypes.TrackerId()) + fun trackerId(obj: solarxr_protocol.datatypes.TrackerId) : solarxr_protocol.datatypes.TrackerId? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(o + bb_pos), bb) + } else { + null + } + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsTrackingChecklistUnassignedHMD(_bb: ByteBuffer): TrackingChecklistUnassignedHMD = getRootAsTrackingChecklistUnassignedHMD(_bb, TrackingChecklistUnassignedHMD()) + @JvmStatic + fun getRootAsTrackingChecklistUnassignedHMD(_bb: ByteBuffer, obj: TrackingChecklistUnassignedHMD): TrackingChecklistUnassignedHMD { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder, trackerIdOffset: Int) : Int { + builder.startTable(1) + addTrackerId(builder, trackerIdOffset) + return endTrackingChecklistUnassignedHMD(builder) + } + @JvmStatic + fun startTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addTrackerId(builder: FlatBufferBuilder, trackerId: Int) = builder.addOffset(0, trackerId, 0) + @JvmStatic + fun endTrackingChecklistUnassignedHMD(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt new file mode 100644 index 00000000..7c067ad7 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigSettingToggleMute.kt @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class VRCConfigSettingToggleMute : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : VRCConfigSettingToggleMute { + __init(_i, _bb) + return this + } + val key : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val keyAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun keyInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsVRCConfigSettingToggleMute(_bb: ByteBuffer): VRCConfigSettingToggleMute = getRootAsVRCConfigSettingToggleMute(_bb, VRCConfigSettingToggleMute()) + @JvmStatic + fun getRootAsVRCConfigSettingToggleMute(_bb: ByteBuffer, obj: VRCConfigSettingToggleMute): VRCConfigSettingToggleMute { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createVRCConfigSettingToggleMute(builder: FlatBufferBuilder, keyOffset: Int) : Int { + builder.startTable(1) + addKey(builder, keyOffset) + return endVRCConfigSettingToggleMute(builder) + } + @JvmStatic + fun startVRCConfigSettingToggleMute(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addKey(builder: FlatBufferBuilder, key: Int) = builder.addOffset(0, key, 0) + @JvmStatic + fun endVRCConfigSettingToggleMute(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt index 026525fb..63eb3393 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/VRCConfigStateChangeResponse.kt @@ -52,6 +52,18 @@ class VRCConfigStateChangeResponse : Table() { null } } + fun muted(j: Int) : String? { + val o = __offset(12) + return if (o != 0) { + __string(__vector(o) + j * 4) + } else { + null + } + } + val mutedLength : Int + get() { + val o = __offset(12); return if (o != 0) __vector_len(o) else 0 + } companion object { @JvmStatic fun validateVersion() = Constants.FLATBUFFERS_22_10_26() @@ -63,8 +75,9 @@ class VRCConfigStateChangeResponse : Table() { return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) } @JvmStatic - fun createVRCConfigStateChangeResponse(builder: FlatBufferBuilder, isSupported: Boolean, validityOffset: Int, stateOffset: Int, recommendedOffset: Int) : Int { - builder.startTable(4) + fun createVRCConfigStateChangeResponse(builder: FlatBufferBuilder, isSupported: Boolean, validityOffset: Int, stateOffset: Int, recommendedOffset: Int, mutedOffset: Int) : Int { + builder.startTable(5) + addMuted(builder, mutedOffset) addRecommended(builder, recommendedOffset) addState(builder, stateOffset) addValidity(builder, validityOffset) @@ -72,7 +85,7 @@ class VRCConfigStateChangeResponse : Table() { return endVRCConfigStateChangeResponse(builder) } @JvmStatic - fun startVRCConfigStateChangeResponse(builder: FlatBufferBuilder) = builder.startTable(4) + fun startVRCConfigStateChangeResponse(builder: FlatBufferBuilder) = builder.startTable(5) @JvmStatic fun addIsSupported(builder: FlatBufferBuilder, isSupported: Boolean) = builder.addBoolean(0, isSupported, false) @JvmStatic @@ -82,6 +95,18 @@ class VRCConfigStateChangeResponse : Table() { @JvmStatic fun addRecommended(builder: FlatBufferBuilder, recommended: Int) = builder.addOffset(3, recommended, 0) @JvmStatic + fun addMuted(builder: FlatBufferBuilder, muted: Int) = builder.addOffset(4, muted, 0) + @JvmStatic + fun createMutedVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startMutedVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic fun endVRCConfigStateChangeResponse(builder: FlatBufferBuilder) : Int { val o = builder.endTable() return o diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs index 960dd3a9..c916223c 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -11,6 +11,11 @@ pub mod solarxr_protocol { mod device_data_generated; pub use self::device_data_generated::*; } // device_data + pub mod server { + use super::*; + mod server_guards_generated; + pub use self::server_guards_generated::*; + } // server pub mod stay_aligned { use super::*; mod stay_aligned_pose_generated; @@ -173,6 +178,12 @@ pub mod solarxr_protocol { pub use self::vrcspine_mode_generated::*; mod vrcavatar_measurement_type_generated; pub use self::vrcavatar_measurement_type_generated::*; + mod tracking_checklist_step_id_generated; + pub use self::tracking_checklist_step_id_generated::*; + mod tracking_checklist_step_visibility_generated; + pub use self::tracking_checklist_step_visibility_generated::*; + mod tracking_checklist_extra_data_generated; + pub use self::tracking_checklist_extra_data_generated::*; mod stay_aligned_relaxed_pose_generated; pub use self::stay_aligned_relaxed_pose_generated::*; mod rpc_message_header_generated; @@ -367,6 +378,28 @@ pub mod solarxr_protocol { pub use self::vrcconfig_state_request_generated::*; mod vrcconfig_state_change_response_generated; pub use self::vrcconfig_state_change_response_generated::*; + mod vrcconfig_setting_toggle_mute_generated; + pub use self::vrcconfig_setting_toggle_mute_generated::*; + mod tracking_checklist_tracker_reset_generated; + pub use self::tracking_checklist_tracker_reset_generated::*; + mod tracking_checklist_tracker_error_generated; + pub use self::tracking_checklist_tracker_error_generated::*; + mod tracking_checklist_need_calibration_generated; + pub use self::tracking_checklist_need_calibration_generated::*; + mod tracking_checklist_steam_vrdisconnected_generated; + pub use self::tracking_checklist_steam_vrdisconnected_generated::*; + mod tracking_checklist_unassigned_hmd_generated; + pub use self::tracking_checklist_unassigned_hmd_generated::*; + mod tracking_checklist_public_networks_generated; + pub use self::tracking_checklist_public_networks_generated::*; + mod tracking_checklist_step_generated; + pub use self::tracking_checklist_step_generated::*; + mod tracking_checklist_request_generated; + pub use self::tracking_checklist_request_generated::*; + mod tracking_checklist_response_generated; + pub use self::tracking_checklist_response_generated::*; + mod ignore_tracking_checklist_step_request_generated; + pub use self::ignore_tracking_checklist_step_request_generated::*; mod enable_stay_aligned_request_generated; pub use self::enable_stay_aligned_request_generated::*; mod detect_stay_aligned_relaxed_pose_request_generated; diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs index 99333b6f..d77d7a12 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_config_generated.rs @@ -32,6 +32,7 @@ impl<'a> DataFeedConfig<'a> { pub const VT_SYNTHETIC_TRACKERS_MASK: flatbuffers::VOffsetT = 8; pub const VT_BONE_MASK: flatbuffers::VOffsetT = 10; pub const VT_STAY_ALIGNED_POSE_MASK: flatbuffers::VOffsetT = 12; + pub const VT_SERVER_GUARDS_MASK: flatbuffers::VOffsetT = 14; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -46,6 +47,7 @@ impl<'a> DataFeedConfig<'a> { if let Some(x) = args.synthetic_trackers_mask { builder.add_synthetic_trackers_mask(x); } if let Some(x) = args.data_mask { builder.add_data_mask(x); } builder.add_minimum_time_since_last(args.minimum_time_since_last); + builder.add_server_guards_mask(args.server_guards_mask); builder.add_stay_aligned_pose_mask(args.stay_aligned_pose_mask); builder.add_bone_mask(args.bone_mask); builder.finish() @@ -89,6 +91,13 @@ impl<'a> DataFeedConfig<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(DataFeedConfig::VT_STAY_ALIGNED_POSE_MASK, Some(false)).unwrap()} } + #[inline] + pub fn server_guards_mask(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(DataFeedConfig::VT_SERVER_GUARDS_MASK, Some(false)).unwrap()} + } } impl flatbuffers::Verifiable for DataFeedConfig<'_> { @@ -103,6 +112,7 @@ impl flatbuffers::Verifiable for DataFeedConfig<'_> { .visit_field::>("synthetic_trackers_mask", Self::VT_SYNTHETIC_TRACKERS_MASK, false)? .visit_field::("bone_mask", Self::VT_BONE_MASK, false)? .visit_field::("stay_aligned_pose_mask", Self::VT_STAY_ALIGNED_POSE_MASK, false)? + .visit_field::("server_guards_mask", Self::VT_SERVER_GUARDS_MASK, false)? .finish(); Ok(()) } @@ -113,6 +123,7 @@ pub struct DataFeedConfigArgs<'a> { pub synthetic_trackers_mask: Option>>, pub bone_mask: bool, pub stay_aligned_pose_mask: bool, + pub server_guards_mask: bool, } impl<'a> Default for DataFeedConfigArgs<'a> { #[inline] @@ -123,6 +134,7 @@ impl<'a> Default for DataFeedConfigArgs<'a> { synthetic_trackers_mask: None, bone_mask: false, stay_aligned_pose_mask: false, + server_guards_mask: false, } } } @@ -153,6 +165,10 @@ impl<'a: 'b, 'b> DataFeedConfigBuilder<'a, 'b> { self.fbb_.push_slot::(DataFeedConfig::VT_STAY_ALIGNED_POSE_MASK, stay_aligned_pose_mask, false); } #[inline] + pub fn add_server_guards_mask(&mut self, server_guards_mask: bool) { + self.fbb_.push_slot::(DataFeedConfig::VT_SERVER_GUARDS_MASK, server_guards_mask, false); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataFeedConfigBuilder<'a, 'b> { let start = _fbb.start_table(); DataFeedConfigBuilder { @@ -175,6 +191,7 @@ impl core::fmt::Debug for DataFeedConfig<'_> { ds.field("synthetic_trackers_mask", &self.synthetic_trackers_mask()); ds.field("bone_mask", &self.bone_mask()); ds.field("stay_aligned_pose_mask", &self.stay_aligned_pose_mask()); + ds.field("server_guards_mask", &self.server_guards_mask()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs index 2a9b8825..63062213 100644 --- a/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/data_feed_update_generated.rs @@ -37,6 +37,7 @@ impl<'a> DataFeedUpdate<'a> { pub const VT_BONES: flatbuffers::VOffsetT = 8; pub const VT_STAY_ALIGNED_POSE: flatbuffers::VOffsetT = 10; pub const VT_INDEX: flatbuffers::VOffsetT = 12; + pub const VT_SERVER_GUARDS: flatbuffers::VOffsetT = 14; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -48,6 +49,7 @@ impl<'a> DataFeedUpdate<'a> { args: &'args DataFeedUpdateArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = DataFeedUpdateBuilder::new(_fbb); + if let Some(x) = args.server_guards { builder.add_server_guards(x); } if let Some(x) = args.stay_aligned_pose { builder.add_stay_aligned_pose(x); } if let Some(x) = args.bones { builder.add_bones(x); } if let Some(x) = args.synthetic_trackers { builder.add_synthetic_trackers(x); } @@ -93,6 +95,13 @@ impl<'a> DataFeedUpdate<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(DataFeedUpdate::VT_INDEX, Some(0)).unwrap()} } + #[inline] + pub fn server_guards(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(DataFeedUpdate::VT_SERVER_GUARDS, None)} + } } impl flatbuffers::Verifiable for DataFeedUpdate<'_> { @@ -107,6 +116,7 @@ impl flatbuffers::Verifiable for DataFeedUpdate<'_> { .visit_field::>>>("bones", Self::VT_BONES, false)? .visit_field::>("stay_aligned_pose", Self::VT_STAY_ALIGNED_POSE, false)? .visit_field::("index", Self::VT_INDEX, false)? + .visit_field::>("server_guards", Self::VT_SERVER_GUARDS, false)? .finish(); Ok(()) } @@ -117,6 +127,7 @@ pub struct DataFeedUpdateArgs<'a> { pub bones: Option>>>>, pub stay_aligned_pose: Option>>, pub index: u8, + pub server_guards: Option>>, } impl<'a> Default for DataFeedUpdateArgs<'a> { #[inline] @@ -127,6 +138,7 @@ impl<'a> Default for DataFeedUpdateArgs<'a> { bones: None, stay_aligned_pose: None, index: 0, + server_guards: None, } } } @@ -157,6 +169,10 @@ impl<'a: 'b, 'b> DataFeedUpdateBuilder<'a, 'b> { self.fbb_.push_slot::(DataFeedUpdate::VT_INDEX, index, 0); } #[inline] + pub fn add_server_guards(&mut self, server_guards: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(DataFeedUpdate::VT_SERVER_GUARDS, server_guards); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataFeedUpdateBuilder<'a, 'b> { let start = _fbb.start_table(); DataFeedUpdateBuilder { @@ -179,6 +195,7 @@ impl core::fmt::Debug for DataFeedUpdate<'_> { ds.field("bones", &self.bones()); ds.field("stay_aligned_pose", &self.stay_aligned_pose()); ds.field("index", &self.index()); + ds.field("server_guards", &self.server_guards()); ds.finish() } } diff --git a/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs b/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs new file mode 100644 index 00000000..db9b5e31 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/data_feed/server/server_guards_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ServerGuardsOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ServerGuards<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ServerGuards<'a> { + type Inner = ServerGuards<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ServerGuards<'a> { + pub const VT_CANDOMOUNTING: flatbuffers::VOffsetT = 4; + pub const VT_CANDOYAWRESET: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ServerGuards { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ServerGuardsArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = ServerGuardsBuilder::new(_fbb); + builder.add_canDoYawReset(args.canDoYawReset); + builder.add_canDoMounting(args.canDoMounting); + builder.finish() + } + + + #[inline] + pub fn canDoMounting(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ServerGuards::VT_CANDOMOUNTING, Some(false)).unwrap()} + } + #[inline] + pub fn canDoYawReset(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ServerGuards::VT_CANDOYAWRESET, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for ServerGuards<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("canDoMounting", Self::VT_CANDOMOUNTING, false)? + .visit_field::("canDoYawReset", Self::VT_CANDOYAWRESET, false)? + .finish(); + Ok(()) + } +} +pub struct ServerGuardsArgs { + pub canDoMounting: bool, + pub canDoYawReset: bool, +} +impl<'a> Default for ServerGuardsArgs { + #[inline] + fn default() -> Self { + ServerGuardsArgs { + canDoMounting: false, + canDoYawReset: false, + } + } +} + +pub struct ServerGuardsBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ServerGuardsBuilder<'a, 'b> { + #[inline] + pub fn add_canDoMounting(&mut self, canDoMounting: bool) { + self.fbb_.push_slot::(ServerGuards::VT_CANDOMOUNTING, canDoMounting, false); + } + #[inline] + pub fn add_canDoYawReset(&mut self, canDoYawReset: bool) { + self.fbb_.push_slot::(ServerGuards::VT_CANDOYAWRESET, canDoYawReset, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ServerGuardsBuilder<'a, 'b> { + let start = _fbb.start_table(); + ServerGuardsBuilder { + 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 ServerGuards<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ServerGuards"); + ds.field("canDoMounting", &self.canDoMounting()); + ds.field("canDoYawReset", &self.canDoYawReset()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs index 61858ec0..fedb4dbe 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/firmware_update_status_generated.rs @@ -64,7 +64,7 @@ impl FirmwareUpdateStatus { pub const ERROR_DOWNLOAD_FAILED: Self = Self(10); /// The server could not authenticate with the MCU pub const ERROR_AUTHENTICATION_FAILED: Self = Self(11); - /// Could not upload the firmware to the MUC + /// Could not upload the firmware to the MCU pub const ERROR_UPLOAD_FAILED: Self = Self(12); /// The provision of the tracker failed, usually wifi credentials pub const ERROR_PROVISIONING_FAILED: Self = Self(13); diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/ignore_tracking_checklist_step_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/ignore_tracking_checklist_step_request_generated.rs new file mode 100644 index 00000000..30115dd1 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/ignore_tracking_checklist_step_request_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum IgnoreTrackingChecklistStepRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct IgnoreTrackingChecklistStepRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for IgnoreTrackingChecklistStepRequest<'a> { + type Inner = IgnoreTrackingChecklistStepRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> IgnoreTrackingChecklistStepRequest<'a> { + pub const VT_STEP_ID: flatbuffers::VOffsetT = 4; + pub const VT_IGNORE: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + IgnoreTrackingChecklistStepRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args IgnoreTrackingChecklistStepRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = IgnoreTrackingChecklistStepRequestBuilder::new(_fbb); + builder.add_ignore(args.ignore); + builder.add_step_id(args.step_id); + builder.finish() + } + + + #[inline] + pub fn step_id(&self) -> TrackingChecklistStepId { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(IgnoreTrackingChecklistStepRequest::VT_STEP_ID, Some(TrackingChecklistStepId::UNKNOWN)).unwrap()} + } + #[inline] + pub fn ignore(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(IgnoreTrackingChecklistStepRequest::VT_IGNORE, Some(false)).unwrap()} + } +} + +impl flatbuffers::Verifiable for IgnoreTrackingChecklistStepRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("step_id", Self::VT_STEP_ID, false)? + .visit_field::("ignore", Self::VT_IGNORE, false)? + .finish(); + Ok(()) + } +} +pub struct IgnoreTrackingChecklistStepRequestArgs { + pub step_id: TrackingChecklistStepId, + pub ignore: bool, +} +impl<'a> Default for IgnoreTrackingChecklistStepRequestArgs { + #[inline] + fn default() -> Self { + IgnoreTrackingChecklistStepRequestArgs { + step_id: TrackingChecklistStepId::UNKNOWN, + ignore: false, + } + } +} + +pub struct IgnoreTrackingChecklistStepRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> IgnoreTrackingChecklistStepRequestBuilder<'a, 'b> { + #[inline] + pub fn add_step_id(&mut self, step_id: TrackingChecklistStepId) { + self.fbb_.push_slot::(IgnoreTrackingChecklistStepRequest::VT_STEP_ID, step_id, TrackingChecklistStepId::UNKNOWN); + } + #[inline] + pub fn add_ignore(&mut self, ignore: bool) { + self.fbb_.push_slot::(IgnoreTrackingChecklistStepRequest::VT_IGNORE, ignore, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> IgnoreTrackingChecklistStepRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + IgnoreTrackingChecklistStepRequestBuilder { + 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 IgnoreTrackingChecklistStepRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("IgnoreTrackingChecklistStepRequest"); + ds.field("step_id", &self.step_id()); + ds.field("ignore", &self.ignore()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs index 6ebdc2b4..b8a5ff87 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/reset_response_generated.rs @@ -27,6 +27,9 @@ impl<'a> flatbuffers::Follow<'a> for ResetResponse<'a> { impl<'a> ResetResponse<'a> { pub const VT_RESET_TYPE: flatbuffers::VOffsetT = 4; pub const VT_STATUS: flatbuffers::VOffsetT = 6; + pub const VT_BODY_PARTS: flatbuffers::VOffsetT = 8; + pub const VT_PROGRESS: flatbuffers::VOffsetT = 10; + pub const VT_DURATION: flatbuffers::VOffsetT = 12; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -35,9 +38,12 @@ impl<'a> ResetResponse<'a> { #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ResetResponseArgs + args: &'args ResetResponseArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = ResetResponseBuilder::new(_fbb); + builder.add_duration(args.duration); + builder.add_progress(args.progress); + if let Some(x) = args.body_parts { builder.add_body_parts(x); } builder.add_status(args.status); builder.add_reset_type(args.reset_type); builder.finish() @@ -58,6 +64,31 @@ impl<'a> ResetResponse<'a> { // which contains a valid value in this slot unsafe { self._tab.get::(ResetResponse::VT_STATUS, Some(ResetStatus::STARTED)).unwrap()} } + /// Should return the body parts reseted / being reset + #[inline] + pub fn body_parts(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(ResetResponse::VT_BODY_PARTS, None)} + } + /// gives the time in seconds passed since the start of the reset + /// is 0 when status == FINISHED + /// starts at 0 + #[inline] + pub fn progress(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ResetResponse::VT_PROGRESS, Some(0)).unwrap()} + } + #[inline] + pub fn duration(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ResetResponse::VT_DURATION, Some(0)).unwrap()} + } } impl flatbuffers::Verifiable for ResetResponse<'_> { @@ -69,20 +100,29 @@ impl flatbuffers::Verifiable for ResetResponse<'_> { v.visit_table(pos)? .visit_field::("reset_type", Self::VT_RESET_TYPE, false)? .visit_field::("status", Self::VT_STATUS, false)? + .visit_field::>>("body_parts", Self::VT_BODY_PARTS, false)? + .visit_field::("progress", Self::VT_PROGRESS, false)? + .visit_field::("duration", Self::VT_DURATION, false)? .finish(); Ok(()) } } -pub struct ResetResponseArgs { +pub struct ResetResponseArgs<'a> { pub reset_type: ResetType, pub status: ResetStatus, + pub body_parts: Option>>, + pub progress: i32, + pub duration: i32, } -impl<'a> Default for ResetResponseArgs { +impl<'a> Default for ResetResponseArgs<'a> { #[inline] fn default() -> Self { ResetResponseArgs { reset_type: ResetType::Yaw, status: ResetStatus::STARTED, + body_parts: None, + progress: 0, + duration: 0, } } } @@ -101,6 +141,18 @@ impl<'a: 'b, 'b> ResetResponseBuilder<'a, 'b> { self.fbb_.push_slot::(ResetResponse::VT_STATUS, status, ResetStatus::STARTED); } #[inline] + pub fn add_body_parts(&mut self, body_parts: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(ResetResponse::VT_BODY_PARTS, body_parts); + } + #[inline] + pub fn add_progress(&mut self, progress: i32) { + self.fbb_.push_slot::(ResetResponse::VT_PROGRESS, progress, 0); + } + #[inline] + pub fn add_duration(&mut self, duration: i32) { + self.fbb_.push_slot::(ResetResponse::VT_DURATION, duration, 0); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ResetResponseBuilder<'a, 'b> { let start = _fbb.start_table(); ResetResponseBuilder { @@ -120,6 +172,9 @@ impl core::fmt::Debug for ResetResponse<'_> { let mut ds = f.debug_struct("ResetResponse"); ds.field("reset_type", &self.reset_type()); ds.field("status", &self.status()); + ds.field("body_parts", &self.body_parts()); + ds.field("progress", &self.progress()); + ds.field("duration", &self.duration()); 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 2555c2d7..ab72020d 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 = 71; +pub const ENUM_MAX_RPC_MESSAGE: u8 = 75; #[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; 72] = [ +pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 76] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, @@ -88,6 +88,10 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 72] = [ RpcMessage::DetectStayAlignedRelaxedPoseRequest, RpcMessage::ResetStayAlignedRelaxedPoseRequest, RpcMessage::SerialTrackerCustomCommandRequest, + RpcMessage::VRCConfigSettingToggleMute, + RpcMessage::TrackingChecklistRequest, + RpcMessage::TrackingChecklistResponse, + RpcMessage::IgnoreTrackingChecklistStepRequest, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -167,9 +171,13 @@ impl RpcMessage { pub const DetectStayAlignedRelaxedPoseRequest: Self = Self(69); pub const ResetStayAlignedRelaxedPoseRequest: Self = Self(70); pub const SerialTrackerCustomCommandRequest: Self = Self(71); + pub const VRCConfigSettingToggleMute: Self = Self(72); + pub const TrackingChecklistRequest: Self = Self(73); + pub const TrackingChecklistResponse: Self = Self(74); + pub const IgnoreTrackingChecklistStepRequest: Self = Self(75); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 71; + pub const ENUM_MAX: u8 = 75; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -243,6 +251,10 @@ impl RpcMessage { Self::DetectStayAlignedRelaxedPoseRequest, Self::ResetStayAlignedRelaxedPoseRequest, Self::SerialTrackerCustomCommandRequest, + Self::VRCConfigSettingToggleMute, + Self::TrackingChecklistRequest, + Self::TrackingChecklistResponse, + Self::IgnoreTrackingChecklistStepRequest, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -319,6 +331,10 @@ impl RpcMessage { Self::DetectStayAlignedRelaxedPoseRequest => Some("DetectStayAlignedRelaxedPoseRequest"), Self::ResetStayAlignedRelaxedPoseRequest => Some("ResetStayAlignedRelaxedPoseRequest"), Self::SerialTrackerCustomCommandRequest => Some("SerialTrackerCustomCommandRequest"), + Self::VRCConfigSettingToggleMute => Some("VRCConfigSettingToggleMute"), + Self::TrackingChecklistRequest => Some("TrackingChecklistRequest"), + Self::TrackingChecklistResponse => Some("TrackingChecklistResponse"), + Self::IgnoreTrackingChecklistStepRequest => Some("IgnoreTrackingChecklistStepRequest"), _ => 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 a1209d96..cf68868f 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 @@ -1134,6 +1134,66 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_vrcconfig_setting_toggle_mute(&self) -> Option> { + if self.message_type() == RpcMessage::VRCConfigSettingToggleMute { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VRCConfigSettingToggleMute::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_tracking_checklist_request(&self) -> Option> { + if self.message_type() == RpcMessage::TrackingChecklistRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_tracking_checklist_response(&self) -> Option> { + if self.message_type() == RpcMessage::TrackingChecklistResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_ignore_tracking_checklist_step_request(&self) -> Option> { + if self.message_type() == RpcMessage::IgnoreTrackingChecklistStepRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { IgnoreTrackingChecklistStepRequest::init_from_table(t) } + }) + } else { + None + } + } + } impl flatbuffers::Verifiable for RpcMessageHeader<'_> { @@ -1217,6 +1277,10 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::DetectStayAlignedRelaxedPoseRequest => v.verify_union_variant::>("RpcMessage::DetectStayAlignedRelaxedPoseRequest", pos), RpcMessage::ResetStayAlignedRelaxedPoseRequest => v.verify_union_variant::>("RpcMessage::ResetStayAlignedRelaxedPoseRequest", pos), RpcMessage::SerialTrackerCustomCommandRequest => v.verify_union_variant::>("RpcMessage::SerialTrackerCustomCommandRequest", pos), + RpcMessage::VRCConfigSettingToggleMute => v.verify_union_variant::>("RpcMessage::VRCConfigSettingToggleMute", pos), + RpcMessage::TrackingChecklistRequest => v.verify_union_variant::>("RpcMessage::TrackingChecklistRequest", pos), + RpcMessage::TrackingChecklistResponse => v.verify_union_variant::>("RpcMessage::TrackingChecklistResponse", pos), + RpcMessage::IgnoreTrackingChecklistStepRequest => v.verify_union_variant::>("RpcMessage::IgnoreTrackingChecklistStepRequest", pos), _ => Ok(()), } })? @@ -1775,6 +1839,34 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::VRCConfigSettingToggleMute => { + if let Some(x) = self.message_as_vrcconfig_setting_toggle_mute() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::TrackingChecklistRequest => { + if let Some(x) = self.message_as_tracking_checklist_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::TrackingChecklistResponse => { + if let Some(x) = self.message_as_tracking_checklist_response() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::IgnoreTrackingChecklistStepRequest => { + if let Some(x) = self.message_as_ignore_tracking_checklist_step_request() { + 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/status_tracker_error_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs index 40e5e096..18bc87f1 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_error_generated.rs @@ -12,7 +12,7 @@ use super::*; pub enum StatusTrackerErrorOffset {} #[derive(Copy, Clone, PartialEq)] -/// Tracker has error state +/// Trackers with error state pub struct StatusTrackerError<'a> { pub _tab: flatbuffers::Table<'a>, } @@ -44,11 +44,11 @@ impl<'a> StatusTrackerError<'a> { #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> Option>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(StatusTrackerError::VT_TRACKER_ID, None)} + unsafe { self._tab.get::>>>(StatusTrackerError::VT_TRACKER_ID, None)} } } @@ -59,13 +59,13 @@ impl flatbuffers::Verifiable for StatusTrackerError<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::>>>("tracker_id", Self::VT_TRACKER_ID, false)? .finish(); Ok(()) } } pub struct StatusTrackerErrorArgs<'a> { - pub tracker_id: Option>>, + pub tracker_id: Option>>>>, } impl<'a> Default for StatusTrackerErrorArgs<'a> { #[inline] @@ -82,8 +82,8 @@ pub struct StatusTrackerErrorBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> StatusTrackerErrorBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(StatusTrackerError::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(StatusTrackerError::VT_TRACKER_ID, tracker_id); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusTrackerErrorBuilder<'a, 'b> { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs index c9c0d337..a1a125cd 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/status_tracker_reset_generated.rs @@ -44,11 +44,11 @@ impl<'a> StatusTrackerReset<'a> { #[inline] - pub fn tracker_id(&self) -> Option> { + pub fn tracker_id(&self) -> Option>>> { // Safety: // Created from valid Table for this object // which contains a valid value in this slot - unsafe { self._tab.get::>(StatusTrackerReset::VT_TRACKER_ID, None)} + unsafe { self._tab.get::>>>(StatusTrackerReset::VT_TRACKER_ID, None)} } } @@ -59,13 +59,13 @@ impl flatbuffers::Verifiable for StatusTrackerReset<'_> { ) -> Result<(), flatbuffers::InvalidFlatbuffer> { use self::flatbuffers::Verifiable; v.visit_table(pos)? - .visit_field::>("tracker_id", Self::VT_TRACKER_ID, false)? + .visit_field::>>>("tracker_id", Self::VT_TRACKER_ID, false)? .finish(); Ok(()) } } pub struct StatusTrackerResetArgs<'a> { - pub tracker_id: Option>>, + pub tracker_id: Option>>>>, } impl<'a> Default for StatusTrackerResetArgs<'a> { #[inline] @@ -82,8 +82,8 @@ pub struct StatusTrackerResetBuilder<'a: 'b, 'b> { } impl<'a: 'b, 'b> StatusTrackerResetBuilder<'a, 'b> { #[inline] - pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(StatusTrackerReset::VT_TRACKER_ID, tracker_id); + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(StatusTrackerReset::VT_TRACKER_ID, tracker_id); } #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusTrackerResetBuilder<'a, 'b> { diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_extra_data_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_extra_data_generated.rs new file mode 100644 index 00000000..d9061d53 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_extra_data_generated.rs @@ -0,0 +1,118 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_TRACKING_CHECKLIST_EXTRA_DATA: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_TRACKING_CHECKLIST_EXTRA_DATA: u8 = 6; +#[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_TRACKING_CHECKLIST_EXTRA_DATA: [TrackingChecklistExtraData; 7] = [ + TrackingChecklistExtraData::NONE, + TrackingChecklistExtraData::TrackingChecklistTrackerReset, + TrackingChecklistExtraData::TrackingChecklistTrackerError, + TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected, + TrackingChecklistExtraData::TrackingChecklistUnassignedHMD, + TrackingChecklistExtraData::TrackingChecklistNeedCalibration, + TrackingChecklistExtraData::TrackingChecklistPublicNetworks, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct TrackingChecklistExtraData(pub u8); +#[allow(non_upper_case_globals)] +impl TrackingChecklistExtraData { + pub const NONE: Self = Self(0); + pub const TrackingChecklistTrackerReset: Self = Self(1); + pub const TrackingChecklistTrackerError: Self = Self(2); + pub const TrackingChecklistSteamVRDisconnected: Self = Self(3); + pub const TrackingChecklistUnassignedHMD: Self = Self(4); + pub const TrackingChecklistNeedCalibration: Self = Self(5); + pub const TrackingChecklistPublicNetworks: Self = Self(6); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 6; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::NONE, + Self::TrackingChecklistTrackerReset, + Self::TrackingChecklistTrackerError, + Self::TrackingChecklistSteamVRDisconnected, + Self::TrackingChecklistUnassignedHMD, + Self::TrackingChecklistNeedCalibration, + Self::TrackingChecklistPublicNetworks, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::NONE => Some("NONE"), + Self::TrackingChecklistTrackerReset => Some("TrackingChecklistTrackerReset"), + Self::TrackingChecklistTrackerError => Some("TrackingChecklistTrackerError"), + Self::TrackingChecklistSteamVRDisconnected => Some("TrackingChecklistSteamVRDisconnected"), + Self::TrackingChecklistUnassignedHMD => Some("TrackingChecklistUnassignedHMD"), + Self::TrackingChecklistNeedCalibration => Some("TrackingChecklistNeedCalibration"), + Self::TrackingChecklistPublicNetworks => Some("TrackingChecklistPublicNetworks"), + _ => None, + } + } +} +impl core::fmt::Debug for TrackingChecklistExtraData { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } +} +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistExtraData { + type Inner = Self; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = flatbuffers::read_scalar_at::(buf, loc); + Self(b) + } +} + +impl flatbuffers::Push for TrackingChecklistExtraData { + type Output = TrackingChecklistExtraData; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for TrackingChecklistExtraData { + type Scalar = u8; + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } +} + +impl<'a> flatbuffers::Verifiable for TrackingChecklistExtraData { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + u8::run_verifier(v, pos) + } +} + +impl flatbuffers::SimpleToVerifyInSlice for TrackingChecklistExtraData {} +pub struct TrackingChecklistExtraDataUnionTableOffset {} + diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs new file mode 100644 index 00000000..85080901 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_need_calibration_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TrackingChecklistNeedCalibrationOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistNeedCalibration<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistNeedCalibration<'a> { + type Inner = TrackingChecklistNeedCalibration<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistNeedCalibration<'a> { + pub const VT_TRACKERS_ID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistNeedCalibration { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistNeedCalibrationArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistNeedCalibrationBuilder::new(_fbb); + if let Some(x) = args.trackers_id { builder.add_trackers_id(x); } + builder.finish() + } + + + #[inline] + pub fn trackers_id(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistNeedCalibration<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistNeedCalibrationArgs<'a> { + pub trackers_id: Option>>>>, +} +impl<'a> Default for TrackingChecklistNeedCalibrationArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistNeedCalibrationArgs { + trackers_id: None, + } + } +} + +pub struct TrackingChecklistNeedCalibrationBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistNeedCalibrationBuilder<'a, 'b> { + #[inline] + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(TrackingChecklistNeedCalibration::VT_TRACKERS_ID, trackers_id); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistNeedCalibrationBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistNeedCalibrationBuilder { + 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 TrackingChecklistNeedCalibration<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistNeedCalibration"); + ds.field("trackers_id", &self.trackers_id()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_public_networks_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_public_networks_generated.rs new file mode 100644 index 00000000..b9aa1cc7 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_public_networks_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TrackingChecklistPublicNetworksOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistPublicNetworks<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistPublicNetworks<'a> { + type Inner = TrackingChecklistPublicNetworks<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistPublicNetworks<'a> { + pub const VT_ADAPTERS: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistPublicNetworks { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistPublicNetworksArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistPublicNetworksBuilder::new(_fbb); + if let Some(x) = args.adapters { builder.add_adapters(x); } + builder.finish() + } + + + #[inline] + pub fn adapters(&self) -> Option>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(TrackingChecklistPublicNetworks::VT_ADAPTERS, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistPublicNetworks<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("adapters", Self::VT_ADAPTERS, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistPublicNetworksArgs<'a> { + pub adapters: Option>>>, +} +impl<'a> Default for TrackingChecklistPublicNetworksArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistPublicNetworksArgs { + adapters: None, + } + } +} + +pub struct TrackingChecklistPublicNetworksBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistPublicNetworksBuilder<'a, 'b> { + #[inline] + pub fn add_adapters(&mut self, adapters: flatbuffers::WIPOffset>>) { + self.fbb_.push_slot_always::>(TrackingChecklistPublicNetworks::VT_ADAPTERS, adapters); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistPublicNetworksBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistPublicNetworksBuilder { + 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 TrackingChecklistPublicNetworks<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistPublicNetworks"); + ds.field("adapters", &self.adapters()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_request_generated.rs new file mode 100644 index 00000000..5fe7e018 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_request_generated.rs @@ -0,0 +1,90 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TrackingChecklistRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistRequest<'a> { + type Inner = TrackingChecklistRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args TrackingChecklistRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for TrackingChecklistRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistRequestArgs { +} +impl<'a> Default for TrackingChecklistRequestArgs { + #[inline] + fn default() -> Self { + TrackingChecklistRequestArgs { + } + } +} + +pub struct TrackingChecklistRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistRequestBuilder { + 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 TrackingChecklistRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_response_generated.rs new file mode 100644 index 00000000..025bebaf --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_response_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TrackingChecklistResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistResponse<'a> { + type Inner = TrackingChecklistResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistResponse<'a> { + pub const VT_STEPS: flatbuffers::VOffsetT = 4; + pub const VT_IGNORED_STEPS: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistResponseBuilder::new(_fbb); + if let Some(x) = args.ignored_steps { builder.add_ignored_steps(x); } + if let Some(x) = args.steps { builder.add_steps(x); } + builder.finish() + } + + + #[inline] + pub fn steps(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(TrackingChecklistResponse::VT_STEPS, None)} + } + #[inline] + pub fn ignored_steps(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(TrackingChecklistResponse::VT_IGNORED_STEPS, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("steps", Self::VT_STEPS, false)? + .visit_field::>>("ignored_steps", Self::VT_IGNORED_STEPS, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistResponseArgs<'a> { + pub steps: Option>>>>, + pub ignored_steps: Option>>, +} +impl<'a> Default for TrackingChecklistResponseArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistResponseArgs { + steps: None, + ignored_steps: None, + } + } +} + +pub struct TrackingChecklistResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistResponseBuilder<'a, 'b> { + #[inline] + pub fn add_steps(&mut self, steps: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(TrackingChecklistResponse::VT_STEPS, steps); + } + #[inline] + pub fn add_ignored_steps(&mut self, ignored_steps: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(TrackingChecklistResponse::VT_IGNORED_STEPS, ignored_steps); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistResponseBuilder { + 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 TrackingChecklistResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistResponse"); + ds.field("steps", &self.steps()); + ds.field("ignored_steps", &self.ignored_steps()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_steam_vrdisconnected_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_steam_vrdisconnected_generated.rs new file mode 100644 index 00000000..20adb283 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_steam_vrdisconnected_generated.rs @@ -0,0 +1,109 @@ +// 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 TrackingChecklistSteamVRDisconnectedOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistSteamVRDisconnected<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistSteamVRDisconnected<'a> { + type Inner = TrackingChecklistSteamVRDisconnected<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistSteamVRDisconnected<'a> { + pub const VT_BRIDGE_SETTINGS_NAME: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistSteamVRDisconnected { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistSteamVRDisconnectedArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistSteamVRDisconnectedBuilder::new(_fbb); + if let Some(x) = args.bridge_settings_name { builder.add_bridge_settings_name(x); } + builder.finish() + } + + + /// Name of bridge in the server's config + #[inline] + pub fn bridge_settings_name(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(TrackingChecklistSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistSteamVRDisconnected<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("bridge_settings_name", Self::VT_BRIDGE_SETTINGS_NAME, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistSteamVRDisconnectedArgs<'a> { + pub bridge_settings_name: Option>, +} +impl<'a> Default for TrackingChecklistSteamVRDisconnectedArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistSteamVRDisconnectedArgs { + bridge_settings_name: None, + } + } +} + +pub struct TrackingChecklistSteamVRDisconnectedBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistSteamVRDisconnectedBuilder<'a, 'b> { + #[inline] + pub fn add_bridge_settings_name(&mut self, bridge_settings_name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(TrackingChecklistSteamVRDisconnected::VT_BRIDGE_SETTINGS_NAME, bridge_settings_name); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistSteamVRDisconnectedBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistSteamVRDisconnectedBuilder { + 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 TrackingChecklistSteamVRDisconnected<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistSteamVRDisconnected"); + ds.field("bridge_settings_name", &self.bridge_settings_name()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_generated.rs new file mode 100644 index 00000000..1263ea1d --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_generated.rs @@ -0,0 +1,373 @@ +// 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 TrackingChecklistStepOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistStep<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistStep<'a> { + type Inner = TrackingChecklistStep<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistStep<'a> { + pub const VT_ID: flatbuffers::VOffsetT = 4; + pub const VT_VALID: flatbuffers::VOffsetT = 6; + pub const VT_ENABLED: flatbuffers::VOffsetT = 8; + pub const VT_VISIBILITY: flatbuffers::VOffsetT = 10; + pub const VT_OPTIONAL: flatbuffers::VOffsetT = 12; + pub const VT_IGNORABLE: flatbuffers::VOffsetT = 14; + pub const VT_EXTRA_DATA_TYPE: flatbuffers::VOffsetT = 16; + pub const VT_EXTRA_DATA: flatbuffers::VOffsetT = 18; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistStep { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistStepArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistStepBuilder::new(_fbb); + if let Some(x) = args.extra_data { builder.add_extra_data(x); } + builder.add_extra_data_type(args.extra_data_type); + builder.add_ignorable(args.ignorable); + builder.add_optional(args.optional); + builder.add_visibility(args.visibility); + builder.add_enabled(args.enabled); + builder.add_valid(args.valid); + builder.add_id(args.id); + builder.finish() + } + + + #[inline] + pub fn id(&self) -> TrackingChecklistStepId { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_ID, Some(TrackingChecklistStepId::UNKNOWN)).unwrap()} + } + #[inline] + pub fn valid(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_VALID, Some(false)).unwrap()} + } + #[inline] + pub fn enabled(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_ENABLED, Some(false)).unwrap()} + } + #[inline] + pub fn visibility(&self) -> TrackingChecklistStepVisibility { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_VISIBILITY, Some(TrackingChecklistStepVisibility::ALWAYS)).unwrap()} + } + #[inline] + pub fn optional(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_OPTIONAL, Some(false)).unwrap()} + } + #[inline] + pub fn ignorable(&self) -> bool { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_IGNORABLE, Some(false)).unwrap()} + } + #[inline] + pub fn extra_data_type(&self) -> TrackingChecklistExtraData { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(TrackingChecklistStep::VT_EXTRA_DATA_TYPE, Some(TrackingChecklistExtraData::NONE)).unwrap()} + } + #[inline] + pub fn extra_data(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(TrackingChecklistStep::VT_EXTRA_DATA, None)} + } + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_tracker_reset(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistTrackerReset { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistTrackerReset::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_tracker_error(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistTrackerError { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistTrackerError::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_steam_vrdisconnected(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistSteamVRDisconnected::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_unassigned_hmd(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistUnassignedHMD { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistUnassignedHMD::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_need_calibration(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistNeedCalibration { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistNeedCalibration::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn extra_data_as_tracking_checklist_public_networks(&self) -> Option> { + if self.extra_data_type() == TrackingChecklistExtraData::TrackingChecklistPublicNetworks { + self.extra_data().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { TrackingChecklistPublicNetworks::init_from_table(t) } + }) + } else { + None + } + } + +} + +impl flatbuffers::Verifiable for TrackingChecklistStep<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("id", Self::VT_ID, false)? + .visit_field::("valid", Self::VT_VALID, false)? + .visit_field::("enabled", Self::VT_ENABLED, false)? + .visit_field::("visibility", Self::VT_VISIBILITY, false)? + .visit_field::("optional", Self::VT_OPTIONAL, false)? + .visit_field::("ignorable", Self::VT_IGNORABLE, false)? + .visit_union::("extra_data_type", Self::VT_EXTRA_DATA_TYPE, "extra_data", Self::VT_EXTRA_DATA, false, |key, v, pos| { + match key { + TrackingChecklistExtraData::TrackingChecklistTrackerReset => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistTrackerReset", pos), + TrackingChecklistExtraData::TrackingChecklistTrackerError => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistTrackerError", pos), + TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected", pos), + TrackingChecklistExtraData::TrackingChecklistUnassignedHMD => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistUnassignedHMD", pos), + TrackingChecklistExtraData::TrackingChecklistNeedCalibration => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistNeedCalibration", pos), + TrackingChecklistExtraData::TrackingChecklistPublicNetworks => v.verify_union_variant::>("TrackingChecklistExtraData::TrackingChecklistPublicNetworks", pos), + _ => Ok(()), + } + })? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistStepArgs { + pub id: TrackingChecklistStepId, + pub valid: bool, + pub enabled: bool, + pub visibility: TrackingChecklistStepVisibility, + pub optional: bool, + pub ignorable: bool, + pub extra_data_type: TrackingChecklistExtraData, + pub extra_data: Option>, +} +impl<'a> Default for TrackingChecklistStepArgs { + #[inline] + fn default() -> Self { + TrackingChecklistStepArgs { + id: TrackingChecklistStepId::UNKNOWN, + valid: false, + enabled: false, + visibility: TrackingChecklistStepVisibility::ALWAYS, + optional: false, + ignorable: false, + extra_data_type: TrackingChecklistExtraData::NONE, + extra_data: None, + } + } +} + +pub struct TrackingChecklistStepBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistStepBuilder<'a, 'b> { + #[inline] + pub fn add_id(&mut self, id: TrackingChecklistStepId) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_ID, id, TrackingChecklistStepId::UNKNOWN); + } + #[inline] + pub fn add_valid(&mut self, valid: bool) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_VALID, valid, false); + } + #[inline] + pub fn add_enabled(&mut self, enabled: bool) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_ENABLED, enabled, false); + } + #[inline] + pub fn add_visibility(&mut self, visibility: TrackingChecklistStepVisibility) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_VISIBILITY, visibility, TrackingChecklistStepVisibility::ALWAYS); + } + #[inline] + pub fn add_optional(&mut self, optional: bool) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_OPTIONAL, optional, false); + } + #[inline] + pub fn add_ignorable(&mut self, ignorable: bool) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_IGNORABLE, ignorable, false); + } + #[inline] + pub fn add_extra_data_type(&mut self, extra_data_type: TrackingChecklistExtraData) { + self.fbb_.push_slot::(TrackingChecklistStep::VT_EXTRA_DATA_TYPE, extra_data_type, TrackingChecklistExtraData::NONE); + } + #[inline] + pub fn add_extra_data(&mut self, extra_data: flatbuffers::WIPOffset) { + self.fbb_.push_slot_always::>(TrackingChecklistStep::VT_EXTRA_DATA, extra_data); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistStepBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistStepBuilder { + 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 TrackingChecklistStep<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistStep"); + ds.field("id", &self.id()); + ds.field("valid", &self.valid()); + ds.field("enabled", &self.enabled()); + ds.field("visibility", &self.visibility()); + ds.field("optional", &self.optional()); + ds.field("ignorable", &self.ignorable()); + ds.field("extra_data_type", &self.extra_data_type()); + match self.extra_data_type() { + TrackingChecklistExtraData::TrackingChecklistTrackerReset => { + if let Some(x) = self.extra_data_as_tracking_checklist_tracker_reset() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + TrackingChecklistExtraData::TrackingChecklistTrackerError => { + if let Some(x) = self.extra_data_as_tracking_checklist_tracker_error() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + TrackingChecklistExtraData::TrackingChecklistSteamVRDisconnected => { + if let Some(x) = self.extra_data_as_tracking_checklist_steam_vrdisconnected() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + TrackingChecklistExtraData::TrackingChecklistUnassignedHMD => { + if let Some(x) = self.extra_data_as_tracking_checklist_unassigned_hmd() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + TrackingChecklistExtraData::TrackingChecklistNeedCalibration => { + if let Some(x) = self.extra_data_as_tracking_checklist_need_calibration() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + TrackingChecklistExtraData::TrackingChecklistPublicNetworks => { + if let Some(x) = self.extra_data_as_tracking_checklist_public_networks() { + ds.field("extra_data", &x) + } else { + ds.field("extra_data", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + _ => { + let x: Option<()> = None; + ds.field("extra_data", &x) + }, + }; + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_id_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_id_generated.rs new file mode 100644 index 00000000..45dbcf02 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_id_generated.rs @@ -0,0 +1,132 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_TRACKING_CHECKLIST_STEP_ID: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_TRACKING_CHECKLIST_STEP_ID: u8 = 10; +#[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_TRACKING_CHECKLIST_STEP_ID: [TrackingChecklistStepId; 11] = [ + TrackingChecklistStepId::UNKNOWN, + TrackingChecklistStepId::TRACKERS_REST_CALIBRATION, + TrackingChecklistStepId::FULL_RESET, + TrackingChecklistStepId::VRCHAT_SETTINGS, + TrackingChecklistStepId::STEAMVR_DISCONNECTED, + TrackingChecklistStepId::UNASSIGNED_HMD, + TrackingChecklistStepId::TRACKER_ERROR, + TrackingChecklistStepId::NETWORK_PROFILE_PUBLIC, + TrackingChecklistStepId::MOUNTING_CALIBRATION, + TrackingChecklistStepId::FEET_MOUNTING_CALIBRATION, + TrackingChecklistStepId::STAY_ALIGNED_CONFIGURED, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct TrackingChecklistStepId(pub u8); +#[allow(non_upper_case_globals)] +impl TrackingChecklistStepId { + pub const UNKNOWN: Self = Self(0); + pub const TRACKERS_REST_CALIBRATION: Self = Self(1); + pub const FULL_RESET: Self = Self(2); + pub const VRCHAT_SETTINGS: Self = Self(3); + pub const STEAMVR_DISCONNECTED: Self = Self(4); + pub const UNASSIGNED_HMD: Self = Self(5); + pub const TRACKER_ERROR: Self = Self(6); + pub const NETWORK_PROFILE_PUBLIC: Self = Self(7); + pub const MOUNTING_CALIBRATION: Self = Self(8); + pub const FEET_MOUNTING_CALIBRATION: Self = Self(9); + pub const STAY_ALIGNED_CONFIGURED: Self = Self(10); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 10; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::UNKNOWN, + Self::TRACKERS_REST_CALIBRATION, + Self::FULL_RESET, + Self::VRCHAT_SETTINGS, + Self::STEAMVR_DISCONNECTED, + Self::UNASSIGNED_HMD, + Self::TRACKER_ERROR, + Self::NETWORK_PROFILE_PUBLIC, + Self::MOUNTING_CALIBRATION, + Self::FEET_MOUNTING_CALIBRATION, + Self::STAY_ALIGNED_CONFIGURED, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::TRACKERS_REST_CALIBRATION => Some("TRACKERS_REST_CALIBRATION"), + Self::FULL_RESET => Some("FULL_RESET"), + Self::VRCHAT_SETTINGS => Some("VRCHAT_SETTINGS"), + Self::STEAMVR_DISCONNECTED => Some("STEAMVR_DISCONNECTED"), + Self::UNASSIGNED_HMD => Some("UNASSIGNED_HMD"), + Self::TRACKER_ERROR => Some("TRACKER_ERROR"), + Self::NETWORK_PROFILE_PUBLIC => Some("NETWORK_PROFILE_PUBLIC"), + Self::MOUNTING_CALIBRATION => Some("MOUNTING_CALIBRATION"), + Self::FEET_MOUNTING_CALIBRATION => Some("FEET_MOUNTING_CALIBRATION"), + Self::STAY_ALIGNED_CONFIGURED => Some("STAY_ALIGNED_CONFIGURED"), + _ => None, + } + } +} +impl core::fmt::Debug for TrackingChecklistStepId { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } +} +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistStepId { + type Inner = Self; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = flatbuffers::read_scalar_at::(buf, loc); + Self(b) + } +} + +impl flatbuffers::Push for TrackingChecklistStepId { + type Output = TrackingChecklistStepId; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for TrackingChecklistStepId { + type Scalar = u8; + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } +} + +impl<'a> flatbuffers::Verifiable for TrackingChecklistStepId { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + u8::run_verifier(v, pos) + } +} + +impl flatbuffers::SimpleToVerifyInSlice for TrackingChecklistStepId {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_visibility_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_visibility_generated.rs new file mode 100644 index 00000000..8159c600 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_step_visibility_generated.rs @@ -0,0 +1,96 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_TRACKING_CHECKLIST_STEP_VISIBILITY: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_TRACKING_CHECKLIST_STEP_VISIBILITY: u8 = 1; +#[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_TRACKING_CHECKLIST_STEP_VISIBILITY: [TrackingChecklistStepVisibility; 2] = [ + TrackingChecklistStepVisibility::ALWAYS, + TrackingChecklistStepVisibility::WHEN_INVALID, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct TrackingChecklistStepVisibility(pub u8); +#[allow(non_upper_case_globals)] +impl TrackingChecklistStepVisibility { + pub const ALWAYS: Self = Self(0); + pub const WHEN_INVALID: Self = Self(1); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 1; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::ALWAYS, + Self::WHEN_INVALID, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::ALWAYS => Some("ALWAYS"), + Self::WHEN_INVALID => Some("WHEN_INVALID"), + _ => None, + } + } +} +impl core::fmt::Debug for TrackingChecklistStepVisibility { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } +} +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistStepVisibility { + type Inner = Self; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = flatbuffers::read_scalar_at::(buf, loc); + Self(b) + } +} + +impl flatbuffers::Push for TrackingChecklistStepVisibility { + type Output = TrackingChecklistStepVisibility; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for TrackingChecklistStepVisibility { + type Scalar = u8; + #[inline] + fn to_little_endian(self) -> u8 { + self.0.to_le() + } + #[inline] + #[allow(clippy::wrong_self_convention)] + fn from_little_endian(v: u8) -> Self { + let b = u8::from_le(v); + Self(b) + } +} + +impl<'a> flatbuffers::Verifiable for TrackingChecklistStepVisibility { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + u8::run_verifier(v, pos) + } +} + +impl flatbuffers::SimpleToVerifyInSlice for TrackingChecklistStepVisibility {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs new file mode 100644 index 00000000..4a03b4bc --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_error_generated.rs @@ -0,0 +1,109 @@ +// 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 TrackingChecklistTrackerErrorOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Trackers with error state +pub struct TrackingChecklistTrackerError<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistTrackerError<'a> { + type Inner = TrackingChecklistTrackerError<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistTrackerError<'a> { + pub const VT_TRACKERS_ID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistTrackerError { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistTrackerErrorArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistTrackerErrorBuilder::new(_fbb); + if let Some(x) = args.trackers_id { builder.add_trackers_id(x); } + builder.finish() + } + + + #[inline] + pub fn trackers_id(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(TrackingChecklistTrackerError::VT_TRACKERS_ID, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistTrackerError<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistTrackerErrorArgs<'a> { + pub trackers_id: Option>>>>, +} +impl<'a> Default for TrackingChecklistTrackerErrorArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistTrackerErrorArgs { + trackers_id: None, + } + } +} + +pub struct TrackingChecklistTrackerErrorBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistTrackerErrorBuilder<'a, 'b> { + #[inline] + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(TrackingChecklistTrackerError::VT_TRACKERS_ID, trackers_id); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistTrackerErrorBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistTrackerErrorBuilder { + 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 TrackingChecklistTrackerError<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistTrackerError"); + ds.field("trackers_id", &self.trackers_id()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs new file mode 100644 index 00000000..2163d7b8 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_tracker_reset_generated.rs @@ -0,0 +1,109 @@ +// 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 TrackingChecklistTrackerResetOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Trackers that need a reset +pub struct TrackingChecklistTrackerReset<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistTrackerReset<'a> { + type Inner = TrackingChecklistTrackerReset<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistTrackerReset<'a> { + pub const VT_TRACKERS_ID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistTrackerReset { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistTrackerResetArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistTrackerResetBuilder::new(_fbb); + if let Some(x) = args.trackers_id { builder.add_trackers_id(x); } + builder.finish() + } + + + #[inline] + pub fn trackers_id(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(TrackingChecklistTrackerReset::VT_TRACKERS_ID, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistTrackerReset<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("trackers_id", Self::VT_TRACKERS_ID, false)? + .finish(); + Ok(()) + } +} +pub struct TrackingChecklistTrackerResetArgs<'a> { + pub trackers_id: Option>>>>, +} +impl<'a> Default for TrackingChecklistTrackerResetArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistTrackerResetArgs { + trackers_id: None, + } + } +} + +pub struct TrackingChecklistTrackerResetBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistTrackerResetBuilder<'a, 'b> { + #[inline] + pub fn add_trackers_id(&mut self, trackers_id: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(TrackingChecklistTrackerReset::VT_TRACKERS_ID, trackers_id); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistTrackerResetBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistTrackerResetBuilder { + 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 TrackingChecklistTrackerReset<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistTrackerReset"); + ds.field("trackers_id", &self.trackers_id()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs new file mode 100644 index 00000000..8290acb3 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/tracking_checklist_unassigned_hmd_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum TrackingChecklistUnassignedHMDOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct TrackingChecklistUnassignedHMD<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for TrackingChecklistUnassignedHMD<'a> { + type Inner = TrackingChecklistUnassignedHMD<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> TrackingChecklistUnassignedHMD<'a> { + pub const VT_TRACKER_ID: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + TrackingChecklistUnassignedHMD { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args TrackingChecklistUnassignedHMDArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = TrackingChecklistUnassignedHMDBuilder::new(_fbb); + if let Some(x) = args.tracker_id { builder.add_tracker_id(x); } + builder.finish() + } + + + #[inline] + pub fn tracker_id(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, None)} + } +} + +impl flatbuffers::Verifiable for TrackingChecklistUnassignedHMD<'_> { + #[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 TrackingChecklistUnassignedHMDArgs<'a> { + pub tracker_id: Option>>, +} +impl<'a> Default for TrackingChecklistUnassignedHMDArgs<'a> { + #[inline] + fn default() -> Self { + TrackingChecklistUnassignedHMDArgs { + tracker_id: None, + } + } +} + +pub struct TrackingChecklistUnassignedHMDBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> TrackingChecklistUnassignedHMDBuilder<'a, 'b> { + #[inline] + pub fn add_tracker_id(&mut self, tracker_id: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(TrackingChecklistUnassignedHMD::VT_TRACKER_ID, tracker_id); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackingChecklistUnassignedHMDBuilder<'a, 'b> { + let start = _fbb.start_table(); + TrackingChecklistUnassignedHMDBuilder { + 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 TrackingChecklistUnassignedHMD<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("TrackingChecklistUnassignedHMD"); + ds.field("tracker_id", &self.tracker_id()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs new file mode 100644 index 00000000..278625b5 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_setting_toggle_mute_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum VRCConfigSettingToggleMuteOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VRCConfigSettingToggleMute<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VRCConfigSettingToggleMute<'a> { + type Inner = VRCConfigSettingToggleMute<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VRCConfigSettingToggleMute<'a> { + pub const VT_KEY: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VRCConfigSettingToggleMute { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VRCConfigSettingToggleMuteArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VRCConfigSettingToggleMuteBuilder::new(_fbb); + if let Some(x) = args.key { builder.add_key(x); } + builder.finish() + } + + + #[inline] + pub fn key(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VRCConfigSettingToggleMute::VT_KEY, None)} + } +} + +impl flatbuffers::Verifiable for VRCConfigSettingToggleMute<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("key", Self::VT_KEY, false)? + .finish(); + Ok(()) + } +} +pub struct VRCConfigSettingToggleMuteArgs<'a> { + pub key: Option>, +} +impl<'a> Default for VRCConfigSettingToggleMuteArgs<'a> { + #[inline] + fn default() -> Self { + VRCConfigSettingToggleMuteArgs { + key: None, + } + } +} + +pub struct VRCConfigSettingToggleMuteBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VRCConfigSettingToggleMuteBuilder<'a, 'b> { + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VRCConfigSettingToggleMute::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCConfigSettingToggleMuteBuilder<'a, 'b> { + let start = _fbb.start_table(); + VRCConfigSettingToggleMuteBuilder { + 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 VRCConfigSettingToggleMute<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VRCConfigSettingToggleMute"); + ds.field("key", &self.key()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs index 30ba4b21..eb78c06b 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/vrcconfig_state_change_response_generated.rs @@ -31,6 +31,7 @@ impl<'a> VRCConfigStateChangeResponse<'a> { pub const VT_VALIDITY: flatbuffers::VOffsetT = 6; pub const VT_STATE: flatbuffers::VOffsetT = 8; pub const VT_RECOMMENDED: flatbuffers::VOffsetT = 10; + pub const VT_MUTED: flatbuffers::VOffsetT = 12; #[inline] pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { @@ -42,6 +43,7 @@ impl<'a> VRCConfigStateChangeResponse<'a> { args: &'args VRCConfigStateChangeResponseArgs<'args> ) -> flatbuffers::WIPOffset> { let mut builder = VRCConfigStateChangeResponseBuilder::new(_fbb); + if let Some(x) = args.muted { builder.add_muted(x); } if let Some(x) = args.recommended { builder.add_recommended(x); } if let Some(x) = args.state { builder.add_state(x); } if let Some(x) = args.validity { builder.add_validity(x); } @@ -78,6 +80,13 @@ impl<'a> VRCConfigStateChangeResponse<'a> { // which contains a valid value in this slot unsafe { self._tab.get::>(VRCConfigStateChangeResponse::VT_RECOMMENDED, None)} } + #[inline] + pub fn muted(&self) -> Option>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(VRCConfigStateChangeResponse::VT_MUTED, None)} + } } impl flatbuffers::Verifiable for VRCConfigStateChangeResponse<'_> { @@ -91,6 +100,7 @@ impl flatbuffers::Verifiable for VRCConfigStateChangeResponse<'_> { .visit_field::>("validity", Self::VT_VALIDITY, false)? .visit_field::>("state", Self::VT_STATE, false)? .visit_field::>("recommended", Self::VT_RECOMMENDED, false)? + .visit_field::>>>("muted", Self::VT_MUTED, false)? .finish(); Ok(()) } @@ -100,6 +110,7 @@ pub struct VRCConfigStateChangeResponseArgs<'a> { pub validity: Option>>, pub state: Option>>, pub recommended: Option>>, + pub muted: Option>>>, } impl<'a> Default for VRCConfigStateChangeResponseArgs<'a> { #[inline] @@ -109,6 +120,7 @@ impl<'a> Default for VRCConfigStateChangeResponseArgs<'a> { validity: None, state: None, recommended: None, + muted: None, } } } @@ -135,6 +147,10 @@ impl<'a: 'b, 'b> VRCConfigStateChangeResponseBuilder<'a, 'b> { self.fbb_.push_slot_always::>(VRCConfigStateChangeResponse::VT_RECOMMENDED, recommended); } #[inline] + pub fn add_muted(&mut self, muted: flatbuffers::WIPOffset>>) { + self.fbb_.push_slot_always::>(VRCConfigStateChangeResponse::VT_MUTED, muted); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VRCConfigStateChangeResponseBuilder<'a, 'b> { let start = _fbb.start_table(); VRCConfigStateChangeResponseBuilder { @@ -156,6 +172,7 @@ impl core::fmt::Debug for VRCConfigStateChangeResponse<'_> { ds.field("validity", &self.validity()); ds.field("state", &self.state()); ds.field("recommended", &self.recommended()); + ds.field("muted", &self.muted()); ds.finish() } } diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index 48764888..d97b086d 100644 --- a/protocol/typescript/src/all_generated.ts +++ b/protocol/typescript/src/all_generated.ts @@ -10,6 +10,7 @@ export { PollDataFeed, PollDataFeedT } from './solarxr-protocol/data-feed/poll-d export { StartDataFeed, StartDataFeedT } from './solarxr-protocol/data-feed/start-data-feed.js'; export { DeviceData, DeviceDataT } from './solarxr-protocol/data-feed/device-data/device-data.js'; export { DeviceDataMask, DeviceDataMaskT } from './solarxr-protocol/data-feed/device-data/device-data-mask.js'; +export { ServerGuards, ServerGuardsT } from './solarxr-protocol/data-feed/server/server-guards.js'; export { StayAlignedPose, StayAlignedPoseT } from './solarxr-protocol/data-feed/stay-aligned/stay-aligned-pose.js'; export { StayAlignedTracker, StayAlignedTrackerT } from './solarxr-protocol/data-feed/stay-aligned/stay-aligned-tracker.js'; export { TrackerData, TrackerDataT } from './solarxr-protocol/data-feed/tracker/tracker-data.js'; @@ -85,6 +86,7 @@ export { HeartbeatRequest, HeartbeatRequestT } from './solarxr-protocol/rpc/hear export { HeartbeatResponse, HeartbeatResponseT } from './solarxr-protocol/rpc/heartbeat-response.js'; export { HeightRequest, HeightRequestT } from './solarxr-protocol/rpc/height-request.js'; export { HeightResponse, HeightResponseT } from './solarxr-protocol/rpc/height-response.js'; +export { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from './solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; export { LegTweaksTmpChange, LegTweaksTmpChangeT } from './solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; export { LegTweaksTmpClear, LegTweaksTmpClearT } from './solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; export { MagToggleRequest, MagToggleRequestT } from './solarxr-protocol/rpc/mag-toggle-request.js'; @@ -151,12 +153,25 @@ export { SteamVRTrackersSetting, SteamVRTrackersSettingT } from './solarxr-proto export { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from './solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; export { TapDetectionSettings, TapDetectionSettingsT } from './solarxr-protocol/rpc/tap-detection-settings.js'; export { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from './solarxr-protocol/rpc/tap-detection-setup-notification.js'; +export { TrackingChecklistExtraData, unionToTrackingChecklistExtraData, unionListToTrackingChecklistExtraData } from './solarxr-protocol/rpc/tracking-checklist-extra-data.js'; +export { TrackingChecklistNeedCalibration, TrackingChecklistNeedCalibrationT } from './solarxr-protocol/rpc/tracking-checklist-need-calibration.js'; +export { TrackingChecklistPublicNetworks, TrackingChecklistPublicNetworksT } from './solarxr-protocol/rpc/tracking-checklist-public-networks.js'; +export { TrackingChecklistRequest, TrackingChecklistRequestT } from './solarxr-protocol/rpc/tracking-checklist-request.js'; +export { TrackingChecklistResponse, TrackingChecklistResponseT } from './solarxr-protocol/rpc/tracking-checklist-response.js'; +export { TrackingChecklistSteamVRDisconnected, TrackingChecklistSteamVRDisconnectedT } from './solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.js'; +export { TrackingChecklistStep, TrackingChecklistStepT } from './solarxr-protocol/rpc/tracking-checklist-step.js'; +export { TrackingChecklistStepId } from './solarxr-protocol/rpc/tracking-checklist-step-id.js'; +export { TrackingChecklistStepVisibility } from './solarxr-protocol/rpc/tracking-checklist-step-visibility.js'; +export { TrackingChecklistTrackerError, TrackingChecklistTrackerErrorT } from './solarxr-protocol/rpc/tracking-checklist-tracker-error.js'; +export { TrackingChecklistTrackerReset, TrackingChecklistTrackerResetT } from './solarxr-protocol/rpc/tracking-checklist-tracker-reset.js'; +export { TrackingChecklistUnassignedHMD, TrackingChecklistUnassignedHMDT } from './solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.js'; 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 { VMCOSCSettings, VMCOSCSettingsT } from './solarxr-protocol/rpc/vmcoscsettings.js'; export { VRCAvatarMeasurementType } from './solarxr-protocol/rpc/vrcavatar-measurement-type.js'; export { VRCConfigRecommendedValues, VRCConfigRecommendedValuesT } from './solarxr-protocol/rpc/vrcconfig-recommended-values.js'; +export { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from './solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; export { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from './solarxr-protocol/rpc/vrcconfig-state-change-response.js'; export { VRCConfigStateRequest, VRCConfigStateRequestT } from './solarxr-protocol/rpc/vrcconfig-state-request.js'; export { VRCConfigValidity, VRCConfigValidityT } from './solarxr-protocol/rpc/vrcconfig-validity.js'; diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts index b5513d7d..043a8da5 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-config.ts @@ -57,8 +57,13 @@ stayAlignedPoseMask():boolean { return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; } +serverGuardsMask():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + static startDataFeedConfig(builder:flatbuffers.Builder) { - builder.startObject(5); + builder.startObject(6); } static addMinimumTimeSinceLast(builder:flatbuffers.Builder, minimumTimeSinceLast:number) { @@ -81,6 +86,10 @@ static addStayAlignedPoseMask(builder:flatbuffers.Builder, stayAlignedPoseMask:b builder.addFieldInt8(4, +stayAlignedPoseMask, +false); } +static addServerGuardsMask(builder:flatbuffers.Builder, serverGuardsMask:boolean) { + builder.addFieldInt8(5, +serverGuardsMask, +false); +} + static endDataFeedConfig(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -93,7 +102,8 @@ unpack(): DataFeedConfigT { (this.dataMask() !== null ? this.dataMask()!.unpack() : null), (this.syntheticTrackersMask() !== null ? this.syntheticTrackersMask()!.unpack() : null), this.boneMask(), - this.stayAlignedPoseMask() + this.stayAlignedPoseMask(), + this.serverGuardsMask() ); } @@ -104,6 +114,7 @@ unpackTo(_o: DataFeedConfigT): void { _o.syntheticTrackersMask = (this.syntheticTrackersMask() !== null ? this.syntheticTrackersMask()!.unpack() : null); _o.boneMask = this.boneMask(); _o.stayAlignedPoseMask = this.stayAlignedPoseMask(); + _o.serverGuardsMask = this.serverGuardsMask(); } } @@ -113,7 +124,8 @@ constructor( public dataMask: DeviceDataMaskT|null = null, public syntheticTrackersMask: TrackerDataMaskT|null = null, public boneMask: boolean = false, - public stayAlignedPoseMask: boolean = false + public stayAlignedPoseMask: boolean = false, + public serverGuardsMask: boolean = false ){} @@ -127,6 +139,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { DataFeedConfig.addSyntheticTrackersMask(builder, syntheticTrackersMask); DataFeedConfig.addBoneMask(builder, this.boneMask); DataFeedConfig.addStayAlignedPoseMask(builder, this.stayAlignedPoseMask); + DataFeedConfig.addServerGuardsMask(builder, this.serverGuardsMask); return DataFeedConfig.endDataFeedConfig(builder); } diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts index a1d8c4ee..5c2fd13c 100644 --- a/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts +++ b/protocol/typescript/src/solarxr-protocol/data-feed/data-feed-update.ts @@ -4,6 +4,7 @@ import * as flatbuffers from 'flatbuffers'; import { Bone, BoneT } from '../../solarxr-protocol/data-feed/bone.js'; import { DeviceData, DeviceDataT } from '../../solarxr-protocol/data-feed/device-data/device-data.js'; +import { ServerGuards, ServerGuardsT } from '../../solarxr-protocol/data-feed/server/server-guards.js'; import { StayAlignedPose, StayAlignedPoseT } from '../../solarxr-protocol/data-feed/stay-aligned/stay-aligned-pose.js'; import { TrackerData, TrackerDataT } from '../../solarxr-protocol/data-feed/tracker/tracker-data.js'; @@ -78,8 +79,13 @@ index():number { return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; } +serverGuards(obj?:ServerGuards):ServerGuards|null { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? (obj || new ServerGuards()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + static startDataFeedUpdate(builder:flatbuffers.Builder) { - builder.startObject(5); + builder.startObject(6); } static addDevices(builder:flatbuffers.Builder, devicesOffset:flatbuffers.Offset) { @@ -138,6 +144,10 @@ static addIndex(builder:flatbuffers.Builder, index:number) { builder.addFieldInt8(4, index, 0); } +static addServerGuards(builder:flatbuffers.Builder, serverGuardsOffset:flatbuffers.Offset) { + builder.addFieldOffset(5, serverGuardsOffset, 0); +} + static endDataFeedUpdate(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -150,7 +160,8 @@ unpack(): DataFeedUpdateT { this.bb!.createObjList(this.syntheticTrackers.bind(this), this.syntheticTrackersLength()), this.bb!.createObjList(this.bones.bind(this), this.bonesLength()), (this.stayAlignedPose() !== null ? this.stayAlignedPose()!.unpack() : null), - this.index() + this.index(), + (this.serverGuards() !== null ? this.serverGuards()!.unpack() : null) ); } @@ -161,6 +172,7 @@ unpackTo(_o: DataFeedUpdateT): void { _o.bones = this.bb!.createObjList(this.bones.bind(this), this.bonesLength()); _o.stayAlignedPose = (this.stayAlignedPose() !== null ? this.stayAlignedPose()!.unpack() : null); _o.index = this.index(); + _o.serverGuards = (this.serverGuards() !== null ? this.serverGuards()!.unpack() : null); } } @@ -170,7 +182,8 @@ constructor( public syntheticTrackers: (TrackerDataT)[] = [], public bones: (BoneT)[] = [], public stayAlignedPose: StayAlignedPoseT|null = null, - public index: number = 0 + public index: number = 0, + public serverGuards: ServerGuardsT|null = null ){} @@ -179,6 +192,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { const syntheticTrackers = DataFeedUpdate.createSyntheticTrackersVector(builder, builder.createObjectOffsetList(this.syntheticTrackers)); const bones = DataFeedUpdate.createBonesVector(builder, builder.createObjectOffsetList(this.bones)); const stayAlignedPose = (this.stayAlignedPose !== null ? this.stayAlignedPose!.pack(builder) : 0); + const serverGuards = (this.serverGuards !== null ? this.serverGuards!.pack(builder) : 0); DataFeedUpdate.startDataFeedUpdate(builder); DataFeedUpdate.addDevices(builder, devices); @@ -186,6 +200,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { DataFeedUpdate.addBones(builder, bones); DataFeedUpdate.addStayAlignedPose(builder, stayAlignedPose); DataFeedUpdate.addIndex(builder, this.index); + DataFeedUpdate.addServerGuards(builder, serverGuards); return DataFeedUpdate.endDataFeedUpdate(builder); } diff --git a/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts b/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts new file mode 100644 index 00000000..345c3003 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/data-feed/server/server-guards.ts @@ -0,0 +1,86 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ServerGuards implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ServerGuards { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsServerGuards(bb:flatbuffers.ByteBuffer, obj?:ServerGuards):ServerGuards { + return (obj || new ServerGuards()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsServerGuards(bb:flatbuffers.ByteBuffer, obj?:ServerGuards):ServerGuards { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ServerGuards()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +canDoMounting():boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +canDoYawReset():boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startServerGuards(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addCanDoMounting(builder:flatbuffers.Builder, canDoMounting:boolean) { + builder.addFieldInt8(0, +canDoMounting, +false); +} + +static addCanDoYawReset(builder:flatbuffers.Builder, canDoYawReset:boolean) { + builder.addFieldInt8(1, +canDoYawReset, +false); +} + +static endServerGuards(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createServerGuards(builder:flatbuffers.Builder, canDoMounting:boolean, canDoYawReset:boolean):flatbuffers.Offset { + ServerGuards.startServerGuards(builder); + ServerGuards.addCanDoMounting(builder, canDoMounting); + ServerGuards.addCanDoYawReset(builder, canDoYawReset); + return ServerGuards.endServerGuards(builder); +} + +unpack(): ServerGuardsT { + return new ServerGuardsT( + this.canDoMounting(), + this.canDoYawReset() + ); +} + + +unpackTo(_o: ServerGuardsT): void { + _o.canDoMounting = this.canDoMounting(); + _o.canDoYawReset = this.canDoYawReset(); +} +} + +export class ServerGuardsT implements flatbuffers.IGeneratedObject { +constructor( + public canDoMounting: boolean = false, + public canDoYawReset: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ServerGuards.createServerGuards(builder, + this.canDoMounting, + this.canDoYawReset + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts index a517fb28..d5cd2502 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/firmware-update-status.ts @@ -60,7 +60,7 @@ export enum FirmwareUpdateStatus { ERROR_AUTHENTICATION_FAILED = 11, /** - * Could not upload the firmware to the MUC + * Could not upload the firmware to the MCU */ ERROR_UPLOAD_FAILED = 12, diff --git a/protocol/typescript/src/solarxr-protocol/rpc/ignore-tracking-checklist-step-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/ignore-tracking-checklist-step-request.ts new file mode 100644 index 00000000..1530b61d --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/ignore-tracking-checklist-step-request.ts @@ -0,0 +1,87 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackingChecklistStepId } from '../../solarxr-protocol/rpc/tracking-checklist-step-id.js'; + + +export class IgnoreTrackingChecklistStepRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):IgnoreTrackingChecklistStepRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsIgnoreTrackingChecklistStepRequest(bb:flatbuffers.ByteBuffer, obj?:IgnoreTrackingChecklistStepRequest):IgnoreTrackingChecklistStepRequest { + return (obj || new IgnoreTrackingChecklistStepRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsIgnoreTrackingChecklistStepRequest(bb:flatbuffers.ByteBuffer, obj?:IgnoreTrackingChecklistStepRequest):IgnoreTrackingChecklistStepRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new IgnoreTrackingChecklistStepRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +stepId():TrackingChecklistStepId { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackingChecklistStepId.UNKNOWN; +} + +ignore():boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +static startIgnoreTrackingChecklistStepRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addStepId(builder:flatbuffers.Builder, stepId:TrackingChecklistStepId) { + builder.addFieldInt8(0, stepId, TrackingChecklistStepId.UNKNOWN); +} + +static addIgnore(builder:flatbuffers.Builder, ignore:boolean) { + builder.addFieldInt8(1, +ignore, +false); +} + +static endIgnoreTrackingChecklistStepRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createIgnoreTrackingChecklistStepRequest(builder:flatbuffers.Builder, stepId:TrackingChecklistStepId, ignore:boolean):flatbuffers.Offset { + IgnoreTrackingChecklistStepRequest.startIgnoreTrackingChecklistStepRequest(builder); + IgnoreTrackingChecklistStepRequest.addStepId(builder, stepId); + IgnoreTrackingChecklistStepRequest.addIgnore(builder, ignore); + return IgnoreTrackingChecklistStepRequest.endIgnoreTrackingChecklistStepRequest(builder); +} + +unpack(): IgnoreTrackingChecklistStepRequestT { + return new IgnoreTrackingChecklistStepRequestT( + this.stepId(), + this.ignore() + ); +} + + +unpackTo(_o: IgnoreTrackingChecklistStepRequestT): void { + _o.stepId = this.stepId(); + _o.ignore = this.ignore(); +} +} + +export class IgnoreTrackingChecklistStepRequestT implements flatbuffers.IGeneratedObject { +constructor( + public stepId: TrackingChecklistStepId = TrackingChecklistStepId.UNKNOWN, + public ignore: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return IgnoreTrackingChecklistStepRequest.createIgnoreTrackingChecklistStepRequest(builder, + this.stepId, + this.ignore + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts index 03dbbba7..0349ed65 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/reset-response.ts @@ -2,6 +2,7 @@ import * as flatbuffers from 'flatbuffers'; +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; import { ResetStatus } from '../../solarxr-protocol/rpc/reset-status.js'; import { ResetType } from '../../solarxr-protocol/rpc/reset-type.js'; @@ -34,8 +35,41 @@ status():ResetStatus { return offset ? this.bb!.readUint8(this.bb_pos + offset) : ResetStatus.STARTED; } +/** + * Should return the body parts reseted / being reset + */ +bodyParts(index: number):BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +bodyPartsLength():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +bodyPartsArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +/** + * gives the time in seconds passed since the start of the reset + * is 0 when status == FINISHED + * starts at 0 + */ +progress():number { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +} + +duration():number { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +} + static startResetResponse(builder:flatbuffers.Builder) { - builder.startObject(2); + builder.startObject(5); } static addResetType(builder:flatbuffers.Builder, resetType:ResetType) { @@ -46,22 +80,52 @@ static addStatus(builder:flatbuffers.Builder, status:ResetStatus) { builder.addFieldInt8(1, status, ResetStatus.STARTED); } +static addBodyParts(builder:flatbuffers.Builder, bodyPartsOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, bodyPartsOffset, 0); +} + +static createBodyPartsVector(builder:flatbuffers.Builder, data:BodyPart[]):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startBodyPartsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static addProgress(builder:flatbuffers.Builder, progress:number) { + builder.addFieldInt32(3, progress, 0); +} + +static addDuration(builder:flatbuffers.Builder, duration:number) { + builder.addFieldInt32(4, duration, 0); +} + static endResetResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createResetResponse(builder:flatbuffers.Builder, resetType:ResetType, status:ResetStatus):flatbuffers.Offset { +static createResetResponse(builder:flatbuffers.Builder, resetType:ResetType, status:ResetStatus, bodyPartsOffset:flatbuffers.Offset, progress:number, duration:number):flatbuffers.Offset { ResetResponse.startResetResponse(builder); ResetResponse.addResetType(builder, resetType); ResetResponse.addStatus(builder, status); + ResetResponse.addBodyParts(builder, bodyPartsOffset); + ResetResponse.addProgress(builder, progress); + ResetResponse.addDuration(builder, duration); return ResetResponse.endResetResponse(builder); } unpack(): ResetResponseT { return new ResetResponseT( this.resetType(), - this.status() + this.status(), + this.bb!.createScalarList(this.bodyParts.bind(this), this.bodyPartsLength()), + this.progress(), + this.duration() ); } @@ -69,20 +133,31 @@ unpack(): ResetResponseT { unpackTo(_o: ResetResponseT): void { _o.resetType = this.resetType(); _o.status = this.status(); + _o.bodyParts = this.bb!.createScalarList(this.bodyParts.bind(this), this.bodyPartsLength()); + _o.progress = this.progress(); + _o.duration = this.duration(); } } export class ResetResponseT implements flatbuffers.IGeneratedObject { constructor( public resetType: ResetType = ResetType.Yaw, - public status: ResetStatus = ResetStatus.STARTED + public status: ResetStatus = ResetStatus.STARTED, + public bodyParts: (BodyPart)[] = [], + public progress: number = 0, + public duration: number = 0 ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const bodyParts = ResetResponse.createBodyPartsVector(builder, this.bodyParts); + return ResetResponse.createResetResponse(builder, this.resetType, - this.status + this.status, + bodyParts, + this.progress, + this.duration ); } } 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 f6df51fa..da5d3032 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -27,6 +27,7 @@ import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/ import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; +import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; import { LegTweaksTmpChange, LegTweaksTmpChangeT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; import { LegTweaksTmpClear, LegTweaksTmpClearT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; import { MagToggleRequest, MagToggleRequestT } from '../../solarxr-protocol/rpc/mag-toggle-request.js'; @@ -69,9 +70,12 @@ import { StatusSystemResponse, StatusSystemResponseT } from '../../solarxr-proto import { StatusSystemUpdate, StatusSystemUpdateT } from '../../solarxr-protocol/rpc/status-system-update.js'; import { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; import { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from '../../solarxr-protocol/rpc/tap-detection-setup-notification.js'; +import { TrackingChecklistRequest, TrackingChecklistRequestT } from '../../solarxr-protocol/rpc/tracking-checklist-request.js'; +import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../solarxr-protocol/rpc/tracking-checklist-response.js'; 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 { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; import { VRCConfigStateRequest, VRCConfigStateRequestT } from '../../solarxr-protocol/rpc/vrcconfig-state-request.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -171,7 +175,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|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|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|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|WifiProvisioningStatusResponseT|null = null + public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|IgnoreTrackingChecklistStepRequestT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|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|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|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 ea298a85..d603d802 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -24,6 +24,7 @@ import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/ import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; +import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; import { LegTweaksTmpChange, LegTweaksTmpChangeT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; import { LegTweaksTmpClear, LegTweaksTmpClearT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; import { MagToggleRequest, MagToggleRequestT } from '../../solarxr-protocol/rpc/mag-toggle-request.js'; @@ -65,9 +66,12 @@ import { StatusSystemResponse, StatusSystemResponseT } from '../../solarxr-proto import { StatusSystemUpdate, StatusSystemUpdateT } from '../../solarxr-protocol/rpc/status-system-update.js'; import { StopWifiProvisioningRequest, StopWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/stop-wifi-provisioning-request.js'; import { TapDetectionSetupNotification, TapDetectionSetupNotificationT } from '../../solarxr-protocol/rpc/tap-detection-setup-notification.js'; +import { TrackingChecklistRequest, TrackingChecklistRequestT } from '../../solarxr-protocol/rpc/tracking-checklist-request.js'; +import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../solarxr-protocol/rpc/tracking-checklist-response.js'; 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 { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; import { VRCConfigStateRequest, VRCConfigStateRequestT } from '../../solarxr-protocol/rpc/vrcconfig-state-request.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -145,13 +149,17 @@ export enum RpcMessage { EnableStayAlignedRequest = 68, DetectStayAlignedRelaxedPoseRequest = 69, ResetStayAlignedRelaxedPoseRequest = 70, - SerialTrackerCustomCommandRequest = 71 + SerialTrackerCustomCommandRequest = 71, + VRCConfigSettingToggleMute = 72, + TrackingChecklistRequest = 73, + TrackingChecklistResponse = 74, + IgnoreTrackingChecklistStepRequest = 75 } export function unionToRpcMessage( type: RpcMessage, - accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { + accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -225,15 +233,19 @@ export function unionToRpcMessage( case 'DetectStayAlignedRelaxedPoseRequest': return accessor(new DetectStayAlignedRelaxedPoseRequest())! as DetectStayAlignedRelaxedPoseRequest; case 'ResetStayAlignedRelaxedPoseRequest': return accessor(new ResetStayAlignedRelaxedPoseRequest())! as ResetStayAlignedRelaxedPoseRequest; case 'SerialTrackerCustomCommandRequest': return accessor(new SerialTrackerCustomCommandRequest())! as SerialTrackerCustomCommandRequest; + case 'VRCConfigSettingToggleMute': return accessor(new VRCConfigSettingToggleMute())! as VRCConfigSettingToggleMute; + case 'TrackingChecklistRequest': return accessor(new TrackingChecklistRequest())! as TrackingChecklistRequest; + case 'TrackingChecklistResponse': return accessor(new TrackingChecklistResponse())! as TrackingChecklistResponse; + case 'IgnoreTrackingChecklistStepRequest': return accessor(new IgnoreTrackingChecklistStepRequest())! as IgnoreTrackingChecklistStepRequest; default: return null; } } export function unionListToRpcMessage( type: RpcMessage, - accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, + accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, index: number -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|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|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -307,6 +319,10 @@ export function unionListToRpcMessage( case 'DetectStayAlignedRelaxedPoseRequest': return accessor(index, new DetectStayAlignedRelaxedPoseRequest())! as DetectStayAlignedRelaxedPoseRequest; case 'ResetStayAlignedRelaxedPoseRequest': return accessor(index, new ResetStayAlignedRelaxedPoseRequest())! as ResetStayAlignedRelaxedPoseRequest; case 'SerialTrackerCustomCommandRequest': return accessor(index, new SerialTrackerCustomCommandRequest())! as SerialTrackerCustomCommandRequest; + case 'VRCConfigSettingToggleMute': return accessor(index, new VRCConfigSettingToggleMute())! as VRCConfigSettingToggleMute; + case 'TrackingChecklistRequest': return accessor(index, new TrackingChecklistRequest())! as TrackingChecklistRequest; + case 'TrackingChecklistResponse': return accessor(index, new TrackingChecklistResponse())! as TrackingChecklistResponse; + case 'IgnoreTrackingChecklistStepRequest': return accessor(index, new IgnoreTrackingChecklistStepRequest())! as IgnoreTrackingChecklistStepRequest; default: return null; } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts index 30fbcd85..0c3afe50 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-error.ts @@ -6,7 +6,7 @@ import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker- /** - * Tracker has error state + * Trackers with error state */ export class StatusTrackerError implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; @@ -26,9 +26,14 @@ static getSizePrefixedRootAsStatusTrackerError(bb:flatbuffers.ByteBuffer, obj?:S return (obj || new StatusTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId(index: number, obj?:TrackerId):TrackerId|null { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +trackerIdLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } static startStatusTrackerError(builder:flatbuffers.Builder) { @@ -39,6 +44,18 @@ static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Off builder.addFieldOffset(0, trackerIdOffset, 0); } +static createTrackerIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startTrackerIdVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + static endStatusTrackerError(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -52,24 +69,24 @@ static createStatusTrackerError(builder:flatbuffers.Builder, trackerIdOffset:fla unpack(): StatusTrackerErrorT { return new StatusTrackerErrorT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()) ); } unpackTo(_o: StatusTrackerErrorT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()); } } export class StatusTrackerErrorT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null + public trackerId: (TrackerIdT)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); + const trackerId = StatusTrackerError.createTrackerIdVector(builder, builder.createObjectOffsetList(this.trackerId)); return StatusTrackerError.createStatusTrackerError(builder, trackerId diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts index cbdef20e..72501805 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/status-tracker-reset.ts @@ -26,9 +26,14 @@ static getSizePrefixedRootAsStatusTrackerReset(bb:flatbuffers.ByteBuffer, obj?:S return (obj || new StatusTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -trackerId(obj?:TrackerId):TrackerId|null { +trackerId(index: number, obj?:TrackerId):TrackerId|null { const offset = this.bb!.__offset(this.bb_pos, 4); - return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +trackerIdLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; } static startStatusTrackerReset(builder:flatbuffers.Builder) { @@ -39,6 +44,18 @@ static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Off builder.addFieldOffset(0, trackerIdOffset, 0); } +static createTrackerIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startTrackerIdVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + static endStatusTrackerReset(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -52,24 +69,24 @@ static createStatusTrackerReset(builder:flatbuffers.Builder, trackerIdOffset:fla unpack(): StatusTrackerResetT { return new StatusTrackerResetT( - (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()) ); } unpackTo(_o: StatusTrackerResetT): void { - _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); + _o.trackerId = this.bb!.createObjList(this.trackerId.bind(this), this.trackerIdLength()); } } export class StatusTrackerResetT implements flatbuffers.IGeneratedObject { constructor( - public trackerId: TrackerIdT|null = null + public trackerId: (TrackerIdT)[] = [] ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - const trackerId = (this.trackerId !== null ? this.trackerId!.pack(builder) : 0); + const trackerId = StatusTrackerReset.createTrackerIdVector(builder, builder.createObjectOffsetList(this.trackerId)); return StatusTrackerReset.createStatusTrackerReset(builder, trackerId diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-extra-data.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-extra-data.ts new file mode 100644 index 00000000..7260f7e7 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-extra-data.ts @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import { TrackingChecklistNeedCalibration, TrackingChecklistNeedCalibrationT } from '../../solarxr-protocol/rpc/tracking-checklist-need-calibration.js'; +import { TrackingChecklistPublicNetworks, TrackingChecklistPublicNetworksT } from '../../solarxr-protocol/rpc/tracking-checklist-public-networks.js'; +import { TrackingChecklistSteamVRDisconnected, TrackingChecklistSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.js'; +import { TrackingChecklistTrackerError, TrackingChecklistTrackerErrorT } from '../../solarxr-protocol/rpc/tracking-checklist-tracker-error.js'; +import { TrackingChecklistTrackerReset, TrackingChecklistTrackerResetT } from '../../solarxr-protocol/rpc/tracking-checklist-tracker-reset.js'; +import { TrackingChecklistUnassignedHMD, TrackingChecklistUnassignedHMDT } from '../../solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.js'; + + +export enum TrackingChecklistExtraData { + NONE = 0, + TrackingChecklistTrackerReset = 1, + TrackingChecklistTrackerError = 2, + TrackingChecklistSteamVRDisconnected = 3, + TrackingChecklistUnassignedHMD = 4, + TrackingChecklistNeedCalibration = 5, + TrackingChecklistPublicNetworks = 6 +} + +export function unionToTrackingChecklistExtraData( + type: TrackingChecklistExtraData, + accessor: (obj:TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD) => TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD|null +): TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD|null { + switch(TrackingChecklistExtraData[type]) { + case 'NONE': return null; + case 'TrackingChecklistTrackerReset': return accessor(new TrackingChecklistTrackerReset())! as TrackingChecklistTrackerReset; + case 'TrackingChecklistTrackerError': return accessor(new TrackingChecklistTrackerError())! as TrackingChecklistTrackerError; + case 'TrackingChecklistSteamVRDisconnected': return accessor(new TrackingChecklistSteamVRDisconnected())! as TrackingChecklistSteamVRDisconnected; + case 'TrackingChecklistUnassignedHMD': return accessor(new TrackingChecklistUnassignedHMD())! as TrackingChecklistUnassignedHMD; + case 'TrackingChecklistNeedCalibration': return accessor(new TrackingChecklistNeedCalibration())! as TrackingChecklistNeedCalibration; + case 'TrackingChecklistPublicNetworks': return accessor(new TrackingChecklistPublicNetworks())! as TrackingChecklistPublicNetworks; + default: return null; + } +} + +export function unionListToTrackingChecklistExtraData( + type: TrackingChecklistExtraData, + accessor: (index: number, obj:TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD) => TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD|null, + index: number +): TrackingChecklistNeedCalibration|TrackingChecklistPublicNetworks|TrackingChecklistSteamVRDisconnected|TrackingChecklistTrackerError|TrackingChecklistTrackerReset|TrackingChecklistUnassignedHMD|null { + switch(TrackingChecklistExtraData[type]) { + case 'NONE': return null; + case 'TrackingChecklistTrackerReset': return accessor(index, new TrackingChecklistTrackerReset())! as TrackingChecklistTrackerReset; + case 'TrackingChecklistTrackerError': return accessor(index, new TrackingChecklistTrackerError())! as TrackingChecklistTrackerError; + case 'TrackingChecklistSteamVRDisconnected': return accessor(index, new TrackingChecklistSteamVRDisconnected())! as TrackingChecklistSteamVRDisconnected; + case 'TrackingChecklistUnassignedHMD': return accessor(index, new TrackingChecklistUnassignedHMD())! as TrackingChecklistUnassignedHMD; + case 'TrackingChecklistNeedCalibration': return accessor(index, new TrackingChecklistNeedCalibration())! as TrackingChecklistNeedCalibration; + case 'TrackingChecklistPublicNetworks': return accessor(index, new TrackingChecklistPublicNetworks())! as TrackingChecklistPublicNetworks; + default: return null; + } +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts new file mode 100644 index 00000000..ce890c72 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-need-calibration.ts @@ -0,0 +1,92 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +export class TrackingChecklistNeedCalibration implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistNeedCalibration { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistNeedCalibration(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistNeedCalibration):TrackingChecklistNeedCalibration { + return (obj || new TrackingChecklistNeedCalibration()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistNeedCalibration(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistNeedCalibration):TrackingChecklistNeedCalibration { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistNeedCalibration()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackersId(index: number, obj?:TrackerId):TrackerId|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +trackersIdLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startTrackingChecklistNeedCalibration(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackersIdOffset, 0); +} + +static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endTrackingChecklistNeedCalibration(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistNeedCalibration(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistNeedCalibration.startTrackingChecklistNeedCalibration(builder); + TrackingChecklistNeedCalibration.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistNeedCalibration.endTrackingChecklistNeedCalibration(builder); +} + +unpack(): TrackingChecklistNeedCalibrationT { + return new TrackingChecklistNeedCalibrationT( + this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + ); +} + + +unpackTo(_o: TrackingChecklistNeedCalibrationT): void { + _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); +} +} + +export class TrackingChecklistNeedCalibrationT implements flatbuffers.IGeneratedObject { +constructor( + public trackersId: (TrackerIdT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackersId = TrackingChecklistNeedCalibration.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + + return TrackingChecklistNeedCalibration.createTrackingChecklistNeedCalibration(builder, + trackersId + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-public-networks.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-public-networks.ts new file mode 100644 index 00000000..10d7c9e3 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-public-networks.ts @@ -0,0 +1,93 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class TrackingChecklistPublicNetworks implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistPublicNetworks { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistPublicNetworks(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistPublicNetworks):TrackingChecklistPublicNetworks { + return (obj || new TrackingChecklistPublicNetworks()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistPublicNetworks(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistPublicNetworks):TrackingChecklistPublicNetworks { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistPublicNetworks()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +adapters(index: number):string +adapters(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array +adapters(index: number,optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +} + +adaptersLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startTrackingChecklistPublicNetworks(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addAdapters(builder:flatbuffers.Builder, adaptersOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, adaptersOffset, 0); +} + +static createAdaptersVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startAdaptersVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endTrackingChecklistPublicNetworks(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistPublicNetworks(builder:flatbuffers.Builder, adaptersOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistPublicNetworks.startTrackingChecklistPublicNetworks(builder); + TrackingChecklistPublicNetworks.addAdapters(builder, adaptersOffset); + return TrackingChecklistPublicNetworks.endTrackingChecklistPublicNetworks(builder); +} + +unpack(): TrackingChecklistPublicNetworksT { + return new TrackingChecklistPublicNetworksT( + this.bb!.createScalarList(this.adapters.bind(this), this.adaptersLength()) + ); +} + + +unpackTo(_o: TrackingChecklistPublicNetworksT): void { + _o.adapters = this.bb!.createScalarList(this.adapters.bind(this), this.adaptersLength()); +} +} + +export class TrackingChecklistPublicNetworksT implements flatbuffers.IGeneratedObject { +constructor( + public adapters: (string)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const adapters = TrackingChecklistPublicNetworks.createAdaptersVector(builder, builder.createObjectOffsetList(this.adapters)); + + return TrackingChecklistPublicNetworks.createTrackingChecklistPublicNetworks(builder, + adapters + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-request.ts new file mode 100644 index 00000000..0524d9de --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class TrackingChecklistRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistRequest(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistRequest):TrackingChecklistRequest { + return (obj || new TrackingChecklistRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistRequest(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistRequest):TrackingChecklistRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startTrackingChecklistRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endTrackingChecklistRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + TrackingChecklistRequest.startTrackingChecklistRequest(builder); + return TrackingChecklistRequest.endTrackingChecklistRequest(builder); +} + +unpack(): TrackingChecklistRequestT { + return new TrackingChecklistRequestT(); +} + + +unpackTo(_o: TrackingChecklistRequestT): void {} +} + +export class TrackingChecklistRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return TrackingChecklistRequest.createTrackingChecklistRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-response.ts new file mode 100644 index 00000000..302818bf --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-response.ts @@ -0,0 +1,130 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackingChecklistStep, TrackingChecklistStepT } from '../../solarxr-protocol/rpc/tracking-checklist-step.js'; +import { TrackingChecklistStepId } from '../../solarxr-protocol/rpc/tracking-checklist-step-id.js'; + + +export class TrackingChecklistResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistResponse(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistResponse):TrackingChecklistResponse { + return (obj || new TrackingChecklistResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistResponse(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistResponse):TrackingChecklistResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +steps(index: number, obj?:TrackingChecklistStep):TrackingChecklistStep|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new TrackingChecklistStep()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +stepsLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +ignoredSteps(index: number):TrackingChecklistStepId|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +ignoredStepsLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +ignoredStepsArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +static startTrackingChecklistResponse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addSteps(builder:flatbuffers.Builder, stepsOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, stepsOffset, 0); +} + +static createStepsVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startStepsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static addIgnoredSteps(builder:flatbuffers.Builder, ignoredStepsOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, ignoredStepsOffset, 0); +} + +static createIgnoredStepsVector(builder:flatbuffers.Builder, data:TrackingChecklistStepId[]):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startIgnoredStepsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static endTrackingChecklistResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistResponse(builder:flatbuffers.Builder, stepsOffset:flatbuffers.Offset, ignoredStepsOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistResponse.startTrackingChecklistResponse(builder); + TrackingChecklistResponse.addSteps(builder, stepsOffset); + TrackingChecklistResponse.addIgnoredSteps(builder, ignoredStepsOffset); + return TrackingChecklistResponse.endTrackingChecklistResponse(builder); +} + +unpack(): TrackingChecklistResponseT { + return new TrackingChecklistResponseT( + this.bb!.createObjList(this.steps.bind(this), this.stepsLength()), + this.bb!.createScalarList(this.ignoredSteps.bind(this), this.ignoredStepsLength()) + ); +} + + +unpackTo(_o: TrackingChecklistResponseT): void { + _o.steps = this.bb!.createObjList(this.steps.bind(this), this.stepsLength()); + _o.ignoredSteps = this.bb!.createScalarList(this.ignoredSteps.bind(this), this.ignoredStepsLength()); +} +} + +export class TrackingChecklistResponseT implements flatbuffers.IGeneratedObject { +constructor( + public steps: (TrackingChecklistStepT)[] = [], + public ignoredSteps: (TrackingChecklistStepId)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const steps = TrackingChecklistResponse.createStepsVector(builder, builder.createObjectOffsetList(this.steps)); + const ignoredSteps = TrackingChecklistResponse.createIgnoredStepsVector(builder, this.ignoredSteps); + + return TrackingChecklistResponse.createTrackingChecklistResponse(builder, + steps, + ignoredSteps + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.ts new file mode 100644 index 00000000..7dc12f65 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.ts @@ -0,0 +1,79 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class TrackingChecklistSteamVRDisconnected implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistSteamVRDisconnected { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistSteamVRDisconnected(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistSteamVRDisconnected):TrackingChecklistSteamVRDisconnected { + return (obj || new TrackingChecklistSteamVRDisconnected()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistSteamVRDisconnected(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistSteamVRDisconnected):TrackingChecklistSteamVRDisconnected { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistSteamVRDisconnected()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +/** + * Name of bridge in the server's config + */ +bridgeSettingsName():string|null +bridgeSettingsName(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +bridgeSettingsName(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startTrackingChecklistSteamVRDisconnected(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addBridgeSettingsName(builder:flatbuffers.Builder, bridgeSettingsNameOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, bridgeSettingsNameOffset, 0); +} + +static endTrackingChecklistSteamVRDisconnected(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistSteamVRDisconnected(builder:flatbuffers.Builder, bridgeSettingsNameOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistSteamVRDisconnected.startTrackingChecklistSteamVRDisconnected(builder); + TrackingChecklistSteamVRDisconnected.addBridgeSettingsName(builder, bridgeSettingsNameOffset); + return TrackingChecklistSteamVRDisconnected.endTrackingChecklistSteamVRDisconnected(builder); +} + +unpack(): TrackingChecklistSteamVRDisconnectedT { + return new TrackingChecklistSteamVRDisconnectedT( + this.bridgeSettingsName() + ); +} + + +unpackTo(_o: TrackingChecklistSteamVRDisconnectedT): void { + _o.bridgeSettingsName = this.bridgeSettingsName(); +} +} + +export class TrackingChecklistSteamVRDisconnectedT implements flatbuffers.IGeneratedObject { +constructor( + public bridgeSettingsName: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const bridgeSettingsName = (this.bridgeSettingsName !== null ? builder.createString(this.bridgeSettingsName!) : 0); + + return TrackingChecklistSteamVRDisconnected.createTrackingChecklistSteamVRDisconnected(builder, + bridgeSettingsName + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-id.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-id.ts new file mode 100644 index 00000000..fb1bd28e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-id.ts @@ -0,0 +1,15 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum TrackingChecklistStepId { + UNKNOWN = 0, + TRACKERS_REST_CALIBRATION = 1, + FULL_RESET = 2, + VRCHAT_SETTINGS = 3, + STEAMVR_DISCONNECTED = 4, + UNASSIGNED_HMD = 5, + TRACKER_ERROR = 6, + NETWORK_PROFILE_PUBLIC = 7, + MOUNTING_CALIBRATION = 8, + FEET_MOUNTING_CALIBRATION = 9, + STAY_ALIGNED_CONFIGURED = 10 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-visibility.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-visibility.ts new file mode 100644 index 00000000..306927b2 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step-visibility.ts @@ -0,0 +1,6 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum TrackingChecklistStepVisibility { + ALWAYS = 0, + WHEN_INVALID = 1 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step.ts new file mode 100644 index 00000000..d8060b0d --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-step.ts @@ -0,0 +1,189 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackingChecklistExtraData, unionToTrackingChecklistExtraData, unionListToTrackingChecklistExtraData } from '../../solarxr-protocol/rpc/tracking-checklist-extra-data.js'; +import { TrackingChecklistNeedCalibration, TrackingChecklistNeedCalibrationT } from '../../solarxr-protocol/rpc/tracking-checklist-need-calibration.js'; +import { TrackingChecklistPublicNetworks, TrackingChecklistPublicNetworksT } from '../../solarxr-protocol/rpc/tracking-checklist-public-networks.js'; +import { TrackingChecklistSteamVRDisconnected, TrackingChecklistSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/tracking-checklist-steam-vrdisconnected.js'; +import { TrackingChecklistStepId } from '../../solarxr-protocol/rpc/tracking-checklist-step-id.js'; +import { TrackingChecklistStepVisibility } from '../../solarxr-protocol/rpc/tracking-checklist-step-visibility.js'; +import { TrackingChecklistTrackerError, TrackingChecklistTrackerErrorT } from '../../solarxr-protocol/rpc/tracking-checklist-tracker-error.js'; +import { TrackingChecklistTrackerReset, TrackingChecklistTrackerResetT } from '../../solarxr-protocol/rpc/tracking-checklist-tracker-reset.js'; +import { TrackingChecklistUnassignedHMD, TrackingChecklistUnassignedHMDT } from '../../solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.js'; + + +export class TrackingChecklistStep implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistStep { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistStep(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistStep):TrackingChecklistStep { + return (obj || new TrackingChecklistStep()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistStep(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistStep):TrackingChecklistStep { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistStep()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +id():TrackingChecklistStepId { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackingChecklistStepId.UNKNOWN; +} + +valid():boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +enabled():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +visibility():TrackingChecklistStepVisibility { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackingChecklistStepVisibility.ALWAYS; +} + +optional():boolean { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +ignorable():boolean { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +extraDataType():TrackingChecklistExtraData { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : TrackingChecklistExtraData.NONE; +} + +extraData(obj:any):any|null { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null; +} + +static startTrackingChecklistStep(builder:flatbuffers.Builder) { + builder.startObject(8); +} + +static addId(builder:flatbuffers.Builder, id:TrackingChecklistStepId) { + builder.addFieldInt8(0, id, TrackingChecklistStepId.UNKNOWN); +} + +static addValid(builder:flatbuffers.Builder, valid:boolean) { + builder.addFieldInt8(1, +valid, +false); +} + +static addEnabled(builder:flatbuffers.Builder, enabled:boolean) { + builder.addFieldInt8(2, +enabled, +false); +} + +static addVisibility(builder:flatbuffers.Builder, visibility:TrackingChecklistStepVisibility) { + builder.addFieldInt8(3, visibility, TrackingChecklistStepVisibility.ALWAYS); +} + +static addOptional(builder:flatbuffers.Builder, optional:boolean) { + builder.addFieldInt8(4, +optional, +false); +} + +static addIgnorable(builder:flatbuffers.Builder, ignorable:boolean) { + builder.addFieldInt8(5, +ignorable, +false); +} + +static addExtraDataType(builder:flatbuffers.Builder, extraDataType:TrackingChecklistExtraData) { + builder.addFieldInt8(6, extraDataType, TrackingChecklistExtraData.NONE); +} + +static addExtraData(builder:flatbuffers.Builder, extraDataOffset:flatbuffers.Offset) { + builder.addFieldOffset(7, extraDataOffset, 0); +} + +static endTrackingChecklistStep(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistStep(builder:flatbuffers.Builder, id:TrackingChecklistStepId, valid:boolean, enabled:boolean, visibility:TrackingChecklistStepVisibility, optional:boolean, ignorable:boolean, extraDataType:TrackingChecklistExtraData, extraDataOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistStep.startTrackingChecklistStep(builder); + TrackingChecklistStep.addId(builder, id); + TrackingChecklistStep.addValid(builder, valid); + TrackingChecklistStep.addEnabled(builder, enabled); + TrackingChecklistStep.addVisibility(builder, visibility); + TrackingChecklistStep.addOptional(builder, optional); + TrackingChecklistStep.addIgnorable(builder, ignorable); + TrackingChecklistStep.addExtraDataType(builder, extraDataType); + TrackingChecklistStep.addExtraData(builder, extraDataOffset); + return TrackingChecklistStep.endTrackingChecklistStep(builder); +} + +unpack(): TrackingChecklistStepT { + return new TrackingChecklistStepT( + this.id(), + this.valid(), + this.enabled(), + this.visibility(), + this.optional(), + this.ignorable(), + this.extraDataType(), + (() => { + const temp = unionToTrackingChecklistExtraData(this.extraDataType(), this.extraData.bind(this)); + if(temp === null) { return null; } + return temp.unpack() + })() + ); +} + + +unpackTo(_o: TrackingChecklistStepT): void { + _o.id = this.id(); + _o.valid = this.valid(); + _o.enabled = this.enabled(); + _o.visibility = this.visibility(); + _o.optional = this.optional(); + _o.ignorable = this.ignorable(); + _o.extraDataType = this.extraDataType(); + _o.extraData = (() => { + const temp = unionToTrackingChecklistExtraData(this.extraDataType(), this.extraData.bind(this)); + if(temp === null) { return null; } + return temp.unpack() + })(); +} +} + +export class TrackingChecklistStepT implements flatbuffers.IGeneratedObject { +constructor( + public id: TrackingChecklistStepId = TrackingChecklistStepId.UNKNOWN, + public valid: boolean = false, + public enabled: boolean = false, + public visibility: TrackingChecklistStepVisibility = TrackingChecklistStepVisibility.ALWAYS, + public optional: boolean = false, + public ignorable: boolean = false, + public extraDataType: TrackingChecklistExtraData = TrackingChecklistExtraData.NONE, + public extraData: TrackingChecklistNeedCalibrationT|TrackingChecklistPublicNetworksT|TrackingChecklistSteamVRDisconnectedT|TrackingChecklistTrackerErrorT|TrackingChecklistTrackerResetT|TrackingChecklistUnassignedHMDT|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const extraData = builder.createObjectOffset(this.extraData); + + return TrackingChecklistStep.createTrackingChecklistStep(builder, + this.id, + this.valid, + this.enabled, + this.visibility, + this.optional, + this.ignorable, + this.extraDataType, + extraData + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts new file mode 100644 index 00000000..1a2f049c --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-error.ts @@ -0,0 +1,95 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +/** + * Trackers with error state + */ +export class TrackingChecklistTrackerError implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistTrackerError { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistTrackerError(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistTrackerError):TrackingChecklistTrackerError { + return (obj || new TrackingChecklistTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistTrackerError(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistTrackerError):TrackingChecklistTrackerError { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistTrackerError()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackersId(index: number, obj?:TrackerId):TrackerId|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +trackersIdLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startTrackingChecklistTrackerError(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackersIdOffset, 0); +} + +static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endTrackingChecklistTrackerError(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistTrackerError(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistTrackerError.startTrackingChecklistTrackerError(builder); + TrackingChecklistTrackerError.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistTrackerError.endTrackingChecklistTrackerError(builder); +} + +unpack(): TrackingChecklistTrackerErrorT { + return new TrackingChecklistTrackerErrorT( + this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + ); +} + + +unpackTo(_o: TrackingChecklistTrackerErrorT): void { + _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); +} +} + +export class TrackingChecklistTrackerErrorT implements flatbuffers.IGeneratedObject { +constructor( + public trackersId: (TrackerIdT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackersId = TrackingChecklistTrackerError.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + + return TrackingChecklistTrackerError.createTrackingChecklistTrackerError(builder, + trackersId + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts new file mode 100644 index 00000000..1b0143b3 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-tracker-reset.ts @@ -0,0 +1,95 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +/** + * Trackers that need a reset + */ +export class TrackingChecklistTrackerReset implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistTrackerReset { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistTrackerReset(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistTrackerReset):TrackingChecklistTrackerReset { + return (obj || new TrackingChecklistTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistTrackerReset(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistTrackerReset):TrackingChecklistTrackerReset { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistTrackerReset()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackersId(index: number, obj?:TrackerId):TrackerId|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +trackersIdLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startTrackingChecklistTrackerReset(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackersId(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackersIdOffset, 0); +} + +static createTrackersIdVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startTrackersIdVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endTrackingChecklistTrackerReset(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistTrackerReset(builder:flatbuffers.Builder, trackersIdOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistTrackerReset.startTrackingChecklistTrackerReset(builder); + TrackingChecklistTrackerReset.addTrackersId(builder, trackersIdOffset); + return TrackingChecklistTrackerReset.endTrackingChecklistTrackerReset(builder); +} + +unpack(): TrackingChecklistTrackerResetT { + return new TrackingChecklistTrackerResetT( + this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()) + ); +} + + +unpackTo(_o: TrackingChecklistTrackerResetT): void { + _o.trackersId = this.bb!.createObjList(this.trackersId.bind(this), this.trackersIdLength()); +} +} + +export class TrackingChecklistTrackerResetT implements flatbuffers.IGeneratedObject { +constructor( + public trackersId: (TrackerIdT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const trackersId = TrackingChecklistTrackerReset.createTrackersIdVector(builder, builder.createObjectOffsetList(this.trackersId)); + + return TrackingChecklistTrackerReset.createTrackingChecklistTrackerReset(builder, + trackersId + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts new file mode 100644 index 00000000..2b521833 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/tracking-checklist-unassigned-hmd.ts @@ -0,0 +1,75 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { TrackerId, TrackerIdT } from '../../solarxr-protocol/datatypes/tracker-id.js'; + + +export class TrackingChecklistUnassignedHMD implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):TrackingChecklistUnassignedHMD { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsTrackingChecklistUnassignedHMD(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistUnassignedHMD):TrackingChecklistUnassignedHMD { + return (obj || new TrackingChecklistUnassignedHMD()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsTrackingChecklistUnassignedHMD(bb:flatbuffers.ByteBuffer, obj?:TrackingChecklistUnassignedHMD):TrackingChecklistUnassignedHMD { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new TrackingChecklistUnassignedHMD()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +trackerId(obj?:TrackerId):TrackerId|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new TrackerId()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +static startTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addTrackerId(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, trackerIdOffset, 0); +} + +static endTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createTrackingChecklistUnassignedHMD(builder:flatbuffers.Builder, trackerIdOffset:flatbuffers.Offset):flatbuffers.Offset { + TrackingChecklistUnassignedHMD.startTrackingChecklistUnassignedHMD(builder); + TrackingChecklistUnassignedHMD.addTrackerId(builder, trackerIdOffset); + return TrackingChecklistUnassignedHMD.endTrackingChecklistUnassignedHMD(builder); +} + +unpack(): TrackingChecklistUnassignedHMDT { + return new TrackingChecklistUnassignedHMDT( + (this.trackerId() !== null ? this.trackerId()!.unpack() : null) + ); +} + + +unpackTo(_o: TrackingChecklistUnassignedHMDT): void { + _o.trackerId = (this.trackerId() !== null ? this.trackerId()!.unpack() : null); +} +} + +export class TrackingChecklistUnassignedHMDT 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 TrackingChecklistUnassignedHMD.createTrackingChecklistUnassignedHMD(builder, + trackerId + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts new file mode 100644 index 00000000..f86256d8 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.ts @@ -0,0 +1,76 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class VRCConfigSettingToggleMute implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VRCConfigSettingToggleMute { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVRCConfigSettingToggleMute(bb:flatbuffers.ByteBuffer, obj?:VRCConfigSettingToggleMute):VRCConfigSettingToggleMute { + return (obj || new VRCConfigSettingToggleMute()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVRCConfigSettingToggleMute(bb:flatbuffers.ByteBuffer, obj?:VRCConfigSettingToggleMute):VRCConfigSettingToggleMute { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VRCConfigSettingToggleMute()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +key():string|null +key(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +key(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startVRCConfigSettingToggleMute(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addKey(builder:flatbuffers.Builder, keyOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, keyOffset, 0); +} + +static endVRCConfigSettingToggleMute(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createVRCConfigSettingToggleMute(builder:flatbuffers.Builder, keyOffset:flatbuffers.Offset):flatbuffers.Offset { + VRCConfigSettingToggleMute.startVRCConfigSettingToggleMute(builder); + VRCConfigSettingToggleMute.addKey(builder, keyOffset); + return VRCConfigSettingToggleMute.endVRCConfigSettingToggleMute(builder); +} + +unpack(): VRCConfigSettingToggleMuteT { + return new VRCConfigSettingToggleMuteT( + this.key() + ); +} + + +unpackTo(_o: VRCConfigSettingToggleMuteT): void { + _o.key = this.key(); +} +} + +export class VRCConfigSettingToggleMuteT implements flatbuffers.IGeneratedObject { +constructor( + public key: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const key = (this.key !== null ? builder.createString(this.key!) : 0); + + return VRCConfigSettingToggleMute.createVRCConfigSettingToggleMute(builder, + key + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts index 18c167ea..4ecfa335 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/vrcconfig-state-change-response.ts @@ -49,8 +49,20 @@ recommended(obj?:VRCConfigRecommendedValues):VRCConfigRecommendedValues|null { return offset ? (obj || new VRCConfigRecommendedValues()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; } +muted(index: number):string +muted(index: number,optionalEncoding:flatbuffers.Encoding):string|Uint8Array +muted(index: number,optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.__string(this.bb!.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null; +} + +mutedLength():number { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + static startVRCConfigStateChangeResponse(builder:flatbuffers.Builder) { - builder.startObject(4); + builder.startObject(5); } static addIsSupported(builder:flatbuffers.Builder, isSupported:boolean) { @@ -69,6 +81,22 @@ static addRecommended(builder:flatbuffers.Builder, recommendedOffset:flatbuffers builder.addFieldOffset(3, recommendedOffset, 0); } +static addMuted(builder:flatbuffers.Builder, mutedOffset:flatbuffers.Offset) { + builder.addFieldOffset(4, mutedOffset, 0); +} + +static createMutedVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startMutedVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + static endVRCConfigStateChangeResponse(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; @@ -80,7 +108,8 @@ unpack(): VRCConfigStateChangeResponseT { this.isSupported(), (this.validity() !== null ? this.validity()!.unpack() : null), (this.state() !== null ? this.state()!.unpack() : null), - (this.recommended() !== null ? this.recommended()!.unpack() : null) + (this.recommended() !== null ? this.recommended()!.unpack() : null), + this.bb!.createScalarList(this.muted.bind(this), this.mutedLength()) ); } @@ -90,6 +119,7 @@ unpackTo(_o: VRCConfigStateChangeResponseT): void { _o.validity = (this.validity() !== null ? this.validity()!.unpack() : null); _o.state = (this.state() !== null ? this.state()!.unpack() : null); _o.recommended = (this.recommended() !== null ? this.recommended()!.unpack() : null); + _o.muted = this.bb!.createScalarList(this.muted.bind(this), this.mutedLength()); } } @@ -98,7 +128,8 @@ constructor( public isSupported: boolean = false, public validity: VRCConfigValidityT|null = null, public state: VRCConfigValuesT|null = null, - public recommended: VRCConfigRecommendedValuesT|null = null + public recommended: VRCConfigRecommendedValuesT|null = null, + public muted: (string)[] = [] ){} @@ -106,12 +137,14 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset { const validity = (this.validity !== null ? this.validity!.pack(builder) : 0); const state = (this.state !== null ? this.state!.pack(builder) : 0); const recommended = (this.recommended !== null ? this.recommended!.pack(builder) : 0); + const muted = VRCConfigStateChangeResponse.createMutedVector(builder, builder.createObjectOffsetList(this.muted)); VRCConfigStateChangeResponse.startVRCConfigStateChangeResponse(builder); VRCConfigStateChangeResponse.addIsSupported(builder, this.isSupported); VRCConfigStateChangeResponse.addValidity(builder, validity); VRCConfigStateChangeResponse.addState(builder, state); VRCConfigStateChangeResponse.addRecommended(builder, recommended); + VRCConfigStateChangeResponse.addMuted(builder, muted); return VRCConfigStateChangeResponse.endVRCConfigStateChangeResponse(builder); } diff --git a/schema/data_feed/data_feed.fbs b/schema/data_feed/data_feed.fbs index 0b241545..949fac49 100644 --- a/schema/data_feed/data_feed.fbs +++ b/schema/data_feed/data_feed.fbs @@ -28,6 +28,7 @@ include "tracker.fbs"; include "device_data.fbs"; include "bone.fbs"; include "stay_aligned.fbs"; +include "server.fbs"; namespace solarxr_protocol.data_feed; @@ -84,6 +85,8 @@ table DataFeedUpdate { // gives the index of the datafeed config that initiated the update index: uint8; + + server_guards: solarxr_protocol.data_feed.server.ServerGuards; } @@ -97,4 +100,5 @@ table DataFeedConfig { synthetic_trackers_mask: solarxr_protocol.data_feed.tracker.TrackerDataMask; bone_mask: bool; // TODO: decide if we want to make this a vec of `BodyPart` stay_aligned_pose_mask: bool; + server_guards_mask: bool; } diff --git a/schema/data_feed/server.fbs b/schema/data_feed/server.fbs new file mode 100644 index 00000000..9ae90930 --- /dev/null +++ b/schema/data_feed/server.fbs @@ -0,0 +1,12 @@ +namespace solarxr_protocol.data_feed.server; + +// Contains various of flags / guards that inform the gui +// about possible actions or blocked states +// idea is to have one source of truth for all these rules +// that are rn spread accross the gui. We should bring those +// here over time +table ServerGuards { + // Tell the gui if you can do a mounting reset + canDoMounting: bool; + canDoYawReset: bool; +} diff --git a/schema/rpc.fbs b/schema/rpc.fbs index d339f6fe..f2ccd7de 100644 --- a/schema/rpc.fbs +++ b/schema/rpc.fbs @@ -52,9 +52,13 @@ union RpcMessage { LegTweaksTmpClear, TapDetectionSetupNotification, SetPauseTrackingRequest, + // DEPRECATED StatusSystemRequest, + // DEPRECATED StatusSystemResponse, + // DEPRECATED StatusSystemUpdate, + // DEPRECATED StatusSystemFixed, ClearMountingResetRequest, HeightRequest, @@ -83,6 +87,10 @@ union RpcMessage { DetectStayAlignedRelaxedPoseRequest, ResetStayAlignedRelaxedPoseRequest, SerialTrackerCustomCommandRequest, + VRCConfigSettingToggleMute, + TrackingChecklistRequest, + TrackingChecklistResponse, + IgnoreTrackingChecklistStepRequest, } table RpcMessageHeader { @@ -119,6 +127,15 @@ table ResetRequest { table ResetResponse { reset_type: ResetType; status: ResetStatus; + + /// Should return the body parts reseted / being reset + body_parts: [solarxr_protocol.datatypes.BodyPart]; + + /// gives the time in seconds passed since the start of the reset + /// is 0 when status == FINISHED + /// starts at 0 + progress: int; + duration: int; } @@ -561,6 +578,7 @@ table LegTweaksTmpClear { foot_plant: bool = false; } +// DEPRECATED union StatusData { StatusTrackerReset, StatusTrackerError, @@ -569,45 +587,54 @@ union StatusData { StatusPublicNetwork, } +// DEPRECATED /// Tracker requires full reset table StatusTrackerReset { - tracker_id: solarxr_protocol.datatypes.TrackerId; + tracker_id: [solarxr_protocol.datatypes.TrackerId]; } -/// Tracker has error state +// DEPRECATED +/// Trackers with error state table StatusTrackerError { - tracker_id: solarxr_protocol.datatypes.TrackerId; + tracker_id: [solarxr_protocol.datatypes.TrackerId]; } +// DEPRECATED /// SteamVR bridge is disconnected table StatusSteamVRDisconnected { /// Name of bridge in the server's config bridge_settings_name: string; } +// DEPRECATED /// There is an available HMD tracker and it's not assigned to head table StatusUnassignedHMD { tracker_id: solarxr_protocol.datatypes.TrackerId; } +// DEPRECATED /// Request current statuses that we have table StatusSystemRequest {} +// DEPRECATED /// Response containing all current valid statuses table StatusSystemResponse { current_statuses: [StatusMessage]; } +// DEPRECATED /// When a new status appears, it's sent alone table StatusSystemUpdate { new_status: StatusMessage; } +// DEPRECATED /// When an status is fixed and it's removed, it's ID is sent table StatusSystemFixed { fixed_status_id: uint32; } +// DEPRECATED /// When the server detects a public network profile table StatusPublicNetwork { /// names of the adapters set to public @@ -693,7 +720,7 @@ enum FirmwareUpdateStatus: uint8 { /// The server could not authenticate with the MCU ERROR_AUTHENTICATION_FAILED, - /// Could not upload the firmware to the MUC + /// Could not upload the firmware to the MCU ERROR_UPLOAD_FAILED, /// The provision of the tracker failed, usually wifi credentials @@ -886,8 +913,109 @@ table VRCConfigStateChangeResponse { validity: VRCConfigValidity; state: VRCConfigValues; recommended: VRCConfigRecommendedValues; + // Just a list of keys from the VRCConfigValidity table. + // didnt want to make it a full table, because it would be another pain to maintain. Strings are fine for that. + // copium + muted: [string]; } +// Mute or unmute a vrc setting warning from its key +table VRCConfigSettingToggleMute { + // Key from VRCConfigValidity + key: string; +} + + +// ------------- Tracking checklist system ----------------- + +enum TrackingChecklistStepId : uint8 { + UNKNOWN = 0, + TRACKERS_REST_CALIBRATION = 1, + FULL_RESET = 2, + VRCHAT_SETTINGS = 3, + STEAMVR_DISCONNECTED = 4, + UNASSIGNED_HMD = 5, + TRACKER_ERROR = 6, + NETWORK_PROFILE_PUBLIC = 7, + MOUNTING_CALIBRATION = 8, + FEET_MOUNTING_CALIBRATION = 9, + STAY_ALIGNED_CONFIGURED = 10, +} + +enum TrackingChecklistStepVisibility : uint8 { + ALWAYS, + WHEN_INVALID, +} + +/// Trackers that need a reset +table TrackingChecklistTrackerReset { + trackers_id: [solarxr_protocol.datatypes.TrackerId]; +} + +/// Trackers with error state +table TrackingChecklistTrackerError { + trackers_id: [solarxr_protocol.datatypes.TrackerId]; +} + +table TrackingChecklistNeedCalibration { + trackers_id: [solarxr_protocol.datatypes.TrackerId]; +} + +table TrackingChecklistSteamVRDisconnected { + /// Name of bridge in the server's config + bridge_settings_name: string; +} + +table TrackingChecklistUnassignedHMD { + tracker_id: solarxr_protocol.datatypes.TrackerId; +} + +table TrackingChecklistPublicNetworks { + adapters: [string]; +} + +union TrackingChecklistExtraData { + TrackingChecklistTrackerReset, + TrackingChecklistTrackerError, + TrackingChecklistSteamVRDisconnected, + TrackingChecklistUnassignedHMD, + TrackingChecklistNeedCalibration, + TrackingChecklistPublicNetworks +} + +table TrackingChecklistStep { + id: TrackingChecklistStepId; + valid: bool; + // Can hide a step, usefull for step that might not be able to be either be valid or invalid + enabled: bool; + visibility: TrackingChecklistStepVisibility; + // For cases where we dont know for sure if the user should do it or no + // Like start steamvr -> we dont know if they should do it as they might want to use standalone + optional: bool; + // Tell if this step can be put in the ignore list + ignorable: bool; + extra_data: TrackingChecklistExtraData; +} + +table TrackingChecklistRequest {} + +table TrackingChecklistResponse { + // the order of the steps mater + // and steps should be unique + steps: [TrackingChecklistStep]; + // A list of the step ids that will not show up in the ui + // we keep this as a way to re-enable the step from the ui if needed + ignored_steps: [TrackingChecklistStepId]; +} + +// Allows to ignore/unignore check list steps +table IgnoreTrackingChecklistStepRequest { + step_id: TrackingChecklistStepId; + ignore: bool; +} + +// ------------- Stay Aligned ----------------- + table EnableStayAlignedRequest { enable: bool; }