Stay Aligned

protocol/java/src/solarxr_protocol/data_feed/DataFeedConfig.java

@@ -29,25 +29,29 @@ public final class DataFeedConfig extends Table {
   public solarxr_protocol.data_feed.tracker.TrackerDataMask syntheticTrackersMask() { return syntheticTrackersMask(new solarxr_protocol.data_feed.tracker.TrackerDataMask()); }
   public solarxr_protocol.data_feed.tracker.TrackerDataMask syntheticTrackersMask(solarxr_protocol.data_feed.tracker.TrackerDataMask obj) { int o = __offset(8); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
   public boolean boneMask() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  public boolean stayAlignedPoseMask() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
 
   public static int createDataFeedConfig(FlatBufferBuilder builder,
       int minimumTimeSinceLast,
       int dataMaskOffset,
       int syntheticTrackersMaskOffset,
-      boolean boneMask) {
-    builder.startTable(4);
+      boolean boneMask,
+      boolean stayAlignedPoseMask) {
+    builder.startTable(5);
     DataFeedConfig.addSyntheticTrackersMask(builder, syntheticTrackersMaskOffset);
     DataFeedConfig.addDataMask(builder, dataMaskOffset);
     DataFeedConfig.addMinimumTimeSinceLast(builder, minimumTimeSinceLast);
+    DataFeedConfig.addStayAlignedPoseMask(builder, stayAlignedPoseMask);
     DataFeedConfig.addBoneMask(builder, boneMask);
     return DataFeedConfig.endDataFeedConfig(builder);
   }
 
-  public static void startDataFeedConfig(FlatBufferBuilder builder) { builder.startTable(4); }
+  public static void startDataFeedConfig(FlatBufferBuilder builder) { builder.startTable(5); }
   public static void addMinimumTimeSinceLast(FlatBufferBuilder builder, int minimumTimeSinceLast) { builder.addShort(0, (short) minimumTimeSinceLast, (short) 0); }
   public static void addDataMask(FlatBufferBuilder builder, int dataMaskOffset) { builder.addOffset(1, dataMaskOffset, 0); }
   public static void addSyntheticTrackersMask(FlatBufferBuilder builder, int syntheticTrackersMaskOffset) { builder.addOffset(2, syntheticTrackersMaskOffset, 0); }
   public static void addBoneMask(FlatBufferBuilder builder, boolean boneMask) { builder.addBoolean(3, boneMask, false); }
+  public static void addStayAlignedPoseMask(FlatBufferBuilder builder, boolean stayAlignedPoseMask) { builder.addBoolean(4, stayAlignedPoseMask, false); }
   public static int endDataFeedConfig(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -73,6 +77,8 @@ public void unpackTo(DataFeedConfigT _o) {
     else _o.setSyntheticTrackersMask(null);
     boolean _oBoneMask = boneMask();
     _o.setBoneMask(_oBoneMask);
+    boolean _oStayAlignedPoseMask = stayAlignedPoseMask();
+    _o.setStayAlignedPoseMask(_oStayAlignedPoseMask);
   }
   public static int pack(FlatBufferBuilder builder, DataFeedConfigT _o) {
     if (_o == null) return 0;
@@ -83,7 +89,8 @@ public static int pack(FlatBufferBuilder builder, DataFeedConfigT _o) {
       _o.getMinimumTimeSinceLast(),
       _dataMask,
       _syntheticTrackersMask,
-      _o.getBoneMask());
+      _o.getBoneMask(),
+      _o.getStayAlignedPoseMask());
   }
 }
 

protocol/java/src/solarxr_protocol/data_feed/DataFeedConfigT.java

@@ -12,6 +12,7 @@ public class DataFeedConfigT {
   private solarxr_protocol.data_feed.device_data.DeviceDataMaskT dataMask;
   private solarxr_protocol.data_feed.tracker.TrackerDataMaskT syntheticTrackersMask;
   private boolean boneMask;
+  private boolean stayAlignedPoseMask;
 
   public int getMinimumTimeSinceLast() { return minimumTimeSinceLast; }
 
@@ -29,12 +30,17 @@ public class DataFeedConfigT {
 
   public void setBoneMask(boolean boneMask) { this.boneMask = boneMask; }
 
+  public boolean getStayAlignedPoseMask() { return stayAlignedPoseMask; }
+
+  public void setStayAlignedPoseMask(boolean stayAlignedPoseMask) { this.stayAlignedPoseMask = stayAlignedPoseMask; }
+
 
   public DataFeedConfigT() {
     this.minimumTimeSinceLast = 0;
     this.dataMask = null;
     this.syntheticTrackersMask = null;
     this.boneMask = false;
+    this.stayAlignedPoseMask = false;
   }
 }
 

protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdate.java

@@ -42,19 +42,23 @@ public final class DataFeedUpdate extends Table {
   public int bonesLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; }
   public solarxr_protocol.data_feed.Bone.Vector bonesVector() { return bonesVector(new solarxr_protocol.data_feed.Bone.Vector()); }
   public solarxr_protocol.data_feed.Bone.Vector bonesVector(solarxr_protocol.data_feed.Bone.Vector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose() { return stayAlignedPose(new solarxr_protocol.data_feed.stay_aligned.StayAlignedPose()); }
+  public solarxr_protocol.data_feed.stay_aligned.StayAlignedPose stayAlignedPose(solarxr_protocol.data_feed.stay_aligned.StayAlignedPose obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
 
   public static int createDataFeedUpdate(FlatBufferBuilder builder,
       int devicesOffset,
       int syntheticTrackersOffset,
-      int bonesOffset) {
-    builder.startTable(3);
+      int bonesOffset,
+      int stayAlignedPoseOffset) {
+    builder.startTable(4);
+    DataFeedUpdate.addStayAlignedPose(builder, stayAlignedPoseOffset);
     DataFeedUpdate.addBones(builder, bonesOffset);
     DataFeedUpdate.addSyntheticTrackers(builder, syntheticTrackersOffset);
     DataFeedUpdate.addDevices(builder, devicesOffset);
     return DataFeedUpdate.endDataFeedUpdate(builder);
   }
 
-  public static void startDataFeedUpdate(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void startDataFeedUpdate(FlatBufferBuilder builder) { builder.startTable(4); }
   public static void addDevices(FlatBufferBuilder builder, int devicesOffset) { builder.addOffset(0, devicesOffset, 0); }
   public static int createDevicesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
   public static void startDevicesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
@@ -64,6 +68,7 @@ public static int createDataFeedUpdate(FlatBufferBuilder builder,
   public static void addBones(FlatBufferBuilder builder, int bonesOffset) { builder.addOffset(2, bonesOffset, 0); }
   public static int createBonesVector(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 startBonesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addStayAlignedPose(FlatBufferBuilder builder, int stayAlignedPoseOffset) { builder.addOffset(3, stayAlignedPoseOffset, 0); }
   public static int endDataFeedUpdate(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -90,6 +95,8 @@ public void unpackTo(DataFeedUpdateT _o) {
     solarxr_protocol.data_feed.BoneT[] _oBones = new solarxr_protocol.data_feed.BoneT[bonesLength()];
     for (int _j = 0; _j < bonesLength(); ++_j) {_oBones[_j] = (bones(_j) != null ? bones(_j).unpack() : null);}
     _o.setBones(_oBones);
+    if (stayAlignedPose() != null) _o.setStayAlignedPose(stayAlignedPose().unpack());
+    else _o.setStayAlignedPose(null);
   }
   public static int pack(FlatBufferBuilder builder, DataFeedUpdateT _o) {
     if (_o == null) return 0;
@@ -114,11 +121,13 @@ public static int pack(FlatBufferBuilder builder, DataFeedUpdateT _o) {
       for (solarxr_protocol.data_feed.BoneT _e : _o.getBones()) { __bones[_j] = solarxr_protocol.data_feed.Bone.pack(builder, _e); _j++;}
       _bones = createBonesVector(builder, __bones);
     }
+    int _stayAlignedPose = _o.getStayAlignedPose() == null ? 0 : solarxr_protocol.data_feed.stay_aligned.StayAlignedPose.pack(builder, _o.getStayAlignedPose());
     return createDataFeedUpdate(
       builder,
       _devices,
       _syntheticTrackers,
-      _bones);
+      _bones,
+      _stayAlignedPose);
   }
 }
 

protocol/java/src/solarxr_protocol/data_feed/DataFeedUpdateT.java

@@ -11,6 +11,7 @@ public class DataFeedUpdateT {
   private solarxr_protocol.data_feed.device_data.DeviceDataT[] devices;
   private solarxr_protocol.data_feed.tracker.TrackerDataT[] syntheticTrackers;
   private solarxr_protocol.data_feed.BoneT[] bones;
+  private solarxr_protocol.data_feed.stay_aligned.StayAlignedPoseT stayAlignedPose;
 
   public solarxr_protocol.data_feed.device_data.DeviceDataT[] getDevices() { return devices; }
 
@@ -24,11 +25,16 @@ public class DataFeedUpdateT {
 
   public void setBones(solarxr_protocol.data_feed.BoneT[] bones) { this.bones = bones; }
 
+  public solarxr_protocol.data_feed.stay_aligned.StayAlignedPoseT getStayAlignedPose() { return stayAlignedPose; }
+
+  public void setStayAlignedPose(solarxr_protocol.data_feed.stay_aligned.StayAlignedPoseT stayAlignedPose) { this.stayAlignedPose = stayAlignedPose; }
+
 
   public DataFeedUpdateT() {
     this.devices = null;
     this.syntheticTrackers = null;
     this.bones = null;
+    this.stayAlignedPose = null;
   }
 }
 

protocol/java/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedPose.java

@@ -0,0 +1,70 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.data_feed.stay_aligned;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class StayAlignedPose extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); }
+  public static StayAlignedPose getRootAsStayAlignedPose(ByteBuffer _bb) { return getRootAsStayAlignedPose(_bb, new StayAlignedPose()); }
+  public static StayAlignedPose getRootAsStayAlignedPose(ByteBuffer _bb, StayAlignedPose 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 StayAlignedPose __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float upperLegAngleInDeg() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public float lowerLegAngleInDeg() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public float footAngleInDeg() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+
+  public static int createStayAlignedPose(FlatBufferBuilder builder,
+      float upperLegAngleInDeg,
+      float lowerLegAngleInDeg,
+      float footAngleInDeg) {
+    builder.startTable(3);
+    StayAlignedPose.addFootAngleInDeg(builder, footAngleInDeg);
+    StayAlignedPose.addLowerLegAngleInDeg(builder, lowerLegAngleInDeg);
+    StayAlignedPose.addUpperLegAngleInDeg(builder, upperLegAngleInDeg);
+    return StayAlignedPose.endStayAlignedPose(builder);
+  }
+
+  public static void startStayAlignedPose(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addUpperLegAngleInDeg(FlatBufferBuilder builder, float upperLegAngleInDeg) { builder.addFloat(0, upperLegAngleInDeg, 0.0f); }
+  public static void addLowerLegAngleInDeg(FlatBufferBuilder builder, float lowerLegAngleInDeg) { builder.addFloat(1, lowerLegAngleInDeg, 0.0f); }
+  public static void addFootAngleInDeg(FlatBufferBuilder builder, float footAngleInDeg) { builder.addFloat(2, footAngleInDeg, 0.0f); }
+  public static int endStayAlignedPose(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 StayAlignedPose get(int j) { return get(new StayAlignedPose(), j); }
+    public StayAlignedPose get(StayAlignedPose obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+  public StayAlignedPoseT unpack() {
+    StayAlignedPoseT _o = new StayAlignedPoseT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(StayAlignedPoseT _o) {
+    float _oUpperLegAngleInDeg = upperLegAngleInDeg();
+    _o.setUpperLegAngleInDeg(_oUpperLegAngleInDeg);
+    float _oLowerLegAngleInDeg = lowerLegAngleInDeg();
+    _o.setLowerLegAngleInDeg(_oLowerLegAngleInDeg);
+    float _oFootAngleInDeg = footAngleInDeg();
+    _o.setFootAngleInDeg(_oFootAngleInDeg);
+  }
+  public static int pack(FlatBufferBuilder builder, StayAlignedPoseT _o) {
+    if (_o == null) return 0;
+    return createStayAlignedPose(
+      builder,
+      _o.getUpperLegAngleInDeg(),
+      _o.getLowerLegAngleInDeg(),
+      _o.getFootAngleInDeg());
+  }
+}
+

protocol/java/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedPoseT.java

@@ -0,0 +1,34 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.data_feed.stay_aligned;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class StayAlignedPoseT {
+  private float upperLegAngleInDeg;
+  private float lowerLegAngleInDeg;
+  private float footAngleInDeg;
+
+  public float getUpperLegAngleInDeg() { return upperLegAngleInDeg; }
+
+  public void setUpperLegAngleInDeg(float upperLegAngleInDeg) { this.upperLegAngleInDeg = upperLegAngleInDeg; }
+
+  public float getLowerLegAngleInDeg() { return lowerLegAngleInDeg; }
+
+  public void setLowerLegAngleInDeg(float lowerLegAngleInDeg) { this.lowerLegAngleInDeg = lowerLegAngleInDeg; }
+
+  public float getFootAngleInDeg() { return footAngleInDeg; }
+
+  public void setFootAngleInDeg(float footAngleInDeg) { this.footAngleInDeg = footAngleInDeg; }
+
+
+  public StayAlignedPoseT() {
+    this.upperLegAngleInDeg = 0.0f;
+    this.lowerLegAngleInDeg = 0.0f;
+    this.footAngleInDeg = 0.0f;
+  }
+}
+

protocol/java/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedTracker.java

@@ -0,0 +1,84 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.data_feed.stay_aligned;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class StayAlignedTracker extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); }
+  public static StayAlignedTracker getRootAsStayAlignedTracker(ByteBuffer _bb) { return getRootAsStayAlignedTracker(_bb, new StayAlignedTracker()); }
+  public static StayAlignedTracker getRootAsStayAlignedTracker(ByteBuffer _bb, StayAlignedTracker 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 StayAlignedTracker __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public float yawCorrectionInDeg() { int o = __offset(4); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public float lockedErrorInDeg() { int o = __offset(6); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public float centerErrorInDeg() { int o = __offset(8); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public float neighborErrorInDeg() { int o = __offset(10); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  public boolean locked() { int o = __offset(12); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+
+  public static int createStayAlignedTracker(FlatBufferBuilder builder,
+      float yawCorrectionInDeg,
+      float lockedErrorInDeg,
+      float centerErrorInDeg,
+      float neighborErrorInDeg,
+      boolean locked) {
+    builder.startTable(5);
+    StayAlignedTracker.addNeighborErrorInDeg(builder, neighborErrorInDeg);
+    StayAlignedTracker.addCenterErrorInDeg(builder, centerErrorInDeg);
+    StayAlignedTracker.addLockedErrorInDeg(builder, lockedErrorInDeg);
+    StayAlignedTracker.addYawCorrectionInDeg(builder, yawCorrectionInDeg);
+    StayAlignedTracker.addLocked(builder, locked);
+    return StayAlignedTracker.endStayAlignedTracker(builder);
+  }
+
+  public static void startStayAlignedTracker(FlatBufferBuilder builder) { builder.startTable(5); }
+  public static void addYawCorrectionInDeg(FlatBufferBuilder builder, float yawCorrectionInDeg) { builder.addFloat(0, yawCorrectionInDeg, 0.0f); }
+  public static void addLockedErrorInDeg(FlatBufferBuilder builder, float lockedErrorInDeg) { builder.addFloat(1, lockedErrorInDeg, 0.0f); }
+  public static void addCenterErrorInDeg(FlatBufferBuilder builder, float centerErrorInDeg) { builder.addFloat(2, centerErrorInDeg, 0.0f); }
+  public static void addNeighborErrorInDeg(FlatBufferBuilder builder, float neighborErrorInDeg) { builder.addFloat(3, neighborErrorInDeg, 0.0f); }
+  public static void addLocked(FlatBufferBuilder builder, boolean locked) { builder.addBoolean(4, locked, false); }
+  public static int endStayAlignedTracker(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 StayAlignedTracker get(int j) { return get(new StayAlignedTracker(), j); }
+    public StayAlignedTracker get(StayAlignedTracker obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+  public StayAlignedTrackerT unpack() {
+    StayAlignedTrackerT _o = new StayAlignedTrackerT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(StayAlignedTrackerT _o) {
+    float _oYawCorrectionInDeg = yawCorrectionInDeg();
+    _o.setYawCorrectionInDeg(_oYawCorrectionInDeg);
+    float _oLockedErrorInDeg = lockedErrorInDeg();
+    _o.setLockedErrorInDeg(_oLockedErrorInDeg);
+    float _oCenterErrorInDeg = centerErrorInDeg();
+    _o.setCenterErrorInDeg(_oCenterErrorInDeg);
+    float _oNeighborErrorInDeg = neighborErrorInDeg();
+    _o.setNeighborErrorInDeg(_oNeighborErrorInDeg);
+    boolean _oLocked = locked();
+    _o.setLocked(_oLocked);
+  }
+  public static int pack(FlatBufferBuilder builder, StayAlignedTrackerT _o) {
+    if (_o == null) return 0;
+    return createStayAlignedTracker(
+      builder,
+      _o.getYawCorrectionInDeg(),
+      _o.getLockedErrorInDeg(),
+      _o.getCenterErrorInDeg(),
+      _o.getNeighborErrorInDeg(),
+      _o.getLocked());
+  }
+}
+

protocol/java/src/solarxr_protocol/data_feed/stay_aligned/StayAlignedTrackerT.java

@@ -0,0 +1,46 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.data_feed.stay_aligned;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class StayAlignedTrackerT {
+  private float yawCorrectionInDeg;
+  private float lockedErrorInDeg;
+  private float centerErrorInDeg;
+  private float neighborErrorInDeg;
+  private boolean locked;
+
+  public float getYawCorrectionInDeg() { return yawCorrectionInDeg; }
+
+  public void setYawCorrectionInDeg(float yawCorrectionInDeg) { this.yawCorrectionInDeg = yawCorrectionInDeg; }
+
+  public float getLockedErrorInDeg() { return lockedErrorInDeg; }
+
+  public void setLockedErrorInDeg(float lockedErrorInDeg) { this.lockedErrorInDeg = lockedErrorInDeg; }
+
+  public float getCenterErrorInDeg() { return centerErrorInDeg; }
+
+  public void setCenterErrorInDeg(float centerErrorInDeg) { this.centerErrorInDeg = centerErrorInDeg; }
+
+  public float getNeighborErrorInDeg() { return neighborErrorInDeg; }
+
+  public void setNeighborErrorInDeg(float neighborErrorInDeg) { this.neighborErrorInDeg = neighborErrorInDeg; }
+
+  public boolean getLocked() { return locked; }
+
+  public void setLocked(boolean locked) { this.locked = locked; }
+
+
+  public StayAlignedTrackerT() {
+    this.yawCorrectionInDeg = 0.0f;
+    this.lockedErrorInDeg = 0.0f;
+    this.centerErrorInDeg = 0.0f;
+    this.neighborErrorInDeg = 0.0f;
+    this.locked = false;
+  }
+}
+