diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index e0ded2e2..f04855a9 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -146,6 +146,18 @@ struct ModelSettingsBuilder; } // namespace settings +struct Keybind; +struct KeybindBuilder; + +struct KeybindRequest; +struct KeybindRequestBuilder; + +struct KeybindResponse; +struct KeybindResponseBuilder; + +struct ChangeKeybindRequest; +struct ChangeKeybindRequestBuilder; + struct RpcMessageHeader; struct RpcMessageHeaderBuilder; @@ -1374,11 +1386,14 @@ enum class RpcMessage : uint8_t { StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, UserHeightRecordingStatusResponse = 78, + KeybindRequest = 79, + ChangeKeybindRequest = 80, + KeybindResponse = 81, MIN = NONE, - MAX = UserHeightRecordingStatusResponse + MAX = KeybindResponse }; -inline const RpcMessage (&EnumValuesRpcMessage())[79] { +inline const RpcMessage (&EnumValuesRpcMessage())[82] { static const RpcMessage values[] = { RpcMessage::NONE, RpcMessage::HeartbeatRequest, @@ -1458,13 +1473,16 @@ inline const RpcMessage (&EnumValuesRpcMessage())[79] { RpcMessage::IgnoreTrackingChecklistStepRequest, RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, - RpcMessage::UserHeightRecordingStatusResponse + RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::KeybindRequest, + RpcMessage::ChangeKeybindRequest, + RpcMessage::KeybindResponse }; return values; } inline const char * const *EnumNamesRpcMessage() { - static const char * const names[80] = { + static const char * const names[83] = { "NONE", "HeartbeatRequest", "HeartbeatResponse", @@ -1544,13 +1562,16 @@ inline const char * const *EnumNamesRpcMessage() { "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", + "KeybindRequest", + "ChangeKeybindRequest", + "KeybindResponse", 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::KeybindResponse)) return ""; const size_t index = static_cast(e); return EnumNamesRpcMessage()[index]; } @@ -1871,9 +1892,60 @@ template<> struct RpcMessageTraits struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::KeybindRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::ChangeKeybindRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::KeybindResponse; +}; + bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); +enum class KeybindName : uint8_t { + FULL_RESET = 0, + YAW_RESET = 1, + MOUNTING_RESET = 2, + PAUSE_TRACKING = 3, + FEET_MOUNTING_RESET = 4, + MIN = FULL_RESET, + MAX = FEET_MOUNTING_RESET +}; + +inline const KeybindName (&EnumValuesKeybindName())[5] { + static const KeybindName values[] = { + KeybindName::FULL_RESET, + KeybindName::YAW_RESET, + KeybindName::MOUNTING_RESET, + KeybindName::PAUSE_TRACKING, + KeybindName::FEET_MOUNTING_RESET + }; + return values; +} + +inline const char * const *EnumNamesKeybindName() { + static const char * const names[6] = { + "FULL_RESET", + "YAW_RESET", + "MOUNTING_RESET", + "PAUSE_TRACKING", + "FEET_MOUNTING_RESET", + nullptr + }; + return names; +} + +inline const char *EnumNameKeybindName(KeybindName e) { + if (flatbuffers::IsOutRange(e, KeybindName::FULL_RESET, KeybindName::FEET_MOUNTING_RESET)) return ""; + const size_t index = static_cast(e); + return EnumNamesKeybindName()[index]; +} + enum class ResetType : uint8_t { Yaw = 0, Full = 1, @@ -5810,6 +5882,226 @@ inline flatbuffers::Offset CreateModelSettings( } // namespace settings +struct Keybind FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND_NAME = 4, + VT_KEYBIND_VALUE = 6, + VT_KEYBIND_DELAY = 8 + }; + solarxr_protocol::rpc::KeybindName keybind_name() const { + return static_cast(GetField(VT_KEYBIND_NAME, 0)); + } + const flatbuffers::String *keybind_value() const { + return GetPointer(VT_KEYBIND_VALUE); + } + float keybind_delay() const { + return GetField(VT_KEYBIND_DELAY, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_KEYBIND_NAME, 1) && + VerifyOffset(verifier, VT_KEYBIND_VALUE) && + verifier.VerifyString(keybind_value()) && + VerifyField(verifier, VT_KEYBIND_DELAY, 4) && + verifier.EndTable(); + } +}; + +struct KeybindBuilder { + typedef Keybind Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind_name(solarxr_protocol::rpc::KeybindName keybind_name) { + fbb_.AddElement(Keybind::VT_KEYBIND_NAME, static_cast(keybind_name), 0); + } + void add_keybind_value(flatbuffers::Offset keybind_value) { + fbb_.AddOffset(Keybind::VT_KEYBIND_VALUE, keybind_value); + } + void add_keybind_delay(float keybind_delay) { + fbb_.AddElement(Keybind::VT_KEYBIND_DELAY, keybind_delay, 0.0f); + } + explicit KeybindBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateKeybind( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindName keybind_name = solarxr_protocol::rpc::KeybindName::FULL_RESET, + flatbuffers::Offset keybind_value = 0, + float keybind_delay = 0.0f) { + KeybindBuilder builder_(_fbb); + builder_.add_keybind_delay(keybind_delay); + builder_.add_keybind_value(keybind_value); + builder_.add_keybind_name(keybind_name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateKeybindDirect( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindName keybind_name = solarxr_protocol::rpc::KeybindName::FULL_RESET, + const char *keybind_value = nullptr, + float keybind_delay = 0.0f) { + auto keybind_value__ = keybind_value ? _fbb.CreateString(keybind_value) : 0; + return solarxr_protocol::rpc::CreateKeybind( + _fbb, + keybind_name, + keybind_value__, + keybind_delay); +} + +struct KeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND_NAME = 4 + }; + solarxr_protocol::rpc::KeybindName keybind_name() const { + return static_cast(GetField(VT_KEYBIND_NAME, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_KEYBIND_NAME, 1) && + verifier.EndTable(); + } +}; + +struct KeybindRequestBuilder { + typedef KeybindRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind_name(solarxr_protocol::rpc::KeybindName keybind_name) { + fbb_.AddElement(KeybindRequest::VT_KEYBIND_NAME, static_cast(keybind_name), 0); + } + explicit KeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateKeybindRequest( + flatbuffers::FlatBufferBuilder &_fbb, + solarxr_protocol::rpc::KeybindName keybind_name = solarxr_protocol::rpc::KeybindName::FULL_RESET) { + KeybindRequestBuilder builder_(_fbb); + builder_.add_keybind_name(keybind_name); + return builder_.Finish(); +} + +struct KeybindResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef KeybindResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND = 4 + }; + const flatbuffers::Vector> *keybind() const { + return GetPointer> *>(VT_KEYBIND); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_KEYBIND) && + verifier.VerifyVector(keybind()) && + verifier.VerifyVectorOfTables(keybind()) && + verifier.EndTable(); + } +}; + +struct KeybindResponseBuilder { + typedef KeybindResponse Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind(flatbuffers::Offset>> keybind) { + fbb_.AddOffset(KeybindResponse::VT_KEYBIND, keybind); + } + explicit KeybindResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateKeybindResponse( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> keybind = 0) { + KeybindResponseBuilder builder_(_fbb); + builder_.add_keybind(keybind); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateKeybindResponseDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *keybind = nullptr) { + auto keybind__ = keybind ? _fbb.CreateVector>(*keybind) : 0; + return solarxr_protocol::rpc::CreateKeybindResponse( + _fbb, + keybind__); +} + +struct ChangeKeybindRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ChangeKeybindRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_KEYBIND = 4 + }; + const flatbuffers::Vector> *keybind() const { + return GetPointer> *>(VT_KEYBIND); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_KEYBIND) && + verifier.VerifyVector(keybind()) && + verifier.VerifyVectorOfTables(keybind()) && + verifier.EndTable(); + } +}; + +struct ChangeKeybindRequestBuilder { + typedef ChangeKeybindRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_keybind(flatbuffers::Offset>> keybind) { + fbb_.AddOffset(ChangeKeybindRequest::VT_KEYBIND, keybind); + } + explicit ChangeKeybindRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateChangeKeybindRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> keybind = 0) { + ChangeKeybindRequestBuilder builder_(_fbb); + builder_.add_keybind(keybind); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateChangeKeybindRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *keybind = nullptr) { + auto keybind__ = keybind ? _fbb.CreateVector>(*keybind) : 0; + return solarxr_protocol::rpc::CreateChangeKeybindRequest( + _fbb, + keybind__); +} + struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { typedef RpcMessageHeaderBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { @@ -6063,6 +6355,15 @@ 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::KeybindRequest *message_as_KeybindRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::ChangeKeybindRequest *message_as_ChangeKeybindRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::ChangeKeybindRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::KeybindResponse *message_as_KeybindResponse() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::KeybindResponse ? static_cast(message()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TX_ID, 4) && @@ -6385,6 +6686,18 @@ template<> inline const solarxr_protocol::rpc::UserHeightRecordingStatusResponse return message_as_UserHeightRecordingStatusResponse(); } +template<> inline const solarxr_protocol::rpc::KeybindRequest *RpcMessageHeader::message_as() const { + return message_as_KeybindRequest(); +} + +template<> inline const solarxr_protocol::rpc::ChangeKeybindRequest *RpcMessageHeader::message_as() const { + return message_as_ChangeKeybindRequest(); +} + +template<> inline const solarxr_protocol::rpc::KeybindResponse *RpcMessageHeader::message_as() const { + return message_as_KeybindResponse(); +} + struct RpcMessageHeaderBuilder { typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -14462,6 +14775,18 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::KeybindRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::ChangeKeybindRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::KeybindResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequest.java b/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequest.java new file mode 100644 index 00000000..c2053b9a --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequest.java @@ -0,0 +1,70 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class ChangeKeybindRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static ChangeKeybindRequest getRootAsChangeKeybindRequest(ByteBuffer _bb) { return getRootAsChangeKeybindRequest(_bb, new ChangeKeybindRequest()); } + public static ChangeKeybindRequest getRootAsChangeKeybindRequest(ByteBuffer _bb, ChangeKeybindRequest 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 ChangeKeybindRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.rpc.Keybind keybind(int j) { return keybind(new solarxr_protocol.rpc.Keybind(), j); } + public solarxr_protocol.rpc.Keybind keybind(solarxr_protocol.rpc.Keybind obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int keybindLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.rpc.Keybind.Vector keybindVector() { return keybindVector(new solarxr_protocol.rpc.Keybind.Vector()); } + public solarxr_protocol.rpc.Keybind.Vector keybindVector(solarxr_protocol.rpc.Keybind.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createChangeKeybindRequest(FlatBufferBuilder builder, + int keybindOffset) { + builder.startTable(1); + ChangeKeybindRequest.addKeybind(builder, keybindOffset); + return ChangeKeybindRequest.endChangeKeybindRequest(builder); + } + + public static void startChangeKeybindRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addKeybind(FlatBufferBuilder builder, int keybindOffset) { builder.addOffset(0, keybindOffset, 0); } + public static int createKeybindVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startKeybindVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endChangeKeybindRequest(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 ChangeKeybindRequest get(int j) { return get(new ChangeKeybindRequest(), j); } + public ChangeKeybindRequest get(ChangeKeybindRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public ChangeKeybindRequestT unpack() { + ChangeKeybindRequestT _o = new ChangeKeybindRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(ChangeKeybindRequestT _o) { + solarxr_protocol.rpc.KeybindT[] _oKeybind = new solarxr_protocol.rpc.KeybindT[keybindLength()]; + for (int _j = 0; _j < keybindLength(); ++_j) {_oKeybind[_j] = (keybind(_j) != null ? keybind(_j).unpack() : null);} + _o.setKeybind(_oKeybind); + } + public static int pack(FlatBufferBuilder builder, ChangeKeybindRequestT _o) { + if (_o == null) return 0; + int _keybind = 0; + if (_o.getKeybind() != null) { + int[] __keybind = new int[_o.getKeybind().length]; + int _j = 0; + for (solarxr_protocol.rpc.KeybindT _e : _o.getKeybind()) { __keybind[_j] = solarxr_protocol.rpc.Keybind.pack(builder, _e); _j++;} + _keybind = createKeybindVector(builder, __keybind); + } + return createChangeKeybindRequest( + builder, + _keybind); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequestT.java b/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequestT.java new file mode 100644 index 00000000..094c5edc --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/ChangeKeybindRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class ChangeKeybindRequestT { + private solarxr_protocol.rpc.KeybindT[] keybind; + + public solarxr_protocol.rpc.KeybindT[] getKeybind() { return keybind; } + + public void setKeybind(solarxr_protocol.rpc.KeybindT[] keybind) { this.keybind = keybind; } + + + public ChangeKeybindRequestT() { + this.keybind = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/Keybind.java b/protocol/java/src/solarxr_protocol/rpc/Keybind.java new file mode 100644 index 00000000..302f25e3 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/Keybind.java @@ -0,0 +1,73 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class Keybind extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static Keybind getRootAsKeybind(ByteBuffer _bb) { return getRootAsKeybind(_bb, new Keybind()); } + public static Keybind getRootAsKeybind(ByteBuffer _bb, Keybind 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 Keybind __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int keybindName() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public String keybindValue() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer keybindValueAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer keybindValueInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + public float keybindDelay() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + + public static int createKeybind(FlatBufferBuilder builder, + int keybindName, + int keybindValueOffset, + float keybindDelay) { + builder.startTable(3); + Keybind.addKeybindDelay(builder, keybindDelay); + Keybind.addKeybindValue(builder, keybindValueOffset); + Keybind.addKeybindName(builder, keybindName); + return Keybind.endKeybind(builder); + } + + public static void startKeybind(FlatBufferBuilder builder) { builder.startTable(3); } + public static void addKeybindName(FlatBufferBuilder builder, int keybindName) { builder.addByte(0, (byte) keybindName, (byte) 0); } + public static void addKeybindValue(FlatBufferBuilder builder, int keybindValueOffset) { builder.addOffset(1, keybindValueOffset, 0); } + public static void addKeybindDelay(FlatBufferBuilder builder, float keybindDelay) { builder.addFloat(2, keybindDelay, 0.0f); } + public static int endKeybind(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 Keybind get(int j) { return get(new Keybind(), j); } + public Keybind get(Keybind obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public KeybindT unpack() { + KeybindT _o = new KeybindT(); + unpackTo(_o); + return _o; + } + public void unpackTo(KeybindT _o) { + int _oKeybindName = keybindName(); + _o.setKeybindName(_oKeybindName); + String _oKeybindValue = keybindValue(); + _o.setKeybindValue(_oKeybindValue); + float _oKeybindDelay = keybindDelay(); + _o.setKeybindDelay(_oKeybindDelay); + } + public static int pack(FlatBufferBuilder builder, KeybindT _o) { + if (_o == null) return 0; + int _keybindValue = _o.getKeybindValue() == null ? 0 : builder.createString(_o.getKeybindValue()); + return createKeybind( + builder, + _o.getKeybindName(), + _keybindValue, + _o.getKeybindDelay()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindName.java b/protocol/java/src/solarxr_protocol/rpc/KeybindName.java new file mode 100644 index 00000000..f8b1c6a8 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindName.java @@ -0,0 +1,18 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +@SuppressWarnings("unused") +public final class KeybindName { + private KeybindName() { } + public static final int FULL_RESET = 0; + public static final int YAW_RESET = 1; + public static final int MOUNTING_RESET = 2; + public static final int PAUSE_TRACKING = 3; + public static final int FEET_MOUNTING_RESET = 4; + + public static final String[] names = { "FULL_RESET", "YAW_RESET", "MOUNTING_RESET", "PAUSE_TRACKING", "FEET_MOUNTING_RESET", }; + + public static String name(int e) { return names[e]; } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java b/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java new file mode 100644 index 00000000..435e0a85 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindRequest.java @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class KeybindRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static KeybindRequest getRootAsKeybindRequest(ByteBuffer _bb) { return getRootAsKeybindRequest(_bb, new KeybindRequest()); } + public static KeybindRequest getRootAsKeybindRequest(ByteBuffer _bb, KeybindRequest 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 KeybindRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public int keybindName() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + + public static int createKeybindRequest(FlatBufferBuilder builder, + int keybindName) { + builder.startTable(1); + KeybindRequest.addKeybindName(builder, keybindName); + return KeybindRequest.endKeybindRequest(builder); + } + + public static void startKeybindRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addKeybindName(FlatBufferBuilder builder, int keybindName) { builder.addByte(0, (byte) keybindName, (byte) 0); } + public static int endKeybindRequest(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 KeybindRequest get(int j) { return get(new KeybindRequest(), j); } + public KeybindRequest get(KeybindRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public KeybindRequestT unpack() { + KeybindRequestT _o = new KeybindRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(KeybindRequestT _o) { + int _oKeybindName = keybindName(); + _o.setKeybindName(_oKeybindName); + } + public static int pack(FlatBufferBuilder builder, KeybindRequestT _o) { + if (_o == null) return 0; + return createKeybindRequest( + builder, + _o.getKeybindName()); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindRequestT.java b/protocol/java/src/solarxr_protocol/rpc/KeybindRequestT.java new file mode 100644 index 00000000..9e89aa05 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class KeybindRequestT { + private int keybindName; + + public int getKeybindName() { return keybindName; } + + public void setKeybindName(int keybindName) { this.keybindName = keybindName; } + + + public KeybindRequestT() { + this.keybindName = 0; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java b/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java new file mode 100644 index 00000000..afd24640 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindResponse.java @@ -0,0 +1,70 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class KeybindResponse extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static KeybindResponse getRootAsKeybindResponse(ByteBuffer _bb) { return getRootAsKeybindResponse(_bb, new KeybindResponse()); } + public static KeybindResponse getRootAsKeybindResponse(ByteBuffer _bb, KeybindResponse 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 KeybindResponse __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public solarxr_protocol.rpc.Keybind keybind(int j) { return keybind(new solarxr_protocol.rpc.Keybind(), j); } + public solarxr_protocol.rpc.Keybind keybind(solarxr_protocol.rpc.Keybind obj, int j) { int o = __offset(4); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int keybindLength() { int o = __offset(4); return o != 0 ? __vector_len(o) : 0; } + public solarxr_protocol.rpc.Keybind.Vector keybindVector() { return keybindVector(new solarxr_protocol.rpc.Keybind.Vector()); } + public solarxr_protocol.rpc.Keybind.Vector keybindVector(solarxr_protocol.rpc.Keybind.Vector obj) { int o = __offset(4); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createKeybindResponse(FlatBufferBuilder builder, + int keybindOffset) { + builder.startTable(1); + KeybindResponse.addKeybind(builder, keybindOffset); + return KeybindResponse.endKeybindResponse(builder); + } + + public static void startKeybindResponse(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addKeybind(FlatBufferBuilder builder, int keybindOffset) { builder.addOffset(0, keybindOffset, 0); } + public static int createKeybindVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startKeybindVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endKeybindResponse(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 KeybindResponse get(int j) { return get(new KeybindResponse(), j); } + public KeybindResponse get(KeybindResponse obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public KeybindResponseT unpack() { + KeybindResponseT _o = new KeybindResponseT(); + unpackTo(_o); + return _o; + } + public void unpackTo(KeybindResponseT _o) { + solarxr_protocol.rpc.KeybindT[] _oKeybind = new solarxr_protocol.rpc.KeybindT[keybindLength()]; + for (int _j = 0; _j < keybindLength(); ++_j) {_oKeybind[_j] = (keybind(_j) != null ? keybind(_j).unpack() : null);} + _o.setKeybind(_oKeybind); + } + public static int pack(FlatBufferBuilder builder, KeybindResponseT _o) { + if (_o == null) return 0; + int _keybind = 0; + if (_o.getKeybind() != null) { + int[] __keybind = new int[_o.getKeybind().length]; + int _j = 0; + for (solarxr_protocol.rpc.KeybindT _e : _o.getKeybind()) { __keybind[_j] = solarxr_protocol.rpc.Keybind.pack(builder, _e); _j++;} + _keybind = createKeybindVector(builder, __keybind); + } + return createKeybindResponse( + builder, + _keybind); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindResponseT.java b/protocol/java/src/solarxr_protocol/rpc/KeybindResponseT.java new file mode 100644 index 00000000..4d43b5ad --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindResponseT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class KeybindResponseT { + private solarxr_protocol.rpc.KeybindT[] keybind; + + public solarxr_protocol.rpc.KeybindT[] getKeybind() { return keybind; } + + public void setKeybind(solarxr_protocol.rpc.KeybindT[] keybind) { this.keybind = keybind; } + + + public KeybindResponseT() { + this.keybind = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/KeybindT.java b/protocol/java/src/solarxr_protocol/rpc/KeybindT.java new file mode 100644 index 00000000..2fa89f62 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/KeybindT.java @@ -0,0 +1,34 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class KeybindT { + private int keybindName; + private String keybindValue; + private float keybindDelay; + + public int getKeybindName() { return keybindName; } + + public void setKeybindName(int keybindName) { this.keybindName = keybindName; } + + public String getKeybindValue() { return keybindValue; } + + public void setKeybindValue(String keybindValue) { this.keybindValue = keybindValue; } + + public float getKeybindDelay() { return keybindDelay; } + + public void setKeybindDelay(float keybindDelay) { this.keybindDelay = keybindDelay; } + + + public KeybindT() { + this.keybindName = 0; + this.keybindValue = null; + this.keybindDelay = 0.0f; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index 5435c77b..8c7b0ac5 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -84,8 +84,11 @@ private RpcMessage() { } public static final byte StartUserHeightCalibration = 76; public static final byte CancelUserHeightCalibration = 77; public static final byte UserHeightRecordingStatusResponse = 78; + public static final byte KeybindRequest = 79; + public static final byte ChangeKeybindRequest = 80; + public static final byte KeybindResponse = 81; - public static final 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", "KeybindRequest", "ChangeKeybindRequest", "KeybindResponse", }; 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..0001a2d5 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -364,6 +364,18 @@ 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.KeybindRequest: + _oMessageValue = message(new solarxr_protocol.rpc.KeybindRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.KeybindRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.ChangeKeybindRequest: + _oMessageValue = message(new solarxr_protocol.rpc.ChangeKeybindRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.ChangeKeybindRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.KeybindResponse: + _oMessageValue = message(new solarxr_protocol.rpc.KeybindResponse()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.KeybindResponse) _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..b47b278d 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -99,6 +99,9 @@ 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.KeybindRequestT asKeybindRequest() { return (solarxr_protocol.rpc.KeybindRequestT) value; } + public solarxr_protocol.rpc.ChangeKeybindRequestT asChangeKeybindRequest() { return (solarxr_protocol.rpc.ChangeKeybindRequestT) value; } + public solarxr_protocol.rpc.KeybindResponseT asKeybindResponse() { return (solarxr_protocol.rpc.KeybindResponseT) value; } public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { switch (_o.type) { @@ -180,6 +183,9 @@ 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.KeybindRequest: return solarxr_protocol.rpc.KeybindRequest.pack(builder, _o.asKeybindRequest()); + case RpcMessage.ChangeKeybindRequest: return solarxr_protocol.rpc.ChangeKeybindRequest.pack(builder, _o.asChangeKeybindRequest()); + case RpcMessage.KeybindResponse: return solarxr_protocol.rpc.KeybindResponse.pack(builder, _o.asKeybindResponse()); default: return 0; } } diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/ChangeKeybindRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/ChangeKeybindRequest.kt new file mode 100644 index 00000000..e612ba50 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/ChangeKeybindRequest.kt @@ -0,0 +1,68 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class ChangeKeybindRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : ChangeKeybindRequest { + __init(_i, _bb) + return this + } + fun keybind(j: Int) : solarxr_protocol.rpc.Keybind? = keybind(solarxr_protocol.rpc.Keybind(), j) + fun keybind(obj: solarxr_protocol.rpc.Keybind, j: Int) : solarxr_protocol.rpc.Keybind? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val keybindLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsChangeKeybindRequest(_bb: ByteBuffer): ChangeKeybindRequest = getRootAsChangeKeybindRequest(_bb, ChangeKeybindRequest()) + @JvmStatic + fun getRootAsChangeKeybindRequest(_bb: ByteBuffer, obj: ChangeKeybindRequest): ChangeKeybindRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createChangeKeybindRequest(builder: FlatBufferBuilder, keybindOffset: Int) : Int { + builder.startTable(1) + addKeybind(builder, keybindOffset) + return endChangeKeybindRequest(builder) + } + @JvmStatic + fun startChangeKeybindRequest(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addKeybind(builder: FlatBufferBuilder, keybind: Int) = builder.addOffset(0, keybind, 0) + @JvmStatic + fun createKeybindVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startKeybindVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endChangeKeybindRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/Keybind.kt b/protocol/kotlin/src/solarxr_protocol/rpc/Keybind.kt new file mode 100644 index 00000000..9d1b17c0 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/Keybind.kt @@ -0,0 +1,68 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class Keybind : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : Keybind { + __init(_i, _bb) + return this + } + val keybindName : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + val keybindValue : String? + get() { + val o = __offset(6) + return if (o != 0) __string(o + bb_pos) else null + } + val keybindValueAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun keybindValueInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + val keybindDelay : Float + get() { + val o = __offset(8) + return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsKeybind(_bb: ByteBuffer): Keybind = getRootAsKeybind(_bb, Keybind()) + @JvmStatic + fun getRootAsKeybind(_bb: ByteBuffer, obj: Keybind): Keybind { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createKeybind(builder: FlatBufferBuilder, keybindName: UByte, keybindValueOffset: Int, keybindDelay: Float) : Int { + builder.startTable(3) + addKeybindDelay(builder, keybindDelay) + addKeybindValue(builder, keybindValueOffset) + addKeybindName(builder, keybindName) + return endKeybind(builder) + } + @JvmStatic + fun startKeybind(builder: FlatBufferBuilder) = builder.startTable(3) + @JvmStatic + fun addKeybindName(builder: FlatBufferBuilder, keybindName: UByte) = builder.addByte(0, keybindName.toByte(), 0) + @JvmStatic + fun addKeybindValue(builder: FlatBufferBuilder, keybindValue: Int) = builder.addOffset(1, keybindValue, 0) + @JvmStatic + fun addKeybindDelay(builder: FlatBufferBuilder, keybindDelay: Float) = builder.addFloat(2, keybindDelay, 0.0) + @JvmStatic + fun endKeybind(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/KeybindName.kt b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindName.kt new file mode 100644 index 00000000..4bd6159e --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindName.kt @@ -0,0 +1,17 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +@Suppress("unused") +class KeybindName private constructor() { + companion object { + const val FULLRESET: UByte = 0u + const val YAWRESET: UByte = 1u + const val MOUNTINGRESET: UByte = 2u + const val PAUSETRACKING: UByte = 3u + const val FEETMOUNTINGRESET: UByte = 4u + val names : Array = arrayOf("FULL_RESET", "YAW_RESET", "MOUNTING_RESET", "PAUSE_TRACKING", "FEET_MOUNTING_RESET") + @JvmStatic + fun name(e: Int) : String = names[e] + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/KeybindRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindRequest.kt new file mode 100644 index 00000000..b4511984 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindRequest.kt @@ -0,0 +1,50 @@ +// 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 KeybindRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : KeybindRequest { + __init(_i, _bb) + return this + } + val keybindName : UByte + get() { + val o = __offset(4) + return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsKeybindRequest(_bb: ByteBuffer): KeybindRequest = getRootAsKeybindRequest(_bb, KeybindRequest()) + @JvmStatic + fun getRootAsKeybindRequest(_bb: ByteBuffer, obj: KeybindRequest): KeybindRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createKeybindRequest(builder: FlatBufferBuilder, keybindName: UByte) : Int { + builder.startTable(1) + addKeybindName(builder, keybindName) + return endKeybindRequest(builder) + } + @JvmStatic + fun startKeybindRequest(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addKeybindName(builder: FlatBufferBuilder, keybindName: UByte) = builder.addByte(0, keybindName.toByte(), 0) + @JvmStatic + fun endKeybindRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/KeybindResponse.kt b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindResponse.kt new file mode 100644 index 00000000..aea76955 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/KeybindResponse.kt @@ -0,0 +1,68 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class KeybindResponse : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : KeybindResponse { + __init(_i, _bb) + return this + } + fun keybind(j: Int) : solarxr_protocol.rpc.Keybind? = keybind(solarxr_protocol.rpc.Keybind(), j) + fun keybind(obj: solarxr_protocol.rpc.Keybind, j: Int) : solarxr_protocol.rpc.Keybind? { + val o = __offset(4) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val keybindLength : Int + get() { + val o = __offset(4); return if (o != 0) __vector_len(o) else 0 + } + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsKeybindResponse(_bb: ByteBuffer): KeybindResponse = getRootAsKeybindResponse(_bb, KeybindResponse()) + @JvmStatic + fun getRootAsKeybindResponse(_bb: ByteBuffer, obj: KeybindResponse): KeybindResponse { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createKeybindResponse(builder: FlatBufferBuilder, keybindOffset: Int) : Int { + builder.startTable(1) + addKeybind(builder, keybindOffset) + return endKeybindResponse(builder) + } + @JvmStatic + fun startKeybindResponse(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addKeybind(builder: FlatBufferBuilder, keybind: Int) = builder.addOffset(0, keybind, 0) + @JvmStatic + fun createKeybindVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + @JvmStatic + fun startKeybindVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + @JvmStatic + fun endKeybindResponse(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..6061068e 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt @@ -84,7 +84,10 @@ 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 KeybindRequest: UByte = 79u + const val ChangeKeybindRequest: UByte = 80u + const val KeybindResponse: UByte = 81u + val names : Array = arrayOf("NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "KeybindRequest", "ChangeKeybindRequest", "KeybindResponse") @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..30077b62 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -150,6 +150,8 @@ pub mod solarxr_protocol { } // settings mod rpc_message_generated; pub use self::rpc_message_generated::*; + mod keybind_name_generated; + pub use self::keybind_name_generated::*; mod reset_type_generated; pub use self::reset_type_generated::*; mod reset_status_generated; @@ -188,6 +190,14 @@ 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 keybind_generated; + pub use self::keybind_generated::*; + mod keybind_request_generated; + pub use self::keybind_request_generated::*; + mod keybind_response_generated; + pub use self::keybind_response_generated::*; + mod change_keybind_request_generated; + pub use self::change_keybind_request_generated::*; mod rpc_message_header_generated; pub use self::rpc_message_header_generated::*; mod heartbeat_request_generated; diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/change_keybind_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/change_keybind_request_generated.rs new file mode 100644 index 00000000..7f0b77d9 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/change_keybind_request_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum ChangeKeybindRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct ChangeKeybindRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for ChangeKeybindRequest<'a> { + type Inner = ChangeKeybindRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> ChangeKeybindRequest<'a> { + pub const VT_KEYBIND: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + ChangeKeybindRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args ChangeKeybindRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = ChangeKeybindRequestBuilder::new(_fbb); + if let Some(x) = args.keybind { builder.add_keybind(x); } + builder.finish() + } + + + #[inline] + pub fn keybind(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(ChangeKeybindRequest::VT_KEYBIND, None)} + } +} + +impl flatbuffers::Verifiable for ChangeKeybindRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("keybind", Self::VT_KEYBIND, false)? + .finish(); + Ok(()) + } +} +pub struct ChangeKeybindRequestArgs<'a> { + pub keybind: Option>>>>, +} +impl<'a> Default for ChangeKeybindRequestArgs<'a> { + #[inline] + fn default() -> Self { + ChangeKeybindRequestArgs { + keybind: None, + } + } +} + +pub struct ChangeKeybindRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> ChangeKeybindRequestBuilder<'a, 'b> { + #[inline] + pub fn add_keybind(&mut self, keybind: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(ChangeKeybindRequest::VT_KEYBIND, keybind); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ChangeKeybindRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + ChangeKeybindRequestBuilder { + 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 ChangeKeybindRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("ChangeKeybindRequest"); + ds.field("keybind", &self.keybind()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_generated.rs new file mode 100644 index 00000000..271ab010 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_generated.rs @@ -0,0 +1,142 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum KeybindOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct Keybind<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for Keybind<'a> { + type Inner = Keybind<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> Keybind<'a> { + pub const VT_KEYBIND_NAME: flatbuffers::VOffsetT = 4; + pub const VT_KEYBIND_VALUE: flatbuffers::VOffsetT = 6; + pub const VT_KEYBIND_DELAY: flatbuffers::VOffsetT = 8; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + Keybind { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args KeybindArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = KeybindBuilder::new(_fbb); + builder.add_keybind_delay(args.keybind_delay); + if let Some(x) = args.keybind_value { builder.add_keybind_value(x); } + builder.add_keybind_name(args.keybind_name); + builder.finish() + } + + + #[inline] + pub fn keybind_name(&self) -> KeybindName { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Keybind::VT_KEYBIND_NAME, Some(KeybindName::FULL_RESET)).unwrap()} + } + #[inline] + pub fn keybind_value(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(Keybind::VT_KEYBIND_VALUE, None)} + } + #[inline] + pub fn keybind_delay(&self) -> f32 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Keybind::VT_KEYBIND_DELAY, Some(0.0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for Keybind<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("keybind_name", Self::VT_KEYBIND_NAME, false)? + .visit_field::>("keybind_value", Self::VT_KEYBIND_VALUE, false)? + .visit_field::("keybind_delay", Self::VT_KEYBIND_DELAY, false)? + .finish(); + Ok(()) + } +} +pub struct KeybindArgs<'a> { + pub keybind_name: KeybindName, + pub keybind_value: Option>, + pub keybind_delay: f32, +} +impl<'a> Default for KeybindArgs<'a> { + #[inline] + fn default() -> Self { + KeybindArgs { + keybind_name: KeybindName::FULL_RESET, + keybind_value: None, + keybind_delay: 0.0, + } + } +} + +pub struct KeybindBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> KeybindBuilder<'a, 'b> { + #[inline] + pub fn add_keybind_name(&mut self, keybind_name: KeybindName) { + self.fbb_.push_slot::(Keybind::VT_KEYBIND_NAME, keybind_name, KeybindName::FULL_RESET); + } + #[inline] + pub fn add_keybind_value(&mut self, keybind_value: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(Keybind::VT_KEYBIND_VALUE, keybind_value); + } + #[inline] + pub fn add_keybind_delay(&mut self, keybind_delay: f32) { + self.fbb_.push_slot::(Keybind::VT_KEYBIND_DELAY, keybind_delay, 0.0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeybindBuilder<'a, 'b> { + let start = _fbb.start_table(); + KeybindBuilder { + 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 Keybind<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("Keybind"); + ds.field("keybind_name", &self.keybind_name()); + ds.field("keybind_value", &self.keybind_value()); + ds.field("keybind_delay", &self.keybind_delay()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_name_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_name_generated.rs new file mode 100644 index 00000000..340f4b33 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_name_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_KEYBIND_NAME: u8 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_KEYBIND_NAME: u8 = 4; +#[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_KEYBIND_NAME: [KeybindName; 5] = [ + KeybindName::FULL_RESET, + KeybindName::YAW_RESET, + KeybindName::MOUNTING_RESET, + KeybindName::PAUSE_TRACKING, + KeybindName::FEET_MOUNTING_RESET, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct KeybindName(pub u8); +#[allow(non_upper_case_globals)] +impl KeybindName { + pub const FULL_RESET: Self = Self(0); + pub const YAW_RESET: Self = Self(1); + pub const MOUNTING_RESET: Self = Self(2); + pub const PAUSE_TRACKING: Self = Self(3); + pub const FEET_MOUNTING_RESET: Self = Self(4); + + pub const ENUM_MIN: u8 = 0; + pub const ENUM_MAX: u8 = 4; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::FULL_RESET, + Self::YAW_RESET, + Self::MOUNTING_RESET, + Self::PAUSE_TRACKING, + Self::FEET_MOUNTING_RESET, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::FULL_RESET => Some("FULL_RESET"), + Self::YAW_RESET => Some("YAW_RESET"), + Self::MOUNTING_RESET => Some("MOUNTING_RESET"), + Self::PAUSE_TRACKING => Some("PAUSE_TRACKING"), + Self::FEET_MOUNTING_RESET => Some("FEET_MOUNTING_RESET"), + _ => None, + } + } +} +impl core::fmt::Debug for KeybindName { + 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 KeybindName { + 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 KeybindName { + type Output = KeybindName; + #[inline] + unsafe fn push(&self, dst: &mut [u8], _written_len: usize) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for KeybindName { + 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 KeybindName { + #[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 KeybindName {} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs new file mode 100644 index 00000000..0e5c119a --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_request_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum KeybindRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct KeybindRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for KeybindRequest<'a> { + type Inner = KeybindRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> KeybindRequest<'a> { + pub const VT_KEYBIND_NAME: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + KeybindRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args KeybindRequestArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = KeybindRequestBuilder::new(_fbb); + builder.add_keybind_name(args.keybind_name); + builder.finish() + } + + + #[inline] + pub fn keybind_name(&self) -> KeybindName { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(KeybindRequest::VT_KEYBIND_NAME, Some(KeybindName::FULL_RESET)).unwrap()} + } +} + +impl flatbuffers::Verifiable for KeybindRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("keybind_name", Self::VT_KEYBIND_NAME, false)? + .finish(); + Ok(()) + } +} +pub struct KeybindRequestArgs { + pub keybind_name: KeybindName, +} +impl<'a> Default for KeybindRequestArgs { + #[inline] + fn default() -> Self { + KeybindRequestArgs { + keybind_name: KeybindName::FULL_RESET, + } + } +} + +pub struct KeybindRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> KeybindRequestBuilder<'a, 'b> { + #[inline] + pub fn add_keybind_name(&mut self, keybind_name: KeybindName) { + self.fbb_.push_slot::(KeybindRequest::VT_KEYBIND_NAME, keybind_name, KeybindName::FULL_RESET); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeybindRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + KeybindRequestBuilder { + 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 KeybindRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("KeybindRequest"); + ds.field("keybind_name", &self.keybind_name()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs new file mode 100644 index 00000000..7545b8d4 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/keybind_response_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum KeybindResponseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct KeybindResponse<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for KeybindResponse<'a> { + type Inner = KeybindResponse<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> KeybindResponse<'a> { + pub const VT_KEYBIND: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + KeybindResponse { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args KeybindResponseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = KeybindResponseBuilder::new(_fbb); + if let Some(x) = args.keybind { builder.add_keybind(x); } + builder.finish() + } + + + #[inline] + pub fn keybind(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(KeybindResponse::VT_KEYBIND, None)} + } +} + +impl flatbuffers::Verifiable for KeybindResponse<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>>>("keybind", Self::VT_KEYBIND, false)? + .finish(); + Ok(()) + } +} +pub struct KeybindResponseArgs<'a> { + pub keybind: Option>>>>, +} +impl<'a> Default for KeybindResponseArgs<'a> { + #[inline] + fn default() -> Self { + KeybindResponseArgs { + keybind: None, + } + } +} + +pub struct KeybindResponseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> KeybindResponseBuilder<'a, 'b> { + #[inline] + pub fn add_keybind(&mut self, keybind: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(KeybindResponse::VT_KEYBIND, keybind); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeybindResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + KeybindResponseBuilder { + 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 KeybindResponse<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("KeybindResponse"); + ds.field("keybind", &self.keybind()); + 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..c0224c72 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 = 81; #[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; 82] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, @@ -95,6 +95,9 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 79] = [ RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::KeybindRequest, + RpcMessage::ChangeKeybindRequest, + RpcMessage::KeybindResponse, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -181,9 +184,12 @@ impl RpcMessage { pub const StartUserHeightCalibration: Self = Self(76); pub const CancelUserHeightCalibration: Self = Self(77); pub const UserHeightRecordingStatusResponse: Self = Self(78); + pub const KeybindRequest: Self = Self(79); + pub const ChangeKeybindRequest: Self = Self(80); + pub const KeybindResponse: Self = Self(81); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 78; + pub const ENUM_MAX: u8 = 81; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -264,6 +270,9 @@ impl RpcMessage { Self::StartUserHeightCalibration, Self::CancelUserHeightCalibration, Self::UserHeightRecordingStatusResponse, + Self::KeybindRequest, + Self::ChangeKeybindRequest, + Self::KeybindResponse, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -347,6 +356,9 @@ impl RpcMessage { Self::StartUserHeightCalibration => Some("StartUserHeightCalibration"), Self::CancelUserHeightCalibration => Some("CancelUserHeightCalibration"), Self::UserHeightRecordingStatusResponse => Some("UserHeightRecordingStatusResponse"), + Self::KeybindRequest => Some("KeybindRequest"), + Self::ChangeKeybindRequest => Some("ChangeKeybindRequest"), + Self::KeybindResponse => Some("KeybindResponse"), _ => 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..06d81b83 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,51 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_keybind_request(&self) -> Option> { + if self.message_type() == RpcMessage::KeybindRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { KeybindRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_change_keybind_request(&self) -> Option> { + if self.message_type() == RpcMessage::ChangeKeybindRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { ChangeKeybindRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_keybind_response(&self) -> Option> { + if self.message_type() == RpcMessage::KeybindResponse { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { KeybindResponse::init_from_table(t) } + }) + } else { + None + } + } + } impl flatbuffers::Verifiable for RpcMessageHeader<'_> { @@ -1329,6 +1374,9 @@ 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::KeybindRequest => v.verify_union_variant::>("RpcMessage::KeybindRequest", pos), + RpcMessage::ChangeKeybindRequest => v.verify_union_variant::>("RpcMessage::ChangeKeybindRequest", pos), + RpcMessage::KeybindResponse => v.verify_union_variant::>("RpcMessage::KeybindResponse", pos), _ => Ok(()), } })? @@ -1936,6 +1984,27 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::KeybindRequest => { + if let Some(x) = self.message_as_keybind_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::ChangeKeybindRequest => { + if let Some(x) = self.message_as_change_keybind_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::KeybindResponse => { + if let Some(x) = self.message_as_keybind_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/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index 1535b09d..bc983a32 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 { ChangeKeybindRequest, ChangeKeybindRequestT } from './solarxr-protocol/rpc/change-keybind-request.js'; export { ChangeMagToggleRequest, ChangeMagToggleRequestT } from './solarxr-protocol/rpc/change-mag-toggle-request.js'; export { ChangeSettingsRequest, ChangeSettingsRequestT } from './solarxr-protocol/rpc/change-settings-request.js'; export { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from './solarxr-protocol/rpc/change-skeleton-config-request.js'; @@ -89,6 +90,10 @@ export { HeartbeatResponse, HeartbeatResponseT } from './solarxr-protocol/rpc/he export { HeightRequest, HeightRequestT } from './solarxr-protocol/rpc/height-request.js'; export { HeightResponse, HeightResponseT } from './solarxr-protocol/rpc/height-response.js'; export { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from './solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; +export { Keybind, KeybindT } from './solarxr-protocol/rpc/keybind.js'; +export { KeybindName } from './solarxr-protocol/rpc/keybind-name.js'; +export { KeybindRequest, KeybindRequestT } from './solarxr-protocol/rpc/keybind-request.js'; +export { KeybindResponse, KeybindResponseT } from './solarxr-protocol/rpc/keybind-response.js'; export { LegTweaksTmpChange, LegTweaksTmpChangeT } from './solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; export { LegTweaksTmpClear, LegTweaksTmpClearT } from './solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; export { MagToggleRequest, MagToggleRequestT } from './solarxr-protocol/rpc/mag-toggle-request.js'; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/change-keybind-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/change-keybind-request.ts new file mode 100644 index 00000000..97540faf --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/change-keybind-request.ts @@ -0,0 +1,92 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { Keybind, KeybindT } from '../../solarxr-protocol/rpc/keybind.js'; + + +export class ChangeKeybindRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ChangeKeybindRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsChangeKeybindRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeKeybindRequest):ChangeKeybindRequest { + return (obj || new ChangeKeybindRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsChangeKeybindRequest(bb:flatbuffers.ByteBuffer, obj?:ChangeKeybindRequest):ChangeKeybindRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ChangeKeybindRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +keybind(index: number, obj?:Keybind):Keybind|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new Keybind()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +keybindLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startChangeKeybindRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addKeybind(builder:flatbuffers.Builder, keybindOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, keybindOffset, 0); +} + +static createKeybindVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startKeybindVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endChangeKeybindRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createChangeKeybindRequest(builder:flatbuffers.Builder, keybindOffset:flatbuffers.Offset):flatbuffers.Offset { + ChangeKeybindRequest.startChangeKeybindRequest(builder); + ChangeKeybindRequest.addKeybind(builder, keybindOffset); + return ChangeKeybindRequest.endChangeKeybindRequest(builder); +} + +unpack(): ChangeKeybindRequestT { + return new ChangeKeybindRequestT( + this.bb!.createObjList(this.keybind.bind(this), this.keybindLength()) + ); +} + + +unpackTo(_o: ChangeKeybindRequestT): void { + _o.keybind = this.bb!.createObjList(this.keybind.bind(this), this.keybindLength()); +} +} + +export class ChangeKeybindRequestT implements flatbuffers.IGeneratedObject { +constructor( + public keybind: (KeybindT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const keybind = ChangeKeybindRequest.createKeybindVector(builder, builder.createObjectOffsetList(this.keybind)); + + return ChangeKeybindRequest.createChangeKeybindRequest(builder, + keybind + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind-name.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind-name.ts new file mode 100644 index 00000000..912531ce --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind-name.ts @@ -0,0 +1,9 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum KeybindName { + FULL_RESET = 0, + YAW_RESET = 1, + MOUNTING_RESET = 2, + PAUSE_TRACKING = 3, + FEET_MOUNTING_RESET = 4 +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts new file mode 100644 index 00000000..39bd64ba --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind-request.ts @@ -0,0 +1,73 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { KeybindName } from '../../solarxr-protocol/rpc/keybind-name.js'; + + +export class KeybindRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):KeybindRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsKeybindRequest(bb:flatbuffers.ByteBuffer, obj?:KeybindRequest):KeybindRequest { + return (obj || new KeybindRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsKeybindRequest(bb:flatbuffers.ByteBuffer, obj?:KeybindRequest):KeybindRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new KeybindRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +keybindName():KeybindName { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : KeybindName.FULL_RESET; +} + +static startKeybindRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addKeybindName(builder:flatbuffers.Builder, keybindName:KeybindName) { + builder.addFieldInt8(0, keybindName, KeybindName.FULL_RESET); +} + +static endKeybindRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createKeybindRequest(builder:flatbuffers.Builder, keybindName:KeybindName):flatbuffers.Offset { + KeybindRequest.startKeybindRequest(builder); + KeybindRequest.addKeybindName(builder, keybindName); + return KeybindRequest.endKeybindRequest(builder); +} + +unpack(): KeybindRequestT { + return new KeybindRequestT( + this.keybindName() + ); +} + + +unpackTo(_o: KeybindRequestT): void { + _o.keybindName = this.keybindName(); +} +} + +export class KeybindRequestT implements flatbuffers.IGeneratedObject { +constructor( + public keybindName: KeybindName = KeybindName.FULL_RESET +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return KeybindRequest.createKeybindRequest(builder, + this.keybindName + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts new file mode 100644 index 00000000..3e7c43d9 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind-response.ts @@ -0,0 +1,92 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { Keybind, KeybindT } from '../../solarxr-protocol/rpc/keybind.js'; + + +export class KeybindResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):KeybindResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsKeybindResponse(bb:flatbuffers.ByteBuffer, obj?:KeybindResponse):KeybindResponse { + return (obj || new KeybindResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsKeybindResponse(bb:flatbuffers.ByteBuffer, obj?:KeybindResponse):KeybindResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new KeybindResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +keybind(index: number, obj?:Keybind):Keybind|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? (obj || new Keybind()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +keybindLength():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startKeybindResponse(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addKeybind(builder:flatbuffers.Builder, keybindOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, keybindOffset, 0); +} + +static createKeybindVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startKeybindVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endKeybindResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createKeybindResponse(builder:flatbuffers.Builder, keybindOffset:flatbuffers.Offset):flatbuffers.Offset { + KeybindResponse.startKeybindResponse(builder); + KeybindResponse.addKeybind(builder, keybindOffset); + return KeybindResponse.endKeybindResponse(builder); +} + +unpack(): KeybindResponseT { + return new KeybindResponseT( + this.bb!.createObjList(this.keybind.bind(this), this.keybindLength()) + ); +} + + +unpackTo(_o: KeybindResponseT): void { + _o.keybind = this.bb!.createObjList(this.keybind.bind(this), this.keybindLength()); +} +} + +export class KeybindResponseT implements flatbuffers.IGeneratedObject { +constructor( + public keybind: (KeybindT)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const keybind = KeybindResponse.createKeybindVector(builder, builder.createObjectOffsetList(this.keybind)); + + return KeybindResponse.createKeybindResponse(builder, + keybind + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/keybind.ts b/protocol/typescript/src/solarxr-protocol/rpc/keybind.ts new file mode 100644 index 00000000..688aa766 --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/keybind.ts @@ -0,0 +1,105 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { KeybindName } from '../../solarxr-protocol/rpc/keybind-name.js'; + + +export class Keybind implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):Keybind { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsKeybind(bb:flatbuffers.ByteBuffer, obj?:Keybind):Keybind { + return (obj || new Keybind()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsKeybind(bb:flatbuffers.ByteBuffer, obj?:Keybind):Keybind { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new Keybind()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +keybindName():KeybindName { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : KeybindName.FULL_RESET; +} + +keybindValue():string|null +keybindValue(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +keybindValue(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; +} + +keybindDelay():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +static startKeybind(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addKeybindName(builder:flatbuffers.Builder, keybindName:KeybindName) { + builder.addFieldInt8(0, keybindName, KeybindName.FULL_RESET); +} + +static addKeybindValue(builder:flatbuffers.Builder, keybindValueOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, keybindValueOffset, 0); +} + +static addKeybindDelay(builder:flatbuffers.Builder, keybindDelay:number) { + builder.addFieldFloat32(2, keybindDelay, 0.0); +} + +static endKeybind(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createKeybind(builder:flatbuffers.Builder, keybindName:KeybindName, keybindValueOffset:flatbuffers.Offset, keybindDelay:number):flatbuffers.Offset { + Keybind.startKeybind(builder); + Keybind.addKeybindName(builder, keybindName); + Keybind.addKeybindValue(builder, keybindValueOffset); + Keybind.addKeybindDelay(builder, keybindDelay); + return Keybind.endKeybind(builder); +} + +unpack(): KeybindT { + return new KeybindT( + this.keybindName(), + this.keybindValue(), + this.keybindDelay() + ); +} + + +unpackTo(_o: KeybindT): void { + _o.keybindName = this.keybindName(); + _o.keybindValue = this.keybindValue(); + _o.keybindDelay = this.keybindDelay(); +} +} + +export class KeybindT implements flatbuffers.IGeneratedObject { +constructor( + public keybindName: KeybindName = KeybindName.FULL_RESET, + public keybindValue: string|Uint8Array|null = null, + public keybindDelay: number = 0.0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const keybindValue = (this.keybindValue !== null ? builder.createString(this.keybindValue!) : 0); + + return Keybind.createKeybind(builder, + this.keybindName, + keybindValue, + this.keybindDelay + ); +} +} 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..f6f19856 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -12,6 +12,7 @@ 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 { ChangeKeybindRequest, ChangeKeybindRequestT } from '../../solarxr-protocol/rpc/change-keybind-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; @@ -29,6 +30,8 @@ import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rp import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; +import { KeybindRequest, KeybindRequestT } from '../../solarxr-protocol/rpc/keybind-request.js'; +import { KeybindResponse, KeybindResponseT } from '../../solarxr-protocol/rpc/keybind-response.js'; import { LegTweaksTmpChange, LegTweaksTmpChangeT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; import { LegTweaksTmpClear, LegTweaksTmpClearT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; import { MagToggleRequest, MagToggleRequestT } from '../../solarxr-protocol/rpc/mag-toggle-request.js'; @@ -178,7 +181,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|ChangeKeybindRequestT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|IgnoreTrackingChecklistStepRequestT|KeybindRequestT|KeybindResponseT|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 ){} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts index 76d9891b..11a80960 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -9,6 +9,7 @@ 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 { ChangeKeybindRequest, ChangeKeybindRequestT } from '../../solarxr-protocol/rpc/change-keybind-request.js'; import { ChangeMagToggleRequest, ChangeMagToggleRequestT } from '../../solarxr-protocol/rpc/change-mag-toggle-request.js'; import { ChangeSettingsRequest, ChangeSettingsRequestT } from '../../solarxr-protocol/rpc/change-settings-request.js'; import { ChangeSkeletonConfigRequest, ChangeSkeletonConfigRequestT } from '../../solarxr-protocol/rpc/change-skeleton-config-request.js'; @@ -26,6 +27,8 @@ import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rp import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; import { HeightResponse, HeightResponseT } from '../../solarxr-protocol/rpc/height-response.js'; import { IgnoreTrackingChecklistStepRequest, IgnoreTrackingChecklistStepRequestT } from '../../solarxr-protocol/rpc/ignore-tracking-checklist-step-request.js'; +import { KeybindRequest, KeybindRequestT } from '../../solarxr-protocol/rpc/keybind-request.js'; +import { KeybindResponse, KeybindResponseT } from '../../solarxr-protocol/rpc/keybind-response.js'; import { LegTweaksTmpChange, LegTweaksTmpChangeT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-change.js'; import { LegTweaksTmpClear, LegTweaksTmpClearT } from '../../solarxr-protocol/rpc/leg-tweaks-tmp-clear.js'; import { MagToggleRequest, MagToggleRequestT } from '../../solarxr-protocol/rpc/mag-toggle-request.js'; @@ -159,13 +162,16 @@ export enum RpcMessage { IgnoreTrackingChecklistStepRequest = 75, StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, - UserHeightRecordingStatusResponse = 78 + UserHeightRecordingStatusResponse = 78, + KeybindRequest = 79, + ChangeKeybindRequest = 80, + KeybindResponse = 81 } 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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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 { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -246,15 +252,18 @@ 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 'KeybindRequest': return accessor(new KeybindRequest())! as KeybindRequest; + case 'ChangeKeybindRequest': return accessor(new ChangeKeybindRequest())! as ChangeKeybindRequest; + case 'KeybindResponse': return accessor(new KeybindResponse())! as KeybindResponse; 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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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, 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|ChangeKeybindRequest|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|KeybindRequest|KeybindResponse|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 { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -335,6 +344,9 @@ 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 'KeybindRequest': return accessor(index, new KeybindRequest())! as KeybindRequest; + case 'ChangeKeybindRequest': return accessor(index, new ChangeKeybindRequest())! as ChangeKeybindRequest; + case 'KeybindResponse': return accessor(index, new KeybindResponse())! as KeybindResponse; default: return null; } } diff --git a/schema/rpc.fbs b/schema/rpc.fbs index c54f1504..eaefd89a 100644 --- a/schema/rpc.fbs +++ b/schema/rpc.fbs @@ -95,9 +95,42 @@ union RpcMessage { IgnoreTrackingChecklistStepRequest, StartUserHeightCalibration, CancelUserHeightCalibration, - UserHeightRecordingStatusResponse + UserHeightRecordingStatusResponse, + KeybindRequest, + ChangeKeybindRequest, + KeybindResponse } +enum KeybindName: uint8 { + FULL_RESET = 0, + YAW_RESET = 1, + MOUNTING_RESET = 2, + PAUSE_TRACKING = 3, + FEET_MOUNTING_RESET = 4 +} + +table Keybind { + keybind_name: KeybindName; + keybind_value: string; + keybind_delay: float; +} + +// Requests specified keybind eg. FULL_RESET -> KeybindResponse sends the keybind back to gui +table KeybindRequest { + keybind_name: KeybindName; +} + +// Returns keybinds for displaying in gui +table KeybindResponse { + keybind: [Keybind]; +} + +table ChangeKeybindRequest { + keybind: [Keybind]; +} + + + table RpcMessageHeader { /// For a request, this identifies the request. For a response, this corresponds /// to the request that it is responding to. @@ -190,6 +223,7 @@ table ChangeSettingsRequest { hid_settings: HIDSettings; } + table SteamVRTrackersSetting { waist: bool; chest: bool; @@ -328,6 +362,7 @@ table HIDSettings { trackersOverHID: bool; } + /// See TapDetectionSettings::setup_mode table TapDetectionSetupNotification { tracker_id: solarxr_protocol.datatypes.TrackerId;