use core::mem;
use core::cmp::Ordering;
extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};
#[allow(unused_imports, dead_code)]
pub mod stardust_xr {
use core::mem;
use core::cmp::Ordering;
extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Vec3(pub [u8; 12]);
impl Default for Vec3 {
fn default() -> Self {
Self([0; 12])
}
}
impl core::fmt::Debug for Vec3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Vec3")
.field("x", &self.x())
.field("y", &self.y())
.field("z", &self.z())
.finish()
}
}
impl flatbuffers::SimpleToVerifyInSlice for Vec3 {}
impl<'a> flatbuffers::Follow<'a> for Vec3 {
type Inner = &'a Vec3;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
<&'a Vec3>::follow(buf, loc)
}
}
impl<'a> flatbuffers::Follow<'a> for &'a Vec3 {
type Inner = &'a Vec3;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
flatbuffers::follow_cast_ref::<Vec3>(buf, loc)
}
}
impl<'b> flatbuffers::Push for Vec3 {
type Output = Vec3;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = ::core::slice::from_raw_parts(self as *const Vec3 as *const u8, Self::size());
dst.copy_from_slice(src);
}
}
impl<'a> flatbuffers::Verifiable for Vec3 {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.in_buffer::<Self>(pos)
}
}
impl<'a> Vec3 {
#[allow(clippy::too_many_arguments)]
pub fn new(
x: f32,
y: f32,
z: f32,
) -> Self {
let mut s = Self([0; 12]);
s.set_x(x);
s.set_y(y);
s.set_z(z);
s
}
pub const fn get_fully_qualified_name() -> &'static str {
"StardustXR.Vec3"
}
pub fn x(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[0..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_x(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[0..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn y(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[4..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_y(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[4..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn z(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[8..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_z(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[8..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn unpack(&self) -> Vec3T {
Vec3T {
x: self.x(),
y: self.y(),
z: self.z(),
}
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Vec3T {
pub x: f32,
pub y: f32,
pub z: f32,
}
impl Vec3T {
pub fn pack(&self) -> Vec3 {
Vec3::new(
self.x,
self.y,
self.z,
)
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Quat(pub [u8; 16]);
impl Default for Quat {
fn default() -> Self {
Self([0; 16])
}
}
impl core::fmt::Debug for Quat {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Quat")
.field("x", &self.x())
.field("y", &self.y())
.field("z", &self.z())
.field("w", &self.w())
.finish()
}
}
impl flatbuffers::SimpleToVerifyInSlice for Quat {}
impl<'a> flatbuffers::Follow<'a> for Quat {
type Inner = &'a Quat;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
<&'a Quat>::follow(buf, loc)
}
}
impl<'a> flatbuffers::Follow<'a> for &'a Quat {
type Inner = &'a Quat;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
flatbuffers::follow_cast_ref::<Quat>(buf, loc)
}
}
impl<'b> flatbuffers::Push for Quat {
type Output = Quat;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = ::core::slice::from_raw_parts(self as *const Quat as *const u8, Self::size());
dst.copy_from_slice(src);
}
}
impl<'a> flatbuffers::Verifiable for Quat {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.in_buffer::<Self>(pos)
}
}
impl<'a> Quat {
#[allow(clippy::too_many_arguments)]
pub fn new(
x: f32,
y: f32,
z: f32,
w: f32,
) -> Self {
let mut s = Self([0; 16]);
s.set_x(x);
s.set_y(y);
s.set_z(z);
s.set_w(w);
s
}
pub const fn get_fully_qualified_name() -> &'static str {
"StardustXR.Quat"
}
pub fn x(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[0..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_x(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[0..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn y(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[4..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_y(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[4..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn z(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[8..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_z(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[8..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn w(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[12..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_w(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[12..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn unpack(&self) -> QuatT {
QuatT {
x: self.x(),
y: self.y(),
z: self.z(),
w: self.w(),
}
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct QuatT {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
impl QuatT {
pub fn pack(&self) -> Quat {
Quat::new(
self.x,
self.y,
self.z,
self.w,
)
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Pose(pub [u8; 28]);
impl Default for Pose {
fn default() -> Self {
Self([0; 28])
}
}
impl core::fmt::Debug for Pose {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Pose")
.field("position", &self.position())
.field("rotation", &self.rotation())
.finish()
}
}
impl flatbuffers::SimpleToVerifyInSlice for Pose {}
impl<'a> flatbuffers::Follow<'a> for Pose {
type Inner = &'a Pose;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
<&'a Pose>::follow(buf, loc)
}
}
impl<'a> flatbuffers::Follow<'a> for &'a Pose {
type Inner = &'a Pose;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
flatbuffers::follow_cast_ref::<Pose>(buf, loc)
}
}
impl<'b> flatbuffers::Push for Pose {
type Output = Pose;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = ::core::slice::from_raw_parts(self as *const Pose as *const u8, Self::size());
dst.copy_from_slice(src);
}
}
impl<'a> flatbuffers::Verifiable for Pose {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.in_buffer::<Self>(pos)
}
}
impl<'a> Pose {
#[allow(clippy::too_many_arguments)]
pub fn new(
position: &Vec3,
rotation: &Quat,
) -> Self {
let mut s = Self([0; 28]);
s.set_position(position);
s.set_rotation(rotation);
s
}
pub const fn get_fully_qualified_name() -> &'static str {
"StardustXR.Pose"
}
pub fn position(&self) -> &Vec3 {
unsafe { &*(self.0[0..].as_ptr() as *const Vec3) }
}
#[allow(clippy::identity_op)]
pub fn set_position(&mut self, x: &Vec3) {
self.0[0..0 + 12].copy_from_slice(&x.0)
}
pub fn rotation(&self) -> &Quat {
unsafe { &*(self.0[12..].as_ptr() as *const Quat) }
}
#[allow(clippy::identity_op)]
pub fn set_rotation(&mut self, x: &Quat) {
self.0[12..12 + 16].copy_from_slice(&x.0)
}
pub fn unpack(&self) -> PoseT {
PoseT {
position: self.position().unpack(),
rotation: self.rotation().unpack(),
}
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct PoseT {
pub position: Vec3T,
pub rotation: QuatT,
}
impl PoseT {
pub fn pack(&self) -> Pose {
Pose::new(
&self.position.pack(),
&self.rotation.pack(),
)
}
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Joint(pub [u8; 32]);
impl Default for Joint {
fn default() -> Self {
Self([0; 32])
}
}
impl core::fmt::Debug for Joint {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Joint")
.field("position", &self.position())
.field("rotation", &self.rotation())
.field("radius", &self.radius())
.finish()
}
}
impl flatbuffers::SimpleToVerifyInSlice for Joint {}
impl<'a> flatbuffers::Follow<'a> for Joint {
type Inner = &'a Joint;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
<&'a Joint>::follow(buf, loc)
}
}
impl<'a> flatbuffers::Follow<'a> for &'a Joint {
type Inner = &'a Joint;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
flatbuffers::follow_cast_ref::<Joint>(buf, loc)
}
}
impl<'b> flatbuffers::Push for Joint {
type Output = Joint;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
let src = ::core::slice::from_raw_parts(self as *const Joint as *const u8, Self::size());
dst.copy_from_slice(src);
}
}
impl<'a> flatbuffers::Verifiable for Joint {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.in_buffer::<Self>(pos)
}
}
impl<'a> Joint {
#[allow(clippy::too_many_arguments)]
pub fn new(
position: &Vec3,
rotation: &Quat,
radius: f32,
) -> Self {
let mut s = Self([0; 32]);
s.set_position(position);
s.set_rotation(rotation);
s.set_radius(radius);
s
}
pub const fn get_fully_qualified_name() -> &'static str {
"StardustXR.Joint"
}
pub fn position(&self) -> &Vec3 {
unsafe { &*(self.0[0..].as_ptr() as *const Vec3) }
}
#[allow(clippy::identity_op)]
pub fn set_position(&mut self, x: &Vec3) {
self.0[0..0 + 12].copy_from_slice(&x.0)
}
pub fn rotation(&self) -> &Quat {
unsafe { &*(self.0[12..].as_ptr() as *const Quat) }
}
#[allow(clippy::identity_op)]
pub fn set_rotation(&mut self, x: &Quat) {
self.0[12..12 + 16].copy_from_slice(&x.0)
}
pub fn radius(&self) -> f32 {
let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
EndianScalar::from_little_endian(unsafe {
core::ptr::copy_nonoverlapping(
self.0[28..].as_ptr(),
mem.as_mut_ptr() as *mut u8,
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
mem.assume_init()
})
}
pub fn set_radius(&mut self, x: f32) {
let x_le = x.to_little_endian();
unsafe {
core::ptr::copy_nonoverlapping(
&x_le as *const _ as *const u8,
self.0[28..].as_mut_ptr(),
core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
);
}
}
pub fn unpack(&self) -> JointT {
JointT {
position: self.position().unpack(),
rotation: self.rotation().unpack(),
radius: self.radius(),
}
}
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct JointT {
pub position: Vec3T,
pub rotation: QuatT,
pub radius: f32,
}
impl JointT {
pub fn pack(&self) -> Joint {
Joint::new(
&self.position.pack(),
&self.rotation.pack(),
self.radius,
)
}
}
}