diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index e0ded2e2..4b6ef862 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -488,6 +488,24 @@ struct CancelUserHeightCalibrationBuilder; struct UserHeightRecordingStatusResponse; struct UserHeightRecordingStatusResponseBuilder; +struct ConnectToWebRTCRequest; +struct ConnectToWebRTCRequestBuilder; + +struct ConnectToWebRTCResponse; +struct ConnectToWebRTCResponseBuilder; + +struct StartVideoTrackerCalibrationRequest; +struct StartVideoTrackerCalibrationRequestBuilder; + +struct CancelVideoTrackerCalibrationRequest; +struct CancelVideoTrackerCalibrationRequestBuilder; + +struct VideoTrackerCalibrationCamera; +struct VideoTrackerCalibrationCameraBuilder; + +struct VideoTrackerCalibrationProgressResponse; +struct VideoTrackerCalibrationProgressResponseBuilder; + } // namespace rpc namespace pub_sub { @@ -1374,11 +1392,16 @@ enum class RpcMessage : uint8_t { StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, UserHeightRecordingStatusResponse = 78, + ConnectToWebRTCRequest = 79, + ConnectToWebRTCResponse = 80, + StartVideoTrackerCalibrationRequest = 81, + CancelVideoTrackerCalibrationRequest = 82, + VideoTrackerCalibrationProgressResponse = 83, MIN = NONE, - MAX = UserHeightRecordingStatusResponse + MAX = VideoTrackerCalibrationProgressResponse }; -inline const RpcMessage (&EnumValuesRpcMessage())[79] { +inline const RpcMessage (&EnumValuesRpcMessage())[84] { static const RpcMessage values[] = { RpcMessage::NONE, RpcMessage::HeartbeatRequest, @@ -1458,13 +1481,18 @@ inline const RpcMessage (&EnumValuesRpcMessage())[79] { RpcMessage::IgnoreTrackingChecklistStepRequest, RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, - RpcMessage::UserHeightRecordingStatusResponse + RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::ConnectToWebRTCRequest, + RpcMessage::ConnectToWebRTCResponse, + RpcMessage::StartVideoTrackerCalibrationRequest, + RpcMessage::CancelVideoTrackerCalibrationRequest, + RpcMessage::VideoTrackerCalibrationProgressResponse }; return values; } inline const char * const *EnumNamesRpcMessage() { - static const char * const names[80] = { + static const char * const names[85] = { "NONE", "HeartbeatRequest", "HeartbeatResponse", @@ -1544,13 +1572,18 @@ inline const char * const *EnumNamesRpcMessage() { "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", + "ConnectToWebRTCRequest", + "ConnectToWebRTCResponse", + "StartVideoTrackerCalibrationRequest", + "CancelVideoTrackerCalibrationRequest", + "VideoTrackerCalibrationProgressResponse", nullptr }; return names; } inline const char *EnumNameRpcMessage(RpcMessage e) { - if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::UserHeightRecordingStatusResponse)) return ""; + if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::VideoTrackerCalibrationProgressResponse)) return ""; const size_t index = static_cast(e); return EnumNamesRpcMessage()[index]; } @@ -1871,6 +1904,26 @@ template<> struct RpcMessageTraits struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ConnectToWebRTCRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ConnectToWebRTCResponse; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::StartVideoTrackerCalibrationRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::CancelVideoTrackerCalibrationRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::VideoTrackerCalibrationProgressResponse; +}; + bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); @@ -2805,6 +2858,68 @@ inline const char *EnumNameUserHeightCalibrationStatus(UserHeightCalibrationStat return EnumNamesUserHeightCalibrationStatus()[index]; } +enum class WebRTCVideoProvider : uint8_t { + VIDEO_CALIBRATION = 0, + MIN = VIDEO_CALIBRATION, + MAX = VIDEO_CALIBRATION +}; + +inline const WebRTCVideoProvider (&EnumValuesWebRTCVideoProvider())[1] { + static const WebRTCVideoProvider values[] = { + WebRTCVideoProvider::VIDEO_CALIBRATION + }; + return values; +} + +inline const char * const *EnumNamesWebRTCVideoProvider() { + static const char * const names[2] = { + "VIDEO_CALIBRATION", + nullptr + }; + return names; +} + +inline const char *EnumNameWebRTCVideoProvider(WebRTCVideoProvider e) { + if (flatbuffers::IsOutRange(e, WebRTCVideoProvider::VIDEO_CALIBRATION, WebRTCVideoProvider::VIDEO_CALIBRATION)) return ""; + const size_t index = static_cast(e); + return EnumNamesWebRTCVideoProvider()[index]; +} + +enum class VideoTrackerCalibrationStatus : uint8_t { + CALIBRATE_CAMERA = 0, + CAPTURE_FORWARD_POSE = 1, + CAPTURE_BENT_OVER_POSE = 2, + CALIBRATE_TRACKERS = 3, + CALIBRATE_SKELETON_OFFSETS = 4, + DONE = 100, + MIN = CALIBRATE_CAMERA, + MAX = DONE +}; + +inline const VideoTrackerCalibrationStatus (&EnumValuesVideoTrackerCalibrationStatus())[6] { + static const VideoTrackerCalibrationStatus values[] = { + VideoTrackerCalibrationStatus::CALIBRATE_CAMERA, + VideoTrackerCalibrationStatus::CAPTURE_FORWARD_POSE, + VideoTrackerCalibrationStatus::CAPTURE_BENT_OVER_POSE, + VideoTrackerCalibrationStatus::CALIBRATE_TRACKERS, + VideoTrackerCalibrationStatus::CALIBRATE_SKELETON_OFFSETS, + VideoTrackerCalibrationStatus::DONE + }; + return values; +} + +inline const char *EnumNameVideoTrackerCalibrationStatus(VideoTrackerCalibrationStatus e) { + switch (e) { + case VideoTrackerCalibrationStatus::CALIBRATE_CAMERA: return "CALIBRATE_CAMERA"; + case VideoTrackerCalibrationStatus::CAPTURE_FORWARD_POSE: return "CAPTURE_FORWARD_POSE"; + case VideoTrackerCalibrationStatus::CAPTURE_BENT_OVER_POSE: return "CAPTURE_BENT_OVER_POSE"; + case VideoTrackerCalibrationStatus::CALIBRATE_TRACKERS: return "CALIBRATE_TRACKERS"; + case VideoTrackerCalibrationStatus::CALIBRATE_SKELETON_OFFSETS: return "CALIBRATE_SKELETON_OFFSETS"; + case VideoTrackerCalibrationStatus::DONE: return "DONE"; + default: return ""; + } +} + } // namespace rpc namespace pub_sub { @@ -6063,6 +6178,21 @@ struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *message_as_UserHeightRecordingStatusResponse() const { return message_type() == solarxr_protocol::rpc::RpcMessage::UserHeightRecordingStatusResponse ? static_cast(message()) : nullptr; } + const solarxr_protocol::rpc::ConnectToWebRTCRequest *message_as_ConnectToWebRTCRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ConnectToWebRTCRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ConnectToWebRTCResponse *message_as_ConnectToWebRTCResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ConnectToWebRTCResponse ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::StartVideoTrackerCalibrationRequest *message_as_StartVideoTrackerCalibrationRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::StartVideoTrackerCalibrationRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::CancelVideoTrackerCalibrationRequest *message_as_CancelVideoTrackerCalibrationRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::CancelVideoTrackerCalibrationRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::VideoTrackerCalibrationProgressResponse *message_as_VideoTrackerCalibrationProgressResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::VideoTrackerCalibrationProgressResponse ? static_cast(message()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TX_ID, 4) && @@ -6385,6 +6515,26 @@ template<> inline const solarxr_protocol::rpc::UserHeightRecordingStatusResponse return message_as_UserHeightRecordingStatusResponse(); } +template<> inline const solarxr_protocol::rpc::ConnectToWebRTCRequest *RpcMessageHeader::message_as() const { + return message_as_ConnectToWebRTCRequest(); +} + +template<> inline const solarxr_protocol::rpc::ConnectToWebRTCResponse *RpcMessageHeader::message_as() const { + return message_as_ConnectToWebRTCResponse(); +} + +template<> inline const solarxr_protocol::rpc::StartVideoTrackerCalibrationRequest *RpcMessageHeader::message_as() const { + return message_as_StartVideoTrackerCalibrationRequest(); +} + +template<> inline const solarxr_protocol::rpc::CancelVideoTrackerCalibrationRequest *RpcMessageHeader::message_as() const { + return message_as_CancelVideoTrackerCalibrationRequest(); +} + +template<> inline const solarxr_protocol::rpc::VideoTrackerCalibrationProgressResponse *RpcMessageHeader::message_as() const { + return message_as_VideoTrackerCalibrationProgressResponse(); +} + struct RpcMessageHeaderBuilder { typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -13417,6 +13567,407 @@ inline flatbuffers::Offset CreateUserHeightRe return builder_.Finish(); } +struct ConnectToWebRTCRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConnectToWebRTCRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PROVIDER = 4, + VT_OFFER_SDP = 6 + }; + solarxr_protocol::rpc::WebRTCVideoProvider provider() const { + return static_cast(GetField(VT_PROVIDER, 0)); + } + const flatbuffers::String *offer_sdp() const { + return GetPointer(VT_OFFER_SDP); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_PROVIDER, 1) && + VerifyOffset(verifier, VT_OFFER_SDP) && + verifier.VerifyString(offer_sdp()) && + verifier.EndTable(); + } +}; + +struct ConnectToWebRTCRequestBuilder { + typedef ConnectToWebRTCRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_provider(solarxr_protocol::rpc::WebRTCVideoProvider provider) { + fbb_.AddElement(ConnectToWebRTCRequest::VT_PROVIDER, static_cast(provider), 0); + } + void add_offer_sdp(flatbuffers::Offset offer_sdp) { + fbb_.AddOffset(ConnectToWebRTCRequest::VT_OFFER_SDP, offer_sdp); + } + explicit ConnectToWebRTCRequestBuilder(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 CreateConnectToWebRTCRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::WebRTCVideoProvider provider = solarxr_protocol::rpc::WebRTCVideoProvider::VIDEO_CALIBRATION, + flatbuffers::Offset offer_sdp = 0) { + ConnectToWebRTCRequestBuilder builder_(_fbb); + builder_.add_offer_sdp(offer_sdp); + builder_.add_provider(provider); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConnectToWebRTCRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::WebRTCVideoProvider provider = solarxr_protocol::rpc::WebRTCVideoProvider::VIDEO_CALIBRATION, + const char *offer_sdp = nullptr) { + auto offer_sdp__ = offer_sdp ? _fbb.CreateString(offer_sdp) : 0; + return solarxr_protocol::rpc::CreateConnectToWebRTCRequest( + _fbb, + provider, + offer_sdp__); +} + +struct ConnectToWebRTCResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConnectToWebRTCResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ANSWER_SDP = 4, + VT_ERROR = 6 + }; + const flatbuffers::String *answer_sdp() const { + return GetPointer(VT_ANSWER_SDP); + } + const flatbuffers::String *error() const { + return GetPointer(VT_ERROR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ANSWER_SDP) && + verifier.VerifyString(answer_sdp()) && + VerifyOffset(verifier, VT_ERROR) && + verifier.VerifyString(error()) && + verifier.EndTable(); + } +}; + +struct ConnectToWebRTCResponseBuilder { + typedef ConnectToWebRTCResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_answer_sdp(flatbuffers::Offset answer_sdp) { + fbb_.AddOffset(ConnectToWebRTCResponse::VT_ANSWER_SDP, answer_sdp); + } + void add_error(flatbuffers::Offset error) { + fbb_.AddOffset(ConnectToWebRTCResponse::VT_ERROR, error); + } + explicit ConnectToWebRTCResponseBuilder(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 CreateConnectToWebRTCResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset answer_sdp = 0, + flatbuffers::Offset error = 0) { + ConnectToWebRTCResponseBuilder builder_(_fbb); + builder_.add_error(error); + builder_.add_answer_sdp(answer_sdp); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConnectToWebRTCResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *answer_sdp = nullptr, + const char *error = nullptr) { + auto answer_sdp__ = answer_sdp ? _fbb.CreateString(answer_sdp) : 0; + auto error__ = error ? _fbb.CreateString(error) : 0; + return solarxr_protocol::rpc::CreateConnectToWebRTCResponse( + _fbb, + answer_sdp__, + error__); +} + +struct StartVideoTrackerCalibrationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StartVideoTrackerCalibrationRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct StartVideoTrackerCalibrationRequestBuilder { + typedef StartVideoTrackerCalibrationRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit StartVideoTrackerCalibrationRequestBuilder(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 CreateStartVideoTrackerCalibrationRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + StartVideoTrackerCalibrationRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct CancelVideoTrackerCalibrationRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CancelVideoTrackerCalibrationRequestBuilder Builder; + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } +}; + +struct CancelVideoTrackerCalibrationRequestBuilder { + typedef CancelVideoTrackerCalibrationRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit CancelVideoTrackerCalibrationRequestBuilder(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 CreateCancelVideoTrackerCalibrationRequest( + flatbuffers::FlatBufferBuilder &_fbb) { + CancelVideoTrackerCalibrationRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +struct VideoTrackerCalibrationCamera FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VideoTrackerCalibrationCameraBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_WORLD_TO_CAMERA = 4, + VT_WORLD_ORIGIN_IN_CAMERA = 6, + VT_FX = 8, + VT_FY = 10, + VT_TX = 12, + VT_TY = 14, + VT_WIDTH = 16, + VT_HEIGHT = 18 + }; + const solarxr_protocol::datatypes::math::Quat *world_to_camera() const { + return GetStruct(VT_WORLD_TO_CAMERA); + } + const solarxr_protocol::datatypes::math::Vec3f *world_origin_in_camera() const { + return GetStruct(VT_WORLD_ORIGIN_IN_CAMERA); + } + float fx() const { + return GetField(VT_FX, 0.0f); + } + float fy() const { + return GetField(VT_FY, 0.0f); + } + float tx() const { + return GetField(VT_TX, 0.0f); + } + float ty() const { + return GetField(VT_TY, 0.0f); + } + int32_t width() const { + return GetField(VT_WIDTH, 0); + } + int32_t height() const { + return GetField(VT_HEIGHT, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_WORLD_TO_CAMERA, 4) && + VerifyField(verifier, VT_WORLD_ORIGIN_IN_CAMERA, 4) && + VerifyField(verifier, VT_FX, 4) && + VerifyField(verifier, VT_FY, 4) && + VerifyField(verifier, VT_TX, 4) && + VerifyField(verifier, VT_TY, 4) && + VerifyField(verifier, VT_WIDTH, 4) && + VerifyField(verifier, VT_HEIGHT, 4) && + verifier.EndTable(); + } +}; + +struct VideoTrackerCalibrationCameraBuilder { + typedef VideoTrackerCalibrationCamera Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_world_to_camera(const solarxr_protocol::datatypes::math::Quat *world_to_camera) { + fbb_.AddStruct(VideoTrackerCalibrationCamera::VT_WORLD_TO_CAMERA, world_to_camera); + } + void add_world_origin_in_camera(const solarxr_protocol::datatypes::math::Vec3f *world_origin_in_camera) { + fbb_.AddStruct(VideoTrackerCalibrationCamera::VT_WORLD_ORIGIN_IN_CAMERA, world_origin_in_camera); + } + void add_fx(float fx) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_FX, fx, 0.0f); + } + void add_fy(float fy) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_FY, fy, 0.0f); + } + void add_tx(float tx) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_TX, tx, 0.0f); + } + void add_ty(float ty) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_TY, ty, 0.0f); + } + void add_width(int32_t width) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_WIDTH, width, 0); + } + void add_height(int32_t height) { + fbb_.AddElement(VideoTrackerCalibrationCamera::VT_HEIGHT, height, 0); + } + explicit VideoTrackerCalibrationCameraBuilder(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 CreateVideoTrackerCalibrationCamera( + flatbuffers::FlatBufferBuilder &_fbb, + const solarxr_protocol::datatypes::math::Quat *world_to_camera = nullptr, + const solarxr_protocol::datatypes::math::Vec3f *world_origin_in_camera = nullptr, + float fx = 0.0f, + float fy = 0.0f, + float tx = 0.0f, + float ty = 0.0f, + int32_t width = 0, + int32_t height = 0) { + VideoTrackerCalibrationCameraBuilder builder_(_fbb); + builder_.add_height(height); + builder_.add_width(width); + builder_.add_ty(ty); + builder_.add_tx(tx); + builder_.add_fy(fy); + builder_.add_fx(fx); + builder_.add_world_origin_in_camera(world_origin_in_camera); + builder_.add_world_to_camera(world_to_camera); + return builder_.Finish(); +} + +struct VideoTrackerCalibrationProgressResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VideoTrackerCalibrationProgressResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_STATUS = 4, + VT_CAMERA = 6, + VT_TRACKERS_DONE = 8, + VT_TRACKERS_PENDING = 10, + VT_ERROR = 12 + }; + solarxr_protocol::rpc::VideoTrackerCalibrationStatus status() const { + return static_cast(GetField(VT_STATUS, 0)); + } + const solarxr_protocol::rpc::VideoTrackerCalibrationCamera *camera() const { + return GetPointer(VT_CAMERA); + } + const flatbuffers::Vector *trackers_done() const { + return GetPointer *>(VT_TRACKERS_DONE); + } + const flatbuffers::Vector *trackers_pending() const { + return GetPointer *>(VT_TRACKERS_PENDING); + } + const flatbuffers::String *error() const { + return GetPointer(VT_ERROR); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_STATUS, 1) && + VerifyOffset(verifier, VT_CAMERA) && + verifier.VerifyTable(camera()) && + VerifyOffset(verifier, VT_TRACKERS_DONE) && + verifier.VerifyVector(trackers_done()) && + VerifyOffset(verifier, VT_TRACKERS_PENDING) && + verifier.VerifyVector(trackers_pending()) && + VerifyOffset(verifier, VT_ERROR) && + verifier.VerifyString(error()) && + verifier.EndTable(); + } +}; + +struct VideoTrackerCalibrationProgressResponseBuilder { + typedef VideoTrackerCalibrationProgressResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_status(solarxr_protocol::rpc::VideoTrackerCalibrationStatus status) { + fbb_.AddElement(VideoTrackerCalibrationProgressResponse::VT_STATUS, static_cast(status), 0); + } + void add_camera(flatbuffers::Offset camera) { + fbb_.AddOffset(VideoTrackerCalibrationProgressResponse::VT_CAMERA, camera); + } + void add_trackers_done(flatbuffers::Offset> trackers_done) { + fbb_.AddOffset(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_DONE, trackers_done); + } + void add_trackers_pending(flatbuffers::Offset> trackers_pending) { + fbb_.AddOffset(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_PENDING, trackers_pending); + } + void add_error(flatbuffers::Offset error) { + fbb_.AddOffset(VideoTrackerCalibrationProgressResponse::VT_ERROR, error); + } + explicit VideoTrackerCalibrationProgressResponseBuilder(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 CreateVideoTrackerCalibrationProgressResponse( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::VideoTrackerCalibrationStatus status = solarxr_protocol::rpc::VideoTrackerCalibrationStatus::CALIBRATE_CAMERA, + flatbuffers::Offset camera = 0, + flatbuffers::Offset> trackers_done = 0, + flatbuffers::Offset> trackers_pending = 0, + flatbuffers::Offset error = 0) { + VideoTrackerCalibrationProgressResponseBuilder builder_(_fbb); + builder_.add_error(error); + builder_.add_trackers_pending(trackers_pending); + builder_.add_trackers_done(trackers_done); + builder_.add_camera(camera); + builder_.add_status(status); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateVideoTrackerCalibrationProgressResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::VideoTrackerCalibrationStatus status = solarxr_protocol::rpc::VideoTrackerCalibrationStatus::CALIBRATE_CAMERA, + flatbuffers::Offset camera = 0, + const std::vector *trackers_done = nullptr, + const std::vector *trackers_pending = nullptr, + const char *error = nullptr) { + auto trackers_done__ = trackers_done ? _fbb.CreateVector(*trackers_done) : 0; + auto trackers_pending__ = trackers_pending ? _fbb.CreateVector(*trackers_pending) : 0; + auto error__ = error ? _fbb.CreateString(error) : 0; + return solarxr_protocol::rpc::CreateVideoTrackerCalibrationProgressResponse( + _fbb, + status, + camera, + trackers_done__, + trackers_pending__, + error__); +} + } // namespace rpc namespace pub_sub { @@ -14462,6 +15013,26 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::ConnectToWebRTCRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ConnectToWebRTCResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::StartVideoTrackerCalibrationRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::CancelVideoTrackerCalibrationRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::VideoTrackerCalibrationProgressResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.java b/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.java new file mode 100644 index 00000000..e869ec98 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.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 CancelVideoTrackerCalibrationRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static CancelVideoTrackerCalibrationRequest getRootAsCancelVideoTrackerCalibrationRequest(ByteBuffer _bb) { return getRootAsCancelVideoTrackerCalibrationRequest(_bb, new CancelVideoTrackerCalibrationRequest()); } + public static CancelVideoTrackerCalibrationRequest getRootAsCancelVideoTrackerCalibrationRequest(ByteBuffer _bb, CancelVideoTrackerCalibrationRequest 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 CancelVideoTrackerCalibrationRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startCancelVideoTrackerCalibrationRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endCancelVideoTrackerCalibrationRequest(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 CancelVideoTrackerCalibrationRequest get(int j) { return get(new CancelVideoTrackerCalibrationRequest(), j); } + public CancelVideoTrackerCalibrationRequest get(CancelVideoTrackerCalibrationRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public CancelVideoTrackerCalibrationRequestT unpack() { + CancelVideoTrackerCalibrationRequestT _o = new CancelVideoTrackerCalibrationRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(CancelVideoTrackerCalibrationRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, CancelVideoTrackerCalibrationRequestT _o) { + if (_o == null) return 0; + startCancelVideoTrackerCalibrationRequest(builder); + return endCancelVideoTrackerCalibrationRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequestT.java b/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequestT.java new file mode 100644 index 00000000..c0975e0c --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequestT.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 CancelVideoTrackerCalibrationRequestT { + + + public CancelVideoTrackerCalibrationRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.java b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.java new file mode 100644 index 00000000..dab6fb11 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.java @@ -0,0 +1,66 @@ +// 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 ConnectToWebRTCRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ConnectToWebRTCRequest getRootAsConnectToWebRTCRequest(ByteBuffer _bb) { return getRootAsConnectToWebRTCRequest(_bb, new ConnectToWebRTCRequest()); } + public static ConnectToWebRTCRequest getRootAsConnectToWebRTCRequest(ByteBuffer _bb, ConnectToWebRTCRequest 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 ConnectToWebRTCRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int provider() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public String offerSdp() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer offerSdpAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer offerSdpInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + + public static int createConnectToWebRTCRequest(FlatBufferBuilder builder, + int provider, + int offerSdpOffset) { + builder.startTable(2); + ConnectToWebRTCRequest.addOfferSdp(builder, offerSdpOffset); + ConnectToWebRTCRequest.addProvider(builder, provider); + return ConnectToWebRTCRequest.endConnectToWebRTCRequest(builder); + } + + public static void startConnectToWebRTCRequest(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addProvider(FlatBufferBuilder builder, int provider) { builder.addByte(0, (byte) provider, (byte) 0); } + public static void addOfferSdp(FlatBufferBuilder builder, int offerSdpOffset) { builder.addOffset(1, offerSdpOffset, 0); } + public static int endConnectToWebRTCRequest(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 ConnectToWebRTCRequest get(int j) { return get(new ConnectToWebRTCRequest(), j); } + public ConnectToWebRTCRequest get(ConnectToWebRTCRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ConnectToWebRTCRequestT unpack() { + ConnectToWebRTCRequestT _o = new ConnectToWebRTCRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ConnectToWebRTCRequestT _o) { + int _oProvider = provider(); + _o.setProvider(_oProvider); + String _oOfferSdp = offerSdp(); + _o.setOfferSdp(_oOfferSdp); + } + public static int pack(FlatBufferBuilder builder, ConnectToWebRTCRequestT _o) { + if (_o == null) return 0; + int _offerSdp = _o.getOfferSdp() == null ? 0 : builder.createString(_o.getOfferSdp()); + return createConnectToWebRTCRequest( + builder, + _o.getProvider(), + _offerSdp); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequestT.java new file mode 100644 index 00000000..847d2942 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCRequestT.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 ConnectToWebRTCRequestT { + private int provider; + private String offerSdp; + + public int getProvider() { return provider; } + + public void setProvider(int provider) { this.provider = provider; } + + public String getOfferSdp() { return offerSdp; } + + public void setOfferSdp(String offerSdp) { this.offerSdp = offerSdp; } + + + public ConnectToWebRTCRequestT() { + this.provider = 0; + this.offerSdp = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.java b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.java new file mode 100644 index 00000000..6a1550e7 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.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 ConnectToWebRTCResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ConnectToWebRTCResponse getRootAsConnectToWebRTCResponse(ByteBuffer _bb) { return getRootAsConnectToWebRTCResponse(_bb, new ConnectToWebRTCResponse()); } + public static ConnectToWebRTCResponse getRootAsConnectToWebRTCResponse(ByteBuffer _bb, ConnectToWebRTCResponse 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 ConnectToWebRTCResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String answerSdp() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer answerSdpAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer answerSdpInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + public String error() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer errorAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer errorInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + + public static int createConnectToWebRTCResponse(FlatBufferBuilder builder, + int answerSdpOffset, + int errorOffset) { + builder.startTable(2); + ConnectToWebRTCResponse.addError(builder, errorOffset); + ConnectToWebRTCResponse.addAnswerSdp(builder, answerSdpOffset); + return ConnectToWebRTCResponse.endConnectToWebRTCResponse(builder); + } + + public static void startConnectToWebRTCResponse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addAnswerSdp(FlatBufferBuilder builder, int answerSdpOffset) { builder.addOffset(0, answerSdpOffset, 0); } + public static void addError(FlatBufferBuilder builder, int errorOffset) { builder.addOffset(1, errorOffset, 0); } + public static int endConnectToWebRTCResponse(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 ConnectToWebRTCResponse get(int j) { return get(new ConnectToWebRTCResponse(), j); } + public ConnectToWebRTCResponse get(ConnectToWebRTCResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ConnectToWebRTCResponseT unpack() { + ConnectToWebRTCResponseT _o = new ConnectToWebRTCResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ConnectToWebRTCResponseT _o) { + String _oAnswerSdp = answerSdp(); + _o.setAnswerSdp(_oAnswerSdp); + String _oError = error(); + _o.setError(_oError); + } + public static int pack(FlatBufferBuilder builder, ConnectToWebRTCResponseT _o) { + if (_o == null) return 0; + int _answerSdp = _o.getAnswerSdp() == null ? 0 : builder.createString(_o.getAnswerSdp()); + int _error = _o.getError() == null ? 0 : builder.createString(_o.getError()); + return createConnectToWebRTCResponse( + builder, + _answerSdp, + _error); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponseT.java b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponseT.java new file mode 100644 index 00000000..348209c9 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ConnectToWebRTCResponseT.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 ConnectToWebRTCResponseT { + private String answerSdp; + private String error; + + public String getAnswerSdp() { return answerSdp; } + + public void setAnswerSdp(String answerSdp) { this.answerSdp = answerSdp; } + + public String getError() { return error; } + + public void setError(String error) { this.error = error; } + + + public ConnectToWebRTCResponseT() { + this.answerSdp = null; + this.error = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index 5435c77b..8c4f7bc0 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -84,8 +84,13 @@ private RpcMessage() { } public static final byte StartUserHeightCalibration = 76; public static final byte CancelUserHeightCalibration = 77; public static final byte UserHeightRecordingStatusResponse = 78; + public static final byte ConnectToWebRTCRequest = 79; + public static final byte ConnectToWebRTCResponse = 80; + public static final byte StartVideoTrackerCalibrationRequest = 81; + public static final byte CancelVideoTrackerCalibrationRequest = 82; + public static final byte VideoTrackerCalibrationProgressResponse = 83; - public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", }; + public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "ConnectToWebRTCRequest", "ConnectToWebRTCResponse", "StartVideoTrackerCalibrationRequest", "CancelVideoTrackerCalibrationRequest", "VideoTrackerCalibrationProgressResponse", }; 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 f8ec9923..238a84c1 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -364,6 +364,26 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.UserHeightRecordingStatusResponse()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UserHeightRecordingStatusResponse) _oMessageValue).unpack() : null); break; + case solarxr_protocol.rpc.RpcMessage.ConnectToWebRTCRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ConnectToWebRTCRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ConnectToWebRTCRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ConnectToWebRTCResponse: + _oMessageValue = message(new solarxr_protocol.rpc.ConnectToWebRTCResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ConnectToWebRTCResponse) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.StartVideoTrackerCalibrationRequest: + _oMessageValue = message(new solarxr_protocol.rpc.StartVideoTrackerCalibrationRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.StartVideoTrackerCalibrationRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.CancelVideoTrackerCalibrationRequest: + _oMessageValue = message(new solarxr_protocol.rpc.CancelVideoTrackerCalibrationRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.CancelVideoTrackerCalibrationRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.VideoTrackerCalibrationProgressResponse: + _oMessageValue = message(new solarxr_protocol.rpc.VideoTrackerCalibrationProgressResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.VideoTrackerCalibrationProgressResponse) _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 0fb9afb4..7e9d3f88 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -99,6 +99,11 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.StartUserHeightCalibrationT asStartUserHeightCalibration() { return (solarxr_protocol.rpc.StartUserHeightCalibrationT) value; } public solarxr_protocol.rpc.CancelUserHeightCalibrationT asCancelUserHeightCalibration() { return (solarxr_protocol.rpc.CancelUserHeightCalibrationT) value; } public solarxr_protocol.rpc.UserHeightRecordingStatusResponseT asUserHeightRecordingStatusResponse() { return (solarxr_protocol.rpc.UserHeightRecordingStatusResponseT) value; } + public solarxr_protocol.rpc.ConnectToWebRTCRequestT asConnectToWebRTCRequest() { return (solarxr_protocol.rpc.ConnectToWebRTCRequestT) value; } + public solarxr_protocol.rpc.ConnectToWebRTCResponseT asConnectToWebRTCResponse() { return (solarxr_protocol.rpc.ConnectToWebRTCResponseT) value; } + public solarxr_protocol.rpc.StartVideoTrackerCalibrationRequestT asStartVideoTrackerCalibrationRequest() { return (solarxr_protocol.rpc.StartVideoTrackerCalibrationRequestT) value; } + public solarxr_protocol.rpc.CancelVideoTrackerCalibrationRequestT asCancelVideoTrackerCalibrationRequest() { return (solarxr_protocol.rpc.CancelVideoTrackerCalibrationRequestT) value; } + public solarxr_protocol.rpc.VideoTrackerCalibrationProgressResponseT asVideoTrackerCalibrationProgressResponse() { return (solarxr_protocol.rpc.VideoTrackerCalibrationProgressResponseT) value; } public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { switch (_o.type) { @@ -180,6 +185,11 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.StartUserHeightCalibration: return solarxr_protocol.rpc.StartUserHeightCalibration.pack(builder, _o.asStartUserHeightCalibration()); case RpcMessage.CancelUserHeightCalibration: return solarxr_protocol.rpc.CancelUserHeightCalibration.pack(builder, _o.asCancelUserHeightCalibration()); case RpcMessage.UserHeightRecordingStatusResponse: return solarxr_protocol.rpc.UserHeightRecordingStatusResponse.pack(builder, _o.asUserHeightRecordingStatusResponse()); + case RpcMessage.ConnectToWebRTCRequest: return solarxr_protocol.rpc.ConnectToWebRTCRequest.pack(builder, _o.asConnectToWebRTCRequest()); + case RpcMessage.ConnectToWebRTCResponse: return solarxr_protocol.rpc.ConnectToWebRTCResponse.pack(builder, _o.asConnectToWebRTCResponse()); + case RpcMessage.StartVideoTrackerCalibrationRequest: return solarxr_protocol.rpc.StartVideoTrackerCalibrationRequest.pack(builder, _o.asStartVideoTrackerCalibrationRequest()); + case RpcMessage.CancelVideoTrackerCalibrationRequest: return solarxr_protocol.rpc.CancelVideoTrackerCalibrationRequest.pack(builder, _o.asCancelVideoTrackerCalibrationRequest()); + case RpcMessage.VideoTrackerCalibrationProgressResponse: return solarxr_protocol.rpc.VideoTrackerCalibrationProgressResponse.pack(builder, _o.asVideoTrackerCalibrationProgressResponse()); default: return 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.java b/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.java new file mode 100644 index 00000000..57881eff --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.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 StartVideoTrackerCalibrationRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static StartVideoTrackerCalibrationRequest getRootAsStartVideoTrackerCalibrationRequest(ByteBuffer _bb) { return getRootAsStartVideoTrackerCalibrationRequest(_bb, new StartVideoTrackerCalibrationRequest()); } + public static StartVideoTrackerCalibrationRequest getRootAsStartVideoTrackerCalibrationRequest(ByteBuffer _bb, StartVideoTrackerCalibrationRequest 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 StartVideoTrackerCalibrationRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + + public static void startStartVideoTrackerCalibrationRequest(FlatBufferBuilder builder) { builder.startTable(0); } + public static int endStartVideoTrackerCalibrationRequest(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 StartVideoTrackerCalibrationRequest get(int j) { return get(new StartVideoTrackerCalibrationRequest(), j); } + public StartVideoTrackerCalibrationRequest get(StartVideoTrackerCalibrationRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public StartVideoTrackerCalibrationRequestT unpack() { + StartVideoTrackerCalibrationRequestT _o = new StartVideoTrackerCalibrationRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(StartVideoTrackerCalibrationRequestT _o) { + } + public static int pack(FlatBufferBuilder builder, StartVideoTrackerCalibrationRequestT _o) { + if (_o == null) return 0; + startStartVideoTrackerCalibrationRequest(builder); + return endStartVideoTrackerCalibrationRequest(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequestT.java b/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequestT.java new file mode 100644 index 00000000..3c0357c1 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequestT.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 StartVideoTrackerCalibrationRequestT { + + + public StartVideoTrackerCalibrationRequestT() { + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.java b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.java new file mode 100644 index 00000000..323f3da2 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.java @@ -0,0 +1,86 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class VideoTrackerCalibrationCamera extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VideoTrackerCalibrationCamera getRootAsVideoTrackerCalibrationCamera(ByteBuffer _bb) { return getRootAsVideoTrackerCalibrationCamera(_bb, new VideoTrackerCalibrationCamera()); } + public static VideoTrackerCalibrationCamera getRootAsVideoTrackerCalibrationCamera(ByteBuffer _bb, VideoTrackerCalibrationCamera 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 VideoTrackerCalibrationCamera __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.datatypes.math.Quat worldToCamera() { return worldToCamera(new solarxr_protocol.datatypes.math.Quat()); } + public solarxr_protocol.datatypes.math.Quat worldToCamera(solarxr_protocol.datatypes.math.Quat obj) { int o = __offset(4); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public solarxr_protocol.datatypes.math.Vec3f worldOriginInCamera() { return worldOriginInCamera(new solarxr_protocol.datatypes.math.Vec3f()); } + public solarxr_protocol.datatypes.math.Vec3f worldOriginInCamera(solarxr_protocol.datatypes.math.Vec3f obj) { int o = __offset(6); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; } + public float fx() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float fy() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float tx() { int o = __offset(12); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public float ty() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public int width() { int o = __offset(16); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public int height() { int o = __offset(18); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + + public static void startVideoTrackerCalibrationCamera(FlatBufferBuilder builder) { builder.startTable(8); } + public static void addWorldToCamera(FlatBufferBuilder builder, int worldToCameraOffset) { builder.addStruct(0, worldToCameraOffset, 0); } + public static void addWorldOriginInCamera(FlatBufferBuilder builder, int worldOriginInCameraOffset) { builder.addStruct(1, worldOriginInCameraOffset, 0); } + public static void addFx(FlatBufferBuilder builder, float fx) { builder.addFloat(2, fx, 0.0f); } + public static void addFy(FlatBufferBuilder builder, float fy) { builder.addFloat(3, fy, 0.0f); } + public static void addTx(FlatBufferBuilder builder, float tx) { builder.addFloat(4, tx, 0.0f); } + public static void addTy(FlatBufferBuilder builder, float ty) { builder.addFloat(5, ty, 0.0f); } + public static void addWidth(FlatBufferBuilder builder, int width) { builder.addInt(6, width, 0); } + public static void addHeight(FlatBufferBuilder builder, int height) { builder.addInt(7, height, 0); } + public static int endVideoTrackerCalibrationCamera(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 VideoTrackerCalibrationCamera get(int j) { return get(new VideoTrackerCalibrationCamera(), j); } + public VideoTrackerCalibrationCamera get(VideoTrackerCalibrationCamera obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VideoTrackerCalibrationCameraT unpack() { + VideoTrackerCalibrationCameraT _o = new VideoTrackerCalibrationCameraT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VideoTrackerCalibrationCameraT _o) { + if (worldToCamera() != null) worldToCamera().unpackTo(_o.getWorldToCamera()); + else _o.setWorldToCamera(null); + if (worldOriginInCamera() != null) worldOriginInCamera().unpackTo(_o.getWorldOriginInCamera()); + else _o.setWorldOriginInCamera(null); + float _oFx = fx(); + _o.setFx(_oFx); + float _oFy = fy(); + _o.setFy(_oFy); + float _oTx = tx(); + _o.setTx(_oTx); + float _oTy = ty(); + _o.setTy(_oTy); + int _oWidth = width(); + _o.setWidth(_oWidth); + int _oHeight = height(); + _o.setHeight(_oHeight); + } + public static int pack(FlatBufferBuilder builder, VideoTrackerCalibrationCameraT _o) { + if (_o == null) return 0; + startVideoTrackerCalibrationCamera(builder); + addWorldToCamera(builder, solarxr_protocol.datatypes.math.Quat.pack(builder, _o.getWorldToCamera())); + addWorldOriginInCamera(builder, solarxr_protocol.datatypes.math.Vec3f.pack(builder, _o.getWorldOriginInCamera())); + addFx(builder, _o.getFx()); + addFy(builder, _o.getFy()); + addTx(builder, _o.getTx()); + addTy(builder, _o.getTy()); + addWidth(builder, _o.getWidth()); + addHeight(builder, _o.getHeight()); + return endVideoTrackerCalibrationCamera(builder); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCameraT.java b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCameraT.java new file mode 100644 index 00000000..1b2480e7 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationCameraT.java @@ -0,0 +1,64 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VideoTrackerCalibrationCameraT { + private solarxr_protocol.datatypes.math.QuatT worldToCamera; + private solarxr_protocol.datatypes.math.Vec3fT worldOriginInCamera; + private float fx; + private float fy; + private float tx; + private float ty; + private int width; + private int height; + + public solarxr_protocol.datatypes.math.QuatT getWorldToCamera() { return worldToCamera; } + + public void setWorldToCamera(solarxr_protocol.datatypes.math.QuatT worldToCamera) { this.worldToCamera = worldToCamera; } + + public solarxr_protocol.datatypes.math.Vec3fT getWorldOriginInCamera() { return worldOriginInCamera; } + + public void setWorldOriginInCamera(solarxr_protocol.datatypes.math.Vec3fT worldOriginInCamera) { this.worldOriginInCamera = worldOriginInCamera; } + + public float getFx() { return fx; } + + public void setFx(float fx) { this.fx = fx; } + + public float getFy() { return fy; } + + public void setFy(float fy) { this.fy = fy; } + + public float getTx() { return tx; } + + public void setTx(float tx) { this.tx = tx; } + + public float getTy() { return ty; } + + public void setTy(float ty) { this.ty = ty; } + + public int getWidth() { return width; } + + public void setWidth(int width) { this.width = width; } + + public int getHeight() { return height; } + + public void setHeight(int height) { this.height = height; } + + + public VideoTrackerCalibrationCameraT() { + this.worldToCamera = new solarxr_protocol.datatypes.math.QuatT(); + this.worldOriginInCamera = new solarxr_protocol.datatypes.math.Vec3fT(); + this.fx = 0.0f; + this.fy = 0.0f; + this.tx = 0.0f; + this.ty = 0.0f; + this.width = 0; + this.height = 0; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.java b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.java new file mode 100644 index 00000000..693a8289 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.java @@ -0,0 +1,121 @@ +// 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 VideoTrackerCalibrationProgressResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static VideoTrackerCalibrationProgressResponse getRootAsVideoTrackerCalibrationProgressResponse(ByteBuffer _bb) { return getRootAsVideoTrackerCalibrationProgressResponse(_bb, new VideoTrackerCalibrationProgressResponse()); } + public static VideoTrackerCalibrationProgressResponse getRootAsVideoTrackerCalibrationProgressResponse(ByteBuffer _bb, VideoTrackerCalibrationProgressResponse 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 VideoTrackerCalibrationProgressResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int status() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public solarxr_protocol.rpc.VideoTrackerCalibrationCamera camera() { return camera(new solarxr_protocol.rpc.VideoTrackerCalibrationCamera()); } + public solarxr_protocol.rpc.VideoTrackerCalibrationCamera camera(solarxr_protocol.rpc.VideoTrackerCalibrationCamera obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; } + public int trackersDone(int j) { int o = __offset(8); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int trackersDoneLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; } + public ByteVector trackersDoneVector() { return trackersDoneVector(new ByteVector()); } + public ByteVector trackersDoneVector(ByteVector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersDoneAsByteBuffer() { return __vector_as_bytebuffer(8, 1); } + public ByteBuffer trackersDoneInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 8, 1); } + public int trackersPending(int j) { int o = __offset(10); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; } + public int trackersPendingLength() { int o = __offset(10); return o != 0 ? __vector_len(o) : 0; } + public ByteVector trackersPendingVector() { return trackersPendingVector(new ByteVector()); } + public ByteVector trackersPendingVector(ByteVector obj) { int o = __offset(10); return o != 0 ? obj.__assign(__vector(o), bb) : null; } + public ByteBuffer trackersPendingAsByteBuffer() { return __vector_as_bytebuffer(10, 1); } + public ByteBuffer trackersPendingInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); } + public String error() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer errorAsByteBuffer() { return __vector_as_bytebuffer(12, 1); } + public ByteBuffer errorInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); } + + public static int createVideoTrackerCalibrationProgressResponse(FlatBufferBuilder builder, + int status, + int cameraOffset, + int trackersDoneOffset, + int trackersPendingOffset, + int errorOffset) { + builder.startTable(5); + VideoTrackerCalibrationProgressResponse.addError(builder, errorOffset); + VideoTrackerCalibrationProgressResponse.addTrackersPending(builder, trackersPendingOffset); + VideoTrackerCalibrationProgressResponse.addTrackersDone(builder, trackersDoneOffset); + VideoTrackerCalibrationProgressResponse.addCamera(builder, cameraOffset); + VideoTrackerCalibrationProgressResponse.addStatus(builder, status); + return VideoTrackerCalibrationProgressResponse.endVideoTrackerCalibrationProgressResponse(builder); + } + + public static void startVideoTrackerCalibrationProgressResponse(FlatBufferBuilder builder) { builder.startTable(5); } + public static void addStatus(FlatBufferBuilder builder, int status) { builder.addByte(0, (byte) status, (byte) 0); } + public static void addCamera(FlatBufferBuilder builder, int cameraOffset) { builder.addOffset(1, cameraOffset, 0); } + public static void addTrackersDone(FlatBufferBuilder builder, int trackersDoneOffset) { builder.addOffset(2, trackersDoneOffset, 0); } + public static int createTrackersDoneVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createTrackersDoneVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startTrackersDoneVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addTrackersPending(FlatBufferBuilder builder, int trackersPendingOffset) { builder.addOffset(3, trackersPendingOffset, 0); } + public static int createTrackersPendingVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); } + public static int createTrackersPendingVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); } + public static void startTrackersPendingVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addError(FlatBufferBuilder builder, int errorOffset) { builder.addOffset(4, errorOffset, 0); } + public static int endVideoTrackerCalibrationProgressResponse(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 VideoTrackerCalibrationProgressResponse get(int j) { return get(new VideoTrackerCalibrationProgressResponse(), j); } + public VideoTrackerCalibrationProgressResponse get(VideoTrackerCalibrationProgressResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public VideoTrackerCalibrationProgressResponseT unpack() { + VideoTrackerCalibrationProgressResponseT _o = new VideoTrackerCalibrationProgressResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(VideoTrackerCalibrationProgressResponseT _o) { + int _oStatus = status(); + _o.setStatus(_oStatus); + if (camera() != null) _o.setCamera(camera().unpack()); + else _o.setCamera(null); + int[] _oTrackersDone = new int[trackersDoneLength()]; + for (int _j = 0; _j < trackersDoneLength(); ++_j) {_oTrackersDone[_j] = trackersDone(_j);} + _o.setTrackersDone(_oTrackersDone); + int[] _oTrackersPending = new int[trackersPendingLength()]; + for (int _j = 0; _j < trackersPendingLength(); ++_j) {_oTrackersPending[_j] = trackersPending(_j);} + _o.setTrackersPending(_oTrackersPending); + String _oError = error(); + _o.setError(_oError); + } + public static int pack(FlatBufferBuilder builder, VideoTrackerCalibrationProgressResponseT _o) { + if (_o == null) return 0; + int _camera = _o.getCamera() == null ? 0 : solarxr_protocol.rpc.VideoTrackerCalibrationCamera.pack(builder, _o.getCamera()); + int _trackersDone = 0; + if (_o.getTrackersDone() != null) { + byte[] __trackersDone = new byte[_o.getTrackersDone().length]; + int _j = 0; + for (int _e : _o.getTrackersDone()) { __trackersDone[_j] = (byte) _e; _j++;} + _trackersDone = createTrackersDoneVector(builder, __trackersDone); + } + int _trackersPending = 0; + if (_o.getTrackersPending() != null) { + byte[] __trackersPending = new byte[_o.getTrackersPending().length]; + int _j = 0; + for (int _e : _o.getTrackersPending()) { __trackersPending[_j] = (byte) _e; _j++;} + _trackersPending = createTrackersPendingVector(builder, __trackersPending); + } + int _error = _o.getError() == null ? 0 : builder.createString(_o.getError()); + return createVideoTrackerCalibrationProgressResponse( + builder, + _o.getStatus(), + _camera, + _trackersDone, + _trackersPending, + _error); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponseT.java b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponseT.java new file mode 100644 index 00000000..0ec3c5a0 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponseT.java @@ -0,0 +1,46 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class VideoTrackerCalibrationProgressResponseT { + private int status; + private solarxr_protocol.rpc.VideoTrackerCalibrationCameraT camera; + private int[] trackersDone; + private int[] trackersPending; + private String error; + + public int getStatus() { return status; } + + public void setStatus(int status) { this.status = status; } + + public solarxr_protocol.rpc.VideoTrackerCalibrationCameraT getCamera() { return camera; } + + public void setCamera(solarxr_protocol.rpc.VideoTrackerCalibrationCameraT camera) { this.camera = camera; } + + public int[] getTrackersDone() { return trackersDone; } + + public void setTrackersDone(int[] trackersDone) { this.trackersDone = trackersDone; } + + public int[] getTrackersPending() { return trackersPending; } + + public void setTrackersPending(int[] trackersPending) { this.trackersPending = trackersPending; } + + public String getError() { return error; } + + public void setError(String error) { this.error = error; } + + + public VideoTrackerCalibrationProgressResponseT() { + this.status = 0; + this.camera = null; + this.trackersDone = null; + this.trackersPending = null; + this.error = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.java b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.java new file mode 100644 index 00000000..8cf7a2aa --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.java @@ -0,0 +1,15 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class VideoTrackerCalibrationStatus { + private VideoTrackerCalibrationStatus() { } + public static final int CALIBRATE_CAMERA = 0; + public static final int CAPTURE_FORWARD_POSE = 1; + public static final int CAPTURE_BENT_OVER_POSE = 2; + public static final int CALIBRATE_TRACKERS = 3; + public static final int CALIBRATE_SKELETON_OFFSETS = 4; + public static final int DONE = 100; +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/WebRTCVideoProvider.java b/protocol/java/src/solarxr_protocol/rpc/WebRTCVideoProvider.java new file mode 100644 index 00000000..d47704f5 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/WebRTCVideoProvider.java @@ -0,0 +1,14 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class WebRTCVideoProvider { + private WebRTCVideoProvider() { } + public static final int VIDEO_CALIBRATION = 0; + + public static final String[] names = { "VIDEO_CALIBRATION", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.kt new file mode 100644 index 00000000..952d1750 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/CancelVideoTrackerCalibrationRequest.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 CancelVideoTrackerCalibrationRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : CancelVideoTrackerCalibrationRequest { + __init(_i, _bb) + return this + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsCancelVideoTrackerCalibrationRequest(_bb: ByteBuffer): CancelVideoTrackerCalibrationRequest = getRootAsCancelVideoTrackerCalibrationRequest(_bb, CancelVideoTrackerCalibrationRequest()) + @JvmStatic + fun getRootAsCancelVideoTrackerCalibrationRequest(_bb: ByteBuffer, obj: CancelVideoTrackerCalibrationRequest): CancelVideoTrackerCalibrationRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun startCancelVideoTrackerCalibrationRequest(builder: FlatBufferBuilder) = builder.startTable(0) + @JvmStatic + fun endCancelVideoTrackerCalibrationRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.kt new file mode 100644 index 00000000..22d18600 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCRequest.kt @@ -0,0 +1,60 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class ConnectToWebRTCRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : ConnectToWebRTCRequest { + __init(_i, _bb) + return this + } + val provider : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val offerSdp : String? + get() { + val o = __offset(6) + return if (o != 0) __string(o + bb_pos) else null + } + val offerSdpAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun offerSdpInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsConnectToWebRTCRequest(_bb: ByteBuffer): ConnectToWebRTCRequest = getRootAsConnectToWebRTCRequest(_bb, ConnectToWebRTCRequest()) + @JvmStatic + fun getRootAsConnectToWebRTCRequest(_bb: ByteBuffer, obj: ConnectToWebRTCRequest): ConnectToWebRTCRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createConnectToWebRTCRequest(builder: FlatBufferBuilder, provider: UByte, offerSdpOffset: Int) : Int { + builder.startTable(2) + addOfferSdp(builder, offerSdpOffset) + addProvider(builder, provider) + return endConnectToWebRTCRequest(builder) + } + @JvmStatic + fun startConnectToWebRTCRequest(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addProvider(builder: FlatBufferBuilder, provider: UByte) = builder.addByte(0, provider.toByte(), 0) + @JvmStatic + fun addOfferSdp(builder: FlatBufferBuilder, offerSdp: Int) = builder.addOffset(1, offerSdp, 0) + @JvmStatic + fun endConnectToWebRTCRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.kt new file mode 100644 index 00000000..9d169dbb --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/ConnectToWebRTCResponse.kt @@ -0,0 +1,62 @@ +// 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 ConnectToWebRTCResponse : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : ConnectToWebRTCResponse { + __init(_i, _bb) + return this + } + val answerSdp : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val answerSdpAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun answerSdpInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + val error : String? + get() { + val o = __offset(6) + return if (o != 0) __string(o + bb_pos) else null + } + val errorAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun errorInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsConnectToWebRTCResponse(_bb: ByteBuffer): ConnectToWebRTCResponse = getRootAsConnectToWebRTCResponse(_bb, ConnectToWebRTCResponse()) + @JvmStatic + fun getRootAsConnectToWebRTCResponse(_bb: ByteBuffer, obj: ConnectToWebRTCResponse): ConnectToWebRTCResponse { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createConnectToWebRTCResponse(builder: FlatBufferBuilder, answerSdpOffset: Int, errorOffset: Int) : Int { + builder.startTable(2) + addError(builder, errorOffset) + addAnswerSdp(builder, answerSdpOffset) + return endConnectToWebRTCResponse(builder) + } + @JvmStatic + fun startConnectToWebRTCResponse(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addAnswerSdp(builder: FlatBufferBuilder, answerSdp: Int) = builder.addOffset(0, answerSdp, 0) + @JvmStatic + fun addError(builder: FlatBufferBuilder, error: Int) = builder.addOffset(1, error, 0) + @JvmStatic + fun endConnectToWebRTCResponse(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 0aba32ed..47b0acab 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt @@ -84,7 +84,12 @@ class RpcMessage private constructor() { const val StartUserHeightCalibration: UByte = 76u const val CancelUserHeightCalibration: UByte = 77u const val UserHeightRecordingStatusResponse: UByte = 78u - val names : Array = arrayOf("NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse") + const val ConnectToWebRTCRequest: UByte = 79u + const val ConnectToWebRTCResponse: UByte = 80u + const val StartVideoTrackerCalibrationRequest: UByte = 81u + const val CancelVideoTrackerCalibrationRequest: UByte = 82u + const val VideoTrackerCalibrationProgressResponse: UByte = 83u + val names : Array = arrayOf("NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "ConnectToWebRTCRequest", "ConnectToWebRTCResponse", "StartVideoTrackerCalibrationRequest", "CancelVideoTrackerCalibrationRequest", "VideoTrackerCalibrationProgressResponse") @JvmStatic fun name(e: Int) : String = names[e] } diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.kt new file mode 100644 index 00000000..f093969a --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/StartVideoTrackerCalibrationRequest.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 StartVideoTrackerCalibrationRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : StartVideoTrackerCalibrationRequest { + __init(_i, _bb) + return this + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsStartVideoTrackerCalibrationRequest(_bb: ByteBuffer): StartVideoTrackerCalibrationRequest = getRootAsStartVideoTrackerCalibrationRequest(_bb, StartVideoTrackerCalibrationRequest()) + @JvmStatic + fun getRootAsStartVideoTrackerCalibrationRequest(_bb: ByteBuffer, obj: StartVideoTrackerCalibrationRequest): StartVideoTrackerCalibrationRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun startStartVideoTrackerCalibrationRequest(builder: FlatBufferBuilder) = builder.startTable(0) + @JvmStatic + fun endStartVideoTrackerCalibrationRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.kt new file mode 100644 index 00000000..01d6bc9a --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationCamera.kt @@ -0,0 +1,101 @@ +// 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 VideoTrackerCalibrationCamera : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : VideoTrackerCalibrationCamera { + __init(_i, _bb) + return this + } + val worldToCamera : solarxr_protocol.datatypes.math.Quat? get() = worldToCamera(solarxr_protocol.datatypes.math.Quat()) + fun worldToCamera(obj: solarxr_protocol.datatypes.math.Quat) : solarxr_protocol.datatypes.math.Quat? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(o + bb_pos, bb) + } else { + null + } + } + val worldOriginInCamera : solarxr_protocol.datatypes.math.Vec3f? get() = worldOriginInCamera(solarxr_protocol.datatypes.math.Vec3f()) + fun worldOriginInCamera(obj: solarxr_protocol.datatypes.math.Vec3f) : solarxr_protocol.datatypes.math.Vec3f? { + val o = __offset(6) + return if (o != 0) { + obj.__assign(o + bb_pos, bb) + } else { + null + } + } + val fx : Float + get() { + val o = __offset(8) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + val fy : Float + get() { + val o = __offset(10) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + val tx : Float + get() { + val o = __offset(12) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + val ty : Float + get() { + val o = __offset(14) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + val width : Int + get() { + val o = __offset(16) + return if(o != 0) bb.getInt(o + bb_pos) else 0 + } + val height : Int + get() { + val o = __offset(18) + return if(o != 0) bb.getInt(o + bb_pos) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsVideoTrackerCalibrationCamera(_bb: ByteBuffer): VideoTrackerCalibrationCamera = getRootAsVideoTrackerCalibrationCamera(_bb, VideoTrackerCalibrationCamera()) + @JvmStatic + fun getRootAsVideoTrackerCalibrationCamera(_bb: ByteBuffer, obj: VideoTrackerCalibrationCamera): VideoTrackerCalibrationCamera { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun startVideoTrackerCalibrationCamera(builder: FlatBufferBuilder) = builder.startTable(8) + @JvmStatic + fun addWorldToCamera(builder: FlatBufferBuilder, worldToCamera: Int) = builder.addStruct(0, worldToCamera, 0) + @JvmStatic + fun addWorldOriginInCamera(builder: FlatBufferBuilder, worldOriginInCamera: Int) = builder.addStruct(1, worldOriginInCamera, 0) + @JvmStatic + fun addFx(builder: FlatBufferBuilder, fx: Float) = builder.addFloat(2, fx, 0.0) + @JvmStatic + fun addFy(builder: FlatBufferBuilder, fy: Float) = builder.addFloat(3, fy, 0.0) + @JvmStatic + fun addTx(builder: FlatBufferBuilder, tx: Float) = builder.addFloat(4, tx, 0.0) + @JvmStatic + fun addTy(builder: FlatBufferBuilder, ty: Float) = builder.addFloat(5, ty, 0.0) + @JvmStatic + fun addWidth(builder: FlatBufferBuilder, width: Int) = builder.addInt(6, width, 0) + @JvmStatic + fun addHeight(builder: FlatBufferBuilder, height: Int) = builder.addInt(7, height, 0) + @JvmStatic + fun endVideoTrackerCalibrationCamera(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.kt new file mode 100644 index 00000000..0499d990 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationProgressResponse.kt @@ -0,0 +1,126 @@ +// 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 VideoTrackerCalibrationProgressResponse : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : VideoTrackerCalibrationProgressResponse { + __init(_i, _bb) + return this + } + val status : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val camera : solarxr_protocol.rpc.VideoTrackerCalibrationCamera? get() = camera(solarxr_protocol.rpc.VideoTrackerCalibrationCamera()) + fun camera(obj: solarxr_protocol.rpc.VideoTrackerCalibrationCamera) : solarxr_protocol.rpc.VideoTrackerCalibrationCamera? { + val o = __offset(6) + return if (o != 0) { + obj.__assign(__indirect(o + bb_pos), bb) + } else { + null + } + } + fun trackersDone(j: Int) : UByte { + val o = __offset(8) + return if (o != 0) { + bb.get(__vector(o) + j * 1).toUByte() + } else { + 0u + } + } + val trackersDoneLength : Int + get() { + val o = __offset(8); return if (o != 0) __vector_len(o) else 0 + } + val trackersDoneAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1) + fun trackersDoneInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1) + fun trackersPending(j: Int) : UByte { + val o = __offset(10) + return if (o != 0) { + bb.get(__vector(o) + j * 1).toUByte() + } else { + 0u + } + } + val trackersPendingLength : Int + get() { + val o = __offset(10); return if (o != 0) __vector_len(o) else 0 + } + val trackersPendingAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1) + fun trackersPendingInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1) + val error : String? + get() { + val o = __offset(12) + return if (o != 0) __string(o + bb_pos) else null + } + val errorAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(12, 1) + fun errorInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 12, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsVideoTrackerCalibrationProgressResponse(_bb: ByteBuffer): VideoTrackerCalibrationProgressResponse = getRootAsVideoTrackerCalibrationProgressResponse(_bb, VideoTrackerCalibrationProgressResponse()) + @JvmStatic + fun getRootAsVideoTrackerCalibrationProgressResponse(_bb: ByteBuffer, obj: VideoTrackerCalibrationProgressResponse): VideoTrackerCalibrationProgressResponse { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createVideoTrackerCalibrationProgressResponse(builder: FlatBufferBuilder, status: UByte, cameraOffset: Int, trackersDoneOffset: Int, trackersPendingOffset: Int, errorOffset: Int) : Int { + builder.startTable(5) + addError(builder, errorOffset) + addTrackersPending(builder, trackersPendingOffset) + addTrackersDone(builder, trackersDoneOffset) + addCamera(builder, cameraOffset) + addStatus(builder, status) + return endVideoTrackerCalibrationProgressResponse(builder) + } + @JvmStatic + fun startVideoTrackerCalibrationProgressResponse(builder: FlatBufferBuilder) = builder.startTable(5) + @JvmStatic + fun addStatus(builder: FlatBufferBuilder, status: UByte) = builder.addByte(0, status.toByte(), 0) + @JvmStatic + fun addCamera(builder: FlatBufferBuilder, camera: Int) = builder.addOffset(1, camera, 0) + @JvmStatic + fun addTrackersDone(builder: FlatBufferBuilder, trackersDone: Int) = builder.addOffset(2, trackersDone, 0) + @JvmStatic + fun createTrackersDoneVector(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 startTrackersDoneVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) + @JvmStatic + fun addTrackersPending(builder: FlatBufferBuilder, trackersPending: Int) = builder.addOffset(3, trackersPending, 0) + @JvmStatic + fun createTrackersPendingVector(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 startTrackersPendingVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1) + @JvmStatic + fun addError(builder: FlatBufferBuilder, error: Int) = builder.addOffset(4, error, 0) + @JvmStatic + fun endVideoTrackerCalibrationProgressResponse(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.kt b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.kt new file mode 100644 index 00000000..f7c3c5d9 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/VideoTrackerCalibrationStatus.kt @@ -0,0 +1,15 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class VideoTrackerCalibrationStatus private constructor() { + companion object { + const val CALIBRATECAMERA: UByte = 0u + const val CAPTUREFORWARDPOSE: UByte = 1u + const val CAPTUREBENTOVERPOSE: UByte = 2u + const val CALIBRATETRACKERS: UByte = 3u + const val CALIBRATESKELETONOFFSETS: UByte = 4u + const val DONE: UByte = 100u + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/WebRTCVideoProvider.kt b/protocol/kotlin/src/solarxr_protocol/rpc/WebRTCVideoProvider.kt new file mode 100644 index 00000000..863961aa --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/WebRTCVideoProvider.kt @@ -0,0 +1,13 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class WebRTCVideoProvider private constructor() { + companion object { + const val VIDEOCALIBRATION: UByte = 0u + val names : Array = arrayOf("VIDEO_CALIBRATION") + @JvmStatic + fun name(e: Int) : String = names[e] + } +} diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs index a3a27b23..ae0ab0b3 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -188,6 +188,10 @@ pub mod solarxr_protocol { pub use self::stay_aligned_relaxed_pose_generated::*; mod user_height_calibration_status_generated; pub use self::user_height_calibration_status_generated::*; + mod web_rtcvideo_provider_generated; + pub use self::web_rtcvideo_provider_generated::*; + mod video_tracker_calibration_status_generated; + pub use self::video_tracker_calibration_status_generated::*; mod rpc_message_header_generated; pub use self::rpc_message_header_generated::*; mod heartbeat_request_generated; @@ -416,6 +420,18 @@ pub mod solarxr_protocol { pub use self::cancel_user_height_calibration_generated::*; mod user_height_recording_status_response_generated; pub use self::user_height_recording_status_response_generated::*; + mod connect_to_web_rtcrequest_generated; + pub use self::connect_to_web_rtcrequest_generated::*; + mod connect_to_web_rtcresponse_generated; + pub use self::connect_to_web_rtcresponse_generated::*; + mod start_video_tracker_calibration_request_generated; + pub use self::start_video_tracker_calibration_request_generated::*; + mod cancel_video_tracker_calibration_request_generated; + pub use self::cancel_video_tracker_calibration_request_generated::*; + mod video_tracker_calibration_camera_generated; + pub use self::video_tracker_calibration_camera_generated::*; + mod video_tracker_calibration_progress_response_generated; + pub use self::video_tracker_calibration_progress_response_generated::*; } // rpc mod message_bundle_generated; pub use self::message_bundle_generated::*; diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/cancel_video_tracker_calibration_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/cancel_video_tracker_calibration_request_generated.rs new file mode 100644 index 00000000..1a2654e4 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/cancel_video_tracker_calibration_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 CancelVideoTrackerCalibrationRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct CancelVideoTrackerCalibrationRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for CancelVideoTrackerCalibrationRequest<'a> { + type Inner = CancelVideoTrackerCalibrationRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> CancelVideoTrackerCalibrationRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + CancelVideoTrackerCalibrationRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args CancelVideoTrackerCalibrationRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = CancelVideoTrackerCalibrationRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for CancelVideoTrackerCalibrationRequest<'_> { + #[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 CancelVideoTrackerCalibrationRequestArgs { +} +impl<'a> Default for CancelVideoTrackerCalibrationRequestArgs { + #[inline] + fn default() -> Self { + CancelVideoTrackerCalibrationRequestArgs { + } + } +} + +pub struct CancelVideoTrackerCalibrationRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> CancelVideoTrackerCalibrationRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CancelVideoTrackerCalibrationRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + CancelVideoTrackerCalibrationRequestBuilder { + 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 CancelVideoTrackerCalibrationRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("CancelVideoTrackerCalibrationRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcrequest_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcrequest_generated.rs new file mode 100644 index 00000000..db99c20e --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcrequest_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 ConnectToWebRTCRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ConnectToWebRTCRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ConnectToWebRTCRequest<'a> { + type Inner = ConnectToWebRTCRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ConnectToWebRTCRequest<'a> { + pub const VT_PROVIDER: flatbuffers::VOffsetT = 4; + pub const VT_OFFER_SDP: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ConnectToWebRTCRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ConnectToWebRTCRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ConnectToWebRTCRequestBuilder::new(_fbb); + if let Some(x) = args.offer_sdp { builder.add_offer_sdp(x); } + builder.add_provider(args.provider); + builder.finish() + } + + + #[inline] + pub fn provider(&self) -> WebRTCVideoProvider { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(ConnectToWebRTCRequest::VT_PROVIDER, Some(WebRTCVideoProvider::VIDEO_CALIBRATION)).unwrap()} + } + #[inline] + pub fn offer_sdp(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ConnectToWebRTCRequest::VT_OFFER_SDP, None)} + } +} + +impl flatbuffers::Verifiable for ConnectToWebRTCRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("provider", Self::VT_PROVIDER, false)? + .visit_field::>("offer_sdp", Self::VT_OFFER_SDP, false)? + .finish(); + Ok(()) + } +} +pub struct ConnectToWebRTCRequestArgs<'a> { + pub provider: WebRTCVideoProvider, + pub offer_sdp: Option>, +} +impl<'a> Default for ConnectToWebRTCRequestArgs<'a> { + #[inline] + fn default() -> Self { + ConnectToWebRTCRequestArgs { + provider: WebRTCVideoProvider::VIDEO_CALIBRATION, + offer_sdp: None, + } + } +} + +pub struct ConnectToWebRTCRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ConnectToWebRTCRequestBuilder<'a, 'b> { + #[inline] + pub fn add_provider(&mut self, provider: WebRTCVideoProvider) { + self.fbb_.push_slot::(ConnectToWebRTCRequest::VT_PROVIDER, provider, WebRTCVideoProvider::VIDEO_CALIBRATION); + } + #[inline] + pub fn add_offer_sdp(&mut self, offer_sdp: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ConnectToWebRTCRequest::VT_OFFER_SDP, offer_sdp); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ConnectToWebRTCRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ConnectToWebRTCRequestBuilder { + 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 ConnectToWebRTCRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ConnectToWebRTCRequest"); + ds.field("provider", &self.provider()); + ds.field("offer_sdp", &self.offer_sdp()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcresponse_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcresponse_generated.rs new file mode 100644 index 00000000..ebe4bd53 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/connect_to_web_rtcresponse_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 ConnectToWebRTCResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ConnectToWebRTCResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ConnectToWebRTCResponse<'a> { + type Inner = ConnectToWebRTCResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ConnectToWebRTCResponse<'a> { + pub const VT_ANSWER_SDP: flatbuffers::VOffsetT = 4; + pub const VT_ERROR: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ConnectToWebRTCResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ConnectToWebRTCResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ConnectToWebRTCResponseBuilder::new(_fbb); + if let Some(x) = args.error { builder.add_error(x); } + if let Some(x) = args.answer_sdp { builder.add_answer_sdp(x); } + builder.finish() + } + + + #[inline] + pub fn answer_sdp(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ConnectToWebRTCResponse::VT_ANSWER_SDP, None)} + } + #[inline] + pub fn error(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(ConnectToWebRTCResponse::VT_ERROR, None)} + } +} + +impl flatbuffers::Verifiable for ConnectToWebRTCResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("answer_sdp", Self::VT_ANSWER_SDP, false)? + .visit_field::>("error", Self::VT_ERROR, false)? + .finish(); + Ok(()) + } +} +pub struct ConnectToWebRTCResponseArgs<'a> { + pub answer_sdp: Option>, + pub error: Option>, +} +impl<'a> Default for ConnectToWebRTCResponseArgs<'a> { + #[inline] + fn default() -> Self { + ConnectToWebRTCResponseArgs { + answer_sdp: None, + error: None, + } + } +} + +pub struct ConnectToWebRTCResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ConnectToWebRTCResponseBuilder<'a, 'b> { + #[inline] + pub fn add_answer_sdp(&mut self, answer_sdp: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ConnectToWebRTCResponse::VT_ANSWER_SDP, answer_sdp); + } + #[inline] + pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(ConnectToWebRTCResponse::VT_ERROR, error); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ConnectToWebRTCResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + ConnectToWebRTCResponseBuilder { + 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 ConnectToWebRTCResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ConnectToWebRTCResponse"); + ds.field("answer_sdp", &self.answer_sdp()); + ds.field("error", &self.error()); + 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 f056f10c..07b225b8 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 = 78; +pub const ENUM_MAX_RPC_MESSAGE: u8 = 83; #[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; 79] = [ +pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 84] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, @@ -95,6 +95,11 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 79] = [ RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::ConnectToWebRTCRequest, + RpcMessage::ConnectToWebRTCResponse, + RpcMessage::StartVideoTrackerCalibrationRequest, + RpcMessage::CancelVideoTrackerCalibrationRequest, + RpcMessage::VideoTrackerCalibrationProgressResponse, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -181,9 +186,14 @@ impl RpcMessage { pub const StartUserHeightCalibration: Self = Self(76); pub const CancelUserHeightCalibration: Self = Self(77); pub const UserHeightRecordingStatusResponse: Self = Self(78); + pub const ConnectToWebRTCRequest: Self = Self(79); + pub const ConnectToWebRTCResponse: Self = Self(80); + pub const StartVideoTrackerCalibrationRequest: Self = Self(81); + pub const CancelVideoTrackerCalibrationRequest: Self = Self(82); + pub const VideoTrackerCalibrationProgressResponse: Self = Self(83); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 78; + pub const ENUM_MAX: u8 = 83; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -264,6 +274,11 @@ impl RpcMessage { Self::StartUserHeightCalibration, Self::CancelUserHeightCalibration, Self::UserHeightRecordingStatusResponse, + Self::ConnectToWebRTCRequest, + Self::ConnectToWebRTCResponse, + Self::StartVideoTrackerCalibrationRequest, + Self::CancelVideoTrackerCalibrationRequest, + Self::VideoTrackerCalibrationProgressResponse, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -347,6 +362,11 @@ impl RpcMessage { Self::StartUserHeightCalibration => Some("StartUserHeightCalibration"), Self::CancelUserHeightCalibration => Some("CancelUserHeightCalibration"), Self::UserHeightRecordingStatusResponse => Some("UserHeightRecordingStatusResponse"), + Self::ConnectToWebRTCRequest => Some("ConnectToWebRTCRequest"), + Self::ConnectToWebRTCResponse => Some("ConnectToWebRTCResponse"), + Self::StartVideoTrackerCalibrationRequest => Some("StartVideoTrackerCalibrationRequest"), + Self::CancelVideoTrackerCalibrationRequest => Some("CancelVideoTrackerCalibrationRequest"), + Self::VideoTrackerCalibrationProgressResponse => Some("VideoTrackerCalibrationProgressResponse"), _ => 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 5302176d..3f81e2ba 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 @@ -1239,6 +1239,81 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_connect_to_web_rtcrequest(&self) -> Option> { + if self.message_type() == RpcMessage::ConnectToWebRTCRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { ConnectToWebRTCRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_connect_to_web_rtcresponse(&self) -> Option> { + if self.message_type() == RpcMessage::ConnectToWebRTCResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { ConnectToWebRTCResponse::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_start_video_tracker_calibration_request(&self) -> Option> { + if self.message_type() == RpcMessage::StartVideoTrackerCalibrationRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { StartVideoTrackerCalibrationRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_cancel_video_tracker_calibration_request(&self) -> Option> { + if self.message_type() == RpcMessage::CancelVideoTrackerCalibrationRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { CancelVideoTrackerCalibrationRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_video_tracker_calibration_progress_response(&self) -> Option> { + if self.message_type() == RpcMessage::VideoTrackerCalibrationProgressResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { VideoTrackerCalibrationProgressResponse::init_from_table(t) } + }) + } else { + None + } + } + } impl flatbuffers::Verifiable for RpcMessageHeader<'_> { @@ -1329,6 +1404,11 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::StartUserHeightCalibration => v.verify_union_variant::>("RpcMessage::StartUserHeightCalibration", pos), RpcMessage::CancelUserHeightCalibration => v.verify_union_variant::>("RpcMessage::CancelUserHeightCalibration", pos), RpcMessage::UserHeightRecordingStatusResponse => v.verify_union_variant::>("RpcMessage::UserHeightRecordingStatusResponse", pos), + RpcMessage::ConnectToWebRTCRequest => v.verify_union_variant::>("RpcMessage::ConnectToWebRTCRequest", pos), + RpcMessage::ConnectToWebRTCResponse => v.verify_union_variant::>("RpcMessage::ConnectToWebRTCResponse", pos), + RpcMessage::StartVideoTrackerCalibrationRequest => v.verify_union_variant::>("RpcMessage::StartVideoTrackerCalibrationRequest", pos), + RpcMessage::CancelVideoTrackerCalibrationRequest => v.verify_union_variant::>("RpcMessage::CancelVideoTrackerCalibrationRequest", pos), + RpcMessage::VideoTrackerCalibrationProgressResponse => v.verify_union_variant::>("RpcMessage::VideoTrackerCalibrationProgressResponse", pos), _ => Ok(()), } })? @@ -1936,6 +2016,41 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::ConnectToWebRTCRequest => { + if let Some(x) = self.message_as_connect_to_web_rtcrequest() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ConnectToWebRTCResponse => { + if let Some(x) = self.message_as_connect_to_web_rtcresponse() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::StartVideoTrackerCalibrationRequest => { + if let Some(x) = self.message_as_start_video_tracker_calibration_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::CancelVideoTrackerCalibrationRequest => { + if let Some(x) = self.message_as_cancel_video_tracker_calibration_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::VideoTrackerCalibrationProgressResponse => { + if let Some(x) = self.message_as_video_tracker_calibration_progress_response() { + 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/start_video_tracker_calibration_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/start_video_tracker_calibration_request_generated.rs new file mode 100644 index 00000000..b970ac20 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/start_video_tracker_calibration_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 StartVideoTrackerCalibrationRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct StartVideoTrackerCalibrationRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for StartVideoTrackerCalibrationRequest<'a> { + type Inner = StartVideoTrackerCalibrationRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> StartVideoTrackerCalibrationRequest<'a> { + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + StartVideoTrackerCalibrationRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + _args: &'args StartVideoTrackerCalibrationRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = StartVideoTrackerCalibrationRequestBuilder::new(_fbb); + builder.finish() + } + +} + +impl flatbuffers::Verifiable for StartVideoTrackerCalibrationRequest<'_> { + #[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 StartVideoTrackerCalibrationRequestArgs { +} +impl<'a> Default for StartVideoTrackerCalibrationRequestArgs { + #[inline] + fn default() -> Self { + StartVideoTrackerCalibrationRequestArgs { + } + } +} + +pub struct StartVideoTrackerCalibrationRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> StartVideoTrackerCalibrationRequestBuilder<'a, 'b> { + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StartVideoTrackerCalibrationRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + StartVideoTrackerCalibrationRequestBuilder { + 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 StartVideoTrackerCalibrationRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("StartVideoTrackerCalibrationRequest"); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_camera_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_camera_generated.rs new file mode 100644 index 00000000..f9967793 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_camera_generated.rs @@ -0,0 +1,227 @@ +// 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 VideoTrackerCalibrationCameraOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VideoTrackerCalibrationCamera<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VideoTrackerCalibrationCamera<'a> { + type Inner = VideoTrackerCalibrationCamera<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VideoTrackerCalibrationCamera<'a> { + pub const VT_WORLD_TO_CAMERA: flatbuffers::VOffsetT = 4; + pub const VT_WORLD_ORIGIN_IN_CAMERA: flatbuffers::VOffsetT = 6; + pub const VT_FX: flatbuffers::VOffsetT = 8; + pub const VT_FY: flatbuffers::VOffsetT = 10; + pub const VT_TX: flatbuffers::VOffsetT = 12; + pub const VT_TY: flatbuffers::VOffsetT = 14; + pub const VT_WIDTH: flatbuffers::VOffsetT = 16; + pub const VT_HEIGHT: flatbuffers::VOffsetT = 18; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VideoTrackerCalibrationCamera { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VideoTrackerCalibrationCameraArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VideoTrackerCalibrationCameraBuilder::new(_fbb); + builder.add_height(args.height); + builder.add_width(args.width); + builder.add_ty(args.ty); + builder.add_tx(args.tx); + builder.add_fy(args.fy); + builder.add_fx(args.fx); + if let Some(x) = args.world_origin_in_camera { builder.add_world_origin_in_camera(x); } + if let Some(x) = args.world_to_camera { builder.add_world_to_camera(x); } + builder.finish() + } + + + #[inline] + pub fn world_to_camera(&self) -> Option<&'a super::datatypes::math::Quat> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_WORLD_TO_CAMERA, None)} + } + #[inline] + pub fn world_origin_in_camera(&self) -> Option<&'a super::datatypes::math::Vec3f> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_WORLD_ORIGIN_IN_CAMERA, None)} + } + #[inline] + pub fn fx(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_FX, Some(0.0)).unwrap()} + } + #[inline] + pub fn fy(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_FY, Some(0.0)).unwrap()} + } + #[inline] + pub fn tx(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_TX, Some(0.0)).unwrap()} + } + #[inline] + pub fn ty(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_TY, Some(0.0)).unwrap()} + } + #[inline] + pub fn width(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_WIDTH, Some(0)).unwrap()} + } + #[inline] + pub fn height(&self) -> i32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationCamera::VT_HEIGHT, Some(0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for VideoTrackerCalibrationCamera<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("world_to_camera", Self::VT_WORLD_TO_CAMERA, false)? + .visit_field::("world_origin_in_camera", Self::VT_WORLD_ORIGIN_IN_CAMERA, false)? + .visit_field::("fx", Self::VT_FX, false)? + .visit_field::("fy", Self::VT_FY, false)? + .visit_field::("tx", Self::VT_TX, false)? + .visit_field::("ty", Self::VT_TY, false)? + .visit_field::("width", Self::VT_WIDTH, false)? + .visit_field::("height", Self::VT_HEIGHT, false)? + .finish(); + Ok(()) + } +} +pub struct VideoTrackerCalibrationCameraArgs<'a> { + pub world_to_camera: Option<&'a super::datatypes::math::Quat>, + pub world_origin_in_camera: Option<&'a super::datatypes::math::Vec3f>, + pub fx: f32, + pub fy: f32, + pub tx: f32, + pub ty: f32, + pub width: i32, + pub height: i32, +} +impl<'a> Default for VideoTrackerCalibrationCameraArgs<'a> { + #[inline] + fn default() -> Self { + VideoTrackerCalibrationCameraArgs { + world_to_camera: None, + world_origin_in_camera: None, + fx: 0.0, + fy: 0.0, + tx: 0.0, + ty: 0.0, + width: 0, + height: 0, + } + } +} + +pub struct VideoTrackerCalibrationCameraBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VideoTrackerCalibrationCameraBuilder<'a, 'b> { + #[inline] + pub fn add_world_to_camera(&mut self, world_to_camera: &super::datatypes::math::Quat) { + self.fbb_.push_slot_always::<&super::datatypes::math::Quat>(VideoTrackerCalibrationCamera::VT_WORLD_TO_CAMERA, world_to_camera); + } + #[inline] + pub fn add_world_origin_in_camera(&mut self, world_origin_in_camera: &super::datatypes::math::Vec3f) { + self.fbb_.push_slot_always::<&super::datatypes::math::Vec3f>(VideoTrackerCalibrationCamera::VT_WORLD_ORIGIN_IN_CAMERA, world_origin_in_camera); + } + #[inline] + pub fn add_fx(&mut self, fx: f32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_FX, fx, 0.0); + } + #[inline] + pub fn add_fy(&mut self, fy: f32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_FY, fy, 0.0); + } + #[inline] + pub fn add_tx(&mut self, tx: f32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_TX, tx, 0.0); + } + #[inline] + pub fn add_ty(&mut self, ty: f32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_TY, ty, 0.0); + } + #[inline] + pub fn add_width(&mut self, width: i32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_WIDTH, width, 0); + } + #[inline] + pub fn add_height(&mut self, height: i32) { + self.fbb_.push_slot::(VideoTrackerCalibrationCamera::VT_HEIGHT, height, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VideoTrackerCalibrationCameraBuilder<'a, 'b> { + let start = _fbb.start_table(); + VideoTrackerCalibrationCameraBuilder { + 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 VideoTrackerCalibrationCamera<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VideoTrackerCalibrationCamera"); + ds.field("world_to_camera", &self.world_to_camera()); + ds.field("world_origin_in_camera", &self.world_origin_in_camera()); + ds.field("fx", &self.fx()); + ds.field("fy", &self.fy()); + ds.field("tx", &self.tx()); + ds.field("ty", &self.ty()); + ds.field("width", &self.width()); + ds.field("height", &self.height()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_progress_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_progress_response_generated.rs new file mode 100644 index 00000000..f3d19a47 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_progress_response_generated.rs @@ -0,0 +1,176 @@ +// 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 VideoTrackerCalibrationProgressResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct VideoTrackerCalibrationProgressResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for VideoTrackerCalibrationProgressResponse<'a> { + type Inner = VideoTrackerCalibrationProgressResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> VideoTrackerCalibrationProgressResponse<'a> { + pub const VT_STATUS: flatbuffers::VOffsetT = 4; + pub const VT_CAMERA: flatbuffers::VOffsetT = 6; + pub const VT_TRACKERS_DONE: flatbuffers::VOffsetT = 8; + pub const VT_TRACKERS_PENDING: flatbuffers::VOffsetT = 10; + pub const VT_ERROR: flatbuffers::VOffsetT = 12; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + VideoTrackerCalibrationProgressResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args VideoTrackerCalibrationProgressResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = VideoTrackerCalibrationProgressResponseBuilder::new(_fbb); + if let Some(x) = args.error { builder.add_error(x); } + if let Some(x) = args.trackers_pending { builder.add_trackers_pending(x); } + if let Some(x) = args.trackers_done { builder.add_trackers_done(x); } + if let Some(x) = args.camera { builder.add_camera(x); } + builder.add_status(args.status); + builder.finish() + } + + + #[inline] + pub fn status(&self) -> VideoTrackerCalibrationStatus { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(VideoTrackerCalibrationProgressResponse::VT_STATUS, Some(VideoTrackerCalibrationStatus::CALIBRATE_CAMERA)).unwrap()} + } + #[inline] + pub fn camera(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VideoTrackerCalibrationProgressResponse::VT_CAMERA, None)} + } + #[inline] + pub fn trackers_done(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_DONE, None)} + } + #[inline] + pub fn trackers_pending(&self) -> Option> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_PENDING, None)} + } + #[inline] + pub fn error(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(VideoTrackerCalibrationProgressResponse::VT_ERROR, None)} + } +} + +impl flatbuffers::Verifiable for VideoTrackerCalibrationProgressResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("status", Self::VT_STATUS, false)? + .visit_field::>("camera", Self::VT_CAMERA, false)? + .visit_field::>>("trackers_done", Self::VT_TRACKERS_DONE, false)? + .visit_field::>>("trackers_pending", Self::VT_TRACKERS_PENDING, false)? + .visit_field::>("error", Self::VT_ERROR, false)? + .finish(); + Ok(()) + } +} +pub struct VideoTrackerCalibrationProgressResponseArgs<'a> { + pub status: VideoTrackerCalibrationStatus, + pub camera: Option>>, + pub trackers_done: Option>>, + pub trackers_pending: Option>>, + pub error: Option>, +} +impl<'a> Default for VideoTrackerCalibrationProgressResponseArgs<'a> { + #[inline] + fn default() -> Self { + VideoTrackerCalibrationProgressResponseArgs { + status: VideoTrackerCalibrationStatus::CALIBRATE_CAMERA, + camera: None, + trackers_done: None, + trackers_pending: None, + error: None, + } + } +} + +pub struct VideoTrackerCalibrationProgressResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> VideoTrackerCalibrationProgressResponseBuilder<'a, 'b> { + #[inline] + pub fn add_status(&mut self, status: VideoTrackerCalibrationStatus) { + self.fbb_.push_slot::(VideoTrackerCalibrationProgressResponse::VT_STATUS, status, VideoTrackerCalibrationStatus::CALIBRATE_CAMERA); + } + #[inline] + pub fn add_camera(&mut self, camera: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(VideoTrackerCalibrationProgressResponse::VT_CAMERA, camera); + } + #[inline] + pub fn add_trackers_done(&mut self, trackers_done: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_DONE, trackers_done); + } + #[inline] + pub fn add_trackers_pending(&mut self, trackers_pending: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(VideoTrackerCalibrationProgressResponse::VT_TRACKERS_PENDING, trackers_pending); + } + #[inline] + pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(VideoTrackerCalibrationProgressResponse::VT_ERROR, error); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> VideoTrackerCalibrationProgressResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + VideoTrackerCalibrationProgressResponseBuilder { + 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 VideoTrackerCalibrationProgressResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("VideoTrackerCalibrationProgressResponse"); + ds.field("status", &self.status()); + ds.field("camera", &self.camera()); + ds.field("trackers_done", &self.trackers_done()); + ds.field("trackers_pending", &self.trackers_pending()); + ds.field("error", &self.error()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_status_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_status_generated.rs new file mode 100644 index 00000000..b7be8b99 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/video_tracker_calibration_status_generated.rs @@ -0,0 +1,112 @@ +// 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_VIDEO_TRACKER_CALIBRATION_STATUS: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_VIDEO_TRACKER_CALIBRATION_STATUS: u8 = 100; +#[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_VIDEO_TRACKER_CALIBRATION_STATUS: [VideoTrackerCalibrationStatus; 6] = [ + VideoTrackerCalibrationStatus::CALIBRATE_CAMERA, + VideoTrackerCalibrationStatus::CAPTURE_FORWARD_POSE, + VideoTrackerCalibrationStatus::CAPTURE_BENT_OVER_POSE, + VideoTrackerCalibrationStatus::CALIBRATE_TRACKERS, + VideoTrackerCalibrationStatus::CALIBRATE_SKELETON_OFFSETS, + VideoTrackerCalibrationStatus::DONE, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct VideoTrackerCalibrationStatus(pub u8); +#[allow(non_upper_case_globals)] +impl VideoTrackerCalibrationStatus { + pub const CALIBRATE_CAMERA: Self = Self(0); + pub const CAPTURE_FORWARD_POSE: Self = Self(1); + pub const CAPTURE_BENT_OVER_POSE: Self = Self(2); + pub const CALIBRATE_TRACKERS: Self = Self(3); + pub const CALIBRATE_SKELETON_OFFSETS: Self = Self(4); + pub const DONE: Self = Self(100); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 100; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::CALIBRATE_CAMERA, + Self::CAPTURE_FORWARD_POSE, + Self::CAPTURE_BENT_OVER_POSE, + Self::CALIBRATE_TRACKERS, + Self::CALIBRATE_SKELETON_OFFSETS, + Self::DONE, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::CALIBRATE_CAMERA => Some("CALIBRATE_CAMERA"), + Self::CAPTURE_FORWARD_POSE => Some("CAPTURE_FORWARD_POSE"), + Self::CAPTURE_BENT_OVER_POSE => Some("CAPTURE_BENT_OVER_POSE"), + Self::CALIBRATE_TRACKERS => Some("CALIBRATE_TRACKERS"), + Self::CALIBRATE_SKELETON_OFFSETS => Some("CALIBRATE_SKELETON_OFFSETS"), + Self::DONE => Some("DONE"), + _ => None, + } + } +} +impl core::fmt::Debug for VideoTrackerCalibrationStatus { + 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 VideoTrackerCalibrationStatus { + 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 VideoTrackerCalibrationStatus { + type Output = VideoTrackerCalibrationStatus; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for VideoTrackerCalibrationStatus { + 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 VideoTrackerCalibrationStatus { + #[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 VideoTrackerCalibrationStatus {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/web_rtcvideo_provider_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/web_rtcvideo_provider_generated.rs new file mode 100644 index 00000000..a8c8c379 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/web_rtcvideo_provider_generated.rs @@ -0,0 +1,92 @@ +// 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_WEB_RTCVIDEO_PROVIDER: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_WEB_RTCVIDEO_PROVIDER: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +#[allow(non_camel_case_types)] +pub const ENUM_VALUES_WEB_RTCVIDEO_PROVIDER: [WebRTCVideoProvider; 1] = [ + WebRTCVideoProvider::VIDEO_CALIBRATION, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct WebRTCVideoProvider(pub u8); +#[allow(non_upper_case_globals)] +impl WebRTCVideoProvider { + pub const VIDEO_CALIBRATION: Self = Self(0); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 0; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::VIDEO_CALIBRATION, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::VIDEO_CALIBRATION => Some("VIDEO_CALIBRATION"), + _ => None, + } + } +} +impl core::fmt::Debug for WebRTCVideoProvider { + 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 WebRTCVideoProvider { + 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 WebRTCVideoProvider { + type Output = WebRTCVideoProvider; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for WebRTCVideoProvider { + 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 WebRTCVideoProvider { + #[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 WebRTCVideoProvider {} diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index 1535b09d..221076cc 100644 --- a/protocol/typescript/src/all_generated.ts +++ b/protocol/typescript/src/all_generated.ts @@ -64,6 +64,7 @@ export { AutoBoneProcessType } from './solarxr-protocol/rpc/auto-bone-process-ty export { AutoBoneSettings, AutoBoneSettingsT } from './solarxr-protocol/rpc/auto-bone-settings.js'; export { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from './solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; export { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from './solarxr-protocol/rpc/cancel-user-height-calibration.js'; +export { CancelVideoTrackerCalibrationRequest, CancelVideoTrackerCalibrationRequestT } from './solarxr-protocol/rpc/cancel-video-tracker-calibration-request.js'; export { ChangeMagToggleRequest, ChangeMagToggleRequestT } from './solarxr-protocol/rpc/change-mag-toggle-request.js'; export { ChangeSettingsRequest, ChangeSettingsRequestT } from './solarxr-protocol/rpc/change-settings-request.js'; export { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from './solarxr-protocol/rpc/change-skeleton-config-request.js'; @@ -71,6 +72,8 @@ export { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from '. export { ClearMountingResetRequest, ClearMountingResetRequestT } from './solarxr-protocol/rpc/clear-mounting-reset-request.js'; export { CloseSerialRequest, CloseSerialRequestT } from './solarxr-protocol/rpc/close-serial-request.js'; export { ComputerDirectory } from './solarxr-protocol/rpc/computer-directory.js'; +export { ConnectToWebRTCRequest, ConnectToWebRTCRequestT } from './solarxr-protocol/rpc/connect-to-web-rtcrequest.js'; +export { ConnectToWebRTCResponse, ConnectToWebRTCResponseT } from './solarxr-protocol/rpc/connect-to-web-rtcresponse.js'; export { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from './solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; export { DriftCompensationSettings, DriftCompensationSettingsT } from './solarxr-protocol/rpc/drift-compensation-settings.js'; export { EnableStayAlignedRequest, EnableStayAlignedRequestT } from './solarxr-protocol/rpc/enable-stay-aligned-request.js'; @@ -138,6 +141,7 @@ export { SkeletonConfigResponse, SkeletonConfigResponseT } from './solarxr-proto export { SkeletonPart, SkeletonPartT } from './solarxr-protocol/rpc/skeleton-part.js'; export { SkeletonResetAllRequest, SkeletonResetAllRequestT } from './solarxr-protocol/rpc/skeleton-reset-all-request.js'; export { StartUserHeightCalibration, StartUserHeightCalibrationT } from './solarxr-protocol/rpc/start-user-height-calibration.js'; +export { StartVideoTrackerCalibrationRequest, StartVideoTrackerCalibrationRequestT } from './solarxr-protocol/rpc/start-video-tracker-calibration-request.js'; export { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from './solarxr-protocol/rpc/start-wifi-provisioning-request.js'; export { StatusData, unionToStatusData, unionListToStatusData } from './solarxr-protocol/rpc/status-data.js'; export { StatusMessage, StatusMessageT } from './solarxr-protocol/rpc/status-message.js'; @@ -184,6 +188,10 @@ export { VRCConfigValues, VRCConfigValuesT } from './solarxr-protocol/rpc/vrccon export { VRCOSCSettings, VRCOSCSettingsT } from './solarxr-protocol/rpc/vrcoscsettings.js'; export { VRCSpineMode } from './solarxr-protocol/rpc/vrcspine-mode.js'; export { VRCTrackerModel } from './solarxr-protocol/rpc/vrctracker-model.js'; +export { VideoTrackerCalibrationCamera, VideoTrackerCalibrationCameraT } from './solarxr-protocol/rpc/video-tracker-calibration-camera.js'; +export { VideoTrackerCalibrationProgressResponse, VideoTrackerCalibrationProgressResponseT } from './solarxr-protocol/rpc/video-tracker-calibration-progress-response.js'; +export { VideoTrackerCalibrationStatus } from './solarxr-protocol/rpc/video-tracker-calibration-status.js'; +export { WebRTCVideoProvider } from './solarxr-protocol/rpc/web-rtcvideo-provider.js'; export { WifiProvisioningStatus } from './solarxr-protocol/rpc/wifi-provisioning-status.js'; export { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from './solarxr-protocol/rpc/wifi-provisioning-status-response.js'; export { LegTweaksSettings, LegTweaksSettingsT } from './solarxr-protocol/rpc/settings/leg-tweaks-settings.js'; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/cancel-video-tracker-calibration-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/cancel-video-tracker-calibration-request.ts new file mode 100644 index 00000000..eea5a289 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/cancel-video-tracker-calibration-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class CancelVideoTrackerCalibrationRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):CancelVideoTrackerCalibrationRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsCancelVideoTrackerCalibrationRequest(bb:flatbuffers.ByteBuffer, obj?:CancelVideoTrackerCalibrationRequest):CancelVideoTrackerCalibrationRequest { + return (obj || new CancelVideoTrackerCalibrationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsCancelVideoTrackerCalibrationRequest(bb:flatbuffers.ByteBuffer, obj?:CancelVideoTrackerCalibrationRequest):CancelVideoTrackerCalibrationRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new CancelVideoTrackerCalibrationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startCancelVideoTrackerCalibrationRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endCancelVideoTrackerCalibrationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createCancelVideoTrackerCalibrationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + CancelVideoTrackerCalibrationRequest.startCancelVideoTrackerCalibrationRequest(builder); + return CancelVideoTrackerCalibrationRequest.endCancelVideoTrackerCalibrationRequest(builder); +} + +unpack(): CancelVideoTrackerCalibrationRequestT { + return new CancelVideoTrackerCalibrationRequestT(); +} + + +unpackTo(_o: CancelVideoTrackerCalibrationRequestT): void {} +} + +export class CancelVideoTrackerCalibrationRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return CancelVideoTrackerCalibrationRequest.createCancelVideoTrackerCalibrationRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcrequest.ts b/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcrequest.ts new file mode 100644 index 00000000..6c50eeac --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcrequest.ts @@ -0,0 +1,91 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { WebRTCVideoProvider } from '../../solarxr-protocol/rpc/web-rtcvideo-provider.js'; + + +export class ConnectToWebRTCRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ConnectToWebRTCRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsConnectToWebRTCRequest(bb:flatbuffers.ByteBuffer, obj?:ConnectToWebRTCRequest):ConnectToWebRTCRequest { + return (obj || new ConnectToWebRTCRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsConnectToWebRTCRequest(bb:flatbuffers.ByteBuffer, obj?:ConnectToWebRTCRequest):ConnectToWebRTCRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ConnectToWebRTCRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +provider():WebRTCVideoProvider { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : WebRTCVideoProvider.VIDEO_CALIBRATION; +} + +offerSdp():string|null +offerSdp(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +offerSdp(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startConnectToWebRTCRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addProvider(builder:flatbuffers.Builder, provider:WebRTCVideoProvider) { + builder.addFieldInt8(0, provider, WebRTCVideoProvider.VIDEO_CALIBRATION); +} + +static addOfferSdp(builder:flatbuffers.Builder, offerSdpOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, offerSdpOffset, 0); +} + +static endConnectToWebRTCRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createConnectToWebRTCRequest(builder:flatbuffers.Builder, provider:WebRTCVideoProvider, offerSdpOffset:flatbuffers.Offset):flatbuffers.Offset { + ConnectToWebRTCRequest.startConnectToWebRTCRequest(builder); + ConnectToWebRTCRequest.addProvider(builder, provider); + ConnectToWebRTCRequest.addOfferSdp(builder, offerSdpOffset); + return ConnectToWebRTCRequest.endConnectToWebRTCRequest(builder); +} + +unpack(): ConnectToWebRTCRequestT { + return new ConnectToWebRTCRequestT( + this.provider(), + this.offerSdp() + ); +} + + +unpackTo(_o: ConnectToWebRTCRequestT): void { + _o.provider = this.provider(); + _o.offerSdp = this.offerSdp(); +} +} + +export class ConnectToWebRTCRequestT implements flatbuffers.IGeneratedObject { +constructor( + public provider: WebRTCVideoProvider = WebRTCVideoProvider.VIDEO_CALIBRATION, + public offerSdp: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const offerSdp = (this.offerSdp !== null ? builder.createString(this.offerSdp!) : 0); + + return ConnectToWebRTCRequest.createConnectToWebRTCRequest(builder, + this.provider, + offerSdp + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcresponse.ts b/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcresponse.ts new file mode 100644 index 00000000..1ea1e686 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/connect-to-web-rtcresponse.ts @@ -0,0 +1,93 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class ConnectToWebRTCResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ConnectToWebRTCResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsConnectToWebRTCResponse(bb:flatbuffers.ByteBuffer, obj?:ConnectToWebRTCResponse):ConnectToWebRTCResponse { + return (obj || new ConnectToWebRTCResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsConnectToWebRTCResponse(bb:flatbuffers.ByteBuffer, obj?:ConnectToWebRTCResponse):ConnectToWebRTCResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ConnectToWebRTCResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +answerSdp():string|null +answerSdp(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +answerSdp(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; +} + +error():string|null +error(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +error(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startConnectToWebRTCResponse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addAnswerSdp(builder:flatbuffers.Builder, answerSdpOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, answerSdpOffset, 0); +} + +static addError(builder:flatbuffers.Builder, errorOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, errorOffset, 0); +} + +static endConnectToWebRTCResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createConnectToWebRTCResponse(builder:flatbuffers.Builder, answerSdpOffset:flatbuffers.Offset, errorOffset:flatbuffers.Offset):flatbuffers.Offset { + ConnectToWebRTCResponse.startConnectToWebRTCResponse(builder); + ConnectToWebRTCResponse.addAnswerSdp(builder, answerSdpOffset); + ConnectToWebRTCResponse.addError(builder, errorOffset); + return ConnectToWebRTCResponse.endConnectToWebRTCResponse(builder); +} + +unpack(): ConnectToWebRTCResponseT { + return new ConnectToWebRTCResponseT( + this.answerSdp(), + this.error() + ); +} + + +unpackTo(_o: ConnectToWebRTCResponseT): void { + _o.answerSdp = this.answerSdp(); + _o.error = this.error(); +} +} + +export class ConnectToWebRTCResponseT implements flatbuffers.IGeneratedObject { +constructor( + public answerSdp: string|Uint8Array|null = null, + public error: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const answerSdp = (this.answerSdp !== null ? builder.createString(this.answerSdp!) : 0); + const error = (this.error !== null ? builder.createString(this.error!) : 0); + + return ConnectToWebRTCResponse.createConnectToWebRTCResponse(builder, + answerSdp, + error + ); +} +} 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 45268429..5166a585 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -12,12 +12,15 @@ import { AutoBoneProcessRequest, AutoBoneProcessRequestT } from '../../solarxr-p import { AutoBoneProcessStatusResponse, AutoBoneProcessStatusResponseT } from '../../solarxr-protocol/rpc/auto-bone-process-status-response.js'; import { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from '../../solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; import { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from '../../solarxr-protocol/rpc/cancel-user-height-calibration.js'; +import { CancelVideoTrackerCalibrationRequest, CancelVideoTrackerCalibrationRequestT } from '../../solarxr-protocol/rpc/cancel-video-tracker-calibration-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; import { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from '../../solarxr-protocol/rpc/clear-drift-compensation-request.js'; import { ClearMountingResetRequest, ClearMountingResetRequestT } from '../../solarxr-protocol/rpc/clear-mounting-reset-request.js'; import { CloseSerialRequest, CloseSerialRequestT } from '../../solarxr-protocol/rpc/close-serial-request.js'; +import { ConnectToWebRTCRequest, ConnectToWebRTCRequestT } from '../../solarxr-protocol/rpc/connect-to-web-rtcrequest.js'; +import { ConnectToWebRTCResponse, ConnectToWebRTCResponseT } from '../../solarxr-protocol/rpc/connect-to-web-rtcresponse.js'; import { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; import { EnableStayAlignedRequest, EnableStayAlignedRequestT } from '../../solarxr-protocol/rpc/enable-stay-aligned-request.js'; import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-protocol/rpc/firmware-update-request.js'; @@ -65,6 +68,7 @@ import { SkeletonConfigRequest, SkeletonConfigRequestT } from '../../solarxr-pro import { SkeletonConfigResponse, SkeletonConfigResponseT } from '../../solarxr-protocol/rpc/skeleton-config-response.js'; import { SkeletonResetAllRequest, SkeletonResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-reset-all-request.js'; import { StartUserHeightCalibration, StartUserHeightCalibrationT } from '../../solarxr-protocol/rpc/start-user-height-calibration.js'; +import { StartVideoTrackerCalibrationRequest, StartVideoTrackerCalibrationRequestT } from '../../solarxr-protocol/rpc/start-video-tracker-calibration-request.js'; import { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/start-wifi-provisioning-request.js'; import { StatusSystemFixed, StatusSystemFixedT } from '../../solarxr-protocol/rpc/status-system-fixed.js'; import { StatusSystemRequest, StatusSystemRequestT } from '../../solarxr-protocol/rpc/status-system-request.js'; @@ -81,6 +85,7 @@ import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } 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 { VideoTrackerCalibrationProgressResponse, VideoTrackerCalibrationProgressResponseT } from '../../solarxr-protocol/rpc/video-tracker-calibration-progress-response.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -178,7 +183,7 @@ export class RpcMessageHeaderT implements flatbuffers.IGeneratedObject { constructor( public txId: TransactionIdT|null = null, public messageType: RpcMessage = RpcMessage.NONE, - public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|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|StartUserHeightCalibrationT|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|WifiProvisioningStatusResponseT|null = null + public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|CancelVideoTrackerCalibrationRequestT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|ConnectToWebRTCRequestT|ConnectToWebRTCResponseT|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|StartUserHeightCalibrationT|StartVideoTrackerCalibrationRequestT|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|VideoTrackerCalibrationProgressResponseT|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 76d9891b..d6c22277 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -9,12 +9,15 @@ import { AutoBoneProcessRequest, AutoBoneProcessRequestT } from '../../solarxr-p import { AutoBoneProcessStatusResponse, AutoBoneProcessStatusResponseT } from '../../solarxr-protocol/rpc/auto-bone-process-status-response.js'; import { AutoBoneStopRecordingRequest, AutoBoneStopRecordingRequestT } from '../../solarxr-protocol/rpc/auto-bone-stop-recording-request.js'; import { CancelUserHeightCalibration, CancelUserHeightCalibrationT } from '../../solarxr-protocol/rpc/cancel-user-height-calibration.js'; +import { CancelVideoTrackerCalibrationRequest, CancelVideoTrackerCalibrationRequestT } from '../../solarxr-protocol/rpc/cancel-video-tracker-calibration-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; import { ClearDriftCompensationRequest, ClearDriftCompensationRequestT } from '../../solarxr-protocol/rpc/clear-drift-compensation-request.js'; import { ClearMountingResetRequest, ClearMountingResetRequestT } from '../../solarxr-protocol/rpc/clear-mounting-reset-request.js'; import { CloseSerialRequest, CloseSerialRequestT } from '../../solarxr-protocol/rpc/close-serial-request.js'; +import { ConnectToWebRTCRequest, ConnectToWebRTCRequestT } from '../../solarxr-protocol/rpc/connect-to-web-rtcrequest.js'; +import { ConnectToWebRTCResponse, ConnectToWebRTCResponseT } from '../../solarxr-protocol/rpc/connect-to-web-rtcresponse.js'; import { DetectStayAlignedRelaxedPoseRequest, DetectStayAlignedRelaxedPoseRequestT } from '../../solarxr-protocol/rpc/detect-stay-aligned-relaxed-pose-request.js'; import { EnableStayAlignedRequest, EnableStayAlignedRequestT } from '../../solarxr-protocol/rpc/enable-stay-aligned-request.js'; import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-protocol/rpc/firmware-update-request.js'; @@ -61,6 +64,7 @@ import { SkeletonConfigRequest, SkeletonConfigRequestT } from '../../solarxr-pro import { SkeletonConfigResponse, SkeletonConfigResponseT } from '../../solarxr-protocol/rpc/skeleton-config-response.js'; import { SkeletonResetAllRequest, SkeletonResetAllRequestT } from '../../solarxr-protocol/rpc/skeleton-reset-all-request.js'; import { StartUserHeightCalibration, StartUserHeightCalibrationT } from '../../solarxr-protocol/rpc/start-user-height-calibration.js'; +import { StartVideoTrackerCalibrationRequest, StartVideoTrackerCalibrationRequestT } from '../../solarxr-protocol/rpc/start-video-tracker-calibration-request.js'; import { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from '../../solarxr-protocol/rpc/start-wifi-provisioning-request.js'; import { StatusSystemFixed, StatusSystemFixedT } from '../../solarxr-protocol/rpc/status-system-fixed.js'; import { StatusSystemRequest, StatusSystemRequestT } from '../../solarxr-protocol/rpc/status-system-request.js'; @@ -77,6 +81,7 @@ import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } 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 { VideoTrackerCalibrationProgressResponse, VideoTrackerCalibrationProgressResponseT } from '../../solarxr-protocol/rpc/video-tracker-calibration-progress-response.js'; import { WifiProvisioningStatusResponse, WifiProvisioningStatusResponseT } from '../../solarxr-protocol/rpc/wifi-provisioning-status-response.js'; @@ -159,13 +164,18 @@ export enum RpcMessage { IgnoreTrackingChecklistStepRequest = 75, StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, - UserHeightRecordingStatusResponse = 78 + UserHeightRecordingStatusResponse = 78, + ConnectToWebRTCRequest = 79, + ConnectToWebRTCResponse = 80, + StartVideoTrackerCalibrationRequest = 81, + CancelVideoTrackerCalibrationRequest = 82, + VideoTrackerCalibrationProgressResponse = 83 } export function unionToRpcMessage( type: RpcMessage, - accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { + accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse|null +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -246,15 +256,20 @@ export function unionToRpcMessage( case 'StartUserHeightCalibration': return accessor(new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'ConnectToWebRTCRequest': return accessor(new ConnectToWebRTCRequest())! as ConnectToWebRTCRequest; + case 'ConnectToWebRTCResponse': return accessor(new ConnectToWebRTCResponse())! as ConnectToWebRTCResponse; + case 'StartVideoTrackerCalibrationRequest': return accessor(new StartVideoTrackerCalibrationRequest())! as StartVideoTrackerCalibrationRequest; + case 'CancelVideoTrackerCalibrationRequest': return accessor(new CancelVideoTrackerCalibrationRequest())! as CancelVideoTrackerCalibrationRequest; + case 'VideoTrackerCalibrationProgressResponse': return accessor(new VideoTrackerCalibrationProgressResponse())! as VideoTrackerCalibrationProgressResponse; default: return null; } } export function unionListToRpcMessage( type: RpcMessage, - accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, + accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse|null, index: number -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|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|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|CancelVideoTrackerCalibrationRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|ConnectToWebRTCRequest|ConnectToWebRTCResponse|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|StartUserHeightCalibration|StartVideoTrackerCalibrationRequest|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|VideoTrackerCalibrationProgressResponse|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -335,6 +350,11 @@ export function unionListToRpcMessage( case 'StartUserHeightCalibration': return accessor(index, new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(index, new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(index, new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'ConnectToWebRTCRequest': return accessor(index, new ConnectToWebRTCRequest())! as ConnectToWebRTCRequest; + case 'ConnectToWebRTCResponse': return accessor(index, new ConnectToWebRTCResponse())! as ConnectToWebRTCResponse; + case 'StartVideoTrackerCalibrationRequest': return accessor(index, new StartVideoTrackerCalibrationRequest())! as StartVideoTrackerCalibrationRequest; + case 'CancelVideoTrackerCalibrationRequest': return accessor(index, new CancelVideoTrackerCalibrationRequest())! as CancelVideoTrackerCalibrationRequest; + case 'VideoTrackerCalibrationProgressResponse': return accessor(index, new VideoTrackerCalibrationProgressResponse())! as VideoTrackerCalibrationProgressResponse; default: return null; } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/start-video-tracker-calibration-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/start-video-tracker-calibration-request.ts new file mode 100644 index 00000000..57ff54cc --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/start-video-tracker-calibration-request.ts @@ -0,0 +1,54 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class StartVideoTrackerCalibrationRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):StartVideoTrackerCalibrationRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsStartVideoTrackerCalibrationRequest(bb:flatbuffers.ByteBuffer, obj?:StartVideoTrackerCalibrationRequest):StartVideoTrackerCalibrationRequest { + return (obj || new StartVideoTrackerCalibrationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsStartVideoTrackerCalibrationRequest(bb:flatbuffers.ByteBuffer, obj?:StartVideoTrackerCalibrationRequest):StartVideoTrackerCalibrationRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new StartVideoTrackerCalibrationRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startStartVideoTrackerCalibrationRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endStartVideoTrackerCalibrationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createStartVideoTrackerCalibrationRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + StartVideoTrackerCalibrationRequest.startStartVideoTrackerCalibrationRequest(builder); + return StartVideoTrackerCalibrationRequest.endStartVideoTrackerCalibrationRequest(builder); +} + +unpack(): StartVideoTrackerCalibrationRequestT { + return new StartVideoTrackerCalibrationRequestT(); +} + + +unpackTo(_o: StartVideoTrackerCalibrationRequestT): void {} +} + +export class StartVideoTrackerCalibrationRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return StartVideoTrackerCalibrationRequest.createStartVideoTrackerCalibrationRequest(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-camera.ts b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-camera.ts new file mode 100644 index 00000000..b34dc96d --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-camera.ts @@ -0,0 +1,161 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { Quat, QuatT } from '../../solarxr-protocol/datatypes/math/quat.js'; +import { Vec3f, Vec3fT } from '../../solarxr-protocol/datatypes/math/vec3f.js'; + + +export class VideoTrackerCalibrationCamera implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VideoTrackerCalibrationCamera { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVideoTrackerCalibrationCamera(bb:flatbuffers.ByteBuffer, obj?:VideoTrackerCalibrationCamera):VideoTrackerCalibrationCamera { + return (obj || new VideoTrackerCalibrationCamera()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVideoTrackerCalibrationCamera(bb:flatbuffers.ByteBuffer, obj?:VideoTrackerCalibrationCamera):VideoTrackerCalibrationCamera { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VideoTrackerCalibrationCamera()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +worldToCamera(obj?:Quat):Quat|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new Quat()).__init(this.bb_pos + offset, this.bb!) : null; +} + +worldOriginInCamera(obj?:Vec3f):Vec3f|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new Vec3f()).__init(this.bb_pos + offset, this.bb!) : null; +} + +fx():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +fy():number { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +tx():number { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +ty():number { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +width():number { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +} + +height():number { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +} + +static startVideoTrackerCalibrationCamera(builder:flatbuffers.Builder) { + builder.startObject(8); +} + +static addWorldToCamera(builder:flatbuffers.Builder, worldToCameraOffset:flatbuffers.Offset) { + builder.addFieldStruct(0, worldToCameraOffset, 0); +} + +static addWorldOriginInCamera(builder:flatbuffers.Builder, worldOriginInCameraOffset:flatbuffers.Offset) { + builder.addFieldStruct(1, worldOriginInCameraOffset, 0); +} + +static addFx(builder:flatbuffers.Builder, fx:number) { + builder.addFieldFloat32(2, fx, 0.0); +} + +static addFy(builder:flatbuffers.Builder, fy:number) { + builder.addFieldFloat32(3, fy, 0.0); +} + +static addTx(builder:flatbuffers.Builder, tx:number) { + builder.addFieldFloat32(4, tx, 0.0); +} + +static addTy(builder:flatbuffers.Builder, ty:number) { + builder.addFieldFloat32(5, ty, 0.0); +} + +static addWidth(builder:flatbuffers.Builder, width:number) { + builder.addFieldInt32(6, width, 0); +} + +static addHeight(builder:flatbuffers.Builder, height:number) { + builder.addFieldInt32(7, height, 0); +} + +static endVideoTrackerCalibrationCamera(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): VideoTrackerCalibrationCameraT { + return new VideoTrackerCalibrationCameraT( + (this.worldToCamera() !== null ? this.worldToCamera()!.unpack() : null), + (this.worldOriginInCamera() !== null ? this.worldOriginInCamera()!.unpack() : null), + this.fx(), + this.fy(), + this.tx(), + this.ty(), + this.width(), + this.height() + ); +} + + +unpackTo(_o: VideoTrackerCalibrationCameraT): void { + _o.worldToCamera = (this.worldToCamera() !== null ? this.worldToCamera()!.unpack() : null); + _o.worldOriginInCamera = (this.worldOriginInCamera() !== null ? this.worldOriginInCamera()!.unpack() : null); + _o.fx = this.fx(); + _o.fy = this.fy(); + _o.tx = this.tx(); + _o.ty = this.ty(); + _o.width = this.width(); + _o.height = this.height(); +} +} + +export class VideoTrackerCalibrationCameraT implements flatbuffers.IGeneratedObject { +constructor( + public worldToCamera: QuatT|null = null, + public worldOriginInCamera: Vec3fT|null = null, + public fx: number = 0.0, + public fy: number = 0.0, + public tx: number = 0.0, + public ty: number = 0.0, + public width: number = 0, + public height: number = 0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + VideoTrackerCalibrationCamera.startVideoTrackerCalibrationCamera(builder); + VideoTrackerCalibrationCamera.addWorldToCamera(builder, (this.worldToCamera !== null ? this.worldToCamera!.pack(builder) : 0)); + VideoTrackerCalibrationCamera.addWorldOriginInCamera(builder, (this.worldOriginInCamera !== null ? this.worldOriginInCamera!.pack(builder) : 0)); + VideoTrackerCalibrationCamera.addFx(builder, this.fx); + VideoTrackerCalibrationCamera.addFy(builder, this.fy); + VideoTrackerCalibrationCamera.addTx(builder, this.tx); + VideoTrackerCalibrationCamera.addTy(builder, this.ty); + VideoTrackerCalibrationCamera.addWidth(builder, this.width); + VideoTrackerCalibrationCamera.addHeight(builder, this.height); + + return VideoTrackerCalibrationCamera.endVideoTrackerCalibrationCamera(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-progress-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-progress-response.ts new file mode 100644 index 00000000..08730fd2 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-progress-response.ts @@ -0,0 +1,174 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { BodyPart } from '../../solarxr-protocol/datatypes/body-part.js'; +import { VideoTrackerCalibrationCamera, VideoTrackerCalibrationCameraT } from '../../solarxr-protocol/rpc/video-tracker-calibration-camera.js'; +import { VideoTrackerCalibrationStatus } from '../../solarxr-protocol/rpc/video-tracker-calibration-status.js'; + + +export class VideoTrackerCalibrationProgressResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):VideoTrackerCalibrationProgressResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsVideoTrackerCalibrationProgressResponse(bb:flatbuffers.ByteBuffer, obj?:VideoTrackerCalibrationProgressResponse):VideoTrackerCalibrationProgressResponse { + return (obj || new VideoTrackerCalibrationProgressResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsVideoTrackerCalibrationProgressResponse(bb:flatbuffers.ByteBuffer, obj?:VideoTrackerCalibrationProgressResponse):VideoTrackerCalibrationProgressResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new VideoTrackerCalibrationProgressResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +status():VideoTrackerCalibrationStatus { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : VideoTrackerCalibrationStatus.CALIBRATE_CAMERA; +} + +camera(obj?:VideoTrackerCalibrationCamera):VideoTrackerCalibrationCamera|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new VideoTrackerCalibrationCamera()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null; +} + +trackersDone(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; +} + +trackersDoneLength():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +trackersDoneArray():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; +} + +trackersPending(index: number):BodyPart|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +trackersPendingLength():number { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +trackersPendingArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 10); + 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; +} + +error():string|null +error(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +error(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startVideoTrackerCalibrationProgressResponse(builder:flatbuffers.Builder) { + builder.startObject(5); +} + +static addStatus(builder:flatbuffers.Builder, status:VideoTrackerCalibrationStatus) { + builder.addFieldInt8(0, status, VideoTrackerCalibrationStatus.CALIBRATE_CAMERA); +} + +static addCamera(builder:flatbuffers.Builder, cameraOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, cameraOffset, 0); +} + +static addTrackersDone(builder:flatbuffers.Builder, trackersDoneOffset:flatbuffers.Offset) { + builder.addFieldOffset(2, trackersDoneOffset, 0); +} + +static createTrackersDoneVector(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 startTrackersDoneVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static addTrackersPending(builder:flatbuffers.Builder, trackersPendingOffset:flatbuffers.Offset) { + builder.addFieldOffset(3, trackersPendingOffset, 0); +} + +static createTrackersPendingVector(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 startTrackersPendingVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static addError(builder:flatbuffers.Builder, errorOffset:flatbuffers.Offset) { + builder.addFieldOffset(4, errorOffset, 0); +} + +static endVideoTrackerCalibrationProgressResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + + +unpack(): VideoTrackerCalibrationProgressResponseT { + return new VideoTrackerCalibrationProgressResponseT( + this.status(), + (this.camera() !== null ? this.camera()!.unpack() : null), + this.bb!.createScalarList(this.trackersDone.bind(this), this.trackersDoneLength()), + this.bb!.createScalarList(this.trackersPending.bind(this), this.trackersPendingLength()), + this.error() + ); +} + + +unpackTo(_o: VideoTrackerCalibrationProgressResponseT): void { + _o.status = this.status(); + _o.camera = (this.camera() !== null ? this.camera()!.unpack() : null); + _o.trackersDone = this.bb!.createScalarList(this.trackersDone.bind(this), this.trackersDoneLength()); + _o.trackersPending = this.bb!.createScalarList(this.trackersPending.bind(this), this.trackersPendingLength()); + _o.error = this.error(); +} +} + +export class VideoTrackerCalibrationProgressResponseT implements flatbuffers.IGeneratedObject { +constructor( + public status: VideoTrackerCalibrationStatus = VideoTrackerCalibrationStatus.CALIBRATE_CAMERA, + public camera: VideoTrackerCalibrationCameraT|null = null, + public trackersDone: (BodyPart)[] = [], + public trackersPending: (BodyPart)[] = [], + public error: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const camera = (this.camera !== null ? this.camera!.pack(builder) : 0); + const trackersDone = VideoTrackerCalibrationProgressResponse.createTrackersDoneVector(builder, this.trackersDone); + const trackersPending = VideoTrackerCalibrationProgressResponse.createTrackersPendingVector(builder, this.trackersPending); + const error = (this.error !== null ? builder.createString(this.error!) : 0); + + VideoTrackerCalibrationProgressResponse.startVideoTrackerCalibrationProgressResponse(builder); + VideoTrackerCalibrationProgressResponse.addStatus(builder, this.status); + VideoTrackerCalibrationProgressResponse.addCamera(builder, camera); + VideoTrackerCalibrationProgressResponse.addTrackersDone(builder, trackersDone); + VideoTrackerCalibrationProgressResponse.addTrackersPending(builder, trackersPending); + VideoTrackerCalibrationProgressResponse.addError(builder, error); + + return VideoTrackerCalibrationProgressResponse.endVideoTrackerCalibrationProgressResponse(builder); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-status.ts b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-status.ts new file mode 100644 index 00000000..ef809472 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/video-tracker-calibration-status.ts @@ -0,0 +1,10 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum VideoTrackerCalibrationStatus { + CALIBRATE_CAMERA = 0, + CAPTURE_FORWARD_POSE = 1, + CAPTURE_BENT_OVER_POSE = 2, + CALIBRATE_TRACKERS = 3, + CALIBRATE_SKELETON_OFFSETS = 4, + DONE = 100 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/web-rtcvideo-provider.ts b/protocol/typescript/src/solarxr-protocol/rpc/web-rtcvideo-provider.ts new file mode 100644 index 00000000..9f06e84e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/web-rtcvideo-provider.ts @@ -0,0 +1,5 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum WebRTCVideoProvider { + VIDEO_CALIBRATION = 0 +} diff --git a/schema/rpc.fbs b/schema/rpc.fbs index c54f1504..f96e861f 100644 --- a/schema/rpc.fbs +++ b/schema/rpc.fbs @@ -95,7 +95,12 @@ union RpcMessage { IgnoreTrackingChecklistStepRequest, StartUserHeightCalibration, CancelUserHeightCalibration, - UserHeightRecordingStatusResponse + UserHeightRecordingStatusResponse, + ConnectToWebRTCRequest, + ConnectToWebRTCResponse, + StartVideoTrackerCalibrationRequest, + CancelVideoTrackerCalibrationRequest, + VideoTrackerCalibrationProgressResponse, } table RpcMessageHeader { @@ -1070,3 +1075,51 @@ table UserHeightRecordingStatusResponse { hmdHeight: float; status: UserHeightCalibrationStatus; } + +enum WebRTCVideoProvider: uint8 { + VIDEO_CALIBRATION = 0 +} + +table ConnectToWebRTCRequest { + provider: WebRTCVideoProvider; + offer_sdp: string; +} + +table ConnectToWebRTCResponse { + answer_sdp: string; + error: string; +} + +table StartVideoTrackerCalibrationRequest { +} + +table CancelVideoTrackerCalibrationRequest { +} + +enum VideoTrackerCalibrationStatus: uint8 { + CALIBRATE_CAMERA = 0, + CAPTURE_FORWARD_POSE = 1, + CAPTURE_BENT_OVER_POSE = 2, + CALIBRATE_TRACKERS = 3, + CALIBRATE_SKELETON_OFFSETS = 4, + DONE = 100, +} + +table VideoTrackerCalibrationCamera { + world_to_camera: solarxr_protocol.datatypes.math.Quat; + world_origin_in_camera: solarxr_protocol.datatypes.math.Vec3f; + fx: float32; + fy: float32; + tx: float32; + ty: float32; + width: int; + height: int; +} + +table VideoTrackerCalibrationProgressResponse { + status: VideoTrackerCalibrationStatus; + camera: VideoTrackerCalibrationCamera; + trackers_done: [solarxr_protocol.datatypes.BodyPart]; + trackers_pending: [solarxr_protocol.datatypes.BodyPart]; + error: string; +} diff --git a/solarxr-protocol.sln b/solarxr-protocol.sln new file mode 100644 index 00000000..e30346ec --- /dev/null +++ b/solarxr-protocol.sln @@ -0,0 +1,55 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.5.2.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "lib", "lib", "{3A8DF596-E814-FECC-DD4B-D8EF8AAC1A0D}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "flatbuffers", "flatbuffers", "{96059861-7A45-4FEF-A64B-5ABD0ACE4FBD}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "net", "net", "{C7A21C56-9437-B29C-969A-4392043DAC8F}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "FlatBuffers", "FlatBuffers", "{A92D184F-D093-76F6-247A-A3E8800DDF76}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Google.FlatBuffers", "lib\flatbuffers\net\FlatBuffers\Google.FlatBuffers.csproj", "{482F4893-B799-E52E-F33B-5507EE2C57A1}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{2A4410F6-1B2C-2E4D-877D-E7DC3C2FF91C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlatBuffers.Benchmarks", "lib\flatbuffers\tests\FlatBuffers.Benchmarks\FlatBuffers.Benchmarks.csproj", "{E9B14BA8-04FE-CF76-1D35-DA4D18547165}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlatBuffers.Test", "lib\flatbuffers\tests\FlatBuffers.Test\FlatBuffers.Test.csproj", "{B888672C-BFB1-6A12-319A-494BE1284D06}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {482F4893-B799-E52E-F33B-5507EE2C57A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {482F4893-B799-E52E-F33B-5507EE2C57A1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {482F4893-B799-E52E-F33B-5507EE2C57A1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {482F4893-B799-E52E-F33B-5507EE2C57A1}.Release|Any CPU.Build.0 = Release|Any CPU + {E9B14BA8-04FE-CF76-1D35-DA4D18547165}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E9B14BA8-04FE-CF76-1D35-DA4D18547165}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E9B14BA8-04FE-CF76-1D35-DA4D18547165}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E9B14BA8-04FE-CF76-1D35-DA4D18547165}.Release|Any CPU.Build.0 = Release|Any CPU + {B888672C-BFB1-6A12-319A-494BE1284D06}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B888672C-BFB1-6A12-319A-494BE1284D06}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B888672C-BFB1-6A12-319A-494BE1284D06}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B888672C-BFB1-6A12-319A-494BE1284D06}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {96059861-7A45-4FEF-A64B-5ABD0ACE4FBD} = {3A8DF596-E814-FECC-DD4B-D8EF8AAC1A0D} + {C7A21C56-9437-B29C-969A-4392043DAC8F} = {96059861-7A45-4FEF-A64B-5ABD0ACE4FBD} + {A92D184F-D093-76F6-247A-A3E8800DDF76} = {C7A21C56-9437-B29C-969A-4392043DAC8F} + {482F4893-B799-E52E-F33B-5507EE2C57A1} = {A92D184F-D093-76F6-247A-A3E8800DDF76} + {2A4410F6-1B2C-2E4D-877D-E7DC3C2FF91C} = {96059861-7A45-4FEF-A64B-5ABD0ACE4FBD} + {E9B14BA8-04FE-CF76-1D35-DA4D18547165} = {2A4410F6-1B2C-2E4D-877D-E7DC3C2FF91C} + {B888672C-BFB1-6A12-319A-494BE1284D06} = {2A4410F6-1B2C-2E4D-877D-E7DC3C2FF91C} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0B21B50B-A94E-4AE4-BDC6-D90A2FAD3727} + EndGlobalSection +EndGlobal