Add rest calibration status to Tracker schema

protocol/cpp/include/solarxr_protocol/generated/all_generated.h

@@ -901,6 +901,39 @@ inline const char *EnumNameMagnetometerStatus(MagnetometerStatus e) {
   return EnumNamesMagnetometerStatus()[index];
 }
 
+enum class RestCalibrationStatus : uint8_t {
+  NOT_SUPPORTED = 0,
+  NOT_CALIBRATED = 1,
+  CALIBRATED = 2,
+  MIN = NOT_SUPPORTED,
+  MAX = CALIBRATED
+};
+
+inline const RestCalibrationStatus (&EnumValuesRestCalibrationStatus())[3] {
+  static const RestCalibrationStatus values[] = {
+    RestCalibrationStatus::NOT_SUPPORTED,
+    RestCalibrationStatus::NOT_CALIBRATED,
+    RestCalibrationStatus::CALIBRATED
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesRestCalibrationStatus() {
+  static const char * const names[4] = {
+    "NOT_SUPPORTED",
+    "NOT_CALIBRATED",
+    "CALIBRATED",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameRestCalibrationStatus(RestCalibrationStatus e) {
+  if (flatbuffers::IsOutRange(e, RestCalibrationStatus::NOT_SUPPORTED, RestCalibrationStatus::CALIBRATED)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesRestCalibrationStatus()[index];
+}
+
 namespace hardware_info {
 
 enum class McuType : uint16_t {
@@ -4039,7 +4072,8 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_MOUNTING_RESET_ORIENTATION = 24,
     VT_IS_HMD = 26,
     VT_MAGNETOMETER = 28,
-    VT_DATA_SUPPORT = 30
+    VT_DATA_SUPPORT = 30,
+    VT_REST_CALIBRATION_STATUS = 32
   };
   solarxr_protocol::datatypes::hardware_info::ImuType imu_type() const {
     return static_cast<solarxr_protocol::datatypes::hardware_info::ImuType>(GetField<uint16_t>(VT_IMU_TYPE, 0));
@@ -4097,6 +4131,9 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support() const {
     return static_cast<solarxr_protocol::datatypes::hardware_info::TrackerDataType>(GetField<uint8_t>(VT_DATA_SUPPORT, 0));
   }
+  solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status() const {
+    return static_cast<solarxr_protocol::datatypes::RestCalibrationStatus>(GetField<uint8_t>(VT_REST_CALIBRATION_STATUS, 0));
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint16_t>(verifier, VT_IMU_TYPE, 2) &&
@@ -4115,6 +4152,7 @@ struct TrackerInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<uint8_t>(verifier, VT_IS_HMD, 1) &&
            VerifyField<uint8_t>(verifier, VT_MAGNETOMETER, 1) &&
            VerifyField<uint8_t>(verifier, VT_DATA_SUPPORT, 1) &&
+           VerifyField<uint8_t>(verifier, VT_REST_CALIBRATION_STATUS, 1) &&
            verifier.EndTable();
   }
 };
@@ -4165,6 +4203,9 @@ struct TrackerInfoBuilder {
   void add_data_support(solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support) {
     fbb_.AddElement<uint8_t>(TrackerInfo::VT_DATA_SUPPORT, static_cast<uint8_t>(data_support), 0);
   }
+  void add_rest_calibration_status(solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status) {
+    fbb_.AddElement<uint8_t>(TrackerInfo::VT_REST_CALIBRATION_STATUS, static_cast<uint8_t>(rest_calibration_status), 0);
+  }
   explicit TrackerInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -4191,14 +4232,16 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfo(
     const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr,
     bool is_hmd = false,
     solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED,
-    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION) {
+    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION,
+    solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status = solarxr_protocol::datatypes::RestCalibrationStatus::NOT_SUPPORTED) {
   TrackerInfoBuilder builder_(_fbb);
   builder_.add_mounting_reset_orientation(mounting_reset_orientation);
   builder_.add_custom_name(custom_name);
   builder_.add_display_name(display_name);
   builder_.add_mounting_orientation(mounting_orientation);
   builder_.add_poll_rate(poll_rate);
   builder_.add_imu_type(imu_type);
+  builder_.add_rest_calibration_status(rest_calibration_status);
   builder_.add_data_support(data_support);
   builder_.add_magnetometer(magnetometer);
   builder_.add_is_hmd(is_hmd);
@@ -4225,7 +4268,8 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfoDirect(
     const solarxr_protocol::datatypes::math::Quat *mounting_reset_orientation = nullptr,
     bool is_hmd = false,
     solarxr_protocol::datatypes::MagnetometerStatus magnetometer = solarxr_protocol::datatypes::MagnetometerStatus::NOT_SUPPORTED,
-    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION) {
+    solarxr_protocol::datatypes::hardware_info::TrackerDataType data_support = solarxr_protocol::datatypes::hardware_info::TrackerDataType::ROTATION,
+    solarxr_protocol::datatypes::RestCalibrationStatus rest_calibration_status = solarxr_protocol::datatypes::RestCalibrationStatus::NOT_SUPPORTED) {
   auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0;
   auto custom_name__ = custom_name ? _fbb.CreateString(custom_name) : 0;
   return solarxr_protocol::data_feed::tracker::CreateTrackerInfo(
@@ -4243,7 +4287,8 @@ inline flatbuffers::Offset<TrackerInfo> CreateTrackerInfoDirect(
       mounting_reset_orientation,
       is_hmd,
       magnetometer,
-      data_support);
+      data_support,
+      rest_calibration_status);
 }
 
 }  // namespace tracker

protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfo.java

@@ -77,8 +77,9 @@ public final class TrackerInfo extends Table {
    * Indicates what type of data the tracker sends (note: it always ends up being rotation in the end)
    */
   public int dataSupport() { int o = __offset(30); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
+  public int restCalibrationStatus() { int o = __offset(32); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
 
-  public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(14); }
+  public static void startTrackerInfo(FlatBufferBuilder builder) { builder.startTable(15); }
   public static void addImuType(FlatBufferBuilder builder, int imuType) { builder.addShort(0, (short) imuType, (short) 0); }
   public static void addBodyPart(FlatBufferBuilder builder, int bodyPart) { builder.addByte(1, (byte) bodyPart, (byte) 0); }
   public static void addPollRate(FlatBufferBuilder builder, int pollRateOffset) { builder.addStruct(2, pollRateOffset, 0); }
@@ -93,6 +94,7 @@ public final class TrackerInfo extends Table {
   public static void addIsHmd(FlatBufferBuilder builder, boolean isHmd) { builder.addBoolean(11, isHmd, false); }
   public static void addMagnetometer(FlatBufferBuilder builder, int magnetometer) { builder.addByte(12, (byte) magnetometer, (byte) 0); }
   public static void addDataSupport(FlatBufferBuilder builder, int dataSupport) { builder.addByte(13, (byte) dataSupport, (byte) 0); }
+  public static void addRestCalibrationStatus(FlatBufferBuilder builder, int restCalibrationStatus) { builder.addByte(14, (byte) restCalibrationStatus, (byte) 0); }
   public static int endTrackerInfo(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -138,6 +140,8 @@ public void unpackTo(TrackerInfoT _o) {
     _o.setMagnetometer(_oMagnetometer);
     int _oDataSupport = dataSupport();
     _o.setDataSupport(_oDataSupport);
+    int _oRestCalibrationStatus = restCalibrationStatus();
+    _o.setRestCalibrationStatus(_oRestCalibrationStatus);
   }
   public static int pack(FlatBufferBuilder builder, TrackerInfoT _o) {
     if (_o == null) return 0;
@@ -158,6 +162,7 @@ public static int pack(FlatBufferBuilder builder, TrackerInfoT _o) {
     addIsHmd(builder, _o.getIsHmd());
     addMagnetometer(builder, _o.getMagnetometer());
     addDataSupport(builder, _o.getDataSupport());
+    addRestCalibrationStatus(builder, _o.getRestCalibrationStatus());
     return endTrackerInfo(builder);
   }
 }

protocol/java/src/solarxr_protocol/data_feed/tracker/TrackerInfoT.java

@@ -22,6 +22,7 @@ public class TrackerInfoT {
   private boolean isHmd;
   private int magnetometer;
   private int dataSupport;
+  private int restCalibrationStatus;
 
   public int getImuType() { return imuType; }
 
@@ -79,6 +80,10 @@ public class TrackerInfoT {
 
   public void setDataSupport(int dataSupport) { this.dataSupport = dataSupport; }
 
+  public int getRestCalibrationStatus() { return restCalibrationStatus; }
+
+  public void setRestCalibrationStatus(int restCalibrationStatus) { this.restCalibrationStatus = restCalibrationStatus; }
+
 
   public TrackerInfoT() {
     this.imuType = 0;
@@ -95,6 +100,7 @@ public TrackerInfoT() {
     this.isHmd = false;
     this.magnetometer = 0;
     this.dataSupport = 0;
+    this.restCalibrationStatus = 0;
   }
 }
 

protocol/java/src/solarxr_protocol/datatypes/RestCalibrationStatus.java

@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes;
+
+@SuppressWarnings("unused")
+public final class RestCalibrationStatus {
+  private RestCalibrationStatus() { }
+  public static final int NOT_SUPPORTED = 0;
+  public static final int NOT_CALIBRATED = 1;
+  public static final int CALIBRATED = 2;
+
+  public static final String[] names = { "NOT_SUPPORTED", "NOT_CALIBRATED", "CALIBRATED", };
+
+  public static String name(int e) { return names[e]; }
+}
+

protocol/kotlin/src/solarxr_protocol/data_feed/tracker/TrackerInfo.kt

@@ -143,6 +143,11 @@ class TrackerInfo : Table() {
             val o = __offset(30)
             return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
         }
+    val restCalibrationStatus : UByte
+        get() {
+            val o = __offset(32)
+            return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
+        }
     companion object {
         @JvmStatic
         fun validateVersion() = Constants.FLATBUFFERS_22_10_26()
@@ -154,7 +159,7 @@ class TrackerInfo : Table() {
             return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
         }
         @JvmStatic
-        fun startTrackerInfo(builder: FlatBufferBuilder) = builder.startTable(14)
+        fun startTrackerInfo(builder: FlatBufferBuilder) = builder.startTable(15)
         @JvmStatic
         fun addImuType(builder: FlatBufferBuilder, imuType: UShort) = builder.addShort(0, imuType.toShort(), 0)
         @JvmStatic
@@ -184,6 +189,8 @@ class TrackerInfo : Table() {
         @JvmStatic
         fun addDataSupport(builder: FlatBufferBuilder, dataSupport: UByte) = builder.addByte(13, dataSupport.toByte(), 0)
         @JvmStatic
+        fun addRestCalibrationStatus(builder: FlatBufferBuilder, restCalibrationStatus: UByte) = builder.addByte(14, restCalibrationStatus.toByte(), 0)
+        @JvmStatic
         fun endTrackerInfo(builder: FlatBufferBuilder) : Int {
             val o = builder.endTable()
             return o

protocol/kotlin/src/solarxr_protocol/datatypes/RestCalibrationStatus.kt

@@ -0,0 +1,15 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes
+
+@Suppress("unused")
+class RestCalibrationStatus private constructor() {
+    companion object {
+        const val NOTSUPPORTED: UByte = 0u
+        const val NOTCALIBRATED: UByte = 1u
+        const val CALIBRATED: UByte = 2u
+        val names : Array<String> = arrayOf("NOT_SUPPORTED", "NOT_CALIBRATED", "CALIBRATED")
+        @JvmStatic
+        fun name(e: Int) : String = names[e]
+    }
+}

protocol/rust/src/generated/mod.rs

@@ -82,6 +82,8 @@ pub mod solarxr_protocol {
     pub use self::tracker_status_generated::*;
     mod magnetometer_status_generated;
     pub use self::magnetometer_status_generated::*;
+    mod rest_calibration_status_generated;
+    pub use self::rest_calibration_status_generated::*;
     mod hz_f32_generated;
     pub use self::hz_f32_generated::*;
     mod transaction_id_generated;

protocol/rust/src/generated/solarxr_protocol/data_feed/tracker/tracker_info_generated.rs

@@ -40,6 +40,7 @@ impl<'a> TrackerInfo<'a> {
   pub const VT_IS_HMD: flatbuffers::VOffsetT = 26;
   pub const VT_MAGNETOMETER: flatbuffers::VOffsetT = 28;
   pub const VT_DATA_SUPPORT: flatbuffers::VOffsetT = 30;
+  pub const VT_REST_CALIBRATION_STATUS: flatbuffers::VOffsetT = 32;
 
   #[inline]
   pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
@@ -57,6 +58,7 @@ impl<'a> TrackerInfo<'a> {
     if let Some(x) = args.mounting_orientation { builder.add_mounting_orientation(x); }
     if let Some(x) = args.poll_rate { builder.add_poll_rate(x); }
     builder.add_imu_type(args.imu_type);
+    builder.add_rest_calibration_status(args.rest_calibration_status);
     builder.add_data_support(args.data_support);
     builder.add_magnetometer(args.magnetometer);
     builder.add_is_hmd(args.is_hmd);
@@ -181,6 +183,13 @@ impl<'a> TrackerInfo<'a> {
     // which contains a valid value in this slot
     unsafe { self._tab.get::<super::super::datatypes::hardware_info::TrackerDataType>(TrackerInfo::VT_DATA_SUPPORT, Some(super::super::datatypes::hardware_info::TrackerDataType::ROTATION)).unwrap()}
   }
+  #[inline]
+  pub fn rest_calibration_status(&self) -> super::super::datatypes::RestCalibrationStatus {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<super::super::datatypes::RestCalibrationStatus>(TrackerInfo::VT_REST_CALIBRATION_STATUS, Some(super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED)).unwrap()}
+  }
 }
 
 impl flatbuffers::Verifiable for TrackerInfo<'_> {
@@ -204,6 +213,7 @@ impl flatbuffers::Verifiable for TrackerInfo<'_> {
      .visit_field::<bool>("is_hmd", Self::VT_IS_HMD, false)?
      .visit_field::<super::super::datatypes::MagnetometerStatus>("magnetometer", Self::VT_MAGNETOMETER, false)?
      .visit_field::<super::super::datatypes::hardware_info::TrackerDataType>("data_support", Self::VT_DATA_SUPPORT, false)?
+     .visit_field::<super::super::datatypes::RestCalibrationStatus>("rest_calibration_status", Self::VT_REST_CALIBRATION_STATUS, false)?
      .finish();
     Ok(())
   }
@@ -223,6 +233,7 @@ pub struct TrackerInfoArgs<'a> {
     pub is_hmd: bool,
     pub magnetometer: super::super::datatypes::MagnetometerStatus,
     pub data_support: super::super::datatypes::hardware_info::TrackerDataType,
+    pub rest_calibration_status: super::super::datatypes::RestCalibrationStatus,
 }
 impl<'a> Default for TrackerInfoArgs<'a> {
   #[inline]
@@ -242,6 +253,7 @@ impl<'a> Default for TrackerInfoArgs<'a> {
       is_hmd: false,
       magnetometer: super::super::datatypes::MagnetometerStatus::NOT_SUPPORTED,
       data_support: super::super::datatypes::hardware_info::TrackerDataType::ROTATION,
+      rest_calibration_status: super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED,
     }
   }
 }
@@ -308,6 +320,10 @@ impl<'a: 'b, 'b> TrackerInfoBuilder<'a, 'b> {
     self.fbb_.push_slot::<super::super::datatypes::hardware_info::TrackerDataType>(TrackerInfo::VT_DATA_SUPPORT, data_support, super::super::datatypes::hardware_info::TrackerDataType::ROTATION);
   }
   #[inline]
+  pub fn add_rest_calibration_status(&mut self, rest_calibration_status: super::super::datatypes::RestCalibrationStatus) {
+    self.fbb_.push_slot::<super::super::datatypes::RestCalibrationStatus>(TrackerInfo::VT_REST_CALIBRATION_STATUS, rest_calibration_status, super::super::datatypes::RestCalibrationStatus::NOT_SUPPORTED);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TrackerInfoBuilder<'a, 'b> {
     let start = _fbb.start_table();
     TrackerInfoBuilder {
@@ -339,6 +355,7 @@ impl core::fmt::Debug for TrackerInfo<'_> {
       ds.field("is_hmd", &self.is_hmd());
       ds.field("magnetometer", &self.magnetometer());
       ds.field("data_support", &self.data_support());
+      ds.field("rest_calibration_status", &self.rest_calibration_status());
       ds.finish()
   }
 }