[wpimath] Add protobuf/struct for trivial types (#5935)

This implements de/serialization for the types that aren't templated (SwerveDriveKinematics) in C++ or where there is no trivial way to go round-trip (Splines) for the messages.

wpimath/src/main/native/cpp/kinematics/struct/ChassisSpeedsStruct.cpp

@@ -0,0 +1,28 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/ChassisSpeedsStruct.h"
+
+namespace {
+constexpr size_t kVxOff = 0;
+constexpr size_t kVyOff = kVxOff + 8;
+constexpr size_t kOmegaOff = kVyOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::ChassisSpeeds>;
+
+frc::ChassisSpeeds StructType::Unpack(std::span<const uint8_t, kSize> data) {
+  return frc::ChassisSpeeds{
+      units::meters_per_second_t{wpi::UnpackStruct<double, kVxOff>(data)},
+      units::meters_per_second_t{wpi::UnpackStruct<double, kVyOff>(data)},
+      units::radians_per_second_t{wpi::UnpackStruct<double, kOmegaOff>(data)},
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::ChassisSpeeds& value) {
+  wpi::PackStruct<kVxOff>(data, value.vx.value());
+  wpi::PackStruct<kVyOff>(data, value.vy.value());
+  wpi::PackStruct<kOmegaOff>(data, value.omega.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/DifferentialDriveKinematicsStruct.cpp

@@ -0,0 +1,23 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/DifferentialDriveKinematicsStruct.h"
+
+namespace {
+constexpr size_t kTrackWidthOff = 0;
+}  // namespace
+
+using StructType = wpi::Struct<frc::DifferentialDriveKinematics>;
+
+frc::DifferentialDriveKinematics StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::DifferentialDriveKinematics{
+      units::meter_t{wpi::UnpackStruct<double, kTrackWidthOff>(data)},
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::DifferentialDriveKinematics& value) {
+  wpi::PackStruct<kTrackWidthOff>(data, value.trackWidth.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/DifferentialDriveWheelSpeedsStruct.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/DifferentialDriveWheelSpeedsStruct.h"
+
+namespace {
+constexpr size_t kLeftOff = 0;
+constexpr size_t kRightOff = kLeftOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::DifferentialDriveWheelSpeeds>;
+
+frc::DifferentialDriveWheelSpeeds StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::DifferentialDriveWheelSpeeds{
+      units::meters_per_second_t{wpi::UnpackStruct<double, kLeftOff>(data)},
+      units::meters_per_second_t{wpi::UnpackStruct<double, kRightOff>(data)},
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::DifferentialDriveWheelSpeeds& value) {
+  wpi::PackStruct<kLeftOff>(data, value.left.value());
+  wpi::PackStruct<kRightOff>(data, value.right.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/MecanumDriveKinematicsStruct.cpp

@@ -0,0 +1,40 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/MecanumDriveKinematicsStruct.h"
+
+namespace {
+constexpr size_t kFrontLeftOff = 0;
+constexpr size_t kFrontRightOff =
+    kFrontLeftOff + wpi::Struct<frc::Translation2d>::kSize;
+constexpr size_t kRearLeftOff =
+    kFrontRightOff + wpi::Struct<frc::Translation2d>::kSize;
+constexpr size_t kRearRightOff =
+    kRearLeftOff + wpi::Struct<frc::Translation2d>::kSize;
+}  // namespace
+
+using StructType = wpi::Struct<frc::MecanumDriveKinematics>;
+
+frc::MecanumDriveKinematics StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::MecanumDriveKinematics{
+      wpi::UnpackStruct<frc::Translation2d, kFrontLeftOff>(data),
+      wpi::UnpackStruct<frc::Translation2d, kFrontRightOff>(data),
+      wpi::UnpackStruct<frc::Translation2d, kRearLeftOff>(data),
+      wpi::UnpackStruct<frc::Translation2d, kRearRightOff>(data),
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::MecanumDriveKinematics& value) {
+  wpi::PackStruct<kFrontLeftOff>(data, value.GetFrontLeftWheel());
+  wpi::PackStruct<kFrontRightOff>(data, value.GetFrontRightWheel());
+  wpi::PackStruct<kRearLeftOff>(data, value.GetRearLeftWheel());
+  wpi::PackStruct<kRearRightOff>(data, value.GetRearRightWheel());
+}
+
+void StructType::ForEachNested(
+    std::invocable<std::string_view, std::string_view> auto fn) {
+  wpi::ForEachStructSchema<frc::Translation2d>(fn);
+}

wpimath/src/main/native/cpp/kinematics/struct/MecanumDriveWheelPositionsStruct.cpp

@@ -0,0 +1,32 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/MecanumDriveWheelPositionsStruct.h"
+
+namespace {
+constexpr size_t kFrontLeftOff = 0;
+constexpr size_t kFrontRightOff = kFrontLeftOff + 8;
+constexpr size_t kRearLeftOff = kFrontRightOff + 8;
+constexpr size_t kRearRightOff = kRearLeftOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::MecanumDriveWheelPositions>;
+
+frc::MecanumDriveWheelPositions StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::MecanumDriveWheelPositions{
+      units::meter_t{wpi::UnpackStruct<double, kFrontLeftOff>(data)},
+      units::meter_t{wpi::UnpackStruct<double, kFrontRightOff>(data)},
+      units::meter_t{wpi::UnpackStruct<double, kRearLeftOff>(data)},
+      units::meter_t{wpi::UnpackStruct<double, kRearRightOff>(data)},
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::MecanumDriveWheelPositions& value) {
+  wpi::PackStruct<kFrontLeftOff>(data, value.frontLeft.value());
+  wpi::PackStruct<kFrontRightOff>(data, value.frontRight.value());
+  wpi::PackStruct<kRearLeftOff>(data, value.rearLeft.value());
+  wpi::PackStruct<kRearRightOff>(data, value.rearRight.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/MecanumDriveWheelSpeedsStruct.cpp

@@ -0,0 +1,35 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/MecanumDriveWheelSpeedsStruct.h"
+
+namespace {
+constexpr size_t kFrontLeftOff = 0;
+constexpr size_t kFrontRightOff = kFrontLeftOff + 8;
+constexpr size_t kRearLeftOff = kFrontRightOff + 8;
+constexpr size_t kRearRightOff = kRearLeftOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::MecanumDriveWheelSpeeds>;
+
+frc::MecanumDriveWheelSpeeds StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::MecanumDriveWheelSpeeds{
+      units::meters_per_second_t{
+          wpi::UnpackStruct<double, kFrontLeftOff>(data)},
+      units::meters_per_second_t{
+          wpi::UnpackStruct<double, kFrontRightOff>(data)},
+      units::meters_per_second_t{wpi::UnpackStruct<double, kRearLeftOff>(data)},
+      units::meters_per_second_t{
+          wpi::UnpackStruct<double, kRearRightOff>(data)},
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::MecanumDriveWheelSpeeds& value) {
+  wpi::PackStruct<kFrontLeftOff>(data, value.frontLeft.value());
+  wpi::PackStruct<kFrontRightOff>(data, value.frontRight.value());
+  wpi::PackStruct<kRearLeftOff>(data, value.rearLeft.value());
+  wpi::PackStruct<kRearRightOff>(data, value.rearRight.value());
+}

wpimath/src/main/native/cpp/kinematics/struct/SwerveModulePositionStruct.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/SwerveModulePositionStruct.h"
+
+namespace {
+constexpr size_t kDistanceOff = 0;
+constexpr size_t kAngleOff = kDistanceOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::SwerveModulePosition>;
+
+frc::SwerveModulePosition StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::SwerveModulePosition{
+      units::meter_t{wpi::UnpackStruct<double, kDistanceOff>(data)},
+      wpi::UnpackStruct<frc::Rotation2d, kAngleOff>(data),
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::SwerveModulePosition& value) {
+  wpi::PackStruct<kDistanceOff>(data, value.distance.value());
+  wpi::PackStruct<kAngleOff>(data, value.angle);
+}
+
+void StructType::ForEachNested(
+    std::invocable<std::string_view, std::string_view> auto fn) {
+  wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+}

wpimath/src/main/native/cpp/kinematics/struct/SwerveModuleStateStruct.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/kinematics/struct/SwerveModuleStateStruct.h"
+
+namespace {
+constexpr size_t kSpeedOff = 0;
+constexpr size_t kAngleOff = kSpeedOff + 8;
+}  // namespace
+
+using StructType = wpi::Struct<frc::SwerveModuleState>;
+
+frc::SwerveModuleState StructType::Unpack(
+    std::span<const uint8_t, kSize> data) {
+  return frc::SwerveModuleState{
+      units::meters_per_second_t{wpi::UnpackStruct<double, kSpeedOff>(data)},
+      wpi::UnpackStruct<frc::Rotation2d, kAngleOff>(data),
+  };
+}
+
+void StructType::Pack(std::span<uint8_t, kSize> data,
+                      const frc::SwerveModuleState& value) {
+  wpi::PackStruct<kSpeedOff>(data, value.speed.value());
+  wpi::PackStruct<kAngleOff>(data, value.angle);
+}
+
+void StructType::ForEachNested(
+    std::invocable<std::string_view, std::string_view> auto fn) {
+  wpi::ForEachStructSchema<frc::Rotation2d>(fn);
+}