pub const mjVERSION_HEADER: u32 = 200;
pub const mjMINVAL: f64 = 0.000000000000001;
pub const mjPI: f64 = 3.141592653589793;
pub const mjMAXVAL: f64 = 10000000000.0;
pub const mjMINMU: f64 = 0.00001;
pub const mjMINIMP: f64 = 0.0001;
pub const mjMAXIMP: f64 = 0.9999;
pub const mjMAXCONPAIR: u32 = 50;
pub const mjMAXVFS: u32 = 200;
pub const mjMAXVFSNAME: u32 = 100;
pub const mjNEQDATA: u32 = 7;
pub const mjNDYN: u32 = 10;
pub const mjNGAIN: u32 = 10;
pub const mjNBIAS: u32 = 10;
pub const mjNREF: u32 = 2;
pub const mjNIMP: u32 = 5;
pub const mjNSOLVER: u32 = 1000;
pub const mjNGROUP: u32 = 6;
pub const mjMAXOVERLAY: u32 = 500;
pub const mjMAXLINE: u32 = 100;
pub const mjMAXLINEPNT: u32 = 1000;
pub const mjMAXPLANEGRID: u32 = 200;
pub const mjNAUX: u32 = 10;
pub const mjMAXTEXTURE: u32 = 1000;
pub const mjMAXUISECT: u32 = 10;
pub const mjMAXUIITEM: u32 = 80;
pub const mjMAXUITEXT: u32 = 500;
pub const mjMAXUINAME: u32 = 40;
pub const mjMAXUIMULTI: u32 = 20;
pub const mjMAXUIEDIT: u32 = 5;
pub const mjMAXUIRECT: u32 = 15;
pub const mjKEY_ESCAPE: u32 = 256;
pub const mjKEY_ENTER: u32 = 257;
pub const mjKEY_TAB: u32 = 258;
pub const mjKEY_BACKSPACE: u32 = 259;
pub const mjKEY_INSERT: u32 = 260;
pub const mjKEY_DELETE: u32 = 261;
pub const mjKEY_RIGHT: u32 = 262;
pub const mjKEY_LEFT: u32 = 263;
pub const mjKEY_DOWN: u32 = 264;
pub const mjKEY_UP: u32 = 265;
pub const mjKEY_PAGE_UP: u32 = 266;
pub const mjKEY_PAGE_DOWN: u32 = 267;
pub const mjKEY_HOME: u32 = 268;
pub const mjKEY_END: u32 = 269;
pub const mjKEY_F1: u32 = 290;
pub const mjKEY_F2: u32 = 291;
pub const mjKEY_F3: u32 = 292;
pub const mjKEY_F4: u32 = 293;
pub const mjKEY_F5: u32 = 294;
pub const mjKEY_F6: u32 = 295;
pub const mjKEY_F7: u32 = 296;
pub const mjKEY_F8: u32 = 297;
pub const mjKEY_F9: u32 = 298;
pub const mjKEY_F10: u32 = 299;
pub const mjKEY_F11: u32 = 300;
pub const mjKEY_F12: u32 = 301;
pub type mjtNum = f64;
pub type mjtByte = ::std::os::raw::c_uchar;
impl _mjtDisableBit {
pub const CONSTRAINT: _mjtDisableBit = _mjtDisableBit(1);
}
impl _mjtDisableBit {
pub const EQUALITY: _mjtDisableBit = _mjtDisableBit(2);
}
impl _mjtDisableBit {
pub const FRICTIONLOSS: _mjtDisableBit = _mjtDisableBit(4);
}
impl _mjtDisableBit {
pub const LIMIT: _mjtDisableBit = _mjtDisableBit(8);
}
impl _mjtDisableBit {
pub const CONTACT: _mjtDisableBit = _mjtDisableBit(16);
}
impl _mjtDisableBit {
pub const PASSIVE: _mjtDisableBit = _mjtDisableBit(32);
}
impl _mjtDisableBit {
pub const GRAVITY: _mjtDisableBit = _mjtDisableBit(64);
}
impl _mjtDisableBit {
pub const CLAMPCTRL: _mjtDisableBit = _mjtDisableBit(128);
}
impl _mjtDisableBit {
pub const WARMSTART: _mjtDisableBit = _mjtDisableBit(256);
}
impl _mjtDisableBit {
pub const FILTERPARENT: _mjtDisableBit = _mjtDisableBit(512);
}
impl _mjtDisableBit {
pub const ACTUATION: _mjtDisableBit = _mjtDisableBit(1024);
}
impl _mjtDisableBit {
pub const REFSAFE: _mjtDisableBit = _mjtDisableBit(2048);
}
impl _mjtDisableBit {
pub const mjNDISABLE: _mjtDisableBit = _mjtDisableBit(12);
}
impl ::std::ops::BitOr<_mjtDisableBit> for _mjtDisableBit {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_mjtDisableBit(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _mjtDisableBit {
#[inline]
fn bitor_assign(&mut self, rhs: _mjtDisableBit) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_mjtDisableBit> for _mjtDisableBit {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_mjtDisableBit(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _mjtDisableBit {
#[inline]
fn bitand_assign(&mut self, rhs: _mjtDisableBit) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _mjtDisableBit(pub u32);
pub use self::_mjtDisableBit as mjtDisableBit;
impl _mjtEnableBit {
pub const OVERRIDE: _mjtEnableBit = _mjtEnableBit(1);
}
impl _mjtEnableBit {
pub const ENERGY: _mjtEnableBit = _mjtEnableBit(2);
}
impl _mjtEnableBit {
pub const FWDINV: _mjtEnableBit = _mjtEnableBit(4);
}
impl _mjtEnableBit {
pub const SENSORNOISE: _mjtEnableBit = _mjtEnableBit(8);
}
impl _mjtEnableBit {
pub const mjNENABLE: _mjtEnableBit = _mjtEnableBit(4);
}
impl ::std::ops::BitOr<_mjtEnableBit> for _mjtEnableBit {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_mjtEnableBit(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _mjtEnableBit {
#[inline]
fn bitor_assign(&mut self, rhs: _mjtEnableBit) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_mjtEnableBit> for _mjtEnableBit {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_mjtEnableBit(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _mjtEnableBit {
#[inline]
fn bitand_assign(&mut self, rhs: _mjtEnableBit) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _mjtEnableBit(pub u32);
pub use self::_mjtEnableBit as mjtEnableBit;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtJoint {
FREE = 0,
BALL = 1,
SLIDE = 2,
HINGE = 3,
}
pub use self::_mjtJoint as mjtJoint;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtGeom {
PLANE = 0,
HFIELD = 1,
SPHERE = 2,
CAPSULE = 3,
ELLIPSOID = 4,
CYLINDER = 5,
BOX = 6,
MESH = 7,
mjNGEOMTYPES = 8,
ARROW = 100,
ARROW1 = 101,
ARROW2 = 102,
LINE = 103,
SKIN = 104,
LABEL = 105,
NONE = 1001,
}
pub use self::_mjtGeom as mjtGeom;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtCamLight {
FIXED = 0,
TRACK = 1,
TRACKCOM = 2,
TARGETBODY = 3,
TARGETBODYCOM = 4,
}
pub use self::_mjtCamLight as mjtCamLight;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtTexture {
TWO_D = 0,
CUBE = 1,
SKYBOX = 2,
}
pub use self::_mjtTexture as mjtTexture;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtIntegrator {
EULER = 0,
RK4 = 1,
}
pub use self::_mjtIntegrator as mjtIntegrator;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtCollision {
ALL = 0,
PAIR = 1,
DYNAMIC = 2,
}
pub use self::_mjtCollision as mjtCollision;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtCone {
PYRAMIDAL = 0,
ELLIPTIC = 1,
}
pub use self::_mjtCone as mjtCone;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtJacobian {
DENSE = 0,
SPARSE = 1,
AUTO = 2,
}
pub use self::_mjtJacobian as mjtJacobian;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtSolver {
PGS = 0,
CG = 1,
NEWTON = 2,
}
pub use self::_mjtSolver as mjtSolver;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtEq {
CONNECT = 0,
WELD = 1,
JOINT = 2,
TENDON = 3,
DISTANCE = 4,
}
pub use self::_mjtEq as mjtEq;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtWrap {
NONE = 0,
JOINT = 1,
PULLEY = 2,
SITE = 3,
SPHERE = 4,
CYLINDER = 5,
}
pub use self::_mjtWrap as mjtWrap;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtTrn {
JOINT = 0,
JOINTINPARENT = 1,
SLIDERCRANK = 2,
TENDON = 3,
SITE = 4,
UNDEFINED = 1000,
}
pub use self::_mjtTrn as mjtTrn;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtDyn {
NONE = 0,
INTEGRATOR = 1,
FILTER = 2,
MUSCLE = 3,
USER = 4,
}
pub use self::_mjtDyn as mjtDyn;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtGain {
FIXED = 0,
MUSCLE = 1,
USER = 2,
}
pub use self::_mjtGain as mjtGain;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtBias {
NONE = 0,
AFFINE = 1,
MUSCLE = 2,
USER = 3,
}
pub use self::_mjtBias as mjtBias;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtObj {
UNKNOWN = 0,
BODY = 1,
XBODY = 2,
JOINT = 3,
DOF = 4,
GEOM = 5,
SITE = 6,
CAMERA = 7,
LIGHT = 8,
MESH = 9,
SKIN = 10,
HFIELD = 11,
TEXTURE = 12,
MATERIAL = 13,
PAIR = 14,
EXCLUDE = 15,
EQUALITY = 16,
TENDON = 17,
ACTUATOR = 18,
SENSOR = 19,
NUMERIC = 20,
TEXT = 21,
TUPLE = 22,
KEY = 23,
}
pub use self::_mjtObj as mjtObj;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtConstraint {
EQUALITY = 0,
FRICTION_DOF = 1,
FRICTION_TENDON = 2,
LIMIT_JOINT = 3,
LIMIT_TENDON = 4,
CONTACT_FRICTIONLESS = 5,
CONTACT_PYRAMIDAL = 6,
CONTACT_ELLIPTIC = 7,
}
pub use self::_mjtConstraint as mjtConstraint;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtConstraintState {
SATISFIED = 0,
QUADRATIC = 1,
LINEARNEG = 2,
LINEARPOS = 3,
CONE = 4,
}
pub use self::_mjtConstraintState as mjtConstraintState;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtSensor {
TOUCH = 0,
ACCELEROMETER = 1,
VELOCIMETER = 2,
GYRO = 3,
FORCE = 4,
TORQUE = 5,
MAGNETOMETER = 6,
RANGEFINDER = 7,
JOINTPOS = 8,
JOINTVEL = 9,
TENDONPOS = 10,
TENDONVEL = 11,
ACTUATORPOS = 12,
ACTUATORVEL = 13,
ACTUATORFRC = 14,
BALLQUAT = 15,
BALLANGVEL = 16,
JOINTLIMITPOS = 17,
JOINTLIMITVEL = 18,
JOINTLIMITFRC = 19,
TENDONLIMITPOS = 20,
TENDONLIMITVEL = 21,
TENDONLIMITFRC = 22,
FRAMEPOS = 23,
FRAMEQUAT = 24,
FRAMEXAXIS = 25,
FRAMEYAXIS = 26,
FRAMEZAXIS = 27,
FRAMELINVEL = 28,
FRAMEANGVEL = 29,
FRAMELINACC = 30,
FRAMEANGACC = 31,
SUBTREECOM = 32,
SUBTREELINVEL = 33,
SUBTREEANGMOM = 34,
USER = 35,
}
pub use self::_mjtSensor as mjtSensor;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtStage {
NONE = 0,
POS = 1,
VEL = 2,
ACC = 3,
}
pub use self::_mjtStage as mjtStage;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtDataType {
REAL = 0,
POSITIVE = 1,
AXIS = 2,
QUATERNION = 3,
}
pub use self::_mjtDataType as mjtDataType;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtLRMode {
NONE = 0,
MUSCLE = 1,
MUSCLEUSER = 2,
ALL = 3,
}
pub use self::_mjtLRMode as mjtLRMode;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjLROpt {
pub mode: ::std::os::raw::c_int,
pub useexisting: ::std::os::raw::c_int,
pub uselimit: ::std::os::raw::c_int,
pub accel: mjtNum,
pub maxforce: mjtNum,
pub timeconst: mjtNum,
pub timestep: mjtNum,
pub inttotal: mjtNum,
pub inteval: mjtNum,
pub tolrange: mjtNum,
}
#[test]
fn bindgen_test_layout__mjLROpt() {
assert_eq!(
::std::mem::size_of::<_mjLROpt>(),
72usize,
concat!("Size of: ", stringify!(_mjLROpt))
);
assert_eq!(
::std::mem::align_of::<_mjLROpt>(),
8usize,
concat!("Alignment of ", stringify!(_mjLROpt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).mode as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjLROpt>())).useexisting as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(useexisting)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).uselimit as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(uselimit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).accel as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(accel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).maxforce as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(maxforce)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).timeconst as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(timeconst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).timestep as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(timestep)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).inttotal as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(inttotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).inteval as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(inteval)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjLROpt>())).tolrange as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_mjLROpt),
"::",
stringify!(tolrange)
)
);
}
pub type mjLROpt = _mjLROpt;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjVFS {
pub nfile: ::std::os::raw::c_int,
pub filename: [[::std::os::raw::c_char; 100usize]; 200usize],
pub filesize: [::std::os::raw::c_int; 200usize],
pub filedata: [*mut ::std::os::raw::c_void; 200usize],
}
#[test]
fn bindgen_test_layout__mjVFS() {
assert_eq!(
::std::mem::size_of::<_mjVFS>(),
22408usize,
concat!("Size of: ", stringify!(_mjVFS))
);
assert_eq!(
::std::mem::align_of::<_mjVFS>(),
8usize,
concat!("Alignment of ", stringify!(_mjVFS))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVFS>())).nfile as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVFS),
"::",
stringify!(nfile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVFS>())).filename as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjVFS),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVFS>())).filesize as *const _ as usize },
20004usize,
concat!(
"Offset of field: ",
stringify!(_mjVFS),
"::",
stringify!(filesize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVFS>())).filedata as *const _ as usize },
20808usize,
concat!(
"Offset of field: ",
stringify!(_mjVFS),
"::",
stringify!(filedata)
)
);
}
impl Default for _mjVFS {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjVFS = _mjVFS;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjOption {
pub timestep: mjtNum,
pub apirate: mjtNum,
pub impratio: mjtNum,
pub tolerance: mjtNum,
pub noslip_tolerance: mjtNum,
pub mpr_tolerance: mjtNum,
pub gravity: [mjtNum; 3usize],
pub wind: [mjtNum; 3usize],
pub magnetic: [mjtNum; 3usize],
pub density: mjtNum,
pub viscosity: mjtNum,
pub o_margin: mjtNum,
pub o_solref: [mjtNum; 2usize],
pub o_solimp: [mjtNum; 5usize],
pub integrator: ::std::os::raw::c_int,
pub collision: ::std::os::raw::c_int,
pub cone: ::std::os::raw::c_int,
pub jacobian: ::std::os::raw::c_int,
pub solver: ::std::os::raw::c_int,
pub iterations: ::std::os::raw::c_int,
pub noslip_iterations: ::std::os::raw::c_int,
pub mpr_iterations: ::std::os::raw::c_int,
pub disableflags: ::std::os::raw::c_int,
pub enableflags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjOption() {
assert_eq!(
::std::mem::size_of::<_mjOption>(),
240usize,
concat!("Size of: ", stringify!(_mjOption))
);
assert_eq!(
::std::mem::align_of::<_mjOption>(),
8usize,
concat!("Alignment of ", stringify!(_mjOption))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).timestep as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(timestep)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).apirate as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(apirate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).impratio as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(impratio)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).tolerance as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(tolerance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).noslip_tolerance as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(noslip_tolerance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).mpr_tolerance as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(mpr_tolerance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).gravity as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(gravity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).wind as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(wind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).magnetic as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(magnetic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).density as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(density)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).viscosity as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(viscosity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).o_margin as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(o_margin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).o_solref as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(o_solref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).o_solimp as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(o_solimp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).integrator as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(integrator)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).collision as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(collision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).cone as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(cone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).jacobian as *const _ as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(jacobian)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjOption>())).solver as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(solver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).iterations as *const _ as usize
},
220usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(iterations)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).noslip_iterations as *const _ as usize
},
224usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(noslip_iterations)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).mpr_iterations as *const _ as usize
},
228usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(mpr_iterations)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).disableflags as *const _ as usize
},
232usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(disableflags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjOption>())).enableflags as *const _ as usize
},
236usize,
concat!(
"Offset of field: ",
stringify!(_mjOption),
"::",
stringify!(enableflags)
)
);
}
pub type mjOption = _mjOption;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual {
pub global: _mjVisual__bindgen_ty_1,
pub quality: _mjVisual__bindgen_ty_2,
pub headlight: _mjVisual__bindgen_ty_3,
pub map: _mjVisual__bindgen_ty_4,
pub scale: _mjVisual__bindgen_ty_5,
pub rgba: _mjVisual__bindgen_ty_6,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_1 {
pub fovy: f32,
pub ipd: f32,
pub linewidth: f32,
pub glow: f32,
pub offwidth: ::std::os::raw::c_int,
pub offheight: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_1>(),
24usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).fovy as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(fovy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).ipd as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(ipd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).linewidth as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(linewidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).glow as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(glow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).offwidth as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(offwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_1>())).offheight as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_1),
"::",
stringify!(offheight)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_2 {
pub shadowsize: ::std::os::raw::c_int,
pub offsamples: ::std::os::raw::c_int,
pub numslices: ::std::os::raw::c_int,
pub numstacks: ::std::os::raw::c_int,
pub numquads: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_2>(),
20usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_2>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_2>())).shadowsize as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_2),
"::",
stringify!(shadowsize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_2>())).offsamples as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_2),
"::",
stringify!(offsamples)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_2>())).numslices as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_2),
"::",
stringify!(numslices)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_2>())).numstacks as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_2),
"::",
stringify!(numstacks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_2>())).numquads as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_2),
"::",
stringify!(numquads)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_3 {
pub ambient: [f32; 3usize],
pub diffuse: [f32; 3usize],
pub specular: [f32; 3usize],
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_3>(),
40usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_3>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_3>())).ambient as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_3),
"::",
stringify!(ambient)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_3>())).diffuse as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_3),
"::",
stringify!(diffuse)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_3>())).specular as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_3),
"::",
stringify!(specular)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_3>())).active as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_3),
"::",
stringify!(active)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_4 {
pub stiffness: f32,
pub stiffnessrot: f32,
pub force: f32,
pub torque: f32,
pub alpha: f32,
pub fogstart: f32,
pub fogend: f32,
pub znear: f32,
pub zfar: f32,
pub haze: f32,
pub shadowclip: f32,
pub shadowscale: f32,
pub actuatortendon: f32,
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_4() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_4>(),
52usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_4))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_4>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_4))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).stiffness as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(stiffness)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).stiffnessrot as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(stiffnessrot)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).force as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(force)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).torque as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(torque)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).alpha as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(alpha)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).fogstart as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(fogstart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).fogend as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(fogend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).znear as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(znear)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).zfar as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(zfar)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).haze as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(haze)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).shadowclip as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(shadowclip)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).shadowscale as *const _
as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(shadowscale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_4>())).actuatortendon
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_4),
"::",
stringify!(actuatortendon)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_5 {
pub forcewidth: f32,
pub contactwidth: f32,
pub contactheight: f32,
pub connect: f32,
pub com: f32,
pub camera: f32,
pub light: f32,
pub selectpoint: f32,
pub jointlength: f32,
pub jointwidth: f32,
pub actuatorlength: f32,
pub actuatorwidth: f32,
pub framelength: f32,
pub framewidth: f32,
pub constraint: f32,
pub slidercrank: f32,
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_5() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_5>(),
64usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_5))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_5>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_5))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).forcewidth as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(forcewidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).contactwidth as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(contactwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).contactheight
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(contactheight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).connect as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(connect)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).com as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(com)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).camera as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(camera)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).light as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(light)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).selectpoint as *const _
as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(selectpoint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).jointlength as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(jointlength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).jointwidth as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(jointwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).actuatorlength
as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(actuatorlength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).actuatorwidth
as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(actuatorwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).framelength as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(framelength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).framewidth as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(framewidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).constraint as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(constraint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_5>())).slidercrank as *const _
as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_5),
"::",
stringify!(slidercrank)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjVisual__bindgen_ty_6 {
pub fog: [f32; 4usize],
pub haze: [f32; 4usize],
pub force: [f32; 4usize],
pub inertia: [f32; 4usize],
pub joint: [f32; 4usize],
pub actuator: [f32; 4usize],
pub actuatornegative: [f32; 4usize],
pub actuatorpositive: [f32; 4usize],
pub com: [f32; 4usize],
pub camera: [f32; 4usize],
pub light: [f32; 4usize],
pub selectpoint: [f32; 4usize],
pub connect: [f32; 4usize],
pub contactpoint: [f32; 4usize],
pub contactforce: [f32; 4usize],
pub contactfriction: [f32; 4usize],
pub contacttorque: [f32; 4usize],
pub contactgap: [f32; 4usize],
pub rangefinder: [f32; 4usize],
pub constraint: [f32; 4usize],
pub slidercrank: [f32; 4usize],
pub crankbroken: [f32; 4usize],
}
#[test]
fn bindgen_test_layout__mjVisual__bindgen_ty_6() {
assert_eq!(
::std::mem::size_of::<_mjVisual__bindgen_ty_6>(),
352usize,
concat!("Size of: ", stringify!(_mjVisual__bindgen_ty_6))
);
assert_eq!(
::std::mem::align_of::<_mjVisual__bindgen_ty_6>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual__bindgen_ty_6))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).fog as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(fog)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).haze as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(haze)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).force as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(force)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).inertia as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(inertia)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).joint as *const _
as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(joint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).actuator as *const _
as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(actuator)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).actuatornegative
as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(actuatornegative)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).actuatorpositive
as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(actuatorpositive)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).com as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(com)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).camera as *const _
as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(camera)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).light as *const _
as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(light)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).selectpoint as *const _
as usize
},
176usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(selectpoint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).connect as *const _
as usize
},
192usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(connect)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).contactpoint as *const _
as usize
},
208usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(contactpoint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).contactforce as *const _
as usize
},
224usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(contactforce)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).contactfriction
as *const _ as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(contactfriction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).contacttorque
as *const _ as usize
},
256usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(contacttorque)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).contactgap as *const _
as usize
},
272usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(contactgap)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).rangefinder as *const _
as usize
},
288usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(rangefinder)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).constraint as *const _
as usize
},
304usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(constraint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).slidercrank as *const _
as usize
},
320usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(slidercrank)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjVisual__bindgen_ty_6>())).crankbroken as *const _
as usize
},
336usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual__bindgen_ty_6),
"::",
stringify!(crankbroken)
)
);
}
#[test]
fn bindgen_test_layout__mjVisual() {
assert_eq!(
::std::mem::size_of::<_mjVisual>(),
552usize,
concat!("Size of: ", stringify!(_mjVisual))
);
assert_eq!(
::std::mem::align_of::<_mjVisual>(),
4usize,
concat!("Alignment of ", stringify!(_mjVisual))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).global as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(global)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).quality as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(quality)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).headlight as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(headlight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).map as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(map)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).scale as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjVisual>())).rgba as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_mjVisual),
"::",
stringify!(rgba)
)
);
}
pub type mjVisual = _mjVisual;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjStatistic {
pub meaninertia: mjtNum,
pub meanmass: mjtNum,
pub meansize: mjtNum,
pub extent: mjtNum,
pub center: [mjtNum; 3usize],
}
#[test]
fn bindgen_test_layout__mjStatistic() {
assert_eq!(
::std::mem::size_of::<_mjStatistic>(),
56usize,
concat!("Size of: ", stringify!(_mjStatistic))
);
assert_eq!(
::std::mem::align_of::<_mjStatistic>(),
8usize,
concat!("Alignment of ", stringify!(_mjStatistic))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjStatistic>())).meaninertia as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjStatistic),
"::",
stringify!(meaninertia)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjStatistic>())).meanmass as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjStatistic),
"::",
stringify!(meanmass)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjStatistic>())).meansize as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjStatistic),
"::",
stringify!(meansize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjStatistic>())).extent as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjStatistic),
"::",
stringify!(extent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjStatistic>())).center as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjStatistic),
"::",
stringify!(center)
)
);
}
pub type mjStatistic = _mjStatistic;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mjModel {
pub nq: ::std::os::raw::c_int,
pub nv: ::std::os::raw::c_int,
pub nu: ::std::os::raw::c_int,
pub na: ::std::os::raw::c_int,
pub nbody: ::std::os::raw::c_int,
pub njnt: ::std::os::raw::c_int,
pub ngeom: ::std::os::raw::c_int,
pub nsite: ::std::os::raw::c_int,
pub ncam: ::std::os::raw::c_int,
pub nlight: ::std::os::raw::c_int,
pub nmesh: ::std::os::raw::c_int,
pub nmeshvert: ::std::os::raw::c_int,
pub nmeshtexvert: ::std::os::raw::c_int,
pub nmeshface: ::std::os::raw::c_int,
pub nmeshgraph: ::std::os::raw::c_int,
pub nskin: ::std::os::raw::c_int,
pub nskinvert: ::std::os::raw::c_int,
pub nskintexvert: ::std::os::raw::c_int,
pub nskinface: ::std::os::raw::c_int,
pub nskinbone: ::std::os::raw::c_int,
pub nskinbonevert: ::std::os::raw::c_int,
pub nhfield: ::std::os::raw::c_int,
pub nhfielddata: ::std::os::raw::c_int,
pub ntex: ::std::os::raw::c_int,
pub ntexdata: ::std::os::raw::c_int,
pub nmat: ::std::os::raw::c_int,
pub npair: ::std::os::raw::c_int,
pub nexclude: ::std::os::raw::c_int,
pub neq: ::std::os::raw::c_int,
pub ntendon: ::std::os::raw::c_int,
pub nwrap: ::std::os::raw::c_int,
pub nsensor: ::std::os::raw::c_int,
pub nnumeric: ::std::os::raw::c_int,
pub nnumericdata: ::std::os::raw::c_int,
pub ntext: ::std::os::raw::c_int,
pub ntextdata: ::std::os::raw::c_int,
pub ntuple: ::std::os::raw::c_int,
pub ntupledata: ::std::os::raw::c_int,
pub nkey: ::std::os::raw::c_int,
pub nuser_body: ::std::os::raw::c_int,
pub nuser_jnt: ::std::os::raw::c_int,
pub nuser_geom: ::std::os::raw::c_int,
pub nuser_site: ::std::os::raw::c_int,
pub nuser_cam: ::std::os::raw::c_int,
pub nuser_tendon: ::std::os::raw::c_int,
pub nuser_actuator: ::std::os::raw::c_int,
pub nuser_sensor: ::std::os::raw::c_int,
pub nnames: ::std::os::raw::c_int,
pub nM: ::std::os::raw::c_int,
pub nemax: ::std::os::raw::c_int,
pub njmax: ::std::os::raw::c_int,
pub nconmax: ::std::os::raw::c_int,
pub nstack: ::std::os::raw::c_int,
pub nuserdata: ::std::os::raw::c_int,
pub nmocap: ::std::os::raw::c_int,
pub nsensordata: ::std::os::raw::c_int,
pub nbuffer: ::std::os::raw::c_int,
pub opt: mjOption,
pub vis: mjVisual,
pub stat: mjStatistic,
pub buffer: *mut ::std::os::raw::c_void,
pub qpos0: *mut mjtNum,
pub qpos_spring: *mut mjtNum,
pub body_parentid: *mut ::std::os::raw::c_int,
pub body_rootid: *mut ::std::os::raw::c_int,
pub body_weldid: *mut ::std::os::raw::c_int,
pub body_mocapid: *mut ::std::os::raw::c_int,
pub body_jntnum: *mut ::std::os::raw::c_int,
pub body_jntadr: *mut ::std::os::raw::c_int,
pub body_dofnum: *mut ::std::os::raw::c_int,
pub body_dofadr: *mut ::std::os::raw::c_int,
pub body_geomnum: *mut ::std::os::raw::c_int,
pub body_geomadr: *mut ::std::os::raw::c_int,
pub body_simple: *mut mjtByte,
pub body_sameframe: *mut mjtByte,
pub body_pos: *mut mjtNum,
pub body_quat: *mut mjtNum,
pub body_ipos: *mut mjtNum,
pub body_iquat: *mut mjtNum,
pub body_mass: *mut mjtNum,
pub body_subtreemass: *mut mjtNum,
pub body_inertia: *mut mjtNum,
pub body_invweight0: *mut mjtNum,
pub body_user: *mut mjtNum,
pub jnt_type: *mut ::std::os::raw::c_int,
pub jnt_qposadr: *mut ::std::os::raw::c_int,
pub jnt_dofadr: *mut ::std::os::raw::c_int,
pub jnt_bodyid: *mut ::std::os::raw::c_int,
pub jnt_group: *mut ::std::os::raw::c_int,
pub jnt_limited: *mut mjtByte,
pub jnt_solref: *mut mjtNum,
pub jnt_solimp: *mut mjtNum,
pub jnt_pos: *mut mjtNum,
pub jnt_axis: *mut mjtNum,
pub jnt_stiffness: *mut mjtNum,
pub jnt_range: *mut mjtNum,
pub jnt_margin: *mut mjtNum,
pub jnt_user: *mut mjtNum,
pub dof_bodyid: *mut ::std::os::raw::c_int,
pub dof_jntid: *mut ::std::os::raw::c_int,
pub dof_parentid: *mut ::std::os::raw::c_int,
pub dof_Madr: *mut ::std::os::raw::c_int,
pub dof_simplenum: *mut ::std::os::raw::c_int,
pub dof_solref: *mut mjtNum,
pub dof_solimp: *mut mjtNum,
pub dof_frictionloss: *mut mjtNum,
pub dof_armature: *mut mjtNum,
pub dof_damping: *mut mjtNum,
pub dof_invweight0: *mut mjtNum,
pub dof_M0: *mut mjtNum,
pub geom_type: *mut ::std::os::raw::c_int,
pub geom_contype: *mut ::std::os::raw::c_int,
pub geom_conaffinity: *mut ::std::os::raw::c_int,
pub geom_condim: *mut ::std::os::raw::c_int,
pub geom_bodyid: *mut ::std::os::raw::c_int,
pub geom_dataid: *mut ::std::os::raw::c_int,
pub geom_matid: *mut ::std::os::raw::c_int,
pub geom_group: *mut ::std::os::raw::c_int,
pub geom_priority: *mut ::std::os::raw::c_int,
pub geom_sameframe: *mut mjtByte,
pub geom_solmix: *mut mjtNum,
pub geom_solref: *mut mjtNum,
pub geom_solimp: *mut mjtNum,
pub geom_size: *mut mjtNum,
pub geom_rbound: *mut mjtNum,
pub geom_pos: *mut mjtNum,
pub geom_quat: *mut mjtNum,
pub geom_friction: *mut mjtNum,
pub geom_margin: *mut mjtNum,
pub geom_gap: *mut mjtNum,
pub geom_user: *mut mjtNum,
pub geom_rgba: *mut f32,
pub site_type: *mut ::std::os::raw::c_int,
pub site_bodyid: *mut ::std::os::raw::c_int,
pub site_matid: *mut ::std::os::raw::c_int,
pub site_group: *mut ::std::os::raw::c_int,
pub site_sameframe: *mut mjtByte,
pub site_size: *mut mjtNum,
pub site_pos: *mut mjtNum,
pub site_quat: *mut mjtNum,
pub site_user: *mut mjtNum,
pub site_rgba: *mut f32,
pub cam_mode: *mut ::std::os::raw::c_int,
pub cam_bodyid: *mut ::std::os::raw::c_int,
pub cam_targetbodyid: *mut ::std::os::raw::c_int,
pub cam_pos: *mut mjtNum,
pub cam_quat: *mut mjtNum,
pub cam_poscom0: *mut mjtNum,
pub cam_pos0: *mut mjtNum,
pub cam_mat0: *mut mjtNum,
pub cam_fovy: *mut mjtNum,
pub cam_ipd: *mut mjtNum,
pub cam_user: *mut mjtNum,
pub light_mode: *mut ::std::os::raw::c_int,
pub light_bodyid: *mut ::std::os::raw::c_int,
pub light_targetbodyid: *mut ::std::os::raw::c_int,
pub light_directional: *mut mjtByte,
pub light_castshadow: *mut mjtByte,
pub light_active: *mut mjtByte,
pub light_pos: *mut mjtNum,
pub light_dir: *mut mjtNum,
pub light_poscom0: *mut mjtNum,
pub light_pos0: *mut mjtNum,
pub light_dir0: *mut mjtNum,
pub light_attenuation: *mut f32,
pub light_cutoff: *mut f32,
pub light_exponent: *mut f32,
pub light_ambient: *mut f32,
pub light_diffuse: *mut f32,
pub light_specular: *mut f32,
pub mesh_vertadr: *mut ::std::os::raw::c_int,
pub mesh_vertnum: *mut ::std::os::raw::c_int,
pub mesh_texcoordadr: *mut ::std::os::raw::c_int,
pub mesh_faceadr: *mut ::std::os::raw::c_int,
pub mesh_facenum: *mut ::std::os::raw::c_int,
pub mesh_graphadr: *mut ::std::os::raw::c_int,
pub mesh_vert: *mut f32,
pub mesh_normal: *mut f32,
pub mesh_texcoord: *mut f32,
pub mesh_face: *mut ::std::os::raw::c_int,
pub mesh_graph: *mut ::std::os::raw::c_int,
pub skin_matid: *mut ::std::os::raw::c_int,
pub skin_rgba: *mut f32,
pub skin_inflate: *mut f32,
pub skin_vertadr: *mut ::std::os::raw::c_int,
pub skin_vertnum: *mut ::std::os::raw::c_int,
pub skin_texcoordadr: *mut ::std::os::raw::c_int,
pub skin_faceadr: *mut ::std::os::raw::c_int,
pub skin_facenum: *mut ::std::os::raw::c_int,
pub skin_boneadr: *mut ::std::os::raw::c_int,
pub skin_bonenum: *mut ::std::os::raw::c_int,
pub skin_vert: *mut f32,
pub skin_texcoord: *mut f32,
pub skin_face: *mut ::std::os::raw::c_int,
pub skin_bonevertadr: *mut ::std::os::raw::c_int,
pub skin_bonevertnum: *mut ::std::os::raw::c_int,
pub skin_bonebindpos: *mut f32,
pub skin_bonebindquat: *mut f32,
pub skin_bonebodyid: *mut ::std::os::raw::c_int,
pub skin_bonevertid: *mut ::std::os::raw::c_int,
pub skin_bonevertweight: *mut f32,
pub hfield_size: *mut mjtNum,
pub hfield_nrow: *mut ::std::os::raw::c_int,
pub hfield_ncol: *mut ::std::os::raw::c_int,
pub hfield_adr: *mut ::std::os::raw::c_int,
pub hfield_data: *mut f32,
pub tex_type: *mut ::std::os::raw::c_int,
pub tex_height: *mut ::std::os::raw::c_int,
pub tex_width: *mut ::std::os::raw::c_int,
pub tex_adr: *mut ::std::os::raw::c_int,
pub tex_rgb: *mut mjtByte,
pub mat_texid: *mut ::std::os::raw::c_int,
pub mat_texuniform: *mut mjtByte,
pub mat_texrepeat: *mut f32,
pub mat_emission: *mut f32,
pub mat_specular: *mut f32,
pub mat_shininess: *mut f32,
pub mat_reflectance: *mut f32,
pub mat_rgba: *mut f32,
pub pair_dim: *mut ::std::os::raw::c_int,
pub pair_geom1: *mut ::std::os::raw::c_int,
pub pair_geom2: *mut ::std::os::raw::c_int,
pub pair_signature: *mut ::std::os::raw::c_int,
pub pair_solref: *mut mjtNum,
pub pair_solimp: *mut mjtNum,
pub pair_margin: *mut mjtNum,
pub pair_gap: *mut mjtNum,
pub pair_friction: *mut mjtNum,
pub exclude_signature: *mut ::std::os::raw::c_int,
pub eq_type: *mut ::std::os::raw::c_int,
pub eq_obj1id: *mut ::std::os::raw::c_int,
pub eq_obj2id: *mut ::std::os::raw::c_int,
pub eq_active: *mut mjtByte,
pub eq_solref: *mut mjtNum,
pub eq_solimp: *mut mjtNum,
pub eq_data: *mut mjtNum,
pub tendon_adr: *mut ::std::os::raw::c_int,
pub tendon_num: *mut ::std::os::raw::c_int,
pub tendon_matid: *mut ::std::os::raw::c_int,
pub tendon_group: *mut ::std::os::raw::c_int,
pub tendon_limited: *mut mjtByte,
pub tendon_width: *mut mjtNum,
pub tendon_solref_lim: *mut mjtNum,
pub tendon_solimp_lim: *mut mjtNum,
pub tendon_solref_fri: *mut mjtNum,
pub tendon_solimp_fri: *mut mjtNum,
pub tendon_range: *mut mjtNum,
pub tendon_margin: *mut mjtNum,
pub tendon_stiffness: *mut mjtNum,
pub tendon_damping: *mut mjtNum,
pub tendon_frictionloss: *mut mjtNum,
pub tendon_lengthspring: *mut mjtNum,
pub tendon_length0: *mut mjtNum,
pub tendon_invweight0: *mut mjtNum,
pub tendon_user: *mut mjtNum,
pub tendon_rgba: *mut f32,
pub wrap_type: *mut ::std::os::raw::c_int,
pub wrap_objid: *mut ::std::os::raw::c_int,
pub wrap_prm: *mut mjtNum,
pub actuator_trntype: *mut ::std::os::raw::c_int,
pub actuator_dyntype: *mut ::std::os::raw::c_int,
pub actuator_gaintype: *mut ::std::os::raw::c_int,
pub actuator_biastype: *mut ::std::os::raw::c_int,
pub actuator_trnid: *mut ::std::os::raw::c_int,
pub actuator_group: *mut ::std::os::raw::c_int,
pub actuator_ctrllimited: *mut mjtByte,
pub actuator_forcelimited: *mut mjtByte,
pub actuator_dynprm: *mut mjtNum,
pub actuator_gainprm: *mut mjtNum,
pub actuator_biasprm: *mut mjtNum,
pub actuator_ctrlrange: *mut mjtNum,
pub actuator_forcerange: *mut mjtNum,
pub actuator_gear: *mut mjtNum,
pub actuator_cranklength: *mut mjtNum,
pub actuator_acc0: *mut mjtNum,
pub actuator_length0: *mut mjtNum,
pub actuator_lengthrange: *mut mjtNum,
pub actuator_user: *mut mjtNum,
pub sensor_type: *mut ::std::os::raw::c_int,
pub sensor_datatype: *mut ::std::os::raw::c_int,
pub sensor_needstage: *mut ::std::os::raw::c_int,
pub sensor_objtype: *mut ::std::os::raw::c_int,
pub sensor_objid: *mut ::std::os::raw::c_int,
pub sensor_dim: *mut ::std::os::raw::c_int,
pub sensor_adr: *mut ::std::os::raw::c_int,
pub sensor_cutoff: *mut mjtNum,
pub sensor_noise: *mut mjtNum,
pub sensor_user: *mut mjtNum,
pub numeric_adr: *mut ::std::os::raw::c_int,
pub numeric_size: *mut ::std::os::raw::c_int,
pub numeric_data: *mut mjtNum,
pub text_adr: *mut ::std::os::raw::c_int,
pub text_size: *mut ::std::os::raw::c_int,
pub text_data: *mut ::std::os::raw::c_char,
pub tuple_adr: *mut ::std::os::raw::c_int,
pub tuple_size: *mut ::std::os::raw::c_int,
pub tuple_objtype: *mut ::std::os::raw::c_int,
pub tuple_objid: *mut ::std::os::raw::c_int,
pub tuple_objprm: *mut mjtNum,
pub key_time: *mut mjtNum,
pub key_qpos: *mut mjtNum,
pub key_qvel: *mut mjtNum,
pub key_act: *mut mjtNum,
pub name_bodyadr: *mut ::std::os::raw::c_int,
pub name_jntadr: *mut ::std::os::raw::c_int,
pub name_geomadr: *mut ::std::os::raw::c_int,
pub name_siteadr: *mut ::std::os::raw::c_int,
pub name_camadr: *mut ::std::os::raw::c_int,
pub name_lightadr: *mut ::std::os::raw::c_int,
pub name_meshadr: *mut ::std::os::raw::c_int,
pub name_skinadr: *mut ::std::os::raw::c_int,
pub name_hfieldadr: *mut ::std::os::raw::c_int,
pub name_texadr: *mut ::std::os::raw::c_int,
pub name_matadr: *mut ::std::os::raw::c_int,
pub name_pairadr: *mut ::std::os::raw::c_int,
pub name_excludeadr: *mut ::std::os::raw::c_int,
pub name_eqadr: *mut ::std::os::raw::c_int,
pub name_tendonadr: *mut ::std::os::raw::c_int,
pub name_actuatoradr: *mut ::std::os::raw::c_int,
pub name_sensoradr: *mut ::std::os::raw::c_int,
pub name_numericadr: *mut ::std::os::raw::c_int,
pub name_textadr: *mut ::std::os::raw::c_int,
pub name_tupleadr: *mut ::std::os::raw::c_int,
pub name_keyadr: *mut ::std::os::raw::c_int,
pub names: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__mjModel() {
assert_eq!(
::std::mem::size_of::<_mjModel>(),
3200usize,
concat!("Size of: ", stringify!(_mjModel))
);
assert_eq!(
::std::mem::align_of::<_mjModel>(),
8usize,
concat!("Alignment of ", stringify!(_mjModel))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nq as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nv as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nu as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).na as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(na)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nbody as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nbody)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).njnt as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(njnt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ngeom as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ngeom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nsite as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nsite)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ncam as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ncam)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nlight as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nlight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmesh as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmesh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmeshvert as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmeshvert)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nmeshtexvert as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmeshtexvert)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmeshface as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmeshface)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmeshgraph as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmeshgraph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nskin as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nskinvert as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskinvert)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nskintexvert as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskintexvert)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nskinface as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskinface)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nskinbone as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskinbone)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nskinbonevert as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nskinbonevert)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nhfield as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nhfield)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nhfielddata as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nhfielddata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntex as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntexdata as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntexdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmat as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).npair as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(npair)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nexclude as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nexclude)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).neq as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(neq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntendon as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntendon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nwrap as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nwrap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nsensor as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nsensor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nnumeric as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nnumeric)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nnumericdata as *const _ as usize
},
132usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nnumericdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntext as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntextdata as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntextdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntuple as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntuple)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).ntupledata as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(ntupledata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nkey as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nkey)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuser_body as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_body)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuser_jnt as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_jnt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuser_geom as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_geom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuser_site as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_site)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuser_cam as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_cam)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nuser_tendon as *const _ as usize
},
176usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_tendon)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nuser_actuator as *const _ as usize
},
180usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_actuator)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nuser_sensor as *const _ as usize
},
184usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuser_sensor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nnames as *const _ as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nnames)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nM as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nM)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nemax as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nemax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).njmax as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(njmax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nconmax as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nconmax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nstack as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nuserdata as *const _ as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nuserdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nmocap as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nmocap)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).nsensordata as *const _ as usize
},
220usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nsensordata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).nbuffer as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(nbuffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).opt as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(opt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).vis as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(vis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).stat as *const _ as usize },
1024usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(stat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).buffer as *const _ as usize },
1080usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).qpos0 as *const _ as usize },
1088usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(qpos0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).qpos_spring as *const _ as usize
},
1096usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(qpos_spring)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_parentid as *const _ as usize
},
1104usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_parentid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_rootid as *const _ as usize
},
1112usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_rootid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_weldid as *const _ as usize
},
1120usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_weldid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_mocapid as *const _ as usize
},
1128usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_mocapid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_jntnum as *const _ as usize
},
1136usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_jntnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_jntadr as *const _ as usize
},
1144usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_jntadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_dofnum as *const _ as usize
},
1152usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_dofnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_dofadr as *const _ as usize
},
1160usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_dofadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_geomnum as *const _ as usize
},
1168usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_geomnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_geomadr as *const _ as usize
},
1176usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_geomadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_simple as *const _ as usize
},
1184usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_simple)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_sameframe as *const _ as usize
},
1192usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_sameframe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_pos as *const _ as usize },
1200usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_quat as *const _ as usize },
1208usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_quat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_ipos as *const _ as usize },
1216usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_ipos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_iquat as *const _ as usize },
1224usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_iquat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_mass as *const _ as usize },
1232usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_mass)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_subtreemass as *const _ as usize
},
1240usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_subtreemass)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_inertia as *const _ as usize
},
1248usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_inertia)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).body_invweight0 as *const _ as usize
},
1256usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_invweight0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).body_user as *const _ as usize },
1264usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(body_user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_type as *const _ as usize },
1272usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).jnt_qposadr as *const _ as usize
},
1280usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_qposadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_dofadr as *const _ as usize },
1288usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_dofadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_bodyid as *const _ as usize },
1296usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_bodyid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_group as *const _ as usize },
1304usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_group)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).jnt_limited as *const _ as usize
},
1312usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_limited)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_solref as *const _ as usize },
1320usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_solref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_solimp as *const _ as usize },
1328usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_solimp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_pos as *const _ as usize },
1336usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_axis as *const _ as usize },
1344usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_axis)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).jnt_stiffness as *const _ as usize
},
1352usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_stiffness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_range as *const _ as usize },
1360usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_margin as *const _ as usize },
1368usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_margin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).jnt_user as *const _ as usize },
1376usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(jnt_user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_bodyid as *const _ as usize },
1384usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_bodyid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_jntid as *const _ as usize },
1392usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_jntid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_parentid as *const _ as usize
},
1400usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_parentid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_Madr as *const _ as usize },
1408usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_Madr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_simplenum as *const _ as usize
},
1416usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_simplenum)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_solref as *const _ as usize },
1424usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_solref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_solimp as *const _ as usize },
1432usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_solimp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_frictionloss as *const _ as usize
},
1440usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_frictionloss)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_armature as *const _ as usize
},
1448usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_armature)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_damping as *const _ as usize
},
1456usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_damping)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).dof_invweight0 as *const _ as usize
},
1464usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_invweight0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).dof_M0 as *const _ as usize },
1472usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(dof_M0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_type as *const _ as usize },
1480usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_contype as *const _ as usize
},
1488usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_contype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_conaffinity as *const _ as usize
},
1496usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_conaffinity)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_condim as *const _ as usize
},
1504usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_condim)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_bodyid as *const _ as usize
},
1512usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_bodyid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_dataid as *const _ as usize
},
1520usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_dataid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_matid as *const _ as usize },
1528usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_matid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_group as *const _ as usize },
1536usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_group)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_priority as *const _ as usize
},
1544usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_priority)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_sameframe as *const _ as usize
},
1552usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_sameframe)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_solmix as *const _ as usize
},
1560usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_solmix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_solref as *const _ as usize
},
1568usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_solref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_solimp as *const _ as usize
},
1576usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_solimp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_size as *const _ as usize },
1584usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_rbound as *const _ as usize
},
1592usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_rbound)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_pos as *const _ as usize },
1600usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_quat as *const _ as usize },
1608usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_quat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_friction as *const _ as usize
},
1616usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_friction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).geom_margin as *const _ as usize
},
1624usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_margin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_gap as *const _ as usize },
1632usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_gap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_user as *const _ as usize },
1640usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).geom_rgba as *const _ as usize },
1648usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(geom_rgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_type as *const _ as usize },
1656usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).site_bodyid as *const _ as usize
},
1664usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_bodyid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_matid as *const _ as usize },
1672usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_matid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_group as *const _ as usize },
1680usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_group)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).site_sameframe as *const _ as usize
},
1688usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_sameframe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_size as *const _ as usize },
1696usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_pos as *const _ as usize },
1704usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_quat as *const _ as usize },
1712usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_quat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_user as *const _ as usize },
1720usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).site_rgba as *const _ as usize },
1728usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(site_rgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_mode as *const _ as usize },
1736usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_bodyid as *const _ as usize },
1744usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_bodyid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).cam_targetbodyid as *const _ as usize
},
1752usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_targetbodyid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_pos as *const _ as usize },
1760usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_quat as *const _ as usize },
1768usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_quat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).cam_poscom0 as *const _ as usize
},
1776usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_poscom0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_pos0 as *const _ as usize },
1784usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_pos0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_mat0 as *const _ as usize },
1792usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_mat0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_fovy as *const _ as usize },
1800usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_fovy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_ipd as *const _ as usize },
1808usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_ipd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).cam_user as *const _ as usize },
1816usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(cam_user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).light_mode as *const _ as usize },
1824usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_bodyid as *const _ as usize
},
1832usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_bodyid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_targetbodyid as *const _ as usize
},
1840usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_targetbodyid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_directional as *const _ as usize
},
1848usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_directional)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_castshadow as *const _ as usize
},
1856usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_castshadow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_active as *const _ as usize
},
1864usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).light_pos as *const _ as usize },
1872usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).light_dir as *const _ as usize },
1880usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_dir)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_poscom0 as *const _ as usize
},
1888usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_poscom0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).light_pos0 as *const _ as usize },
1896usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_pos0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).light_dir0 as *const _ as usize },
1904usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_dir0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_attenuation as *const _ as usize
},
1912usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_attenuation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_cutoff as *const _ as usize
},
1920usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_cutoff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_exponent as *const _ as usize
},
1928usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_exponent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_ambient as *const _ as usize
},
1936usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_ambient)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_diffuse as *const _ as usize
},
1944usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_diffuse)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).light_specular as *const _ as usize
},
1952usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(light_specular)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_vertadr as *const _ as usize
},
1960usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_vertadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_vertnum as *const _ as usize
},
1968usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_vertnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_texcoordadr as *const _ as usize
},
1976usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_texcoordadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_faceadr as *const _ as usize
},
1984usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_faceadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_facenum as *const _ as usize
},
1992usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_facenum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_graphadr as *const _ as usize
},
2000usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_graphadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).mesh_vert as *const _ as usize },
2008usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_vert)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_normal as *const _ as usize
},
2016usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_normal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mesh_texcoord as *const _ as usize
},
2024usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_texcoord)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).mesh_face as *const _ as usize },
2032usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_face)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).mesh_graph as *const _ as usize },
2040usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mesh_graph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).skin_matid as *const _ as usize },
2048usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_matid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).skin_rgba as *const _ as usize },
2056usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_rgba)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_inflate as *const _ as usize
},
2064usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_inflate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_vertadr as *const _ as usize
},
2072usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_vertadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_vertnum as *const _ as usize
},
2080usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_vertnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_texcoordadr as *const _ as usize
},
2088usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_texcoordadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_faceadr as *const _ as usize
},
2096usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_faceadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_facenum as *const _ as usize
},
2104usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_facenum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_boneadr as *const _ as usize
},
2112usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_boneadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonenum as *const _ as usize
},
2120usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonenum)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).skin_vert as *const _ as usize },
2128usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_vert)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_texcoord as *const _ as usize
},
2136usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_texcoord)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).skin_face as *const _ as usize },
2144usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_face)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonevertadr as *const _ as usize
},
2152usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonevertadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonevertnum as *const _ as usize
},
2160usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonevertnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonebindpos as *const _ as usize
},
2168usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonebindpos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonebindquat as *const _ as usize
},
2176usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonebindquat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonebodyid as *const _ as usize
},
2184usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonebodyid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonevertid as *const _ as usize
},
2192usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonevertid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).skin_bonevertweight as *const _
as usize
},
2200usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(skin_bonevertweight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).hfield_size as *const _ as usize
},
2208usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(hfield_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).hfield_nrow as *const _ as usize
},
2216usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(hfield_nrow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).hfield_ncol as *const _ as usize
},
2224usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(hfield_ncol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).hfield_adr as *const _ as usize },
2232usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(hfield_adr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).hfield_data as *const _ as usize
},
2240usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(hfield_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tex_type as *const _ as usize },
2248usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tex_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tex_height as *const _ as usize },
2256usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tex_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tex_width as *const _ as usize },
2264usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tex_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tex_adr as *const _ as usize },
2272usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tex_adr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tex_rgb as *const _ as usize },
2280usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tex_rgb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).mat_texid as *const _ as usize },
2288usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_texid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_texuniform as *const _ as usize
},
2296usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_texuniform)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_texrepeat as *const _ as usize
},
2304usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_texrepeat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_emission as *const _ as usize
},
2312usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_emission)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_specular as *const _ as usize
},
2320usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_specular)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_shininess as *const _ as usize
},
2328usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_shininess)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).mat_reflectance as *const _ as usize
},
2336usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_reflectance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).mat_rgba as *const _ as usize },
2344usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(mat_rgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).pair_dim as *const _ as usize },
2352usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_dim)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).pair_geom1 as *const _ as usize },
2360usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_geom1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).pair_geom2 as *const _ as usize },
2368usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_geom2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).pair_signature as *const _ as usize
},
2376usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_signature)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).pair_solref as *const _ as usize
},
2384usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_solref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).pair_solimp as *const _ as usize
},
2392usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_solimp)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).pair_margin as *const _ as usize
},
2400usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_margin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).pair_gap as *const _ as usize },
2408usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_gap)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).pair_friction as *const _ as usize
},
2416usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(pair_friction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).exclude_signature as *const _ as usize
},
2424usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(exclude_signature)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_type as *const _ as usize },
2432usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_obj1id as *const _ as usize },
2440usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_obj1id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_obj2id as *const _ as usize },
2448usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_obj2id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_active as *const _ as usize },
2456usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_solref as *const _ as usize },
2464usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_solref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_solimp as *const _ as usize },
2472usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_solimp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).eq_data as *const _ as usize },
2480usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(eq_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tendon_adr as *const _ as usize },
2488usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_adr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tendon_num as *const _ as usize },
2496usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_num)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_matid as *const _ as usize
},
2504usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_matid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_group as *const _ as usize
},
2512usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_group)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_limited as *const _ as usize
},
2520usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_limited)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_width as *const _ as usize
},
2528usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_width)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_solref_lim as *const _ as usize
},
2536usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_solref_lim)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_solimp_lim as *const _ as usize
},
2544usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_solimp_lim)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_solref_fri as *const _ as usize
},
2552usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_solref_fri)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_solimp_fri as *const _ as usize
},
2560usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_solimp_fri)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_range as *const _ as usize
},
2568usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_range)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_margin as *const _ as usize
},
2576usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_margin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_stiffness as *const _ as usize
},
2584usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_stiffness)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_damping as *const _ as usize
},
2592usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_damping)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_frictionloss as *const _
as usize
},
2600usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_frictionloss)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_lengthspring as *const _
as usize
},
2608usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_lengthspring)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_length0 as *const _ as usize
},
2616usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_length0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_invweight0 as *const _ as usize
},
2624usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_invweight0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_user as *const _ as usize
},
2632usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_user)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tendon_rgba as *const _ as usize
},
2640usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tendon_rgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).wrap_type as *const _ as usize },
2648usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(wrap_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).wrap_objid as *const _ as usize },
2656usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(wrap_objid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).wrap_prm as *const _ as usize },
2664usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(wrap_prm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_trntype as *const _ as usize
},
2672usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_trntype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_dyntype as *const _ as usize
},
2680usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_dyntype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_gaintype as *const _ as usize
},
2688usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_gaintype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_biastype as *const _ as usize
},
2696usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_biastype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_trnid as *const _ as usize
},
2704usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_trnid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_group as *const _ as usize
},
2712usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_group)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_ctrllimited as *const _
as usize
},
2720usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_ctrllimited)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_forcelimited as *const _
as usize
},
2728usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_forcelimited)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_dynprm as *const _ as usize
},
2736usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_dynprm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_gainprm as *const _ as usize
},
2744usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_gainprm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_biasprm as *const _ as usize
},
2752usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_biasprm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_ctrlrange as *const _ as usize
},
2760usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_ctrlrange)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_forcerange as *const _
as usize
},
2768usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_forcerange)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_gear as *const _ as usize
},
2776usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_gear)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_cranklength as *const _
as usize
},
2784usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_cranklength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_acc0 as *const _ as usize
},
2792usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_acc0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_length0 as *const _ as usize
},
2800usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_length0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_lengthrange as *const _
as usize
},
2808usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_lengthrange)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).actuator_user as *const _ as usize
},
2816usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(actuator_user)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_type as *const _ as usize
},
2824usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_datatype as *const _ as usize
},
2832usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_datatype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_needstage as *const _ as usize
},
2840usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_needstage)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_objtype as *const _ as usize
},
2848usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_objtype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_objid as *const _ as usize
},
2856usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_objid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).sensor_dim as *const _ as usize },
2864usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_dim)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).sensor_adr as *const _ as usize },
2872usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_adr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_cutoff as *const _ as usize
},
2880usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_cutoff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_noise as *const _ as usize
},
2888usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_noise)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).sensor_user as *const _ as usize
},
2896usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(sensor_user)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).numeric_adr as *const _ as usize
},
2904usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(numeric_adr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).numeric_size as *const _ as usize
},
2912usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(numeric_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).numeric_data as *const _ as usize
},
2920usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(numeric_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).text_adr as *const _ as usize },
2928usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(text_adr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).text_size as *const _ as usize },
2936usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(text_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).text_data as *const _ as usize },
2944usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(text_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tuple_adr as *const _ as usize },
2952usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tuple_adr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).tuple_size as *const _ as usize },
2960usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tuple_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tuple_objtype as *const _ as usize
},
2968usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tuple_objtype)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tuple_objid as *const _ as usize
},
2976usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tuple_objid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).tuple_objprm as *const _ as usize
},
2984usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(tuple_objprm)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).key_time as *const _ as usize },
2992usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(key_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).key_qpos as *const _ as usize },
3000usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(key_qpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).key_qvel as *const _ as usize },
3008usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(key_qvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).key_act as *const _ as usize },
3016usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(key_act)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_bodyadr as *const _ as usize
},
3024usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_bodyadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_jntadr as *const _ as usize
},
3032usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_jntadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_geomadr as *const _ as usize
},
3040usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_geomadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_siteadr as *const _ as usize
},
3048usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_siteadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_camadr as *const _ as usize
},
3056usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_camadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_lightadr as *const _ as usize
},
3064usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_lightadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_meshadr as *const _ as usize
},
3072usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_meshadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_skinadr as *const _ as usize
},
3080usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_skinadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_hfieldadr as *const _ as usize
},
3088usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_hfieldadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_texadr as *const _ as usize
},
3096usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_texadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_matadr as *const _ as usize
},
3104usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_matadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_pairadr as *const _ as usize
},
3112usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_pairadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_excludeadr as *const _ as usize
},
3120usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_excludeadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).name_eqadr as *const _ as usize },
3128usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_eqadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_tendonadr as *const _ as usize
},
3136usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_tendonadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_actuatoradr as *const _ as usize
},
3144usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_actuatoradr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_sensoradr as *const _ as usize
},
3152usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_sensoradr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_numericadr as *const _ as usize
},
3160usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_numericadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_textadr as *const _ as usize
},
3168usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_textadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_tupleadr as *const _ as usize
},
3176usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_tupleadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjModel>())).name_keyadr as *const _ as usize
},
3184usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(name_keyadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjModel>())).names as *const _ as usize },
3192usize,
concat!(
"Offset of field: ",
stringify!(_mjModel),
"::",
stringify!(names)
)
);
}
impl Default for _mjModel {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjModel = _mjModel;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtWarning {
INERTIA = 0,
CONTACTFULL = 1,
CNSTRFULL = 2,
VGEOMFULL = 3,
BADQPOS = 4,
BADQVEL = 5,
BADQACC = 6,
BADCTRL = 7,
mjNWARNING = 8,
}
pub use self::_mjtWarning as mjtWarning;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtTimer {
STEP = 0,
FORWARD = 1,
INVERSE = 2,
POSITION = 3,
VELOCITY = 4,
ACTUATION = 5,
ACCELERATION = 6,
CONSTRAINT = 7,
POS_KINEMATICS = 8,
POS_INERTIA = 9,
POS_COLLISION = 10,
POS_MAKE = 11,
POS_PROJECT = 12,
mjNTIMER = 13,
}
pub use self::_mjtTimer as mjtTimer;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjContact {
pub dist: mjtNum,
pub pos: [mjtNum; 3usize],
pub frame: [mjtNum; 9usize],
pub includemargin: mjtNum,
pub friction: [mjtNum; 5usize],
pub solref: [mjtNum; 2usize],
pub solimp: [mjtNum; 5usize],
pub mu: mjtNum,
pub H: [mjtNum; 36usize],
pub dim: ::std::os::raw::c_int,
pub geom1: ::std::os::raw::c_int,
pub geom2: ::std::os::raw::c_int,
pub exclude: ::std::os::raw::c_int,
pub efc_address: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjContact() {
assert_eq!(
::std::mem::size_of::<_mjContact>(),
528usize,
concat!("Size of: ", stringify!(_mjContact))
);
assert_eq!(
::std::mem::align_of::<_mjContact>(),
8usize,
concat!("Alignment of ", stringify!(_mjContact))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).dist as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(dist)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).pos as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).frame as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjContact>())).includemargin as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(includemargin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).friction as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(friction)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).solref as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(solref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).solimp as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(solimp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).mu as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(mu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).H as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(H)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).dim as *const _ as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(dim)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).geom1 as *const _ as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(geom1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).geom2 as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(geom2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjContact>())).exclude as *const _ as usize },
516usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(exclude)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjContact>())).efc_address as *const _ as usize
},
520usize,
concat!(
"Offset of field: ",
stringify!(_mjContact),
"::",
stringify!(efc_address)
)
);
}
impl Default for _mjContact {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjContact = _mjContact;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjWarningStat {
pub lastinfo: ::std::os::raw::c_int,
pub number: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjWarningStat() {
assert_eq!(
::std::mem::size_of::<_mjWarningStat>(),
8usize,
concat!("Size of: ", stringify!(_mjWarningStat))
);
assert_eq!(
::std::mem::align_of::<_mjWarningStat>(),
4usize,
concat!("Alignment of ", stringify!(_mjWarningStat))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjWarningStat>())).lastinfo as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjWarningStat),
"::",
stringify!(lastinfo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjWarningStat>())).number as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjWarningStat),
"::",
stringify!(number)
)
);
}
pub type mjWarningStat = _mjWarningStat;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjTimerStat {
pub duration: mjtNum,
pub number: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjTimerStat() {
assert_eq!(
::std::mem::size_of::<_mjTimerStat>(),
16usize,
concat!("Size of: ", stringify!(_mjTimerStat))
);
assert_eq!(
::std::mem::align_of::<_mjTimerStat>(),
8usize,
concat!("Alignment of ", stringify!(_mjTimerStat))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjTimerStat>())).duration as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjTimerStat),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjTimerStat>())).number as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjTimerStat),
"::",
stringify!(number)
)
);
}
pub type mjTimerStat = _mjTimerStat;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjSolverStat {
pub improvement: mjtNum,
pub gradient: mjtNum,
pub lineslope: mjtNum,
pub nactive: ::std::os::raw::c_int,
pub nchange: ::std::os::raw::c_int,
pub neval: ::std::os::raw::c_int,
pub nupdate: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjSolverStat() {
assert_eq!(
::std::mem::size_of::<_mjSolverStat>(),
40usize,
concat!("Size of: ", stringify!(_mjSolverStat))
);
assert_eq!(
::std::mem::align_of::<_mjSolverStat>(),
8usize,
concat!("Alignment of ", stringify!(_mjSolverStat))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).improvement as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(improvement)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).gradient as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(gradient)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).lineslope as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(lineslope)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).nactive as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(nactive)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).nchange as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(nchange)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjSolverStat>())).neval as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(neval)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjSolverStat>())).nupdate as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjSolverStat),
"::",
stringify!(nupdate)
)
);
}
pub type mjSolverStat = _mjSolverStat;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjData {
pub nstack: ::std::os::raw::c_int,
pub nbuffer: ::std::os::raw::c_int,
pub pstack: ::std::os::raw::c_int,
pub maxuse_stack: ::std::os::raw::c_int,
pub maxuse_con: ::std::os::raw::c_int,
pub maxuse_efc: ::std::os::raw::c_int,
pub warning: [mjWarningStat; 8usize],
pub timer: [mjTimerStat; 13usize],
pub solver: [mjSolverStat; 1000usize],
pub solver_iter: ::std::os::raw::c_int,
pub solver_nnz: ::std::os::raw::c_int,
pub solver_fwdinv: [mjtNum; 2usize],
pub ne: ::std::os::raw::c_int,
pub nf: ::std::os::raw::c_int,
pub nefc: ::std::os::raw::c_int,
pub ncon: ::std::os::raw::c_int,
pub time: mjtNum,
pub energy: [mjtNum; 2usize],
pub buffer: *mut ::std::os::raw::c_void,
pub stack: *mut mjtNum,
pub qpos: *mut mjtNum,
pub qvel: *mut mjtNum,
pub act: *mut mjtNum,
pub qacc_warmstart: *mut mjtNum,
pub ctrl: *mut mjtNum,
pub qfrc_applied: *mut mjtNum,
pub xfrc_applied: *mut mjtNum,
pub qacc: *mut mjtNum,
pub act_dot: *mut mjtNum,
pub mocap_pos: *mut mjtNum,
pub mocap_quat: *mut mjtNum,
pub userdata: *mut mjtNum,
pub sensordata: *mut mjtNum,
pub xpos: *mut mjtNum,
pub xquat: *mut mjtNum,
pub xmat: *mut mjtNum,
pub xipos: *mut mjtNum,
pub ximat: *mut mjtNum,
pub xanchor: *mut mjtNum,
pub xaxis: *mut mjtNum,
pub geom_xpos: *mut mjtNum,
pub geom_xmat: *mut mjtNum,
pub site_xpos: *mut mjtNum,
pub site_xmat: *mut mjtNum,
pub cam_xpos: *mut mjtNum,
pub cam_xmat: *mut mjtNum,
pub light_xpos: *mut mjtNum,
pub light_xdir: *mut mjtNum,
pub subtree_com: *mut mjtNum,
pub cdof: *mut mjtNum,
pub cinert: *mut mjtNum,
pub ten_wrapadr: *mut ::std::os::raw::c_int,
pub ten_wrapnum: *mut ::std::os::raw::c_int,
pub ten_J_rownnz: *mut ::std::os::raw::c_int,
pub ten_J_rowadr: *mut ::std::os::raw::c_int,
pub ten_J_colind: *mut ::std::os::raw::c_int,
pub ten_length: *mut mjtNum,
pub ten_J: *mut mjtNum,
pub wrap_obj: *mut ::std::os::raw::c_int,
pub wrap_xpos: *mut mjtNum,
pub actuator_length: *mut mjtNum,
pub actuator_moment: *mut mjtNum,
pub crb: *mut mjtNum,
pub qM: *mut mjtNum,
pub qLD: *mut mjtNum,
pub qLDiagInv: *mut mjtNum,
pub qLDiagSqrtInv: *mut mjtNum,
pub contact: *mut mjContact,
pub efc_type: *mut ::std::os::raw::c_int,
pub efc_id: *mut ::std::os::raw::c_int,
pub efc_J_rownnz: *mut ::std::os::raw::c_int,
pub efc_J_rowadr: *mut ::std::os::raw::c_int,
pub efc_J_rowsuper: *mut ::std::os::raw::c_int,
pub efc_J_colind: *mut ::std::os::raw::c_int,
pub efc_JT_rownnz: *mut ::std::os::raw::c_int,
pub efc_JT_rowadr: *mut ::std::os::raw::c_int,
pub efc_JT_rowsuper: *mut ::std::os::raw::c_int,
pub efc_JT_colind: *mut ::std::os::raw::c_int,
pub efc_J: *mut mjtNum,
pub efc_JT: *mut mjtNum,
pub efc_pos: *mut mjtNum,
pub efc_margin: *mut mjtNum,
pub efc_frictionloss: *mut mjtNum,
pub efc_diagApprox: *mut mjtNum,
pub efc_KBIP: *mut mjtNum,
pub efc_D: *mut mjtNum,
pub efc_R: *mut mjtNum,
pub efc_AR_rownnz: *mut ::std::os::raw::c_int,
pub efc_AR_rowadr: *mut ::std::os::raw::c_int,
pub efc_AR_colind: *mut ::std::os::raw::c_int,
pub efc_AR: *mut mjtNum,
pub ten_velocity: *mut mjtNum,
pub actuator_velocity: *mut mjtNum,
pub cvel: *mut mjtNum,
pub cdof_dot: *mut mjtNum,
pub qfrc_bias: *mut mjtNum,
pub qfrc_passive: *mut mjtNum,
pub efc_vel: *mut mjtNum,
pub efc_aref: *mut mjtNum,
pub subtree_linvel: *mut mjtNum,
pub subtree_angmom: *mut mjtNum,
pub actuator_force: *mut mjtNum,
pub qfrc_actuator: *mut mjtNum,
pub qfrc_unc: *mut mjtNum,
pub qacc_unc: *mut mjtNum,
pub efc_b: *mut mjtNum,
pub efc_force: *mut mjtNum,
pub efc_state: *mut ::std::os::raw::c_int,
pub qfrc_constraint: *mut mjtNum,
pub qfrc_inverse: *mut mjtNum,
pub cacc: *mut mjtNum,
pub cfrc_int: *mut mjtNum,
pub cfrc_ext: *mut mjtNum,
}
#[test]
fn bindgen_test_layout__mjData() {
assert_eq!(
::std::mem::size_of::<_mjData>(),
41120usize,
concat!("Size of: ", stringify!(_mjData))
);
assert_eq!(
::std::mem::align_of::<_mjData>(),
8usize,
concat!("Alignment of ", stringify!(_mjData))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).nstack as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(nstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).nbuffer as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(nbuffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).pstack as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(pstack)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).maxuse_stack as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(maxuse_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).maxuse_con as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(maxuse_con)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).maxuse_efc as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(maxuse_efc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).warning as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(warning)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).timer as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(timer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).solver as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(solver)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).solver_iter as *const _ as usize },
40296usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(solver_iter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).solver_nnz as *const _ as usize },
40300usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(solver_nnz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).solver_fwdinv as *const _ as usize
},
40304usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(solver_fwdinv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ne as *const _ as usize },
40320usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ne)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).nf as *const _ as usize },
40324usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(nf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).nefc as *const _ as usize },
40328usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(nefc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ncon as *const _ as usize },
40332usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ncon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).time as *const _ as usize },
40336usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).energy as *const _ as usize },
40344usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(energy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).buffer as *const _ as usize },
40360usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).stack as *const _ as usize },
40368usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qpos as *const _ as usize },
40376usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qvel as *const _ as usize },
40384usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).act as *const _ as usize },
40392usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(act)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qacc_warmstart as *const _ as usize
},
40400usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qacc_warmstart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ctrl as *const _ as usize },
40408usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ctrl)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qfrc_applied as *const _ as usize
},
40416usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_applied)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).xfrc_applied as *const _ as usize
},
40424usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xfrc_applied)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qacc as *const _ as usize },
40432usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qacc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).act_dot as *const _ as usize },
40440usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(act_dot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).mocap_pos as *const _ as usize },
40448usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(mocap_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).mocap_quat as *const _ as usize },
40456usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(mocap_quat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).userdata as *const _ as usize },
40464usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).sensordata as *const _ as usize },
40472usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(sensordata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xpos as *const _ as usize },
40480usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xquat as *const _ as usize },
40488usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xquat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xmat as *const _ as usize },
40496usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xmat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xipos as *const _ as usize },
40504usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xipos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ximat as *const _ as usize },
40512usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ximat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xanchor as *const _ as usize },
40520usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xanchor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).xaxis as *const _ as usize },
40528usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(xaxis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).geom_xpos as *const _ as usize },
40536usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(geom_xpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).geom_xmat as *const _ as usize },
40544usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(geom_xmat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).site_xpos as *const _ as usize },
40552usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(site_xpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).site_xmat as *const _ as usize },
40560usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(site_xmat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cam_xpos as *const _ as usize },
40568usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cam_xpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cam_xmat as *const _ as usize },
40576usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cam_xmat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).light_xpos as *const _ as usize },
40584usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(light_xpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).light_xdir as *const _ as usize },
40592usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(light_xdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).subtree_com as *const _ as usize },
40600usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(subtree_com)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cdof as *const _ as usize },
40608usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cdof)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cinert as *const _ as usize },
40616usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cinert)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ten_wrapadr as *const _ as usize },
40624usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_wrapadr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ten_wrapnum as *const _ as usize },
40632usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_wrapnum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).ten_J_rownnz as *const _ as usize
},
40640usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_J_rownnz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).ten_J_rowadr as *const _ as usize
},
40648usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_J_rowadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).ten_J_colind as *const _ as usize
},
40656usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_J_colind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ten_length as *const _ as usize },
40664usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).ten_J as *const _ as usize },
40672usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_J)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).wrap_obj as *const _ as usize },
40680usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(wrap_obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).wrap_xpos as *const _ as usize },
40688usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(wrap_xpos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).actuator_length as *const _ as usize
},
40696usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(actuator_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).actuator_moment as *const _ as usize
},
40704usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(actuator_moment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).crb as *const _ as usize },
40712usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(crb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qM as *const _ as usize },
40720usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qM)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qLD as *const _ as usize },
40728usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qLD)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qLDiagInv as *const _ as usize },
40736usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qLDiagInv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qLDiagSqrtInv as *const _ as usize
},
40744usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qLDiagSqrtInv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).contact as *const _ as usize },
40752usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(contact)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_type as *const _ as usize },
40760usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_id as *const _ as usize },
40768usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_J_rownnz as *const _ as usize
},
40776usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_J_rownnz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_J_rowadr as *const _ as usize
},
40784usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_J_rowadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_J_rowsuper as *const _ as usize
},
40792usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_J_rowsuper)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_J_colind as *const _ as usize
},
40800usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_J_colind)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_JT_rownnz as *const _ as usize
},
40808usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_JT_rownnz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_JT_rowadr as *const _ as usize
},
40816usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_JT_rowadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_JT_rowsuper as *const _ as usize
},
40824usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_JT_rowsuper)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_JT_colind as *const _ as usize
},
40832usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_JT_colind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_J as *const _ as usize },
40840usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_J)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_JT as *const _ as usize },
40848usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_JT)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_pos as *const _ as usize },
40856usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_margin as *const _ as usize },
40864usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_margin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_frictionloss as *const _ as usize
},
40872usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_frictionloss)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_diagApprox as *const _ as usize
},
40880usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_diagApprox)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_KBIP as *const _ as usize },
40888usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_KBIP)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_D as *const _ as usize },
40896usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_D)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_R as *const _ as usize },
40904usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_R)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_AR_rownnz as *const _ as usize
},
40912usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_AR_rownnz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_AR_rowadr as *const _ as usize
},
40920usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_AR_rowadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).efc_AR_colind as *const _ as usize
},
40928usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_AR_colind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_AR as *const _ as usize },
40936usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_AR)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).ten_velocity as *const _ as usize
},
40944usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(ten_velocity)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).actuator_velocity as *const _ as usize
},
40952usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(actuator_velocity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cvel as *const _ as usize },
40960usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cdof_dot as *const _ as usize },
40968usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cdof_dot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qfrc_bias as *const _ as usize },
40976usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_bias)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qfrc_passive as *const _ as usize
},
40984usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_passive)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_vel as *const _ as usize },
40992usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_vel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_aref as *const _ as usize },
41000usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_aref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).subtree_linvel as *const _ as usize
},
41008usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(subtree_linvel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).subtree_angmom as *const _ as usize
},
41016usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(subtree_angmom)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).actuator_force as *const _ as usize
},
41024usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(actuator_force)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qfrc_actuator as *const _ as usize
},
41032usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_actuator)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qfrc_unc as *const _ as usize },
41040usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_unc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).qacc_unc as *const _ as usize },
41048usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qacc_unc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_b as *const _ as usize },
41056usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_force as *const _ as usize },
41064usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_force)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).efc_state as *const _ as usize },
41072usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(efc_state)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qfrc_constraint as *const _ as usize
},
41080usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_constraint)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjData>())).qfrc_inverse as *const _ as usize
},
41088usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(qfrc_inverse)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cacc as *const _ as usize },
41096usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cacc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cfrc_int as *const _ as usize },
41104usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cfrc_int)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjData>())).cfrc_ext as *const _ as usize },
41112usize,
concat!(
"Offset of field: ",
stringify!(_mjData),
"::",
stringify!(cfrc_ext)
)
);
}
impl Default for _mjData {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjData = _mjData;
pub type mjfGeneric =
::std::option::Option<unsafe extern "C" fn(m: *const mjModel, d: *mut mjData)>;
pub type mjfConFilt = ::std::option::Option<
unsafe extern "C" fn(
m: *const mjModel,
d: *mut mjData,
geom1: ::std::os::raw::c_int,
geom2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type mjfSensor = ::std::option::Option<
unsafe extern "C" fn(
m: *const mjModel,
d: *mut mjData,
stage: ::std::os::raw::c_int,
),
>;
pub type mjfTime = ::std::option::Option<unsafe extern "C" fn() -> mjtNum>;
pub type mjfAct = ::std::option::Option<
unsafe extern "C" fn(
m: *const mjModel,
d: *const mjData,
id: ::std::os::raw::c_int,
) -> mjtNum,
>;
pub type mjfCollision = ::std::option::Option<
unsafe extern "C" fn(
m: *const mjModel,
d: *const mjData,
con: *mut mjContact,
g1: ::std::os::raw::c_int,
g2: ::std::os::raw::c_int,
margin: mjtNum,
) -> ::std::os::raw::c_int,
>;
impl _mjtCatBit {
pub const STATIC: _mjtCatBit = _mjtCatBit(1);
}
impl _mjtCatBit {
pub const DYNAMIC: _mjtCatBit = _mjtCatBit(2);
}
impl _mjtCatBit {
pub const DECOR: _mjtCatBit = _mjtCatBit(4);
}
impl _mjtCatBit {
pub const ALL: _mjtCatBit = _mjtCatBit(7);
}
impl ::std::ops::BitOr<_mjtCatBit> for _mjtCatBit {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_mjtCatBit(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _mjtCatBit {
#[inline]
fn bitor_assign(&mut self, rhs: _mjtCatBit) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_mjtCatBit> for _mjtCatBit {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_mjtCatBit(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _mjtCatBit {
#[inline]
fn bitand_assign(&mut self, rhs: _mjtCatBit) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _mjtCatBit(pub u32);
pub use self::_mjtCatBit as mjtCatBit;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtMouse {
NONE = 0,
ROTATE_V = 1,
ROTATE_H = 2,
MOVE_V = 3,
MOVE_H = 4,
ZOOM = 5,
SELECT = 6,
}
pub use self::_mjtMouse as mjtMouse;
impl _mjtPertBit {
pub const TRANSLATE: _mjtPertBit = _mjtPertBit(1);
}
impl _mjtPertBit {
pub const ROTATE: _mjtPertBit = _mjtPertBit(2);
}
impl ::std::ops::BitOr<_mjtPertBit> for _mjtPertBit {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
_mjtPertBit(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for _mjtPertBit {
#[inline]
fn bitor_assign(&mut self, rhs: _mjtPertBit) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<_mjtPertBit> for _mjtPertBit {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
_mjtPertBit(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for _mjtPertBit {
#[inline]
fn bitand_assign(&mut self, rhs: _mjtPertBit) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct _mjtPertBit(pub u32);
pub use self::_mjtPertBit as mjtPertBit;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtCamera {
FREE = 0,
TRACKING = 1,
FIXED = 2,
USER = 3,
}
pub use self::_mjtCamera as mjtCamera;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtLabel {
NONE = 0,
BODY = 1,
JOINT = 2,
GEOM = 3,
SITE = 4,
CAMERA = 5,
LIGHT = 6,
TENDON = 7,
ACTUATOR = 8,
CONSTRAINT = 9,
SKIN = 10,
SELECTION = 11,
SELPNT = 12,
CONTACTFORCE = 13,
mjNLABEL = 14,
}
pub use self::_mjtLabel as mjtLabel;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtFrame {
NONE = 0,
BODY = 1,
GEOM = 2,
SITE = 3,
CAMERA = 4,
LIGHT = 5,
WORLD = 6,
mjNFRAME = 7,
}
pub use self::_mjtFrame as mjtFrame;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtVisFlag {
CONVEXHULL = 0,
TEXTURE = 1,
JOINT = 2,
ACTUATOR = 3,
CAMERA = 4,
LIGHT = 5,
TENDON = 6,
RANGEFINDER = 7,
CONSTRAINT = 8,
INERTIA = 9,
SCLINERTIA = 10,
PERTFORCE = 11,
PERTOBJ = 12,
CONTACTPOINT = 13,
CONTACTFORCE = 14,
CONTACTSPLIT = 15,
TRANSPARENT = 16,
AUTOCONNECT = 17,
COM = 18,
SELECT = 19,
STATIC = 20,
SKIN = 21,
mjNVISFLAG = 22,
}
pub use self::_mjtVisFlag as mjtVisFlag;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtRndFlag {
SHADOW = 0,
WIREFRAME = 1,
REFLECTION = 2,
ADDITIVE = 3,
SKYBOX = 4,
FOG = 5,
HAZE = 6,
SEGMENT = 7,
IDCOLOR = 8,
mjNRNDFLAG = 9,
}
pub use self::_mjtRndFlag as mjtRndFlag;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtStereo {
NONE = 0,
QUADBUFFERED = 1,
SIDEBYSIDE = 2,
}
pub use self::_mjtStereo as mjtStereo;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjvPerturb {
pub select: ::std::os::raw::c_int,
pub skinselect: ::std::os::raw::c_int,
pub active: ::std::os::raw::c_int,
pub refpos: [mjtNum; 3usize],
pub refquat: [mjtNum; 4usize],
pub localpos: [mjtNum; 3usize],
pub scale: mjtNum,
}
#[test]
fn bindgen_test_layout__mjvPerturb() {
assert_eq!(
::std::mem::size_of::<_mjvPerturb>(),
104usize,
concat!("Size of: ", stringify!(_mjvPerturb))
);
assert_eq!(
::std::mem::align_of::<_mjvPerturb>(),
8usize,
concat!("Alignment of ", stringify!(_mjvPerturb))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvPerturb>())).select as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(select)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvPerturb>())).skinselect as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(skinselect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvPerturb>())).active as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvPerturb>())).refpos as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(refpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvPerturb>())).refquat as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(refquat)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvPerturb>())).localpos as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(localpos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvPerturb>())).scale as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_mjvPerturb),
"::",
stringify!(scale)
)
);
}
pub type mjvPerturb = _mjvPerturb;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjvCamera {
pub type_: ::std::os::raw::c_int,
pub fixedcamid: ::std::os::raw::c_int,
pub trackbodyid: ::std::os::raw::c_int,
pub lookat: [mjtNum; 3usize],
pub distance: mjtNum,
pub azimuth: mjtNum,
pub elevation: mjtNum,
}
#[test]
fn bindgen_test_layout__mjvCamera() {
assert_eq!(
::std::mem::size_of::<_mjvCamera>(),
64usize,
concat!("Size of: ", stringify!(_mjvCamera))
);
assert_eq!(
::std::mem::align_of::<_mjvCamera>(),
8usize,
concat!("Alignment of ", stringify!(_mjvCamera))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvCamera>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvCamera>())).fixedcamid as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(fixedcamid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvCamera>())).trackbodyid as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(trackbodyid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvCamera>())).lookat as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(lookat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvCamera>())).distance as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(distance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvCamera>())).azimuth as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(azimuth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvCamera>())).elevation as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_mjvCamera),
"::",
stringify!(elevation)
)
);
}
pub type mjvCamera = _mjvCamera;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjvGLCamera {
pub pos: [f32; 3usize],
pub forward: [f32; 3usize],
pub up: [f32; 3usize],
pub frustum_center: f32,
pub frustum_bottom: f32,
pub frustum_top: f32,
pub frustum_near: f32,
pub frustum_far: f32,
}
#[test]
fn bindgen_test_layout__mjvGLCamera() {
assert_eq!(
::std::mem::size_of::<_mjvGLCamera>(),
56usize,
concat!("Size of: ", stringify!(_mjvGLCamera))
);
assert_eq!(
::std::mem::align_of::<_mjvGLCamera>(),
4usize,
concat!("Alignment of ", stringify!(_mjvGLCamera))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGLCamera>())).pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).forward as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(forward)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGLCamera>())).up as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(up)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).frustum_center as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(frustum_center)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).frustum_bottom as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(frustum_bottom)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).frustum_top as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(frustum_top)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).frustum_near as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(frustum_near)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGLCamera>())).frustum_far as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_mjvGLCamera),
"::",
stringify!(frustum_far)
)
);
}
pub type mjvGLCamera = _mjvGLCamera;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjvGeom {
pub type_: ::std::os::raw::c_int,
pub dataid: ::std::os::raw::c_int,
pub objtype: ::std::os::raw::c_int,
pub objid: ::std::os::raw::c_int,
pub category: ::std::os::raw::c_int,
pub texid: ::std::os::raw::c_int,
pub texuniform: ::std::os::raw::c_int,
pub texcoord: ::std::os::raw::c_int,
pub segid: ::std::os::raw::c_int,
pub texrepeat: [f32; 2usize],
pub size: [f32; 3usize],
pub pos: [f32; 3usize],
pub mat: [f32; 9usize],
pub rgba: [f32; 4usize],
pub emission: f32,
pub specular: f32,
pub shininess: f32,
pub reflectance: f32,
pub label: [::std::os::raw::c_char; 100usize],
pub camdist: f32,
pub modelrbound: f32,
pub transparent: mjtByte,
}
#[test]
fn bindgen_test_layout__mjvGeom() {
assert_eq!(
::std::mem::size_of::<_mjvGeom>(),
248usize,
concat!("Size of: ", stringify!(_mjvGeom))
);
assert_eq!(
::std::mem::align_of::<_mjvGeom>(),
4usize,
concat!("Alignment of ", stringify!(_mjvGeom))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).dataid as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(dataid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).objtype as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(objtype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).objid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(objid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).category as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(category)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).texid as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(texid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).texuniform as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(texuniform)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).texcoord as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(texcoord)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).segid as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(segid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).texrepeat as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(texrepeat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).size as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).pos as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).mat as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(mat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).rgba as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(rgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).emission as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(emission)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).specular as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(specular)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).shininess as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(shininess)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGeom>())).reflectance as *const _ as usize
},
132usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(reflectance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).label as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvGeom>())).camdist as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(camdist)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGeom>())).modelrbound as *const _ as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(modelrbound)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvGeom>())).transparent as *const _ as usize
},
244usize,
concat!(
"Offset of field: ",
stringify!(_mjvGeom),
"::",
stringify!(transparent)
)
);
}
impl Default for _mjvGeom {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjvGeom = _mjvGeom;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjvLight {
pub pos: [f32; 3usize],
pub dir: [f32; 3usize],
pub attenuation: [f32; 3usize],
pub cutoff: f32,
pub exponent: f32,
pub ambient: [f32; 3usize],
pub diffuse: [f32; 3usize],
pub specular: [f32; 3usize],
pub headlight: mjtByte,
pub directional: mjtByte,
pub castshadow: mjtByte,
}
#[test]
fn bindgen_test_layout__mjvLight() {
assert_eq!(
::std::mem::size_of::<_mjvLight>(),
84usize,
concat!("Size of: ", stringify!(_mjvLight))
);
assert_eq!(
::std::mem::align_of::<_mjvLight>(),
4usize,
concat!("Alignment of ", stringify!(_mjvLight))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).dir as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(dir)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvLight>())).attenuation as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(attenuation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).cutoff as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(cutoff)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).exponent as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(exponent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).ambient as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(ambient)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).diffuse as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(diffuse)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).specular as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(specular)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvLight>())).headlight as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(headlight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvLight>())).directional as *const _ as usize
},
81usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(directional)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvLight>())).castshadow as *const _ as usize
},
82usize,
concat!(
"Offset of field: ",
stringify!(_mjvLight),
"::",
stringify!(castshadow)
)
);
}
pub type mjvLight = _mjvLight;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjvOption {
pub label: ::std::os::raw::c_int,
pub frame: ::std::os::raw::c_int,
pub geomgroup: [mjtByte; 6usize],
pub sitegroup: [mjtByte; 6usize],
pub jointgroup: [mjtByte; 6usize],
pub tendongroup: [mjtByte; 6usize],
pub actuatorgroup: [mjtByte; 6usize],
pub flags: [mjtByte; 22usize],
}
#[test]
fn bindgen_test_layout__mjvOption() {
assert_eq!(
::std::mem::size_of::<_mjvOption>(),
60usize,
concat!("Size of: ", stringify!(_mjvOption))
);
assert_eq!(
::std::mem::align_of::<_mjvOption>(),
4usize,
concat!("Alignment of ", stringify!(_mjvOption))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvOption>())).label as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvOption>())).frame as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvOption>())).geomgroup as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(geomgroup)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvOption>())).sitegroup as *const _ as usize
},
14usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(sitegroup)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvOption>())).jointgroup as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(jointgroup)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvOption>())).tendongroup as *const _ as usize
},
26usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(tendongroup)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvOption>())).actuatorgroup as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(actuatorgroup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvOption>())).flags as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(_mjvOption),
"::",
stringify!(flags)
)
);
}
pub type mjvOption = _mjvOption;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mjvScene {
pub maxgeom: ::std::os::raw::c_int,
pub ngeom: ::std::os::raw::c_int,
pub geoms: *mut mjvGeom,
pub geomorder: *mut ::std::os::raw::c_int,
pub nskin: ::std::os::raw::c_int,
pub skinfacenum: *mut ::std::os::raw::c_int,
pub skinvertadr: *mut ::std::os::raw::c_int,
pub skinvertnum: *mut ::std::os::raw::c_int,
pub skinvert: *mut f32,
pub skinnormal: *mut f32,
pub nlight: ::std::os::raw::c_int,
pub lights: [mjvLight; 8usize],
pub camera: [mjvGLCamera; 2usize],
pub enabletransform: mjtByte,
pub translate: [f32; 3usize],
pub rotate: [f32; 4usize],
pub scale: f32,
pub stereo: ::std::os::raw::c_int,
pub flags: [mjtByte; 9usize],
}
#[test]
fn bindgen_test_layout__mjvScene() {
assert_eq!(
::std::mem::size_of::<_mjvScene>(),
912usize,
concat!("Size of: ", stringify!(_mjvScene))
);
assert_eq!(
::std::mem::align_of::<_mjvScene>(),
8usize,
concat!("Alignment of ", stringify!(_mjvScene))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).maxgeom as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(maxgeom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).ngeom as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(ngeom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).geoms as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(geoms)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).geomorder as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(geomorder)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).nskin as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(nskin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvScene>())).skinfacenum as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(skinfacenum)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvScene>())).skinvertadr as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(skinvertadr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvScene>())).skinvertnum as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(skinvertnum)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).skinvert as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(skinvert)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvScene>())).skinnormal as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(skinnormal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).nlight as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(nlight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).lights as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(lights)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).camera as *const _ as usize },
748usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(camera)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvScene>())).enabletransform as *const _ as usize
},
860usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(enabletransform)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).translate as *const _ as usize },
864usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(translate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).rotate as *const _ as usize },
876usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(rotate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).scale as *const _ as usize },
892usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).stereo as *const _ as usize },
896usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(stereo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvScene>())).flags as *const _ as usize },
900usize,
concat!(
"Offset of field: ",
stringify!(_mjvScene),
"::",
stringify!(flags)
)
);
}
impl Default for _mjvScene {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjvScene = _mjvScene;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjvFigure {
pub flg_legend: ::std::os::raw::c_int,
pub flg_ticklabel: [::std::os::raw::c_int; 2usize],
pub flg_extend: ::std::os::raw::c_int,
pub flg_barplot: ::std::os::raw::c_int,
pub flg_selection: ::std::os::raw::c_int,
pub flg_symmetric: ::std::os::raw::c_int,
pub legendoff: ::std::os::raw::c_int,
pub gridsize: [::std::os::raw::c_int; 2usize],
pub selection: ::std::os::raw::c_int,
pub highlight: [::std::os::raw::c_int; 2usize],
pub gridrgb: [f32; 3usize],
pub gridwidth: f32,
pub figurergba: [f32; 4usize],
pub panergba: [f32; 4usize],
pub legendrgba: [f32; 4usize],
pub textrgb: [f32; 3usize],
pub range: [[f32; 2usize]; 2usize],
pub xlabel: [::std::os::raw::c_char; 100usize],
pub title: [::std::os::raw::c_char; 100usize],
pub xformat: [::std::os::raw::c_char; 20usize],
pub yformat: [::std::os::raw::c_char; 20usize],
pub minwidth: [::std::os::raw::c_char; 20usize],
pub linepnt: [::std::os::raw::c_int; 100usize],
pub linergb: [[f32; 3usize]; 100usize],
pub linewidth: [f32; 100usize],
pub linedata: [[f32; 2000usize]; 100usize],
pub linename: [[::std::os::raw::c_char; 100usize]; 100usize],
pub xaxispixel: [::std::os::raw::c_int; 2usize],
pub yaxispixel: [::std::os::raw::c_int; 2usize],
pub xaxisdata: [f32; 2usize],
pub yaxisdata: [f32; 2usize],
}
#[test]
fn bindgen_test_layout__mjvFigure() {
assert_eq!(
::std::mem::size_of::<_mjvFigure>(),
812436usize,
concat!("Size of: ", stringify!(_mjvFigure))
);
assert_eq!(
::std::mem::align_of::<_mjvFigure>(),
4usize,
concat!("Alignment of ", stringify!(_mjvFigure))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_legend as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_legend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_ticklabel as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_ticklabel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_extend as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_extend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_barplot as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_barplot)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_selection as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_selection)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).flg_symmetric as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(flg_symmetric)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).legendoff as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(legendoff)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).gridsize as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(gridsize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).selection as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(selection)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).highlight as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(highlight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).gridrgb as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(gridrgb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).gridwidth as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(gridwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).figurergba as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(figurergba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).panergba as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(panergba)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).legendrgba as *const _ as usize
},
100usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(legendrgba)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).textrgb as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(textrgb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).range as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).xlabel as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(xlabel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).title as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).xformat as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(xformat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).yformat as *const _ as usize },
364usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(yformat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).minwidth as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(minwidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).linepnt as *const _ as usize },
404usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(linepnt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).linergb as *const _ as usize },
804usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(linergb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).linewidth as *const _ as usize
},
2004usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(linewidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).linedata as *const _ as usize },
2404usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(linedata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjvFigure>())).linename as *const _ as usize },
802404usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(linename)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).xaxispixel as *const _ as usize
},
812404usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(xaxispixel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).yaxispixel as *const _ as usize
},
812412usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(yaxispixel)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).xaxisdata as *const _ as usize
},
812420usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(xaxisdata)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjvFigure>())).yaxisdata as *const _ as usize
},
812428usize,
concat!(
"Offset of field: ",
stringify!(_mjvFigure),
"::",
stringify!(yaxisdata)
)
);
}
impl Default for _mjvFigure {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjvFigure = _mjvFigure;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtGridPos {
TOPLEFT = 0,
TOPRIGHT = 1,
BOTTOMLEFT = 2,
BOTTOMRIGHT = 3,
}
pub use self::_mjtGridPos as mjtGridPos;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtFramebuffer {
WINDOW = 0,
OFFSCREEN = 1,
}
pub use self::_mjtFramebuffer as mjtFramebuffer;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtFontScale {
SCALE_50 = 50,
SCALE_100 = 100,
SCALE_150 = 150,
SCALE_200 = 200,
SCALE_250 = 250,
SCALE_300 = 300,
}
pub use self::_mjtFontScale as mjtFontScale;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtFont {
NORMAL = 0,
SHADOW = 1,
BIG = 2,
}
pub use self::_mjtFont as mjtFont;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjrRect {
pub left: ::std::os::raw::c_int,
pub bottom: ::std::os::raw::c_int,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjrRect() {
assert_eq!(
::std::mem::size_of::<_mjrRect>(),
16usize,
concat!("Size of: ", stringify!(_mjrRect))
);
assert_eq!(
::std::mem::align_of::<_mjrRect>(),
4usize,
concat!("Alignment of ", stringify!(_mjrRect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrRect>())).left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjrRect),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrRect>())).bottom as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjrRect),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrRect>())).width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_mjrRect),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrRect>())).height as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_mjrRect),
"::",
stringify!(height)
)
);
}
pub type mjrRect = _mjrRect;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjrContext {
pub lineWidth: f32,
pub shadowClip: f32,
pub shadowScale: f32,
pub fogStart: f32,
pub fogEnd: f32,
pub fogRGBA: [f32; 4usize],
pub shadowSize: ::std::os::raw::c_int,
pub offWidth: ::std::os::raw::c_int,
pub offHeight: ::std::os::raw::c_int,
pub offSamples: ::std::os::raw::c_int,
pub fontScale: ::std::os::raw::c_int,
pub auxWidth: [::std::os::raw::c_int; 10usize],
pub auxHeight: [::std::os::raw::c_int; 10usize],
pub auxSamples: [::std::os::raw::c_int; 10usize],
pub offFBO: ::std::os::raw::c_uint,
pub offFBO_r: ::std::os::raw::c_uint,
pub offColor: ::std::os::raw::c_uint,
pub offColor_r: ::std::os::raw::c_uint,
pub offDepthStencil: ::std::os::raw::c_uint,
pub offDepthStencil_r: ::std::os::raw::c_uint,
pub shadowFBO: ::std::os::raw::c_uint,
pub shadowTex: ::std::os::raw::c_uint,
pub auxFBO: [::std::os::raw::c_uint; 10usize],
pub auxFBO_r: [::std::os::raw::c_uint; 10usize],
pub auxColor: [::std::os::raw::c_uint; 10usize],
pub auxColor_r: [::std::os::raw::c_uint; 10usize],
pub ntexture: ::std::os::raw::c_int,
pub textureType: [::std::os::raw::c_int; 100usize],
pub texture: [::std::os::raw::c_uint; 100usize],
pub basePlane: ::std::os::raw::c_uint,
pub baseMesh: ::std::os::raw::c_uint,
pub baseHField: ::std::os::raw::c_uint,
pub baseBuiltin: ::std::os::raw::c_uint,
pub baseFontNormal: ::std::os::raw::c_uint,
pub baseFontShadow: ::std::os::raw::c_uint,
pub baseFontBig: ::std::os::raw::c_uint,
pub rangePlane: ::std::os::raw::c_int,
pub rangeMesh: ::std::os::raw::c_int,
pub rangeHField: ::std::os::raw::c_int,
pub rangeBuiltin: ::std::os::raw::c_int,
pub rangeFont: ::std::os::raw::c_int,
pub nskin: ::std::os::raw::c_int,
pub skinvertVBO: *mut ::std::os::raw::c_uint,
pub skinnormalVBO: *mut ::std::os::raw::c_uint,
pub skintexcoordVBO: *mut ::std::os::raw::c_uint,
pub skinfaceVBO: *mut ::std::os::raw::c_uint,
pub charWidth: [::std::os::raw::c_int; 127usize],
pub charWidthBig: [::std::os::raw::c_int; 127usize],
pub charHeight: ::std::os::raw::c_int,
pub charHeightBig: ::std::os::raw::c_int,
pub glewInitialized: ::std::os::raw::c_int,
pub windowAvailable: ::std::os::raw::c_int,
pub windowSamples: ::std::os::raw::c_int,
pub windowStereo: ::std::os::raw::c_int,
pub windowDoublebuffer: ::std::os::raw::c_int,
pub currentBuffer: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjrContext() {
assert_eq!(
::std::mem::size_of::<_mjrContext>(),
2304usize,
concat!("Size of: ", stringify!(_mjrContext))
);
assert_eq!(
::std::mem::align_of::<_mjrContext>(),
8usize,
concat!("Alignment of ", stringify!(_mjrContext))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).lineWidth as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(lineWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).shadowClip as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(shadowClip)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).shadowScale as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(shadowScale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).fogStart as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(fogStart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).fogEnd as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(fogEnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).fogRGBA as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(fogRGBA)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).shadowSize as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(shadowSize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offWidth as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offHeight as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offSamples as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offSamples)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).fontScale as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(fontScale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxWidth as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxHeight as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxSamples as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxSamples)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).offFBO as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offFBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offFBO_r as *const _ as usize
},
180usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offFBO_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offColor as *const _ as usize
},
184usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offColor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offColor_r as *const _ as usize
},
188usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offColor_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offDepthStencil as *const _ as usize
},
192usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offDepthStencil)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).offDepthStencil_r as *const _
as usize
},
196usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(offDepthStencil_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).shadowFBO as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(shadowFBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).shadowTex as *const _ as usize
},
204usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(shadowTex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).auxFBO as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxFBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxFBO_r as *const _ as usize
},
248usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxFBO_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxColor as *const _ as usize
},
288usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxColor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).auxColor_r as *const _ as usize
},
328usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(auxColor_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).ntexture as *const _ as usize
},
368usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(ntexture)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).textureType as *const _ as usize
},
372usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(textureType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).texture as *const _ as usize },
772usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).basePlane as *const _ as usize
},
1172usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(basePlane)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseMesh as *const _ as usize
},
1176usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseMesh)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseHField as *const _ as usize
},
1180usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseHField)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseBuiltin as *const _ as usize
},
1184usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseBuiltin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseFontNormal as *const _ as usize
},
1188usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseFontNormal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseFontShadow as *const _ as usize
},
1192usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseFontShadow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).baseFontBig as *const _ as usize
},
1196usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(baseFontBig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).rangePlane as *const _ as usize
},
1200usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(rangePlane)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).rangeMesh as *const _ as usize
},
1204usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(rangeMesh)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).rangeHField as *const _ as usize
},
1208usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(rangeHField)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).rangeBuiltin as *const _ as usize
},
1212usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(rangeBuiltin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).rangeFont as *const _ as usize
},
1216usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(rangeFont)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjrContext>())).nskin as *const _ as usize },
1220usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(nskin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).skinvertVBO as *const _ as usize
},
1224usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(skinvertVBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).skinnormalVBO as *const _ as usize
},
1232usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(skinnormalVBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).skintexcoordVBO as *const _ as usize
},
1240usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(skintexcoordVBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).skinfaceVBO as *const _ as usize
},
1248usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(skinfaceVBO)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).charWidth as *const _ as usize
},
1256usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(charWidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).charWidthBig as *const _ as usize
},
1764usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(charWidthBig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).charHeight as *const _ as usize
},
2272usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(charHeight)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).charHeightBig as *const _ as usize
},
2276usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(charHeightBig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).glewInitialized as *const _ as usize
},
2280usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(glewInitialized)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).windowAvailable as *const _ as usize
},
2284usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(windowAvailable)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).windowSamples as *const _ as usize
},
2288usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(windowSamples)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).windowStereo as *const _ as usize
},
2292usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(windowStereo)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).windowDoublebuffer as *const _
as usize
},
2296usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(windowDoublebuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjrContext>())).currentBuffer as *const _ as usize
},
2300usize,
concat!(
"Offset of field: ",
stringify!(_mjrContext),
"::",
stringify!(currentBuffer)
)
);
}
impl Default for _mjrContext {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjrContext = _mjrContext;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtButton {
NONE = 0,
LEFT = 1,
RIGHT = 2,
MIDDLE = 3,
}
pub use self::_mjtButton as mjtButton;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtEvent {
NONE = 0,
MOVE = 1,
PRESS = 2,
RELEASE = 3,
SCROLL = 4,
KEY = 5,
RESIZE = 6,
}
pub use self::_mjtEvent as mjtEvent;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum _mjtItem {
END = -2,
SECTION = -1,
SEPARATOR = 0,
STATIC = 1,
BUTTON = 2,
CHECKINT = 3,
CHECKBYTE = 4,
RADIO = 5,
SELECT = 6,
SLIDERINT = 7,
SLIDERNUM = 8,
EDITINT = 9,
EDITNUM = 10,
EDITTXT = 11,
mjNITEM = 12,
}
pub use self::_mjtItem as mjtItem;
pub type mjfItemEnable = ::std::option::Option<
unsafe extern "C" fn(
category: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _mjuiState {
pub nrect: ::std::os::raw::c_int,
pub rect: [mjrRect; 15usize],
pub userdata: *mut ::std::os::raw::c_void,
pub type_: ::std::os::raw::c_int,
pub left: ::std::os::raw::c_int,
pub right: ::std::os::raw::c_int,
pub middle: ::std::os::raw::c_int,
pub doubleclick: ::std::os::raw::c_int,
pub button: ::std::os::raw::c_int,
pub buttontime: f64,
pub x: f64,
pub y: f64,
pub dx: f64,
pub dy: f64,
pub sx: f64,
pub sy: f64,
pub control: ::std::os::raw::c_int,
pub shift: ::std::os::raw::c_int,
pub alt: ::std::os::raw::c_int,
pub key: ::std::os::raw::c_int,
pub keytime: f64,
pub mouserect: ::std::os::raw::c_int,
pub dragrect: ::std::os::raw::c_int,
pub dragbutton: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjuiState() {
assert_eq!(
::std::mem::size_of::<_mjuiState>(),
376usize,
concat!("Size of: ", stringify!(_mjuiState))
);
assert_eq!(
::std::mem::align_of::<_mjuiState>(),
8usize,
concat!("Alignment of ", stringify!(_mjuiState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).nrect as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(nrect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).rect as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(rect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).userdata as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).type_ as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).left as *const _ as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).right as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).middle as *const _ as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(middle)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiState>())).doubleclick as *const _ as usize
},
272usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(doubleclick)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).button as *const _ as usize },
276usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiState>())).buttontime as *const _ as usize
},
280usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(buttontime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).x as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).y as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).dx as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).dy as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(dy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).sx as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(sx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).sy as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(sy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).control as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(control)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).shift as *const _ as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(shift)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).alt as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(alt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).key as *const _ as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).keytime as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(keytime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiState>())).mouserect as *const _ as usize
},
360usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(mouserect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiState>())).dragrect as *const _ as usize },
364usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(dragrect)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiState>())).dragbutton as *const _ as usize
},
368usize,
concat!(
"Offset of field: ",
stringify!(_mjuiState),
"::",
stringify!(dragbutton)
)
);
}
impl Default for _mjuiState {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjuiState = _mjuiState;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjuiThemeSpacing {
pub total: ::std::os::raw::c_int,
pub scroll: ::std::os::raw::c_int,
pub label: ::std::os::raw::c_int,
pub section: ::std::os::raw::c_int,
pub itemside: ::std::os::raw::c_int,
pub itemmid: ::std::os::raw::c_int,
pub itemver: ::std::os::raw::c_int,
pub texthor: ::std::os::raw::c_int,
pub textver: ::std::os::raw::c_int,
pub linescroll: ::std::os::raw::c_int,
pub samples: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjuiThemeSpacing() {
assert_eq!(
::std::mem::size_of::<_mjuiThemeSpacing>(),
44usize,
concat!("Size of: ", stringify!(_mjuiThemeSpacing))
);
assert_eq!(
::std::mem::align_of::<_mjuiThemeSpacing>(),
4usize,
concat!("Alignment of ", stringify!(_mjuiThemeSpacing))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).total as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).scroll as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(scroll)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).label as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).section as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(section)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).itemside as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(itemside)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).itemmid as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(itemmid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).itemver as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(itemver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).texthor as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(texthor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).textver as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(textver)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).linescroll as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(linescroll)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeSpacing>())).samples as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeSpacing),
"::",
stringify!(samples)
)
);
}
pub type mjuiThemeSpacing = _mjuiThemeSpacing;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjuiThemeColor {
pub master: [f32; 3usize],
pub thumb: [f32; 3usize],
pub secttitle: [f32; 3usize],
pub sectfont: [f32; 3usize],
pub sectsymbol: [f32; 3usize],
pub sectpane: [f32; 3usize],
pub shortcut: [f32; 3usize],
pub fontactive: [f32; 3usize],
pub fontinactive: [f32; 3usize],
pub decorinactive: [f32; 3usize],
pub decorinactive2: [f32; 3usize],
pub button: [f32; 3usize],
pub check: [f32; 3usize],
pub radio: [f32; 3usize],
pub select: [f32; 3usize],
pub select2: [f32; 3usize],
pub slider: [f32; 3usize],
pub slider2: [f32; 3usize],
pub edit: [f32; 3usize],
pub edit2: [f32; 3usize],
pub cursor: [f32; 3usize],
}
#[test]
fn bindgen_test_layout__mjuiThemeColor() {
assert_eq!(
::std::mem::size_of::<_mjuiThemeColor>(),
252usize,
concat!("Size of: ", stringify!(_mjuiThemeColor))
);
assert_eq!(
::std::mem::align_of::<_mjuiThemeColor>(),
4usize,
concat!("Alignment of ", stringify!(_mjuiThemeColor))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).master as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(master)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).thumb as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(thumb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).secttitle as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(secttitle)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).sectfont as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(sectfont)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).sectsymbol as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(sectsymbol)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).sectpane as *const _ as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(sectpane)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).shortcut as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(shortcut)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).fontactive as *const _ as usize
},
84usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(fontactive)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).fontinactive as *const _
as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(fontinactive)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).decorinactive as *const _
as usize
},
108usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(decorinactive)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).decorinactive2 as *const _
as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(decorinactive2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).button as *const _ as usize
},
132usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).check as *const _ as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(check)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).radio as *const _ as usize
},
156usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(radio)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).select as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(select)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).select2 as *const _ as usize
},
180usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(select2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).slider as *const _ as usize
},
192usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(slider)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).slider2 as *const _ as usize
},
204usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(slider2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).edit as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(edit)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).edit2 as *const _ as usize
},
228usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(edit2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiThemeColor>())).cursor as *const _ as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(_mjuiThemeColor),
"::",
stringify!(cursor)
)
);
}
pub type mjuiThemeColor = _mjuiThemeColor;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjuiItem {
pub type_: ::std::os::raw::c_int,
pub name: [::std::os::raw::c_char; 40usize],
pub state: ::std::os::raw::c_int,
pub pdata: *mut ::std::os::raw::c_void,
pub sectionid: ::std::os::raw::c_int,
pub itemid: ::std::os::raw::c_int,
pub __bindgen_anon_1: _mjuiItem__bindgen_ty_1,
pub rect: mjrRect,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _mjuiItem__bindgen_ty_1 {
pub single: _mjuiItem__bindgen_ty_1__bindgen_ty_1,
pub multi: _mjuiItem__bindgen_ty_1__bindgen_ty_2,
pub slider: _mjuiItem__bindgen_ty_1__bindgen_ty_3,
pub edit: _mjuiItem__bindgen_ty_1__bindgen_ty_4,
_bindgen_union_align: [u64; 101usize],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjuiItem__bindgen_ty_1__bindgen_ty_1 {
pub modifier: ::std::os::raw::c_int,
pub shortcut: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__mjuiItem__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_1>())).modifier
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(modifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_1>())).shortcut
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(shortcut)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjuiItem__bindgen_ty_1__bindgen_ty_2 {
pub nelem: ::std::os::raw::c_int,
pub name: [[::std::os::raw::c_char; 40usize]; 20usize],
}
#[test]
fn bindgen_test_layout__mjuiItem__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_2>(),
804usize,
concat!(
"Size of: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_2>())).nelem
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(nelem)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_2>())).name
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(name)
)
);
}
impl Default for _mjuiItem__bindgen_ty_1__bindgen_ty_2 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjuiItem__bindgen_ty_1__bindgen_ty_3 {
pub range: [f64; 2usize],
pub divisions: f64,
}
#[test]
fn bindgen_test_layout__mjuiItem__bindgen_ty_1__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_3>(),
24usize,
concat!(
"Size of: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_3>(),
8usize,
concat!(
"Alignment of ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_3>())).range
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_3>())).divisions
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(divisions)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _mjuiItem__bindgen_ty_1__bindgen_ty_4 {
pub nelem: ::std::os::raw::c_int,
pub range: [[f64; 2usize]; 5usize],
}
#[test]
fn bindgen_test_layout__mjuiItem__bindgen_ty_1__bindgen_ty_4() {
assert_eq!(
::std::mem::size_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_4>(),
88usize,
concat!(
"Size of: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
::std::mem::align_of::<_mjuiItem__bindgen_ty_1__bindgen_ty_4>(),
8usize,
concat!(
"Alignment of ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_4>())).nelem
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(nelem)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1__bindgen_ty_4>())).range
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(range)
)
);
}
#[test]
fn bindgen_test_layout__mjuiItem__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_mjuiItem__bindgen_ty_1>(),
808usize,
concat!("Size of: ", stringify!(_mjuiItem__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_mjuiItem__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(_mjuiItem__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1>())).single as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1),
"::",
stringify!(single)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1>())).multi as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1),
"::",
stringify!(multi)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1>())).slider as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1),
"::",
stringify!(slider)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiItem__bindgen_ty_1>())).edit as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem__bindgen_ty_1),
"::",
stringify!(edit)
)
);
}
impl Default for _mjuiItem__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout__mjuiItem() {
assert_eq!(
::std::mem::size_of::<_mjuiItem>(),
888usize,
concat!("Size of: ", stringify!(_mjuiItem))
);
assert_eq!(
::std::mem::align_of::<_mjuiItem>(),
8usize,
concat!("Alignment of ", stringify!(_mjuiItem))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).name as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).state as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).pdata as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(pdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).sectionid as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(sectionid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).itemid as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(itemid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiItem>())).rect as *const _ as usize },
872usize,
concat!(
"Offset of field: ",
stringify!(_mjuiItem),
"::",
stringify!(rect)
)
);
}
impl Default for _mjuiItem {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjuiItem = _mjuiItem;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjuiSection {
pub name: [::std::os::raw::c_char; 40usize],
pub state: ::std::os::raw::c_int,
pub modifier: ::std::os::raw::c_int,
pub shortcut: ::std::os::raw::c_int,
pub nitem: ::std::os::raw::c_int,
pub item: [mjuiItem; 80usize],
pub rtitle: mjrRect,
pub rcontent: mjrRect,
}
#[test]
fn bindgen_test_layout__mjuiSection() {
assert_eq!(
::std::mem::size_of::<_mjuiSection>(),
71128usize,
concat!("Size of: ", stringify!(_mjuiSection))
);
assert_eq!(
::std::mem::align_of::<_mjuiSection>(),
8usize,
concat!("Alignment of ", stringify!(_mjuiSection))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiSection>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiSection>())).state as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiSection>())).modifier as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(modifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiSection>())).shortcut as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(shortcut)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiSection>())).nitem as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(nitem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiSection>())).item as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(item)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiSection>())).rtitle as *const _ as usize },
71096usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(rtitle)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_mjuiSection>())).rcontent as *const _ as usize
},
71112usize,
concat!(
"Offset of field: ",
stringify!(_mjuiSection),
"::",
stringify!(rcontent)
)
);
}
impl Default for _mjuiSection {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjuiSection = _mjuiSection;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjUI {
pub spacing: mjuiThemeSpacing,
pub color: mjuiThemeColor,
pub predicate: mjfItemEnable,
pub userdata: *mut ::std::os::raw::c_void,
pub rectid: ::std::os::raw::c_int,
pub auxid: ::std::os::raw::c_int,
pub radiocol: ::std::os::raw::c_int,
pub width: ::std::os::raw::c_int,
pub height: ::std::os::raw::c_int,
pub maxheight: ::std::os::raw::c_int,
pub scroll: ::std::os::raw::c_int,
pub mousesect: ::std::os::raw::c_int,
pub mouseitem: ::std::os::raw::c_int,
pub mousehelp: ::std::os::raw::c_int,
pub editsect: ::std::os::raw::c_int,
pub edititem: ::std::os::raw::c_int,
pub editcursor: ::std::os::raw::c_int,
pub editscroll: ::std::os::raw::c_int,
pub edittext: [::std::os::raw::c_char; 500usize],
pub editchanged: *mut mjuiItem,
pub nsect: ::std::os::raw::c_int,
pub sect: [mjuiSection; 10usize],
}
#[test]
fn bindgen_test_layout__mjUI() {
assert_eq!(
::std::mem::size_of::<_mjUI>(),
712168usize,
concat!("Size of: ", stringify!(_mjUI))
);
assert_eq!(
::std::mem::align_of::<_mjUI>(),
8usize,
concat!("Alignment of ", stringify!(_mjUI))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).spacing as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).color as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).predicate as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(predicate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).userdata as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).rectid as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(rectid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).auxid as *const _ as usize },
316usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(auxid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).radiocol as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(radiocol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).width as *const _ as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).height as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).maxheight as *const _ as usize },
332usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(maxheight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).scroll as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(scroll)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).mousesect as *const _ as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(mousesect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).mouseitem as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(mouseitem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).mousehelp as *const _ as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(mousehelp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).editsect as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(editsect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).edititem as *const _ as usize },
356usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(edititem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).editcursor as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(editcursor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).editscroll as *const _ as usize },
364usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(editscroll)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).edittext as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(edittext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).editchanged as *const _ as usize },
872usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(editchanged)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).nsect as *const _ as usize },
880usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(nsect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjUI>())).sect as *const _ as usize },
888usize,
concat!(
"Offset of field: ",
stringify!(_mjUI),
"::",
stringify!(sect)
)
);
}
impl Default for _mjUI {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjUI = _mjUI;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _mjuiDef {
pub type_: ::std::os::raw::c_int,
pub name: [::std::os::raw::c_char; 40usize],
pub state: ::std::os::raw::c_int,
pub pdata: *mut ::std::os::raw::c_void,
pub other: [::std::os::raw::c_char; 500usize],
}
#[test]
fn bindgen_test_layout__mjuiDef() {
assert_eq!(
::std::mem::size_of::<_mjuiDef>(),
560usize,
concat!("Size of: ", stringify!(_mjuiDef))
);
assert_eq!(
::std::mem::align_of::<_mjuiDef>(),
8usize,
concat!("Alignment of ", stringify!(_mjuiDef))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiDef>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_mjuiDef),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiDef>())).name as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_mjuiDef),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiDef>())).state as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_mjuiDef),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiDef>())).pdata as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_mjuiDef),
"::",
stringify!(pdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_mjuiDef>())).other as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_mjuiDef),
"::",
stringify!(other)
)
);
}
impl Default for _mjuiDef {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type mjuiDef = _mjuiDef;
extern "C" {
pub static mut mju_user_error: ::std::option::Option<
unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char),
>;
}
extern "C" {
pub static mut mju_user_warning: ::std::option::Option<
unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char),
>;
}
extern "C" {
pub static mut mju_user_malloc: ::std::option::Option<
unsafe extern "C" fn(arg1: usize) -> *mut ::std::os::raw::c_void,
>;
}
extern "C" {
pub static mut mju_user_free:
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
}
extern "C" {
pub static mut mjcb_passive: mjfGeneric;
}
extern "C" {
pub static mut mjcb_control: mjfGeneric;
}
extern "C" {
pub static mut mjcb_contactfilter: mjfGeneric;
}
extern "C" {
pub static mut mjcb_sensor: mjfSensor;
}
extern "C" {
pub static mut mjcb_time: mjfTime;
}
extern "C" {
pub static mut mjcb_act_dyn: mjfAct;
}
extern "C" {
pub static mut mjcb_act_gain: mjfAct;
}
extern "C" {
pub static mut mjcb_act_bias: mjfAct;
}
extern "C" {
pub static mut mjCOLLISIONFUNC: [[mjfCollision; 8usize]; 8usize];
}
extern "C" {
pub static mut mjDISABLESTRING: [*const ::std::os::raw::c_char; 12usize];
}
extern "C" {
pub static mut mjENABLESTRING: [*const ::std::os::raw::c_char; 4usize];
}
extern "C" {
pub static mut mjTIMERSTRING: [*const ::std::os::raw::c_char; 13usize];
}
extern "C" {
pub static mut mjLABELSTRING: [*const ::std::os::raw::c_char; 14usize];
}
extern "C" {
pub static mut mjFRAMESTRING: [*const ::std::os::raw::c_char; 7usize];
}
extern "C" {
pub static mut mjVISSTRING: [[*const ::std::os::raw::c_char; 3usize]; 22usize];
}
extern "C" {
pub fn mj_activate(
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_deactivate();
}
extern "C" {
pub fn mj_certQuestion(question: *mut mjtNum);
}
extern "C" {
pub fn mj_certAnswer(question: *const mjtNum, answer: *mut mjtNum);
}
extern "C" {
pub fn mj_certCheck(
question: *const mjtNum,
answer: *const mjtNum,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_defaultVFS(vfs: *mut mjVFS);
}
extern "C" {
pub fn mj_addFileVFS(
vfs: *mut mjVFS,
directory: *const ::std::os::raw::c_char,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_makeEmptyFileVFS(
vfs: *mut mjVFS,
filename: *const ::std::os::raw::c_char,
filesize: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_findFileVFS(
vfs: *const mjVFS,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_deleteFileVFS(
vfs: *mut mjVFS,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_deleteVFS(vfs: *mut mjVFS);
}
extern "C" {
pub fn mj_loadXML(
filename: *const ::std::os::raw::c_char,
vfs: *const mjVFS,
error: *mut ::std::os::raw::c_char,
error_sz: ::std::os::raw::c_int,
) -> *mut mjModel;
}
extern "C" {
pub fn mj_saveLastXML(
filename: *const ::std::os::raw::c_char,
m: *const mjModel,
error: *mut ::std::os::raw::c_char,
error_sz: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_freeLastXML();
}
extern "C" {
pub fn mj_printSchema(
filename: *const ::std::os::raw::c_char,
buffer: *mut ::std::os::raw::c_char,
buffer_sz: ::std::os::raw::c_int,
flg_html: ::std::os::raw::c_int,
flg_pad: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_step(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_step1(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_step2(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_forward(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_inverse(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_forwardSkip(
m: *const mjModel,
d: *mut mjData,
skipstage: ::std::os::raw::c_int,
skipsensor: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_inverseSkip(
m: *const mjModel,
d: *mut mjData,
skipstage: ::std::os::raw::c_int,
skipsensor: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_defaultLROpt(opt: *mut mjLROpt);
}
extern "C" {
pub fn mj_defaultSolRefImp(solref: *mut mjtNum, solimp: *mut mjtNum);
}
extern "C" {
pub fn mj_defaultOption(opt: *mut mjOption);
}
extern "C" {
pub fn mj_defaultVisual(vis: *mut mjVisual);
}
extern "C" {
pub fn mj_copyModel(dest: *mut mjModel, src: *const mjModel) -> *mut mjModel;
}
extern "C" {
pub fn mj_saveModel(
m: *const mjModel,
filename: *const ::std::os::raw::c_char,
buffer: *mut ::std::os::raw::c_void,
buffer_sz: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_loadModel(
filename: *const ::std::os::raw::c_char,
vfs: *const mjVFS,
) -> *mut mjModel;
}
extern "C" {
pub fn mj_deleteModel(m: *mut mjModel);
}
extern "C" {
pub fn mj_sizeModel(m: *const mjModel) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_makeData(m: *const mjModel) -> *mut mjData;
}
extern "C" {
pub fn mj_copyData(
dest: *mut mjData,
m: *const mjModel,
src: *const mjData,
) -> *mut mjData;
}
extern "C" {
pub fn mj_resetData(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_resetDataDebug(
m: *const mjModel,
d: *mut mjData,
debug_value: ::std::os::raw::c_uchar,
);
}
extern "C" {
pub fn mj_resetDataKeyframe(
m: *const mjModel,
d: *mut mjData,
key: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_stackAlloc(d: *mut mjData, size: ::std::os::raw::c_int) -> *mut mjtNum;
}
extern "C" {
pub fn mj_deleteData(d: *mut mjData);
}
extern "C" {
pub fn mj_resetCallbacks();
}
extern "C" {
pub fn mj_setConst(m: *mut mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_setLengthRange(
m: *mut mjModel,
d: *mut mjData,
index: ::std::os::raw::c_int,
opt: *const mjLROpt,
error: *mut ::std::os::raw::c_char,
error_sz: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_printModel(m: *const mjModel, filename: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mj_printData(
m: *const mjModel,
d: *mut mjData,
filename: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn mju_printMat(
mat: *const mjtNum,
nr: ::std::os::raw::c_int,
nc: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_printMatSparse(
mat: *const mjtNum,
nr: ::std::os::raw::c_int,
rownnz: *const ::std::os::raw::c_int,
rowadr: *const ::std::os::raw::c_int,
colind: *const ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_fwdPosition(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_fwdVelocity(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_fwdActuation(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_fwdAcceleration(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_fwdConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_Euler(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_RungeKutta(m: *const mjModel, d: *mut mjData, N: ::std::os::raw::c_int);
}
extern "C" {
pub fn mj_invPosition(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_invVelocity(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_invConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_compareFwdInv(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_sensorPos(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_sensorVel(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_sensorAcc(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_energyPos(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_energyVel(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_checkPos(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_checkVel(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_checkAcc(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_kinematics(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_comPos(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_camlight(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_tendon(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_transmission(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_crb(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_factorM(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_solveM(
m: *const mjModel,
d: *mut mjData,
x: *mut mjtNum,
y: *const mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_solveM2(
m: *const mjModel,
d: *mut mjData,
x: *mut mjtNum,
y: *const mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_comVel(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_passive(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_subtreeVel(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_rne(
m: *const mjModel,
d: *mut mjData,
flg_acc: ::std::os::raw::c_int,
result: *mut mjtNum,
);
}
extern "C" {
pub fn mj_rnePostConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_collision(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_makeConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_projectConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_referenceConstraint(m: *const mjModel, d: *mut mjData);
}
extern "C" {
pub fn mj_constraintUpdate(
m: *const mjModel,
d: *mut mjData,
jar: *const mjtNum,
cost: *mut mjtNum,
flg_coneHessian: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_addContact(
m: *const mjModel,
d: *mut mjData,
con: *const mjContact,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_isPyramidal(m: *const mjModel) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_isSparse(m: *const mjModel) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_isDual(m: *const mjModel) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_mulJacVec(
m: *const mjModel,
d: *mut mjData,
res: *mut mjtNum,
vec: *const mjtNum,
);
}
extern "C" {
pub fn mj_mulJacTVec(
m: *const mjModel,
d: *mut mjData,
res: *mut mjtNum,
vec: *const mjtNum,
);
}
extern "C" {
pub fn mj_jac(
m: *const mjModel,
d: *const mjData,
jacp: *mut mjtNum,
jacr: *mut mjtNum,
point: *const mjtNum,
body: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_jacBody(
m: *const mjModel,
d: *const mjData,
jacp: *mut mjtNum,
jacr: *mut mjtNum,
body: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_jacBodyCom(
m: *const mjModel,
d: *const mjData,
jacp: *mut mjtNum,
jacr: *mut mjtNum,
body: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_jacGeom(
m: *const mjModel,
d: *const mjData,
jacp: *mut mjtNum,
jacr: *mut mjtNum,
geom: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_jacSite(
m: *const mjModel,
d: *const mjData,
jacp: *mut mjtNum,
jacr: *mut mjtNum,
site: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_jacPointAxis(
m: *const mjModel,
d: *mut mjData,
jacPoint: *mut mjtNum,
jacAxis: *mut mjtNum,
point: *const mjtNum,
axis: *const mjtNum,
body: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_name2id(
m: *const mjModel,
type_: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_id2name(
m: *const mjModel,
type_: ::std::os::raw::c_int,
id: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mj_fullM(m: *const mjModel, dst: *mut mjtNum, M: *const mjtNum);
}
extern "C" {
pub fn mj_mulM(
m: *const mjModel,
d: *const mjData,
res: *mut mjtNum,
vec: *const mjtNum,
);
}
extern "C" {
pub fn mj_mulM2(
m: *const mjModel,
d: *const mjData,
res: *mut mjtNum,
vec: *const mjtNum,
);
}
extern "C" {
pub fn mj_addM(
m: *const mjModel,
d: *mut mjData,
dst: *mut mjtNum,
rownnz: *mut ::std::os::raw::c_int,
rowadr: *mut ::std::os::raw::c_int,
colind: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_applyFT(
m: *const mjModel,
d: *mut mjData,
force: *const mjtNum,
torque: *const mjtNum,
point: *const mjtNum,
body: ::std::os::raw::c_int,
qfrc_target: *mut mjtNum,
);
}
extern "C" {
pub fn mj_objectVelocity(
m: *const mjModel,
d: *const mjData,
objtype: ::std::os::raw::c_int,
objid: ::std::os::raw::c_int,
res: *mut mjtNum,
flg_local: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_objectAcceleration(
m: *const mjModel,
d: *const mjData,
objtype: ::std::os::raw::c_int,
objid: ::std::os::raw::c_int,
res: *mut mjtNum,
flg_local: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mj_contactForce(
m: *const mjModel,
d: *const mjData,
id: ::std::os::raw::c_int,
result: *mut mjtNum,
);
}
extern "C" {
pub fn mj_differentiatePos(
m: *const mjModel,
qvel: *mut mjtNum,
dt: mjtNum,
qpos1: *const mjtNum,
qpos2: *const mjtNum,
);
}
extern "C" {
pub fn mj_integratePos(
m: *const mjModel,
qpos: *mut mjtNum,
qvel: *const mjtNum,
dt: mjtNum,
);
}
extern "C" {
pub fn mj_normalizeQuat(m: *const mjModel, qpos: *mut mjtNum);
}
extern "C" {
pub fn mj_local2Global(
d: *mut mjData,
xpos: *mut mjtNum,
xmat: *mut mjtNum,
pos: *const mjtNum,
quat: *const mjtNum,
body: ::std::os::raw::c_int,
sameframe: mjtByte,
);
}
extern "C" {
pub fn mj_getTotalmass(m: *const mjModel) -> mjtNum;
}
extern "C" {
pub fn mj_setTotalmass(m: *mut mjModel, newmass: mjtNum);
}
extern "C" {
pub fn mj_version() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mj_ray(
m: *const mjModel,
d: *const mjData,
pnt: *const mjtNum,
vec: *const mjtNum,
geomgroup: *const mjtByte,
flg_static: mjtByte,
bodyexclude: ::std::os::raw::c_int,
geomid: *mut ::std::os::raw::c_int,
) -> mjtNum;
}
extern "C" {
pub fn mj_rayHfield(
m: *const mjModel,
d: *const mjData,
geomid: ::std::os::raw::c_int,
pnt: *const mjtNum,
vec: *const mjtNum,
) -> mjtNum;
}
extern "C" {
pub fn mj_rayMesh(
m: *const mjModel,
d: *const mjData,
geomid: ::std::os::raw::c_int,
pnt: *const mjtNum,
vec: *const mjtNum,
) -> mjtNum;
}
extern "C" {
pub fn mju_rayGeom(
pos: *const mjtNum,
mat: *const mjtNum,
size: *const mjtNum,
pnt: *const mjtNum,
vec: *const mjtNum,
geomtype: ::std::os::raw::c_int,
) -> mjtNum;
}
extern "C" {
pub fn mju_raySkin(
nface: ::std::os::raw::c_int,
nvert: ::std::os::raw::c_int,
face: *const ::std::os::raw::c_int,
vert: *const f32,
pnt: *const mjtNum,
vec: *const mjtNum,
vertid: *mut ::std::os::raw::c_int,
) -> mjtNum;
}
extern "C" {
pub fn mjv_defaultCamera(cam: *mut mjvCamera);
}
extern "C" {
pub fn mjv_defaultPerturb(pert: *mut mjvPerturb);
}
extern "C" {
pub fn mjv_room2model(
modelpos: *mut mjtNum,
modelquat: *mut mjtNum,
roompos: *const mjtNum,
roomquat: *const mjtNum,
scn: *const mjvScene,
);
}
extern "C" {
pub fn mjv_model2room(
roompos: *mut mjtNum,
roomquat: *mut mjtNum,
modelpos: *const mjtNum,
modelquat: *const mjtNum,
scn: *const mjvScene,
);
}
extern "C" {
pub fn mjv_cameraInModel(
headpos: *mut mjtNum,
forward: *mut mjtNum,
up: *mut mjtNum,
scn: *const mjvScene,
);
}
extern "C" {
pub fn mjv_cameraInRoom(
headpos: *mut mjtNum,
forward: *mut mjtNum,
up: *mut mjtNum,
scn: *const mjvScene,
);
}
extern "C" {
pub fn mjv_frustumHeight(scn: *const mjvScene) -> mjtNum;
}
extern "C" {
pub fn mjv_alignToCamera(
res: *mut mjtNum,
vec: *const mjtNum,
forward: *const mjtNum,
);
}
extern "C" {
pub fn mjv_moveCamera(
m: *const mjModel,
action: ::std::os::raw::c_int,
reldx: mjtNum,
reldy: mjtNum,
scn: *const mjvScene,
cam: *mut mjvCamera,
);
}
extern "C" {
pub fn mjv_movePerturb(
m: *const mjModel,
d: *const mjData,
action: ::std::os::raw::c_int,
reldx: mjtNum,
reldy: mjtNum,
scn: *const mjvScene,
pert: *mut mjvPerturb,
);
}
extern "C" {
pub fn mjv_moveModel(
m: *const mjModel,
action: ::std::os::raw::c_int,
reldx: mjtNum,
reldy: mjtNum,
roomup: *const mjtNum,
scn: *mut mjvScene,
);
}
extern "C" {
pub fn mjv_initPerturb(
m: *const mjModel,
d: *const mjData,
scn: *const mjvScene,
pert: *mut mjvPerturb,
);
}
extern "C" {
pub fn mjv_applyPerturbPose(
m: *const mjModel,
d: *mut mjData,
pert: *const mjvPerturb,
flg_paused: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mjv_applyPerturbForce(
m: *const mjModel,
d: *mut mjData,
pert: *const mjvPerturb,
);
}
extern "C" {
pub fn mjv_averageCamera(
cam1: *const mjvGLCamera,
cam2: *const mjvGLCamera,
) -> mjvGLCamera;
}
extern "C" {
pub fn mjv_select(
m: *const mjModel,
d: *const mjData,
vopt: *const mjvOption,
aspectratio: mjtNum,
relx: mjtNum,
rely: mjtNum,
scn: *const mjvScene,
selpnt: *mut mjtNum,
geomid: *mut ::std::os::raw::c_int,
skinid: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mjv_defaultOption(opt: *mut mjvOption);
}
extern "C" {
pub fn mjv_defaultFigure(fig: *mut mjvFigure);
}
extern "C" {
pub fn mjv_initGeom(
geom: *mut mjvGeom,
type_: ::std::os::raw::c_int,
size: *const mjtNum,
pos: *const mjtNum,
mat: *const mjtNum,
rgba: *const f32,
);
}
extern "C" {
pub fn mjv_makeConnector(
geom: *mut mjvGeom,
type_: ::std::os::raw::c_int,
width: mjtNum,
a0: mjtNum,
a1: mjtNum,
a2: mjtNum,
b0: mjtNum,
b1: mjtNum,
b2: mjtNum,
);
}
extern "C" {
pub fn mjv_defaultScene(scn: *mut mjvScene);
}
extern "C" {
pub fn mjv_makeScene(
m: *const mjModel,
scn: *mut mjvScene,
maxgeom: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mjv_freeScene(scn: *mut mjvScene);
}
extern "C" {
pub fn mjv_updateScene(
m: *const mjModel,
d: *mut mjData,
opt: *const mjvOption,
pert: *const mjvPerturb,
cam: *mut mjvCamera,
catmask: ::std::os::raw::c_int,
scn: *mut mjvScene,
);
}
extern "C" {
pub fn mjv_addGeoms(
m: *const mjModel,
d: *mut mjData,
opt: *const mjvOption,
pert: *const mjvPerturb,
catmask: ::std::os::raw::c_int,
scn: *mut mjvScene,
);
}
extern "C" {
pub fn mjv_makeLights(m: *const mjModel, d: *mut mjData, scn: *mut mjvScene);
}
extern "C" {
pub fn mjv_updateCamera(
m: *const mjModel,
d: *mut mjData,
cam: *mut mjvCamera,
scn: *mut mjvScene,
);
}
extern "C" {
pub fn mjv_updateSkin(m: *const mjModel, d: *mut mjData, scn: *mut mjvScene);
}
extern "C" {
pub fn mjui_themeSpacing(ind: ::std::os::raw::c_int) -> mjuiThemeSpacing;
}
extern "C" {
pub fn mjui_themeColor(ind: ::std::os::raw::c_int) -> mjuiThemeColor;
}
extern "C" {
pub fn mjui_add(ui: *mut mjUI, def: *const mjuiDef);
}
extern "C" {
pub fn mjui_resize(ui: *mut mjUI, con: *const mjrContext);
}
extern "C" {
pub fn mjui_update(
section: ::std::os::raw::c_int,
item: ::std::os::raw::c_int,
ui: *const mjUI,
state: *const mjuiState,
con: *const mjrContext,
);
}
extern "C" {
pub fn mjui_event(
ui: *mut mjUI,
state: *mut mjuiState,
con: *const mjrContext,
) -> *mut mjuiItem;
}
extern "C" {
pub fn mjui_render(ui: *mut mjUI, state: *const mjuiState, con: *const mjrContext);
}
extern "C" {
pub fn mju_error(msg: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mju_error_i(msg: *const ::std::os::raw::c_char, i: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_error_s(
msg: *const ::std::os::raw::c_char,
text: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn mju_warning(msg: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn mju_warning_i(msg: *const ::std::os::raw::c_char, i: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_warning_s(
msg: *const ::std::os::raw::c_char,
text: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn mju_clearHandlers();
}
extern "C" {
pub fn mju_malloc(size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn mju_free(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn mj_warning(
d: *mut mjData,
warning: ::std::os::raw::c_int,
info: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_writeLog(
type_: *const ::std::os::raw::c_char,
msg: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn mju_zero3(res: *mut mjtNum);
}
extern "C" {
pub fn mju_copy3(res: *mut mjtNum, data: *const mjtNum);
}
extern "C" {
pub fn mju_scl3(res: *mut mjtNum, vec: *const mjtNum, scl: mjtNum);
}
extern "C" {
pub fn mju_add3(res: *mut mjtNum, vec1: *const mjtNum, vec2: *const mjtNum);
}
extern "C" {
pub fn mju_sub3(res: *mut mjtNum, vec1: *const mjtNum, vec2: *const mjtNum);
}
extern "C" {
pub fn mju_addTo3(res: *mut mjtNum, vec: *const mjtNum);
}
extern "C" {
pub fn mju_subFrom3(res: *mut mjtNum, vec: *const mjtNum);
}
extern "C" {
pub fn mju_addToScl3(res: *mut mjtNum, vec: *const mjtNum, scl: mjtNum);
}
extern "C" {
pub fn mju_addScl3(
res: *mut mjtNum,
vec1: *const mjtNum,
vec2: *const mjtNum,
scl: mjtNum,
);
}
extern "C" {
pub fn mju_normalize3(res: *mut mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_norm3(vec: *const mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_dot3(vec1: *const mjtNum, vec2: *const mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_dist3(pos1: *const mjtNum, pos2: *const mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_rotVecMat(res: *mut mjtNum, vec: *const mjtNum, mat: *const mjtNum);
}
extern "C" {
pub fn mju_rotVecMatT(res: *mut mjtNum, vec: *const mjtNum, mat: *const mjtNum);
}
extern "C" {
pub fn mju_cross(res: *mut mjtNum, a: *const mjtNum, b: *const mjtNum);
}
extern "C" {
pub fn mju_zero4(res: *mut mjtNum);
}
extern "C" {
pub fn mju_unit4(res: *mut mjtNum);
}
extern "C" {
pub fn mju_copy4(res: *mut mjtNum, data: *const mjtNum);
}
extern "C" {
pub fn mju_normalize4(res: *mut mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_zero(res: *mut mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_copy(res: *mut mjtNum, data: *const mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_sum(vec: *const mjtNum, n: ::std::os::raw::c_int) -> mjtNum;
}
extern "C" {
pub fn mju_L1(vec: *const mjtNum, n: ::std::os::raw::c_int) -> mjtNum;
}
extern "C" {
pub fn mju_scl(
res: *mut mjtNum,
vec: *const mjtNum,
scl: mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_add(
res: *mut mjtNum,
vec1: *const mjtNum,
vec2: *const mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_sub(
res: *mut mjtNum,
vec1: *const mjtNum,
vec2: *const mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_addTo(res: *mut mjtNum, vec: *const mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_subFrom(res: *mut mjtNum, vec: *const mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_addToScl(
res: *mut mjtNum,
vec: *const mjtNum,
scl: mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_addScl(
res: *mut mjtNum,
vec1: *const mjtNum,
vec2: *const mjtNum,
scl: mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_normalize(res: *mut mjtNum, n: ::std::os::raw::c_int) -> mjtNum;
}
extern "C" {
pub fn mju_norm(res: *const mjtNum, n: ::std::os::raw::c_int) -> mjtNum;
}
extern "C" {
pub fn mju_dot(
vec1: *const mjtNum,
vec2: *const mjtNum,
n: ::std::os::raw::c_int,
) -> mjtNum;
}
extern "C" {
pub fn mju_mulMatVec(
res: *mut mjtNum,
mat: *const mjtNum,
vec: *const mjtNum,
nr: ::std::os::raw::c_int,
nc: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_mulMatTVec(
res: *mut mjtNum,
mat: *const mjtNum,
vec: *const mjtNum,
nr: ::std::os::raw::c_int,
nc: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_transpose(
res: *mut mjtNum,
mat: *const mjtNum,
nr: ::std::os::raw::c_int,
nc: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_mulMatMat(
res: *mut mjtNum,
mat1: *const mjtNum,
mat2: *const mjtNum,
r1: ::std::os::raw::c_int,
c1: ::std::os::raw::c_int,
c2: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_mulMatMatT(
res: *mut mjtNum,
mat1: *const mjtNum,
mat2: *const mjtNum,
r1: ::std::os::raw::c_int,
c1: ::std::os::raw::c_int,
r2: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_mulMatTMat(
res: *mut mjtNum,
mat1: *const mjtNum,
mat2: *const mjtNum,
r1: ::std::os::raw::c_int,
c1: ::std::os::raw::c_int,
c2: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_sqrMatTD(
res: *mut mjtNum,
mat: *const mjtNum,
diag: *const mjtNum,
nr: ::std::os::raw::c_int,
nc: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_transformSpatial(
res: *mut mjtNum,
vec: *const mjtNum,
flg_force: ::std::os::raw::c_int,
newpos: *const mjtNum,
oldpos: *const mjtNum,
rotnew2old: *const mjtNum,
);
}
extern "C" {
pub fn mju_rotVecQuat(res: *mut mjtNum, vec: *const mjtNum, quat: *const mjtNum);
}
extern "C" {
pub fn mju_negQuat(res: *mut mjtNum, quat: *const mjtNum);
}
extern "C" {
pub fn mju_mulQuat(res: *mut mjtNum, quat1: *const mjtNum, quat2: *const mjtNum);
}
extern "C" {
pub fn mju_mulQuatAxis(res: *mut mjtNum, quat: *const mjtNum, axis: *const mjtNum);
}
extern "C" {
pub fn mju_axisAngle2Quat(res: *mut mjtNum, axis: *const mjtNum, angle: mjtNum);
}
extern "C" {
pub fn mju_quat2Vel(res: *mut mjtNum, quat: *const mjtNum, dt: mjtNum);
}
extern "C" {
pub fn mju_subQuat(res: *mut mjtNum, qa: *const mjtNum, qb: *const mjtNum);
}
extern "C" {
pub fn mju_quat2Mat(res: *mut mjtNum, quat: *const mjtNum);
}
extern "C" {
pub fn mju_mat2Quat(quat: *mut mjtNum, mat: *const mjtNum);
}
extern "C" {
pub fn mju_derivQuat(res: *mut mjtNum, quat: *const mjtNum, vel: *const mjtNum);
}
extern "C" {
pub fn mju_quatIntegrate(quat: *mut mjtNum, vel: *const mjtNum, scale: mjtNum);
}
extern "C" {
pub fn mju_quatZ2Vec(quat: *mut mjtNum, vec: *const mjtNum);
}
extern "C" {
pub fn mju_mulPose(
posres: *mut mjtNum,
quatres: *mut mjtNum,
pos1: *const mjtNum,
quat1: *const mjtNum,
pos2: *const mjtNum,
quat2: *const mjtNum,
);
}
extern "C" {
pub fn mju_negPose(
posres: *mut mjtNum,
quatres: *mut mjtNum,
pos: *const mjtNum,
quat: *const mjtNum,
);
}
extern "C" {
pub fn mju_trnVecPose(
res: *mut mjtNum,
pos: *const mjtNum,
quat: *const mjtNum,
vec: *const mjtNum,
);
}
extern "C" {
pub fn mju_cholFactor(
mat: *mut mjtNum,
n: ::std::os::raw::c_int,
mindiag: mjtNum,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_cholSolve(
res: *mut mjtNum,
mat: *const mjtNum,
vec: *const mjtNum,
n: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_cholUpdate(
mat: *mut mjtNum,
x: *mut mjtNum,
n: ::std::os::raw::c_int,
flg_plus: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_eig3(
eigval: *mut mjtNum,
eigvec: *mut mjtNum,
quat: *mut mjtNum,
mat: *const mjtNum,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_muscleGain(
len: mjtNum,
vel: mjtNum,
lengthrange: *const mjtNum,
acc0: mjtNum,
prm: *const mjtNum,
) -> mjtNum;
}
extern "C" {
pub fn mju_muscleBias(
len: mjtNum,
lengthrange: *const mjtNum,
acc0: mjtNum,
prm: *const mjtNum,
) -> mjtNum;
}
extern "C" {
pub fn mju_muscleDynamics(ctrl: mjtNum, act: mjtNum, prm: *const mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_encodePyramid(
pyramid: *mut mjtNum,
force: *const mjtNum,
mu: *const mjtNum,
dim: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_decodePyramid(
force: *mut mjtNum,
pyramid: *const mjtNum,
mu: *const mjtNum,
dim: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn mju_springDamper(
pos0: mjtNum,
vel0: mjtNum,
Kp: mjtNum,
Kv: mjtNum,
dt: mjtNum,
) -> mjtNum;
}
extern "C" {
pub fn mju_min(a: mjtNum, b: mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_max(a: mjtNum, b: mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_sign(x: mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_round(x: mjtNum) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_type2Str(type_: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mju_str2Type(str_: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_warningText(
warning: ::std::os::raw::c_int,
info: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn mju_isBad(x: mjtNum) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_isZero(
vec: *mut mjtNum,
n: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn mju_standardNormal(num2: *mut mjtNum) -> mjtNum;
}
extern "C" {
pub fn mju_f2n(res: *mut mjtNum, vec: *const f32, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_n2f(res: *mut f32, vec: *const mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_d2n(res: *mut mjtNum, vec: *const f64, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_n2d(res: *mut f64, vec: *const mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_insertionSort(list: *mut mjtNum, n: ::std::os::raw::c_int);
}
extern "C" {
pub fn mju_Halton(
index: ::std::os::raw::c_int,
base: ::std::os::raw::c_int,
) -> mjtNum;
}
extern "C" {
pub fn mju_strncpy(
dst: *mut ::std::os::raw::c_char,
src: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}